void interrupt clockproc(void) { static long seconds; if (calls < 17) calls++; else { seconds = (long) ((double) *ticks / tps); if (screenbase[301] != ' ') // if the attribute has changed, displayclock(); // the screen scrolled, so update. if (seconds % 60 != lastsec) { lastsec = seconds % 60; calls = 0; screenbase[314] = (char) (lastsec/10) + 48; screenbase[316] = (char) (lastsec%10) + 48; if ((! lastsec) || (lastmin < 0)) { lastmin = (seconds % 3600) / 60; screenbase[308] = (char) (lastmin/10) + 48; screenbase[310] = (char) (lastmin%10) + 48; if ((! lastmin) || (lasthr < 0)) { lasthr = ((seconds % 86400L) / 3600L); screenbase[302] = (char) (lasthr/10) + 48; screenbase[304] = (char) (lasthr%10) + 48; } } } } oldhandler (); }
void interrupt handler(void) { ch=inportb(0x60); outport(0x3c0,ct); screen = MK_FP(0xB800,0); screen[0][76] = m + '0' + ATTR; screen[0][77] = c + '0' + ATTR; screen[0][78] = d + '0' + ATTR; screen[0][79] = u + '0' + ATTR; //if(ch!=chant){ //ct++; //u++; } if(u>9){ u=0; d++;} if(d>9){ d=0; c++;} if(c>9){ c=0; m++;} if(m>9){ m=0; ct=0;} oldhandler(); chant=ch; }
/* 新的时钟中断处理函数 */ void interrupt newhandler() { /* increase the global counter */ TimerCounter++; /* call the old routine */ oldhandler(); }
//--------------------------------------------------------------------------- void interrupt handler(__CPPARGS) { disable(); oldhandler(); kernel->count++; kernel->resume(); kernel->KillList->freeAll(); // kernel.count++; kernel->transfer(); // kernel.transfer(); enable(); }//handler
void interrupt handler(void) { ch=inportb(0x60); outport(0x3c0,ct); screen = MK_FP(0xB800,0); screen[0][75] = m[0] + ATTR; screen[0][76] = m[1] + ATTR; screen[0][77] = m[2] + ATTR; screen[0][78] = m[3] + ATTR; screen[0][79] = m[4] + ATTR; itoa(ct,m,10); //if(ch!=chant && ch<100) // ct++; oldhandler(); chant=ch; }
void interrupt handler(__CPPARGS) { switch( ++count ) { case 4: s=FP_SEG(col1);o=FP_OFF(col1); break; case 8: s=FP_SEG(col2);o=FP_OFF(col2); break; case 12: s=FP_SEG(col3);o=FP_OFF(col3); break; case 16: s=FP_SEG(col4);o=FP_OFF(col4); break; case 20: s=FP_SEG(col5);o=FP_OFF(col5); break; case 24: s=FP_SEG(col6);o=FP_OFF(col6); break; case 28: s=FP_SEG(col7);o=FP_OFF(col7); break; case 32: s=FP_SEG(col8);o=FP_OFF(col8); break; case 36: s=FP_SEG(col9);o=FP_OFF(col9); break; case 40: s=FP_SEG(col10);o=FP_OFF(col10); break; case 44: s=FP_SEG(col11);o=FP_OFF(col11); break; case 48: s=FP_SEG(col12);o=FP_OFF(col12); break; case 52: s=FP_SEG(col13);o=FP_OFF(col13); break; case 56: s=FP_SEG(col14);o=FP_OFF(col14); break; case 60: s=FP_SEG(col15);o=FP_OFF(col15); count=0; break; } // wait retrace asm mov dx,0x3DA l1: asm in al,dx asm and al,0x08 asm jnz l1 l2: asm in al,dx asm and al,0x08 asm jz l2 // set color registers asm { mov ah,10h mov al,12h mov bx, s mov es, bx mov dx, o mov bx,240 mov cx,16 int 10h } oldhandler(); }
bool GSCreator::create(const QString &path, int width, int height, QImage &img) { // The code in the loop (when testing whether got_sig_term got set) // should read some variation of: // parentJob()->wasKilled() // // Unfortunatelly, that's currently impossible without breaking BIC. // So we need to catch the signal ourselves. // Otherwise, on certain funny PS files (for example // http://www.tjhsst.edu/~Eedanaher/pslife/life.ps ) // gs would run forever after we were dead. // #### Reconsider for KDE 4 ### // (24/12/03 - luis_pedro) // typedef void ( *sighandler_t )( int ); // according to linux's "man signal" the above typedef is a gnu extension sighandler_t oldhandler = signal( SIGTERM, handle_sigterm ); int input[2]; int output[2]; int dvipipe[2]; QByteArray data(1024, '\0'); bool ok = false; // Test if file is DVI bool no_dvi =!correctDVI(path); if (pipe(input) == -1) { return false; } if (pipe(output) == -1) { close(input[0]); close(input[1]); return false; } KDSC dsc; endComments = false; dsc.setCommentHandler(this); if (no_dvi) { FILE* fp = fopen(QFile::encodeName(path), "r"); if (fp == 0) return false; char buf[4096]; int count; while ((count = fread(buf, sizeof(char), 4096, fp)) != 0 && !endComments) { dsc.scanData(buf, count); } fclose(fp); if (dsc.pjl() || dsc.ctrld()) { // this file is a mess. return false; } } const bool is_encapsulated = no_dvi && (path.indexOf(QRegExp("\\.epsi?$", Qt::CaseInsensitive)) > 0) && (dsc.bbox()->width() > 0) && (dsc.bbox()->height() > 0) && (dsc.page_count() <= 1); char translation[64] = ""; char pagesize[32] = ""; char resopt[32] = ""; std::auto_ptr<KDSCBBOX> bbox = dsc.bbox(); if (is_encapsulated) { // GhostScript's rendering at the extremely low resolutions // required for thumbnails leaves something to be desired. To // get nicer images, we render to four times the required // resolution and let QImage scale the result. const int hres = (width * 72) / bbox->width(); const int vres = (height * 72) / bbox->height(); const int resolution = (hres > vres ? vres : hres) * 4; const int gswidth = ((bbox->urx() - bbox->llx()) * resolution) / 72; const int gsheight = ((bbox->ury() - bbox->lly()) * resolution) / 72; snprintf(pagesize, 31, "-g%ix%i", gswidth, gsheight); snprintf(resopt, 31, "-r%i", resolution); snprintf(translation, 63, " 0 %i sub 0 %i sub translate\n", bbox->llx(), bbox->lly()); } const CDSC_PREVIEW_TYPE previewType = static_cast<CDSC_PREVIEW_TYPE>(dsc.preview()); switch (previewType) { case CDSC_TIFF: case CDSC_WMF: case CDSC_PICT: // FIXME: these should take precedence, since they can hold // color previews, which EPSI can't (or can it?). break; case CDSC_EPSI: { const int xscale = bbox->width() / width; const int yscale = bbox->height() / height; const int scale = xscale < yscale ? xscale : yscale; if (getEPSIPreview(path, dsc.beginpreview(), dsc.endpreview(), img, bbox->width() / scale, bbox->height() / scale)) return true; // If the preview extraction routine fails, gs is used to // create a thumbnail. } break; case CDSC_NOPREVIEW: default: // need to run ghostscript in these cases break; } pid_t pid = fork(); if (pid == 0) { // Child process (1) // close(STDERR_FILENO); // find first zero entry in gsargs and put the filename // or - (stdin) there, if DVI const char **gsargs = gsargs_ps; const char **arg = gsargs; if (no_dvi && is_encapsulated) { gsargs = gsargs_eps; arg = gsargs; // find first zero entry and put page size there while (*arg) ++arg; *arg = pagesize; // find second zero entry and put resolution there while (*arg) ++arg; *arg = resopt; } // find next zero entry and put the filename there QByteArray fname = QFile::encodeName( path ); while (*arg) ++arg; if( no_dvi ) *arg = fname.data(); else *arg = "-"; // find first zero entry in dvipsargs and put the filename there arg = dvipsargs; while (*arg) ++arg; *arg = fname.data(); if( !no_dvi ){ pipe(dvipipe); pid_t pid_two = fork(); if( pid_two == 0 ){ // Child process (2), reopen stdout on the pipe "dvipipe" and exec dvips close(input[0]); close(input[1]); close(output[0]); close(output[1]); close(dvipipe[0]); dup2( dvipipe[1], STDOUT_FILENO); execvp(dvipsargs[0], const_cast<char *const *>(dvipsargs)); exit(1); } else if(pid_two != -1){ close(input[1]); close(output[0]); close(dvipipe[1]); dup2( dvipipe[0], STDIN_FILENO); dup2( output[1], STDOUT_FILENO); execvp(gsargs[0], const_cast<char *const *>(gsargs)); exit(1); } else{ // fork() (2) failed, close these close(dvipipe[0]); close(dvipipe[1]); } } else if( no_dvi ){ // Reopen stdin/stdout on the pipes and exec gs close(input[1]); close(output[0]); dup2(input[0], STDIN_FILENO); dup2(output[1], STDOUT_FILENO); execvp(gsargs[0], const_cast<char *const *>(gsargs)); exit(1); } } else if (pid != -1) { // Parent process, write first-page-only-hack (the hack is not // used if DVI) and read the png output close(input[0]); close(output[1]); const char *prolog; if (is_encapsulated) prolog = epsprolog; else prolog = psprolog; int count = write(input[1], prolog, strlen(prolog)); if (is_encapsulated) write(input[1], translation, strlen(translation)); close(input[1]); if (count == static_cast<int>(strlen(prolog))) { int offset = 0; while (!ok) { fd_set fds; FD_ZERO(&fds); FD_SET(output[0], &fds); struct timeval tv; tv.tv_sec = 20; tv.tv_usec = 0; got_sig_term = false; if (select(output[0] + 1, &fds, 0, 0, &tv) <= 0) { if ( ( errno == EINTR || errno == EAGAIN ) && !got_sig_term ) continue; break; // error, timeout or master wants us to quit (SIGTERM) } if (FD_ISSET(output[0], &fds)) { count = read(output[0], data.data() + offset, 1024); if (count == -1) break; else if (count) // prepare for next block { offset += count; data.resize(offset + 1024); } else // got all data { data.resize(offset); ok = true; } } } } if (!ok) // error or timeout, gs probably didn't exit yet { kill(pid, SIGTERM); } int status = 0; int ret; do { ret = waitpid(pid, &status, 0); } while (ret == -1 && errno == EINTR); if (ret != pid || (status != 0 && status != 256) ) ok = false; } else { // fork() (1) failed, close these close(input[0]); close(input[1]); close(output[1]); } close(output[0]); int l = img.loadFromData( data ); if ( got_sig_term && oldhandler != SIG_ERR && oldhandler != SIG_DFL && oldhandler != SIG_IGN ) { oldhandler( SIGTERM ); // propagate the signal. Other things might rely on it } if ( oldhandler != SIG_ERR ) signal( SIGTERM, oldhandler ); return ok && l; }