void dounit(void) { char tbuff[100]; if (todo == 0) return; wrong = 0; retry: start(todo); /* script = lesson */ snprintf(tbuff, sizeof tbuff, "%s/%s/L%s", _PATH_LLIB, sname, todo); scrin = fopen(tbuff, "r"); if (scrin == NULL) { fprintf(stderr, "No script.\n"); err(1, "%s", tbuff); wrapup(1); } copy(0, scrin); if (more == 0) return; copy(1, stdin); if (more == 0) return; copy(0, scrin); if (comfile >= 0) close(comfile); wait(&didok); didok = (status == 0); if (!didok) { wrong++; printf("\nSorry, that's %snot right. Try again? ", wrong > 1 ? "still " : ""); fflush(stdout); for (;;) { if (fgets(tbuff, sizeof tbuff, stdin) == NULL) errx(1, "could not read input"); trim(tbuff); if (tbuff[0] == 'y') { printf("Try the problem again.\n"); fflush(stdout); goto retry; } else if (strcmp(tbuff, "bye") == 0) wrapup(1); else if (tbuff[0] == 'n') { wrong = 0; printf("\nOK. Lesson %s (%d)\n", todo, speed); printf("Skipping to next lesson.\n\n"); fflush(stdout); break; } else { printf("Please type yes, no or bye: "); fflush(stdout); } } } setdid(todo, sequence++); }
virtual void startBlock( const Block *b, uint64_t ) { if(0<=cutoffBlock && cutoffBlock<b->height) wrapup(); uint8_t blockHash[kSHA256ByteSize]; sha256Twice(blockHash, b->data, 80); const uint8_t *p = b->data; SKIP(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); SKIP(uint256_t, blkMerkleRoot, p); LOAD(uint32_t, blkTime, p); // id BIGINT PRIMARY KEY // hash BINARY(32) // time BIGINT fprintf(blockFile, "%" PRIu64 "\t", (blkID = b->height-1)); writeEscapedBinaryBuffer(blockFile, blockHash, kSHA256ByteSize); fputc('\t', blockFile); fprintf(blockFile, "%" PRIu64 "\n", (uint64_t)blkTime); if(0==(b->height)%500) { fprintf( stderr, "block=%8" PRIu64 " " "nbOutputs=%8" PRIu64 "\n", b->height, outputMap.size() ); } }
virtual void startBlock( const Block *b, uint64_t chainBase ) { if (lastBlock >= 0 && lastBlock < b->height - 1) wrapup(); if (b->height - 1 == firstBlock) active = 1; if (active) { uint8_t blockHash[kSHA256ByteSize]; sha256Twice(blockHash, b->data, 80); const uint8_t *p = b->data; // Total block size is 81 bytes plus transactions blkSize = 81; totalBlkFees = 0; totalBlkOutput = 0; numBlkTxs = 0; LOAD(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); LOAD(uint256_t, blkMerkleRoot, p); LOAD(uint32_t, blkTime, p); LOAD(uint32_t, difficultyBits, p); LOAD(uint32_t, nonce, p); // ID fprintf(blockFile, "%" PRIu64 ",", blkID); // Hash uint8_t buf[1 + 2*kSHA256ByteSize]; toHex(buf, blockHash); fprintf(blockFile, "\"%s\",", buf); // Version fprintf(blockFile, "%" PRIu32 ",", version); // Timestamp time_t blockTime = blkTime; char tbuf[23]; strftime(tbuf, sizeof tbuf, "%FT%TZ", gmtime(&blockTime)); fprintf(blockFile, "\"%s\",", tbuf); // Nonce fprintf(blockFile, "%" PRIu32 ",", nonce); // Difficulty fprintf(blockFile, "%f,", difficulty(difficultyBits)); // Merkle root uint8_t buf2[kSHA256ByteSize]; uint8_t buf3[1 + 2*kSHA256ByteSize]; memcpy(buf2, &blkMerkleRoot, kSHA256ByteSize); toHex(buf3, buf2); fprintf(blockFile, "\"%s\",", buf3); } }
void readloop(int cnt, int if_fd, struct bpf_program *fp, printfunc printit) { #ifdef IBMRTPC register struct packet_header *ph; register u_char *bp; register int inc; #else /* !IBMRTPC */ static struct timeval tv = { 0 }; #endif /* IBMRTPC */ register int cc, caplen; register struct bpf_insn *fcode = fp->bf_insns; union { struct packet_header hdr; u_char p[BUFSPACE]; u_short s; } buf; while (1) { if ((cc = read(if_fd, (char *)buf.p, sizeof(buf))) < 0) efReadError(if_fd, "reader"); #ifdef IBMRTPC /* * Loop through each packet. */ bp = buf.p; while (cc > 0) { ph = (struct packet_header *)bp; caplen = ph->tap.th_wirelen > snaplen ? snaplen : ph->tap .th_wirelen ; if (bpf_filter(fcode, (char *)ph->packet, ph->tap.th_wirelen, caplen)) { if (cnt >= 0 && --cnt < 0) goto out; (*printit)((char *)ph->packet, (struct timeval *)ph->tap.th_timestamp, ph->tap.th_wirelen, caplen); } inc = ph->length.PacketOffset; cc -= inc; bp += inc; } #else /* !IBMRTPC */ caplen = cc > snaplen ? snaplen : cc ; if (bpf_filter(fcode, buf.hdr.packet, cc, caplen)) { if (cnt >= 0 && --cnt < 0) goto out; (*printit)(buf.hdr.packet, &tv, cc, caplen); } #endif /* IBMRTPC */ } out: wrapup(if_fd); }
virtual void startBlock( const Block *b, uint64_t chainSize ) { curBlock = b; const uint8_t *p = b->data; const uint8_t *sz = -4 + p; LOAD(uint32_t, size, sz); offset += size; double now = usecs(); static double startTime = 0; static double lastStatTime = 0; double elapsed = now - lastStatTime; bool longEnough = (5*1000*1000<elapsed); bool closeEnough = ((chainSize - offset)<80); if(unlikely(longEnough || closeEnough)) { if(0==startTime) { startTime = now; } double progress = offset/(double)chainSize; double elasedSinceStart = 1e-6*(now - startTime); double speed = progress / elasedSinceStart; info( "%8" PRIu64 " blocks, " "%8.3f MegaAddrs , " "%6.2f%% , " "elapsed = %5.2fs , " "eta = %5.2fs , " , curBlock->height, addrMap.size()*1e-6, 100.0*progress, elasedSinceStart, (1.0/speed) - elasedSinceStart ); lastStatTime = now; } SKIP(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); SKIP(uint256_t, blkMerkleRoot, p); LOAD(uint32_t, bTime, p); blockTime = bTime; if(0<=cutoffBlock && cutoffBlock<=curBlock->height) { wrapup(); } }
void setdid(char *lesson, int seq) { struct whichdid *pw; for (pw = which; pw < which + nwh; pw++) { if (strcmp(pw->w_less, lesson) == SAME) { pw->w_seq = seq; return; } } pw = which + nwh++; if (nwh >= NW) { fprintf(stderr, "nwh >= NW\n"); wrapup(1); } pw->w_seq = seq; pw->w_less = whcp; while ((*whcp++ = *lesson++) != 0) ; if (whcp >= whbuff + NWCH) { fprintf(stderr, "lesson name too long\n"); wrapup(1); } }
void signal_intrpt(int signo __attribute__ ((__unused__))) { char response[20], *p; signal(SIGINT, signal_hangup); write(2, "\nInterrupt.\nWant to go on? ", 28); p = response; *p = 'n'; while (read(0, p, 1) == 1 && *p != '\n') p++; if (response[0] != 'y') wrapup(1); ungetc('\n', stdin); signal(SIGINT, signal_intrpt); }
void start(char *lesson) { struct direct { int inode; char name[14]; }; #if 0 struct direct dv[ND], *dm, *dp; int f, c, n; #endif char where [1024]; #if 0 /* I'm not sure the point of this loop to unlink files, it may be * some kind of cleanup. I'm sure I don't like unlinking files * like this and, anyway, it would all have to be recoded using * opendir() and readdir(). -- Ian */ f = open(".", O_RDONLY); n = read(f, dv, ND*sizeof(*dp)); n /= sizeof(*dp); if (n == ND) fprintf(stderr, "lesson too long\n"); dm = dv + n; for (dp = dv; dp < dm; dp++) if (dp->inode) { n = strlen(dp->name); if (dp->name[n - 2] == '.' && dp->name[n - 1] == 'c') continue; c = dp->name[0]; if (c >= 'a' && c <= 'z') unlink(dp->name); } close(f); if (ask) return; #endif snprintf(where, sizeof where, "%s/%s/L%s", _PATH_LLIB, sname, lesson); if (access(where, R_OK) == 0) /* there is a file */ return; fprintf(stderr, "No lesson %s\n", lesson); err(1, "%s", where); wrapup(1); }
void updateAccount(int pid_accnt_no,int add_amount) { struct balance_record* curr; for(curr=globl_shm_ptr;curr!=globl_shm_end_record; curr++) { if(curr->client_accnt_no==pid_accnt_no) { printf(" Adding %d to AccountNo. : %d \n",add_amount, curr->client_accnt_no); curr->client_balance += add_amount; curr->last_update_timestamp = time(0); return; } } printf("Error : Account PID %d Not found @ Master ! \n\n",pid_accnt_no); wrapup(); }
int main(int argc, char *argv[]) { speed = 0; more = 1; pwline = getlogin(); setbuf(stdout, malloc(BUFSIZ)); selsub(argc, argv); signal(SIGHUP, signal_hangup); signal(SIGINT, signal_intrpt); while (more) { selunit(); dounit(); whatnow(); } wrapup(0); return (0); }
int main(int argc, char **argv) { FILE *tmpfd; char makeMacro[ BUFSIZ ]; char makefileMacro[ BUFSIZ ]; program = argv[0]; init(); SetOpts(argc, argv); Imakefile = FindImakefile(Imakefile); CheckImakefileC(ImakefileC); if (Makefile) tmpMakefile = Makefile; else { tmpMakefile = Strdup(tmpMakefile); (void) mkstemp(tmpMakefile); } AddMakeArg("-f"); AddMakeArg( tmpMakefile ); sprintf(makeMacro, "MAKE=%s", program); AddMakeArg( makeMacro ); sprintf(makefileMacro, "MAKEFILE=%s", Imakefile); AddMakeArg( makefileMacro ); if ((tmpfd = fopen(tmpMakefile, "w+")) == NULL) LogFatal("Cannot create temporary file %s.", tmpMakefile); cleanedImakefile = CleanCppInput(Imakefile); cppit(cleanedImakefile, Template, ImakefileC, tmpfd, tmpMakefile); if (show) { if (Makefile == NULL) showit(tmpfd); } else makeit(); wrapup(); exit(0); }
virtual void startBlock( const Block *b, uint64_t ) { if (lastBlock < b->height) { wrapup(); } auto p = b->chunk->getData(); uint8_t blockHash[kSHA256ByteSize]; sha256Twice(blockHash, p, 80); SKIP(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); SKIP(uint256_t, blkMerkleRoot, p); LOAD(uint32_t, blkTime, p); blkID = b->height - 1; if (blkID >= firstBlock) { fprintf(blockFile, "%" PRIu64 "|", blkID); writeHexEscapedBinaryBuffer(blockFile, blockHash, kSHA256ByteSize); fputc('|', blockFile); fprintf(blockFile, "%" PRIu64 "\n", (uint64_t)blkTime); } if (0 == blkID % 5000) { fprintf( stderr, "block=%8" PRIu64 " " "nbOutputs=%9" PRIu64 "\n", blkID, outputMap.size() ); } }
selunit() { char fnam[20], s[50]; static char dobuff[50]; char posslev[20][20]; int diff[20], i, k, m, n, best, alts; FILE *f; char zb[200]; static char saved[20]; while (ask) { printf("What lesson? "); fflush(stdout); gets(dobuff); if (strcmp(dobuff, "bye") == 0) wrapup(0); level = todo = dobuff; sprintf(s, "../../%s/L%s", sname, dobuff); if (access(s, 04) == 0) return; printf("no such lesson\n"); } alts = 0; retry: f=scrin; if (f==NULL) { sprintf(fnam, "../../%s/L%s", sname, level); f = fopen(fnam, "r"); if (f==NULL) { fprintf(stderr, "No script for lesson %s.\n", level); wrapup(1); } while (fgets(zb, 200, f)) { trim(zb); if (strcmp(zb, "#next")==0) break; } } if (feof(f)) { printf("Congratulations; you have finished this sequence.\n"); fflush(stdout); todo = 0; return; } for(i=0; fgets(s, 50, f); i++) { sscanf(s, "%s %d", posslev[i], &diff[i]); } best = -1; /* cycle through lessons from random start */ /* first try the current place, failing that back up to last place there are untried alternatives (but only one backup) */ n = grand()%i; for(k=0; k<i; k++) { m = (n+k)%i; if (already(posslev[m],0)) continue; if (best<0) best=m; /* real alternatives */ alts++; if (abs(diff[m]-speed) < abs(diff[best]-speed)) best=m; } if (best < 0 && nsave) { nsave--; strcpy(level, saved); goto retry; } if (best <0) { /* lessons exhausted or missing */ printf("Sorry, there are no alternative lessons at this stage.\n"); printf("See someone for help.\n"); fflush(stdout); todo = 0; return; } strcpy (dobuff, posslev[best]); if (alts>1) { nsave=1; strcpy (saved, level); } todo = dobuff; fclose(f); }
void copy(int prompt, FILE *fin) { FILE *fout, *f; char s[200], t[200], s1[200], *r, *tod; char nm[100]; int *p; time_t tval; int nmatch = 0; if (subdir[0] == 0) snprintf(subdir, sizeof subdir, "%s/%s", _PATH_LLIB, sname); for (;;) { if (pgets(s, sizeof s, prompt, fin) == 0) { if (fin == stdin) { /* fprintf(stderr, "Don't type control-D\n"); */ /* this didn't work out very well */ wrapup(1); /* ian */ continue; } else break; } trim(s); /* change the sequence %s to lesson directory */ /* if needed */ for (r = s; *r; r++) if (*r == '%') { snprintf(s1, sizeof s1, s, subdir, subdir, subdir); strlcpy(s, s1, sizeof s); break; } r = wordb(s, t); p = action(t); /* some actions done only once per script */ if (p && *p == ONCE) { if (wrong) { /* we are on 2nd time */ scopy(fin, NULL); continue; } strlcpy(s, r, sizeof s); r = wordb(s, t); p = action(t); } if (p == 0) { if (comfile >= 0) { write(comfile, s, strlen(s)); write(comfile, "\n", 1); } else { signal(SIGINT, SIG_IGN); status = mysys(s); signal(SIGINT, signal_intrpt); } if (incopy) { fprintf(incopy, "%s\n", s); strlcpy(last, s, sizeof last); } continue; } switch (*p) { case READY: if (incopy && r) { fprintf(incopy, "%s\n", r); strlcpy(last, r, sizeof last); } return; case PRINT: if (wrong) scopy(fin, NULL); /* don't repeat msg */ else if (r) list(r); else scopy(fin, stdout); break; case NOP: break; case MATCH: if (nmatch > 0) /* we have already passed */ scopy(fin, NULL); /* did we pass this time? */ else if ((status = strcmp(r, last)) == 0) { nmatch++; scopy(fin, stdout); } else scopy(fin, NULL); break; case BAD: if (strcmp(r, last) == 0) scopy(fin, stdout); else scopy(fin, NULL); break; case SUCCEED: scopy(fin, (status == 0) ? stdout : NULL); break; case FAIL: scopy(fin, (status != 0) ? stdout : NULL); break; case CREATE: fout = fopen(r, "w"); scopy(fin, fout); fclose(fout); break; case CMP: status = cmp(r); /* contains two file names */ break; case MV: snprintf(nm, sizeof nm, "%s/L%s.%s", subdir, todo, r); fcopy(r, nm); break; case USER: case NEXT: more = 1; return; case COPYIN: incopy = fopen(".copy", "w"); break; case UNCOPIN: fclose(incopy); incopy = NULL; break; case COPYOUT: maktee(); break; case UNCOPOUT: untee(); break; case PIPE: comfile = makpipe(); break; case UNPIPE: close(comfile); wait(0); comfile = -1; break; case YES: case NO: if (incopy) { fprintf(incopy, "%s\n", s); strlcpy(last, s, sizeof last); } return; case WHERE: printf("You are in lesson %s\n", todo); fflush(stdout); break; case BYE: more = 0; return; case CHDIR: printf("cd not allowed\n"); fflush(stdout); break; case LEARN: printf("You are already in learn.\n"); fflush(stdout); break; case LOG: if (!logging) break; if (logfile[0] == 0) { snprintf(logfile, sizeof logfile, "%s/log/%s", direct, sname); } f = fopen((r ? r : logfile), "a"); if (f == NULL) break; time(&tval); tod = ctime(&tval); tod[24] = 0; fprintf(f, "%s L%-6s %s %2d %s\n", tod, todo, status? "fail" : "pass", speed, pwline); fclose(f); break; } } return; }
void main(int argc,char* argv[]) { signal(SIGKILL,wrapup); signal(SIGINT,wrapup); signal(SIGTERM,wrapup); signal(SIGQUIT,wrapup); int num_ATMs,i; if(argc!=2) { printf("Please enter : %s <number_of_ATMs>\n", argv[0]); exit(0); } else sscanf(argv[1],"%d",&num_ATMs); createLocatorFile(); semID = semget((key_t)SEMAPHORE_KEY,num_ATMs,IPC_CREAT|0666); if(semID==-1) perror("Error in semget !\n"); mssgQ_ID=msgget((key_t)MASTER_MSSG_Q_KEY,IPC_CREAT|0666); if(mssgQ_ID==-1) perror("Error in msgget !\n"); globl_shmID = shmget((key_t)GLOBAL_SHARED_MEMORY_KEY,MAX_CLIENTS*sizeof(struct balance_record),IPC_CREAT|0666); if(globl_shmID==-1) perror("Error in shmget !\n"); globl_shm_ptr = shmat(globl_shmID,NULL,0); globl_shm_end_record = globl_shm_ptr; // initially NO client record initializeAllSubSemaphoreValues(num_ATMs); for(i=0;i<num_ATMs;i++) { int index,KEY; // the same KEY will be used for both the ATM - Client Message Queue as well as the shared memory of the ATM process int pid = fork(); if(pid == 0) { // ATM (forked child) process index = getpid() - getppid(); KEY = 10*index; char buf[10]; sprintf(buf,"%d",KEY); //int retv = execlp("atm.c","./atm",buf,NULL); int retv = execlp("./atm","./atm",buf,NULL); if(retv == -1) {perror("Error in execlp ! \n"); exit(1);} } else { // master(parent) process index = pid - getpid(); KEY = 10*index; appendToLocatorFile(index,KEY,index-1,KEY); } //sleep(1); // sleep for 1 second before generating another process } while(1) { int pid; int atm_pid; struct mssg buffer; struct msqid_ds qstat; msgrcv(mssgQ_ID,&buffer,sizeof(buffer),getpid(),0); msgctl(mssgQ_ID,IPC_STAT,&qstat); printf("Master Process received message %s from ATM%d\n\n",buffer.mtext,qstat.msg_lspid-getpid()); if(sscanf(buffer.mtext,"CHCK_ACCOUNT %d",&pid)==1) checkClientAccount(pid); else if(strcmp(buffer.mtext,"GLOBAL_CONSISTENCY_CHECK_REQUEST")==0) { performGlobalConsistencyCheck(); buffer.mtype=qstat.msg_lspid; strcpy(buffer.mtext,"GLOBAL CONSISTENCY CHECK COMPLETION CONFIRMATION "); msgsnd(mssgQ_ID,&buffer,sizeof(buffer),0); } else printf("Invalid Message !\n\n"); } wrapup(); }
/* xexit - get out of xlisp */ LVAL xexit() { xllastarg(); wrapup(); }
//------------------------------------------------------------- void TestCase::run (void) { // Reset cancel flag cancel_m = false; // Inform the monitor TestMonitor::enterTestSection( name() ); // Log memory action TestMonitor::setAllocationRecording(true); // Setup test setup(); // Stop logging memory action TestMonitor::setAllocationRecording(false); // Run all those test functions for( list<TestFunction>::const_iterator test = testFuns_m.begin(); test != testFuns_m.end(); ++test ) { // Inform the monitor TestMonitor::enterTestSection( test->name_m, false ); // Log memory action TestMonitor::setAllocationRecording(true); // Run the test try { (*test->testFunction_m)(); } catch( Testframe::Exception &x ) { TestMonitor::recordProblem( x.type().c_str(), x.message().c_str(), "n/a", -1 ); } catch( ... ) { TestMonitor::recordProblem( "Exception", "n/a", "n/a", -1 ); } // Stop logging memory action TestMonitor::setAllocationRecording(false); // Inform the monitor TestMonitor::leaveTestSection(); // Cancel? if( cancel_m ) break; } // Log memory action TestMonitor::setAllocationRecording(true); // Wrapup test wrapup(); // Stop logging memory action TestMonitor::setAllocationRecording(false); // Inform the monitor TestMonitor::leaveTestSection(); }
void signal_hangup(int signo __attribute__ ((__unused__))) { wrapup(1); }
void selsub(int argc, char *argv[]) { char ans1[100], *cp; static char ans2[30]; static char subname[20]; if (argc > 1 && argv[1][0] == '-') { direct = argv[1] + 1; argc--; argv++; } chknam(direct); if (chdir(direct) != 0) { fprintf(stderr, "can't cd to %s\n", direct); exit(1); } sname = argc > 1 ? argv[1] : 0; if (argc > 2) strlcpy(level = ans2, argv[2], sizeof ans2); else level = 0; if (argc > 3 ) speed = atoi(argv[3]); if (!sname) { printf("These are the available courses:\n"); list("Linfo"); printf("If you want more information about the courses,\n"); printf("or if you have never used 'learn' before,\n"); printf("type 'return'; otherwise type the name of\n"); printf("the course you want, followed by 'return'.\n"); fflush(stdout); if (fgets(sname = subname, sizeof subname, stdin) == NULL) errx(1, "could not read input"); trim(sname); if (sname[0] == '\0') { list("Xinfo"); do { printf("\nWhich subject? "); fflush(stdout); if (fgets(sname = subname, sizeof subname, stdin) == NULL) errx(1, "could not read input"); trim(sname); } while (sname[0] == '\0'); } } chknam(sname); if (!level) { printf("If you were in the middle of this subject\n"); printf("and want to start where you left off, type\n"); printf("the last lesson number the computer printed.\n"); printf("To start at the beginning, just hit return.\n"); fflush(stdout); if (fgets(ans2, sizeof ans2, stdin) == NULL) errx(1, "could not read input"); trim(ans2); if (ans2[0] == 0) strlcpy(ans2, "0", sizeof ans2); for (cp = ans2; *cp; cp++) { if (*cp == '(' || *cp == ' ') *cp = 0; } level = ans2; } /* make new directory for user to play in */ if ((playdir = mkdtemp(strdup("/tmp/plXXXXXX"))) == NULL || chdir(playdir) < 0) { fprintf(stderr, "Couldn't create playpen directory %s.\n", playdir); fprintf(stderr, "Bye.\n"); exit(1); } /* * after this point, we have a working directory. * have to call wrapup to clean up */ snprintf(ans1, sizeof ans1, "%s/%s/Init", direct, sname); if (access(ans1, R_OK) == 0) { snprintf(ans1, sizeof ans1, "%s/%s/Init %s", direct, sname, level); if (system(ans1) != 0) { printf("Leaving learn.\n"); wrapup(1); } } if (level[0] == '-') /* no lesson names start with - */ ask = 1; start(level); }
void tex::main_control() { if (every_job != null) begin_token_list(every_job, EVERY_JOB_TEXT); big_switch: get_x_token(); reswitch: if (tracing_commands > 0) show_cur_cmd_chr(); switch(abs(mode) + cur_cmd) { hmode(LETTER): hmode(OTHER_CHAR): hmode(CHAR_GIVEN): goto main_loop; hmode(CHAR_NUM): scan_char_num(); cur_chr = cur_val; goto main_loop; hmode(NO_BOUNDARY): get_x_token(); if (cur_cmd == LETTER || cur_cmd == OTHER_CHAR || cur_cmd == CHAR_GIVEN || cur_cmd == CHAR_NUM) { cancel_boundary = TRUE; } goto reswitch; hmode(SPACER): if (space_factor == 1000) { goto append_normal_space; } else { app_space(); } break; hmode(EX_SPACE): mmode(EX_SPACE): goto append_normal_space; any_mode(RELAX): vmode(SPACER): mmode(SPACER): mmode(NO_BOUNDARY): break; any_mode(IGNORE_SPACES): get_nbx_token(); goto reswitch; vmode(STOP): if (its_all_over()) return; break; any_mode(LAST_ITEM): any_mode(MAC_PARAM): non_math(EQ_NO): vmode(VMOVE): hmode(HMOVE): mmode(HMOVE): vmode(VADJUST): vmode(ITAL_CORR): report_illegal_case(); break; non_math(SUP_MARK): non_math(SUB_MARK): non_math(MATH_CHAR_NUM): non_math(MATH_GIVEN): non_math(MATH_COMP): non_math(DELIM_NUM): non_math(LEFT_RIGHT): non_math(ABOVE): non_math(RADICAL): non_math(MATH_STYLE): non_math(MATH_CHOICE): non_math(VCENTER): non_math(NON_SCRIPT): non_math(MKERN): non_math(LIMIT_SWITCH): non_math(MSKIP): non_math(MATH_ACCENT): mmode(ENDV): mmode(PAR_END): mmode(STOP): mmode(VSKIP): mmode(UN_VBOX): mmode(VALIGN): mmode(HRULE): insert_dollar_sign(); break; vmode(HRULE): hmode(VRULE): mmode(VRULE): tail_append(scan_rule_spec()); if (abs(mode) == VMODE) prev_depth = IGNORE_DEPTH; else if (abs(mode) == HMODE) space_factor = 1000; break; vmode(VSKIP): hmode(HSKIP): mmode(HSKIP): mmode(MSKIP): append_glue(); break; any_mode(KERN): mmode(MKERN): append_kern(); break; non_math(LEFT_BRACE): new_save_level(SIMPLE_GROUP); break; any_mode(BEGIN_GROUP): new_save_level(SEMI_SIMPLE_GROUP); break; any_mode(END_GROUP): if (cur_group == SEMI_SIMPLE_GROUP) { unsave(); } else { off_save(); } break; any_mode(RIGHT_BRACE): handle_right_brace(); break; vmode(HMOVE): hmode(VMOVE): mmode(VMOVE): { int t; t = cur_chr; scan_normal_dimen(); if (t == 0) { scan_box(cur_val); } else { scan_box(-cur_val); } break; } any_mode(LEADER_SHIP): scan_box(LEADER_FLAG + cur_chr - A_LEADERS); break; any_mode(MAKE_BOX): begin_box(0); break; vmode(START_PAR): new_graf(cur_chr > 0); break; vmode(LETTER): vmode(OTHER_CHAR): vmode(CHAR_NUM): vmode(CHAR_GIVEN): vmode(MATH_SHIFT): vmode(UN_HBOX): vmode(VRULE): vmode(ACCENT): vmode(DISCRETIONARY): vmode(HSKIP): vmode(VALIGN): vmode(EX_SPACE): vmode(NO_BOUNDARY): back_input(); new_graf(TRUE); break; hmode(START_PAR): mmode(START_PAR): indent_in_hmode(); break; vmode(PAR_END): normal_paragraph(); if (mode > 0) build_page(); break; hmode(PAR_END): if (align_state < 0) off_save(); end_graf(); if (mode == VMODE) build_page(); break; hmode(STOP): hmode(VSKIP): hmode(HRULE): hmode(UN_VBOX): hmode(HALIGN): head_for_vmode(); break; any_mode(INSERT): hmode(VADJUST): mmode(VADJUST): begin_insert_or_adjust(); break; any_mode(MARK): make_mark(); break; any_mode(BREAK_PENALTY): append_penalty(); break; any_mode(REMOVE_ITEM): delete_last(); break; vmode(UN_VBOX): hmode(UN_HBOX): mmode(UN_HBOX): unpackage(); break; hmode(ITAL_CORR): append_italic_correction(); break; mmode(ITAL_CORR): tail_append(new_kern(0)); break; hmode(DISCRETIONARY): mmode(DISCRETIONARY): append_discretionary(); break; hmode(ACCENT): make_accent(); break; any_mode(CAR_RET): any_mode(TAB_MARK): align_error(); break; any_mode(NO_ALIGN): no_align_error(); break; any_mode(OMIT): omit_error(); break; vmode(HALIGN): hmode(VALIGN): init_align(); break; mmode(HALIGN): if (privileged()) { if (cur_group == MATH_SHIFT_GROUP) { init_align(); } else { off_save(); } } break; vmode(ENDV): hmode(ENDV): do_endv(); break; any_mode(END_CS_NAME): cs_error(); break; hmode(MATH_SHIFT): init_math(); break; mmode(EQ_NO): if (privileged()) { if (cur_group == MATH_SHIFT_GROUP) { start_eq_no(); } else { off_save(); } } break; mmode(LEFT_BRACE): tail_append(new_noad()); back_input(); scan_math(nucleus(tail)); break; mmode(LETTER): mmode(OTHER_CHAR): mmode(CHAR_GIVEN): if (cur_chr < 256) set_math_char(math_code(cur_chr)); else set_math_char(cur_chr); break; mmode(CHAR_NUM): scan_char_num(); cur_chr = cur_val; if (cur_chr < 256) set_math_char(math_code(cur_chr)); else set_math_char(cur_chr); break; mmode(MATH_CHAR_NUM): scan_fifteen_bit_int(); set_math_char(cur_val); break; mmode(MATH_GIVEN): set_math_char(cur_chr); break; mmode(DELIM_NUM): scan_twenty_seven_bit_int(); set_math_char(cur_val / 010000); break; mmode(MATH_COMP): tail_append(new_noad()); type(tail) = cur_chr; scan_math(nucleus(tail)); break; mmode(LIMIT_SWITCH): math_limit_switch(); break; mmode(RADICAL): math_radical(); break; mmode(ACCENT): mmode(MATH_ACCENT): math_ac(); break; mmode(VCENTER): scan_spec(VCENTER_GROUP, FALSE); normal_paragraph(); push_nest(); mode = -VMODE; prev_depth = IGNORE_DEPTH; if (every_vbox != null) begin_token_list(every_vbox, EVERY_VBOX_TEXT); break; mmode(MATH_STYLE): tail_append(new_style(cur_chr)); break; mmode(NON_SCRIPT): tail_append(new_glue(zero_glue)); subtype(tail) = COND_MATH_GLUE; break; mmode(MATH_CHOICE): append_choices(); break; mmode(SUB_MARK): mmode(SUP_MARK): sub_sup(); break; mmode(ABOVE): math_fraction(); break; mmode(LEFT_RIGHT): math_left_right(); break; mmode(MATH_SHIFT): if (cur_group == MATH_SHIFT_GROUP) { after_math(); } else { off_save(); } break; any_mode(AFTER_ASSIGNMENT): get_token(); after_token = cur_tok; break; any_mode(AFTER_GROUP): get_token(); save_for_after(cur_tok); break; any_mode(IN_STREAM): clopen_stream(); break; any_mode(MESSAGE): issue_message(); break; any_mode(CASE_SHIFT): shift_case(); break; any_mode(XRAY): show_whatever(); break; any_mode(EXTENSION): do_extension(); break; default: prefixed_command(); break; } goto big_switch; #define adjust_space_factor() \ { \ main_s = sf_code(cur_chr); \ if (main_s == 1000) { \ space_factor = 1000; \ } else if (main_s < 1000) { \ if (main_s > 0) { \ space_factor = main_s; \ } \ } else if (space_factor < 1000) { \ space_factor = 1000; \ } else { \ space_factor = main_s; \ } \ } main_loop: adjust_space_factor(); main_f = cur_font; bchar = font_bchar(main_f); false_bchar = font_false_bchar(main_f); if (mode > 0 && language != clang) fix_language(); fast_new_avail(lig_stack); font(lig_stack) = main_f; character(lig_stack) = cur_l = cur_chr; cur_q = tail; if (cancel_boundary) { cancel_boundary = FALSE; main_k = NON_ADDRESS; } else { main_k = bchar_label(main_f); } if (main_k == NON_ADDRESS) goto main_loop_move_2; cur_r = cur_l; cur_l = NON_CHAR; goto main_lig_loop_1; #define pack_lig(RT_HIT) \ { \ main_p = new_ligature(main_f, cur_l, link(cur_q)); \ if (lft_hit) { \ subtype(main_p) = 2; \ lft_hit = FALSE; \ } \ if (RT_HIT && lig_stack == null) { \ incr(subtype(main_p)); \ rt_hit = FALSE; \ } \ tail = link(cur_q) = main_p; \ ligature_present = FALSE; \ } #define wrapup(RT_HIT) \ { \ if (cur_l < NON_CHAR) { \ if (character(tail) == hyphen_char(main_f) \ && link(cur_q) != null) \ ins_disc = TRUE; \ if (ligature_present) \ pack_lig(RT_HIT); \ if (ins_disc) { \ ins_disc = FALSE; \ if (mode > 0) \ tail_append(new_disc()); \ } \ } \ } main_loop_wrapup: wrapup(rt_hit); main_loop_move: if (lig_stack == null) goto reswitch; cur_q = tail; cur_l = cur_r; main_loop_move_1: if (!is_char_node(lig_stack)) goto main_loop_move_lig; main_loop_move_2: if (cur_chr < font_bc(main_f) || cur_chr > font_ec(main_f)) { char_warning(main_f, cur_chr); free_avail(lig_stack); goto big_switch; } main_i = char_info(main_f, cur_l); if (!char_exists(main_i)) { char_warning(main_f, cur_chr); free_avail(lig_stack); goto big_switch; } tail_append(lig_stack); main_loop_lookahead: get_next(); if (cur_cmd == LETTER || cur_cmd == OTHER_CHAR || cur_cmd == CHAR_GIVEN) { goto main_loop_lookahead_1; } x_token(); if (cur_cmd == LETTER || cur_cmd == OTHER_CHAR || cur_cmd == CHAR_GIVEN) { goto main_loop_lookahead_1; } if (cur_cmd == CHAR_NUM) { scan_char_num(); cur_chr = cur_val; goto main_loop_lookahead_1; } if (cur_cmd == NO_BOUNDARY) { bchar = NON_CHAR; } cur_r = bchar; lig_stack = null; goto main_lig_loop; main_loop_lookahead_1: adjust_space_factor(); fast_new_avail(lig_stack); font(lig_stack) = main_f; character(lig_stack) = cur_r = cur_chr; if (cur_r == false_bchar) { cur_r = NON_CHAR; } main_lig_loop: if (char_tag(main_i) != LIG_TAG) { goto main_loop_wrapup; } main_k = lig_kern_start(main_f, main_i); main_j = *main_k; if (skip_byte(main_j) <= STOP_FLAG) { goto main_lig_loop_2; } main_k = lig_kern_restart(main_f, main_j); main_lig_loop_1: main_j = *main_k; main_lig_loop_2: if (next_char(main_j) == cur_r && skip_byte(main_j) <= STOP_FLAG) { if (op_byte(main_j) >= KERN_FLAG) { wrapup(rt_hit); tail_append(new_kern(char_kern(main_f, main_j))); goto main_loop_move; } if (cur_l == NON_CHAR) { lft_hit = TRUE; } else if (lig_stack == null) { rt_hit = TRUE; } if(interrupted) throw std::logic_error("interrupted"); switch (op_byte(main_j)) { case 1: case 5: cur_l = rem_byte(main_j); main_i = char_info(main_f, cur_l); ligature_present = TRUE; break; case 2: case 6: cur_r = rem_byte(main_j); if (lig_stack == null) { lig_stack = new_lig_item(cur_r); bchar = NON_CHAR; } else if (is_char_node(lig_stack)) { main_p = lig_stack; lig_stack = new_lig_item(cur_r); lig_ptr(lig_stack) = main_p; } else { character(lig_stack) = cur_r; } break; case 3: cur_r = rem_byte(main_j); main_p = lig_stack; lig_stack = new_lig_item(cur_r); link(lig_stack) = main_p; break; case 7: case 11: wrapup(FALSE); cur_q = tail; cur_l = rem_byte(main_j); main_i = char_info(main_f, cur_l); ligature_present = TRUE; break; default: cur_l = rem_byte(main_j); ligature_present = TRUE; if (lig_stack == null) { goto main_loop_wrapup; } else { goto main_loop_move_1; } break; } if (op_byte(main_j) > 4 && op_byte(main_j) != 7) goto main_loop_wrapup; if (cur_l < NON_CHAR) goto main_lig_loop; main_k = bchar_label(main_f); goto main_lig_loop_1; } if (skip_byte(main_j) == 0) { incr(main_k); } else { if (skip_byte(main_j) >= STOP_FLAG) goto main_loop_wrapup; main_k += skip_byte(main_j) + 1; } goto main_lig_loop_1; main_loop_move_lig: main_p = lig_ptr(lig_stack); if (main_p != null) { tail_append(main_p); } main_t = lig_stack; lig_stack = link(main_t); free_node(main_t, SMALL_NODE_SIZE); main_i = char_info(main_f, cur_l); ligature_present = TRUE; if (lig_stack == null) { if (main_p != null) { goto main_loop_lookahead; } else { cur_r = bchar; } } else { cur_r = character(lig_stack); } goto main_lig_loop; append_normal_space: if (space_skip == zero_glue) { main_p = font_glue(cur_font); if (main_p == null) main_p = find_font_glue(cur_font); main_t = new_glue(main_p); } else { main_t = new_param_glue(SPACE_SKIP_CODE); } tail_append(main_t); goto big_switch; }
int main(int argc, char ** argv) { char * fn; int ix; if (3 > argc) return fprintf(stderr, "Specify library file name and copy file name(s).\n"), 1; if (openout(argv[1])) return 16; if (getdir(cards * 80)) return 20; for (ix = 2; argv[ix]; ix++) { char * dot; char * slash; char * name; int namelen; int ismacro = 1; /* Assume file is macro */ char * s; fn = argv[ix]; f = fopen(fn, "r"); if (!f) return fprintf(stderr, "Cannot open %s: %s\n", fn, strerror(errno)), 16; slash = strrchr(fn, '/'); name = slash ? slash + 1 : fn; namelen = strlen(name); dot = strrchr(name, '.'); if (dot) { namelen = dot - name; if (!strcmp(dot + 1, "copy")) ismacro = 0; } s = gline(); if (!s) continue; if (!ismacro && memcmp(s, "*COPY ", 6)) ismacro = 1; /* Not stacked copy */ if (ismacro) { loadname(name, namelen); if (doline(line)) return 20; } else if (newmember(s)) return 20; for (;;) { s = gline(); if (!s) break; if (!ismacro && !memcmp(s, "*COPY ", 6)) { if (eom()) return 20; if (newmember(s)) return 20; continue; } if (doline(line)) return 20; } if (eom()) return 20; } if (wrapup(dirs, dir)) return 16; printf("%s %d files %d members.\n", fno, ix - 2, members); return 0; }