static int
unregister_process(DWORD pid)
{ win_process **wpp, *wp;
LOCK();
for(wpp=&processes, wp=*wpp; wp; wpp=&wp->next, wp=*wpp)
{ if ( wp->pid == pid )
{ *wpp = wp->next;
PL_free(wp);
UNLOCK();
return TRUE;
}
}
UNLOCK();
return FALSE;
}
static int
release_archive(atom_t symbol)
{ archive_wrapper *ar = PL_blob_data(symbol, NULL, NULL);
struct archive *a;
assert(ar->status != AR_OPENED_ENTRY);
if ( (a=ar->archive) )
{ ar->archive = NULL;
archive_read_free(a);
}
free_archive(ar);
PL_free(ar);
return TRUE;
}
void
cleanupFunctors(void)
{ FunctorTable table = functorDefTable;
if ( table )
{ int i;
int builtin_count = sizeof(functors)/sizeof(builtin_functor) - 1;
FunctorDef builtin = GD->functors.array.blocks[0][1];
FunctorDef builtin_end = builtin+builtin_count;
FunctorDef *fp0;
freeHeap(builtin, builtin_count * sizeof(struct functorDef));
for(i=0; (fp0=GD->functors.array.blocks[i]); i++)
{ size_t bs = (size_t)1<<i;
size_t upto = (size_t)2<<i;
FunctorDef *fp, *ep;
fp0 += bs;
fp = fp0;
ep=fp+bs;
if ( upto > GD->functors.highest )
ep -= upto-GD->functors.highest;
for(; fp<ep; fp++)
{ FunctorDef f = *fp;
if ( !(f>=builtin && f<=builtin_end) )
freeHeap(f, sizeof(*f));
}
GD->functors.array.blocks[i] = NULL;
PL_free(fp0);
}
while ( table )
{ FunctorTable prev = table->prev;
freeHeap(table->table, table->buckets * sizeof(FunctorDef));
freeHeap(table, sizeof(functor_table));
table = prev;
}
table = NULL;
}
}
static int
win_exec(size_t len, const wchar_t *cmd, UINT show)
{ GET_LD
STARTUPINFOW startup;
PROCESS_INFORMATION info;
int rval;
wchar_t *wcmd;
memset(&startup, 0, sizeof(startup));
startup.cb = sizeof(startup);
startup.wShowWindow = show;
/* ensure 0-terminated */
wcmd = PL_malloc((len+1)*sizeof(wchar_t));
memcpy(wcmd, cmd, len*sizeof(wchar_t));
wcmd[len] = 0;
rval = CreateProcessW(NULL, /* app */
wcmd,
NULL, NULL, /* security */
FALSE, /* inherit handles */
0, /* flags */
NULL, /* environment */
NULL, /* Directory */
&startup,
&info); /* process info */
PL_free(wcmd);
if ( rval )
{ CloseHandle(info.hProcess);
CloseHandle(info.hThread);
succeed;
} else
{ term_t tmp = PL_new_term_ref();
return ( PL_unify_wchars(tmp, PL_ATOM, len, cmd) &&
PL_error(NULL, 0, WinError(), ERR_SHELL_FAILED, tmp)
);
}
}
static int
attach_console(void)
{ static int done = 0;
switch(done)
{ case 0:
if ( AllocConsole() )
{ cin = GetStdHandle(STD_INPUT_HANDLE);
cout = GetStdHandle(STD_OUTPUT_HANDLE);
cerr = GetStdHandle(STD_ERROR_HANDLE);
if ( cin != INVALID_HANDLE_VALUE &&
cerr != INVALID_HANDLE_VALUE &&
cout != INVALID_HANDLE_VALUE )
{ use_console = C_ATTACHED;
done = 1;
if ( recall_buffer.size )
{ write_console(Soutput, recall_buffer.data, recall_buffer.size);
recall_buffer.size = 0;
recall_buffer.allocated = 0;
PL_free(recall_buffer.data);
recall_buffer.data = NULL;
}
return TRUE;
}
}
done = -1;
return FALSE;
case 1:
return TRUE; /* already done so */
default:
return FALSE; /* tried but failed */
}
}
static void
free_options(p_options *info) /* TBD: close streams */
{ if ( info->exe )
{ PL_free(info->exe);
info->exe = NULL;
}
if ( info->cwd )
{ PL_free(info->cwd);
info->cwd = NULL;
}
#ifndef __WINDOWS__
if ( info->envp )
{ PL_free(info->envp);
info->envp = NULL;
}
#endif
free_ecbuf(&info->envbuf);
#ifdef __WINDOWS__
if ( info->cmdline )
{ PL_free(info->cmdline);
info->cmdline = NULL;
}
#else /*__WINDOWS__*/
if ( info->argv )
{ char **a;
for(a=info->argv; *a; a++)
{ if ( *a )
PL_free(*a);
}
PL_free(info->argv);
info->argv = NULL;
}
#endif /*__WINDOWS__*/
}
static int
win_command_line(term_t t, int arity, const wchar_t *exe, wchar_t **cline)
{ if ( arity > 0 )
{ arg_string *av = PL_malloc((arity+1)*sizeof(*av));
term_t arg = PL_new_term_ref();
size_t cmdlen;
wchar_t *cmdline, *o;
const wchar_t *b;
int i;
if ( (b=wcsrchr(exe, '\\')) )
b++;
else
b = exe;
av[0].text = (wchar_t*)b;
av[0].len = wcslen(av[0].text);
set_quote(&av[0]);
cmdlen = av[0].len+(av[0].quote?2:0)+1;
for( i=1; i<=arity; i++)
{ PL_get_arg(i, t, arg);
if ( !PL_get_wchars(arg, &av[i].len, &av[i].text,
CVT_ATOMIC|CVT_EXCEPTION|BUF_MALLOC) )
return FALSE;
if ( wcslen(av[i].text) != av[i].len )
return domain_error(arg, "no_zero_code_atom");
if ( !set_quote(&av[i]) )
return domain_error(arg, "dos_quotable_atom");
cmdlen += av[i].len+(av[i].quote?2:0)+1;
}
cmdline = PL_malloc(cmdlen*sizeof(wchar_t));
for( o=cmdline,i=0; i<=arity; )
{ wchar_t *s = av[i].text;
if ( av[i].quote )
*o++ = av[i].quote;
wcsncpy(o, s, av[i].len);
o += av[i].len;
if ( i > 0 )
PL_free(s); /* do not free shared exename */
if ( av[i].quote )
*o++ = av[i].quote;
if (++i <= arity)
*o++ = ' ';
}
*o = 0;
PL_free(av);
*cline = cmdline;
} else
{ *cline = NULL;
}
return TRUE;
}
static void
free_charbuf(charbuf *cb)
{ if ( cb->base != cb->tmp )
PL_free(cb->base);
}
static int
destroy_node(ptr_hash_node *node, void *closure)
{ PL_free(node);
return TRUE;
}
