//eka, to dump temperature in transistor layer and map it //back to structures in power model void ThermTrace::BlockT2StrcTMap() { //strTemp->resize(energyCntrNames_->size()); // eka,Find mappings between variables and flp and // copy temperature to each match (power model structure) //FIXME: Move the mapping to config, avoid doing it in runtime for(size_t id=0;id<flp.size();id++) { for(size_t i=0; i<flp[id]->match.size(); i++) { for(size_t j=0; j<mapping.size(); j++) { if (grep(mapping[j].name, flp[id]->match[i])) { //LOG("mapping[%d].map[%d]=%d (%s -> %s)", // (int) j, (int) mapping[j].map.size(), (int) id, // flp[id]->match[i], mapping[j].name); //find index of match in energyCntrNames int index=-1; for (int ii=0; ii < (int) energyBundle->cntrs.size(); ii++){ string name = energyBundle->cntrs[ii].getName(); if (name.compare(flp[id]->match[i]) == 0){ index = ii; break; } } if (index == -1){ LOG("Could not find the map for <%s> in Power Counters.",flp[id]->match[i] ); }else{ flp[id]->blk2strMap.push_back(index); } } } } } }
TEST(TestMultiGrep, TestGrep6) { std::string line; MultiGrep grep(2); grep.process("hi1\n", true); // x - M ASSERT_TRUE(grep.hasNext()); grep.getNext(line); ASSERT_EQ("hi1\n", line); grep.process("hi2\n", false); // x ASSERT_TRUE(grep.hasNext()); grep.getNext(line); ASSERT_EQ("hi2\n", line); grep.process("hi3\n", false); // x ASSERT_TRUE(grep.hasNext()); grep.getNext(line); ASSERT_EQ("hi3\n", line); grep.process("hi4\n", false); ASSERT_FALSE(grep.hasNext()); grep.process("hi5\n", false); // x ASSERT_FALSE(grep.hasNext()); grep.process("hi6\n", false); // x ASSERT_FALSE(grep.hasNext()); grep.process("hi7\n", true); // x - M ASSERT_TRUE(grep.hasNext()); grep.getNext(line); ASSERT_EQ("hi5\n", line); ASSERT_TRUE(grep.hasNext()); grep.getNext(line); ASSERT_EQ("hi6\n", line); ASSERT_TRUE(grep.hasNext()); grep.getNext(line); ASSERT_EQ("hi7\n", line); ASSERT_FALSE(grep.hasNext()); }
/** * 5.10 grep * main 関数の引数 */ int main(int argc, char *argv[]) { int c, except = 0, number = 0; while( --argc > 0 && (*++argv)[0] == '-'){ while(c = *++argv[0]){ switch(c){ case 'x': except = 1; break; case 'n': number = 1; break; default: printf("find: illegal option %c\n", c); argc = 0; break; } } } if(argc != 1){ printf("Usage: find -x -n pattern\n"); return -1; }else{ return grep( *argv, number, except); } }
int main(int argc, char *argv[]) { char* line; g_progname = argv[0]; switch (argc) { case 2: break; case 1: die("too few arguments (need regexp pattern)"); default: die("too many arguments (only one pattern accepted)"); } while ((line = readln()) != NULL) grep(line, argv[1]); switch (errno) { /* find out why readln() couldn't get another line */ case 0: break; case EIO: die("couldn't read from standard input"); case ENOMEM: die("out of memory (can't store input)"); } freeln(line); /* "TODO": More code here, that justifies bothering to call freeln() * * before program termination (which frees all heap memory). */ return EXIT_SUCCESS; }
int main(int argc, char** argv) { // grep файл подстрока // grep -l директория подстрока // Проверка на корректность числа аргументов if( (argc != 3) && (argc != 4) ) { perror("Uncorrect arguments number"); _exit(1); } char* file_name; char* str; // Выполнение функции grep if(strcmp(argv[1], "-l")) { file_name = argv[1]; str = argv[2]; grep(file_name, str); } // Выполнение функции grep -l else { file_name = argv[2]; str = argv[3]; grep_l(file_name, str); } return 0; }
void ThermTrace::loadLkgCoefs(){ // eka,Find mappings between variables and flp and // to find the device type for each flp block for(size_t id=0;id<flp.size();id++) { for(size_t i=0; i<flp[id]->match.size(); i++) { for(size_t j=0; j<mapping.size(); j++) { if (grep(mapping[j].name, flp[id]->match[i])) { //set the device type switch(energyBundle->cntrs[j].getDevType()){ case 0: flp[id]->devType.set(hpThLeakageCoefs); break; case 1: flp[id]->devType.set(lstpThLeakageCoefs); break; case 2: flp[id]->devType.set(lpThLeakageCoefs); break; default:break; } } } } } }
/* "match" tests whether the source matches the pattern exactly */ boolean match(Char *source_, Char *pattern_) { Char source[256], pattern[256]; static Char target[256] = ""; strcpy(source, source_); strcpy(pattern, pattern_); grep(source, pattern, target); return (*source == '\0' && *pattern == '\0'); }
/* read a line, trying to find 'variable = value' Currently groks two constructs: VAR=value : {VAR=value} using regex to analyze them. The variable is added to the symbol table. In the first case, it overrides an old value, not in the second case. */ boolean parse_variable(string line) { char **vars; static char *r1 = "^[[:space:]]*([[:alnum:]_]+)=[[:space:]]*([^[:space:]]*)[[:space:]]*.*$"; static char *r2 = "^:[[:space:]]+\\$\\{([[:alnum:]_]+)=([^\\}]*)\\}[[:space:]]*.*$"; if ((vars = grep(r1, line, 2))) { setval(vars[1], vars[2]); return true; } else if ((vars = grep(r2, line, 2))) { setval_default(vars[1], vars[2]); return true; } else WARNING1("The following line has not been parsed:\n%s\n", line); return false; }
/* "translate" replaces the pattern by the target in the source. */ Char *translate(Char *Result, Char *source_, Char *pattern_, Char *target_) { Char source[256], pattern[256], target[256]; strcpy(source, source_); strcpy(pattern, pattern_); strcpy(target, target_); grep(source, pattern, target); return strcpy(Result, target); }
/* find: print lines that match pattern from 1st arg */ int main(int argc, char *argv[]) { char *line; long lineno = 0; int c, number = 0, found = 0; while (--argc > 0 && (*++argv)[0] == '-') while ((c = *++argv[0])) switch (c) { case 'x': except = 1; break; case 'n': number = 1; break; default: printf("find: illegal option %c\n", c); argc = 0; found = -1; break; } if (argc < 1) { fprintf(stderr, "Usage: find -x -n pattern\n"); exit(1); } else { char *pattern = *argv++; argc--; if (argc > 0) while (argc-- > 0) { FILE *f = fopen(*argv, "r"); if (f == NULL) { fprintf(stderr, "Unable to read file %s\n", *argv); } else { found += grep(pattern, f); } fclose(f); argv++; } else found += grep(pattern, stdin); } return found; }
int main(int argc, char *argv[]) { int n_tasks, rank, rc, tag=1; unsigned int i = 0; unsigned int n_linhas, size_job; unsigned int job[2]; MPI_Status Stat; MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD, &n_tasks); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if(rank == 0) { n_linhas = numero_de_linhas(); size_job = n_linhas/(n_tasks-1); if((n_linhas % (n_tasks-1)) != 0) size_job++; //printf("size_job: %d\n\n",size_job); for(i=1;i<n_tasks;i++) { job[0] = (i-1)*size_job + 1; job[1] = i*size_job; if(job[0] > n_linhas) job[0] = n_linhas; if(job[1] > n_linhas) job[1] = n_linhas; rc = MPI_Send(&job, 2, MPI_INT, i, tag, MPI_COMM_WORLD); } } else { rc = MPI_Recv(&job, 2, MPI_INT, 0, tag, MPI_COMM_WORLD, &Stat); //printf("rank%d: %d a %d\n",rank,job[0],job[1]); grep(rank,job[0],job[1]); } MPI_Finalize(); return 0; }
void real_main (int argc, char *const argv[]) { int found = 0; int i = 1; panic_code = 2; for (; i < argc && argv[i][0] == '-'; ++i) parse_options (argv[i] + 1); if (i == argc) usage (); else if (i + 1 == argc) found = grep (argv[i], stdin, NULL); else { const char *regexp = argv[i++]; showing_filenames = (1 < argc - i); for (; i < argc; ++i) { FILE *in = must_fopen (argv[i], "r"); found |= grep (regexp, in, argv[i]); must_fclose (in, argv[i]); } } exit (!found); }
int main( int argc, char *argv[] ){ char *pattern; int found = 0; FILE *fp; while( --argc > 0 && (*++argv)[0] == '-' ) while( *++argv[ 0 ] ) switch( **argv ){ case 'x': except = 1; break; case 'n': number = 1; break; case 'w': name = 1; break; default: fprintf( stderr, "grep: illegal option %c\n", **argv ); return 0; } if( argc == 0 ){ fprintf( stderr, "Usage: grep -x -n -w pattern files\n" ); return 0; } pattern = *argv++; if( !*argv ) found = grep( pattern, stdin, "stdin" ); else while( *argv ){ if( (fp = fopen( *argv, "r" )) == NULL ){ fprintf( stderr, "grep: %s: error opening file\n", *argv ); return 0; } else { found += grep( pattern, fp, *argv ); fclose( fp ); } argv++; } return found; }
BoincError TestBoincHttpPostForm(void * data) { post_index = 0; char* form = "go=1&search=boinc"; BoincError res = boincHttpPost("http://fr.wikipedia.org/wiki/Sp%C3%A9cial:Recherche", TMPFILE, strlen(form), TestBoincHttpPostCallback, form); if (!res) { if (grep(TMPFILE, "BOINC")) if (zgrep(TMPFILE, "BOINC")) res = boincErrorCreate(kBoincError, 999, "String 'BOINC' not found in result file"); } remove(TMPFILE); return res; }
int main (void) { int sdb1, mnt, proc; while (1) { sdb1 = grep ("sdb1", "/proc/diskstats"); mnt = grep ("sdb1", "/proc/mounts"); if (sdb1 && !mnt) { if ((proc = pgrep (VICTIM)) != 0) kill (proc, SIGTERM); mount (SOURCE, TARGET, "vfat", MS_RDONLY, NULL); } if (!sdb1 && mnt) { if ((proc = pgrep (VICTIM)) != 0) kill (proc, SIGTERM); umount (TARGET); } sleep (DELAY); } }
int main (int argc, char * * argv) { cppshell::Command ls("ls"); cppshell::Command grep("grep"); cppshell::Command sort("sort"); // auto s = (ls % "-lh" % "/tmp")(); // auto s = (ls[{"-lh", "/tmp"}] | grep[{"a"}] | sort) (); auto s = (ls[{"-lh", "/tmp"}] | grep[{"a"}]) (); // auto s = (ls[{"-lh", "/tmp"}]) (); // ls[{"-lh", "/tmp", "/"}]; std::cout << "stdout :" << std::endl; std::cout << s << std::endl; return 0; }
TEST(TestMultiGrep, TestGrep7) { std::string line; MultiGrep grep(0); // no multiple lines, no buffering grep.process("hi1\n", true); // x - M ASSERT_TRUE(grep.hasNext()); grep.getNext(line); ASSERT_EQ("hi1\n", line); grep.process("hi2\n", false); ASSERT_FALSE(grep.hasNext()); grep.process("hi3\n", true); // x - M ASSERT_TRUE(grep.hasNext()); grep.getNext(line); ASSERT_EQ("hi3\n", line); ASSERT_FALSE(grep.hasNext()); }
int cycle (mpf_t x) { char s[10000]; char srch[SSIZE+1]; int i; mp_exp_t e; mpf_get_str (s, &e, 10, 10000, x); // copy a search string for (i=0; i<SSIZE; i++) srch[i] = s[i+SSIZE]; srch[i]='\0'; return grep(srch, s+SSIZE+1); }
void Index::scan(QString path, QString match) { QString spec; QString name; if(path.isEmpty()) spec = QDir::currentPath(); else spec = QDir::currentPath() + QDir::separator() + path; QDir dir(spec); if(!dir.exists()) return; QDir::Filters filter = QDir::Files | QDir::NoDot; QDir::SortFlags sorting = QDir::SortFlags(QDir::Name); if(!Main::casefilter) sorting |= QDir::IgnoreCase; QStringList dirs = dir.entryList(QDir::AllDirs, sorting); dir.setNameFilters(filters); QStringList list = dir.entryList(filter, sorting); for(unsigned pos = 0; pos < (unsigned)dirs.size(); ++pos) { if(dirs[pos][0] == '.') continue; if(path.isEmpty()) scan(dirs[pos], match); else scan(path + QDir::separator() + dirs[pos], match); } for(unsigned pos = 0; pos < (unsigned)list.size(); ++pos) { if(list[pos][0] == '.') continue; if(path.isEmpty()) name = list[pos]; else name = path + QDir::separator() + list[pos]; if(!match.isEmpty() && !grep(name, match)) continue; names << name; ++rows; } }
int main() { int c; char ch; int j; char str[10]; int ret = 0; while (gi < MAX) { printf ("enter your choice\n\n"); printf ("D or dfor display\n\n"); printf ("I or ifor insert a line\n"); printf ("s or S for search\n\n"); scanf ("%c", &ch); switch(ch) { case 'd': case 'D': for (j = 0; j < gi; j++) printf ("%s\n", array[j]); break; case 'i': case 'I': getline1(&array[gi++]); break; case 's': case 'S': printf ("enter the string"); scanf ("%s", str); ret = grep(array, str); if(ret) printf("string found at line no %d \n", ret); else printf ("string not found\n"); break; default: continue; } } }
void putlog (char *name, char *befbuf) //************************************************************************* // //************************************************************************* { #ifdef __FLAT__ html_putf("<b>%s:</b> <a href=cmd?cmd=slog>Syslog</a> | ", ms(m_otherlogs)); html_putf("<a href=cmd?cmd=erlog>Erase</a> | "); html_putf("<a href=cmd?cmd=swaplog>Swap</a> | "); html_putf("<a href=cmd?cmd=pwlog>PW</a> | "); html_putf("<a href=cmd?cmd=unknown>Unknown</a> | "); html_putf("<a href=cmd?cmd=rlog>Reject</a> | "); html_putf("<a href=cmd?cmd=sfhold>S&F-Hold</a>"); if ((m.tcpiptrace == 1) || (m.tcpiptrace == 8)) html_putf(" | <a href=cmd?cmd=httplog>HTTP</a>"); if ((m.tcpiptrace == 2) || (m.tcpiptrace == 8)) html_putf(" | <a href=cmd?cmd=nntplog>NNTP</a>"); if ((m.tcpiptrace == 3) || (m.tcpiptrace == 8)) html_putf(" | <a href=cmd?cmd=pop3log>POP3</a>"); if ((m.tcpiptrace == 4) || (m.tcpiptrace == 8)) html_putf(" | <a href=cmd?cmd=smtplog>SMTP</a>"); if ((m.tcpiptrace == 5) || (m.tcpiptrace == 8)) html_putf(" | <a href=cmd?cmd=ftplog>FTP</a>"); // html_putf("<form method=get action=\"/cmd\" target=\"txt\">\n"); // html_putf("Search: <input name=\"search\" value=\"\" size=40>"); // html_putf("<input type=\"submit\" value=\"Execute\">"); html_putf("<br><hr>"); #endif if (*befbuf) { // Optionen durchreichen if (b->optminus & o_i) b->optplus |= o_i; // wenn nicht explizit "-i-", ist "-i" default befbuf += blkill(befbuf); grep(name, befbuf, b->optplus); } else { fileio_text fio; fio.usefile(name); fio.settail(-2500); fio.tx(); } }
int main(int argc,char * argv[]) { int fd,offset=0,bytesread,readchar; char buff[1024]; char line[1024]; if(argc < 3) { fd = 0; } else { fd = open(argv[2],READ); } //get lines from file, print them if they match pattern //no regex support required(thank god) bytesread = read(fd,buff,1024); //printf("fd = %d,buff = %s,bytes read = %d\r\n",fd,buff,bytesread); do { //printf("\r\nBefore: buff: %s\r\n line: %s\r\n offset: %d\r\n",buff,line,offset); readchar = readUntilChar(buff,line,'\n',&offset); //printf("Chars read %d",readchar); if (offset == 1024) { //we have a split line to handle offset = 0; bytesread = read(fd,buff,1024); if (bytesread < 1024) { buff[bytesread] = '\0'; } readchar = readUntilChar(buff,line+readchar,'\n',&offset); } if (grep(argv[1],line)==1) { printf("%s\r\n",line); } }while(readchar != -1 ); }
int main(int argc, char *argv[]) { int c; char *pfind = NULL; int err; static struct option const long_options[] = { {"help", 0, NULL, 'h'}, {NULL, 0, NULL, 0} }; exit_status = EXIT_SUCESS; program_name = argv[0]; while((c = getopt_long(argc, argv, "h", long_options, NULL)) != -1) { switch(c) { case 'h': case 'H': grep_usage_exit(EXIT_SUCESS); break; default: grep_usage_exit(EXIT_FAILURE); break; } } if(argc - optind < 2) grep_usage_exit(EXIT_FAILURE); pfind = argv[optind++]; while(optind < argc) { if((err = grep(pfind, argv[optind++])) != 0) exit_status = EXIT_FAILURE; } exit(exit_status); }
bool CmdDoc::exec(CmdHelper* ch) { if(!init(ch)) return false; mCmd->regStdOpts("grep"); if(mCmd->wantHelp()) { mCmd->inOptBrief("grep", tr("Search in documentation")); } if(mCmd->isMissingParms()) { if(mCmd->printThisWay("[<FileNumber>|<Pattern>]")) return !hasError(); mCmd->printComment(tr( "Without any parameter will a table of all available documentation shown " "and you prompt to enter a file number to display the document. After quit " "reading the doc you will ask again to enter a file number. Hit RETURN " "to leave the loop.")); mCmd->printComment(tr( "When you give the <FileNumber> as parameter will the document shown immediately " "and you will not ask again for a new file number. You can limit the table " "by give a <Pattern> matching the document name. If the result is only one " "file will it shown immediately.")); mCmd->printNote(tr( "Text files are shown by UNIX 'less' command whereas other files will called " "with 'xdg-open' to use your preferred application.")); mCmd->aided(); return !hasError(); } if(mCmd->has("grep")) grep(); else list(); return !hasError(); }
int bulBeni(char *arguman, char *sstring, int lineNum) { struct stat stDirInfo; struct dirent * stFiles; DIR * stDirIn; pid_t pid; char szFullName[MAXPATHLEN]; /* dosya isimleri icin */ char szDirectory[MAXPATHLEN]; struct stat stFileInfo; int fd[2]; /* For pipe */ char bufin[BUFSIZE]; int countLess=0; /* for Less count */ char chr; /* for getchar() */ strncpy( szDirectory, arguman, MAXPATHLEN - 1 ); /* Error check */ if (lstat( szDirectory, &stDirInfo) < 0) { perror (szDirectory); return; } if (!S_ISDIR(stDirInfo.st_mode)) return; if ((stDirIn = opendir( szDirectory)) == NULL) /* klasor acilir */ { perror( szDirectory ); return; } /* klasorun icerigi okunur */ while (( stFiles = readdir(stDirIn)) != NULL) { sprintf(szFullName, "%s/%s", szDirectory, stFiles -> d_name ); if (lstat(szFullName, &stFileInfo) < 0) perror ( szFullName ); /* klasor mu diye bakilir, kalsor ise onunda icine girilir. */ if (S_ISDIR(stFileInfo.st_mode)) { if ((strcmp(stFiles->d_name , "..")) && (strcmp(stFiles->d_name , "."))) { /* recursive olarak ic icedosyalara girilebilir. */ bulBeni(szFullName, sstring, lineNum); } } else /* dosya ise */ { /* pipe */ if (pipe(fd) == -1) { perror("Failed to create the pipe"); exit(EXIT_FAILURE); } pid = fork(); /* prosesler oluşturulur */ /* Error check */ if(pid == -1) { perror("Error: Cannot fork \n"); exit(1); } /* pid 0 ise child dir. */ if (pid == 0) { printf("\npid:%ld , %s\n",(long)getpid(),szFullName); /* Ctrl + C sinyali yakalanir */ signal( SIGINT, signalChild ); /* grep fonksiyonu cagirilarak islemler yaptirilir. */ grep(szFullName, sstring, fd); exit(1); /* exit ile prosesler oldurulur. */ } else /* parent */ { /* childin pipe a yazdigini parent okur */ close(fd[1]); while(read(fd[0],bufin,BUFSIZE) > 0) { if(countLess == lineNum ) { chr = getchar(); /* q ya basilinca program biter */ if((chr == 'q')||( chr== 'Q')) exit(1); countLess = 0; } printf("%s",bufin); countLess++; } /* Sinyal geldiginde if e girer. */ if (doneflag) { /* Pipe yazilanin geri kalaninida okur ve programi bitirir. */ close(fd[1]); while(read(fd[0],bufin,BUFSIZE) > 0) { printf("%s",bufin); } printf("\n***** Parent killed. *****\n"); exit( doneflag ); } wait(NULL);/* parent child lari bekler. */ } } } /* end while */ /* Dosyalar kapatilir. */ while ((closedir(stDirIn) == -1) && (errno == EINTR)) ; return 0; }
int _alpm_runscriptlet(alpm_handle_t *handle, const char *filepath, const char *script, const char *ver, const char *oldver, int is_archive) { char arg0[64], arg1[3], cmdline[PATH_MAX]; char *argv[] = { arg0, arg1, cmdline, NULL }; char *tmpdir, *scriptfn = NULL, *scriptpath; int retval = 0; size_t len; if(_alpm_access(handle, NULL, filepath, R_OK) != 0) { _alpm_log(handle, ALPM_LOG_DEBUG, "scriptlet '%s' not found\n", filepath); return 0; } if(!is_archive && !grep(filepath, script)) { /* script not found in scriptlet file; we can only short-circuit this early * if it is an actual scriptlet file and not an archive. */ return 0; } strcpy(arg0, SCRIPTLET_SHELL); strcpy(arg1, "-c"); /* create a directory in $root/tmp/ for copying/extracting the scriptlet */ len = strlen(handle->root) + strlen("tmp/alpm_XXXXXX") + 1; MALLOC(tmpdir, len, RET_ERR(handle, ALPM_ERR_MEMORY, -1)); snprintf(tmpdir, len, "%stmp/", handle->root); if(access(tmpdir, F_OK) != 0) { _alpm_makepath_mode(tmpdir, 01777); } snprintf(tmpdir, len, "%stmp/alpm_XXXXXX", handle->root); if(mkdtemp(tmpdir) == NULL) { _alpm_log(handle, ALPM_LOG_ERROR, _("could not create temp directory\n")); free(tmpdir); return 1; } /* either extract or copy the scriptlet */ len += strlen("/.INSTALL"); MALLOC(scriptfn, len, free(tmpdir); RET_ERR(handle, ALPM_ERR_MEMORY, -1)); snprintf(scriptfn, len, "%s/.INSTALL", tmpdir); if(is_archive) { if(_alpm_unpack_single(handle, filepath, tmpdir, ".INSTALL")) { retval = 1; } } else { if(_alpm_copyfile(filepath, scriptfn)) { _alpm_log(handle, ALPM_LOG_ERROR, _("could not copy tempfile to %s (%s)\n"), scriptfn, strerror(errno)); retval = 1; } } if(retval == 1) { goto cleanup; } if(is_archive && !grep(scriptfn, script)) { /* script not found in extracted scriptlet file */ goto cleanup; } /* chop off the root so we can find the tmpdir in the chroot */ scriptpath = scriptfn + strlen(handle->root) - 1; if(oldver) { snprintf(cmdline, PATH_MAX, ". %s; %s %s %s", scriptpath, script, ver, oldver); } else { snprintf(cmdline, PATH_MAX, ". %s; %s %s", scriptpath, script, ver); } _alpm_log(handle, ALPM_LOG_DEBUG, "executing \"%s\"\n", cmdline); retval = _alpm_run_chroot(handle, SCRIPTLET_SHELL, argv, NULL, NULL); cleanup: if(scriptfn && unlink(scriptfn)) { _alpm_log(handle, ALPM_LOG_WARNING, _("could not remove %s\n"), scriptfn); } if(rmdir(tmpdir)) { _alpm_log(handle, ALPM_LOG_WARNING, _("could not remove tmpdir %s\n"), tmpdir); } free(scriptfn); free(tmpdir); return retval; }
int _alpm_runscriptlet(alpm_handle_t *handle, const char *installfn, const char *script, const char *ver, const char *oldver) { char scriptfn[PATH_MAX]; char cmdline[PATH_MAX]; char tmpdir[PATH_MAX]; char *argv[] = { "sh", "-c", cmdline, NULL }; char *scriptpath; int clean_tmpdir = 0; int retval = 0; if(access(installfn, R_OK)) { /* not found */ _alpm_log(handle, ALPM_LOG_DEBUG, "scriptlet '%s' not found\n", installfn); return 0; } /* creates a directory in $root/tmp/ for copying/extracting the scriptlet */ snprintf(tmpdir, PATH_MAX, "%stmp/", handle->root); if(access(tmpdir, F_OK) != 0) { _alpm_makepath_mode(tmpdir, 01777); } snprintf(tmpdir, PATH_MAX, "%stmp/alpm_XXXXXX", handle->root); if(mkdtemp(tmpdir) == NULL) { _alpm_log(handle, ALPM_LOG_ERROR, _("could not create temp directory\n")); return 1; } else { clean_tmpdir = 1; } /* either extract or copy the scriptlet */ snprintf(scriptfn, PATH_MAX, "%s/.INSTALL", tmpdir); if(strcmp(script, "pre_upgrade") == 0 || strcmp(script, "pre_install") == 0) { if(_alpm_unpack_single(handle, installfn, tmpdir, ".INSTALL")) { retval = 1; } } else { if(_alpm_copyfile(installfn, scriptfn)) { _alpm_log(handle, ALPM_LOG_ERROR, _("could not copy tempfile to %s (%s)\n"), scriptfn, strerror(errno)); retval = 1; } } if(retval == 1) { goto cleanup; } /* chop off the root so we can find the tmpdir in the chroot */ scriptpath = scriptfn + strlen(handle->root) - 1; if(!grep(scriptfn, script)) { /* script not found in scriptlet file */ goto cleanup; } if(oldver) { snprintf(cmdline, PATH_MAX, ". %s; %s %s %s", scriptpath, script, ver, oldver); } else { snprintf(cmdline, PATH_MAX, ". %s; %s %s", scriptpath, script, ver); } _alpm_log(handle, ALPM_LOG_DEBUG, "executing \"%s\"\n", cmdline); retval = _alpm_run_chroot(handle, "/bin/sh", argv); cleanup: if(clean_tmpdir && _alpm_rmrf(tmpdir)) { _alpm_log(handle, ALPM_LOG_WARNING, _("could not remove tmpdir %s\n"), tmpdir); } return retval; }
int main(int argc, char **argv) { const char *av = NULL; int db; int optchar; int option_index = 0; while ((optchar = getopt_long(argc, argv, "ace:ifgGIlL:noOpPqrstTuvVx", long_options, &option_index)) != EOF) { switch (optchar) { case 0: break; case 'a': aflag++; break; case 'c': cflag++; setcom(optchar); break; case 'e': av = optarg; break; case 'f': fflag++; xflag++; setcom(optchar); break; case 'g': gflag++; setcom(optchar); break; case 'G': Gflag++; break; case 'i': iflag++; break; case 'I': Iflag++; setcom(optchar); break; case 'l': lflag++; break; case 'L': file_list = optarg; break; case 'n': nflag++; if (optarg) { if (!strcmp(optarg, "sort")) nofilter |= SORT_FILTER; else if (!strcmp(optarg, "path")) nofilter |= PATH_FILTER; } else { nofilter = BOTH_FILTER; } break; case 'o': oflag++; break; case 'O': Oflag++; break; case 'p': pflag++; setcom(optchar); break; case 'P': Pflag++; setcom(optchar); break; case 'q': qflag++; setquiet(); break; case 'r': rflag++; break; case 's': sflag++; break; case 't': tflag++; break; case 'T': Tflag++; break; case 'u': uflag++; setcom(optchar); break; case 'v': vflag++; break; case 'V': Vflag++; break; case 'x': xflag++; break; case ENCODE_PATH: if (strlen(optarg) > 255) die("too many encode chars."); if (strchr(optarg, '/') || strchr(optarg, '.')) die("cannot encode '/' and '.' in the path."); set_encode_chars((unsigned char *)optarg); break; case FROM_HERE: { char *p = optarg; const char *usage = "usage: global --from-here=lineno:path."; context_lineno = p; while (*p && isdigit(*p)) p++; if (*p != ':') die_with_code(2, usage); *p++ = '\0'; if (!*p) die_with_code(2, usage); context_file = p; } break; case RESULT: if (!strcmp(optarg, "ctags-x")) format = FORMAT_CTAGS_X; else if (!strcmp(optarg, "ctags-xid")) format = FORMAT_CTAGS_XID; else if (!strcmp(optarg, "ctags")) format = FORMAT_CTAGS; else if (!strcmp(optarg, "path")) format = FORMAT_PATH; else if (!strcmp(optarg, "grep")) format = FORMAT_GREP; else if (!strcmp(optarg, "cscope")) format = FORMAT_CSCOPE; else die_with_code(2, "unknown format type for the --result option."); break; default: usage(); break; } } if (qflag) vflag = 0; if (show_help) help(); argc -= optind; argv += optind; /* * At first, we pickup pattern from -e option. If it is not found * then use argument which is not option. */ if (!av) { av = *argv; /* * global -g pattern [files ...] * av argv */ if (gflag && av) argv++; } if (show_version) version(av, vflag); /* * only -c, -u, -P and -p allows no argument. */ if (!av) { switch (command) { case 'c': case 'u': case 'p': case 'P': break; case 'f': if (file_list) break; default: usage(); break; } } /* * -u and -p cannot have any arguments. */ if (av) { switch (command) { case 'u': case 'p': usage(); default: break; } } if (tflag) xflag = 0; if (nflag > 1) nosource = 1; /* to keep compatibility */ if (print0) set_print0(); /* * remove leading blanks. */ if (!Iflag && !gflag && av) for (; *av == ' ' || *av == '\t'; av++) ; if (cflag && av && isregex(av)) die_with_code(2, "only name char is allowed with -c option."); /* * get path of following directories. * o current directory * o root of source tree * o dbpath directory * * if GTAGS not found, getdbpath doesn't return. */ getdbpath(cwd, root, dbpath, (pflag && vflag)); /* * print dbpath or rootdir. */ if (pflag) { fprintf(stdout, "%s\n", (rflag) ? root : dbpath); exit(0); } /* * incremental update of tag files. */ if (uflag) { STRBUF *sb = strbuf_open(0); char *gtags = usable("gtags"); if (!gtags) die("gtags command not found."); if (chdir(root) < 0) die("cannot change directory to '%s'.", root); strbuf_puts(sb, gtags); strbuf_puts(sb, " -i"); if (vflag) strbuf_putc(sb, 'v'); strbuf_putc(sb, ' '); strbuf_puts(sb, dbpath); if (system(strbuf_value(sb))) exit(1); strbuf_close(sb); exit(0); } /* * complete function name */ if (cflag) { if (Iflag) completion_idutils(dbpath, root, av); else completion(dbpath, root, av); exit(0); } /* * make local prefix. * local prefix must starts with './' and ends with '/'. */ if (lflag) { STRBUF *sb = strbuf_open(0); strbuf_putc(sb, '.'); if (strcmp(root, cwd) != 0) { char *p = cwd + strlen(root); if (*p != '/') strbuf_putc(sb, '/'); strbuf_puts(sb, p); } strbuf_putc(sb, '/'); localprefix = check_strdup(strbuf_value(sb)); strbuf_close(sb); #ifdef DEBUG fprintf(stderr, "root=%s\n", root); fprintf(stderr, "cwd=%s\n", cwd); fprintf(stderr, "localprefix=%s\n", localprefix); #endif } /* * decide tag type. */ if (context_file) { if (isregex(av)) die_with_code(2, "regular expression is not allowed with the --from-here option."); db = decide_tag_by_context(av, context_file, atoi(context_lineno)); } else { if (rflag && sflag) db = GRTAGS + GSYMS; else db = (rflag) ? GRTAGS : ((sflag) ? GSYMS : GTAGS); } /* * decide format. * The --result option is given to priority more than the -t and -x option. */ if (format == 0) { if (tflag) { /* ctags format */ format = FORMAT_CTAGS; } else if (xflag) { /* print details */ format = FORMAT_CTAGS_X; } else { /* print just a file name */ format = FORMAT_PATH; } } /* * decide path conversion type. */ if (nofilter & PATH_FILTER) type = PATH_THROUGH; else if (aflag) type = PATH_ABSOLUTE; else type = PATH_RELATIVE; /* * exec lid(idutils). */ if (Iflag) { chdir(root); idutils(av, dbpath); } /* * search pattern (regular expression). */ else if (gflag) { chdir(root); grep(av, argv, dbpath); } /* * locate paths including the pattern. */ else if (Pflag) { chdir(root); pathlist(av, dbpath); } /* * parse source files. */ else if (fflag) { chdir(root); parsefile(argv, cwd, root, dbpath, db); } /* * tag search. */ else { tagsearch(av, cwd, root, dbpath, db); } return 0; }
void ThermTrace::read_floorplan_mapping() { GI(input_file_[0]!=0,!mapping.empty()); // first call read_sesc_variable const char *flpSec = SescConf->getCharPtr("","floorplan"); size_t min = SescConf->getRecordMin(flpSec,"blockDescr"); size_t max = SescConf->getRecordMax(flpSec,"blockDescr"); // Floor plan parameters for(size_t id=min; id<=max; id++) { if (!SescConf->checkCharPtr(flpSec,"blockDescr", id)) { MSG("There is a HOLE on the floorplan. This can create problems blockDescr[%lu]", id); exit(-1); continue; } const char *blockDescr = SescConf->getCharPtr(flpSec,"blockDescr", id); TokenVectorType descr; tokenize(blockDescr, descr); FLPUnit *xflp = new FLPUnit(strdup(descr[0])); xflp->id = id; xflp->area = atof(descr[1])*atof(descr[2]); xflp->x = atof(descr[3]); xflp->y = atof(descr[4]); xflp->delta_x = atof(descr[1]); xflp->delta_y = atof(descr[2]); const char *blockMatch = SescConf->getCharPtr(flpSec,"blockMatch", id); tokenize(blockMatch, xflp->match); flp.push_back(xflp); } // Find mappings between variables and flp for(size_t id=0; id<flp.size(); id++) { for(size_t i=0; i<flp[id]->match.size(); i++) { for(size_t j=0; j<mapping.size(); j++) { if (grep(mapping[j].name, flp[id]->match[i])) { #ifdef DEBUG MSG("mapping[%d].map[%d]=%d (%s -> %s)", j, mapping[j].map.size(), id, flp[id]->match[i], mapping[j].name); #endif I(id < flp.size()); flp[id]->units++; I(j < mapping.size()); mapping[j].area += flp[id]->area; mapping[j].map.push_back(id); } } } } for(size_t i=0; i<mapping.size(); i++) { for(size_t j=0; j<mapping[i].map.size(); j++) { float ratio = flp[mapping[i].map[j]]->area/mapping[i].area; mapping[i].ratio.push_back(ratio); } } for(size_t j=0; j<mapping.size(); j++) { I(mapping[j].map.size() == mapping[j].ratio.size()); if (mapping[j].map.empty()) { MSG("Error: sesc variable %s [%lu] does not update any block", mapping[j].name, j); exit(3); } } }
/* * mainline for grep */ int main(int argc, char **argv) { char *ap, *test; int c; int fflag = 0; int i, n_pattern = 0, n_file = 0; char **pattern_list = NULL; char **file_list = NULL; (void) setlocale(LC_ALL, ""); #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ #endif (void) textdomain(TEXT_DOMAIN); /* * true if this is running on the multibyte locale */ mblocale = (MB_CUR_MAX > 1); /* * Skip leading slashes */ cmdname = argv[0]; if (ap = strrchr(cmdname, '/')) cmdname = ap + 1; ap = cmdname; /* * Detect egrep/fgrep via command name, map to -E and -F options. */ if (*ap == 'e' || *ap == 'E') { regflags |= REG_EXTENDED; egrep++; } else { if (*ap == 'f' || *ap == 'F') { fgrep++; } } /* check for non-standard "-line-count" option */ for (i = 1; i < argc; i++) { if (strcmp(argv[i], "--") == 0) break; if ((argv[i][0] == '-') && isdigit(argv[i][1])) { if (strlen(&argv[i][1]) != strspn(&argv[i][1], "0123456789")) { (void) fprintf(stderr, gettext( "%s: Bad number flag\n"), argv[0]); usage(); } conalen = conblen = strtoul(&argv[i][1], (char **)NULL, 10); /* isdigit() check prevents negative arguments */ if (conalen >= ULONG_MAX) { (void) fprintf(stderr, gettext( "%s: Bad context argument\n"), argv[0]); } if (conalen) conflag = CONTEXT; while (i < argc) { argv[i] = argv[i + 1]; i++; } argc--; } } while ((c = getopt(argc, argv, "vwchHilnrbse:f:qxEFIRA:B:C:")) != EOF) { unsigned long tval; switch (c) { case 'v': /* POSIX: negate matches */ nvflag = 0; break; case 'c': /* POSIX: write count */ cflag++; break; case 'i': /* POSIX: ignore case */ iflag++; regflags |= REG_ICASE; break; case 'l': /* POSIX: Write filenames only */ lflag++; break; case 'n': /* POSIX: Write line numbers */ nflag++; break; case 'r': /* Solaris: search recursively */ rflag++; break; case 'b': /* Solaris: Write file block numbers */ bflag++; break; case 's': /* POSIX: No error msgs for files */ sflag++; break; case 'e': /* POSIX: pattern list */ n_pattern++; pattern_list = realloc(pattern_list, sizeof (char *) * n_pattern); if (pattern_list == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); exit(2); } *(pattern_list + n_pattern - 1) = optarg; break; case 'f': /* POSIX: pattern file */ fflag = 1; n_file++; file_list = realloc(file_list, sizeof (char *) * n_file); if (file_list == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); exit(2); } *(file_list + n_file - 1) = optarg; break; /* based on options order h or H is set as in GNU grep */ case 'h': /* Solaris: supress printing of file name */ hflag = 1; Hflag = 0; break; /* Solaris: precede every matching with file name */ case 'H': Hflag = 1; hflag = 0; break; case 'q': /* POSIX: quiet: status only */ qflag++; break; case 'w': /* Solaris: treat pattern as word */ wflag++; break; case 'x': /* POSIX: full line matches */ xflag++; regflags |= REG_ANCHOR; break; case 'E': /* POSIX: Extended RE's */ regflags |= REG_EXTENDED; Eflag++; break; case 'F': /* POSIX: strings, not RE's */ Fflag++; break; case 'R': /* Solaris: like rflag, but follow symlinks */ Rflag++; rflag++; break; case 'A': /* print N lines after each match */ conalen = strtoul(optarg, &test, 10); /* *test will be non-null if optarg is negative */ if (*test != '\0' || conalen >= ULONG_MAX) { (void) fprintf(stderr, gettext( "%s: Bad context argument\n"), argv[0]); exit(2); } if (conalen) conflag |= AFTER; else conflag &= ~AFTER; break; case 'B': /* print N lines before each match */ conblen = strtoul(optarg, &test, 10); /* *test will be non-null if optarg is negative */ if (*test != '\0' || conblen >= ULONG_MAX) { (void) fprintf(stderr, gettext( "%s: Bad context argument\n"), argv[0]); exit(2); } if (conblen) conflag |= BEFORE; else conflag &= ~BEFORE; break; case 'C': /* print N lines around each match */ tval = strtoul(optarg, &test, 10); /* *test will be non-null if optarg is negative */ if (*test != '\0' || tval >= ULONG_MAX) { (void) fprintf(stderr, gettext( "%s: Bad context argument\n"), argv[0]); exit(2); } if (tval) { conflag = CONTEXT; conalen = conblen = tval; } break; default: usage(); } } /* * If we're invoked as egrep or fgrep we need to do some checks */ if (egrep || fgrep) { /* * Use of -E or -F with egrep or fgrep is illegal */ if (Eflag || Fflag) usage(); /* * Don't allow use of wflag with egrep / fgrep */ if (wflag) usage(); /* * For Solaris the -s flag is equivalent to XCU -q */ if (sflag) qflag++; /* * done with above checks - set the appropriate flags */ if (egrep) Eflag++; else /* Else fgrep */ Fflag++; } if (wflag && (Eflag || Fflag)) { /* * -w cannot be specified with grep -F */ usage(); } /* * -E and -F flags are mutually exclusive - check for this */ if (Eflag && Fflag) usage(); /* * -l overrides -H like in GNU grep */ if (lflag) Hflag = 0; /* * -c, -l and -q flags are mutually exclusive * We have -c override -l like in Solaris. * -q overrides -l & -c programmatically in grep() function. */ if (cflag && lflag) lflag = 0; argv += optind - 1; argc -= optind - 1; /* * Now handling -e and -f option */ if (pattern_list) { for (i = 0; i < n_pattern; i++) { addpattern(pattern_list[i]); } free(pattern_list); } if (file_list) { for (i = 0; i < n_file; i++) { addfile(file_list[i]); } free(file_list); } /* * No -e or -f? Make sure there is one more arg, use it as the pattern. */ if (patterns == NULL && !fflag) { if (argc < 2) usage(); addpattern(argv[1]); argc--; argv++; } /* * If -x flag is not specified or -i flag is specified * with fgrep in a multibyte locale, need to use * the wide character APIs. Otherwise, byte-oriented * process will be done. */ use_wchar = Fflag && mblocale && (!xflag || iflag); /* * Compile Patterns and also decide if BMG can be used */ fixpatterns(); /* Process all files: stdin, or rest of arg list */ if (argc < 2) { matched = grep(0, STDIN_FILENAME); } else { if (Hflag || (argc > 2 && hflag == 0)) outfn = 1; /* Print filename on match line */ for (argv++; *argv != NULL; argv++) { process_path(*argv); } } /* * Return() here is used instead of exit */ (void) fflush(stdout); if (errors) return (2); return (matched ? 0 : 1); }