//deep-bindによる。シンボルが見つからなかったら登録。
//見つかったらそこに値をいれておく。
void bindsym(int symaddr, int valaddr){
int addr,num;
char *name;
name = symname(symaddr);
if((addr=findsym(name)) == NIL){
addr = freshcell();
SET_NAME(addr,name);
SET_CDR(addr,E);
E = addr;
}
switch(GET_TAG(valaddr)){
case NUM: { SET_TAG(addr,NUM);
num = GET_NUMBER(valaddr);
SET_NUMBER(addr,num);
break; }
case SYM: { SET_TAG(addr,SYM);
name = GET_NAME(valaddr);
SET_NAME(addr,name);
break; }
case LIS: { SET_TAG(addr,LIS);
SET_BIND(addr,valaddr);
break; }
}
}
int makesym(char *name){
int addr;
addr = freshcell();
SET_TAG(addr,SYM);
SET_NAME(addr,name);
return(addr);
}
//空リストを作る。シンボルnilを空リストとも解釈している。
int makeempty(void){
int addr;
addr = freshcell();
SET_TAG(addr,SYM);
SET_NAME(addr,"nil");
return(addr);
}
//シンボルＴを返す。
int makeT(void){
int addr;
addr = freshcell();
SET_TAG(addr,SYM);
SET_NAME(addr,"t");
return(addr);
}
static void *
sock_write(void *arg)
{
int fd = *(int *)arg;
SET_NAME("writer");
CHECKe(write(fd, MESSAGE5, sizeof(MESSAGE5)));
return(NULL);
}
void initcell(void){
int addr,addr1;
for(addr=0; addr < HEAPSIZE; addr++){
heap[addr].tag = EMP;
heap[addr].cdr = addr+1;
}
H = 0;
//0番地はnil、1番地はＴとして環境レジスタを設定する。初期環境
addr = freshcell(); //symbol nil
SET_TAG(addr,SYM);
SET_NAME(addr,"nil");
addr1 = freshcell(); //symbol t
SET_TAG(addr1,SYM);
SET_NAME(addr1,"t");
SET_CDR(addr1,addr);
E = addr1;
}
/*
* Install a signal handler for sigusr1 and then wait for it to
* occur.
*/
static void *
do_nothing (void *arg)
{
SET_NAME("nothing");
ASSERT(signal(SIGUSR1, sighandler) != SIG_ERR);
CHECKr(pthread_mutex_lock(&sync_mutex));
ASSERT(got_signal != 0);
CHECKr(pthread_mutex_unlock(&sync_mutex));
return 0;
}
bool apoAttrCalcHelper::InitAttrNode(attrid_t aid, const char *name, const char*realName, const char *formula)
{
if (aid >= APO_ATTR_CAPACITY) {
return false;
}
role_attr_description node;
node.wa_id = aid;
#define SET_NAME(_NAME,_INPUTNAME) if(_INPUTNAME && *_INPUTNAME) {node._NAME = _INPUTNAME;}
SET_NAME(name, name);
SET_NAME(real_name, realName);
SET_NAME(input_for, formula);
m_wahelper_bufs[aid] = node;
int curNum = aid + 1;
if (m_wa_num < curNum) {
m_wa_num = curNum;
}
return true;
}
static void *
thread_contention(void *arg)
{
pthread_mutex_t *mutex = arg;
SET_NAME("cntntn");
CHECKr(pthread_mutex_lock(mutex));
ASSERT(contention_variable == 1);
contention_variable = 2;
CHECKr(pthread_mutex_unlock(mutex));
pthread_exit(NULL);
}
static void *
new_thread(void *arg)
{
int i;
SET_NAME("writer");
while (!ending) {
CHECKe(write (fd, (char *) arg, 1));
x[(char *)arg - buf] = 1;
for (i = 0; i < 999999; i += 1)
;
}
return NULL;
}
void bindfunc(char *name, ftype ftype, int func){
int addr;
addr = freshcell();
SET_NAME(addr,name);
SET_TAG(addr,FUN);
SET_FTYPE(addr,ftype);
switch(ftype){
case SUBR:
case FSUBR: SET_SUBR(addr,func);
case LAMBDA: SET_BIND(addr,func);
}
SET_CDR(addr,E);
E = addr;
}
static void *
waiter(void *arg)
{
int status;
pid_t pid;
SET_NAME("waiter");
CHECKr(pthread_mutex_lock(&waiter_mutex));
printf("waiting for child\n");
CHECKe(pid = wait(&status));
ASSERT(WIFEXITED(status));
ASSERT(WEXITSTATUS(status) == 0);
printf("child exited\n");
CHECKr(pthread_mutex_unlock(&waiter_mutex));
return (NULL);
}
static void *
thread(void * arg)
{
sigset_t run_mask;
sigset_t suspender_mask;
/* wait for sigusr1 */
SET_NAME(arg);
/* Run with all signals blocked, then suspend for SIGUSR1 */
sigfillset(&run_mask);
CHECKe(sigprocmask(SIG_SETMASK, &run_mask, NULL));
sigfillset(&suspender_mask);
sigdelset(&suspender_mask, SIGUSR1);
for (;;) {
sigsuspend(&suspender_mask);
ASSERT(errno == EINTR);
printf("Thread %s woke up\n", (char*) arg);
}
}
static void *
sigsuspender (void *arg)
{
int save_count, status, i;
sigset_t run_mask;
SET_NAME("sigsuspender");
/* Run with all signals blocked. */
sigfillset (&run_mask);
CHECKe(sigprocmask (SIG_SETMASK, &run_mask, NULL));
/* Allow these signals to wake us up during a sigsuspend. */
sigfillset (&suspender_mask); /* Default action */
sigdelset (&suspender_mask, SIGINT); /* terminate */
sigdelset (&suspender_mask, SIGHUP); /* terminate */
sigdelset (&suspender_mask, SIGQUIT); /* create core image */
sigdelset (&suspender_mask, SIGURG); /* ignore */
sigdelset (&suspender_mask, SIGIO); /* ignore */
sigdelset (&suspender_mask, SIGUSR2); /* terminate */
sigdelset (&suspender_mask, SIGSTOP); /* unblockable */
sigdelset (&suspender_mask, SIGKILL); /* unblockable */
while (sigcounts[SIGINT] == 0) {
save_count = sigcounts[SIGUSR2];
status = sigsuspend (&suspender_mask);
if ((status == 0) || (errno != EINTR)) {
DIE(errno, "Unable to suspend for signals, "
"return value %d\n",
status);
}
for (i = 0; i < fifo_depth; i++)
printf ("Sigsuspend woke up by signal %d (%s)\n",
sigfifo[i], strsignal(sigfifo[i]));
fifo_depth = 0;
}
return (arg);
}
static void *
sigwaiter (void *arg)
{
int signo;
SET_NAME("sigwaiter");
/* Block all of the signals that the function will wait for */
CHECKe(sigprocmask (SIG_BLOCK, &wait_mask, NULL));
while (sigcounts[SIGINT] == 0) {
printf("Sigwait waiting (thread %p)\n", pthread_self());
CHECKe(sigwait (&wait_mask, &signo));
sigcounts[signo]++;
printf ("Sigwait caught signal %d (%s)\n", signo,
strsignal(signo));
/* Allow the main thread to prevent the sigwait. */
CHECKr(pthread_mutex_lock (&waiter_mutex));
CHECKr(pthread_mutex_unlock (&waiter_mutex));
}
return (arg);
}
