/*
* datablob_parse - parse the keyctl data and fill in the
* payload and options structures
*
* On success returns 0, otherwise -EINVAL.
*/
static int datablob_parse(char *datablob, struct trusted_key_payload *p,
struct trusted_key_options *o)
{
substring_t args[MAX_OPT_ARGS];
long keylen;
int ret = -EINVAL;
int key_cmd;
char *c;
/* main command */
c = strsep(&datablob, " \t");
if (!c)
return -EINVAL;
key_cmd = match_token(c, key_tokens, args);
switch (key_cmd) {
case Opt_new:
/* first argument is key size */
c = strsep(&datablob, " \t");
if (!c)
return -EINVAL;
ret = kstrtol(c, 10, &keylen);
if (ret < 0 || keylen < MIN_KEY_SIZE || keylen > MAX_KEY_SIZE)
return -EINVAL;
p->key_len = keylen;
ret = getoptions(datablob, p, o);
if (ret < 0)
return ret;
ret = Opt_new;
break;
case Opt_load:
/* first argument is sealed blob */
c = strsep(&datablob, " \t");
if (!c)
return -EINVAL;
p->blob_len = strlen(c) / 2;
if (p->blob_len > MAX_BLOB_SIZE)
return -EINVAL;
ret = hex2bin(p->blob, c, p->blob_len);
if (ret < 0)
return -EINVAL;
ret = getoptions(datablob, p, o);
if (ret < 0)
return ret;
ret = Opt_load;
break;
case Opt_update:
/* all arguments are options */
ret = getoptions(datablob, p, o);
if (ret < 0)
return ret;
ret = Opt_update;
break;
case Opt_err:
return -EINVAL;
break;
}
return ret;
}
int main(int argc, char** argv)
{
try {
if (getoptions(argc, argv) != 0)
return 1;
if (! temporary_dir.empty())
::setenv("TMPDIR_SPEC", temporary_dir.string().data(), 1);
expgram::NGram ngram(ngram_file, shards, debug);
utils::compress_ostream os(output_file);
os << "ngram order: " << ngram.index.order() << '\n';
for (int order = 1; order <= ngram.index.order(); ++ order)
os << order << "-gram: " << std::setw(16) << ngram.index.ngram_size(order) << '\n';
dump(os, "index", ngram.stat_index()) << '\n';
dump(os, "pointer", ngram.stat_pointer()) << '\n';
dump(os, "vocab", ngram.stat_vocab()) << '\n';
dump(os, "logprob", ngram.stat_logprob()) << '\n';
dump(os, "backoff", ngram.stat_backoff()) << '\n';
dump(os, "logbound", ngram.stat_logbound()) << '\n';
}
catch (std::exception& err) {
std::cerr << "error: " << err.what() << std::endl;
return 1;
}
return 0;
}
void doinit()
{
/* initializes variables */
inputnumbers2(&spp, &nonodes2, 1);
getoptions();
if ( !usertree )
nonodes2--;
alloctree(&curtree.nodep, nonodes2);
allocd(nonodes2, curtree.nodep);
allocw(nonodes2, curtree.nodep);
if (!usertree) {
alloctree(&bestree.nodep, nonodes2);
allocd(nonodes2, bestree.nodep);
allocw(nonodes2, bestree.nodep);
alloctree(&priortree.nodep, nonodes2);
allocd(nonodes2, priortree.nodep);
allocw(nonodes2, priortree.nodep);
if (njumble > 1) {
alloctree(&bestree2.nodep, nonodes2);
allocd(nonodes2, bestree2.nodep);
allocw(nonodes2, bestree2.nodep);
}
}
allocrest();
} /* doinit */
/**********************************************************************//**
*************************************************************************/
int main(int argc, char** argv) {
// If no arguments have been passed, print the help text and quit
if (argc==1) {
Print_Help() ;
return 0 ;
}
// Define the optional arguments
struct option longopts[5] ;
getoptions(longopts) ;
// Parse the options
std::map<std::string, double> options = parseoptions(argc, argv, longopts) ;
// If no valid options were given, quit
if (options.empty()) return 0 ;
// Create a map to store the results
std::map<std::string, double> results ;
results["ra"] = 0.0 ;
results["dec"] = 0.0 ;
// Convert the coordinates
CECoordinates::Galactic2CIRS(options["glon"]*DD2R,
options["glat"]*DD2R,
&results["ra"],
&results["dec"],
CEDate(options["juliandate"])) ;
// Print the results
PrintResults(options, results) ;
return 0 ;
}
// 主程序
int main(int argc, char* argv[]) {
// Get command line optins
getoptions(argc, argv);
// Load temp images to be matched
IplImage* imgTemp = cvLoadImage(globalArgs.inputFiles[0]);
// Get image from srcs[] which match temp image, and set ROI on it
int nMatch;
IplImage* imgSrc;
if ((imgSrc = GetSourceImage(imgTemp, &nMatch)) == NULL) {
if (globalArgs.verbosity)
printf("[ERROR] Cannot match any temps. Abort.\n");
return EXIT_FAILURE;
}
// Calculate match area of temp image
int nMatchAreaSize = MatchAreaCount(imgSrc, imgTemp);
// Calculate the change value
int nChangeValue = ChangeValue(nMatchAreaSize, nMatch);
if (globalArgs.verbosity) {
printf(
"MatchValue=%d YUAN\nMatchAreaRate=%f\nChangeValue = %d YUAN\n",
full_value[nMatch],
MatchAreaRate(nMatchAreaSize, nMatch),
nChangeValue);
}
printf("%d", nChangeValue);
cvReleaseImage(&imgSrc);
cvReleaseImage(&imgTemp);
return EXIT_SUCCESS;
}
void doinput(int argc, Char *argv[])
{ /* reads the input data */
getoptions();
seqboot_inputnumbers();
allocrest();
inputoptions();
seqboot_inputdata();
} /* doinput */
void doinit()
{
/* initializes variables */
restdist_inputnumbers();
getoptions();
if (printdata)
fprintf(outfile, "\n %4ld Species, %4ld Sites\n", spp, sites);
allocrest();
} /* doinit */
/* getopt might be declared in stdio.h */
static struct option *get_opt(const char *sect_name, const char *key)
{
struct option *o = getoptions(sect_name);
while (o) {
if (!strcmp(key, opt_key(o)))
return o;
o = o->next;
}
return NULL;
}
void doinit(U2::MemoryLocker& memLocker)
{
/* initializes variables */
//inputnumbers(&spp, &sites, &nonodes, 1);
getoptions();
if (printdata) {
fprintf(outfile, "%2ld species, %3ld sites\n", spp, sites);
}
allocrest(memLocker);
} /* doinit */
int main(int argc, char** argv)
{
utils::mpi_world mpi_world(argc, argv);
const int mpi_rank = MPI::COMM_WORLD.Get_rank();
const int mpi_size = MPI::COMM_WORLD.Get_size();
try {
if (getoptions(argc, argv) != 0)
return 1;
if (! temporary_dir.empty())
::setenv("TMPDIR_SPEC", temporary_dir.string().data(), 1);
if (ngram_file.empty() || ! boost::filesystem::exists(ngram_file))
throw std::runtime_error("no ngram file?");
if (output_file.empty())
throw std::runtime_error("no output file?");
if (ngram_file == output_file)
throw std::runtime_error("dump to the same directory?");
ngram_type ngram(debug);
ngram.open_shard(ngram_file, mpi_rank);
if (static_cast<int>(ngram.index.size()) != mpi_size)
throw std::runtime_error("MPI universe size do not match with ngram shard size");
utils::resource start;
ngram_quantize(ngram);
utils::resource end;
if (debug && mpi_rank == 0)
std::cerr << "quantize language model"
<< " cpu time: " << end.cpu_time() - start.cpu_time()
<< " user time: " << end.user_time() - start.user_time()
<< std::endl;
if (mpi_rank == 0)
ngram.write_prepare(output_file);
MPI::COMM_WORLD.Barrier();
ngram.write_shard(output_file, mpi_rank);
}
catch (std::exception& err) {
std::cerr << "error: " << err.what() << std::endl;
MPI::COMM_WORLD.Abort(1);
return 1;
}
return 0;
}
void doinit()
{
/* initializes variables */
inputnumbers(&spp, &chars, &nonodes, 1);
words = chars / bits + 1;
getoptions();
if (printdata)
fprintf(outfile, "%2ld species, %3ld characters\n", spp, chars);
alloctree2(&treenode);
setuptree2(treenode);
allocrest();
} /* doinit */
void doinit()
{
/* initializes variables */
node *p;
inputnumbers2(&spp, &nonodes2, 2);
nonodes2 += (njoin ? 0 : 1);
getoptions();
alloctree(&curtree.nodep, nonodes2+1);
p = curtree.nodep[nonodes2]->next->next;
curtree.nodep[nonodes2]->next = curtree.nodep[nonodes2];
free(p);
allocrest();
} /* doinit */
int main (int argc, char ** argv){
if(argc != 5)
usage(1);
getoptions(argc, argv);
if(DEBUG){
printf("port: %d\n", port);
printf("fileOpt: %s\n", fileOpt);
}
int fd, bytesRead, fileSize, counter, i;
char* inFile = "./tracker.txt";
FILE * trackFp =fopen(inFile, "r");
if(trackFp == NULL)
errorExit("bad Tracker");
int numlines = numLines(inFile);
if(DEBUG)
printf("Numlines:%d\n", numlines);
tracker * tracks = malloc ( numlines * sizeof(tracker));
buildTracker(tracks, trackFp);
//sort the tracks to make easier for later. Look @ compare to see sort order
qsort (tracks, numlines, sizeof(tracks[0]), compare);
if(DEBUG){
for(i =0; i < numlines ; ++i)
printTrack(tracks[i]);
}
//now we have all information in memory
int numChunks = getNumChunks(tracks, fileOpt, numlines);
printf("numChunks:%d\n", numChunks);
sd = UDP_Open(-1);
assert(sd > -1);
for(i=1; i <= numChunks; ++i){
packArgs argsP = getIDParams(tracks, fileOpt, i, numlines);
if(DEBUG > 1)
printf("host:%s, port:%d\n", argsP.hostname, argsP.port);
getPackets(argsP.hostname, argsP.port);
}
return 0;
}
void gettermoptions()
{
struct option *o = getoptions("term");
for (; o; o = o->next) {
if (!strcmp(opt_key(o), "drawing")) {
if (o->val.integ)
textgfx_flags |= ASCII;
} else if (!strcmp(opt_key(o), "color")) {
if (!o->val.integ)
textgfx_flags |= MONOCHROME;
} else
blockstyle_from_option(o);
}
reset_block_chars();
}
int main (int argc, char *argv[])
{
struct queryopt opt;
struct ofields *fields;
struct select_doc *s_doc;
struct query_doc *qu_doc;
struct db_connect *db_conn;
struct output *out;
struct db_cursor *db_c;
struct results *res;
opt.e_skip = 0; // standard
opt.e_ret = 0; // standard
opt.bsever = 0;
opt.blevel = 0;
opt.bdate = 0;
opt.bdateu = 0;
opt.bdatef = 0;
opt.bmsg = 0;
opt.bskip = 0;
opt.bsys = 0;
getoptions(argc, argv, &opt);
qu_doc = create_query(&opt); // crate query
s_doc = create_select();
db_conn = create_conn(); // create connection
out = launch_query(&opt, s_doc, qu_doc, db_conn); // launch the query
db_c = open_cursor(db_conn, out); // open cursor
while (cursor_next(db_c))
{
res = read_data(db_c);
fields = get_data(res);
formater(fields); // formate output
free(fields);
free(res);
}
free_cursor(db_c);
close_conn(db_conn);
free(out);
free(s_doc);
free(qu_doc);
return (0);
}
int
main (int argc, char *argv[])
{
int rt;
rt = _i18n_init (I18N_CAT_MIN);
setdefaults ();
getoptions (argc, argv);
getpids (argc, argv);
printheader ();
initstats ();
processlogfile ();
printsummary ();
_i18n_end (ls_catd);
return (0);
}
void doinit()
{ /* initializes variables */
inputnumbers(&spp, &loci, &nonodes2, 1);
getoptions();
if(!usertree)
nonodes2--;
if (printdata)
fprintf(outfile, "\n%4ld Populations, %4ld Loci\n", spp, loci);
alloctree(&curtree.nodep, nonodes2);
if (!usertree) {
alloctree(&bestree.nodep, nonodes2);
alloctree(&priortree.nodep, nonodes2);
if (njumble > 1) {
alloctree(&bestree2.nodep, nonodes2);
}
}
allocrest();
} /* doinit */
void doinput(int argc, Char *argv[])
{ /* reads the input data */
getoptions();
seqboot_inputnumbers();
allocrest();
if (weights)
openfile(&weightfile,WEIGHTFILE,"input weight file",
"r",argv[0],weightfilename);
if (mixture){
openfile(&mixfile,MIXFILE,"mixture file", "r",argv[0],mixfilename);
openfile(&outmixfile,"outmixture","output mixtures file","w",argv[0],
outmixfilename);
seqboot_inputaux(mixdata, mixfile);
}
if (ancvar){
openfile(&ancfile,ANCFILE,"ancestor file", "r",argv[0],ancfilename);
openfile(&outancfile,"outancestors","output ancestors file","w",argv[0],
outancfilename);
seqboot_inputaux(ancdata, ancfile);
}
if (categories) {
openfile(&catfile,CATFILE,"input category file","r",argv[0],catfilename);
openfile(&outcatfile,"outcategories","output category file","w",argv[0],
outcatfilename);
inputcategs(0, sites, category, 9, "SeqBoot");
}
if (factors){
openfile(&factfile,FACTFILE,"factors file","r",argv[0],factfilename);
openfile(&outfactfile,"outfactors","output factors file","w",argv[0],
outfactfilename);
}
if (justwts && !permute)
openfile(&outweightfile,"outweights","output weight file",
"w",argv[0],outweightfilename);
else {
openfile(&outfile,OUTFILE,"output data file","w",argv[0],outfilename);
}
inputoptions();
seqboot_inputdata();
} /* doinput */
void doinput()
{
/* reads the input data */
inputnumbers(&spp, &chars, &nonodes, 1);
words = chars / bits + 1;
printf("%2ld species, %3ld characters\n", spp, chars);
printf("\nReading input file ...\n\n");
getoptions();
if (weights)
openfile(&weightfile,WEIGHTFILE,"weights file","r",progname,weightfilename);
if(ancvar)
openfile(&ancfile,ANCFILE,"ancestors file", "r",progname,ancfilename);
if(factors)
openfile(&factfile,FACTFILE,"factors file", "r",progname,factfilename);
alloctree(&treenode);
setuptree(treenode);
allocrest();
inputoptions();
inputdata(treenode, dollo, false, stdout);
} /* doinput */
int main(int argc, char* argv[])
{
try
{
struct t_hostparams params;
getoptions(argc, argv, params);
// Check command line arguments.
if (params.notconfigured())
{
std::cerr << " To run final usage: -h <address> -p <port> -d <doc_root>\n";
std::cerr << " try:\n";
std::cerr << " ./final -h 0.0.0.0 -p 80 -d .\n";
return 1;
}
auto pid = fork();
if (!pid)
{
httpservice::server myserver(params.host, params.port, params.doc_root);
myserver.run();
}
else
{
std::ofstream f("final.pid");
f << pid << std::endl;
}
}
catch (std::exception& e)
{
std::cerr << "std::exception: " << e.what() << "\n";
}
return 0;
}
static int
checkfs(const char *vfstype, const char *spec, const char *mntpt, void *auxarg,
pid_t *pidp)
{
/* List of directories containing fsck_xxx subcommands. */
static const char *edirs[] = {
_PATH_SBIN,
_PATH_USRSBIN,
NULL
};
const char **argv, **edir;
pid_t pid;
int argc, i, status, maxargc;
char *optbuf = NULL, fsname[MAXPATHLEN], execname[MAXPATHLEN];
const char *extra = getoptions(vfstype);
if (strcmp(vfstype, "ufs") == 0)
vfstype = MOUNT_UFS;
maxargc = 100;
argv = emalloc(sizeof(char *) * maxargc);
argc = 0;
(void)snprintf(fsname, sizeof(fsname), "fsck_%s", vfstype);
argv[argc++] = fsname;
if (options) {
if (extra != NULL)
optbuf = catopt(options, extra, 0);
else
optbuf = estrdup(options);
}
else if (extra)
optbuf = estrdup(extra);
if (optbuf)
mangle(optbuf, &argc, &argv, &maxargc);
argv[argc++] = spec;
argv[argc] = NULL;
if (flags & (CHECK_DEBUG|CHECK_VERBOSE)) {
(void)printf("start %s %swait %s", mntpt,
pidp ? "no" : "", fsname);
for (i = 1; i < argc; i++)
(void)printf(" %s", argv[i]);
(void)printf("\n");
}
switch (pid = fork()) {
case -1: /* Error. */
warn("fork");
if (optbuf)
free(optbuf);
free(argv);
return (1);
case 0: /* Child. */
if (flags & CHECK_DEBUG)
_exit(0);
/* Go find an executable. */
edir = edirs;
do {
(void)snprintf(execname,
sizeof(execname), "%s/fsck_%s", *edir, vfstype);
execv(execname, (char * const *)argv);
if (errno != ENOENT) {
if (spec)
warn("exec %s for %s", execname, spec);
else
warn("exec %s", execname);
}
} while (*++edir != NULL);
if (errno == ENOENT) {
if (spec)
warn("exec %s for %s", execname, spec);
else
warn("exec %s", execname);
}
exit(1);
/* NOTREACHED */
default: /* Parent. */
if (optbuf)
free(optbuf);
free(argv);
if (pidp) {
*pidp = pid;
return 0;
}
if (waitpid(pid, &status, 0) < 0) {
warn("waitpid");
return (1);
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) != 0)
return (WEXITSTATUS(status));
}
else if (WIFSIGNALED(status)) {
warnx("%s: %s", spec, strsignal(WTERMSIG(status)));
return (1);
}
break;
}
return (0);
}
int
main( int argc, char **argv, char **arg_environ )
{
int n, num_targets;
const char *s;
struct option optv[N_OPTS];
char* targets[N_TARGETS];
const char *all = "all";
int anyhow = 0;
int status;
# ifdef OS_MAC
InitGraf(&qd.thePort);
# endif
argc--, argv++;
if( ( num_targets = getoptions( argc, argv, "d:j:f:gs:t:ano:qv", optv, targets ) ) < 0 )
{
printf( "\nusage: jam [ options ] targets...\n\n" );
printf( "-a Build all targets, even if they are current.\n" );
printf( "-dx Display (a)actions (c)causes (d)dependencies\n" );
printf( " (m)make tree (x)commands (0-9) debug levels.\n" );
printf( "-fx Read x instead of Jambase.\n" );
printf( "-g Build from newest sources first.\n" );
printf( "-jx Run up to x shell commands concurrently.\n" );
printf( "-n Don't actually execute the updating actions.\n" );
printf( "-ox Write the updating actions to file x.\n" );
printf( "-q Quit quickly as soon as a target fails.\n" );
printf( "-sx=y Set variable x=y, overriding environment.\n" );
printf( "-tx Rebuild x, even if it is up-to-date.\n" );
printf( "-v Print the version of jam and exit.\n\n" );
exit( EXITBAD );
}
/* Version info. */
if( ( s = getoptval( optv, 'v', 0 ) ) )
{
printf( "FT-Jam %s. %s. ", VERSION, OSMINOR );
printf( "(C) 1993-2003 Christopher Seiwald, see www.freetype.org/jam/\n" );
return EXITOK;
}
/* Pick up interesting options */
if( ( s = getoptval( optv, 'n', 0 ) ) )
globs.noexec++, DEBUG_MAKE = DEBUG_MAKEQ = DEBUG_EXEC = 1;
if( ( s = getoptval( optv, 'q', 0 ) ) )
globs.quitquick = 1;
if( ( s = getoptval( optv, 'a', 0 ) ) )
anyhow++;
if( ( s = getoptval( optv, 'j', 0 ) ) )
globs.jobs = atoi( s );
if( ( s = getoptval( optv, 'g', 0 ) ) )
globs.newestfirst = 1;
/* Turn on/off debugging */
for( n = 0; (s = getoptval( optv, 'd', n )) != 0; n++ )
{
int i = atoi( s );
/* First -d, turn off defaults. */
if( !n )
DEBUG_MAKE = DEBUG_MAKEQ = DEBUG_EXEC = 0;
/* n turns on levels 1-n */
/* +n turns on level n */
/* c turns on named display c */
if( i < 0 || i >= DEBUG_MAX )
{
printf( "Invalid debug level '%s'.\n", s );
}
else if( *s == '+' )
{
globs.debug[i] = 1;
}
else if( i ) while( i )
{
globs.debug[i--] = 1;
}
else while( *s ) switch( *s++ )
{
case 'a': DEBUG_MAKE = DEBUG_MAKEQ = 1; break;
case 'c': DEBUG_CAUSES = 1; break;
case 'd': DEBUG_DEPENDS = 1; break;
case 'm': DEBUG_MAKEPROG = 1; break;
case 'x': DEBUG_EXEC = 1; break;
case '0': break;
default: printf( "Invalid debug flag '%c'.\n", s[-1] );
}
}
/* Set JAMDATE first */
{
char buf[ 128 ];
time_t clock;
time( &clock );
strcpy( buf, ctime( &clock ) );
/* Trim newline from date */
if( strlen( buf ) == 25 )
buf[ 24 ] = 0;
var_set( "JAMDATE", list_new( L0, buf, 0 ), VAR_SET );
}
/* And JAMUNAME */
# ifdef unix
{
struct utsname u;
if( uname( &u ) >= 0 )
{
LIST *l = L0;
l = list_new( l, u.machine, 0 );
l = list_new( l, u.version, 0 );
l = list_new( l, u.release, 0 );
l = list_new( l, u.nodename, 0 );
l = list_new( l, u.sysname, 0 );
var_set( "JAMUNAME", l, VAR_SET );
}
}
# endif /* unix */
/*
* Jam defined variables OS, OSPLAT
*/
var_defines( othersyms );
/* load up environment variables */
var_defines( (const char **)use_environ );
/* Load up variables set on command line. */
for( n = 0; (s = getoptval( optv, 's', n )) != 0; n++ )
{
const char *symv[2];
symv[0] = s;
symv[1] = 0;
var_defines( symv );
}
/* Initialize built-in rules */
load_builtins();
/* Parse ruleset */
for( n = 0; (s = getoptval( optv, 'f', n )) != 0; n++ )
parse_file( s );
if( !n )
parse_file( "+" );
status = yyanyerrors();
/* Manually touch -t targets */
for( n = 0; (s = getoptval( optv, 't', n )) != 0; n++ )
touchtarget( s );
/* If an output file is specified, set globs.cmdout to that */
if( (s = getoptval( optv, 'o', 0 )) != 0 )
{
if( !( globs.cmdout = fopen( s, "w" ) ) )
{
printf( "Failed to write to '%s'\n", s );
exit( EXITBAD );
}
globs.noexec++;
}
/* Add JAMCMDARGS
*/
{
LIST* l = L0;
for ( n = 0; n < num_targets; n++ )
l = list_new( l, targets[n], 0 );
var_set( "JAMCMDARGS", l, VAR_SET );
}
/* Now make target */
if( !num_targets )
status |= make( 1, &all, anyhow );
else
status |= make( num_targets, (const char**)targets, anyhow );
/* Widely scattered cleanup */
var_done();
donerules();
donestamps();
donestr();
/* close cmdout */
if( globs.cmdout )
fclose( globs.cmdout );
return status ? EXITBAD : EXITOK;
}
static int
checkfs(const char *pvfstype, const char *spec, const char *mntpt,
const char *auxopt, pid_t *pidp)
{
const char ** volatile argv;
pid_t pid;
int argc, i, status, maxargc;
char *optbuf, execbase[MAXPATHLEN];
char *vfstype = NULL;
const char *extra = NULL;
#ifdef __GNUC__
/* Avoid vfork clobbering */
(void) &optbuf;
(void) &vfstype;
#endif
/*
* We convert the vfstype to lowercase and any spaces to underscores
* to not confuse the issue
*
* XXX This is a kludge to make automatic filesystem type guessing
* from the disklabel work for "4.2BSD" filesystems. It does a
* very limited subset of transliteration to a normalised form of
* filesystem name, and we do not seem to enforce a filesystem
* name character set.
*/
vfstype = strdup(pvfstype);
if (vfstype == NULL)
perr("strdup(pvfstype)");
for (i = 0; i < (int)strlen(vfstype); i++) {
vfstype[i] = tolower(vfstype[i]);
if (vfstype[i] == ' ')
vfstype[i] = '_';
}
extra = getoptions(vfstype);
optbuf = NULL;
if (options)
catopt(&optbuf, options);
if (extra)
catopt(&optbuf, extra);
if (auxopt)
catopt(&optbuf, auxopt);
else if (flags & DO_BACKGRD)
catopt(&optbuf, "-B");
maxargc = 64;
argv = emalloc(sizeof(char *) * maxargc);
(void) snprintf(execbase, sizeof(execbase), "fsck_%s", vfstype);
argc = 0;
argv[argc++] = execbase;
if (optbuf)
mangle(optbuf, &argc, &argv, &maxargc);
argv[argc++] = spec;
argv[argc] = NULL;
if (flags & (CHECK_DEBUG|CHECK_VERBOSE)) {
(void)printf("start %s %swait", mntpt,
pidp ? "no" : "");
for (i = 0; i < argc; i++)
(void)printf(" %s", argv[i]);
(void)printf("\n");
}
switch (pid = vfork()) {
case -1: /* Error. */
warn("vfork");
if (optbuf)
free(optbuf);
free(vfstype);
return (1);
case 0: /* Child. */
if ((flags & CHECK_DEBUG) && auxopt == NULL)
_exit(0);
/* Go find an executable. */
execvP(execbase, _PATH_SYSPATH, __DECONST(char * const *, argv));
if (spec)
warn("exec %s for %s in %s", execbase, spec, _PATH_SYSPATH);
else
warn("exec %s in %s", execbase, _PATH_SYSPATH);
_exit(1);
/* NOTREACHED */
default: /* Parent. */
if (optbuf)
free(optbuf);
free(vfstype);
if (pidp) {
*pidp = pid;
return 0;
}
if (waitpid(pid, &status, 0) < 0) {
warn("waitpid");
return (1);
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) != 0)
return (WEXITSTATUS(status));
}
else if (WIFSIGNALED(status)) {
warnx("%s: %s", spec, strsignal(WTERMSIG(status)));
return (1);
}
break;
}
return (0);
}
int main( int argc, char * * argv, char * * arg_environ )
{
int n;
char * s;
struct bjam_option optv[N_OPTS];
char const * all = "all";
int status;
int arg_c = argc;
char * * arg_v = argv;
char const * progname = argv[0];
module_t * environ_module;
#if defined(unix) || defined(__unix)
sigset_t sigmask;
struct sigaction sa;
sigemptyset(&sigmask);
sigaddset(&sigmask, SIGCHLD);
sigprocmask(SIG_BLOCK, &sigmask, NULL);
sa.sa_flags = 0;
sa.sa_handler = child_sig_handler;
sigemptyset(&sa.sa_mask);
sigaction(SIGCHLD, &sa, NULL);
sigemptyset(&empty_sigmask);
#endif
saved_argv0 = argv[0];
BJAM_MEM_INIT();
# ifdef OS_MAC
InitGraf(&qd.thePort);
# endif
--argc;
++argv;
if ( getoptions( argc, argv, "-:l:m:d:j:p:f:gs:t:ano:qv", optv ) < 0 )
{
printf( "\nusage: %s [ options ] targets...\n\n", progname );
printf( "-a Build all targets, even if they are current.\n" );
printf( "-dx Set the debug level to x (0-9).\n" );
printf( "-fx Read x instead of Jambase.\n" );
/* printf( "-g Build from newest sources first.\n" ); */
printf( "-jx Run up to x shell commands concurrently.\n" );
printf( "-lx Limit actions to x number of seconds after which they are stopped.\n" );
printf( "-mx Limit action output buffer to x kb's of data, after which action output is read and ignored.\n" );
printf( "-n Don't actually execute the updating actions.\n" );
printf( "-ox Write the updating actions to file x.\n" );
printf( "-px x=0, pipes action stdout and stderr merged into action output.\n" );
printf( "-q Quit quickly as soon as a target fails.\n" );
printf( "-sx=y Set variable x=y, overriding environment.\n" );
printf( "-tx Rebuild x, even if it is up-to-date.\n" );
printf( "-v Print the version of jam and exit.\n" );
printf( "--x Option is ignored.\n\n" );
exit( EXITBAD );
}
/* Version info. */
if ( ( s = getoptval( optv, 'v', 0 ) ) )
{
printf( "Boost.Jam " );
printf( "Version %s. %s.\n", VERSION, OSMINOR );
printf( " Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc. \n" );
printf( " Copyright 2001 David Turner.\n" );
printf( " Copyright 2001-2004 David Abrahams.\n" );
printf( " Copyright 2002-2008 Rene Rivera.\n" );
printf( " Copyright 2003-2008 Vladimir Prus.\n" );
return EXITOK;
}
/* Pick up interesting options. */
if ( ( s = getoptval( optv, 'n', 0 ) ) )
globs.noexec++, globs.debug[2] = 1;
if ( ( s = getoptval( optv, 'p', 0 ) ) )
{
/* Undocumented -p3 (acts like both -p1 -p2) means separate pipe action
* stdout and stderr.
*/
globs.pipe_action = atoi( s );
if ( ( 3 < globs.pipe_action ) || ( globs.pipe_action < 0 ) )
{
printf(
"Invalid pipe descriptor '%d', valid values are -p[0..3].\n",
globs.pipe_action );
exit( EXITBAD );
}
}
if ( ( s = getoptval( optv, 'q', 0 ) ) )
globs.quitquick = 1;
if ( ( s = getoptval( optv, 'a', 0 ) ) )
anyhow++;
if ( ( s = getoptval( optv, 'j', 0 ) ) )
{
globs.jobs = atoi( s );
if (globs.jobs == 0)
{
printf("Invalid value for the '-j' option.\n");
exit(EXITBAD);
}
}
if ( ( s = getoptval( optv, 'g', 0 ) ) )
globs.newestfirst = 1;
if ( ( s = getoptval( optv, 'l', 0 ) ) )
globs.timeout = atoi( s );
if ( ( s = getoptval( optv, 'm', 0 ) ) )
globs.maxbuf = atoi( s ) * 1024;
/* Turn on/off debugging */
for ( n = 0; ( s = getoptval( optv, 'd', n ) ); ++n )
{
int i;
/* First -d, turn off defaults. */
if ( !n )
for ( i = 0; i < DEBUG_MAX; ++i )
globs.debug[i] = 0;
i = atoi( s );
if ( ( i < 0 ) || ( i >= DEBUG_MAX ) )
{
printf( "Invalid debug level '%s'.\n", s );
continue;
}
/* n turns on levels 1-n. */
/* +n turns on level n. */
if ( *s == '+' )
globs.debug[i] = 1;
else while ( i )
globs.debug[i--] = 1;
}
constants_init();
{
PROFILE_ENTER( MAIN );
#ifdef HAVE_PYTHON
{
PROFILE_ENTER( MAIN_PYTHON );
Py_Initialize();
{
static PyMethodDef BjamMethods[] = {
{"call", bjam_call, METH_VARARGS,
"Call the specified bjam rule."},
{"import_rule", bjam_import_rule, METH_VARARGS,
"Imports Python callable to bjam."},
{"define_action", bjam_define_action, METH_VARARGS,
"Defines a command line action."},
{"variable", bjam_variable, METH_VARARGS,
"Obtains a variable from bjam's global module."},
{"backtrace", bjam_backtrace, METH_VARARGS,
"Returns bjam backtrace from the last call into Python."},
{"caller", bjam_caller, METH_VARARGS,
"Returns the module from which the last call into Python is made."},
{NULL, NULL, 0, NULL}
};
Py_InitModule( "bjam", BjamMethods );
}
PROFILE_EXIT( MAIN_PYTHON );
}
#endif
#ifndef NDEBUG
run_unit_tests();
#endif
#if YYDEBUG != 0
if ( DEBUG_PARSE )
yydebug = 1;
#endif
/* Set JAMDATE. */
var_set( root_module(), constant_JAMDATE, list_new( L0, outf_time(time(0)) ), VAR_SET );
/* Set JAM_VERSION. */
var_set( root_module(), constant_JAM_VERSION,
list_new( list_new( list_new( L0,
object_new( VERSION_MAJOR_SYM ) ),
object_new( VERSION_MINOR_SYM ) ),
object_new( VERSION_PATCH_SYM ) ),
VAR_SET );
/* Set JAMUNAME. */
#if defined(unix) || defined(__unix)
{
struct utsname u;
if ( uname( &u ) >= 0 )
{
var_set( root_module(), constant_JAMUNAME,
list_new(
list_new(
list_new(
list_new(
list_new( L0,
object_new( u.sysname ) ),
object_new( u.nodename ) ),
object_new( u.release ) ),
object_new( u.version ) ),
object_new( u.machine ) ), VAR_SET );
}
}
#endif /* unix */
/* Load up environment variables. */
/* First into the global module, with splitting, for backward
* compatibility.
*/
var_defines( root_module(), use_environ, 1 );
environ_module = bindmodule( constant_ENVIRON );
/* Then into .ENVIRON, without splitting. */
var_defines( environ_module, use_environ, 0 );
/*
* Jam defined variables OS & OSPLAT. We load them after environment, so
* that setting OS in environment does not change Jam's notion of the
* current platform.
*/
var_defines( root_module(), othersyms, 1 );
/* Load up variables set on command line. */
for ( n = 0; ( s = getoptval( optv, 's', n ) ); ++n )
{
char *symv[2];
symv[ 0 ] = s;
symv[ 1 ] = 0;
var_defines( root_module(), symv, 1 );
var_defines( environ_module, symv, 0 );
}
/* Set the ARGV to reflect the complete list of arguments of invocation.
*/
for ( n = 0; n < arg_c; ++n )
{
var_set( root_module(), constant_ARGV, list_new( L0, object_new( arg_v[n] ) ), VAR_APPEND );
}
/* Initialize built-in rules. */
load_builtins();
/* Add the targets in the command line to the update list. */
for ( n = 1; n < arg_c; ++n )
{
if ( arg_v[ n ][ 0 ] == '-' )
{
char * f = "-:l:d:j:f:gs:t:ano:qv";
for ( ; *f; ++f ) if ( *f == arg_v[ n ][ 1 ] ) break;
if ( ( f[ 1 ] == ':' ) && ( arg_v[ n ][ 2 ] == '\0' ) ) ++n;
}
else
{
OBJECT * target = object_new( arg_v[ n ] );
mark_target_for_updating( target );
object_free( target );
}
}
if (!targets_to_update())
{
mark_target_for_updating( constant_all );
}
/* Parse ruleset. */
{
FRAME frame[ 1 ];
frame_init( frame );
for ( n = 0; ( s = getoptval( optv, 'f', n ) ); ++n )
{
OBJECT * filename = object_new( s );
parse_file( filename, frame );
object_free( filename );
}
if ( !n )
{
parse_file( constant_plus, frame );
}
}
status = yyanyerrors();
/* Manually touch -t targets. */
for ( n = 0; ( s = getoptval( optv, 't', n ) ); ++n )
{
OBJECT * target = object_new( s );
touch_target( target );
object_free( target );
}
/* If an output file is specified, set globs.cmdout to that. */
if ( ( s = getoptval( optv, 'o', 0 ) ) )
{
if ( !( globs.cmdout = fopen( s, "w" ) ) )
{
printf( "Failed to write to '%s'\n", s );
exit( EXITBAD );
}
++globs.noexec;
}
/* The build system may set the PARALLELISM variable to override -j
options. */
{
LIST *p = L0;
p = var_get ( root_module(), constant_PARALLELISM );
if ( p )
{
int j = atoi( object_str( p->value ) );
if ( j == -1 )
{
printf( "Invalid value of PARALLELISM: %s\n", object_str( p->value ) );
}
else
{
globs.jobs = j;
}
}
}
/* KEEP_GOING overrides -q option. */
{
LIST *p = L0;
p = var_get( root_module(), constant_KEEP_GOING );
if ( p )
{
int v = atoi( object_str( p->value ) );
if ( v == 0 )
globs.quitquick = 1;
else
globs.quitquick = 0;
}
}
/* Now make target. */
{
PROFILE_ENTER( MAIN_MAKE );
LIST * targets = targets_to_update();
if (targets)
{
int targets_count = list_length( targets );
OBJECT * * targets2 = (OBJECT * *)
BJAM_MALLOC( targets_count * sizeof( OBJECT * ) );
int n = 0;
for ( ; targets; targets = list_next( targets ) )
targets2[ n++ ] = targets->value;
status |= make( targets_count, targets2, anyhow );
BJAM_FREE( (void *)targets2 );
}
else
{
status = last_update_now_status;
}
PROFILE_EXIT( MAIN_MAKE );
}
PROFILE_EXIT( MAIN );
}
if ( DEBUG_PROFILE )
profile_dump();
#ifdef OPT_HEADER_CACHE_EXT
hcache_done();
#endif
clear_targets_to_update();
/* Widely scattered cleanup. */
file_done();
rules_done();
stamps_done();
search_done();
class_done();
modules_done();
regex_done();
exec_done();
pwd_done();
path_done();
function_done();
list_done();
constants_done();
object_done();
/* Close cmdout. */
if ( globs.cmdout )
fclose( globs.cmdout );
#ifdef HAVE_PYTHON
Py_Finalize();
#endif
BJAM_MEM_CLOSE();
return status ? EXITBAD : EXITOK;
}
int main(int argc, char *argv[], char *const envp[])
{
struct cpuidle_datas *datas;
struct cpuidle_datas *baseline;
struct program_options options;
int args;
double start_ts = 0, end_ts = 0;
struct init_pstates *initp = NULL;
struct report_ops *output_handler = NULL;
struct cpu_topology *cpu_topo = NULL;
struct trace_options *saved_trace_options = NULL;
void *report_data = NULL;
args = getoptions(argc, argv, &options);
if (args <= 0)
return 1;
/* Tracing requires manipulation of some files only accessible
* to root */
if ((options.mode == TRACE) && getuid()) {
fprintf(stderr, "must be root to run traces\n");
return 1;
}
output_handler = get_report_ops(options.report_type_name);
if (is_err(output_handler))
return 1;
if (output_handler->check_options &&
output_handler->check_options(&options) < 0)
return 1;
if (output_handler->allocate_report_data) {
report_data = output_handler->allocate_report_data(&options);
if (is_err(report_data))
return 1;
}
if (output_handler->check_output(&options, report_data))
return 1;
if (options.energy_model_filename &&
parse_energy_model(&options) < 0) {
fprintf(stderr, "can't parse energy model file\n");
return 1;
}
/* Acquisition time specified means we will get the traces */
if ((options.mode == TRACE) || args < argc) {
/* Read cpu topology info from sysfs */
cpu_topo = read_sysfs_cpu_topo();
if (is_err(cpu_topo)) {
fprintf(stderr, "Failed to read CPU topology info from"
" sysfs.\n");
return 1;
}
/* Stop tracing (just in case) */
if (idlestat_trace_enable(false)) {
fprintf(stderr, "idlestat requires kernel Ftrace and "
"debugfs mounted on /sys/kernel/debug\n");
return 1;
}
saved_trace_options = idlestat_store_trace_options();
if (is_err(saved_trace_options))
return 1;
/*
* Calculate/verify buffer size and polling trace data
* interval. The interval or may may not be used to
* transfer data from kernel trace buffer to some
* storage media. It is needed for long eventful traces,
* but is not preferred. If the user does not specify
* the values, we will calculate reasonable defaults.
*/
if (calculate_buffer_parameters(options.duration, &options.tbs))
return 1;
/* Initialize the traces for cpu_idle and increase the
* buffer size to let 'idlestat' to possibly sleep instead
* of acquiring data, hence preventing it to pertubate the
* measurements. */
if (idlestat_init_trace(options.tbs.percpu_buffer_size))
goto err_restore_trace_options;
/* Remove all the previous traces */
if (idlestat_flush_trace())
goto err_restore_trace_options;
/* Get starting timestamp */
if (get_trace_ts(&start_ts) == -1)
goto err_restore_trace_options;
initp = build_init_pstates(cpu_topo);
/* Start the recording */
if (idlestat_trace_enable(true))
goto err_restore_trace_options;
/* We want to prevent to begin the acquisition with a cpu in
* idle state because we won't be able later to close the
* state and to determine which state it was. */
if (idlestat_wake_all())
goto err_restore_trace_options;
/* Execute the command or wait a specified delay */
if (execute(argc - args, &argv[args], envp, &options))
goto err_restore_trace_options;
/* Wake up all cpus again to account for last idle state */
if (idlestat_wake_all())
goto err_restore_trace_options;
/* Stop tracing */
if (idlestat_trace_enable(false))
goto err_restore_trace_options;
/* Get ending timestamp */
if (get_trace_ts(&end_ts) == -1)
goto err_restore_trace_options;
/* At this point we should have some spurious wake up
* at the beginning of the traces and at the end (wake
* up all cpus and timer expiration for the timer
* acquisition). We assume these will be lost in the number
* of other traces and could be negligible. */
if (idlestat_store(options.filename, start_ts, end_ts,
initp, cpu_topo))
goto err_restore_trace_options;
/* Restore original kernel ftrace options */
if (idlestat_restore_trace_options(saved_trace_options))
return 1;
/* Discard topology, will be reloaded during trace load */
release_cpu_topo_cstates(cpu_topo);
release_cpu_topo_info(cpu_topo);
cpu_topo = NULL;
}
/* Load the idle states information */
datas = idlestat_load(options.filename);
if (is_err(datas))
return 1;
cpu_topo = datas->topo;
if (options.baseline_filename) {
baseline = idlestat_load(options.baseline_filename);
merge_pstates(datas, baseline);
} else {
baseline = NULL;
}
if (is_err(baseline))
return 1;
datas->baseline = baseline;
assign_baseline_in_topo(datas);
if (output_handler->open_report_file(options.outfilename, report_data))
return 1;
if (options.display & IDLE_DISPLAY) {
output_handler->cstate_table_header(report_data);
dump_cpu_topo_info(output_handler, report_data,
display_cstates, cpu_topo, 1);
output_handler->cstate_table_footer(report_data);
}
if (options.display & FREQUENCY_DISPLAY) {
output_handler->pstate_table_header(report_data);
dump_cpu_topo_info(output_handler, report_data,
display_pstates, cpu_topo, 0);
output_handler->pstate_table_footer(report_data);
}
if (options.display & WAKEUP_DISPLAY) {
output_handler->wakeup_table_header(report_data);
dump_cpu_topo_info(output_handler, report_data,
display_wakeup, cpu_topo, 1);
output_handler->wakeup_table_footer(report_data);
}
if (options.energy_model_filename)
calculate_energy_consumption(cpu_topo);
output_handler->close_report_file(report_data);
release_init_pstates(initp);
release_datas(datas);
if (output_handler->release_report_data)
output_handler->release_report_data(report_data);
return 0;
err_restore_trace_options:
/* Restore original kernel ftrace options */
idlestat_restore_trace_options(saved_trace_options);
return 1;
}
int main(int argc, char *argv[])
{
yyin = stdin;
int i = getoptions(argc, argv);
char buf[PATH_MAX];
if (out[0] == '/')
strcpy(buf, out);
else
{
getcwd(buf, PATH_MAX);
strcat(buf, "/");
strcat(buf, out);
}
BEntry e;
if (e.SetTo(out)) error("entry set to %s", out);
BDirectory d;
if (e.GetParent(&d)) error("get parent of %s", out);
if ((gTruncate || gSaveAsHeader) && e.Exists() && e.Remove())
error("removing %s", out);
BFile f;
BResources res;
if (!gDump)
{
if (gTruncate || !e.Exists())
{
if (d.CreateFile(buf, &f)) error("creating %s", buf);
gTruncate = true;
}
else
if (f.SetTo(buf, B_READ_WRITE)) error("opening %s", buf);
if (gSaveAsHeader)
{
gHeader = fopen(buf, "w");
if (!gHeader) error("Error creating %s", buf);
}
else if (res.SetTo(&f, gTruncate) != B_NO_ERROR)
error("opening resource file %s", buf);
}
resFile = &res;
if (i == argc)
Work(NULL);
else
{
while (i < argc)
Work(in = argv[i++]);
}
if (verbose)
puts("done");
if (gHeader)
fclose(gHeader);
else
f.Sync();
return 0;
} /* main */
/*
* Search for variable, if not found create globally.
*/
struct tbl *
global(const char *n)
{
struct block *l = e->loc;
struct tbl *vp;
int c;
unsigned int h;
bool array;
int val;
/* Check to see if this is an array */
n = array_index_calc(n, &array, &val);
h = hash(n);
c = n[0];
if (!letter(c)) {
if (array)
errorf("bad substitution");
vp = &vtemp;
vp->flag = DEFINED;
vp->type = 0;
vp->areap = ATEMP;
*vp->name = c;
if (digit(c)) {
for (c = 0; digit(*n); n++)
c = c*10 + *n-'0';
if (c <= l->argc)
/* setstr can't fail here */
setstr(vp, l->argv[c], KSH_RETURN_ERROR);
vp->flag |= RDONLY;
return vp;
}
vp->flag |= RDONLY;
if (n[1] != '\0')
return vp;
vp->flag |= ISSET|INTEGER;
switch (c) {
case '$':
vp->val.i = kshpid;
break;
case '!':
/* If no job, expand to nothing */
if ((vp->val.i = j_async()) == 0)
vp->flag &= ~(ISSET|INTEGER);
break;
case '?':
vp->val.i = exstat;
break;
case '#':
vp->val.i = l->argc;
break;
case '-':
vp->flag &= ~INTEGER;
vp->val.s = getoptions();
break;
default:
vp->flag &= ~(ISSET|INTEGER);
}
return vp;
}
for (l = e->loc; ; l = l->next) {
vp = ktsearch(&l->vars, n, h);
if (vp != NULL) {
if (array)
return arraysearch(vp, val);
else
return vp;
}
if (l->next == NULL)
break;
}
vp = ktenter(&l->vars, n, h);
if (array)
vp = arraysearch(vp, val);
vp->flag |= DEFINED;
if (special(n))
vp->flag |= SPECIAL;
return vp;
}
static int
checkfs(const char *vfst, const char *spec, const char *mntpt, void *auxarg,
pid_t *pidp)
{
/* List of directories containing fsck_xxx subcommands. */
static const char *edirs[] = {
#ifdef RESCUEDIR
RESCUEDIR,
#endif
_PATH_SBIN,
_PATH_USRSBIN,
NULL
};
const char ** volatile argv, **edir;
const char * volatile vfstype = vfst;
pid_t pid;
int argc, i, status, maxargc;
char *optb;
char *volatile optbuf;
char execname[MAXPATHLEN + 1], execbase[MAXPATHLEN];
const char *extra = getoptions(vfstype);
if (!strcmp(vfstype, "ufs"))
vfstype = MOUNT_UFS;
optb = NULL;
if (options)
catopt(&optb, options);
if (extra)
catopt(&optb, extra);
optbuf = optb;
maxargc = 64;
argv = emalloc(sizeof(char *) * maxargc);
(void) snprintf(execbase, sizeof(execbase), "fsck_%s", vfstype);
argc = 0;
argv[argc++] = execbase;
if (optbuf)
mangle(optbuf, &argc, &argv, &maxargc);
argv[argc++] = spec;
argv[argc] = NULL;
if (flags & (CHECK_DEBUG|CHECK_VERBOSE)) {
(void)printf("start %s %swait", mntpt,
pidp ? "no" : "");
for (i = 0; i < argc; i++)
(void)printf(" %s", argv[i]);
(void)printf("\n");
}
switch (pid = vfork()) {
case -1: /* Error. */
warn("vfork");
if (optbuf)
free(optbuf);
free(argv);
return FSCK_EXIT_CHECK_FAILED;
case 0: /* Child. */
if ((flags & CHECK_FORCE) == 0) {
struct statvfs sfs;
/*
* if mntpt is a mountpoint of a mounted file
* system and it's mounted read-write, skip it
* unless -f is given.
*/
if ((statvfs(mntpt, &sfs) == 0) &&
(strcmp(mntpt, sfs.f_mntonname) == 0) &&
((sfs.f_flag & MNT_RDONLY) == 0)) {
printf(
"%s: file system is mounted read-write on %s; not checking\n",
spec, mntpt);
if ((flags & CHECK_PREEN) && auxarg != NULL)
_exit(FSCK_EXIT_OK); /* fsck -p */
else
_exit(FSCK_EXIT_CHECK_FAILED); /* fsck [[-p] ...] */
}
}
if (flags & CHECK_DEBUG)
_exit(FSCK_EXIT_OK);
/* Go find an executable. */
edir = edirs;
do {
(void)snprintf(execname,
sizeof(execname), "%s/%s", *edir, execbase);
execv(execname, (char * const *)__UNCONST(argv));
if (errno != ENOENT) {
if (spec)
warn("exec %s for %s", execname, spec);
else
warn("exec %s", execname);
}
} while (*++edir != NULL);
if (errno == ENOENT) {
if (spec)
warn("exec %s for %s", execname, spec);
else
warn("exec %s", execname);
}
_exit(FSCK_EXIT_CHECK_FAILED);
/* NOTREACHED */
default: /* Parent. */
if (optbuf)
free(optbuf);
free(argv);
if (pidp) {
*pidp = pid;
return FSCK_EXIT_OK;
}
if (waitpid(pid, &status, 0) < 0) {
warn("waitpid");
return FSCK_EXIT_CHECK_FAILED;
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) != 0)
return WEXITSTATUS(status);
}
else if (WIFSIGNALED(status)) {
warnx("%s: %s", spec, strsignal(WTERMSIG(status)));
return FSCK_EXIT_CHECK_FAILED;
}
break;
}
return FSCK_EXIT_OK;
}
/*
* Search for variable, if not found create globally.
*/
struct tbl *
global(const char *n)
{
struct block *l = e->loc;
struct tbl *vp;
int c;
bool array;
uint32_t h, val;
/*
* check to see if this is an array;
* dereference namerefs; must come first
*/
n = array_index_calc(n, &array, &val);
h = hash(n);
c = (unsigned char)n[0];
if (!ksh_isalphx(c)) {
if (array)
errorf("bad substitution");
vp = &vtemp;
vp->flag = DEFINED;
vp->type = 0;
vp->areap = ATEMP;
*vp->name = c;
if (ksh_isdigit(c)) {
if (getn(n, &c) && (c <= l->argc))
/* setstr can't fail here */
setstr(vp, l->argv[c], KSH_RETURN_ERROR);
vp->flag |= RDONLY;
return (vp);
}
vp->flag |= RDONLY;
if (n[1] != '\0')
return (vp);
vp->flag |= ISSET|INTEGER;
switch (c) {
case '$':
vp->val.i = kshpid;
break;
case '!':
/* if no job, expand to nothing */
if ((vp->val.i = j_async()) == 0)
vp->flag &= ~(ISSET|INTEGER);
break;
case '?':
vp->val.i = exstat & 0xFF;
break;
case '#':
vp->val.i = l->argc;
break;
case '-':
vp->flag &= ~INTEGER;
vp->val.s = getoptions();
break;
default:
vp->flag &= ~(ISSET|INTEGER);
}
return (vp);
}
l = varsearch(e->loc, &vp, n, h);
if (vp != NULL)
return (array ? arraysearch(vp, val) : vp);
vp = ktenter(&l->vars, n, h);
if (array)
vp = arraysearch(vp, val);
vp->flag |= DEFINED;
if (special(n))
vp->flag |= SPECIAL;
return (vp);
}
int main(int argc, char** argv)
{
try {
if (getoptions(argc, argv) != 0)
return 1;
expgram::NGramCounts ngram(ngram_file, shards, debug);
std::string line;
tokens_type tokens;
const int order = ngram.index.order();
while (std::getline(std::cin, line)) {
tokenizer_type tokenizer(line);
// Here, we store in vector<string>.
tokens.clear();
tokens.insert(tokens.end(), tokenizer.begin(), tokenizer.end());
//
// Alternatively, you can try: (Remark: sentence is simply vector<word_type>)
//
// sentence.clear();
// sentence.insert(sentence.end(), tokenizer.begin(), tokenizer.end());
//
// and iterate over sentence type, not tokens.
//
//
// The above example still automatically convert word_type into word_type::id_type on the fly.
// An alternative faster approach is: (Remark: we assume id_set is vector<word_type::id_type> )
//
// id_set.clear();
// for (tokenizer_type::iterator titer = tokenizer.begin(); titer != tokenizer.end(); ++ titer)
// id_set.push_back(ngram.index.vocab()[*titer]);
//
// then, you can iterate over id_set, not tokens.
//
//
// Note that the word_type will automatically assign id which may not
// match with the word-id assigned by the indexed ngram language model.
// This means that even OOV by the ngram language model may be assigned word-id.
// If you want to avoid this, here is a solution:
//
// const word_type::id_type unk_id = ngram.index.vocab()[vocab_type::UNK]
//
// id_set.clear();
// for (tokenizer_type::iterator titer = tokenizer.begin(); titer != tokenizer.end(); ++ titer)
// id_set.push_back(ngram.index.vocab().exists(*titer) ? ngram.index.vocab()[*titer] : unk_id);
//
// ngram access must use containser that supports forward-iterator concepts.
// If not sure, use vector!
std::copy(tokens.begin(), tokens.end(), std::ostream_iterator<std::string>(std::cout, " "));
std::cout << ngram(tokens.begin(), tokens.end()) << std::endl;
}
}
catch (std::exception& err) {
std::cerr << "error: " << err.what() << std::endl;
return 1;
}
return 0;
}
