/*********************************************************************/
/* file: misc.c - misc commands */
/* TINTIN III */
/* (T)he K(I)cki(N) (T)ickin D(I)kumud Clie(N)t */
/* coded by peter unold 1992 */
/*********************************************************************/
#include <string.h>
#include <ctype.h>
#include "tintin.h"
#if IRIX
#include <stdlib.h>
#endif
/* externs */
extern struct session *newactive_session();
extern struct listnode *common_aliases, *common_actions, *common_subs, *common_myvars;
extern struct listnode *common_highs, *common_antisubs, *common_pathdirs;
extern char *get_arg_in_braces();
extern void term_echo();
extern int redraw, is_split;
extern struct session *sessionlist;
extern struct completenode *complete_head;
extern char tintin_char;
extern int echo;
extern int speedwalk;
extern int presub;
extern int togglesubs;
extern char vars[10][BUFFER_SIZE]; /* the %0, %1, %2,....%9 variables */
extern int mesvar[7];
extern int verbatim;
/****************************/
/* the cr command */
/****************************/
void cr_command(ses)
struct session *ses;
{
if (ses != NULL)
write_line_mud("\n", ses);
}
/****************************/
/* the version command */
/****************************/
void version_command()
{
char temp[80];
sprintf(temp,"#You are using TINTIN++ %s\n\r", VERSION_NUM);
tintin_puts2(temp, NULL);
prompt(NULL);
}
/****************************/
/* the verbatim command, */
/* used as a toggle */
/****************************/
void verbatim_command()
{
verbatim=!verbatim;
if (verbatim)
tintin_puts2("#All text is now sent 'as is'.", (struct sesssion *)NULL);
else
tintin_puts2("#Text is no longer sent 'as is'.", (struct session *)NULL);
prompt(NULL);
}
/********************/
/* the #all command */
/********************/
struct session *all_command(arg, ses)
char *arg;
struct session *ses;
{
struct session *sesptr;
if(sessionlist) {
get_arg_in_braces(arg, arg, 1);
for(sesptr=sessionlist; sesptr; sesptr=sesptr->next)
parse_input(arg, sesptr);
}
else
tintin_puts("BUT THERE ISN'T ANY SESSION AT ALL!", ses);
return ses;
}
void redraw_command()
{
redraw=!redraw;
if (redraw)
tintin_puts2("#Ok. I now redraw input line when text arrives.", (struct session *)NULL);
else
tintin_puts2("#Ok. I no longer redraw the input line.", (struct session *)NULL);
prompt(NULL);
}
/*********************/
/* the #bell command */
/*********************/
void bell_command(ses)
struct session *ses;
{
char temp[2];
temp[0]=7;
temp[1]=0;
write(1, temp, 2);
}
/*********************/
/* the #boss command */
/*********************/
void boss_command(ses)
struct session *ses;
{
char temp[80];
int i;
for(i=0; i<50; i++) {
sprintf(temp, "in-order traverse of tree starting from node %d resulted in %d red nodes\n", i, 50-i);
tintin_puts2(temp, (struct session *)NULL);
}
getchar(); /* stop screen from scrolling stuff */
}
/*********************/
/* the #char command */
/*********************/
void char_command(arg, ses)
char *arg;
struct session *ses;
{
char strng[80];
get_arg_in_braces(arg, arg,1);
if(ispunct(*arg)) {
tintin_char= *arg;
sprintf(strng, "#OK. TINTIN-CHAR is now {%c}\n", tintin_char);
tintin_puts2(strng, (struct session *)NULL);
}
else
tintin_puts2("#SPECIFY A PROPER TINTIN-CHAR! SOMETHING LIKE # OR /!", (struct session *)NULL);
}
/*********************/
/* the #echo command */
/*********************/
void echo_command(ses)
struct session *ses;
{
echo=!echo;
if(echo)
tintin_puts("#ECHO IS NOW ON.", ses);
else
tintin_puts("#ECHO IS NOW OFF.", ses);
}
/*********************/
/* the #end command */
/*********************/
void end_command(command, ses)
char *command;
struct session *ses;
{
if(strcmp(command, "end"))
tintin_puts("#YOU HAVE TO WRITE #end - NO LESS, TO END!", ses);
else {
struct session *sesptr;
for(sesptr=sessionlist; sesptr; sesptr=sesptr->next)
cleanup_session(sesptr);
ses=NULL;
if (is_split)
write(1, "c", 3);
tintin_puts2("TINTIN suffers from bloodlack, and the lack of a beating heart...", ses);
tintin_puts2("TINTIN is dead! R.I.P.", ses);
tintin_puts2("Your blood freezes as you hear TINTIN's death cry.", ses);
term_echo();
exit(0);
}
}
/***********************/
/* the #ignore command */
/***********************/
void ignore_command(ses)
struct session *ses;
{
if (ses) {
if(ses->ignore=!ses->ignore)
tintin_puts("#ACTIONS ARE IGNORED FROM NOW ON.", ses);
else
tintin_puts("#ACTIONS ARE NO LONGER IGNORED.", ses);
} else tintin_puts("#No session active => Nothing to ignore!", ses);
}
/**********************/
/* the #presub command*/
/**********************/
void presub_command(ses)
struct session *ses;
{
presub=!presub;
if(presub)
tintin_puts("#ACTIONS ARE NOW PROCESSED ON SUBSTITUTED BUFFER.",ses);
else
tintin_puts("#ACTIONS ARE NO LONGER DONE ON SUBSTITUTED BUFFER.",ses);
}
/**************************/
/* the #togglesubs command*/
/**************************/
void togglesubs_command(ses)
struct session *ses;
{
togglesubs=!togglesubs;
if(togglesubs)
tintin_puts("#SUBSTITUTES ARE NOW IGNORED.",ses);
else
tintin_puts("#SUBSTITUTES ARE NO LONGER IGNORED.", ses);
}
/***********************/
/* the #showme command */
/***********************/
void showme_command(arg, ses)
char *arg;
struct session *ses;
{
char result[BUFFER_SIZE], strng[BUFFER_SIZE];
get_arg_in_braces(arg,arg,1);
prepare_actionalias(arg,result,ses);
sprintf(strng,"%s",result);
tintin_puts2(strng, ses);
}
/***********************/
/* the #loop command */
/***********************/
void loop_command(arg, ses)
char *arg;
struct session *ses;
{
char left[BUFFER_SIZE],right[BUFFER_SIZE];
char result[BUFFER_SIZE];
int flag, bound1, bound2, counter;
arg=get_arg_in_braces(arg,left,0);
arg=get_arg_in_braces(arg,right,1);
flag =1;
if (sscanf(left,"%d,%d",&bound1,&bound2)!=2)
tintin_puts2("#Wrong number of arguments in #loop",ses);
else {
flag=1;
counter=bound1;
while(flag==1) {
sprintf(vars[0], "%d", counter);
substitute_vars(right,result);
parse_input(result,ses);
if (bound1<bound2) {
counter++;
if (counter>bound2)
flag=0;
}
else {
counter--;
if (counter<bound2)
flag=0;
}
}
}
}
/************************/
/* the #message command */
/************************/
void message_command(arg, ses)
char *arg;
struct session *ses;
{
char offon[2][20];
int mestype;
char ms[6][20], tpstr[80];
sscanf("aliases actions substitutes antisubstitutes highlights variables",
"%s %s %s %s %s %s",ms[0],ms[1],ms[2],ms[3],ms[4],ms[5]);
strcpy(offon[0],"OFF.");
strcpy(offon[1],"ON.");
get_arg_in_braces(arg,arg,1);
mestype=0;
while (!is_abrev(arg,ms[mestype]) && mestype<6)
mestype++;
if (mestype==6)
tintin_puts2("#Invalid message type to toggle.", ses);
else {
mesvar[mestype]=!mesvar[mestype];
sprintf(tpstr,"#Ok. messages concerning %s are now %s",
ms[mestype],offon[mesvar[mestype]]);
tintin_puts2(tpstr,ses);
}
}
/**********************/
/* the #snoop command */
/**********************/
void snoop_command(arg, ses)
char *arg;
struct session *ses;
{
char buf[100];
struct session *sesptr=ses;
if(ses) {
get_arg_in_braces(arg, arg,1);
if(*arg) {
for(sesptr=sessionlist; sesptr && strcmp(sesptr->name, arg); sesptr=sesptr->next);
if(!sesptr) {
tintin_puts("#NO SESSION WITH THAT NAME!", ses);
return;
}
}
if(sesptr->snoopstatus) {
sesptr->snoopstatus=FALSE;
sprintf(buf, "#UNSNOOPING SESSION '%s'", sesptr->name);
tintin_puts(buf, ses);
}
else {
sesptr->snoopstatus=TRUE;
sprintf(buf, "#SNOOPING SESSION '%s'", sesptr->name);
tintin_puts(buf, ses);
}
}
else
tintin_puts("#NO SESSION ACTIVE => NO SNOOPING", ses);
}
/**************************/
/* the #speedwalk command */
/**************************/
void speedwalk_command(ses)
struct session *ses;
{
speedwalk=!speedwalk;
if(speedwalk)
tintin_puts("#SPEEDWALK IS NOW ON.", ses);
else
tintin_puts("#SPEEDWALK IS NOW OFF.", ses);
}
/***********************/
/* the #system command */
/***********************/
void system_command(arg, ses)
char *arg;
struct session *ses;
{
get_arg_in_braces(arg, arg, 1);
if(*arg) {
tintin_puts3("^#OK EXECUTING SHELL COMMAND.", ses);
term_echo();
#if defined(DEBUG)
system(arg);
#else
alarm(0);
system(arg);
#endif
#if defined(DEBUG)
alarm(0);
#else
alarm(1);
#endif
term_noecho();
tintin_puts3("!#OK COMMAND EXECUTED.", ses);
}
else
tintin_puts2("#EXECUTE WHAT COMMAND?", ses);
prompt(NULL);
}
/********************/
/* the #zap command */
/********************/
struct session *zap_command(ses)
struct session *ses;
{
tintin_puts("#ZZZZZZZAAAAAAAAPPPP!!!!!!!!! LET'S GET OUTTA HERE!!!!!!!!", ses);
if(ses) {
cleanup_session(ses);
return newactive_session();
}
else {
end_command("end", (struct session *) NULL);
}
}
/************************/
/* the #wizlist command */
/************************/
/* void wizlist_command(ses)
struct session *ses;
{
tintin_puts2("==========================================================================", ses);
tintin_puts2(" Implementor:", ses);
tintin_puts2(" Valgar ", ses);
tintin_puts2("", ses);
tintin_puts2(" Special thanks to Grimmy for all her help :)", ses);
tintin_puts2("\n\r TINTIN++ testers:", ses);
tintin_puts2(" Nemesis, Urquan, Elvworn, Kare, Merjon, Grumm, Tolebas, Winterblade ", ses);
tintin_puts2("\n\r A very special hello to Zoe, Oura, GODDESS, Reyna, Randela, Kell, ", ses);
tintin_puts2(" and everyone else at GrimneDIKU\n\r", ses);
tintin_puts2("==========================================================================", ses);
prompt(ses);
} */
void wizlist_command(ses)
struct session *ses;
{
tintin_puts2("==========================================================================", ses);
tintin_puts2(" There are too many people to thank for making tintin++ into one of the", ses);
tintin_puts2("finest clients available. Those deserving mention though would be ", ses);
tintin_puts2("Peter Unold, Bill Reiss, Joann Ellsworth, Jeremy Jack, and the many people", ses);
tintin_puts2("who send us bug reports and suggestions.", ses);
tintin_puts2(" Enjoy!!! And keep those suggestions coming in!!\n\r", ses);
tintin_puts2(" The Management...", ses);
tintin_puts2("==========================================================================", ses);
}
/*********************************************************************/
/* tablist will display the all items in the tab completion file */
/*********************************************************************/
void tablist(tcomplete)
struct completenode *tcomplete;
{
int count, done;
char tbuf[BUFFER_SIZE];
struct completenode *tmp;
done=0;
if (tcomplete==NULL)
{
tintin_puts2("Sorry.. But you have no words in your tab completion file",NULL);
return;
}
count=1;
*tbuf='\0';
/*
I'll search through the entire list, printing thre names to a line then
outputing the line. Creates a nice 3 column effect. To increase the #
if columns, just increase the mod #. Also.. decrease the # in the %s's
*/
for(tmp=tcomplete->next;tmp!=NULL;tmp=tmp->next)
{
if ((count % 3))
{
if (count == 1)
sprintf(tbuf,"%25s", tmp->strng);
else
sprintf(tbuf,"%s%25s",tbuf,tmp->strng);
done=0;
++count;
}
else
{
sprintf(tbuf,"%s%25s",tbuf,tmp->strng);
tintin_puts2(tbuf, NULL);
done=1;
*tbuf='\0';
++count;
}
}
if (!done)
tintin_puts2(tbuf, NULL);
prompt(NULL);
}
void tab_add(arg)
char *arg;
{
struct completenode *tmp, *tmpold, *tcomplete;
struct completenode *newt;
char *newcomp, buff[BUFFER_SIZE];
tcomplete=complete_head;
if ((arg == NULL) || (strlen(arg)<=0)) {
tintin_puts("Sorry, you must have some word to add.", NULL);
prompt(NULL);
return;
}
get_arg_in_braces(arg, buff, 1);
if ((newcomp=(char *)(malloc(strlen(buff)+1)))==NULL) {
fprintf(stderr, "Could not allocate enough memory for that Completion word.\n");
exit(1);
}
strcpy(newcomp, buff);
tmp=tcomplete;
while (tmp->next != NULL) {
tmpold=tmp;
tmp=tmp->next;
}
if ((newt=(struct completenode *)(malloc(sizeof(struct completenode))))==NULL) {
fprintf(stderr, "Could not allocate enough memory for that Completion word.\n");
exit(1);
}
newt->strng=newcomp;
newt->next=NULL;
tmp->next=newt;
tmp=newt;
sprintf(buff,"#New word %s added to tab completion list.", arg);
tintin_puts(buff, NULL);
prompt(NULL);
}
void tab_delete(arg)
char *arg;
{
struct completenode *tmp, *tmpold, *tmpnext, *tcomplete;
struct completenode *newt;
char *oldcomp, s_buff[BUFFER_SIZE], c_buff[BUFFER_SIZE];
tcomplete=complete_head;
if ((arg == NULL) || (strlen(arg)<=0)) {
tintin_puts("#Sorry, you must have some word to delete.", NULL);
prompt(NULL);
return;
}
get_arg_in_braces(arg, s_buff, 1);
tmp=tcomplete->next;
tmpold=tcomplete;
if (tmpold->strng == NULL) { /* (no list if the second node is null) */
tintin_puts("#There are no words for you to delete!", NULL);
prompt(NULL);
return;
}
strcpy(c_buff, tmp->strng);
while ((tmp->next != NULL) && (strcmp(c_buff, s_buff) != 0)) {
tmpold=tmp;
tmp=tmp->next;
strcpy(c_buff, tmp->strng);
}
if (tmp->next != NULL) {
tmpnext=tmp->next;
tmpold->next=tmpnext;
free(tmp);
tintin_puts("#Tab word deleted.", NULL);
prompt(NULL);
} else {
if (strcmp(c_buff, s_buff) == 0) { /* for the last node to delete */
tmpold->next=NULL;
free(tmp);
tintin_puts("#Tab word deleted.", NULL);
prompt(NULL);
return;
}
tintin_puts("Word not found in list.", NULL);
prompt(NULL);
}
}
void display_info(ses)
struct session *ses;
{
char buf[BUFFER_SIZE];
int actions=0;
int aliases=0;
int vars=0;
int subs=0;
int antisubs=0;
int highs=0;
int ignore;
actions=count_list((ses) ? ses->actions : common_actions);
aliases=count_list((ses) ? ses->aliases : common_aliases);
subs=count_list((ses) ? ses->subs : common_subs);
antisubs=count_list((ses) ? ses->antisubs : common_antisubs);
vars=count_list((ses) ? ses->myvars : common_myvars);
highs=count_list((ses) ? ses->highs : common_highs);
if (ses)
ignore = ses->ignore;
else
ignore =0;
tintin_puts2("You have defined the following:",ses);
sprintf(buf,"Actions : %d", actions);
tintin_puts2(buf, ses);
sprintf(buf,"Aliases : %d", aliases);
tintin_puts2(buf, ses);
sprintf(buf,"Substitutes : %d", subs);
tintin_puts2(buf, ses);
sprintf(buf,"Antisubstitutes : %d",antisubs);
tintin_puts2(buf, ses);
sprintf(buf,"Variables : %d", vars);
tintin_puts2(buf, ses);
sprintf(buf,"Highlights : %d", highs);
tintin_puts2(buf, ses);
sprintf(buf,"Echo : %d (1 - on, 0 - off) Speedwalking : %d Redraw: %d", echo, speedwalk, redraw);
tintin_puts2(buf, ses);
sprintf(buf,"Toggle Subs: %d Ignore Actions : %d PreSub-ing: %d", togglesubs, ignore, presub);
tintin_puts2(buf, ses);
prompt(ses);
}