src/int/handler.c

   1 #include "depend.h"
   2 #include "genint.h"
   3 #include "int.h"
   4 #include "process.h"
   5 #include "intproto.h"
   6
   7 /* Handler routines */
   8
   9 /* Pataud le 13-06-1995
  10 #if !NO_GRAPH ||!DJE
  11 #if MSDOS
  12 #include "graf\graf.h"
  13 #else
  14 #include "graf/graf.h"
  15 #endif
  16 #endif
  17 */
  18
  19 void errsignal(int exception)
  20 {
  21         word signum, ah, am;
  22
  23
  24         signum = scot[exception];
  25         /* A.Salwicki 30 pazdz. 2002 *
  26         fprintf(stderr, "\n signum= %ld\n", signum);
  27
  28         *    fprintf(stderr, " Wlazl kotek");   *
  29
  30     if (signum != -1)                   * attempt to call a handler *
  31     {
  32
  33         raise_signal(signum, (word) 0, &ah, &am);
  34         fprintf(stderr, "\n ic= %ld\n", ic);
  35
  36       /*  if (ic != 0)                    /* continue execution *
  37         {
  38             go(ah, am);
  39             longjmp(contenv, 1);
  40         } *
  41     }
  42     */
  43
  44 /* A. Salwicki 27-10-2002
  45 #if MSDOS && !NO_GRAPH
  46         {
  47         extern bool graphmode;
  48
  49         if (graphmode)
  50                 groff();
  51         graphmode = FALSE;
  52         }
  53 #endif
  54 */
  55
  56         putc('\n', stderr);
  57         switch (exception) {
  58         case RTESLCOF:
  59                 fprintf(stderr, " SL CHAIN CUT OFF");
  60                 break;
  61         case RTEUNSTP:
  62                 fprintf(stderr, " UNIMPLEMENTED STANDARD PROCEDURE");
  63                 break;
  64         case RTEILLAT:
  65                 fprintf(stderr, " ILLEGAL ATTACH");
  66                 break;
  67         case RTEILLDT:
  68                 fprintf(stderr, " ILLEGAL DETACH");
  69                 break;
  70         case RTECORTM:
  71                 fprintf(stderr, " COROUTINE TERMINATED");
  72                 break;
  73         case RTECORAC:
  74                 fprintf(stderr, " COROUTINE ACTIVE");
  75                 break;
  76         case RTEINVIN:
  77                 fprintf(stderr, " ARRAY INDEX ERROR");
  78                 break;
  79         case RTEILLAB:
  80                 fprintf(stderr, " INCORRECT ARRAY BOUNDS");
  81                 break;
  82         case RTEINCQA:
  83                 fprintf(stderr, " IMPROPER QUA");
  84                 break;
  85         case RTEINCAS:
  86                 fprintf(stderr, " ILLEGAL ASSIGNMENT");
  87                 break;
  88         case RTEFTPMS:
  89                 fprintf(stderr, " FORMAL TYPE MISSING");
  90                 break;
  91         case RTEILLKL:
  92                 fprintf(stderr, " ILLEGAL KILL");
  93                 break;
  94         case RTEILLCP:
  95                 fprintf(stderr, " ILLEGAL COPY");
  96                 break;
  97         case RTEINCHS:
  98                 fprintf(stderr, " INCOMPATIBLE HEADERS");
  99                 break;
 100         case RTEHNDNF:
 101                 fprintf(stderr, " HANDLER NOT FOUND");
 102                 break;
 103         case RTEMEMOV:
 104                 fprintf(stderr, " MEMORY OVERFLOW");
 105                 break;
 106         case RTEFHTLG:
 107                 fprintf(stderr, " FORMAL LIST TOO LONG");
 108                 break;
 109         case RTEILLRT:
 110                 fprintf(stderr, " ILLEGAL RETURN");
 111                 break;
 112         case RTEREFTN:
 113                 fprintf(stderr, " REFERENCE TO NONE");
 114                 break;
 115         case RTEDIVBZ:
 116                 fprintf(stderr, " DIVISION BY ZERO");
 117                 break;
 118         case RTESYSER:
 119                 fprintf(stderr, " SYSTEM ERROR");
 120                 break;
 121         case RTEILLIO:
 122                 fprintf(stderr, " ILLEGAL I/O OPERATION");
 123                 break;
 124         case RTEIOERR:
 125                 fprintf(stderr, " I/O ERROR");
 126                 break;
 127         case RTECNTOP:
 128                 fprintf(stderr, " CANNOT OPEN FILE");
 129                 break;
 130         case RTEBADFM:
 131                 fprintf(stderr, " INPUT DATA FORMAT BAD");
 132                 break;
 133         case RTEILLRS:
 134                 fprintf(stderr, " ILLEGAL RESUME");
 135                 break;
 136         case RTETMPRC:
 137                 fprintf(stderr, " TOO MANY PROCESSES ON ONE MACHINE");
 138                 break;
 139         case RTEINVND:
 140                 fprintf(stderr, " INVALID NODE NUMBER");
 141                 break;
 142         case RTENEGST:
 143                 fprintf(stderr, " NEGATIVE STEP VALUE");
 144                 break;
 145         case RTENONGL:
 146                 fprintf(stderr, " REFERENCE TO GLOBAL NON PROCESS OBJECT FROM PROCESS");
 147                 break;
 148         default:
 149                 fprintf(stderr, " UNRECOGNIZED ERROR");
 150         }
 151         if (thisp->trlnumber < 0)
 152                 thisp->trlnumber = -thisp->trlnumber;
 153         if (thisp->trlnumber != 0)
 154                 fprintf(stderr, "\n AT LINE: %ld\n", (long)thisp->trlnumber);
 155         endprocess(4);
 156 }
 157
 158 /**
 159  * Raise exception
 160  */
 161 void raise_signal(word signal, word skip, word *ahnew, word *amnew)
 162 {
 163         word t1, t2, t3, t4, t5, virts;
 164         protdescr *ptr;
 165
 166         /* handler for others = no */
 167         t1 = 0;
 168         /* ah of current */
 169         t2 = M[display2 + M[c1 + PROTNUM]];
 170         /* am of current */
 171         t3 = c1;
 172         /* flag handler not found */
 173         t5 = 0;
 174         do {
 175                 /* prototype of current */
 176                 ptr = prototype[M[t3 + PROTNUM]];
 177                 t4 = ptr->handlerlist;
 178                 /* any handlers ? */
 179                 if (t4 != 0) {
 180                         do {
 181                                 /* signal number */
 182                                 t5 = M[ t4 ];
 183                                 if (t5 != signal) {
 184                                         if (t5 == 0 && t1 == 0)
 185                                                 t1 = t4;
 186                                         t4 = M[t4 + 2];
 187                                 }
 188                         } while (t5 != signal && t4 != 0);
 189                 }
 190                 /* look in DL or SL */
 191                 if (t5 != signal) {
 192                         /* handler for others found */
 193                         if (t1 != 0)
 194                                 t4 = t1;
 195                         else {
 196                                 t4 = t3 + M[t3];
 197                                 if (ptr->kind == HANDLER) {
 198                                         /* use SL for handlers */
 199                                         t2 = M[t4 + SL];
 200                                 } else {
 201                                         /* or DL for other goodies */
 202                                         t2 = M[t4 + DL];
 203                                 }
 204                                 /* handler not found */
 205                                 if (t2 == 0) {
 206                                         /* system signal */
 207                                         if (signal <= MAXSYSSN) {
 208                                                 ic = skip;
 209                                                 if (ic != 0)
 210                                                         longjmp(contenv, 1);
 211                                                 else
 212                                                         return;
 213                                         }
 214                                         else
 215                                                 errsignal(RTEHNDNF);
 216                                 }
 217                                 t3 = M[t2];
 218                         }
 219                 } else {
 220                         t1 = 0;
 221                 }
 222         } while (t1 == 0 && t5 != signal);
 223
 224         virts = thisp->prochead + M[thisp->prochead] + VIRTSC;
 225         /* compactification possible */
 226         M[virts] = t2;
 227         M[virts + 1] = M[t2 + 1];
 228         /* prototype number of handler */
 229         t3 = M[t4 + 1];
 230         t5 = prototype[t3]->appetite;
 231         /* others */
 232         if (t1 != 0) {
 233                 request(t5, ahnew, amnew);
 234                 M[*amnew + M[*amnew] + SIGNR] = 0;
 235         } else {
 236                 if (signal == scot[RTEMEMOV] &&
 237                                 thisp->lastitem - thisp->lastused-1 < t5) {
 238                         /* make memov look like abort */
 239                         scot[RTEMEMOV] = -1;
 240                         errsignal(RTEMEMOV);
 241                 }
 242                 request(t5, ahnew, amnew);
 243                 M[*amnew + M[*amnew] + SIGNR] = signal;
 244         }
 245         /* provide system attributes */
 246         M[*amnew + PROTNUM] = t3;
 247         t5 = *amnew + M[*amnew];
 248         M[t5 + SL] = M[virts];
 249         M[t5 + SL + 1] = M[virts + 1];
 250         /* ah of current */
 251         t2 = M[display2 + M[c1 + PROTNUM]];
 252         M[t5 + DL] = t2;
 253         M[t5 + DL + 1] = M[t2 + 1];
 254         /* skip */
 255         if (t1 != 0) {
 256                 ic = skip;
 257                 go(*ahnew, *amnew);
 258         }
 259 }
 260
 261 void wind()
 262 {
 263         word t1, t2;
 264
 265         /* am of handlers' SL */
 266         t1 = M[M[c1 + M[c1] + SL]];
 267         /* current */
 268         t2 = c1;
 269         while (TRUE) {
 270                 /* am of DL */
 271                 t2 = M[M[t2 + M[t2] + DL]];
 272                 if (t2 == t1)
 273                         break;
 274                 M[t2 + M[t2] + LSC] = prototype[M[t2 + PROTNUM]]->lastwill;
 275         }
 276         back(&thisp->backobj, &M[ temporary ], (word) 0);
 277 }
 278
 279 void term()
 280 {
 281         word t1;
 282
 283         /* am of handlers' SL */
 284         t1 = M[M[c1 + M[c1] + SL]];
 285         M[t1 + M[t1] + LSC] = prototype[M[t1 + PROTNUM]]->lastwill;
 286         wind();
 287 }
 288
 289 /*
 290  * This wraps up the above series of the handler procedures.
 291  */
 292
 293 void backhd(virtaddr *virt, word *am)
 294 {
 295         if (M[c1 + M[c1] + SIGNR] <= MAXSYSSN) {
 296                 /* illegal return */
 297                 errsignal(RTEILLRT);
 298         }
 299         else {
 300                 back(virt, am, (word) 0);
 301         }
 302 }