int main(void) { static char buf[100]; static char bufCNM[100]; int fd; // Assumes three file descriptors open. while((fd = open("console", O_RDWR)) >= 0){ if(fd >= 3){ close(fd); break; } } // Read and run input commands. while(getcmd(buf, sizeof(buf)) >= 0){ if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){ // Clumsy but will have to do for now. // Chdir has no effect on the parent if run in the child. buf[strlen(buf)-1] = 0; // chop \n if(chdir(buf+3) < 0) printf(2, "cannot cd %s\n", buf+3); else{ if((buf + 3)[0] == '.' && (buf + 3)[1] == '.' && (buf + 3)[2] == 0){ cutChild(currentDir); if(currentDir[0] == 0) isRootDir = 1; continue; } if(isRootDir){ catenate(currentDir, buf + 3); isRootDir = 0; } else{ append(currentDir, '/'); catenate(currentDir, buf + 3); } } continue; } if(fork1() == 0) { int i; int len = strlen(buf); for(i = len + 1; i > 0; i--) { bufCNM[i] = buf[i-1]; } bufCNM[0] = '/'; runcmd(parsecmd(buf)); if(buf[0] != '/') { runcmd(parsecmd(bufCNM)); } exit(); } wait(); } exit(); }
BoxList& BoxList::complementIn (const Box& b, const BoxList& bl) { BL_ASSERT(bl.ixType() == b.ixType()); if (bl.size() == 1) { *this = BoxLib::boxDiff(b,bl.front()); } else { clear(); Box mbox = bl.minimalBox(); BoxList diff = BoxLib::boxDiff(b,mbox); catenate(diff); BoxArray ba(bl); BoxList mesh(b.ixType()); if (mbox.ok()) mesh.push_back(mbox); mesh.maxSize(BL_SPACEDIM == 3 ? 64 : 128); std::vector< std::pair<int,Box> > isects; for (BoxList::const_iterator bli = mesh.begin(), End = mesh.end(); bli != End; ++bli) { const Box& bx = *bli & b; if (!bx.ok()) continue; ba.intersections(bx,isects); if (isects.empty()) { push_back(bx); } else { BoxList tm(b.ixType()), tmpbl(b.ixType()); for (int i = 0, N = isects.size(); i < N; i++) tmpbl.push_back(isects[i].second); tm.complementIn_base(bx,tmpbl); catenate(tm); } } } return *this; }
int main(int argc, char** argv) { // help to optimize c++ stream I/O (may screw up threaded I/O though) std::ios_base::sync_with_stdio(false); int result = 0; try { CollectorApp myApp(argc, argv); bool startup_OK = myApp.Startup(); if (startup_OK) { myApp.Run(); myApp.Shutdown(); } else { std::cout << "Problems starting program. No processing done.\n"; } } catch (const std::exception& theProblem) { spdlog::error(catenate("Something fundamental went wrong: ", theProblem.what())); result = 7; } catch (...) { spdlog::error("Something totally unexpected happened."); result = 9; } return result; }
/* * Main process for cpp -- copies tokens from the current input * stream (main file, include file, or a macro) to the output * file. */ void cppmain() { int c; /* Current character */ int counter; /* newlines and spaces */ /* * Explicitly output a #line at the start of cpp output so * that lint (etc.) knows the name of the original source * file. If we don't do this explicitly, we may get * the name of the first #include file instead. * We also seem to need a blank line following that first #line. */ #ifdef EVALDEFS if ( !bIsInEval ) #endif { sharp(); PUTCHAR('\n'); } /* * This loop is started "from the top" at the beginning of each line * wrongline is set TRUE in many places if it is necessary to write * a #line record. (But we don't write them when expanding macros.) * * The counter variable has two different uses: at * the start of a line, it counts the number of blank lines that * have been skipped over. These are then either output via * #line records or by outputting explicit blank lines. * When expanding tokens within a line, the counter remembers * whether a blank/tab has been output. These are dropped * at the end of the line, and replaced by a single blank * within lines. */ for (;;) { counter = 0; /* Count empty lines */ for (;;) { /* For each line, ... */ while (type[(c = get())] == SPA) /* Skip leading blanks */ ; /* in this line. */ if (c == '\n') /* If line's all blank, */ ++counter; /* Do nothing now */ else if (c == '#') { /* Is 1st non-space '#' */ keepcomments = FALSE; /* Don't pass comments */ counter = control(counter); /* Yes, do a #command */ keepcomments = (cflag && compiling); } else if (c == EOF_CHAR) /* At end of file? */ { break; } else if (!compiling) { /* #ifdef false? */ skipnl(); /* Skip to newline */ counter++; /* Count it, too. */ } else { break; /* Actual token */ } } if (c == EOF_CHAR) /* Exit process at */ break; /* End of file */ /* * If the loop didn't terminate because of end of file, we * know there is a token to compile. First, clean up after * absorbing newlines. counter has the number we skipped. */ if ((wrongline && infile->fp != NULL) || counter > 4) sharp(); /* Output # line number */ else { /* If just a few, stuff */ while (--counter >= 0) /* them out ourselves */ PUTCHAR('\n'); } /* * Process each token on this line. */ unget(); /* Reread the char. */ for (;;) { /* For the whole line, */ do { /* Token concat. loop */ for (counter = 0; type[(c = get())] == SPA;) { #if COMMENT_INVISIBLE if (c != COM_SEP) #endif counter++; /* Skip over blanks */ } if (c == EOF_CHAR || c == '\n') goto end_line; /* Exit line loop */ else if (counter > 0) /* If we got any spaces */ PUTCHAR(' '); /* Output one space */ c = macroid(c); /* Grab the token */ } while (type[c] == LET && catenate()); if (c == EOF_CHAR || c == '\n') /* From macro exp error */ goto end_line; /* Exit line loop */ switch (type[c]) { case LET: fputs(token, pCppOut); /* Quite ordinary token */ #ifdef EVALDEFS { int len; if ( bIsInEval && nEvalOff + (len=strlen(token)) < NEVALBUF ) { strcpy( &EvalBuf[nEvalOff], token ); nEvalOff += len; } } #endif break; case DIG: /* Output a number */ case DOT: /* Dot may begin floats */ #ifdef EVALDEFS if ( bIsInEval ) scannumber(c, outputEval); else scannumber(c, output); #else scannumber(c, output); #endif break; case QUO: /* char or string const */ scanstring(c, output); /* Copy it to output */ break; default: /* Some other character */ cput(c); /* Just output it */ #ifdef EVALDEFS if ( bIsInEval && nEvalOff < NEVALBUF ) EvalBuf[nEvalOff++] = c; #endif break; } /* Switch ends */ } /* Line for loop */ end_line: if (c == '\n') { /* Compiling at EOL? */ PUTCHAR('\n'); /* Output newline, if */ if (infile->fp == NULL) /* Expanding a macro, */ wrongline = TRUE; /* Output # line later */ } } /* Continue until EOF */ #ifdef EVALDEFS if ( bIsInEval ) EvalBuf[nEvalOff++] = '\0'; #endif }
INLINE FILE_LOCAL ReturnCode cppmain(struct Global *global) { /* * Main process for cpp -- copies tokens from the current input * stream (main file, include file, or a macro) to the output * file. */ int c; /* Current character */ int counter; /* newlines and spaces */ ReturnCode ret; /* return code variable type */ long bracelevel = 0; long parenlevel = 0; long bracketlevel = 0; int fake = 0; #define MAX_FUNC_LENGTH 50 char tempfunc[MAX_FUNC_LENGTH + 1]; char tempfunc2[MAX_FUNC_LENGTH + 1]; char define = 0; /* probability of a function define phase in the program */ char prev = 0; /* previous type */ char go = 0; char include = 0; char initfunc = 0; /* Initialize for reading tokens */ global->tokenbsize = 50; global->tokenbuf = malloc(global->tokenbsize + 1); if(!global->tokenbuf) return(FPP_OUT_OF_MEMORY); global->functionname = malloc(global->tokenbsize + 1); if(!global->functionname) return(FPP_OUT_OF_MEMORY); global->functionname[0] = '\0'; if(global->showspace) { global->spacebuf = (char *)malloc(MAX_SPACE_SIZE); if(!global->spacebuf) return(FPP_OUT_OF_MEMORY); } if(global->showversion) Error(global, VERSION_TEXT); /* * Explicitly output a #line at the start of cpp output so * that lint (etc.) knows the name of the original source * file. If we don't do this explicitly, we may get * the name of the first #include file instead. */ if(global->linelines) /* if #line lines are wanted! */ sharp(global); /* * This loop is started "from the top" at the beginning of each line * wrongline is set TRUE in many places if it is necessary to write * a #line record. (But we don't write them when expanding macros.) * * The counter variable has two different uses: at * the start of a line, it counts the number of blank lines that * have been skipped over. These are then either output via * #line records or by outputting explicit blank lines. * When expanding tokens within a line, the counter remembers * whether a blank/tab has been output. These are dropped * at the end of the line, and replaced by a single blank * within lines. */ include = global->included; while(include--) { openinclude(global, global->include[include], TRUE); } for (;;) { counter = 0; /* Count empty lines */ for (;;) { /* For each line, ... */ global->comment = FALSE; /* No comment yet! */ global->chpos = 0; /* Count whitespaces */ while (type[(c = get(global))] == SPA) /* Skip leading blanks */ if(global->showspace) { if(global->chpos<MAX_SPACE_SIZE-1) /* we still have buffer to store this! */ global->spacebuf[global->chpos++]=(char)c; } if (c == '\n') { /* If line's all blank, */ if(global->comment) { /* A comment was output! */ Putchar(global, '\n'); } else ++counter; /* Do nothing now */ } else if (c == '#') { /* Is 1st non-space '#' */ global->keepcomments = FALSE; /* Don't pass comments */ ret = control(global, &counter); /* Yes, do a #command */ if(ret) return(ret); global->keepcomments = (global->cflag && compiling); } else if (c == EOF_CHAR) /* At end of file? */ break; else if (!compiling) { /* #ifdef false? */ skipnl(global); /* Skip to newline */ counter++; /* Count it, too. */ } else { break; /* Actual token */ } } if (c == EOF_CHAR) /* Exit process at */ break; /* End of file */ /* * If the loop didn't terminate because of end of file, we * know there is a token to compile. First, clean up after * absorbing newlines. counter has the number we skipped. */ if(global->linelines) { /* if #line lines are wanted! */ if ((global->wrongline && global->infile->fp != NULL) || counter > 4) sharp(global); /* Output # line number */ else { /* If just a few, stuff */ while (--counter >= 0) /* them out ourselves */ Putchar(global, (int)'\n'); } } if(global->showspace) { /* Show all whitespaces! */ global->spacebuf[global->chpos] = '\0'; Putstring(global, global->spacebuf); } /* * Process each token on this line. */ unget(global); /* Reread the char. */ for (;;) { /* For the whole line, */ do { /* Token concat. loop */ for (global->chpos = counter = 0; (type[(c = get(global))] == SPA);) { #if COMMENT_INVISIBLE if (c != COM_SEP) counter++; #else if(global->showspace && global->chpos < MAX_SPACE_SIZE-1) { global->spacebuf[global->chpos++]=(char)c; } counter++; /* Skip over blanks */ #endif } if (c == EOF_CHAR || c == '\n') break; /* Exit line loop */ else if (counter > 0) { /* If we got any spaces */ if(!global->showspace) /* We don't output all spaces */ Putchar(global, (int)' ');/* Output one space */ else { global->spacebuf[global->chpos] = '\0'; Putstring(global, global->spacebuf); /* Output all whitespaces */ } } if(ret=macroid(global, &c)) /* Grab the token */ return(ret); } while (type[c] == LET && catenate(global, &ret) && !ret); if(ret) /* If the loop was broken because of a fatal error! */ return(ret); if (c == EOF_CHAR || c == '\n') /* From macro exp error */ break; /* Exit line loop */ go++; switch (type[c]) { case LET: go =0; /* Quite ordinary token */ Putstring(global, global->tokenbuf); if(!define) { /* Copy the name */ strncpy(tempfunc, global->tokenbuf, MAX_FUNC_LENGTH); tempfunc[MAX_FUNC_LENGTH]=0; } /* fputs(global->tokenbuf, stdout); */ break; case DIG: /* Output a number */ case DOT: /* Dot may begin floats */ go = 0; ret=scannumber(global, c, (ReturnCode(*)(struct Global *, int))output); if(ret) return(ret); break; case QUO: /* char or string const */ go = 0; /* Copy it to output */ if(!global->webmode) { ret=scanstring(global, c, (ReturnCode(*)(struct Global *, int))output); if(ret) return(ret); break; } /* FALLTHROUGH */ default: /* Some other character */ define++; switch(c) { case '{': if(! bracelevel++ && define > 2) { /* * This is a starting brace. If there is a probability of a * function defining, we copy the `tempfunc' function name to * `global->functionname'. */ strcpy(global->functionname, tempfunc2); global->funcline = global->line; if(global->outputfunctions) { /* * Output the discovered function name to stderr! */ Error(global, "#> Function defined at line %d: %s <#\n", global->line, global->functionname); } if(global->initialfunc) { int a; for(a=0; a<global->excluded; a++) { /* check for excluded functions */ if(!strcmp(global->functionname, global->excludedinit[a])) break; } if(a==global->excluded) { expstuff(global, "__brace__", "{"); expstuff(global, "__init_func__", global->initialfunc); initfunc = TRUE; } } } break; case '}': go = 0; if( (--bracelevel == initfunc) && strcmp(global->infile->filename, "__init_func__") ) { /* we just stepped out of the function! */ global->functionname[0] = '\0'; global->funcline = 0; define = 1; if(initfunc) { Putchar(global, '}'); bracelevel--; initfunc=0; } } fake = 0; break; case ';': case ',': if(go == 2) { define = 1; fake = 0; go--; break; } break; case '(': if(! parenlevel++ && !bracelevel) { if(go == 2) { /* foobar(text) -> "(" is found. This can't be a function */ go--; define = 1; break; } if( define < 2 && prev == LET) { /* This is the first parenthesis on the ground brace level, and we did previously not have a probable function name */ strncpy(tempfunc2, global->tokenbuf, MAX_FUNC_LENGTH); tempfunc2[MAX_FUNC_LENGTH]=0; define++; } else { /* we have a fake start */ fake++; } } break; case ')': if(! --parenlevel && !bracelevel && define>1 && !fake) { /* * The starting parentheses level and * the starting brace level. * This might be the start of a function defining coming * up! */ define++; /* increase probability */ fake = 0; go = 1; } break; case '[': bracketlevel++; break; case ']': bracketlevel--; break; } define--; /* decrease function probability */ Putchar(global, c); /* Just output it */ break; } /* Switch ends */ prev = type[c]; } /* Line for loop */ if (c == '\n') { /* Compiling at EOL? */ Putchar(global, '\n'); /* Output newline, if */ if (global->infile->fp == NULL) /* Expanding a macro, */ global->wrongline = TRUE; /* Output # line later */ } } /* Continue until EOF */ if(global->showbalance) { if(bracketlevel) { cwarn(global, WARN_BRACKET_DEPTH, bracketlevel); } if(parenlevel) { cwarn(global, WARN_PAREN_DEPTH, parenlevel); } if(bracelevel) { cwarn(global, WARN_BRACE_DEPTH, bracelevel); } } if (global->wflag) { global->out = TRUE; /* enable output */ outdefines(global); /* Write out #defines */ } return(FPP_OK); }
/** * Build the clause for the expression e. Does not change e */ static Clause * build_clause(Exp *e, int cost_cutoff) { Clause *c = NULL, *c1, *c2, *c3, *c4, *c_head; E_list * e_list; assert(e != NULL, "build_clause called with null parameter"); if (e->type == AND_type) { c1 = (Clause *) xalloc(sizeof (Clause)); c1->c = NULL; c1->next = NULL; c1->cost = 0; c1->maxcost = 0 ; for (e_list = e->u.l; e_list != NULL; e_list = e_list->next) { c2 = build_clause(e_list->e, cost_cutoff); c_head = NULL; for (c3 = c1; c3 != NULL; c3 = c3->next) { for (c4 = c2; c4 != NULL; c4 = c4->next) { c = (Clause *) xalloc(sizeof (Clause)); c->cost = c3->cost + c4->cost; c->maxcost = MAX(c3->maxcost,c4->maxcost); c->c = catenate(c3->c, c4->c); c->next = c_head; c_head = c; } } free_clause_list(c1); free_clause_list(c2); c1 = c_head; } c = c1; } else if (e->type == OR_type) { /* we'll catenate the lists of clauses */ c = NULL; for (e_list = e->u.l; e_list != NULL; e_list = e_list->next) { c1 = build_clause(e_list->e, cost_cutoff); while(c1 != NULL) { c3 = c1->next; c1->next = c; c = c1; c1 = c3; } } } else if (e->type == CONNECTOR_type) { c = (Clause *) xalloc(sizeof(Clause)); c->c = build_terminal(e); c->cost = 0; c->maxcost = 0; c->next = NULL; } else { assert(FALSE, "an expression node with no type"); } /* c now points to the list of clauses */ for (c1 = c; c1 != NULL; c1 = c1->next) { c1->cost += e->cost; /* c1->maxcost = MAX(c1->maxcost,e->cost); */ /* Above is how Dennis had it. Someone changed it to below. * However, this can sometimes lead to a maxcost that is less * than the cost ! -- which seems wrong to me ... seems Dennis * had it right!? */ c1->maxcost += e->cost; } return c; }