Return to event.c CVS log

Up to [Research Unix] / researchv10no / cmd / cfront / libC / task

Annotation of researchv10no/cmd/cfront/libC/task/event.c, revision 1.1.1.1

1.1       root        1: /*ident        "%W%" */
                      2: /**************************************************************************
                      3:                        Copyright (c) 1984 AT&T
                      4:                          All Rights Reserved   
                      5: 
                      6:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T
                      7:        
                      8:        The copyright notice above does not evidence any        
                      9:        actual or intended publication of such source code.
                     10: 
                     11: *****************************************************************************/
                     12: #include <task.h>
                     13: 
                     14: const  NASS = NSIG;
                     15: 
                     16: static Interrupt_handler*      hnd[NASS];      // hnd[i] is used for signal i
                     17: static SIG_PF  old_handlers[NASS];
                     18: 
                     19: Interrupt_alerter::Interrupt_alerter()
                     20: : ("Interrupt_alerter")
                     21: {
                     22:        for(;;) {
                     23:                sleep();
                     24:                for (register Interrupt_handler** p = &hnd[0]; p < &hnd[NASS]; p++)
                     25:                        if (*p && (*p)->got_interrupt) {
                     26:                                (*p)->alert();
                     27:                        }
                     28:        }
                     29: }
                     30: 
                     31: /* Note:  the type of this function must match the definition of SIG_FUNC_TYP
                     32:    in signal.h. */
                     33: void
                     34: sigFunc(int sigNo)
                     35: {
                     36:        if ((unsigned)sigNo >= (unsigned)NASS)
                     37:                object::task_error(E_BADSIG, (object*)0);
                     38:        Interrupt_handler*      as = hnd[sigNo];
                     39:        if (as == 0)
                     40:                object::task_error(E_NO_HNDLR, (object*)0);
                     41:        as->interrupt();
                     42:        as->got_interrupt = 1;
                     43:        sched::priority_sched = &interrupt_alerter;
                     44:        signal(sigNo, sigFunc);         //reset
                     45:                                        //MORE:  ifdef SVR3 use sigset
                     46: }
                     47: 
                     48: Interrupt_handler::Interrupt_handler(int vecid)
                     49: : id(vecid), got_interrupt(0)
                     50: {
                     51:        if ((unsigned)id >= (unsigned)NASS)
                     52:                task_error(E_BADSIG, this);
                     53:        if((old = hnd[id]) == 0)
                     54:                old_handlers[id] = signal(id, sigFunc);
                     55:        else
                     56:                if (old->got_interrupt) {
                     57:                        old->alert();
                     58:                }
                     59:        hnd[id] = this;
                     60:        this_task()->keep_waiting();
                     61: }
                     62: 
                     63: Interrupt_handler::~Interrupt_handler()
                     64: {
                     65:        this_task()->dont_wait();
                     66:        for(register Interrupt_handler** as = &hnd[id];; as = &(*as)->old) {
                     67:                if (*as == this) break;
                     68:                if (*as == 0)
                     69:                        task_error(E_LOSTHNDLR, this);
                     70:        }
                     71:        if ((*as = old) == 0)
                     72:                 signal(id, old_handlers[id]);
                     73: }
                     74: 
                     75: void
                     76: Interrupt_handler::interrupt()
                     77: {
                     78: }
                     79: 
                     80: int
                     81: Interrupt_handler::pending()
                     82: {
                     83:        if (!got_interrupt)
                     84:                return 1;
                     85:        got_interrupt = 0;
                     86:        return 0;
                     87: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.