[clinton/bobotpp.git] / source / ScriptCommands.C

// ScriptCommands.C  -*- C++ -*-
// Copyright (c) 1998 Etienne BERNARD
// Copyright (C) 2002 Clinton Ebadi

// 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
// 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef USESCRIPTS

#include "Utils.H"
#include "Server.H"
#include "ServerList.H"
#include "ScriptCommands.H"
#include "Interp.H"
#include <libguile.h>

#define VERIFY_STRING(par) if (!SCM_STRINGP((par))) \
                             return scm_long2num(-17)

#define VERIFY_NUMBER(par) if (!SCM_NUMBERP((par))) \
                             return scm_long2num(-17)

SCM
ScriptCommands::Action(SCM channel, SCM message)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(message);
  Message m = Commands::Action(Interp::bot, Utils::scm2String(channel),
                               Utils::scm2String(message));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::AddUser(SCM who, SCM maskChannel, SCM level, 
			SCM prot, SCM aop, SCM expire, SCM password)
{
  // It segfaults when not online, but otherwise appears to work
  VERIFY_STRING (who);
  VERIFY_STRING (maskChannel);
  VERIFY_NUMBER (level);

  String wwho = Utils::scm2String (who);
  String mask = Utils::scm2String (maskChannel);
  String passwd; 
  std::time_t eexpire;

  if (SCM_UNBNDP (password))
    passwd = "";
  else
    {
      VERIFY_STRING (password);
      passwd = Utils::scm2String (password);
    }
  if (SCM_UNBNDP (expire))
    eexpire = -1;
  else
    {
      VERIFY_STRING (expire);
      eexpire = Utils::strToTime (Utils::scm2String (expire));
      if (!eexpire) eexpire = -1;
    }

  int protect = scm_num2int (prot, SCM_ARG1, "ScriptCommands::AddUser");
  bool aaop = SCM_NFALSEP (aop);
  int llevel = scm_num2int (level, SCM_ARG1, 
				  "ScriptCommands::AddUser");

  Message m = Commands::AddUser (Interp::bot, wwho, mask, llevel, 
				 protect, aaop, eexpire, passwd);

  return scm_long2num(m.getCode ());
}

