static int
test_tailq_create(void)
{
struct rte_dummy_head *d_head;
unsigned i;
/* create a first tailq and check its non-null */
d_head = RTE_TAILQ_RESERVE_BY_IDX(DEFAULT_TAILQ, rte_dummy_head);
if (d_head == NULL)
do_return("Error allocating dummy_q0\n");
/* check we can add an item to it
*/
TAILQ_INSERT_TAIL(d_head, &d_elem, next);
/* try allocating dummy_q0 again, and check for failure */
if (RTE_TAILQ_RESERVE_BY_IDX(DEFAULT_TAILQ, rte_dummy_head) == NULL)
do_return("Error, non-null result returned when attemption to "
"re-allocate a tailq\n");
/* now fill up the tailq slots available and check we get an error */
for (i = RTE_TAILQ_NUM; i < RTE_MAX_TAILQ; i++) {
if ((d_head = RTE_TAILQ_RESERVE_BY_IDX(i, rte_dummy_head)) == NULL)
break;
}
/* check that we had an error return before RTE_MAX_TAILQ */
if (i != RTE_MAX_TAILQ)
do_return("Error, we did not have a reservation as expected\n");
return 0;
}
static void maybe_write(struct thread *thread)
{
obj_t *fp = thread->fp;
int fd = fixnum_value(fp[-9]);
int nfound, res;
obj_t *old_sp;
nfound = output_writable(fd);
if (nfound < 0) {
if (errno != EINTR) {
old_sp = pop_linkage(thread);
thread->sp = old_sp + 2;
old_sp[0] = obj_False;
old_sp[1] = make_fixnum(errno);
do_return(thread, old_sp, old_sp);
} else {
wait_for_output(thread, fd, maybe_write);
}
} else if (nfound == 0)
wait_for_output(thread, fd, maybe_write);
else {
res = write(fd,
buffer_data(fp[-8]) + fixnum_value(fp[-7]),
fixnum_value(fp[-6]));
results(thread, pop_linkage(thread), res, make_fixnum(res));
}
}
void branch_if(int do_branch)
{
uint8_t branch;
uint16_t offset;
branch = BYTE(pc++);
if(!do_branch) branch ^= 0x80;
offset = branch & 0x3f;
if((branch & 0x40) == 0)
{
offset = (offset << 8) | BYTE(pc++);
/* Get the sign right. */
if(offset & 0x2000) offset |= 0xc000;
}
if(branch & 0x80)
{
if(offset > 1)
{
pc += (int16_t)offset - 2;
ZASSERT(pc < memory_size, "branch to invalid address 0x%lx", (unsigned long)pc);
}
else
{
do_return(offset);
}
}
}
void shell_write_char(EditState *e, int c)
{
char ch;
if (e->interactive) {
ShellState *s = e->b->priv_data;
ch = c;
tty_write(s, &ch, 1);
} else {
switch (c) {
case 4:
do_delete_char(e);
break;
case 9:
do_tab(e);
break;
case 11:
do_kill_region(e, 2);
break;
case 127:
do_backspace(e);
break;
case '\r':
do_return(e);
break;
default:
text_write_char(e, c);
break;
}
}
}
static void maybe_read(struct thread *thread)
{
obj_t *fp = thread->fp;
int fd = fixnum_value(fp[-9]);
int nfound, res;
obj_t *old_sp;
nfound = input_available(fd);
if (nfound < 0) {
old_sp = pop_linkage(thread);
thread->sp = old_sp + 2;
old_sp[0] = obj_False;
old_sp[1] = make_fixnum(errno);
do_return(thread, old_sp, old_sp);
}
else if (nfound == 0)
wait_for_input(thread, fd, maybe_read);
else {
res = mindy_read(fd,
(char *)(buffer_data(fp[-8]) + fixnum_value(fp[-7])),
fixnum_value(fp[-6]));
results(thread, pop_linkage(thread), res, make_fixnum(res));
}
}
static void dylan_vector(struct thread *thread, int nargs)
{
obj_t *args = thread->sp - nargs;
obj_t res = make_vector(nargs, args);
obj_t *old_sp = args-1;
*old_sp = res;
thread->sp = args;
do_return(thread, old_sp, old_sp);
}
static int
test_tailq_lookup(void)
{
/* run successful test - check result is found */
struct rte_dummy_head *d_head;
struct rte_dummy *d_ptr;
d_head = RTE_TAILQ_LOOKUP_BY_IDX(DEFAULT_TAILQ, rte_dummy_head);
if (d_head == NULL)
do_return("Error with tailq lookup\n");
TAILQ_FOREACH(d_ptr, d_head, next)
if (d_ptr != &d_elem)
do_return("Error with tailq returned from lookup - "
"expected element not found\n");
/* now try a bad/error lookup */
d_head = RTE_TAILQ_LOOKUP_BY_IDX(RTE_MAX_TAILQ, rte_dummy_head);
if (d_head != NULL)
do_return("Error, lookup does not return NULL for bad tailq name\n");
return 0;
}
static void fd_exec(obj_t self, struct thread *thread, obj_t *args)
{
obj_t *oldargs;
oldargs = args - 1;
thread->sp = args + 1;
/* Mac doesn't support forking or piping */
oldargs[0] = obj_False;
oldargs[1] = obj_False;
do_return(thread, oldargs, oldargs);
}
inline void update( player_data* player )
{
int idle;
if( !player->In_Game( ) )
return;
if( player->save_time+600 < current_time ) {
if( is_set( &player->pcdata->message, MSG_AUTOSAVE ) )
send( player, "Autosaving...\r\n" );
write( player );
reference( player, player->contents, -1 );
}
idle = current_time-player->timer;
if( player->shdata->level < LEVEL_BUILDER
&& idle > ( player->link == NULL ? 30 : 300 ) ) {
if( player->was_in_room == NULL && player->in_room != NULL ) {
if( player->switched != NULL )
do_return( player->switched, "" );
player->was_in_room = player->in_room;
send( player, "You are pulled into nothingness.\r\n" );
send_seen( player, "%s is pulled into nothingness.\r\n", player );
write( player );
player->From( );
player->To( get_room_index( ROOM_LIMBO ) );
}
else if( idle > 900 ) {
forced_quit( player );
return;
}
}
if( player->was_in_room != NULL )
return;
if( player->gossip_pts < 1000
&& number_range( 0, player->pcdata->trust >= LEVEL_AVATAR ? 3 : 5 ) == 0 )
player->gossip_pts++;
player->shdata->fame = max( --player->shdata->fame, 0 );
player->whistle = max( --player->whistle, 0 );
player->prayer = min( ++player->prayer, 1000 );
condition_update( player );
update( (char_data*) player );
}
MINDY_NORETURN
static void unlink_catch(struct thread *thread, obj_t *vals)
{
obj_t catch_block;
obj_t *old_sp;
/* Unlink and invalidate the current catch block. */
catch_block = thread->cur_catch;
thread->cur_catch = obj_ptr(struct catch_block *, catch_block)->prev_catch;
obj_ptr(struct catch_block *, catch_block)->thread = NULL;
obj_ptr(struct catch_block *, catch_block)->prev_catch = obj_False;
/* Return the same values we got. */
old_sp = pop_linkage(thread);
do_return(thread, old_sp, vals);
}
static void results(struct thread *thread, obj_t *old_sp,
int okay, obj_t result)
{
thread->sp = old_sp + 2;
if (okay < 0) {
old_sp[0] = obj_False;
old_sp[1] = make_fixnum(errno);
}
else {
old_sp[0] = result;
old_sp[1] = obj_False;
}
do_return(thread, old_sp, old_sp);
}
MINDY_NORETURN
static void done_with_cleanup(struct thread *thread, obj_t *cleanup_vals)
{
obj_t *old_sp, *vals;
/* Get the pointer to the values from the protected form from the stack.
We pushed it just before calling the cleanup, so it just below the
cleanup values. */
vals = obj_rawptr(cleanup_vals[-1]);
/* Reset the stack to just after the protected form values. */
thread->sp = cleanup_vals - 1;
/* Return those values. */
old_sp = pop_linkage(thread);
do_return(thread, old_sp, vals);
}
void close_socket( link_data* link, bool process )
{
char buf [ MAX_STRING_LENGTH ];
char_data* ch;
int connected = link->connected;
if( link->channel == -1 ) {
bug( "Close_Socket: Closing a dead socket??" );
return;
}
// unswitch
if( ( ch = link->player ) != NULL && ch != link->character )
do_return( link->character, "" );
// send last of buffer
if( process ) {
link->connected = CON_CLOSING_LINK;
process_output( link );
}
// send EOF
send(link->channel, empty_string, 1, (unsigned int) 0);
if( ch != NULL ) {
if( connected == CON_PLAYING ) {
send_seen( ch, "%s has lost %s link.\n\r",
ch, ch->His_Her( ) );
sprintf( buf, "%s has lost link.", ch->descr->name );
info( buf, LEVEL_IMMORTAL, buf, IFLAG_LOGINS, 1, ch );
ch->link = NULL;
}
else {
if( ch->shdata->level == 0 && ch->pcdata->pfile != NULL )
extract( ch->pcdata->pfile, link );
ch->Extract( );
}
}
close( link->channel );
extract( link );
return;
}
static void fd_exec(obj_t self, struct thread *thread, obj_t *args)
{
obj_t *oldargs;
oldargs = args - 1;
thread->sp = args + 1;
{
PROCESS_INFORMATION piProcInfo;
STARTUPINFO siStartInfo;
SECURITY_ATTRIBUTES saAttr;
int inpipes[2], outpipes[2];
HANDLE old_handles[2];
const char *command_line = string_chars(args[0]);
siStartInfo.cb = sizeof(STARTUPINFO);
siStartInfo.lpReserved = NULL;
siStartInfo.lpReserved2 = NULL;
siStartInfo.cbReserved2 = 0;
siStartInfo.lpDesktop = NULL;
/* pipe_setup initializes the rest of siStartInfo */
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = true;
saAttr.lpSecurityDescriptor = NULL;
pipe_setup(&siStartInfo, inpipes, outpipes, old_handles);
if (! CreateProcess(NULL, command_line, NULL, NULL, true, 0,
NULL, NULL, &siStartInfo, &piProcInfo)) {
DWORD debug_info = GetLastError();
oldargs[0] = obj_False;
oldargs[1] = obj_False;
} else {
oldargs[0] = make_fixnum(inpipes[1]); /* fd we can write to */
oldargs[1] = make_fixnum(outpipes[0]); /* fd we can read from */
setup_input_checker(outpipes[0]);
}
pipe_cleanup(inpipes, outpipes, old_handles);
}
do_return(thread, oldargs, oldargs);
}
MINDY_NORETURN
static void getc_or_wait(struct thread *thread)
{
// if (FBUFEMPTYP(stdin) && !feof(stdin)) {
if (!feof(stdin)) {
int fd = fileno(stdin);
int nfound = input_available(fd);
if (nfound < 0) {
switch (errno) {
case EBADF:
error("Tried to getc with stdin broken.");
case EINTR:
wait_for_input(thread, fd, getc_or_wait);
case EINVAL:
lose("select failed with EINVAL?");
}
}
else if (nfound == 0)
wait_for_input(thread, fd, getc_or_wait);
}
{
obj_t *old_sp;
int c = mindy_getchar();
old_sp = pop_linkage(thread);
if (c != EOF)
*old_sp = int_char(c);
else
*old_sp = obj_False;
thread->sp = old_sp + 1;
do_return(thread, old_sp, old_sp);
}
}
/* test for deprecated functions - mainly for coverage */
static int
test_tailq_deprecated(void)
{
struct rte_dummy_head *d_head;
/* since TAILQ_RESERVE is not able to create new tailqs,
* we should find an existing one (IOW, RTE_TAILQ_RESERVE behaves identical
* to RTE_TAILQ_LOOKUP).
*
* PCI_RESOURCE_LIST tailq is guaranteed to
* be present in any DPDK app. */
d_head = RTE_TAILQ_RESERVE("PCI_RESOURCE_LIST", rte_dummy_head);
if (d_head == NULL)
do_return("Error finding PCI_RESOURCE_LIST\n");
d_head = RTE_TAILQ_LOOKUP("PCI_RESOURCE_LIST", rte_dummy_head);
if (d_head == NULL)
do_return("Error finding PCI_RESOURCE_LIST\n");
/* try doing that with non-existent names */
d_head = RTE_TAILQ_RESERVE("random name", rte_dummy_head);
if (d_head != NULL)
do_return("Non-existent tailq found!\n");
d_head = RTE_TAILQ_LOOKUP("random name", rte_dummy_head);
if (d_head != NULL)
do_return("Non-existent tailq found!\n");
/* try doing the same with NULL names */
d_head = RTE_TAILQ_RESERVE(NULL, rte_dummy_head);
if (d_head != NULL)
do_return("NULL tailq found!\n");
d_head = RTE_TAILQ_LOOKUP(NULL, rte_dummy_head);
if (d_head != NULL)
do_return("NULL tailq found!\n");
return 0;
}
/* Extract a ch completely from the world, and leave his stuff behind */
void extract_char_final(struct char_data *ch)
{
struct char_data *k, *temp;
struct descriptor_data *d;
struct obj_data *obj;
int i;
if (IN_ROOM(ch) == NOWHERE) {
log("SYSERR: NOWHERE extracting char %s. (%s, extract_char_final)",
GET_NAME(ch), __FILE__);
exit(1);
}
/* We're booting the character of someone who has switched so first we need
* to stuff them back into their own body. This will set ch->desc we're
* checking below this loop to the proper value. */
if (!IS_NPC(ch) && !ch->desc) {
for (d = descriptor_list; d; d = d->next)
if (d->original == ch) {
do_return(d->character, NULL, 0, 0);
break;
}
}
if (ch->desc) {
/* This time we're extracting the body someone has switched into (not the
* body of someone switching as above) so we need to put the switcher back
* to their own body. If this body is not possessed, the owner won't have a
* body after the removal so dump them to the main menu. */
if (ch->desc->original)
do_return(ch, NULL, 0, 0);
else {
/* Now we boot anybody trying to log in with the same character, to help
* guard against duping. CON_DISCONNECT is used to close a descriptor
* without extracting the d->character associated with it, for being
* link-dead, so we want CON_CLOSE to clean everything up. If we're
* here, we know it's a player so no IS_NPC check required. */
for (d = descriptor_list; d; d = d->next) {
if (d == ch->desc)
continue;
if (d->character && GET_IDNUM(ch) == GET_IDNUM(d->character))
STATE(d) = CON_CLOSE;
}
STATE(ch->desc) = CON_MENU;
write_to_output(ch->desc, "%s", CONFIG_MENU);
}
}
/* On with the character's assets... */
if (ch->followers || ch->master)
die_follower(ch);
/* Check to see if we are grouped! */
if (GROUP(ch))
leave_group(ch);
/* transfer objects to room, if any */
while (ch->carrying) {
obj = ch->carrying;
obj_from_char(obj);
obj_to_room(obj, IN_ROOM(ch));
}
/* transfer equipment to room, if any */
for (i = 0; i < NUM_WEARS; i++)
if (GET_EQ(ch, i))
obj_to_room(unequip_char(ch, i), IN_ROOM(ch));
if (FIGHTING(ch))
stop_fighting(ch);
for (k = combat_list; k; k = temp) {
temp = k->next_fighting;
if (FIGHTING(k) == ch)
stop_fighting(k);
}
/* Whipe character from the memory of hunters and other intelligent NPCs... */
for (temp = character_list; temp; temp = temp->next) {
/* PCs can't use MEMORY, and don't use HUNTING() */
if (!IS_NPC(temp))
continue;
/* If "temp" is hunting our extracted char, stop the hunt. */
if (HUNTING(temp) == ch)
HUNTING(temp) = NULL;
/* If "temp" has allocated memory data and our ch is a PC, forget the
* extracted character (if he/she is remembered) */
if (!IS_NPC(ch) && GET_POS(ch) == POS_DEAD && MEMORY(temp))
forget(temp, ch); /* forget() is safe to use without a check. */
}
char_from_room(ch);
if (IS_NPC(ch)) {
if (GET_MOB_RNUM(ch) != NOTHING) /* prototyped */
mob_index[GET_MOB_RNUM(ch)].number--;
clearMemory(ch);
if (SCRIPT(ch))
extract_script(ch, MOB_TRIGGER);
if (SCRIPT_MEM(ch))
extract_script_mem(SCRIPT_MEM(ch));
} else {
save_char(ch);
Crash_delete_crashfile(ch);
}
/* If there's a descriptor, they're in the menu now. */
if (IS_NPC(ch) || !ch->desc)
free_char(ch);
}
/**
* @return false iff all threads are dead.
*/
void throw_exception (Object *exception)
{
Thread *auxThread;
#ifdef VERIFY
assert (exception != null, EXCEPTIONS0);
#endif // VERIFY
#if DEBUG_EXCEPTIONS
printf("Throw exception\n");
#endif
if (currentThread == null)
{
// No threads have started probably
return;
}
else if (exception == interruptedException)
{
// Throwing an interrupted exception clears the flag
currentThread->interruptState = INTERRUPT_CLEARED;
}
#ifdef VERIFY
assert (currentThread->state > DEAD, EXCEPTIONS1);
#endif // VERIFY
gExceptionPc = pc;
gExcepMethodRec = null;
#if 0
trace (-1, get_class_index(exception), 3);
#endif
LABEL_PROPAGATE:
tempStackFrame = current_stackframe();
tempMethodRecord = tempStackFrame->methodRecord;
if (gExcepMethodRec == null)
gExcepMethodRec = tempMethodRecord;
gExceptionRecord = (ExceptionRecord *) (get_binary_base() + tempMethodRecord->exceptionTable);
tempCurrentOffset = ptr2word(pc) - ptr2word(get_binary_base() + tempMethodRecord->codeOffset);
#if 0
trace (-1, tempCurrentOffset, 5);
#endif
gNumExceptionHandlers = tempMethodRecord->numExceptionHandlers;
#if DEBUG_EXCEPTIONS
printf("Num exception handlers=%d\n",gNumExceptionHandlers);
#endif
while (gNumExceptionHandlers--)
{
if (gExceptionRecord->start <= tempCurrentOffset /* off by one? < ? */
&& tempCurrentOffset <= gExceptionRecord->end)
{
// Check if exception class applies
if (instance_of (exception, gExceptionRecord->classIndex))
{
// Clear operand stack
init_sp (tempStackFrame, tempMethodRecord);
// Push the exception object
push_ref (ptr2word (exception));
// Jump to handler:
pc = get_binary_base() + tempMethodRecord->codeOffset +
gExceptionRecord->handler;
#if DEBUG_EXCEPTIONS
printf("Found exception handler\n");
#endif
return;
}
}
gExceptionRecord++;
}
// No good handlers in current stack frame - go up.
auxThread = currentThread;
do_return (0);
// Note: return takes care of synchronized methods.
if (auxThread->state == DEAD)
{
#if DEBUG_EXCEPTIONS
printf("Thread is dead\n");
#endif
if (get_class_index(exception) != JAVA_LANG_THREADDEATH)
{
#if DEBUG_EXCEPTIONS
printf("Handle uncaught exception\n");
#endif
handle_uncaught_exception (exception, auxThread,
gExcepMethodRec, tempMethodRecord,
gExceptionPc);
}
return;
}
goto LABEL_PROPAGATE;
}
static void op_return_single(int byte, struct thread *thread)
{
do_return(thread, pop_linkage(thread), thread->sp - 1);
}
void outputFunction(FILE *fp, ClassInfo *data)
{
static unsigned int supported_types[] = {
VTK_PARSE_VOID, VTK_PARSE_BOOL, VTK_PARSE_FLOAT, VTK_PARSE_DOUBLE,
VTK_PARSE_CHAR, VTK_PARSE_UNSIGNED_CHAR, VTK_PARSE_SIGNED_CHAR,
VTK_PARSE_INT, VTK_PARSE_UNSIGNED_INT,
VTK_PARSE_SHORT, VTK_PARSE_UNSIGNED_SHORT,
VTK_PARSE_LONG, VTK_PARSE_UNSIGNED_LONG,
VTK_PARSE_ID_TYPE, VTK_PARSE_UNSIGNED_ID_TYPE,
VTK_PARSE_LONG_LONG, VTK_PARSE_UNSIGNED_LONG_LONG,
VTK_PARSE___INT64, VTK_PARSE_UNSIGNED___INT64,
VTK_PARSE_OBJECT, VTK_PARSE_STRING,
0
};
unsigned int rType =
(currentFunction->ReturnType & VTK_PARSE_UNQUALIFIED_TYPE);
unsigned int aType = 0;
unsigned int baseType = 0;
int i, j;
int args_ok = 1;
const char *jniFunction = 0;
char *jniFunctionNew = 0;
const char *begPtr = 0;
const char *endPtr = 0;
CurrentData = data;
/* some functions will not get wrapped no matter what else */
if (currentFunction->IsOperator ||
currentFunction->ArrayFailure ||
!currentFunction->IsPublic ||
!currentFunction->Name)
{
return;
}
/* NewInstance and SafeDownCast can not be wrapped because it is a
(non-virtual) method which returns a pointer of the same type as
the current pointer. Since all methods are virtual in Java, this
looks like polymorphic return type. */
if (!strcmp("NewInstance",currentFunction->Name))
{
return ;
}
if (!strcmp("SafeDownCast",currentFunction->Name))
{
return ;
}
/* The unwrappable methods in Filtering/vtkInformation.c */
if (strcmp(data->Name, "vtkInformation") == 0 &&
currentFunction->IsLegacy)
{
return;
}
/* The GetInput() in vtkMapper cannot be overriden with a
* different return type, Java doesn't allow this */
if (strcmp(data->Name, "vtkMapper") == 0 &&
strcmp(currentFunction->Name, "GetInput") == 0)
{
return;
}
/* check to see if we can handle the args */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
aType = (currentFunction->ArgTypes[i] & VTK_PARSE_UNQUALIFIED_TYPE);
baseType = (aType & VTK_PARSE_BASE_TYPE);
if (currentFunction->ArgTypes[i] != VTK_PARSE_FUNCTION)
{
for (j = 0; supported_types[j] != 0; j++)
{
if (baseType == supported_types[j]) { break; }
}
if (supported_types[j] == 0)
{
args_ok = 0;
}
}
if (baseType == VTK_PARSE_OBJECT)
{
if ((aType & VTK_PARSE_INDIRECT) != VTK_PARSE_POINTER)
{
args_ok = 0;
}
else if (hierarchyInfo)
{
if (vtkParseHierarchy_IsExtern(hierarchyInfo,
currentFunction->ArgClasses[i]) ||
vtkParseHierarchy_GetProperty(hierarchyInfo,
currentFunction->ArgClasses[i], "WRAP_EXCLUDE") ||
!vtkParseHierarchy_IsTypeOf(hierarchyInfo,
currentFunction->ArgClasses[i], "vtkObjectBase"))
{
args_ok = 0;
}
}
}
if (((aType & VTK_PARSE_INDIRECT) != VTK_PARSE_POINTER) &&
((aType & VTK_PARSE_INDIRECT) != 0) &&
(aType != VTK_PARSE_STRING_REF)) args_ok = 0;
if (aType == VTK_PARSE_STRING_PTR) args_ok = 0;
if (aType == VTK_PARSE_UNSIGNED_CHAR_PTR) args_ok = 0;
if (aType == VTK_PARSE_UNSIGNED_INT_PTR) args_ok = 0;
if (aType == VTK_PARSE_UNSIGNED_SHORT_PTR) args_ok = 0;
if (aType == VTK_PARSE_UNSIGNED_LONG_PTR) args_ok = 0;
if (aType == VTK_PARSE_UNSIGNED_ID_TYPE_PTR) args_ok = 0;
if (aType == VTK_PARSE_UNSIGNED_LONG_LONG_PTR) args_ok = 0;
if (aType == VTK_PARSE_UNSIGNED___INT64_PTR) args_ok = 0;
}
baseType = (rType & VTK_PARSE_BASE_TYPE);
for (j = 0; supported_types[j] != 0; j++)
{
if (baseType == supported_types[j]) { break; }
}
if (supported_types[j] == 0)
{
args_ok = 0;
}
if (baseType == VTK_PARSE_OBJECT)
{
if ((rType & VTK_PARSE_INDIRECT) != VTK_PARSE_POINTER)
{
args_ok = 0;
}
else if (hierarchyInfo)
{
if (vtkParseHierarchy_IsExtern(hierarchyInfo,
currentFunction->ReturnClass) ||
vtkParseHierarchy_GetProperty(hierarchyInfo,
currentFunction->ReturnClass, "WRAP_EXCLUDE") ||
!vtkParseHierarchy_IsTypeOf(hierarchyInfo,
currentFunction->ReturnClass, "vtkObjectBase"))
{
args_ok = 0;
}
}
}
if (((rType & VTK_PARSE_INDIRECT) != VTK_PARSE_POINTER) &&
((rType & VTK_PARSE_INDIRECT) != 0) &&
(rType != VTK_PARSE_STRING_REF)) args_ok = 0;
if (rType == VTK_PARSE_STRING_PTR) args_ok = 0;
/* eliminate unsigned short * usigned int * etc */
if (rType == VTK_PARSE_UNSIGNED_INT_PTR) args_ok = 0;
if (rType == VTK_PARSE_UNSIGNED_SHORT_PTR) args_ok = 0;
if (rType == VTK_PARSE_UNSIGNED_LONG_PTR) args_ok = 0;
if (rType == VTK_PARSE_UNSIGNED_ID_TYPE_PTR) args_ok = 0;
if (rType == VTK_PARSE_UNSIGNED_LONG_LONG_PTR) args_ok = 0;
if (rType == VTK_PARSE_UNSIGNED___INT64_PTR) args_ok = 0;
if (currentFunction->NumberOfArguments &&
(currentFunction->ArgTypes[0] == VTK_PARSE_FUNCTION)
&&(currentFunction->NumberOfArguments != 1)) args_ok = 0;
/* make sure we have all the info we need for array arguments in */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
aType = (currentFunction->ArgTypes[i] & VTK_PARSE_UNQUALIFIED_TYPE);
if (((aType & VTK_PARSE_INDIRECT) == VTK_PARSE_POINTER)&&
(currentFunction->ArgCounts[i] <= 0)&&
(aType != VTK_PARSE_OBJECT_PTR)&&
(aType != VTK_PARSE_CHAR_PTR)) args_ok = 0;
}
/* if we need a return type hint make sure we have one */
switch (rType)
{
case VTK_PARSE_FLOAT_PTR:
case VTK_PARSE_VOID_PTR:
case VTK_PARSE_DOUBLE_PTR:
case VTK_PARSE_INT_PTR:
case VTK_PARSE_SHORT_PTR:
case VTK_PARSE_LONG_PTR:
case VTK_PARSE_ID_TYPE_PTR:
case VTK_PARSE_LONG_LONG_PTR:
case VTK_PARSE___INT64_PTR:
case VTK_PARSE_SIGNED_CHAR_PTR:
case VTK_PARSE_BOOL_PTR:
case VTK_PARSE_UNSIGNED_CHAR_PTR:
args_ok = currentFunction->HaveHint;
break;
}
/* make sure there isn't a Java-specific override */
if (!strcmp("vtkObject",data->Name))
{
/* remove the original vtkCommand observer methods */
if (!strcmp(currentFunction->Name,"AddObserver") ||
!strcmp(currentFunction->Name,"GetCommand") ||
(!strcmp(currentFunction->Name,"RemoveObserver") &&
(currentFunction->ArgTypes[0] != VTK_PARSE_UNSIGNED_LONG)) ||
((!strcmp(currentFunction->Name,"RemoveObservers") ||
!strcmp(currentFunction->Name,"HasObserver")) &&
(((currentFunction->ArgTypes[0] != VTK_PARSE_UNSIGNED_LONG) &&
(currentFunction->ArgTypes[0] !=
(VTK_PARSE_CHAR_PTR|VTK_PARSE_CONST))) ||
(currentFunction->NumberOfArguments > 1))) ||
(!strcmp(currentFunction->Name,"RemoveAllObservers") &&
(currentFunction->NumberOfArguments > 0)))
{
args_ok = 0;
}
}
else if (!strcmp("vtkObjectBase",data->Name))
{
/* remove the special vtkObjectBase methods */
if (!strcmp(currentFunction->Name,"PrintRevisions") ||
!strcmp(currentFunction->Name,"Print"))
{
args_ok = 0;
}
}
/* make sure it isn't a Delete or New function */
if (!strcmp("Delete",currentFunction->Name) ||
!strcmp("New",currentFunction->Name))
{
args_ok = 0;
}
/* handle DataReader SetBinaryInputString as a special case */
if (!strcmp("SetBinaryInputString",currentFunction->Name) &&
(!strcmp("vtkDataReader",data->Name) ||
!strcmp("vtkStructuredGridReader",data->Name) ||
!strcmp("vtkRectilinearGridReader",data->Name) ||
!strcmp("vtkUnstructuredGridReader",data->Name) ||
!strcmp("vtkStructuredPointsReader",data->Name) ||
!strcmp("vtkPolyDataReader",data->Name)))
{
if(currentFunction->IsLegacy)
{
fprintf(fp,"#if !defined(VTK_LEGACY_REMOVE)\n");
}
HandleDataReader(fp,data);
if(currentFunction->IsLegacy)
{
fprintf(fp,"#endif\n");
}
wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
numberOfWrappedFunctions++;
}
if (currentFunction->IsPublic && args_ok &&
strcmp(data->Name,currentFunction->Name) &&
strcmp(data->Name, currentFunction->Name + 1))
{
/* make sure we haven't already done one of these */
if (!DoneOne())
{
fprintf(fp,"\n");
/* Underscores are escaped in method names, see
http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/design.html#wp133
VTK class names contain no underscore and do not need to be escaped. */
jniFunction = currentFunction->Name;
begPtr = currentFunction->Name;
endPtr = strchr(begPtr, '_');
if(endPtr)
{
jniFunctionNew = (char *)malloc(2*strlen(currentFunction->Name) + 1);
jniFunctionNew[0] = '\0';
while (endPtr)
{
strncat(jniFunctionNew, begPtr, endPtr - begPtr + 1);
strcat(jniFunctionNew, "1");
begPtr = endPtr + 1;
endPtr = strchr(begPtr, '_');
}
strcat(jniFunctionNew, begPtr);
jniFunction = jniFunctionNew;
}
if(currentFunction->IsLegacy)
{
fprintf(fp,"#if !defined(VTK_LEGACY_REMOVE)\n");
}
fprintf(fp,"extern \"C\" JNIEXPORT ");
return_result(fp);
fprintf(fp," JNICALL Java_vtk_%s_%s_1%i(JNIEnv *env, jobject obj",
data->Name, jniFunction, numberOfWrappedFunctions);
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
fprintf(fp,",");
output_proto_vars(fp, i);
}
fprintf(fp,")\n{\n");
/* get the object pointer */
fprintf(fp," %s *op;\n",data->Name);
/* process the args */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
output_temp(fp, i, currentFunction->ArgTypes[i],
currentFunction->ArgClasses[i],
currentFunction->ArgCounts[i]);
}
output_temp(fp, MAX_ARGS,currentFunction->ReturnType,
currentFunction->ReturnClass,0);
/* now get the required args from the stack */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
get_args(fp, i);
}
fprintf(fp,"\n op = (%s *)vtkJavaGetPointerFromObject(env,obj);\n",
data->Name);
switch (rType)
{
case VTK_PARSE_VOID:
fprintf(fp," op->%s(",currentFunction->Name);
break;
default:
if ((rType & VTK_PARSE_INDIRECT) == VTK_PARSE_REF)
{
fprintf(fp," temp%i = &(op)->%s(",MAX_ARGS,currentFunction->Name);
}
else
{
fprintf(fp," temp%i = (op)->%s(",MAX_ARGS,currentFunction->Name);
}
break;
}
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
aType = (currentFunction->ArgTypes[i] & VTK_PARSE_UNQUALIFIED_TYPE);
if (i)
{
fprintf(fp,",");
}
if (currentFunction->ArgTypes[i] == VTK_PARSE_FUNCTION)
{
fprintf(fp,"vtkJavaVoidFunc,(void *)temp%i",i);
}
else
{
fprintf(fp,"temp%i",i);
}
} /* for */
fprintf(fp,");\n");
if (currentFunction->NumberOfArguments == 1 &&
currentFunction->ArgTypes[0] == VTK_PARSE_FUNCTION)
{
fprintf(fp," op->%sArgDelete(vtkJavaVoidFuncArgDelete);\n",
jniFunction);
}
/* now copy and release any arrays */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
copy_and_release_args(fp, i);
}
do_return(fp);
fprintf(fp,"}\n");
if(currentFunction->IsLegacy)
{
fprintf(fp,"#endif\n");
}
wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
numberOfWrappedFunctions++;
if (jniFunctionNew)
{
free(jniFunctionNew);
jniFunctionNew = 0;
}
} /* isDone() */
} /* isAbstract */
}
void outputFunction(FILE *fp, ClassInfo *data)
{
int i;
int args_ok;
unsigned int rType =
(currentFunction->ReturnType & VTK_PARSE_UNQUALIFIED_TYPE);
const char *jniFunction = 0;
char *jniFunctionNew = 0;
char *jniFunctionOld = 0;
size_t j;
CurrentData = data;
args_ok = checkFunctionSignature(data);
/* handle DataReader SetBinaryInputString as a special case */
if (!strcmp("SetBinaryInputString",currentFunction->Name) &&
(!strcmp("vtkDataReader",data->Name) ||
!strcmp("vtkStructuredGridReader",data->Name) ||
!strcmp("vtkRectilinearGridReader",data->Name) ||
!strcmp("vtkUnstructuredGridReader",data->Name) ||
!strcmp("vtkStructuredPointsReader",data->Name) ||
!strcmp("vtkPolyDataReader",data->Name)))
{
if(currentFunction->IsLegacy)
{
fprintf(fp,"#if !defined(VTK_LEGACY_REMOVE)\n");
}
HandleDataReader(fp,data);
if(currentFunction->IsLegacy)
{
fprintf(fp,"#endif\n");
}
wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
numberOfWrappedFunctions++;
}
if (currentFunction->IsPublic && args_ok &&
strcmp(data->Name,currentFunction->Name) &&
strcmp(data->Name, currentFunction->Name + 1))
{
/* make sure we haven't already done one of these */
if (!DoneOne())
{
fprintf(fp,"\n");
/* Underscores are escaped in method names, see
http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/design.html#wp133
VTK class names contain no underscore and do not need to be escaped. */
jniFunction = currentFunction->Name;
jniFunctionOld = 0;
j = 0;
while (jniFunction[j] != '\0')
{
/* replace "_" with "_1" */
if (jniFunction[j] == '_')
{
j++;
jniFunctionNew = (char *)malloc(strlen(jniFunction) + 2);
strncpy(jniFunctionNew, jniFunction, j);
jniFunctionNew[j] = '1';
strcpy(&jniFunctionNew[j+1], &jniFunction[j]);
free(jniFunctionOld);
jniFunctionOld = jniFunctionNew;
jniFunction = jniFunctionNew;
}
j++;
}
if(currentFunction->IsLegacy)
{
fprintf(fp,"#if !defined(VTK_LEGACY_REMOVE)\n");
}
fprintf(fp,"extern \"C\" JNIEXPORT ");
return_result(fp);
fprintf(fp," JNICALL Java_vtk_%s_%s_1%i(JNIEnv *env, jobject obj",
data->Name, jniFunction, numberOfWrappedFunctions);
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
fprintf(fp,",");
output_proto_vars(fp, i);
/* ignore args after function pointer */
if (currentFunction->ArgTypes[i] == VTK_PARSE_FUNCTION)
{
break;
}
}
fprintf(fp,")\n{\n");
/* get the object pointer */
fprintf(fp," %s *op;\n",data->Name);
/* process the args */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
output_temp(fp, i, currentFunction->ArgTypes[i],
currentFunction->ArgClasses[i],
currentFunction->ArgCounts[i]);
/* ignore args after function pointer */
if (currentFunction->ArgTypes[i] == VTK_PARSE_FUNCTION)
{
break;
}
}
output_temp(fp, MAX_ARGS,currentFunction->ReturnType,
currentFunction->ReturnClass,0);
/* now get the required args from the stack */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
get_args(fp, i);
/* ignore args after function pointer */
if (currentFunction->ArgTypes[i] == VTK_PARSE_FUNCTION)
{
break;
}
}
fprintf(fp,"\n op = (%s *)vtkJavaGetPointerFromObject(env,obj);\n",
data->Name);
switch (rType)
{
case VTK_PARSE_VOID:
fprintf(fp," op->%s(",currentFunction->Name);
break;
default:
if ((rType & VTK_PARSE_INDIRECT) == VTK_PARSE_REF)
{
fprintf(fp," temp%i = &(op)->%s(",MAX_ARGS,currentFunction->Name);
}
else
{
fprintf(fp," temp%i = (op)->%s(",MAX_ARGS,currentFunction->Name);
}
break;
}
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
if (i)
{
fprintf(fp,",");
}
if (currentFunction->ArgTypes[i] == VTK_PARSE_FUNCTION)
{
fprintf(fp,"vtkJavaVoidFunc,(void *)temp%i",i);
break;
}
else
{
fprintf(fp,"temp%i",i);
}
} /* for */
fprintf(fp,");\n");
if (currentFunction->NumberOfArguments == 2 &&
currentFunction->ArgTypes[0] == VTK_PARSE_FUNCTION)
{
fprintf(fp," op->%sArgDelete(vtkJavaVoidFuncArgDelete);\n",
jniFunction);
}
/* now copy and release any arrays */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
copy_and_release_args(fp, i);
/* ignore args after function pointer */
if (currentFunction->ArgTypes[i] == VTK_PARSE_FUNCTION)
{
break;
}
}
do_return(fp);
fprintf(fp,"}\n");
if(currentFunction->IsLegacy)
{
fprintf(fp,"#endif\n");
}
wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
numberOfWrappedFunctions++;
if (jniFunctionNew)
{
free(jniFunctionNew);
jniFunctionNew = 0;
}
} /* isDone() */
} /* isAbstract */
}
/* Extract a ch completely from the world, and leave his stuff behind */
void extract_char(struct char_data *ch, bool pull)
{
struct obj_data *obj;
struct char_data *k, *next_char;
struct descriptor_data *t_desc;
int l, was_in;
extern struct char_data *combat_list;
void die_follower(struct char_data *ch);
if ( !IS_NPC(ch) && !ch->desc )
{
for ( t_desc = descriptor_list; t_desc; t_desc = t_desc->next )
{
if ( t_desc->original == ch )
do_return( t_desc->character, "", 0 );
}
}
if ( ch->in_room == NOWHERE )
{
log( "Extract_char: NOWHERE" );
exit( 1 );
}
if ( ch->followers || ch->master )
die_follower(ch);
while ( ( obj = ch->carrying ) != NULL )
{
obj_from_char( obj );
obj_to_room( obj, ch->in_room );
}
if ( ch->specials.fighting )
stop_fighting( ch );
for ( k = combat_list; k ; k = next_char )
{
next_char = k->next_fighting;
if ( k->specials.fighting == ch )
stop_fighting( k );
}
/* Must remove from room before removing the equipment! */
was_in = ch->in_room;
char_from_room( ch );
if ( !pull )
char_to_room(ch, real_room(3001));
/* clear equipment_list */
for ( l = 0; l < MAX_WEAR; l++ )
{
if ( ch->equipment[l] )
obj_to_room(unequip_char(ch,l), was_in);
}
GET_AC(ch) = 100;
if ( ch->desc && ch->desc->original )
do_return( ch, "", 0 );
if ( IS_NPC(ch) && ch->nr > -1 )
mob_index[ch->nr].number--;
if ( pull )
{
if ( ch == character_list )
character_list = ch->next;
else
{
for ( k = character_list; k && k->next != ch; k = k->next )
;
if ( k )
k->next = ch->next;
else
{
log( "Extract_char: bad char list" );
abort();
}
}
free_char( ch );
}
}
void outputFunction(FILE *fp, FileInfo *data)
{
int i;
int args_ok = 1;
char *jniFunction = 0;
char *begPtr = 0;
char *endPtr = 0;
CurrentData = data;
/* some functions will not get wrapped no matter what else */
if (currentFunction->IsOperator ||
currentFunction->ArrayFailure ||
!currentFunction->IsPublic ||
!currentFunction->Name)
{
return;
}
/* NewInstance and SafeDownCast can not be wrapped because it is a
(non-virtual) method which returns a pointer of the same type as
the current pointer. Since all methods are virtual in Java, this
looks like polymorphic return type. */
if (!strcmp("NewInstance",currentFunction->Name))
{
return ;
}
if (!strcmp("SafeDownCast",currentFunction->Name))
{
return ;
}
/* check to see if we can handle the args */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
if (currentFunction->ArgTypes[i] % 0x1000 == 0x9) args_ok = 0;
if ((currentFunction->ArgTypes[i] % 0x10) == 0x8) args_ok = 0;
if (((currentFunction->ArgTypes[i] % 0x1000)/0x100 != 0x3)&&
(currentFunction->ArgTypes[i] % 0x1000 != 0x109)&&
((currentFunction->ArgTypes[i] % 0x1000)/0x100)) args_ok = 0;
if (currentFunction->ArgTypes[i] % 0x1000 == 0x313) args_ok = 0;
if (currentFunction->ArgTypes[i] % 0x1000 == 0x314) args_ok = 0;
if (currentFunction->ArgTypes[i] % 0x1000 == 0x315) args_ok = 0;
if (currentFunction->ArgTypes[i] % 0x1000 == 0x316) args_ok = 0;
if (currentFunction->ArgTypes[i] % 0x1000 == 0x31A) args_ok = 0;
if (currentFunction->ArgTypes[i] % 0x1000 == 0x31B) args_ok = 0;
if (currentFunction->ArgTypes[i] % 0x1000 == 0x31C) args_ok = 0;
}
if ((currentFunction->ReturnType % 0x10) == 0x8) args_ok = 0;
if (currentFunction->ReturnType % 0x1000 == 0x9) args_ok = 0;
if (((currentFunction->ReturnType % 0x1000)/0x100 != 0x3)&&
(currentFunction->ReturnType % 0x1000 != 0x109)&&
((currentFunction->ReturnType % 0x1000)/0x100)) args_ok = 0;
/* eliminate unsigned short * usigned int * etc */
if (currentFunction->ReturnType % 0x1000 == 0x314) args_ok = 0;
if (currentFunction->ReturnType % 0x1000 == 0x315) args_ok = 0;
if (currentFunction->ReturnType % 0x1000 == 0x316) args_ok = 0;
if (currentFunction->ReturnType % 0x1000 == 0x31A) args_ok = 0;
if (currentFunction->ReturnType % 0x1000 == 0x31B) args_ok = 0;
if (currentFunction->ReturnType % 0x1000 == 0x31C) args_ok = 0;
if (currentFunction->NumberOfArguments &&
(currentFunction->ArgTypes[0] == 0x5000)
&&(currentFunction->NumberOfArguments != 1)) args_ok = 0;
/* make sure we have all the info we need for array arguments in */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
if (((currentFunction->ArgTypes[i] % 0x1000)/0x100 == 0x3)&&
(currentFunction->ArgCounts[i] <= 0)&&
(currentFunction->ArgTypes[i] % 0x1000 != 0x309)&&
(currentFunction->ArgTypes[i] % 0x1000 != 0x303)) args_ok = 0;
}
/* if we need a return type hint make sure we have one */
switch (currentFunction->ReturnType % 0x1000)
{
case 0x301: case 0x302: case 0x307:
case 0x304: case 0x305: case 0x306:
case 0x30A: case 0x30B: case 0x30C: case 0x30D: case 0x30E:
case 0x313:
args_ok = currentFunction->HaveHint;
break;
}
/* make sure it isn't a Delete or New function */
if (!strcmp("Delete",currentFunction->Name) ||
!strcmp("New",currentFunction->Name))
{
args_ok = 0;
}
/* handle DataReader SetBinaryInputString as a special case */
if (!strcmp("SetBinaryInputString",currentFunction->Name) &&
(!strcmp("vtkDataReader",data->ClassName) ||
!strcmp("vtkStructuredGridReader",data->ClassName) ||
!strcmp("vtkRectilinearGridReader",data->ClassName) ||
!strcmp("vtkUnstructuredGridReader",data->ClassName) ||
!strcmp("vtkStructuredPointsReader",data->ClassName) ||
!strcmp("vtkPolyDataReader",data->ClassName)))
{
if(currentFunction->IsLegacy)
{
fprintf(fp,"#if !defined(VTK_LEGACY_REMOVE)\n");
}
HandleDataReader(fp,data);
if(currentFunction->IsLegacy)
{
fprintf(fp,"#endif\n");
}
wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
numberOfWrappedFunctions++;
}
if (currentFunction->IsPublic && args_ok &&
strcmp(data->ClassName,currentFunction->Name) &&
strcmp(data->ClassName, currentFunction->Name + 1))
{
/* make sure we haven't already done one of these */
if (!DoneOne())
{
fprintf(fp,"\n");
/* Underscores are escaped in method names, see
http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/design.html#wp133
VTK class names contain no underscore and do not need to be escaped. */
jniFunction = currentFunction->Name;
begPtr = currentFunction->Name;
endPtr = strchr(begPtr, '_');
if(endPtr)
{
jniFunction = (char *)malloc(2*strlen(currentFunction->Name) + 1);
jniFunction[0] = '\0';
while (endPtr)
{
strncat(jniFunction, begPtr, endPtr - begPtr + 1);
strcat(jniFunction, "1");
begPtr = endPtr + 1;
endPtr = strchr(begPtr, '_');
}
strcat(jniFunction, begPtr);
}
if(currentFunction->IsLegacy)
{
fprintf(fp,"#if !defined(VTK_LEGACY_REMOVE)\n");
}
fprintf(fp,"extern \"C\" JNIEXPORT ");
return_result(fp);
fprintf(fp," JNICALL Java_vtk_%s_%s_1%i(JNIEnv *env, jobject obj",
data->ClassName, jniFunction, numberOfWrappedFunctions);
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
fprintf(fp,",");
output_proto_vars(fp, i);
}
fprintf(fp,")\n{\n");
/* get the object pointer */
fprintf(fp," %s *op;\n",data->ClassName);
/* process the args */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
output_temp(fp, i, currentFunction->ArgTypes[i],
currentFunction->ArgClasses[i],
currentFunction->ArgCounts[i]);
}
output_temp(fp, MAX_ARGS,currentFunction->ReturnType,
currentFunction->ReturnClass,0);
/* now get the required args from the stack */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
get_args(fp, i);
}
fprintf(fp,"\n op = (%s *)vtkJavaGetPointerFromObject(env,obj);\n",
data->ClassName);
switch (currentFunction->ReturnType % 0x1000)
{
case 0x2:
fprintf(fp," op->%s(",currentFunction->Name);
break;
case 0x109:
fprintf(fp," temp%i = &(op)->%s(",MAX_ARGS, currentFunction->Name);
break;
default:
fprintf(fp," temp%i = (op)->%s(",MAX_ARGS, currentFunction->Name);
}
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
if (i)
{
fprintf(fp,",");
}
if (currentFunction->ArgTypes[i] % 0x1000 == 0x109)
{
fprintf(fp,"*(temp%i)",i);
}
else if (currentFunction->ArgTypes[i] == 0x5000)
{
fprintf(fp,"vtkJavaVoidFunc,(void *)temp%i",i);
}
else
{
fprintf(fp,"temp%i",i);
}
} /* for */
fprintf(fp,");\n");
if (currentFunction->NumberOfArguments == 1 && currentFunction->ArgTypes[0] == 0x5000)
{
fprintf(fp," op->%sArgDelete(vtkJavaVoidFuncArgDelete);\n",
jniFunction);
}
/* now copy and release any arrays */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
copy_and_release_args(fp, i);
}
do_return(fp);
fprintf(fp,"}\n");
if(currentFunction->IsLegacy)
{
fprintf(fp,"#endif\n");
}
wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
numberOfWrappedFunctions++;
if (jniFunction != currentFunction->Name)
{
free(jniFunction);
}
} /* isDone() */
} /* isAbstract */
}
static void fd_exec(obj_t self, struct thread *thread, obj_t *args)
{
int inpipes[2], outpipes[2], forkresult;
obj_t *oldargs;
oldargs = args - 1;
thread->sp = args + 1;
/* ### Collect some zombie processes before we launch a new
process. Ideally, we'd collect them in a more orderly fashion,
but this will do for now. */
while (waitpid(-1, NULL, WNOHANG) > 0)
;
if (pipe(inpipes) >= 0 && pipe(outpipes) >= 0 &&
(forkresult = fork()) != -1)
{
if (forkresult == 0) {
/* This process is going to exit shortly, so we needn't be too
careful about malloc behavior, nor about the fact that we
destructively modify the command string. */
char *command = string_chars(args[0]);
char *p, **args;
int argcounter = 1;
for (p = command; *p != 0; p++)
if (*p == ' ') {
argcounter++;
while (*(++p) == ' ');
}
args = (char **) calloc(argcounter+1, sizeof(char *));
args[0] = command;
for (p = command, argcounter = 1; *p != 0; p++) {
if (*p == ' ') {
*p = 0;
while (*(++p) == ' ');
if (*p != 0)
args[argcounter++] = p;
}
}
args[argcounter] = 0;
close(0);
dup(inpipes[0]);
close(inpipes[0]);
close(inpipes[1]);
close(1);
dup(outpipes[1]);
close(outpipes[0]);
close(outpipes[1]);
/* Put the child in its own session so that signals don't hit it */
setsid();
execvp(args[0], args);
/* If we get here, execvp failed, so shut down as
* gracefully as we can
*/
exit(1);
}
close(inpipes[0]);
close(outpipes[1]);
oldargs[0] = make_fixnum(inpipes[1]);
oldargs[1] = make_fixnum(outpipes[0]);
} else {
oldargs[0] = obj_False;
oldargs[1] = obj_False;
}
do_return(thread, oldargs, oldargs);
}
void outputFunction2(FILE *fp, FileInfo *data)
{
int i, j, k, is_static, is_vtkobject, fnum, occ, backnum, goto_used;
int all_legacy;
FunctionInfo *theFunc;
FunctionInfo *backFunc;
is_vtkobject = ((strcmp(data->ClassName,"vtkObjectBase") == 0) ||
(data->NumberOfSuperClasses != 0));
/* create a python-type signature for each method (for use in docstring) */
for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
{
theFunc = wrappedFunctions[fnum];
currentFunction = theFunc;
get_python_signature();
}
/* create external type declarations for all object
return types */
for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
{
theFunc = wrappedFunctions[fnum];
currentFunction = theFunc;
/* check for object return types */
if ((theFunc->ReturnType % 0x1000 == 0x309)||
(theFunc->ReturnType % 0x1000 == 0x109))
{
/* check that we haven't done this type (no duplicate declarations) */
for (backnum = fnum-1; backnum >= 0; backnum--)
{
backFunc = wrappedFunctions[backnum];
if (((backFunc->ReturnType % 0x1000 == 0x309)||
(backFunc->ReturnType % 0x1000 == 0x109)) &&
(strcmp(theFunc->ReturnClass,backFunc->ReturnClass) == 0))
{
break;
}
}
}
}
/* for each function in the array */
for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
{
/* make sure we haven't already done one of these */
theFunc = wrappedFunctions[fnum];
currentFunction = theFunc;
if (theFunc->Name)
{
fprintf(fp,"\n");
/* check whether all signatures are static methods or legacy */
is_static = 1;
all_legacy = 1;
for (occ = fnum; occ < numberOfWrappedFunctions; occ++)
{
/* is it the same name */
if (wrappedFunctions[occ]->Name &&
!strcmp(theFunc->Name,wrappedFunctions[occ]->Name))
{
/* check for static methods */
if (((wrappedFunctions[occ]->ReturnType/0x1000) & 0x2) != 0x2)
{
is_static = 0;
}
/* check for legacy */
if (!wrappedFunctions[occ]->IsLegacy)
{
all_legacy = 0;
}
}
}
if(all_legacy)
{
fprintf(fp,"#if !defined(VTK_LEGACY_REMOVE)\n");
}
fprintf(fp,"static PyObject *Py%s_%s(PyObject *%s, PyObject *args)\n",
data->ClassName,currentFunction->Name,
(is_static ? "" : "self"));
fprintf(fp,"{\n");
/* find all occurances of this method */
for (occ = fnum; occ < numberOfWrappedFunctions; occ++)
{
goto_used = 0;
is_static = 0;
/* is it the same name */
if (wrappedFunctions[occ]->Name &&
!strcmp(theFunc->Name,wrappedFunctions[occ]->Name))
{
/* check for static methods */
if (((wrappedFunctions[occ]->ReturnType/0x1000) & 0x2) == 0x2)
{
is_static = 1;
}
currentFunction = wrappedFunctions[occ];
if(currentFunction->IsLegacy && !all_legacy)
{
fprintf(fp,"#if defined(VTK_LEGACY_REMOVE)\n");
/* avoid warnings if all signatures are legacy and removed */
if(!is_static)
{
fprintf(fp,
" (void)self;"
" /* avoid warning if all signatures removed */\n");
}
fprintf(fp,
" (void)args;"
" /* avoid warning if all signatures removed */\n");
fprintf(fp,"#else\n");
}
fprintf(fp," /* handle an occurrence */\n {\n");
/* declare the variables */
if (!is_static)
{
if (is_vtkobject)
{
fprintf(fp," %s *op;\n\n",data->ClassName);
}
else
{
fprintf(fp," %s *op = (%s *)((PyVTKSpecialObject *)self)->vtk_ptr;\n\n",data->ClassName,data->ClassName);
}
}
/* process the args */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
output_temp(fp, i, currentFunction->ArgTypes[i],
currentFunction->ArgClasses[i],
currentFunction->ArgCounts[i]);
}
output_temp(fp, MAX_ARGS,currentFunction->ReturnType,
currentFunction->ReturnClass,0);
/* don't clear error first time around */
if (occ != fnum)
{
fprintf(fp," PyErr_Clear();\n");
}
if (is_static || !is_vtkobject)
{
fprintf(fp," if ((PyArg_ParseTuple(args, (char*)\"%s\"",
get_format_string());
}
else
{
fprintf(fp," op = (%s *)PyArg_VTKParseTuple(self, args, (char*)\"%s\"",
data->ClassName,get_format_string());
}
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
if ((currentFunction->ArgTypes[i] % 0x1000 == 0x309)||
(currentFunction->ArgTypes[i] % 0x1000 == 0x109))
{
fprintf(fp,", &tempH%d",i);
}
else if (currentFunction->ArgTypes[i] % 0x1000 == 0x302)
{
fprintf(fp,", &temp%d, &size%d",i,i);
}
else
{
if (currentFunction->ArgCounts[i])
{
for (j = 0; j < currentFunction->ArgCounts[i]; j++)
{
fprintf(fp,", temp%d + %d",i,j);
}
}
else
{
fprintf(fp,", &temp%d",i);
}
}
}
if (is_static || !is_vtkobject)
{
fprintf(fp,")))\n {\n");
}
else
{
fprintf(fp,");\n");
fprintf(fp," if (op)\n {\n");
}
/* lookup and required objects */
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
if ((currentFunction->ArgTypes[i] % 0x1000 == 0x309)||
(currentFunction->ArgTypes[i] % 0x1000 == 0x109))
{
fprintf(fp," temp%d = (%s *)vtkPythonGetPointerFromObject(tempH%d,(char*)\"%s\");\n",
i, currentFunction->ArgClasses[i], i,
currentFunction->ArgClasses[i]);
fprintf(fp," if (!temp%d && tempH%d != Py_None) goto break%d;\n",i,i,occ);
goto_used = 1;
}
}
/* make sure passed method is callable for VAR functions */
if (currentFunction->NumberOfArguments == 0x1 &&
currentFunction->ArgTypes[0] == 0x5000)
{
fprintf(fp," if (!PyCallable_Check(temp0) && temp0 != Py_None)\n");
fprintf(fp," {\n PyErr_SetString(PyExc_ValueError,\"vtk callback method passed to %s in %s was not callable.\");\n",
currentFunction->Name,data->ClassName);
fprintf(fp," return NULL;\n }\n");
fprintf(fp," Py_INCREF(temp0);\n");
}
/* check for void pointers and pass appropriate info*/
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
if (currentFunction->ArgTypes[i] % 0x1000 == 0x302)
{
fprintf(fp," temp%i = vtkPythonUnmanglePointer((char *)temp%i,&size%i,(char*)\"%s\");\n",i,i,i,"void_p");
fprintf(fp," if (size%i == -1) {\n PyErr_SetString(PyExc_ValueError,\"mangled pointer to %s in %s was of incorrect type.\");\n",
i,currentFunction->Name,data->ClassName);
fprintf(fp," return NULL;\n }\n");
fprintf(fp," else if (size%i == -2) {\n PyErr_SetString(PyExc_ValueError,\"mangled pointer to %s in %s was poorly formed.\");\n",
i,currentFunction->Name,data->ClassName);
fprintf(fp," return NULL;\n }\n");
}
}
for (k = 0; k < (2 - (is_static || !is_vtkobject)); k++)
{
char methodname[256];
if (k == 0)
{
if (is_static)
{
fprintf(fp," {\n");
sprintf(methodname,"%s::%s",
data->ClassName,currentFunction->Name);
}
else if (!is_vtkobject)
{
fprintf(fp," {\n");
sprintf(methodname,"op->%s",currentFunction->Name);
}
else
{
if (currentFunction->IsPureVirtual)
{
fprintf(fp," if (PyVTKClass_Check(self))\n {\n");
fprintf(fp," PyErr_SetString(PyExc_TypeError,\"pure virtual method call\");\n");
fprintf(fp," return NULL;\n }\n");
continue;
}
else
{
fprintf(fp," if (PyVTKClass_Check(self))\n {\n");
sprintf(methodname,"op->%s::%s",
data->ClassName,currentFunction->Name);
}
}
}
else
{
fprintf(fp," else\n {\n");
sprintf(methodname,"op->%s",currentFunction->Name);
}
switch (currentFunction->ReturnType % 0x1000)
{
case 0x2:
fprintf(fp," %s(",methodname);
break;
case 0x109:
fprintf(fp," temp%i = &%s(",MAX_ARGS,methodname);
break;
default:
fprintf(fp," temp%i = %s(",MAX_ARGS,methodname);
}
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
if (i)
{
fprintf(fp,",");
}
if (currentFunction->ArgTypes[i] % 0x1000 == 0x109)
{
fprintf(fp,"*(temp%i)",i);
}
else if (currentFunction->NumberOfArguments == 1
&& currentFunction->ArgTypes[i] == 0x5000)
{
fprintf(fp,"((temp0 != Py_None) ? vtkPythonVoidFunc : NULL),(void *)temp%i",i);
}
else
{
fprintf(fp,"temp%i",i);
}
}
fprintf(fp,");\n");
if (currentFunction->NumberOfArguments == 1
&& currentFunction->ArgTypes[0] == 0x5000)
{
fprintf(fp," %sArgDelete(vtkPythonVoidFuncArgDelete);\n",
methodname);
}
fprintf(fp," }\n");
}
for (i = 0; i < currentFunction->NumberOfArguments; i++)
{
if (currentFunction->ArgCounts[i] && /* array */
currentFunction->ArgTypes[i] % 0x10 != 0 && /* not a special type */
currentFunction->ArgTypes[i] % 0x10 != 0x9 && /* not class pointer */
currentFunction->ArgTypes[i] % 0x10 != 0x8 &&
currentFunction->ArgTypes[i] % 0x10 != 0x2 && /* not void pointer */
(currentFunction->ArgTypes[i] % 0x2000 < 0x1000)) /* not const */
{
fprintf(fp," if (vtkPythonCheckArray(args,%d,temp%d,%d)) {\n"
" return 0;\n"
" }\n", i, i, currentFunction->ArgCounts[i]);
}
}
do_return(fp);
fprintf(fp," }\n }\n");
if (goto_used)
{
fprintf(fp," break%d:\n",occ);
}
if(currentFunction->IsLegacy && !all_legacy)
{
fprintf(fp,"#endif\n");
}
}
}
fprintf(fp," return NULL;\n}\n");
if(all_legacy)
{
fprintf(fp,"#endif\n");
}
fprintf(fp,"\n");
/* clear all occurances of this method from further consideration */
for (occ = fnum + 1; occ < numberOfWrappedFunctions; occ++)
{
/* is it the same name */
if (wrappedFunctions[occ]->Name &&
!strcmp(theFunc->Name,wrappedFunctions[occ]->Name))
{
size_t siglen = strlen(wrappedFunctions[fnum]->Signature);
/* memory leak here but ... */
wrappedFunctions[occ]->Name = NULL;
wrappedFunctions[fnum]->Signature = (char *)
realloc(wrappedFunctions[fnum]->Signature,siglen+3+
strlen(wrappedFunctions[occ]->Signature));
strcpy(&wrappedFunctions[fnum]->Signature[siglen],"\\n");
strcpy(&wrappedFunctions[fnum]->Signature[siglen+2],
wrappedFunctions[occ]->Signature);
}
}
} /* is this method non NULL */
} /* loop over all methods */
/* output the method table */
/* for each function in the array */
fprintf(fp,"static PyMethodDef Py%sMethods[] = {\n",data->ClassName);
for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
{
if(wrappedFunctions[fnum]->IsLegacy)
{
fprintf(fp,"#if !defined(VTK_LEGACY_REMOVE)\n");
}
if (wrappedFunctions[fnum]->Name)
{
fprintf(fp," {(char*)\"%s\", (PyCFunction)Py%s_%s, 1,\n (char*)\"%s\\n\\n%s\"},\n",
wrappedFunctions[fnum]->Name, data->ClassName,
wrappedFunctions[fnum]->Name, wrappedFunctions[fnum]->Signature,
quote_string(wrappedFunctions[fnum]->Comment,1000));
}
if(wrappedFunctions[fnum]->IsLegacy)
{
fprintf(fp,"#endif\n");
}
}
if (!strcmp("vtkObject",data->ClassName))
{
fprintf(fp," {(char*)\"AddObserver\", (PyCFunction)Py%s_AddObserver, 1,\n (char*)\"V.AddObserver(int, function) -> int\\n\\n Add an event callback function(vtkObject, int) for an event type.\\n Returns a handle that can be used with RemoveEvent(int).\"},\n", data->ClassName);
}
else if (!strcmp("vtkObjectBase",data->ClassName))
{
fprintf(fp," {(char*)\"GetAddressAsString\", (PyCFunction)Py%s_GetAddressAsString, 1,\n (char*)\"V.GetAddressAsString(string) -> string\\n\\n Get address of C++ object in format 'Addr=%%p' after casting to\\n the specified type. You can get the same information from V.__this__.\"},\n", data->ClassName);
fprintf(fp," {(char*)\"PrintRevisions\", (PyCFunction)Py%s_PrintRevisions, 1,\n (char*)\"V.PrintRevisions() -> string\\n\\n Prints the .cxx file CVS revisions of the classes in the\\n object's inheritance chain.\"},\n", data->ClassName);
}
fprintf(fp," {NULL, NULL, 0, NULL}\n};\n\n");
}
/* Extract a ch completely from the world, and leave his stuff behind */
void extract_char(struct char_data * ch)
{
struct char_data *k, *temp;
struct descriptor_data *t_desc;
struct obj_data *obj;
int i, freed = 0;
//int j;
extern struct char_data *combat_list;
ACMD(do_return);
void die_follower(struct char_data * ch);
if (!IS_NPC(ch) && !ch->desc) {
for (t_desc = descriptor_list; t_desc; t_desc = t_desc->next) {
if (t_desc->original == ch) {
do_return(t_desc->character, "", 0, 0);
}
}
}
if (ch->in_room == NOWHERE) {
log("SYSERR: NOWHERE extracting char. (handler.c, extract_char)");
exit(1);
}
if (ch->followers || ch->master) {
die_follower(ch);
}
if (RIDING(ch) || RIDDEN_BY(ch))
dismount_char(ch);
REMOVE_BIT(PLR_FLAGS(ch), PLR_FISHING);
REMOVE_BIT(PLR_FLAGS(ch), PLR_FISH_ON);
REMOVE_BIT(PLR_FLAGS(ch), PLR_DIGGING);
REMOVE_BIT(PLR_FLAGS(ch), PLR_DIG_ON);
REMOVE_BIT(PLR_FLAGS(ch), PLR_FIRE_ON);
REMOVE_BIT(PRF_FLAGS(ch), PRF_NOTSELF);
//REMOVE_BIT(PRF_FLAGS(ch), PRF_DISGUISE);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_MAGE);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_MONK);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_KNIGHT);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_CLERIC);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_BARD);
//REMOVE_BIT(PLR_FLAGS(ch), PLR_BEGGAR);
REMOVE_BIT(PLR_FLAGS(ch), PLR_COURIER);
REMOVE_BIT(PLR_FLAGS(ch), PLR_BEAR);
REMOVE_BIT(PLR_FLAGS(ch), PLR_BIRD);
REMOVE_BIT(PLR_FLAGS(ch), PLR_WOLF);
REMOVE_BIT(PLR_FLAGS(ch), PLR_RABBIT);
REMOVE_BIT(PLR_FLAGS(ch), PLR_CAT);
/* Forget snooping, if applicable */
if (ch->desc) {
if (ch->desc->snooping) {
ch->desc->snooping->snoop_by = NULL;
ch->desc->snooping = NULL;
}
if (ch->desc->snoop_by) {
SEND_TO_Q("Your victim is no longer among us.\r\n",
ch->desc->snoop_by);
ch->desc->snoop_by->snooping = NULL;
ch->desc->snoop_by = NULL;
}
}
/* transfer objects to room, if any */
while (ch->carrying) {
obj = ch->carrying;
obj_from_char(obj);
obj_to_room(obj, ch->in_room);
}
/* transfer equipment to room, if any */
for (i = 0; i < NUM_WEARS; i++) {
if (GET_EQ(ch, i)) {
obj_to_room(unequip_char(ch, i), ch->in_room);
}
}
if (FIGHTING(ch)) {
stop_fighting(ch);
}
for (k = combat_list; k; k = temp) {
temp = k->next_fighting;
if (FIGHTING(k) == ch) {
stop_fighting(k);
}
}
char_from_room(ch);
/* pull the char from the list */
REMOVE_FROM_LIST(ch, character_list, next);
if (ch->desc && ch->desc->original) {
do_return(ch, NULL, 0, 0);
}
if (!IS_NPC(ch)) {
save_char(ch, NOWHERE);
Crash_delete_crashfile(ch);
} else {
if (GET_MOB_RNUM(ch) > -1) { /* if mobile */
mob_index[GET_MOB_RNUM(ch)].number--;
}
clearMemory(ch); /* Only NPC's can have memory */
if (SCRIPT(ch)) {
extract_script(SCRIPT(ch));
}
free_char(ch);
freed = 1;
}
if (!freed && ch->desc != NULL) {
STATE(ch->desc) = CON_MENU;
SEND_TO_Q(MENU, ch->desc);
} else { /* if a player gets purged from within the game */
if (ch->master || ch->followers)
die_follower(ch);
if (!freed) {
free_char(ch);
}
}
}
/* Extract a ch completely from the world, and leave his stuff behind */
void extract_char_smarter(struct char_data *ch, int save_room)
{
struct obj_data *i;
struct char_data *k, *next_char;
struct descriptor_data *t_desc;
int l, was_in, j;
extern long mob_count;
extern struct char_data *combat_list;
void do_save(struct char_data *ch, char *argument, int cmd);
void do_return(struct char_data *ch, char *argument, int cmd);
void die_follower(struct char_data *ch);
if(IS_SET(ch->specials.act, ACT_FIGURINE) && ch->link)
extract_obj(ch->link);
if(!IS_NPC(ch) && !ch->desc) {
for(t_desc = descriptor_list; t_desc; t_desc = t_desc->next)
if(t_desc->original==ch)
do_return(t_desc->character, "", 0);
}
if (ch->in_room == NOWHERE) {
logE("NOWHERE extracting char. (handler.c, extract_char)");
/*
** problem from linkdeath
*/
char_to_room(ch, 4); /* 4 == all purpose store */
}
if (ch->followers || ch->master)
die_follower(ch);
if(ch->desc) {
/* Forget snooping */
if ((ch->desc->snoop.snooping) && (ch->desc->snoop.snooping->desc))
ch->desc->snoop.snooping->desc->snoop.snoop_by = 0;
if (ch->desc->snoop.snoop_by) {
send_to_char("Your victim is no longer among us.\n\r",
ch->desc->snoop.snoop_by);
if (ch->desc->snoop.snoop_by->desc)
ch->desc->snoop.snoop_by->desc->snoop.snooping = 0;
}
ch->desc->snoop.snooping = ch->desc->snoop.snoop_by = 0;
}
if (ch->carrying) {
/* transfer ch's objects to room */
if (!IS_IMMORTAL(ch)) {
while(ch->carrying) {
i=ch->carrying;
obj_from_char(i);
obj_to_room(i, ch->in_room);
check_falling_obj(i, ch->in_room);
}
} else {
send_to_char("Here, you dropped some stuff, let me help you get rid of that.\n\r",ch);
/*
equipment too
*/
for (j=0; j<MAX_WEAR; j++) {
if (ch->equipment[j])
obj_to_char(unequip_char(ch, j), ch);
}
while (ch->carrying) {
i = ch->carrying;
obj_from_char(i);
extract_obj(i);
}
}
}
if (ch->specials.fighting)
stop_fighting(ch);
for (k = combat_list; k ; k = next_char) {
next_char = k->next_fighting;
if (k->specials.fighting == ch)
stop_fighting(k);
}
if (MOUNTED(ch)) {
Dismount(ch, MOUNTED(ch), POSITION_STANDING);
}
if (RIDDEN(ch)) {
Dismount(RIDDEN(ch), ch, POSITION_STANDING);
}
/* Must remove from room before removing the equipment! */
was_in = ch->in_room;
char_from_room(ch);
/* clear equipment_list */
for (l = 0; l < MAX_WEAR; l++)
if (ch->equipment[l])
obj_to_room(unequip_char(ch,l), was_in);
if (IS_NPC(ch)) {
for (k=character_list; k; k=k->next) {
if (k->specials.hunting)
if (k->specials.hunting == ch) {
k->specials.hunting = 0;
}
if (Hates(k, ch)) {
RemHated(k, ch);
}
if (Fears(k, ch)) {
RemFeared(k, ch);
}
if (k->orig == ch) {
k->orig = 0;
}
}
} else {
for (k=character_list; k; k=k->next) {
if (k->specials.hunting)
if (k->specials.hunting == ch) {
k->specials.hunting = 0;
}
if (Hates(k, ch)) {
ZeroHatred(k, ch);
}
if (Fears(k, ch)) {
ZeroFeared(k, ch);
}
if (k->orig == ch) {
k->orig = 0;
}
}
}
/* pull the char from the list */
if (ch == character_list)
character_list = ch->next;
else {
for(k = character_list; (k) && (k->next != ch); k = k->next);
if(k)
k->next = ch->next;
else {
logE("Trying to remove ?? from character_list.(handler.c,extract_char)");
exit(0);
}
}
if (ch->specials.gname)
free(ch->specials.gname);
GET_AC(ch) = 100;
if (ch->desc) {
if (ch->desc->original)
do_return(ch, "", 0);
if (!strcmp(GET_NAME(ch), "Odin's heroic minion")) {
free(GET_NAME(ch));
GET_NAME(ch) = strdup("111111");
}
save_char(ch, save_room);
}
t_desc = ch->desc;
if(ch->term) {
ScreenOff(ch);
ch->term = 0;
}
if (IS_NPC(ch)) {
if (ch->nr > -1) /* if mobile */
mob_index[ch->nr].number--;
FreeHates(ch);
FreeFears(ch);
mob_count--;
free_char(ch);
}
if (t_desc) {
t_desc->connected = CON_SLCT;
SEND_TO_Q(MENU, t_desc);
}
}
