/* find the real compiler. We just search the PATH to find a executable of the
same name that isn't a link to ourselves */
static void find_compiler(int argc, char **argv)
{
char *base;
char *path;
orig_args = args_init(argc, argv);
base = str_basename(argv[0]);
/* we might be being invoked like "ccache gcc -c foo.c" */
if (strcmp(base, MYNAME) == 0) {
args_remove_first(orig_args);
free(base);
if (strchr(argv[1],'/')) {
/* a full path was given */
return;
}
base = str_basename(argv[1]);
}
/* support user override of the compiler */
if ((path=getenv("CCACHE_CC"))) {
base = strdup(path);
}
orig_args->argv[0] = find_executable(base, MYNAME);
/* can't find the compiler! */
if (!orig_args->argv[0]) {
stats_update(STATS_COMPILER);
perror(base);
exit(1);
}
}
int
main(int argc, char **argv)
{
cmd_args_t *args;
int rc = 0;
/* Argument init and parsing */
if ((args = args_init(argc, argv)) == NULL) {
rc = -1;
goto out;
}
/* Device specific init */
if ((rc = dev_init()))
goto out;
/* Generic kernel version string */
if (args->verbose)
fprintf(stdout, "%s", zpios_version);
print_stats_header(args);
rc = run_thread_counts(args);
out:
if (args != NULL)
args_fini(args);
dev_fini();
return (rc);
}
static
void parse_options(struct poclidek_ctx *cctx, struct poldek_ts *ts,
int argc, char **argv, int mode)
{
struct argp argp = { common_options, parse_opt,
args_doc, poldek_BANNER, 0, 0, 0};
int n, i, index, hide_child_opts = 0;
struct argp_child *child;
args_init(cctx, ts, argc, argv, mode);
n = 0;
while (poclidek_opgroup_tab[n])
n++;
child = alloca((n + 2) * sizeof(*child));
args.opgroup_rts = n_array_new(n, NULL, NULL);
for (i=0; i < n; i++) {
struct poclidek_opgroup_rt *rt;
child[i] = *(poclidek_opgroup_tab[i]->argp_child);
rt = poclidek_opgroup_rt_new(args.ts, args.opctx);
rt->run = poclidek_opgroup_tab[i]->run;
n_array_push(args.opgroup_rts, rt);
}
child[i].argp = NULL;
argp.children = child;
if (poclidek_argv_is_help(argc, (const char **)argv))
hide_child_opts = 1;
#if GENDOCBOOK
hide_child_opts = 1;
#endif
argp_prepare_child_options(&argp, hide_child_opts);
poldek_set_verbose(0);
index = 0;
argp_parse(&argp, argc, argv, ARGP_IN_ORDER, &index, &args);
if (!poclidek_op_ctx_verify_major_mode(args.opctx))
exit(EXIT_FAILURE);
if (!load_conf(&args))
exit(EXIT_FAILURE);
#if GENDOCBOOK
if (args.cnflags & OPT_AS_FLAG(OPT_DOCB)) {
argp_as_docbook(&argp);
exit(EXIT_SUCCESS);
}
#endif
return;
}
void in_push(char *s, char **args)
{
int len = strlen(s);
in_new();
buf->buf = xmalloc(len + 1);
buf->len = len;
strcpy(buf->buf, s);
buf->args = args ? args_init(args) : NULL;
}
void args_process(void *base,cmd_config_t *cmd_configs,int argc, char *argv[])
{
args_processor_t *processor = args_get_processor_globle_addr();
args_init(processor,base,cmd_configs);
/*
*args_print_help_info(processor);
*/
args_parse_args(processor,argc - 1, argv + 1);
}
static void test_unix_socket(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
args_struct args;
args_init(&exec_ctx, &args);
poll_pollset_until_request_done(&args);
grpc_resolve_address(
&exec_ctx, "unix:/path/name", NULL, args.pollset_set,
GRPC_CLOSURE_CREATE(must_succeed, &args, grpc_schedule_on_exec_ctx),
&args.addrs);
args_finish(&exec_ctx, &args);
grpc_exec_ctx_finish(&exec_ctx);
}
int main(int argc, char **argv)
{
ZArgs zargs;
args_init(&zargs, argc, argv, standard_malloc_factory_init());
SyncFactory_Pthreads sf;
Catalog catalog(&zargs, &sf);
catalog.scan(zargs.log, zargs.dep_file, zargs.zar);
catalog.emit(zargs.zar);
return 0;
}
/**
* Everything begins "here"
*
* @param argc The number of command line arguments
* @param argv Command line arguments
* @return Zero on and only on success
*/
int main(int argc, char* argv[])
{
int rc = 0;
size_t first, diff, end;
args_init((char*)"Rotate images in a pattern",
(char*)"crazy-rotate [--] <first> <gaps+1> [<last>]",
NULL, NULL, 1, 0, args_standard_abbreviations);
args_add_option(args_new_argumentless(NULL, 0, (char*)"--help", NULL),
(char*)"Prints this help message");
args_parse(argc, argv);
args_support_alternatives();
if (args_opts_used((char*)"--help"))
{
args_help();
goto exit;
}
if (args_unrecognised_count || (args_files_count < 2) || (args_files_count > 3))
goto invalid_opts;
first = parse_size(args_files[0]);
diff = parse_size(args_files[1]);
end = args_files_count == 3 ? parse_size(args_files[2]) : (SIZE_MAX - 1);
if (!first || !diff || !end)
goto invalid_opts;
if (end++ == SIZE_MAX)
t ((errno = ERANGE));
t (perform_rotate(first, diff, end));
exit:
args_dispose();
return rc;
invalid_opts:
args_help();
fail:
if (errno)
perror(*argv);
rc = 1;
goto exit;
}
int main(int argc, char **argv)
{
args_t args;
args_init (&args);
if (!args_parse (&args, argc, argv)) {
return -1;
} else {
if (args.Verbose)
args_print (&args);
}
return ! Yee_Compare(&args);
}
struct args *
args_init_from_string(const char *command)
{
char *p = x_strdup(command);
char *q = p;
char *word, *saveptr = NULL;
struct args *args = args_init(0, NULL);
while ((word = strtok_r(q, " \t\r\n", &saveptr))) {
args_add(args, word);
q = NULL;
}
free(p);
return args;
}
int
main(int argc, char **argv)
{
cmd_args_t *args = NULL;
int rc = 0;
/* General init */
if ((rc = init()))
return rc;
/* Device specific init */
if ((rc = dev_init()))
goto out;
/* Argument init and parsing */
if ((args = args_init(argc, argv)) == NULL) {
rc = -1;
goto out;
}
/* Generic kernel version string */
if (args->args_verbose)
fprintf(stdout, "%s", splat_version);
/* Print the available test list and exit */
if (args->args_do_list) {
subsystem_list(subsystems, 0);
goto out;
}
/* Add all available test to the list of tests to run */
if (args->args_do_all) {
if ((rc = test_add_all(args)))
goto out;
}
/* Run all the requested tests */
if ((rc = tests_run(args)))
goto out;
out:
if (args != NULL)
args_fini(args);
dev_fini();
fini();
return rc;
}
int main(int argc, const char *argv[])
{
int err, optind;
args_t args;
char *cmd_name;
ipkg_cmd_t *cmd;
ipkg_conf_t ipkg_conf;
error_list=NULL;
args_init(&args);
optind = args_parse(&args, argc, argv);
if (optind == argc || optind < 0) {
args_usage("ipkg must have one sub-command argument");
}
cmd_name = argv[optind++];
err = ipkg_conf_init(&ipkg_conf, &args);
if (err) {
return err;
}
args_deinit(&args);
cmd = ipkg_cmd_find(cmd_name);
if (cmd == NULL) {
fprintf(stderr, "%s: unknown sub-command %s\n", argv[0], cmd_name);
args_usage(NULL);
}
if (cmd->requires_args && optind == argc) {
fprintf(stderr, "%s: the ``%s'' command requires at least one argument\n",
__FUNCTION__, cmd_name);
args_usage(NULL);
}
err = ipkg_cmd_exec(cmd, &ipkg_conf, argc - optind, argv + optind);
if ( err == 0 ) {
ipkg_message(ipkg_conf, IPKG_NOTICE, "Succesfully done.\n");
} else {
ipkg_message(ipkg_conf, IPKG_NOTICE, "Error returned. Return value is %d\n.",err);
}
}
int
main(int argc, char *argv[])
{
char *program_name, *compiler_name, *other_wrappers, *sysroot;
struct args *compiler_args, *cmd;
compiler_args = args_init(argc, argv);
/* check if we were called directly. */
program_name = basename(compiler_args->argv[0]);
args_remove_first(compiler_args);
if (str_eq(program_name, MYNAME)) {
/* the first argument should be a compiler */
if (compiler_args->argc < 1 || compiler_args->argv[0][0] == '-') {
fprintf(stderr, "%s", USAGE_TEXT);
exit(1);
}
compiler_name = x_strdup(compiler_args->argv[0]);
args_remove_first(compiler_args);
} else {
compiler_name = x_strdup(program_name);
}
free(program_name);
other_wrappers = getenv(MYNAME "_OTHER_WRAPPERS");
if (!other_wrappers) {
other_wrappers = "ccache distcc";
}
cmd = find_all_executables(compiler_name, MYNAME, other_wrappers);
if (!cmd) {
fatal("No valid executables named %s found!", compiler_name);
}
free(compiler_name);
sysroot = getenv("SYSROOT");
if (sysroot) {
args_add(cmd, "--sysroot");
args_add(cmd, sysroot);
}
args_extend(cmd, compiler_args);
args_free(compiler_args);
execute(cmd->argv);
return 1;
}
int main(int argc, char **argv)
{
t_application app;
t_args args;
(void)argc;
if (!args_init(&args, argv + 1))
{
if (!application_init(&app, &args))
{
args_free(&args);
application_run(&app);
}
else
args_free(&args);
application_free(&app);
}
return (0);
}
static void test_unix_socket_path_name_too_long(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
args_struct args;
args_init(&exec_ctx, &args);
const char prefix[] = "unix:/path/name";
size_t path_name_length =
GPR_ARRAY_SIZE(((struct sockaddr_un *)0)->sun_path) + 6;
char *path_name = gpr_malloc(sizeof(char) * path_name_length);
memset(path_name, 'a', path_name_length);
memcpy(path_name, prefix, strlen(prefix) - 1);
path_name[path_name_length - 1] = '\0';
poll_pollset_until_request_done(&args);
grpc_resolve_address(
&exec_ctx, path_name, NULL, args.pollset_set,
GRPC_CLOSURE_CREATE(must_fail, &args, grpc_schedule_on_exec_ctx),
&args.addrs);
gpr_free(path_name);
args_finish(&exec_ctx, &args);
grpc_exec_ctx_finish(&exec_ctx);
}
int
main(int argc, char **argv)
{
fence_virt_args_t args;
const char *my_options;
int ret = 0;
args_init(&args);
if (!strcmp(basename(argv[0]), "fence_xvm")) {
my_options = "di:a:p:r:C:c:k:M:H:uo:t:?hVw:";
args.mode = MODE_MULTICAST;
} else {
my_options = "dD:P:A:p:M:H:o:t:?hVT:C:c:k:w:";
args.mode = MODE_SERIAL;
}
if (argc == 1) {
args_get_stdin(my_options, &args);
} else {
args_get_getopt(argc, argv, my_options, &args);
}
if (args.flags & F_HELP) {
args_usage(argv[0], my_options, 0);
printf("With no command line argument, arguments are "
"read from standard input.\n");
printf("Arguments read from standard input take "
"the form of:\n\n");
printf(" arg1=value1\n");
printf(" arg2=value2\n\n");
args_usage(argv[0], my_options, 1);
exit(0);
}
if (args.flags & F_VERSION) {
printf("%s %s\n", basename(argv[0]), XVM_VERSION);
#ifdef FENCE_RELEASE_NAME
printf("fence release %s\n", FENCE_RELEASE_NAME);
#endif
exit(0);
}
openlog(basename(argv[0]), LOG_NDELAY | LOG_PID, LOG_DAEMON);
args_finalize(&args);
dset(args.debug);
if (args.debug > 0)
args_print(&args);
/* Additional validation here */
if (!args.domain && (args.op != FENCE_DEVSTATUS &&
args.op != FENCE_HOSTLIST &&
args.op != FENCE_METADATA)) {
printf("No domain specified!\n");
syslog(LOG_NOTICE, "No domain specified");
args.flags |= F_ERR;
}
if (args.net.ipaddr) {
args.mode = MODE_TCP;
}
if (args.flags & F_ERR) {
args_usage(argv[0], my_options, (argc == 1));
exit(1);
}
if (args.op == FENCE_METADATA) {
args_metadata(argv[0], my_options);
return 0;
}
if (args.delay > 0 &&
args.op != FENCE_STATUS &&
args.op != FENCE_DEVSTATUS &&
args.op != FENCE_HOSTLIST)
sleep(args.delay);
switch(args.mode) {
case MODE_MULTICAST:
ret = mcast_fence_virt(&args);
break;
case MODE_SERIAL:
ret = serial_fence_virt(&args);
break;
case MODE_TCP:
ret = tcp_fence_virt(&args);
break;
default:
ret = 1;
goto out;
}
switch(ret) {
case RESP_OFF:
if (args.op == FENCE_STATUS)
printf("Status: OFF\n");
else if (args.domain)
syslog(LOG_NOTICE, "Domain \"%s\" is OFF", args.domain);
break;
case 0:
if (args.op == FENCE_STATUS)
printf("Status: ON\n");
else if (args.domain)
syslog(LOG_NOTICE, "Domain \"%s\" is ON", args.domain);
break;
case RESP_FAIL:
if (args.domain) {
syslog(LOG_NOTICE, "Fence operation failed for domain \"%s\"",
args.domain);
} else
syslog(LOG_NOTICE, "Fence operation failed");
printf("Operation failed\n");
break;
case RESP_PERM:
if (args.domain) {
syslog(LOG_NOTICE,
"Permission denied for Fence operation for domain \"%s\"",
args.domain);
} else
syslog(LOG_NOTICE, "Permission denied for fence operation");
printf("Permission denied\n");
break;
default:
if (args.domain) {
syslog(LOG_NOTICE, "Unknown response (%d) for domain \"%s\"",
ret, args.domain);
} else
syslog(LOG_NOTICE, "Unknown response (%d)", ret);
printf("Unknown response (%d)\n", ret);
break;
}
out:
closelog();
return ret;
}
/*
* Process the compiler options into options suitable for passing to the
* preprocessor and the real compiler. The preprocessor options don't include
* -E; this is added later. Returns true on success, otherwise false.
*/
bool
armcc_process_args(struct args *orig_args, struct args **preprocessor_args,
struct args **compiler_args)
{
int i;
bool found_c_opt = false;
bool found_S_opt = false;
bool found_pch = false;
bool found_fpch_preprocess = false;
const char *actual_language; /* Language to actually use. */
const char *input_charset = NULL;
struct stat st;
/* is the dependency makefile name overridden with --depend? */
bool dependency_filename_specified = false;
/* is the dependency makefile target name specified ? */
bool dependency_target_specified = false;
char *dep_file = NULL, *dep_dir = NULL;
struct args *stripped_args = NULL, *dep_args = NULL;
int argc = orig_args->argc;
char **argv = orig_args->argv;
bool result = true;
/* 0: Choose preprocessor type by the file extension.
* 1: Use c preprocessor.
* 2: Use c++ preprocessor.*/
unsigned force_preprocessor_type = 0;
stripped_args = args_init(0, NULL);
dep_args = args_init(0, NULL);
args_add(stripped_args, argv[0]);
for (i = 1; i < argc; i++) {
/* The user knows best: just swallow the next arg */
if (str_eq(argv[i], "--ccache-skip")) {
i++;
if (i == argc) {
cc_log("--ccache-skip lacks an argument");
result = false;
goto out;
}
args_add(stripped_args, argv[i]);
continue;
}
/* Special case for -E. */
if (str_eq(argv[i], "-E")) {
stats_update(STATS_PREPROCESSING);
result = false;
goto out;
}
/* These are always too hard. */
if (compopt_too_hard(argv[i])
|| str_startswith(argv[i], "@")
|| str_startswith(argv[i], "-fdump-")) {
cc_log("Compiler option %s is unsupported", argv[i]);
stats_update(STATS_UNSUPPORTED);
result = false;
goto out;
}
/* These are too hard in direct mode. */
if (enable_direct) {
if (compopt_too_hard_for_direct_mode(argv[i])) {
cc_log("Unsupported compiler option for direct mode: %s", argv[i]);
enable_direct = false;
}
}
/* we must have -c */
if (str_eq(argv[i], "-c")) {
args_add(stripped_args, argv[i]);
found_c_opt = true;
continue;
}
/* -S changes the default extension */
if (str_eq(argv[i], "-S")) {
args_add(stripped_args, argv[i]);
found_S_opt = true;
continue;
}
/* we need to work out where the output was meant to go */
if (str_eq(argv[i], "-o")) {
if (i == argc-1) {
cc_log("Missing argument to %s", argv[i]);
stats_update(STATS_ARGS);
result = false;
goto out;
}
output_obj = argv[i+1];
i++;
continue;
}
/* alternate form of -o, with no space */
if (str_startswith(argv[i], "-o")) {
output_obj = &argv[i][2];
continue;
}
/* If multiple source type options are there, the armcc will use the last one. */
if (str_eq(argv[i], "--cpp")) {
force_preprocessor_type = 2;
continue;
}
else if (str_eq(argv[i], "--c90") || str_eq(argv[i], "--c99")) {
force_preprocessor_type = 1;
continue;
}
if (str_eq(argv[i], "--md")) {
generating_dependencies = true;
continue;
}
/* The rvct started supporting --depend_target from 4.0.
* And there is a bug when using -E and --depend together with rvct which version is earlier than 4.0_697.
* That is too hard to support "--depend" for the earlier version of rvct.*/
if (str_startswith(argv[i], "--depend_dir")) {
/* We just concat the dir and the filename and pass the result
* to --depend. */
if (i >= argc - 1) {
cc_log("Missing argument to %s", argv[i]);
stats_update(STATS_ARGS);
result = false;
goto out;
}
dep_dir= x_strdup(argv[i+1]);
i++;
continue;
}
else if (str_startswith(argv[i], "--depend_target")) {
if (i >= argc - 1) {
cc_log("Missing argument to %s", argv[i]);
stats_update(STATS_ARGS);
result = false;
goto out;
}
dependency_target_specified = true;
args_add(dep_args, argv[i]);
args_add(dep_args, argv[i+1]);
i++;
continue;
}
else if (str_startswith(argv[i], "--depend")) {
dependency_filename_specified = true;
generating_dependencies = true;
if (i >= argc - 1) {
cc_log("Missing argument to %s", argv[i]);
stats_update(STATS_ARGS);
result = false;
goto out;
}
dep_file = x_strdup(argv[i + 1]);
i++;
continue;
}
/*
* Options taking an argument that that we may want to rewrite
* to relative paths to get better hit rate. A secondary effect
* is that paths in the standard error output produced by the
* compiler will be normalized.
*/
if (compopt_takes_path(argv[i])) {
char *relpath;
char *pchpath;
if (i == argc-1) {
cc_log("Missing argument to %s", argv[i]);
stats_update(STATS_ARGS);
result = false;
goto out;
}
args_add(stripped_args, argv[i]);
relpath = make_relative_path(x_strdup(argv[i+1]));
args_add(stripped_args, relpath);
/* Try to be smart about detecting precompiled headers */
pchpath = format("%s.gch", argv[i+1]);
if (stat(pchpath, &st) == 0) {
cc_log("Detected use of precompiled header: %s", pchpath);
found_pch = true;
}
free(pchpath);
free(relpath);
i++;
continue;
}
/* Same as above but options with concatenated argument. */
if (compopt_short(compopt_takes_path, argv[i])) {
char *relpath;
char *option;
relpath = make_relative_path(x_strdup(argv[i] + 2));
option = format("-%c%s", argv[i][1], relpath);
args_add(stripped_args, option);
free(relpath);
free(option);
continue;
}
/* options that take an argument */
if (compopt_takes_arg(argv[i])) {
if (i == argc-1) {
cc_log("Missing argument to %s", argv[i]);
stats_update(STATS_ARGS);
result = false;
goto out;
}
args_add(stripped_args, argv[i]);
args_add(stripped_args, argv[i+1]);
i++;
continue;
}
/* other options */
if (argv[i][0] == '-') {
args_add(stripped_args, argv[i]);
continue;
}
/* if an argument isn't a plain file then assume its
an option, not an input file. This allows us to
cope better with unusual compiler options */
if (stat(argv[i], &st) != 0 || !S_ISREG(st.st_mode)) {
cc_log("%s is not a regular file, not considering as input file",
argv[i]);
args_add(stripped_args, argv[i]);
continue;
}
if (input_file) {
if (language_for_file(argv[i])) {
cc_log("Multiple input files: %s and %s", input_file, argv[i]);
stats_update(STATS_MULTIPLE);
} else if (!found_c_opt) {
cc_log("Called for link with %s", argv[i]);
if (strstr(argv[i], "conftest.")) {
stats_update(STATS_CONFTEST);
} else {
stats_update(STATS_LINK);
}
} else {
cc_log("Unsupported source extension: %s", argv[i]);
stats_update(STATS_SOURCELANG);
}
result = false;
goto out;
}
/* Rewrite to relative to increase hit rate. */
input_file = make_relative_path(x_strdup(argv[i]));
}
if (!input_file) {
cc_log("No input file found");
stats_update(STATS_NOINPUT);
result = false;
goto out;
}
if (found_pch || found_fpch_preprocess) {
using_precompiled_header = true;
if (!(sloppiness & SLOPPY_TIME_MACROS)) {
cc_log("You have to specify \"time_macros\" sloppiness when using"
" precompiled headers to get direct hits");
cc_log("Disabling direct mode");
stats_update(STATS_CANTUSEPCH);
result = false;
goto out;
}
}
if(force_preprocessor_type == 0) {
actual_language = language_for_file(input_file);
}
else if(force_preprocessor_type == 2) {
actual_language = "c++";
}
else {
actual_language = "c";
}
output_is_precompiled_header =
actual_language && strstr(actual_language, "-header") != NULL;
if (!found_c_opt && !output_is_precompiled_header) {
cc_log("No -c option found");
/* I find that having a separate statistic for autoconf tests is useful,
as they are the dominant form of "called for link" in many cases */
if (strstr(input_file, "conftest.")) {
stats_update(STATS_CONFTEST);
} else {
stats_update(STATS_LINK);
}
result = false;
goto out;
}
if (!actual_language) {
cc_log("Unsupported source extension: %s", input_file);
stats_update(STATS_SOURCELANG);
result = false;
goto out;
}
direct_i_file = language_is_preprocessed(actual_language);
if (output_is_precompiled_header) {
/* It doesn't work to create the .gch from preprocessed source. */
cc_log("Creating precompiled header; not compiling preprocessed code");
compile_preprocessed_source_code = false;
}
/* don't try to second guess the compilers heuristics for stdout handling */
if (output_obj && str_eq(output_obj, "-")) {
stats_update(STATS_OUTSTDOUT);
cc_log("Output file is -");
result = false;
goto out;
}
if (!output_obj) {
if (output_is_precompiled_header) {
output_obj = format("%s.gch", input_file);
} else {
char *p;
output_obj = x_strdup(input_file);
if ((p = strrchr(output_obj, '/'))) {
output_obj = p+1;
}
p = strrchr(output_obj, '.');
if (!p || !p[1]) {
cc_log("Badly formed object filename");
stats_update(STATS_ARGS);
result = false;
goto out;
}
p[1] = found_S_opt ? 's' : 'o';
p[2] = 0;
}
}
/* cope with -o /dev/null */
if (!str_eq(output_obj,"/dev/null")
&& stat(output_obj, &st) == 0
&& !S_ISREG(st.st_mode)) {
cc_log("Not a regular file: %s", output_obj);
stats_update(STATS_DEVICE);
result = false;
goto out;
}
/*
* Some options shouldn't be passed to the real compiler when it compiles
* preprocessed code:
*
* -finput-charset=XXX (otherwise conversion happens twice)
* -x XXX (otherwise the wrong language is selected)
*/
*preprocessor_args = args_copy(stripped_args);
if (input_charset) {
args_add(*preprocessor_args, input_charset);
}
if (found_pch) {
args_add(*preprocessor_args, "-fpch-preprocess");
}
/*
* Add flags for dependency generation only to the preprocessor command line.
*/
if (generating_dependencies) {
char *dep_path;
if(!dependency_filename_specified)
{
char *base_name;
base_name = remove_extension(output_obj);
dep_file = format("%s.d", base_name);
free(base_name);
}
if (!dependency_target_specified) {
args_add(dep_args, "--depend_target");
args_add(dep_args, output_obj);
}
free(output_dep);
if(dep_dir)
{
#ifdef _WIN32
dep_path = make_relative_path(format("%s\\%s", dep_dir, dep_file));
#else
dep_path = make_relative_path(format("%s/%s", dep_dir, dep_file));
#endif
}
else
{
dep_path = x_strdup(dep_file);
}
args_add(dep_args, "--depend");
args_add(dep_args, dep_path);
/* dep_path will be free in make_relative_path */
output_dep = make_relative_path(x_strdup(dep_path));
}
if (compile_preprocessed_source_code) {
*compiler_args = args_copy(stripped_args);
} else {
*compiler_args = args_copy(*preprocessor_args);
}
i_extension = getenv("CCACHE_EXTENSION");
if (!i_extension) {
const char *p_language = p_language_for_language(actual_language);
i_extension = extension_for_language(p_language) + 1;
}
/* Patch for preprocessed file extension for armcc 3.1.
* armcc 3.1 cannot recognize "i" or "ii" as the preprocessed source file
* without --compile_all_input. */
args_add(*compiler_args, "--compile_all_input");
if (str_eq(i_extension, "ii")) {
args_add(*compiler_args, "--cpp");
}
/*
* Only pass dependency arguments to the preprocesor since Intel's C++
* compiler doesn't produce a correct .d file when compiling preprocessed
* source.
*/
args_extend(*preprocessor_args, dep_args);
out:
free(dep_file);
free(dep_dir);
args_free(stripped_args);
args_free(dep_args);
return result;
}
/*
* Process the compiler options into options suitable for passing to the
* preprocessor and the real compiler. The preprocessor options don't include
* -E; this is added later. Returns true on success, otherwise false.
*/
bool
c166_process_args(struct args *orig_args, struct args **preprocessor_args,
struct args **compiler_args)
{
int i;
bool found_c_opt = false;
bool found_S_opt = false;
bool found_H_opt = false;
/* 0: Choose preprocessor type by the file extension.
* 1: Use c preprocessor.
* 2: Use c++ preprocessor.*/
unsigned force_preprocessor_type = 0;
const char *actual_language; /* Language to actually use. */
struct stat st;
/* is the dependency makefile name overridden with -MF? */
bool dependency_filename_specified = false;
/* is the dependency makefile target name specified with -MT or -MQ? */
bool dependency_target_specified = false;
struct args *stripped_args = NULL, *dep_args = NULL, *h_args;
int argc = orig_args->argc;
char **argv = orig_args->argv;
bool result = true;
stripped_args = args_init(0, NULL);
dep_args = args_init(0, NULL);
h_args = args_init(0, NULL);
args_add(stripped_args, argv[0]);
for (i = 1; i < argc; i++) {
/* The user knows best: just swallow the next arg */
if (str_eq(argv[i], "--ccache-skip")) {
i++;
if (i == argc) {
cc_log("--ccache-skip lacks an argument");
result = false;
goto out;
}
args_add(stripped_args, argv[i]);
continue;
}
/* Special case for -E. */
if (str_eq(argv[i], "-E")) {
stats_update(STATS_PREPROCESSING);
result = false;
goto out;
}
/* These are always too hard. */
if (compopt_too_hard(argv[i])) {
cc_log("Compiler option %s is unsupported", argv[i]);
stats_update(STATS_UNSUPPORTED);
result = false;
goto out;
}
/* These are too hard in direct mode. */
if (enable_direct) {
if (compopt_too_hard_for_direct_mode(argv[i])) {
cc_log("Unsupported compiler option for direct mode: %s", argv[i]);
enable_direct = false;
}
}
/* we must have -c */
if (str_eq(argv[i], "-c")) {
args_add(stripped_args, argv[i]);
found_c_opt = true;
continue;
}
/* -S changes the default extension */
/* TODO: Check this -S out!
if (str_eq(argv[i], "-S")) {
args_add(stripped_args, argv[i]);
found_S_opt = true;
continue;
}
*/
/* we need to work out where the output was meant to go */
if (str_eq(argv[i], "-o")) {
if (i == argc-1) {
cc_log("Missing argument to %s", argv[i]);
stats_update(STATS_ARGS);
result = false;
goto out;
}
output_obj = argv[i+1];
i++;
continue;
}
/* alternate form of -o, with no space */
if (str_startswith(argv[i], "-o")) {
output_obj = &argv[i][2];
continue;
}
/* debugging is handled specially, so that we know if we
can strip line number info
*/
if (str_startswith(argv[i], "-g")) {
args_add(stripped_args, argv[i]);
if (enable_unify) {
cc_log("%s used; disabling unify mode", argv[i]);
enable_unify = false;
}
continue;
}
if (str_startswith(argv[i], "-H")) {
cc_log("Detected -H %s", argv[i]);
args_add(h_args, argv[i]);
found_H_opt = true;
continue;
}
/*
* Options taking an argument that that we may want to rewrite
* to relative paths to get better hit rate. A secondary effect
* is that paths in the standard error output produced by the
* compiler will be normalized.
*/
if (compopt_takes_path(argv[i])) {
char *relpath;
if (i == argc-1) {
cc_log("Missing argument to %s", argv[i]);
stats_update(STATS_ARGS);
result = false;
goto out;
}
args_add(stripped_args, argv[i]);
relpath = make_relative_path(x_strdup(argv[i+1]));
args_add(stripped_args, relpath);
free(relpath);
i++;
continue;
}
/* Same as above but options with concatenated argument. */
if (compopt_short(compopt_takes_path, argv[i])) {
char *relpath;
char *option;
relpath = make_relative_path(x_strdup(argv[i] + 2));
option = format("-%c%s", argv[i][1], relpath);
args_add(stripped_args, option);
free(relpath);
free(option);
continue;
}
/* options that take an argument */
if (compopt_takes_arg(argv[i])) {
if (i == argc-1) {
cc_log("Missing argument to %s", argv[i]);
stats_update(STATS_ARGS);
result = false;
goto out;
}
args_add(stripped_args, argv[i]);
args_add(stripped_args, argv[i+1]);
i++;
continue;
}
if (str_eq(argv[i], "-c++")) {
force_preprocessor_type = 2;
args_add(stripped_args, argv[i]);
continue;
}
if (str_eq(argv[i], "-noc++")) {
force_preprocessor_type = 1;
args_add(stripped_args, argv[i]);
continue;
}
/* other options */
if (argv[i][0] == '-') {
args_add(stripped_args, argv[i]);
continue;
}
/* if an argument isn't a plain file then assume its
an option, not an input file. This allows us to
cope better with unusual compiler options */
if (stat(argv[i], &st) != 0 || !S_ISREG(st.st_mode)) {
cc_log("%s is not a regular file, not considering as input file",
argv[i]);
args_add(stripped_args, argv[i]);
continue;
}
if (input_file) {
if (language_for_file(argv[i])) {
cc_log("Multiple input files: %s and %s", input_file, argv[i]);
stats_update(STATS_MULTIPLE);
} else if (!found_c_opt) {
cc_log("Called for link with %s", argv[i]);
if (strstr(argv[i], "conftest.")) {
stats_update(STATS_CONFTEST);
} else {
stats_update(STATS_LINK);
}
} else {
cc_log("Unsupported source extension: %s", argv[i]);
stats_update(STATS_SOURCELANG);
}
result = false;
goto out;
}
/* Rewrite to relative to increase hit rate. */
input_file = make_relative_path(x_strdup(argv[i]));
}
if (!input_file) {
cc_log("No input file found");
stats_update(STATS_NOINPUT);
result = false;
goto out;
}
if(force_preprocessor_type == 0) {
actual_language = language_for_file(input_file);
}
else if(force_preprocessor_type == 2) {
actual_language = "c++";
}
else {
actual_language = "c";
}
output_is_precompiled_header =
actual_language && strstr(actual_language, "-header") != NULL;
if (!found_c_opt && !output_is_precompiled_header) {
cc_log("No -c option found");
/* I find that having a separate statistic for autoconf tests is useful,
as they are the dominant form of "called for link" in many cases */
if (strstr(input_file, "conftest.")) {
stats_update(STATS_CONFTEST);
} else {
stats_update(STATS_LINK);
}
result = false;
goto out;
}
if (!actual_language) {
cc_log("Unsupported source extension: %s", input_file);
stats_update(STATS_SOURCELANG);
result = false;
goto out;
}
direct_i_file = language_is_preprocessed(actual_language);
if (output_is_precompiled_header) {
/* It doesn't work to create the .gch from preprocessed source. */
cc_log("Creating precompiled header; not compiling preprocessed code");
compile_preprocessed_source_code = false;
}
i_extension = getenv("CCACHE_EXTENSION");
if (!i_extension) {
const char *p_language = p_language_for_language(actual_language);
if(str_eq(p_language, "c++-cpp-output")) {
/* Dirty fix for preprocessed file extension for cc166.
* The cp166 cannot handle cpp files with extension ii.*/
i_extension = "ii.cpp";
}
else {
i_extension = extension_for_language(p_language) + 1;
}
}
/* don't try to second guess the compilers heuristics for stdout handling */
if (output_obj && str_eq(output_obj, "-")) {
stats_update(STATS_OUTSTDOUT);
cc_log("Output file is -");
result = false;
goto out;
}
if (!output_obj) {
if (output_is_precompiled_header) {
output_obj = format("%s.gch", input_file);
} else {
char *p;
output_obj = x_strdup(input_file);
if ((p = strrchr(output_obj, '/'))) {
output_obj = p+1;
}
p = strrchr(output_obj, '.');
if (!p || !p[1]) {
cc_log("Badly formed object filename");
stats_update(STATS_ARGS);
result = false;
goto out;
}
*p = 0;
p = output_obj;
if(found_S_opt)
{
output_obj = format("%s.s", p);
}
else
{ /*The default extension of object file is obj for c166.*/
output_obj = format("%s.obj", p);
}
free(p);
}
}
/* cope with -o /dev/null */
if (!str_eq(output_obj,"/dev/null")
&& stat(output_obj, &st) == 0
&& !S_ISREG(st.st_mode)) {
cc_log("Not a regular file: %s", output_obj);
stats_update(STATS_DEVICE);
result = false;
goto out;
}
/*
* Some options shouldn't be passed to the real compiler when it compiles
* preprocessed code:
*/
*preprocessor_args = args_copy(stripped_args);
/* Args with -H has been already preprocessed.
* If it passed to the compiler again, some type redefined error will pop up.*/
if (found_H_opt) {
args_extend(*preprocessor_args, h_args);
}
/*
* Add flags for dependency generation only to the preprocessor command line.
*/
if (generating_dependencies) {
if (!dependency_filename_specified) {
char *default_depfile_name;
char *base_name;
base_name = remove_extension(output_obj);
default_depfile_name = format("%s.d", base_name);
free(base_name);
args_add(dep_args, "-MF");
args_add(dep_args, default_depfile_name);
output_dep = make_relative_path(x_strdup(default_depfile_name));
}
if (!dependency_target_specified) {
args_add(dep_args, "-MQ");
args_add(dep_args, output_obj);
}
}
if (compile_preprocessed_source_code) {
*compiler_args = args_copy(stripped_args);
} else {
*compiler_args = args_copy(*preprocessor_args);
}
/* Due to bugs or cc166 v8.6r3, the behaviours of c/c++ preprocessor
* are quite different.
* When using cpp preprocessor, the output will be directly send to stdout like gcc.
* When using c preprocessor, the output will be written to filename.i even without "-o".*/
if(str_eq(actual_language, "c"))
{
#ifdef _WIN32
#error Never test this in Windows.
#else
args_add(*preprocessor_args, "-o/dev/stdout");
#endif
}
/*
* Only pass dependency arguments to the preprocesor since Intel's C++
* compiler doesn't produce a correct .d file when compiling preprocessed
* source.
*/
args_extend(*preprocessor_args, dep_args);
out:
args_free(stripped_args);
args_free(dep_args);
args_free(h_args);
return result;
}
int main(int argc, char** argv_)
{
int found = 0;
int first_pid = 1;
char* usage_str;
ssize_t i, n;
argv = argv_;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
n = (ssize_t)(strlen(_(" [options] [program...]")) + strlen(*argv) + 1);
usage_str = alloca((size_t)n * sizeof(char));
sprintf(usage_str, "%s%s", *argv, _(" [options] [program...]"));
args_init(!strcmp(argv[0], "dpidof")
? _("epidof with display isolation")
: _("pidof with environment constraints"),
usage_str, NULL, 0, 1, 0, args_standard_abbreviations);
args_add_option(args_new_argumentless(NULL, 0, "-c", "--check-root", NULL), _("Restrict to processes running under the same root"));
args_add_option(args_new_argumentless(NULL, 0, "-s", "--single-shot", NULL), _("Return only one process ID"));
args_add_option(args_new_argumentless(NULL, 0, "-x", "--scripts", NULL), _("Test the name of scripts"));
args_add_option(args_new_argumented (NULL, _("PID"), 0, "-o", "--omit-pid", NULL), _("Do not return a specific process ID"));
args_add_option(args_new_argumentless(NULL, 0, "-h", "--help", NULL), _("Display this help information"));
args_add_option(args_new_argumentless(NULL, 0, "-V", "--version", NULL), _("Print the name and version of this program"));
environment_parse(&argc, argv);
args_parse(argc, argv);
if (args_unrecognised_count || args_opts_used("-h")) args_help(), fprintf(stderr, "%s\n\n", _(environment_synopsis));
else if (args_opts_used("-V")) printf("%s " VERSION, !strcmp(argv[0], "dpidof") ? "dpidof" : "epidof");
else goto cont;
return args_unrecognised_count ? EXIT_FAILURE : EXIT_SUCCESS;
cont:
/* process command-line options */
if (args_opts_used("-s")) opt_single_shot = 1;
if (args_opts_used("-x")) opt_scripts_too = 1;
if (args_opts_used("-c") && (geteuid() == 0))
epidof_root = pid_link(getpid(), "root");
if (args_opts_used("-o"))
{
char** arr = args_opts_get("-o");
for (i = 0, n = (ssize_t)args_opts_get_count("-o"); i < n; i++)
add_to_omit_list(arr[i]);
}
/* main loop */
for (n = 0; n < args_files_count; n++) /* for each program */
{
program = args_files[n];
proc_count = 0;
select_procs(); /* get the list of matching processes */
if (proc_count > 0)
{
found = 1;
for (i = (ssize_t)proc_count - 1; i >= 0; i--) /* and display their PIDs */
{
printf(first_pid ? "%ld" : " %ld", (long)(procs[i]));
first_pid = 0;
if (opt_single_shot)
break;
}
}
}
/* final line feed */
if (found)
printf("\n");
xfree(procs);
xfree(omitted_procs);
xfree(epidof_root);
args_dispose();
environment_dispose();
return !found;
}
int main (int argc, char * argv[])
{
fillheader();
getentirecommandline(argc, argv);
args_init(argc, argv);
srand((unsigned int)opt_seed);
if (!opt_quiet)
show_header();
if (opt_help)
{
cmd_help();
}
else if (opt_lca_left)
{
cmd_lca_left();
}
else if (opt_identical)
{
cmd_identical();
}
else if (opt_root)
{
cmd_root();
}
else if (opt_extract_ltips)
{
cmd_extract_ltips();
}
else if (opt_extract_rtips)
{
cmd_extract_rtips();
}
else if (opt_extract_tips)
{
cmd_extract_tips();
}
else if (opt_prune_tips || opt_prune_random)
{
cmd_prune_tips();
}
else if (opt_svg)
{
cmd_svg();
}
else if (opt_extract_lsubtree)
{
cmd_extract_subtree(0);
}
else if (opt_extract_rsubtree)
{
cmd_extract_subtree(1);
}
else if (opt_treeshow)
{
cmd_tree_show();
}
else if (opt_induce_subtree)
{
cmd_induce_tree();
}
else if (opt_subtree_short >= 0)
{
cmd_subtree_short();
}
else if (opt_info)
{
cmd_info();
}
else if (opt_make_binary)
{
cmd_make_binary();
}
else if (opt_alltree_filename)
{
cmd_utree_bf();
}
else if (opt_randomtree_binary)
{
cmd_randomtree_binary();
}
else if (opt_simulate_bd)
{
cmd_simulate_bd();
}
else if (opt_attach_filename)
{
cmd_attach_tree();
}
else if (opt_scalebranch)
{
cmd_scalebranch();
}
free(cmdline);
return (0);
}
struct args *
args_init_from_gcc_atfile(const char *filename)
{
char *argtext;
if (!(argtext = read_text_file(filename, 0))) {
return NULL;
}
struct args *args = args_init(0, NULL);
char *pos = argtext;
char *argbuf = x_malloc(strlen(argtext) + 1);
char *argpos = argbuf;
// Used to track quoting state; if \0, we are not inside quotes. Otherwise
// stores the quoting character that started it, for matching the end quote.
char quoting = '\0';
while (1) {
switch (*pos) {
case '\\':
pos++;
if (*pos == '\0') {
continue;
}
break;
case '\"':
case '\'':
if (quoting != '\0') {
if (quoting == *pos) {
quoting = '\0';
pos++;
continue;
} else {
break;
}
} else {
quoting = *pos;
pos++;
continue;
}
case '\n':
case '\r':
case '\t':
case ' ':
if (quoting) {
break;
}
// Fall through.
case '\0':
// End of token
*argpos = '\0';
if (argbuf[0] != '\0') {
args_add(args, argbuf);
}
argpos = argbuf;
if (*pos == '\0') {
goto out;
} else {
pos++;
continue;
}
}
*argpos = *pos;
pos++;
argpos++;
}
out:
free(argbuf);
free(argtext);
return args;
}
struct args *
args_copy(struct args *args)
{
return args_init(args->argc, args->argv);
}
int ssh_open_url(url_t* urlp)
{
ftp->session = ssh_new();
if (!ftp->session)
return -1;
/* set log level */
if (ftp_get_verbosity() == vbDebug)
{
int verbosity = SSH_LOG_PROTOCOL;
ssh_options_set(ftp->session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
}
/* If we have ssh options from yafcrc, load them */
if (gvSSHOptions) {
args_t *args = args_create();
args_init(args, 0, NULL);
args_push_back(args, gvSSHOptions);
int argc = 0;
if (ssh_options_getopt(ftp->session, &argc, args->argv) != SSH_OK) {
ftp_err(_("Failed to load SSH options from yafcrc config (ssh_options = '%s')\n"), gvSSHOptions);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
args->argc = argc;
args_destroy(args);
}
/* set host name */
ssh_options_set(ftp->session, SSH_OPTIONS_HOST, urlp->hostname);
/* if we have port use that one */
if (urlp->port > 0)
ssh_options_set(ftp->session, SSH_OPTIONS_PORT, &urlp->port);
/* parse .ssh/config */
int r = ssh_options_parse_config(ftp->session, NULL);
if (r != SSH_OK)
{
ftp_err(_("Failed to parse ssh config: %s\n"), ssh_get_error(ftp->session));
ssh_free(ftp->session);
ftp->session = NULL;
return r;
}
/* if we have username use that one */
if (urlp->username)
ssh_options_set(ftp->session, SSH_OPTIONS_USER, urlp->username);
/* connect to server */
r = ssh_connect(ftp->session);
if (r != SSH_OK)
{
ftp_err(_("Couldn't initialise connection to server: %s\n"), ssh_get_error(ftp->session));
ssh_free(ftp->session);
ftp->session = NULL;
return r;
}
/* verify server */
if (verify_knownhost(ftp->session))
{
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
/* authenticate user */
r = test_several_auth_methods(ftp->session, urlp);
if (r != SSH_OK)
{
ftp_err(_("Authentication failed: %s\n"), ssh_get_error(ftp->session));
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
ftp->ssh_version = ssh_get_version(ftp->session);
if (!ftp->ssh_version) {
ftp_err(_("Couldn't initialise connection to server\n"));
return -1;
}
ftp->sftp_session = sftp_new(ftp->session);
if (!ftp->sftp_session)
{
ftp_err(_("Couldn't initialise ftp subsystem: %s\n"), ssh_get_error(ftp->session));
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
r = sftp_init(ftp->sftp_session);
if (r != SSH_OK)
{
ftp_err(_("Couldn't initialise ftp subsystem: %s\n"), ssh_get_error(ftp->sftp_session));
sftp_free(ftp->sftp_session);
ftp->sftp_session = NULL;
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return r;
}
ftp->connected = true;
ftp->loggedin = true;
free(ftp->homedir);
ftp->homedir = ftp_getcurdir();
url_destroy(ftp->url);
ftp->url = url_clone(urlp);
free(ftp->curdir);
ftp->curdir = xstrdup(ftp->homedir);
free(ftp->prevdir);
ftp->prevdir = xstrdup(ftp->homedir);
if (ftp->url->directory)
ftp_chdir(ftp->url->directory);
ftp_get_feat();
return 0;
}
/*
process the compiler options to form the correct set of options
for obtaining the preprocessor output
*/
static void process_args(int argc, char **argv)
{
int i;
int found_c_opt = 0;
int found_S_opt = 0;
struct stat st;
char *e;
/* is gcc being asked to output dependencies? */
int generating_dependencies = 0;
/* is the dependency makefile name overridden with -MF? */
int dependency_filename_specified = 0;
/* is the dependency makefile target name specified with -MQ or -MF? */
int dependency_target_specified = 0;
stripped_args = args_init(0, NULL);
args_add(stripped_args, argv[0]);
/* -c not required for SWIG */
if (swig) {
found_c_opt = 1;
}
for (i=1; i<argc; i++) {
/* some options will never work ... */
if (strcmp(argv[i], "-E") == 0) {
failed();
}
/* these are too hard */
if (strcmp(argv[i], "-fbranch-probabilities")==0 ||
strcmp(argv[i], "-fprofile-arcs") == 0 ||
strcmp(argv[i], "-ftest-coverage") == 0 ||
strcmp(argv[i], "--coverage") == 0 ||
strcmp(argv[i], "-M") == 0 ||
strcmp(argv[i], "-MM") == 0 ||
strcmp(argv[i], "-x") == 0) {
cc_log("argument %s is unsupported\n", argv[i]);
stats_update(STATS_UNSUPPORTED);
failed();
continue;
}
/* we must have -c */
if (strcmp(argv[i], "-c") == 0) {
if (!strip_c_option) {
args_add(stripped_args, argv[i]);
}
found_c_opt = 1;
continue;
}
/* -S changes the default extension */
if (strcmp(argv[i], "-S") == 0) {
args_add(stripped_args, argv[i]);
found_S_opt = 1;
continue;
}
/* we need to work out where the output was meant to go */
if (strcmp(argv[i], "-o") == 0) {
if (i == argc-1) {
cc_log("missing argument to %s\n", argv[i]);
stats_update(STATS_ARGS);
failed();
}
output_file = argv[i+1];
i++;
continue;
}
/* alternate form of -o, with no space */
if (!swig) { /* some of SWIG's arguments begin with -o */
if (strncmp(argv[i], "-o", 2) == 0) {
output_file = &argv[i][2];
continue;
}
}
/* debugging is handled specially, so that we know if we
can strip line number info
*/
if (strncmp(argv[i], "-g", 2) == 0) {
args_add(stripped_args, argv[i]);
if (strcmp(argv[i], "-g0") != 0) {
enable_unify = 0;
}
continue;
}
/* The user knows best: just swallow the next arg */
if (strcmp(argv[i], "--ccache-skip") == 0) {
i++;
if (i == argc) {
failed();
}
args_add(stripped_args, argv[i]);
continue;
}
/* These options require special handling, because they
behave differently with gcc -E, when the output
file is not specified. */
if (strcmp(argv[i], "-MD") == 0 || strcmp(argv[i], "-MMD") == 0) {
generating_dependencies = 1;
} else if (strcmp(argv[i], "-MF") == 0) {
dependency_filename_specified = 1;
} else if (strcmp(argv[i], "-MQ") == 0 || strcmp(argv[i], "-MT") == 0) {
dependency_target_specified = 1;
}
/* the input file is already preprocessed */
if (swig && strcmp(argv[i], "-nopreprocess") == 0) {
direct_i_file = 1;
continue;
}
/* options that take an argument */
{
const char *opts[] = {"-I", "-include", "-imacros", "-iprefix",
"-iwithprefix", "-iwithprefixbefore",
"-L", "-D", "-U", "-x", "-MF",
"-MT", "-MQ", "-isystem", "-aux-info",
"--param", "-A", "-Xlinker", "-u",
"-idirafter",
NULL};
int j;
for (j=0;opts[j];j++) {
if (strcmp(argv[i], opts[j]) == 0) {
if (i == argc-1) {
cc_log("missing argument to %s\n",
argv[i]);
stats_update(STATS_ARGS);
failed();
}
args_add(stripped_args, argv[i]);
args_add(stripped_args, argv[i+1]);
i++;
break;
}
}
if (opts[j]) continue;
}
/* other options */
if (argv[i][0] == '-') {
args_add(stripped_args, argv[i]);
continue;
}
/* if an argument isn't a plain file then assume its
an option, not an input file. This allows us to
cope better with unusual compiler options */
if (stat(argv[i], &st) != 0 || !S_ISREG(st.st_mode)) {
args_add(stripped_args, argv[i]);
continue;
}
if (input_file) {
if (check_extension(argv[i], NULL)) {
cc_log("multiple input files (%s and %s)\n",
input_file, argv[i]);
stats_update(STATS_MULTIPLE);
} else if (!found_c_opt) {
cc_log("called for link with %s\n", argv[i]);
if (strstr(argv[i], "conftest.")) {
stats_update(STATS_CONFTEST);
} else {
stats_update(STATS_LINK);
}
} else {
cc_log("non C/C++ file %s\n", argv[i]);
stats_update(STATS_NOTC);
}
failed();
}
input_file = argv[i];
}
if (!input_file) {
cc_log("No input file found\n");
stats_update(STATS_NOINPUT);
failed();
}
if (swig) {
i_extension = check_extension(input_file, NULL);
} else {
i_extension = check_extension(input_file, &direct_i_file);
}
if (i_extension == NULL) {
cc_log("Not a C/C++ file - %s\n", input_file);
stats_update(STATS_NOTC);
failed();
}
if (!found_c_opt) {
cc_log("No -c option found for %s\n", input_file);
/* I find that having a separate statistic for autoconf tests is useful,
as they are the dominant form of "called for link" in many cases */
if (strstr(input_file, "conftest.")) {
stats_update(STATS_CONFTEST);
} else {
stats_update(STATS_LINK);
}
failed();
}
/* don't try to second guess the compilers heuristics for stdout handling */
if (output_file && strcmp(output_file, "-") == 0) {
stats_update(STATS_OUTSTDOUT);
failed();
}
if (!swig && !output_file) {
char *p;
output_file = x_strdup(input_file);
if ((p = strrchr(output_file, '/'))) {
output_file = p+1;
}
p = strrchr(output_file, '.');
if (!p || !p[1]) {
cc_log("badly formed output_file %s\n", output_file);
stats_update(STATS_ARGS);
failed();
}
p[1] = found_S_opt ? 's' : 'o';
p[2] = 0;
}
/* If dependencies are generated, configure the preprocessor */
if (generating_dependencies && output_file) {
if (!dependency_filename_specified) {
char *default_depfile_name = x_strdup(output_file);
char *p = strrchr(default_depfile_name, '.');
if (p) {
if (strlen(p) < 2) {
cc_log("badly formed dependency file %s\n", output_file);
stats_update(STATS_ARGS);
failed();
return;
}
*p = 0;
}
else {
int len = p - default_depfile_name;
p = x_malloc(len + 3);
strncpy(default_depfile_name, p, len - 1);
free(default_depfile_name);
default_depfile_name = p;
}
strcat(default_depfile_name, ".d");
args_add(stripped_args, "-MF");
args_add(stripped_args, default_depfile_name);
}
if (!dependency_target_specified) {
args_add(stripped_args, "-MT");
args_add(stripped_args, output_file);
}
}
/* cope with -o /dev/null */
if (output_file && strcmp(output_file,"/dev/null") != 0 && stat(output_file, &st) == 0 && !S_ISREG(st.st_mode)) {
cc_log("Not a regular file %s\n", output_file);
stats_update(STATS_DEVICE);
failed();
}
if ((e=getenv("CCACHE_PREFIX"))) {
char *p = find_executable(e, MYNAME);
if (!p) {
cc_log("could not find executable (%s)\n", e);
stats_update(STATS_ENVIRONMMENT);
perror(e);
exit(1);
}
args_add_prefix(stripped_args, p);
}
}
Args *args_new() {
Args *this = malloc(sizeof(Args));
args_init(this);
return this;
}
int args_get(int argc, char **argv, args *arg)
{
int i;
int ret = 0;
args_init(arg);
for(i = 1; i < argc; i++)
{
if(!strcmp(*(argv + i), "-c") || !strcmp(*(argv + i), "--collect"))
{
arg->collect = 1;
ret++;
}
else if(!strcmp(*(argv + i), "-g") || !strcmp(*(argv + i), "--graph"))
{
arg->graph = 1;
arg->res = *(argv + i + 1);
ret++;
}
else if(!strcmp(*(argv + i), "-t") || !strcmp(*(argv + i), "--test"))
{
arg->test = 1;
ret++;
}
else if(!strcmp(*(argv + i), "-d") || !strcmp(*(argv + i), "--daemon"))
{
arg->daemon = 1;
ret++;
}
else if(!strcmp(*(argv + i), "-r") || !strcmp(*(argv + i), "--rrdopt"))
{
arg->rrdopt = *(argv + i + 1);
ret++;
}
else if(!strcmp(*(argv + i), "-v") || !strcmp(*(argv + i), "--version"))
{
arg->version = 1;
ret++;
}
else if(!strcmp(*(argv + i), "-gp") || !strcmp(*(argv + i), "--gpath"))
{
if(!check_valid_path(*(argv + i + 1)))
{
arg->gpath = *(argv + i + 1);
ret++;
}
}
else if(!strcmp(*(argv + i), "-rp") || !strcmp(*(argv + i), "--rpath"))
{
if(!check_valid_path(*(argv + i + 1)))
{
arg->rpath = *(argv + i + 1);
ret++;
}
}
else if(!strcmp(*(argv + i), "-f") || !strcmp(*(argv + i), "--conffile"))
{
if(!check_configuration_file(*(argv + i + 1)))
{
arg->conffile = *(argv + i + 1);
ret++;
}
}
else if(!strcmp(*(argv + i), "-l") || !strcmp(*(argv + i), "--log"))
{
arg->logfile = *(argv + i + 1);
log_set_file(*(argv + i + 1));
ret++;
}
else if(!strcmp(*(argv + i), "-h") || !strcmp(*(argv + i), "--help"))
{
arg->help = 1;
ret++;
}
}
return ret;
}
/*
process the compiler options to form the correct set of options
for obtaining the preprocessor output
*/
static void process_args(int argc, char **argv)
{
int i;
int found_c_opt = 0;
int found_S_opt = 0;
struct stat st;
char *e;
stripped_args = args_init(0, NULL);
args_add(stripped_args, argv[0]);
for (i=1; i<argc; i++) {
/* some options will never work ... */
if (strcmp(argv[i], "-E") == 0) {
failed();
}
/* these are too hard */
if (strcmp(argv[i], "-fbranch-probabilities")==0 ||
strcmp(argv[i], "-M") == 0 ||
strcmp(argv[i], "-MM") == 0 ||
strcmp(argv[i], "-x") == 0) {
cc_log("argument %s is unsupported\n", argv[i]);
stats_update(STATS_UNSUPPORTED);
failed();
continue;
}
/* we must have -c */
if (strcmp(argv[i], "-c") == 0) {
args_add(stripped_args, argv[i]);
found_c_opt = 1;
continue;
}
/* -S changes the default extension */
if (strcmp(argv[i], "-S") == 0) {
args_add(stripped_args, argv[i]);
found_S_opt = 1;
continue;
}
/* we need to work out where the output was meant to go */
if (strcmp(argv[i], "-o") == 0) {
if (i == argc-1) {
cc_log("missing argument to %s\n", argv[i]);
stats_update(STATS_ARGS);
failed();
}
output_file = argv[i+1];
i++;
continue;
}
/* alternate form of -o, with no space */
if (strncmp(argv[i], "-o", 2) == 0) {
output_file = &argv[i][2];
continue;
}
/* debugging is handled specially, so that we know if we
can strip line number info
*/
if (strncmp(argv[i], "-g", 2) == 0) {
args_add(stripped_args, argv[i]);
if (strcmp(argv[i], "-g0") != 0) {
enable_unify = 0;
}
continue;
}
/* The user knows best: just swallow the next arg */
if (strcmp(argv[i], "--ccache-skip") == 0) {
i++;
if (i == argc) {
failed();
}
args_add(stripped_args, argv[i]);
continue;
}
/* options that take an argument */
{
const char *opts[] = {"-I", "-include", "-imacros", "-iprefix",
"-iwithprefix", "-iwithprefixbefore",
"-L", "-D", "-U", "-x", "-MF",
"-MT", "-MQ", "-isystem", "-aux-info",
"--param", "-A", "-Xlinker", "-u",
"-idirafter",
NULL};
int j;
for (j=0;opts[j];j++) {
if (strcmp(argv[i], opts[j]) == 0) {
if (i == argc-1) {
cc_log("missing argument to %s\n",
argv[i]);
stats_update(STATS_ARGS);
failed();
}
args_add(stripped_args, argv[i]);
args_add(stripped_args, argv[i+1]);
i++;
break;
}
}
if (opts[j]) continue;
}
/* other options */
if (argv[i][0] == '-') {
args_add(stripped_args, argv[i]);
continue;
}
/* if an argument isn't a plain file then assume its
an option, not an input file. This allows us to
cope better with unusual compiler options */
if (stat(argv[i], &st) != 0 || !S_ISREG(st.st_mode)) {
args_add(stripped_args, argv[i]);
continue;
}
if (input_file) {
if (check_extension(argv[i], NULL)) {
cc_log("multiple input files (%s and %s)\n",
input_file, argv[i]);
stats_update(STATS_MULTIPLE);
} else if (!found_c_opt) {
cc_log("called for link with %s\n", argv[i]);
if (strstr(argv[i], "conftest.")) {
stats_update(STATS_CONFTEST);
} else {
stats_update(STATS_LINK);
}
} else {
cc_log("non C/C++ file %s\n", argv[i]);
stats_update(STATS_NOTC);
}
failed();
}
input_file = argv[i];
}
if (!input_file) {
cc_log("No input file found\n");
stats_update(STATS_NOINPUT);
failed();
}
i_extension = check_extension(input_file, &direct_i_file);
if (i_extension == NULL) {
cc_log("Not a C/C++ file - %s\n", input_file);
stats_update(STATS_NOTC);
failed();
}
if (!found_c_opt) {
cc_log("No -c option found for %s\n", input_file);
/* I find that having a separate statistic for autoconf tests is useful,
as they are the dominant form of "called for link" in many cases */
if (strstr(input_file, "conftest.")) {
stats_update(STATS_CONFTEST);
} else {
stats_update(STATS_LINK);
}
failed();
}
/* don't try to second guess the compilers heuristics for stdout handling */
if (output_file && strcmp(output_file, "-") == 0) {
stats_update(STATS_OUTSTDOUT);
failed();
}
if (!output_file) {
char *p;
output_file = x_strdup(input_file);
if ((p = strrchr(output_file, '/'))) {
output_file = p+1;
}
p = strrchr(output_file, '.');
if (!p || !p[1]) {
cc_log("badly formed output_file %s\n", output_file);
stats_update(STATS_ARGS);
failed();
}
p[1] = found_S_opt ? 's' : 'o';
p[2] = 0;
}
/* cope with -o /dev/null */
if (strcmp(output_file,"/dev/null") != 0 && stat(output_file, &st) == 0 && !S_ISREG(st.st_mode)) {
cc_log("Not a regular file %s\n", output_file);
stats_update(STATS_DEVICE);
failed();
}
if ((e=getenv("CCACHE_PREFIX"))) {
char *p = find_executable(e, MYNAME);
if (!p) {
perror(e);
exit(1);
}
args_add_prefix(stripped_args, p);
}
}