SCM
ScriptCommands::AddServer(SCM servername, SCM port)
{
  int p = 6667;
  if (SCM_NUMBERP(port))
    p = scm_num2long(port, SCM_ARG1, "ScriptCommands::AddServer");
  Message m = Commands::AddServer(Interp::bot,
                                  Utils::scm2String(servername),
                                  p);
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::AddShit(SCM mask, SCM maskChannel, SCM level, 
			SCM expiration, SCM reason)
{
  // This appears to work...not much testing though
  VERIFY_STRING (mask);
  VERIFY_STRING (maskChannel);
  VERIFY_NUMBER (level);
  String mmask = Utils::scm2String (mask);
  String mmaskChannel = Utils::scm2String (maskChannel);
  int llevel = scm_num2int (level, SCM_ARG1, "ScriptCommands::AddShit");
  std::time_t expire;
  String rreason;

  if (SCM_UNBNDP (expiration))
    expire = -1;
  else
    {
      VERIFY_STRING (expiration);
      expire = Utils::strToTime (Utils::scm2String (expiration));
      if (!expire) expire = -1;
    }
  if (SCM_UNBNDP (reason))
    rreason = "You're on my shitlist, lamer";
  else
    {
      VERIFY_STRING (reason);
      rreason = Utils::scm2String (reason);
    }
  Message m = Commands::AddShit (Interp::bot, mmask, mmaskChannel,
				 llevel, expire, rreason);

  return scm_long2num(m.getCode ());
}

SCM
ScriptCommands::Ban(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Ban(Interp::bot, Utils::scm2String(channel),
                            Utils::scm2String(who));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Cycle(SCM channel)
{
  VERIFY_STRING(channel);
  Message m = Commands::Cycle(Interp::bot, Utils::scm2String(channel));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Deban(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Deban(Interp::bot, Utils::scm2String(channel),
                              Utils::scm2String(who));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::DelServer(SCM number)
{
  VERIFY_NUMBER(number);
  Message m = Commands::DelServer(Interp::bot, 
				  scm_num2long(number, SCM_ARG1, 
					       "ScriptCommands::DelServer"));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::DelUser(SCM who, SCM maskChannel)
{
  VERIFY_STRING(who);
  VERIFY_STRING(maskChannel);
  Message m = Commands::DelUser(Interp::bot, Utils::scm2String(who),
                                Utils::scm2String(maskChannel));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::DelShit(SCM who, SCM maskChannel)
{
  VERIFY_STRING(who);
  VERIFY_STRING(maskChannel);
  Message m = Commands::DelShit(Interp::bot, Utils::scm2String(who),
                                Utils::scm2String(maskChannel));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Deop(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Deop(Interp::bot, Utils::scm2String(channel),
                             Utils::scm2String(who));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Die(SCM reason)
{
  String r = "Leaving";
  if (SCM_STRINGP(reason))
    r = Utils::scm2String(reason);
  Message m = Commands::Die(Interp::bot, r);
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Do(SCM command)
{
  VERIFY_STRING(command);
  Message m = Commands::Do(Interp::bot, Utils::scm2String(command));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Invite(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Invite(Interp::bot, Utils::scm2String(channel),
                               Utils::scm2String(who));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Join(SCM channel, SCM key)
{
  VERIFY_STRING(channel);
  String k = "";
  if (SCM_STRINGP(key))
    k = Utils::scm2String(key);
  Message m = Commands::Join(Interp::bot, Utils::scm2String(channel),
                             k);
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Keep(SCM channel, SCM modes)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(modes);
  Message m = Commands::Keep(Interp::bot, Utils::scm2String(channel),
                             Utils::scm2String(modes));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Kick(SCM channel, SCM who, SCM reason)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);

  String r = "";
  if (SCM_STRINGP(reason))
    r = Utils::scm2String(reason);

  Message m = Commands::Kick(Interp::bot, Utils::scm2String(channel),
                             Utils::scm2String(who), r);
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::KickBan(SCM channel, SCM who, SCM reason)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  String r = "";
  if (SCM_STRINGP(reason))
    r = Utils::scm2String(reason);
  Message m = Commands::KickBan(Interp::bot, Utils::scm2String(channel),
                                Utils::scm2String(who), r);
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Lock(SCM channel)
{
  VERIFY_STRING(channel);
  Message m = Commands::Lock(Interp::bot, Utils::scm2String(channel));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::LogPort(void)
{
  return Interp::bot->botInterp->logPort;
}

SCM
ScriptCommands::Mode(SCM channel, SCM mode)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(mode);
  Message m = Commands::Mode(Interp::bot, Utils::scm2String(channel),
                             Utils::scm2String(mode));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Msg(SCM nick, SCM message)
{
  VERIFY_STRING(nick);
  VERIFY_STRING(message);
  Message m = Commands::Msg(Interp::bot, Utils::scm2String(nick),
                            Utils::scm2String(message));
  return scm_long2num(m.getCode());

}

SCM
ScriptCommands::NextServer(void)
{
  Message m = Commands::NextServer(Interp::bot);
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Nick(SCM nick)
{
  VERIFY_STRING(nick);
  Message m = Commands::Nick(Interp::bot, Utils::scm2String(nick));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Op(SCM channel, SCM who)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  Message m = Commands::Op(Interp::bot, Utils::scm2String(channel),
                           Utils::scm2String(who));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Part(SCM channel)
{
  VERIFY_STRING(channel);
  Message m = Commands::Part(Interp::bot, Utils::scm2String(channel));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Reconnect(void)
{
  Message m = Commands::Reconnect(Interp::bot);
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Say(SCM channel, SCM message)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(message);
  Message m = Commands::Say(Interp::bot, Utils::scm2String(channel),
                            Utils::scm2String(message));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Server(SCM number)
{
  VERIFY_NUMBER(number);
  Message m = Commands::Server(Interp::bot, gh_scm2long(number));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::SetVersion(SCM version)
{
  Message m = Commands::SetVersion(Interp::bot, Utils::scm2String(version));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::TBan(SCM channel, SCM who, SCM seconds)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  VERIFY_NUMBER(seconds);
  Message m = Commands::TBan(Interp::bot, Utils::scm2String(channel),
                             Utils::scm2String(who), gh_scm2long(seconds));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::TKBan(SCM channel, SCM who, SCM seconds, SCM reason)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(who);
  VERIFY_NUMBER(seconds);
  String r = "";
  if (SCM_STRINGP(reason))
    r = Utils::scm2String(reason);
  Message m = Commands::TKBan(Interp::bot, Utils::scm2String(channel),
                              Utils::scm2String(who),
                              gh_scm2long(seconds), r);
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Topic(SCM channel, SCM topic)
{
  VERIFY_STRING(channel);
  VERIFY_STRING(topic);
  Message m = Commands::Topic(Interp::bot, Utils::scm2String(channel),
                              Utils::scm2String(topic));
  return scm_long2num(m.getCode());
}

SCM
ScriptCommands::Unlock(SCM channel)
{
  VERIFY_STRING(channel);
  Message m = Commands::Unlock(Interp::bot, Utils::scm2String(channel));
  return scm_long2num(m.getCode());
}


SCM
ScriptCommands::getNickname(void)
{
  return Utils::string2SCM(Interp::bot->nickName);
}

SCM
ScriptCommands::getServer(void)
{
  ::Server *serv = Interp::bot->serverList->currentServer();
  int serverNumber = Interp::bot->serverList->currentNumber;

  return gh_list(scm_long2num(serverNumber),
                 Utils::string2SCM(serv->getHostName()),
                 scm_long2num(serv->getPort()),
                 Utils::string2SCM(serv->getPassword()),
                 SCM_UNDEFINED);
}

SCM
ScriptCommands::getServerList(void)
{
  SCM res = gh_list(SCM_UNDEFINED);
  ::Server *s;
  int i = 0;
  std::vector<class Server *>::iterator it = Interp::bot->serverList->begin();

  for ( ; it != Interp::bot->serverList->end(); ++it) {
    s = (*it);
    res = gh_append2(res,
                     gh_list(gh_list(scm_long2num(i++),
                                     Utils::string2SCM(s->getHostName()),
                                     scm_long2num(s->getPort()),
                                     Utils::string2SCM(s->getPassword()),
                                     SCM_UNDEFINED), SCM_UNDEFINED));
  }
  return res;
}

SCM
ScriptCommands::flushQueue(void)
{
  if (!Interp::bot->serverConnection)
    return SCM_BOOL_F;
  Interp::bot->serverConnection->queue->flush();
  return SCM_BOOL_T;
}

SCM
ScriptCommands::flushPort(void)
{
  scm_flush(Interp::bot->botInterp->logPort);
  return SCM_BOOL_T;
}

SCM
ScriptCommands::random(SCM scm_max)
{
  int max = 0;
  //srand(time(NULL));
  if (SCM_NUMBERP(scm_max))
    max = gh_scm2int(scm_max);
  return scm_long2num(max ? rand() % max : 0);
}

SCM
ScriptCommands::addCommand(SCM scm_commandName, SCM scm_function,
                           SCM scm_needsChannel, SCM scm_args,
                           SCM scm_minLevel)
{
  // We check that commandName is a string
  if (!SCM_STRINGP(scm_commandName))
    return SCM_BOOL_F;

  // We check that the command does not exist
  String commandName = Utils::scm2String(scm_commandName).toUpper();
  std::list<class userFunction *>::iterator it =
    Interp::bot->userFunctions.begin();
  for ( ; it != Interp::bot->userFunctions.end(); ++it) {
    if ((*it)->name == commandName)
      return SCM_BOOL_F;
  }

  // Next we check that needsChannel is a boolean
  if (!gh_boolean_p(scm_needsChannel))
    return SCM_BOOL_F;
  bool needsChannel = (bool)gh_scm2bool(scm_needsChannel);

  // We check that minLevel is an integer and that it's
  // a valid level
  if (!SCM_NUMBERP(scm_minLevel))
    return SCM_BOOL_F;

  int minLevel = gh_scm2long(scm_minLevel);
  if (minLevel < User::NONE || minLevel > User::MASTER)
    return SCM_BOOL_F;

  // We check that "scm_function" is a Scheme procedure
  if (!gh_procedure_p(scm_function))
    return SCM_BOOL_F;

  // We check that args is an integer and is between 0 and 20 (arbitrary limit)
  if (!SCM_NUMBERP(scm_args))
    return SCM_BOOL_F;

  int args = gh_scm2long(scm_args);
  if (args < 0 || args > 20)
    return SCM_BOOL_F;

  // We add the command in the commands list
  Interp::bot->userFunctions.push_back(new userFunction(commandName, 
(void (*)(ServerConnection *, Person *, String, String))0, minLevel, needsChannel, args, scm_function));

  return SCM_BOOL_T;
}

SCM
ScriptCommands::delCommand(SCM scm_commandName)
{
  // We check that commandName is a string
  if (!SCM_STRINGP(scm_commandName))
    return SCM_BOOL_F;

  // We check that the command does exist
  String commandName = Utils::scm2String(scm_commandName).toUpper();
  std::list<class userFunction *>::iterator it =
    Interp::bot->userFunctions.begin();
  for ( ; it != Interp::bot->userFunctions.end(); ++it) {
    if ((*it)->name == commandName)
      break;
  }

  if (it == Interp::bot->userFunctions.end())
    return SCM_BOOL_F;

  // We delete the command
  Interp::bot->userFunctions.erase(it);
  delete (*it);

  return SCM_BOOL_T;
}

SCM
ScriptCommands::AddHook(SCM type, SCM regex, SCM function, SCM pri, SCM fall)
{
  int priority = 0;
  bool fallt = true; // does this hook fall through?

  if (!SCM_UNBNDP (pri))
    priority = scm_num2int (pri, SCM_ARG1, "ScriptCommands::AddHook");
  if (!SCM_UNBNDP (fall))
    fallt = SCM_NFALSEP (fall);
  return SCM_BOOL (Interp::bot->botInterp->AddHook(gh_scm2long(type),
						   regex, function,
						   priority, fallt));
}

SCM
ScriptCommands::AddTimer(SCM when, SCM function)
{
  return Interp::bot->botInterp->AddTimer(gh_scm2long(when), function);
}

SCM
ScriptCommands::DelTimer(SCM timer)
{
  return gh_bool2scm(Interp::bot->botInterp->DelTimer(timer));
}

#endif
Commit	Line	Data
cb21075d	1	// ScriptCommands.C -- C++ --
	2	// Copyright (c) 1998 Etienne BERNARD
	3	// Copyright (C) 2002 Clinton Ebadi
	4
	5	// This program is free software; you can redistribute it and/or modify
	6	// it under the terms of the GNU General Public License as published by
	7	// the Free Software Foundation; either version 2 of the License, or
	8	// any later version.
	9
	10	// This program is distributed in the hope that it will be useful,
	11	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	// GNU General Public License for more details.
	14
	15	// You should have received a copy of the GNU General Public License
	16	// along with this program; if not, write to the Free Software
	17	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
	18
	19	#ifdef HAVE_CONFIG_H
	20	#include "config.h"
	21	#endif
	22
	23	#ifdef USESCRIPTS
	24
	25	#include "Utils.H"
	26	#include "Server.H"
	27	#include "ServerList.H"
	28	#include "ScriptCommands.H"
	29	#include "Interp.H"
	30	#include <libguile.h>
	31
	32	#define VERIFY_STRING(par) if (!SCM_STRINGP((par))) \
	33	return scm_long2num(-17)
	34
	35	#define VERIFY_NUMBER(par) if (!SCM_NUMBERP((par))) \
	36	return scm_long2num(-17)
	37
	38	SCM
	39	ScriptCommands::Action(SCM channel, SCM message)
	40	{
	41	VERIFY_STRING(channel);
	42	VERIFY_STRING(message);
	43	Message m = Commands::Action(Interp::bot, Utils::scm2String(channel),
	44	Utils::scm2String(message));
	45	return scm_long2num(m.getCode());
	46	}
	47
	48	SCM
	49	ScriptCommands::AddUser(SCM who, SCM maskChannel, SCM level,
	50	SCM prot, SCM aop, SCM expire, SCM password)
	51	{
	52	// It segfaults when not online, but otherwise appears to work
	53	VERIFY_STRING (who);
	54	VERIFY_STRING (maskChannel);
	55	VERIFY_NUMBER (level);
	56
	57	String wwho = Utils::scm2String (who);
	58	String mask = Utils::scm2String (maskChannel);
	59	String passwd;
	60	std::time_t eexpire;
	61
	62	if (SCM_UNBNDP (password))
	63	passwd = "";
	64	else
65	{
66	VERIFY_STRING (password);
67	passwd = Utils::scm2String (password);
68	}
69	if (SCM_UNBNDP (expire))
70	eexpire = -1;
71	else
72	{
73	VERIFY_STRING (expire);
74	eexpire = Utils::strToTime (Utils::scm2String (expire));
75	if (!eexpire) eexpire = -1;
76	}
77
78	int protect = scm_num2int (prot, SCM_ARG1, "ScriptCommands::AddUser");
79	bool aaop = SCM_NFALSEP (aop);
80	int llevel = scm_num2int (level, SCM_ARG1,
81	"ScriptCommands::AddUser");
82
83	Message m = Commands::AddUser (Interp::bot, wwho, mask, llevel,
84	protect, aaop, eexpire, passwd);
85
86	return scm_long2num(m.getCode ());
87	}
88
89	SCM
90	ScriptCommands::AddServer(SCM servername, SCM port)
91	{
92	int p = 6667;
93	if (SCM_NUMBERP(port))
94	p = scm_num2long(port, SCM_ARG1, "ScriptCommands::AddServer");
95	Message m = Commands::AddServer(Interp::bot,
96	Utils::scm2String(servername),
97	p);
98	return scm_long2num(m.getCode());
99	}
100
101	SCM
102	ScriptCommands::AddShit(SCM mask, SCM maskChannel, SCM level,
103	SCM expiration, SCM reason)
104	{
105	// This appears to work...not much testing though
106	VERIFY_STRING (mask);
107	VERIFY_STRING (maskChannel);
108	VERIFY_NUMBER (level);
109	String mmask = Utils::scm2String (mask);
110	String mmaskChannel = Utils::scm2String (maskChannel);
111	int llevel = scm_num2int (level, SCM_ARG1, "ScriptCommands::AddShit");
112	std::time_t expire;
113	String rreason;
114
115	if (SCM_UNBNDP (expiration))
116	expire = -1;
117	else
118	{
119	VERIFY_STRING (expiration);
120	expire = Utils::strToTime (Utils::scm2String (expiration));
121	if (!expire) expire = -1;
122	}
123	if (SCM_UNBNDP (reason))
124	rreason = "You're on my shitlist, lamer";
125	else
126	{
127	VERIFY_STRING (reason);
128	rreason = Utils::scm2String (reason);
129	}
130	Message m = Commands::AddShit (Interp::bot, mmask, mmaskChannel,
131	llevel, expire, rreason);
132
133	return scm_long2num(m.getCode ());
134	}
135
136	SCM
137	ScriptCommands::Ban(SCM channel, SCM who)
138	{
139	VERIFY_STRING(channel);
140	VERIFY_STRING(who);
141	Message m = Commands::Ban(Interp::bot, Utils::scm2String(channel),
142	Utils::scm2String(who));
143	return scm_long2num(m.getCode());
144	}
145
146	SCM
147	ScriptCommands::Cycle(SCM channel)
148	{
149	VERIFY_STRING(channel);
150	Message m = Commands::Cycle(Interp::bot, Utils::scm2String(channel));
151	return scm_long2num(m.getCode());
152	}
153
154	SCM
155	ScriptCommands::Deban(SCM channel, SCM who)
156	{
157	VERIFY_STRING(channel);
158	VERIFY_STRING(who);
159	Message m = Commands::Deban(Interp::bot, Utils::scm2String(channel),
160	Utils::scm2String(who));
161	return scm_long2num(m.getCode());
162	}
163
164	SCM
165	ScriptCommands::DelServer(SCM number)
166	{
167	VERIFY_NUMBER(number);
168	Message m = Commands::DelServer(Interp::bot,
169	scm_num2long(number, SCM_ARG1,
170	"ScriptCommands::DelServer"));
171	return scm_long2num(m.getCode());
172	}
173
174	SCM
175	ScriptCommands::DelUser(SCM who, SCM maskChannel)
176	{
177	VERIFY_STRING(who);
178	VERIFY_STRING(maskChannel);
179	Message m = Commands::DelUser(Interp::bot, Utils::scm2String(who),
180	Utils::scm2String(maskChannel));
181	return scm_long2num(m.getCode());
182	}
183
184	SCM
185	ScriptCommands::DelShit(SCM who, SCM maskChannel)
186	{
187	VERIFY_STRING(who);
188	VERIFY_STRING(maskChannel);
189	Message m = Commands::DelShit(Interp::bot, Utils::scm2String(who),
190	Utils::scm2String(maskChannel));
191	return scm_long2num(m.getCode());
192	}
193
194	SCM
195	ScriptCommands::Deop(SCM channel, SCM who)
196	{
197	VERIFY_STRING(channel);
198	VERIFY_STRING(who);
199	Message m = Commands::Deop(Interp::bot, Utils::scm2String(channel),
200	Utils::scm2String(who));
201	return scm_long2num(m.getCode());
202	}
203
204	SCM
205	ScriptCommands::Die(SCM reason)
206	{
207	String r = "Leaving";
208	if (SCM_STRINGP(reason))
209	r = Utils::scm2String(reason);
210	Message m = Commands::Die(Interp::bot, r);
211	return scm_long2num(m.getCode());
212	}
213
214	SCM
215	ScriptCommands::Do(SCM command)
216	{
217	VERIFY_STRING(command);
218	Message m = Commands::Do(Interp::bot, Utils::scm2String(command));
219	return scm_long2num(m.getCode());
220	}
221
222	SCM
223	ScriptCommands::Invite(SCM channel, SCM who)
224	{
225	VERIFY_STRING(channel);
226	VERIFY_STRING(who);
227	Message m = Commands::Invite(Interp::bot, Utils::scm2String(channel),
228	Utils::scm2String(who));
229	return scm_long2num(m.getCode());
230	}
231
232	SCM
233	ScriptCommands::Join(SCM channel, SCM key)
234	{
235	VERIFY_STRING(channel);
236	String k = "";
237	if (SCM_STRINGP(key))
238	k = Utils::scm2String(key);
239	Message m = Commands::Join(Interp::bot, Utils::scm2String(channel),
240	k);
241	return scm_long2num(m.getCode());
242	}
243
244	SCM
245	ScriptCommands::Keep(SCM channel, SCM modes)
246	{
247	VERIFY_STRING(channel);
248	VERIFY_STRING(modes);
249	Message m = Commands::Keep(Interp::bot, Utils::scm2String(channel),
250	Utils::scm2String(modes));
251	return scm_long2num(m.getCode());
252	}
253
254	SCM
255	ScriptCommands::Kick(SCM channel, SCM who, SCM reason)
256	{
257	VERIFY_STRING(channel);
258	VERIFY_STRING(who);
259
260	String r = "";
261	if (SCM_STRINGP(reason))
262	r = Utils::scm2String(reason);
263
264	Message m = Commands::Kick(Interp::bot, Utils::scm2String(channel),
265	Utils::scm2String(who), r);
266	return scm_long2num(m.getCode());
267	}
268
269	SCM
270	ScriptCommands::KickBan(SCM channel, SCM who, SCM reason)
271	{
272	VERIFY_STRING(channel);
273	VERIFY_STRING(who);
274	String r = "";
275	if (SCM_STRINGP(reason))
276	r = Utils::scm2String(reason);
277	Message m = Commands::KickBan(Interp::bot, Utils::scm2String(channel),
278	Utils::scm2String(who), r);
279	return scm_long2num(m.getCode());
280	}
281
282	SCM
283	ScriptCommands::Lock(SCM channel)
284	{
285	VERIFY_STRING(channel);
286	Message m = Commands::Lock(Interp::bot, Utils::scm2String(channel));
287	return scm_long2num(m.getCode());
288	}
289
290	SCM
291	ScriptCommands::LogPort(void)
292	{
293	return Interp::bot->botInterp->logPort;
294	}
295
296	SCM
297	ScriptCommands::Mode(SCM channel, SCM mode)
298	{
299	VERIFY_STRING(channel);
300	VERIFY_STRING(mode);
301	Message m = Commands::Mode(Interp::bot, Utils::scm2String(channel),
302	Utils::scm2String(mode));
303	return scm_long2num(m.getCode());
304	}
305
306	SCM
307	ScriptCommands::Msg(SCM nick, SCM message)
308	{
309	VERIFY_STRING(nick);
310	VERIFY_STRING(message);
311	Message m = Commands::Msg(Interp::bot, Utils::scm2String(nick),
312	Utils::scm2String(message));
313	return scm_long2num(m.getCode());
314
315	}
316
317	SCM
318	ScriptCommands::NextServer(void)
319	{
320	Message m = Commands::NextServer(Interp::bot);
321	return scm_long2num(m.getCode());
322	}
323
324	SCM
325	ScriptCommands::Nick(SCM nick)
326	{
327	VERIFY_STRING(nick);
328	Message m = Commands::Nick(Interp::bot, Utils::scm2String(nick));
329	return scm_long2num(m.getCode());
330	}
331
332	SCM
333	ScriptCommands::Op(SCM channel, SCM who)
334	{
335	VERIFY_STRING(channel);
336	VERIFY_STRING(who);
337	Message m = Commands::Op(Interp::bot, Utils::scm2String(channel),
338	Utils::scm2String(who));
339	return scm_long2num(m.getCode());
340	}
341
342	SCM
343	ScriptCommands::Part(SCM channel)
344	{
345	VERIFY_STRING(channel);
346	Message m = Commands::Part(Interp::bot, Utils::scm2String(channel));
347	return scm_long2num(m.getCode());
348	}
349
350	SCM
351	ScriptCommands::Reconnect(void)
352	{
353	Message m = Commands::Reconnect(Interp::bot);
354	return scm_long2num(m.getCode());
355	}
356
357	SCM
358	ScriptCommands::Say(SCM channel, SCM message)
359	{
360	VERIFY_STRING(channel);
361	VERIFY_STRING(message);
362	Message m = Commands::Say(Interp::bot, Utils::scm2String(channel),
363	Utils::scm2String(message));
364	return scm_long2num(m.getCode());
365	}
366
367	SCM
368	ScriptCommands::Server(SCM number)
369	{
370	VERIFY_NUMBER(number);
371	Message m = Commands::Server(Interp::bot, gh_scm2long(number));
372	return scm_long2num(m.getCode());
373	}
374
375	SCM
376	ScriptCommands::SetVersion(SCM version)
377	{
378	Message m = Commands::SetVersion(Interp::bot, Utils::scm2String(version));
379	return scm_long2num(m.getCode());
380	}
381
382	SCM
383	ScriptCommands::TBan(SCM channel, SCM who, SCM seconds)
384	{
385	VERIFY_STRING(channel);
386	VERIFY_STRING(who);
387	VERIFY_NUMBER(seconds);
388	Message m = Commands::TBan(Interp::bot, Utils::scm2String(channel),
389	Utils::scm2String(who), gh_scm2long(seconds));
390	return scm_long2num(m.getCode());
391	}
392
393	SCM
394	ScriptCommands::TKBan(SCM channel, SCM who, SCM seconds, SCM reason)
395	{
396	VERIFY_STRING(channel);
397	VERIFY_STRING(who);
398	VERIFY_NUMBER(seconds);
399	String r = "";
400	if (SCM_STRINGP(reason))
401	r = Utils::scm2String(reason);
402	Message m = Commands::TKBan(Interp::bot, Utils::scm2String(channel),
403	Utils::scm2String(who),
404	gh_scm2long(seconds), r);
405	return scm_long2num(m.getCode());
406	}
407
408	SCM
409	ScriptCommands::Topic(SCM channel, SCM topic)
410	{
411	VERIFY_STRING(channel);
412	VERIFY_STRING(topic);
413	Message m = Commands::Topic(Interp::bot, Utils::scm2String(channel),
414	Utils::scm2String(topic));
415	return scm_long2num(m.getCode());
416	}
417
418	SCM
419	ScriptCommands::Unlock(SCM channel)
420	{
421	VERIFY_STRING(channel);
422	Message m = Commands::Unlock(Interp::bot, Utils::scm2String(channel));
423	return scm_long2num(m.getCode());
424	}
425
426
427
428
429	SCM
430	ScriptCommands::getNickname(void)
431	{
432	return Utils::string2SCM(Interp::bot->nickName);
433	}
434
435	SCM
436	ScriptCommands::getServer(void)
437	{
438	::Server *serv = Interp::bot->serverList->currentServer();
439	int serverNumber = Interp::bot->serverList->currentNumber;
440
441	return gh_list(scm_long2num(serverNumber),
442	Utils::string2SCM(serv->getHostName()),
443	scm_long2num(serv->getPort()),
444	Utils::string2SCM(serv->getPassword()),
445	SCM_UNDEFINED);
446	}
447
448	SCM
449	ScriptCommands::getServerList(void)
450	{
451	SCM res = gh_list(SCM_UNDEFINED);
452	::Server *s;
453	int i = 0;
454	std::vector<class Server *>::iterator it = Interp::bot->serverList->begin();
455
456	for ( ; it != Interp::bot->serverList->end(); ++it) {
457	s = (*it);
458	res = gh_append2(res,
459	gh_list(gh_list(scm_long2num(i++),
460	Utils::string2SCM(s->getHostName()),
461	scm_long2num(s->getPort()),
462	Utils::string2SCM(s->getPassword()),
463	SCM_UNDEFINED), SCM_UNDEFINED));
464	}
465	return res;
466	}
467
468	SCM
469	ScriptCommands::flushQueue(void)
470	{
471	if (!Interp::bot->serverConnection)
472	return SCM_BOOL_F;
473	Interp::bot->serverConnection->queue->flush();
474	return SCM_BOOL_T;
475	}
476
477	SCM
478	ScriptCommands::flushPort(void)
479	{
480	scm_flush(Interp::bot->botInterp->logPort);
481	return SCM_BOOL_T;
482	}
483
484	SCM
485	ScriptCommands::random(SCM scm_max)
486	{
487	int max = 0;
488	//srand(time(NULL));
489	if (SCM_NUMBERP(scm_max))
490	max = gh_scm2int(scm_max);
491	return scm_long2num(max ? rand() % max : 0);
492	}
493
494	SCM
495	ScriptCommands::addCommand(SCM scm_commandName, SCM scm_function,
496	SCM scm_needsChannel, SCM scm_args,
497	SCM scm_minLevel)
498	{
499	// We check that commandName is a string
500	if (!SCM_STRINGP(scm_commandName))
501	return SCM_BOOL_F;
502
503	// We check that the command does not exist
504	String commandName = Utils::scm2String(scm_commandName).toUpper();
505	std::list<class userFunction *>::iterator it =
506	Interp::bot->userFunctions.begin();
507	for ( ; it != Interp::bot->userFunctions.end(); ++it) {
508	if ((*it)->name == commandName)
509	return SCM_BOOL_F;
510	}
511
512	// Next we check that needsChannel is a boolean
513	if (!gh_boolean_p(scm_needsChannel))
514	return SCM_BOOL_F;
515	bool needsChannel = (bool)gh_scm2bool(scm_needsChannel);
516
517	// We check that minLevel is an integer and that it's
518	// a valid level
519	if (!SCM_NUMBERP(scm_minLevel))
520	return SCM_BOOL_F;
521
522	int minLevel = gh_scm2long(scm_minLevel);
523	if (minLevel < User::NONE \|\| minLevel > User::MASTER)
524	return SCM_BOOL_F;
525
526	// We check that "scm_function" is a Scheme procedure
527	if (!gh_procedure_p(scm_function))
528	return SCM_BOOL_F;
529
530	// We check that args is an integer and is between 0 and 20 (arbitrary limit)
531	if (!SCM_NUMBERP(scm_args))
532	return SCM_BOOL_F;
533
534	int args = gh_scm2long(scm_args);
535	if (args < 0 \|\| args > 20)
536	return SCM_BOOL_F;
537
538	// We add the command in the commands list
539	Interp::bot->userFunctions.push_back(new userFunction(commandName,
540	(void ()(ServerConnection , Person *, String, String))0, minLevel, needsChannel, args, scm_function));
541
542	return SCM_BOOL_T;
543	}
544
545	SCM
546	ScriptCommands::delCommand(SCM scm_commandName)
547	{
548	// We check that commandName is a string
549	if (!SCM_STRINGP(scm_commandName))
550	return SCM_BOOL_F;
551
552	// We check that the command does exist
553	String commandName = Utils::scm2String(scm_commandName).toUpper();
554	std::list<class userFunction *>::iterator it =
555	Interp::bot->userFunctions.begin();
556	for ( ; it != Interp::bot->userFunctions.end(); ++it) {
557	if ((*it)->name == commandName)
558	break;
559	}
560
561	if (it == Interp::bot->userFunctions.end())
562	return SCM_BOOL_F;
563
564	// We delete the command
565	Interp::bot->userFunctions.erase(it);
566	delete (*it);
567
568	return SCM_BOOL_T;
569	}
570
571	SCM
572	ScriptCommands::AddHook(SCM type, SCM regex, SCM function, SCM pri, SCM fall)
573	{
574	int priority = 0;
439869bf	575	bool fallt = true; // does this hook fall through?
cb21075d	576
	577	if (!SCM_UNBNDP (pri))
	578	priority = scm_num2int (pri, SCM_ARG1, "ScriptCommands::AddHook");
	579	if (!SCM_UNBNDP (fall))
	580	fallt = SCM_NFALSEP (fall);
	581	return SCM_BOOL (Interp::bot->botInterp->AddHook(gh_scm2long(type),
	582	regex, function,
	583	priority, fallt));
	584	}
	585
	586	SCM
	587	ScriptCommands::AddTimer(SCM when, SCM function)
	588	{
	589	return Interp::bot->botInterp->AddTimer(gh_scm2long(when), function);
	590	}
	591
	592	SCM
	593	ScriptCommands::DelTimer(SCM timer)
	594	{
	595	return gh_bool2scm(Interp::bot->botInterp->DelTimer(timer));
	596	}
	597
	598	#endif