int param_main(int argc, char *argv[]) { if (argc >= 2) { if (!strcmp(argv[1], "save")) { if (argc >= 3) { do_save(argv[2]); } else { do_save(param_get_default_file()); } } if (!strcmp(argv[1], "load")) { if (argc >= 3) { do_load(argv[2]); } else { do_load(param_get_default_file()); } } if (!strcmp(argv[1], "import")) { if (argc >= 3) { do_import(argv[2]); } else { do_import(param_get_default_file()); } } if (!strcmp(argv[1], "select")) { if (argc >= 3) { param_set_default_file(argv[2]); } else { param_set_default_file(NULL); } warnx("selected parameter default file %s", param_get_default_file()); exit(0); } if (!strcmp(argv[1], "show")) if (argc >= 3) { do_show(argv[2]); } else { do_show(NULL); } } errx(1, "expected a command, try 'load', 'import', 'show', 'select' or 'save'"); }
void SFunctionImport:: DoApply(int paramsc, const SReference paramsv[], IntelibContinuation& lf) const // <symbol(s)> <package> { SExpressionHashPackage *pkg = paramsv[1].DynamicCastGetPtr<SExpressionHashPackage>(); INTELIB_ASSERT(pkg, IntelibX_not_a_package(paramsv[1])); SExpressionCons *dp = paramsv[0].DynamicCastGetPtr<SExpressionCons>(); if(dp) { do_import(pkg, dp->Car(), dp->Cdr()); } else { do_import(pkg, paramsv[0], *PTheEmptyList); } lf.RegularReturn(lf.True()); }
static void* handle_import(enum mg_event event, struct mg_connection *conn, const struct mg_request_info *request_info) { std::string file = get_qs(request_info, "file"); int sorted = atoi(get_qs(request_info, "sorted").c_str()); uint_t limit = atoi(get_qs(request_info, "limit").c_str()); int nadded, nlines; const time_t start_time = time(NULL); if (!limit) { limit = minus_one; } int ret = do_import(file, sorted, limit, nadded, nlines); if (ret < 0) { switch (-ret) { case IMPORT_FILE_NOT_FOUND: print_HTTP_response(conn, 404, "Not Found"); break; default: cerr<<"ERROR::Unknown error: "<<ret<<endl; } } else { print_HTTP_response(conn, 200, "OK"); mg_printf(conn, "Successfully added %d/%d records from \"%s\" in %d second(s)\n", nadded, nlines, file.c_str(), time(NULL) - start_time); } return (void*)""; }
static void import_float_spec_colors( GLcontext *ctx ) { struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; struct gl_client_array *to = &SWSETUP_CONTEXT(ctx)->ChanSecondaryColor; do_import( VB, to, VB->SecondaryColorPtr[0] ); VB->SecondaryColorPtr[0] = to; }
static NMConnection * import (NMVpnEditorPlugin *iface, const char *path, GError **error) { NMConnection *connection = NULL; char *contents = NULL; char *ext; gsize contents_len; ext = strrchr (path, '.'); if (!ext || ( !g_str_has_suffix (ext, ".ovpn") && !g_str_has_suffix (ext, ".conf") && !g_str_has_suffix (ext, ".cnf") && !g_str_has_suffix (ext, ".ovpntest"))) { /* Special extension for testcases */ g_set_error_literal (error, NMV_EDITOR_PLUGIN_ERROR, NMV_EDITOR_PLUGIN_ERROR_FILE_NOT_VPN, _("unknown OpenVPN file extension")); goto out; } if (!g_file_get_contents (path, &contents, &contents_len, error)) return NULL; connection = do_import (path, contents, contents_len, error); out: g_free (contents); return connection; }
static __inline__ void ffbImportColors(ffbContextPtr fmesa, GLcontext *ctx, int index) { struct gl_client_array *to = &fmesa->FloatColor; struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; do_import(VB, to, VB->ColorPtr[index]); VB->ColorPtr[index] = to; }
IMPORT_QUALIFIER void TAG(import_float_spec_colors)( GLcontext *ctx ) { LOCALVARS struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; struct gl_client_array *to = GET_UBYTE_SPEC_COLOR_STORE(); do_import( VB, to, VB->SecondaryColorPtr[0] ); VB->SecondaryColorPtr[0] = to; }
/*================================================= * import_from_file -- Read GEDCOM file to database * ifeed: [IN] output methods * fp: [I/O] GEDCOM file whence to load data *===============================================*/ BOOLEAN import_from_gedcom_file (IMPORT_FEEDBACK ifeed, FILE *fp) { BOOLEAN rtn=FALSE; flineno = 0; rtn = do_import(ifeed, fp); return rtn; }
static PyObject * import_module(PyObject *self, PyObject *args) { char *initfuncname; char *modname; char *pathname; HMODULE hmem; FARPROC init_func; ULONG_PTR cookie = 0; PyObject *findproc; /* code, initfuncname, fqmodulename, path */ if (!PyArg_ParseTuple(args, "sssO:import_module", &modname, &pathname, &initfuncname, &findproc)) return NULL; cookie = _My_ActivateActCtx();//try some windows manifest magic... hmem = MyLoadLibrary(pathname, NULL, findproc); _My_DeactivateActCtx(cookie); if (!hmem) { char *msg; FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (void *)&msg, 0, NULL); msg[strlen(msg)-2] = '\0'; PyErr_Format(PyExc_ImportError, "MemoryLoadLibrary failed loading %s: %s (%d)", pathname, msg, GetLastError()); LocalFree(msg); /* PyErr_Format(PyExc_ImportError, */ /* "MemoryLoadLibrary failed loading %s (Error %d loading %s)", */ /* pathname, GetLastError(), LastErrorString); */ /* PyErr_Format(PyExc_ImportError, */ /* "MemoryLoadLibrary failed loading %s", pathname); */ return NULL; } init_func = MyGetProcAddress(hmem, initfuncname); if (do_import(init_func, modname) < 0) { MyFreeLibrary(hmem); return NULL; } /* Retrieve from sys.modules */ return PyImport_ImportModule(modname); }
int main( int argc, char **argv ) { progname = argv[0]; if(argc > 1 && !strcmp(argv[1], "import")){ do_import(argc, argv); } else if(argc > 1 && !strcmp(argv[1], "export")){ do_export(argc, argv); } else { usage(); } return 0; }
static void do_import(SExpressionHashPackage *pkg, const SReference &a, const SReference &d) { SReference la(a); if(!pkg->Import(la)) { throw IntelibX_package_conflict(a); } if(d.IsEmptyList()) return; SExpressionCons *dp = d.DynamicCastGetPtr<SExpressionCons>(); INTELIB_ASSERT(dp, IntelibX_not_a_list(d)); do_import(pkg, dp->Car(), dp->Cdr()); }
h2o_socket_t *h2o_socket_import(h2o_loop_t *loop, h2o_socket_export_t *info) { h2o_socket_t *sock; assert(info->fd != -1); sock = do_import(loop, info); info->fd = -1; /* just in case */ if ((sock->ssl = info->ssl) != NULL) h2o_buffer_set_prototype(&sock->ssl->input.encrypted, &h2o_socket_buffer_prototype); sock->input = info->input; h2o_buffer_set_prototype(&sock->input, &h2o_socket_buffer_prototype); return sock; }
int param_main(int argc, char *argv[]) { if (argc >= 2) { if (!strcmp(argv[1], "save")) { if (argc >= 3) { do_save(argv[2]); } else { do_save(param_file_name_default); } } if (!strcmp(argv[1], "load")) { if (argc >= 3) { do_load(argv[2]); } else { do_load(param_file_name_default); } } if (!strcmp(argv[1], "import")) { if (argc >= 3) { do_import(argv[2]); } else { do_import(param_file_name_default); } } if (!strcmp(argv[1], "show")) { do_show(); } } errx(1, "expected a command, try 'load', 'import', 'show' or 'save'\n"); }
int main(int argc, char* argv[]) { parse_options(argc, argv); if (opt_show_help) { show_usage(argv); return 0; } started_at = time(NULL); cerr<<"INFO::Starting lib-face on port '"<<port<<"'\n"; if (ac_file) { int nadded, nlines; const time_t start_time = time(NULL); int ret = do_import(ac_file, line_limit, nadded, nlines); if (ret < 0) { switch (-ret) { case IMPORT_FILE_NOT_FOUND: fprintf(stderr, "The file '%s' was not found\n", ac_file); break; case IMPORT_MUNMAP_FAILED: fprintf(stderr, "munmap(2) on file '%s' failed\n", ac_file); break; case IMPORT_MMAP_FAILED: fprintf(stderr, "mmap(2) on file '%s' failed\n", ac_file); break; default: cerr<<"ERROR::Unknown error: "<<ret<<endl; } return 1; } else { fprintf(stderr, "INFO::Successfully added %d/%d records from \"%s\" in %d second(s)\n", nadded, nlines, ac_file, (int)(time(NULL) - start_time)); } } int r = httpserver_start(&serve_request, "0.0.0.0", port); if (r != 0) { fprintf(stderr, "ERROR::Could not start the web server\n"); return 1; } return 0; }
int param_main(int argc, char *argv[]) { if (argc >= 2) { if (!strcmp(argv[1], "save")) do_save(); if (!strcmp(argv[1], "load")) do_load(); if (!strcmp(argv[1], "import")) do_import(); if (!strcmp(argv[1], "show")) do_show(); } errx(1, "expected a command, try 'load', 'import', 'show' or 'save'\n"); }
static void handle_import(client_t *client, parsed_url_t &url) { std::string body; headers_t headers; headers["Cache-Control"] = "no-cache"; std::string file = unescape_query(url.query["file"]); uint_t limit = atoi(url.query["limit"].c_str()); int nadded, nlines; const time_t start_time = time(NULL); if (!limit) { limit = minus_one; } int ret = do_import(file, limit, nadded, nlines); if (ret < 0) { switch (-ret) { case IMPORT_FILE_NOT_FOUND: body = "The file '" + file + "' was not found"; write_response(client, 404, "Not Found", headers, body); break; case IMPORT_MUNMAP_FAILED: body = "munmap(2) failed"; write_response(client, 500, "Internal Server Error", headers, body); break; case IMPORT_MMAP_FAILED: body = "mmap(2) failed"; write_response(client, 500, "Internal Server Error", headers, body); break; default: body = "Unknown Error"; write_response(client, 500, "Internal Server Error", headers, body); cerr<<"ERROR::Unknown error: "<<ret<<endl; } } else { std::ostringstream os; os << "Successfully added " << nadded << "/" << nlines << "records from '" << file << "' in " << (time(NULL) - start_time) << "second(s)\n"; body = os.str(); write_response(client, 200, "OK", headers, body); } }
static NMConnection * import (NMVpnPluginUiInterface *iface, const char *path, GError **error) { NMConnection *connection = NULL; char *contents = NULL; char **lines = NULL; char *ext; ext = strrchr (path, '.'); if (!ext) { g_set_error (error, L2TP_PLUGIN_UI_ERROR, L2TP_PLUGIN_UI_ERROR_FILE_NOT_L2TP, "unknown L2TP file extension"); goto out; } if (strcmp (ext, ".conf") && strcmp (ext, ".cnf")) { g_set_error (error, L2TP_PLUGIN_UI_ERROR, L2TP_PLUGIN_UI_ERROR_FILE_NOT_L2TP, "unknown L2TP file extension"); goto out; } if (!g_file_get_contents (path, &contents, NULL, error)) return NULL; lines = g_strsplit_set (contents, "\r\n", 0); if (g_strv_length (lines) <= 1) { g_set_error (error, L2TP_PLUGIN_UI_ERROR, L2TP_PLUGIN_UI_ERROR_FILE_NOT_READABLE, "not a valid L2TP configuration file"); goto out; } connection = do_import (path, lines, error); out: if (lines) g_strfreev (lines); g_free (contents); return connection; }
/* * Like JSResolveOp, but flags provide contextual information as follows: * * JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id * JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment * JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence * JSRESOLVE_DECLARING var, const, or function prolog declaration opcode * JSRESOLVE_CLASSNAME class name used when constructing * * The *objp out parameter, on success, should be null to indicate that id * was not resolved; and non-null, referring to obj or one of its prototypes, * if id was resolved. */ static JSBool importer_new_resolve(JSContext *context, JSObject **obj, jsid *id, unsigned flags, JSObject **objp) { Importer *priv; char *name; JSBool ret = JS_TRUE; jsid module_init_name; *objp = NULL; module_init_name = gjs_context_get_const_string(context, GJS_STRING_MODULE_INIT); if (*id == module_init_name) return JS_TRUE; if (!gjs_get_string_id(context, *id, &name)) return JS_FALSE; /* let Object.prototype resolve these */ if (strcmp(name, "valueOf") == 0 || strcmp(name, "toString") == 0 || strcmp(name, "__iterator__") == 0) goto out; priv = priv_from_js(context, *obj); gjs_debug_jsprop(GJS_DEBUG_IMPORTER, "Resolve prop '%s' hook obj %p priv %p", name, (void *)obj, priv); if (priv == NULL) /* we are the prototype, or have the wrong class */ goto out; JS_BeginRequest(context); if (do_import(context, *obj, priv, name)) { *objp = *obj; } else { ret = JS_FALSE; } JS_EndRequest(context); out: g_free(name); return ret; }
int main(int argc, char* argv[]) { parse_options(argc, argv); if (opt_show_help) { show_usage(argv); return 0; } struct mg_context *ctx; const char *options[] = {"listening_ports", port, NULL}; started_at = time(NULL); cerr<<"INFO::Starting lib-face on port '"<<port<<"'\n"; if (ac_file) { int nadded, nlines; const time_t start_time = time(NULL); int ret = do_import(ac_file, ac_sorted, minus_one, nadded, nlines); if (ret < 0) { fprintf(stderr, "ERROR::Could not add lines in file '%s'\n", ac_file); } else { fprintf(stderr, "INFO::Successfully added %d/%d records from \"%s\" in %d second(s)\n", nadded, nlines, ac_file, (int)(time(NULL) - start_time)); } } ctx = mg_start(&callback, NULL, options); if (!ctx) { fprintf(stderr, "ERROR::Could not start the web server\n"); return 1; } while (1) { // Never stop sleep(100); } mg_stop(ctx); return 0; }
/* * Like JSResolveOp, but flags provide contextual information as follows: * * JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id * JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment * JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence * JSRESOLVE_DECLARING var, const, or function prolog declaration opcode * JSRESOLVE_CLASSNAME class name used when constructing * * The *objp out parameter, on success, should be null to indicate that id * was not resolved; and non-null, referring to obj or one of its prototypes, * if id was resolved. */ static JSBool importer_new_resolve(JSContext *context, JS::HandleObject obj, JS::HandleId id, unsigned flags, JS::MutableHandleObject objp) { Importer *priv; std::string name; JSBool ret = JS_TRUE; jsid module_init_name; module_init_name = gjs_context_get_const_string(context, GJS_STRING_MODULE_INIT); if (id == module_init_name) return JS_TRUE; if (!gjs_get_string_id(context, id, name)) return JS_FALSE; /* let Object.prototype resolve these */ if (name == "valueOf" || name == "toString" || name == "__iterator__") goto out; priv = priv_from_js(context, obj); // std::cout << "Resolve prop '" << name << "' hook obj " << (uint32_t)*obj << " priv " << (uint32_t)priv << "\n"; if (priv == NULL) /* we are the prototype, or have the wrong class */ goto out; JS_BeginRequest(context); if (do_import(context, obj, priv, name)) { objp.set(obj); } else { ret = JS_FALSE; } JS_EndRequest(context); out: return ret; }
/* * Like JSResolveOp, but flags provide contextual information as follows: * * JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id * JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment * JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence * JSRESOLVE_DECLARING var, const, or function prolog declaration opcode * JSRESOLVE_CLASSNAME class name used when constructing * * The *objp out parameter, on success, should be null to indicate that id * was not resolved; and non-null, referring to obj or one of its prototypes, * if id was resolved. */ static JSBool importer_new_resolve(JSContext *context, JSObject *obj, jsid id, uintN flags, JSObject **objp) { Importer *priv; char *name; JSBool ret = JS_TRUE; *objp = NULL; if (!gjs_get_string_id(context, id, &name)) return JS_FALSE; /* let Object.prototype resolve these */ if (strcmp(name, "valueOf") == 0 || strcmp(name, "toString") == 0 || strcmp(name, "__iterator__") == 0) goto out; priv = priv_from_js(context, obj); gjs_debug_jsprop(GJS_DEBUG_IMPORTER, "Resolve prop '%s' hook obj %p priv %p", name, obj, priv); if (priv == NULL) /* we are the prototype, or have the wrong class */ goto out; JS_BeginRequest(context); if (do_import(context, obj, priv, name)) { *objp = obj; } else { ret = JS_FALSE; } JS_EndRequest(context); out: g_free(name); return ret; }
/* read second linker member and process all archive members */ static int read_link_member (struct ar_hdr *hdr, FILE *f) { uint32 n_memb; uint32 n_syms; uint32 *ofs; uint16 *idx; char *buf; char *sym; uint32 n; uint16 i; /* FIXME: are offsets and sizes in host endianness? Currently we assume so. */ /* get number of archive members */ if (fread (&n_memb, 4, 1, f) != 1) return 0; if (only_symbols) { /* if we only dump symbols there is no need to read the offset * and index tables */ if (fseek (f, 4 * n_memb, SEEK_CUR) != 0) return 0; if (fread (&n_syms, 4, 1, f) != 1) return 0; if (fseek (f, 2 * n_syms, SEEK_CUR) != 0) return 0; ofs = NULL; idx = NULL; } else { /* suck in everything from the archive */ ofs = xmalloc (4 * n_memb); if (fread (ofs, 4, n_memb, f) != n_memb) { free (ofs); return 0; } if (fread (&n_syms, 4, 1, f) != 1) { free (ofs); return 0; } idx = xmalloc (2 * n_syms); if (fread (idx, 2, n_syms, f) != n_syms) { free (ofs); free (idx); return 0; } } /* calculate size of symbol string table */ n = strtol (hdr->ar_size, NULL, 10); n = n - (4 + 4 + 2 * n_syms + 4 * n_memb); /* allocate memory for string table */ buf = xmalloc (n); /* read symbol string table */ if (fread (buf, n, 1, f) != 1) { free (ofs); free (idx); return 0; } /* look for long-names member */ ar_read_header (hdr, f); /* read symbols */ for (n = 0, sym = buf; n < n_syms; n++) { if (is_import (sym)) { if (only_symbols) puts (sym); else { i = idx[n]; do_import (sym, ofs[i-1], f); } } sym += strlen (sym) + 1; } free (buf); free (ofs); free (idx); return 1; }
static int zpool_import_by_guid(uint64_t searchguid) { int err = 0; nvlist_t *pools = NULL; nvpair_t *elem; nvlist_t *config; nvlist_t *found_config = NULL; nvlist_t *policy = NULL; boolean_t first; int flags = ZFS_IMPORT_NORMAL; uint32_t rewind_policy = ZPOOL_NO_REWIND; uint64_t pool_state, txg = -1ULL; importargs_t idata = { 0 }; #ifdef ZFS_AUTOIMPORT_ZPOOL_STATUS_OK_ONLY char *msgid; zpool_status_t reason; zpool_errata_t errata; #endif if ((g_zfs = libzfs_init()) == NULL) return (1); idata.unique = B_TRUE; /* In the future, we can capture further policy and include it here */ if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, txg) != 0 || nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0) goto error; if (!priv_ineffect(PRIV_SYS_CONFIG)) { printf("cannot discover pools: permission denied\n"); nvlist_free(policy); return (1); } idata.guid = searchguid; pools = zpool_search_import(g_zfs, &idata); if (pools == NULL && idata.exists) { printf("cannot import '%llu': a pool with that guid is already " "created/imported\n", searchguid); err = 1; } else if (pools == NULL) { printf("cannot import '%llu': no such pool available\n", searchguid); err = 1; } if (err == 1) { nvlist_free(policy); return (1); } /* * At this point we have a list of import candidate configs. Even though * we were searching by guid, we still need to post-process the list to * deal with pool state. */ err = 0; elem = NULL; first = B_TRUE; while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) { verify(nvpair_value_nvlist(elem, &config) == 0); verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, &pool_state) == 0); if (pool_state == POOL_STATE_DESTROYED) continue; verify(nvlist_add_nvlist(config, ZPOOL_REWIND_POLICY, policy) == 0); uint64_t guid; /* * Search for a pool by guid. */ verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &guid) == 0); if (guid == searchguid) found_config = config; } /* * If we were searching for a specific pool, verify that we found a * pool, and then do the import. */ if (err == 0) { if (found_config == NULL) { printf("cannot import '%llu': no such pool available\n", searchguid); err = B_TRUE; } else { #ifdef ZFS_AUTOIMPORT_ZPOOL_STATUS_OK_ONLY reason = zpool_import_status(config, &msgid, &errata); if (reason == ZPOOL_STATUS_OK) err |= do_import(found_config, NULL, NULL, NULL, flags); else err = 1; #else err |= do_import(found_config, NULL, NULL, NULL, flags); #endif } } error: nvlist_free(pools); nvlist_free(policy); libzfs_fini(g_zfs); return (err ? 1 : 0); }
int param_main(int argc, char *argv[]) { if (argc >= 2) { if (!strcmp(argv[1], "save")) { if (argc >= 3) { return do_save(argv[2]); } else { int ret = do_save_default(); if (ret) { PX4_ERR("Param save failed (%i)", ret); return 1; } else { return 0; } } } if (!strcmp(argv[1], "load")) { if (argc >= 3) { return do_load(argv[2]); } else { return do_load(param_get_default_file()); } } if (!strcmp(argv[1], "import")) { if (argc >= 3) { return do_import(argv[2]); } else { return do_import(param_get_default_file()); } } if (!strcmp(argv[1], "select")) { if (argc >= 3) { param_set_default_file(argv[2]); } else { param_set_default_file(NULL); } PX4_INFO("selected parameter default file %s", param_get_default_file()); return 0; } if (!strcmp(argv[1], "show")) { if (argc >= 3) { // optional argument -c to show only non-default params if (!strcmp(argv[2], "-c")) { if (argc >= 4) { return do_show(argv[3], true); } else { return do_show(NULL, true); } } else { return do_show(argv[2], false); } } else { return do_show(NULL, false); } } if (!strcmp(argv[1], "set")) { if (argc >= 5) { /* if the fail switch is provided, fails the command if not found */ bool fail = !strcmp(argv[4], "fail"); return do_set(argv[2], argv[3], fail); } else if (argc >= 4) { return do_set(argv[2], argv[3], false); } else { PX4_ERR("not enough arguments.\nTry 'param set PARAM_NAME 3 [fail]'"); return 1; } } if (!strcmp(argv[1], "compare")) { if (argc >= 4) { return do_compare(argv[2], &argv[3], argc - 3, COMPARE_OPERATOR_EQUAL); } else { PX4_ERR("not enough arguments.\nTry 'param compare PARAM_NAME 3'"); return 1; } } if (!strcmp(argv[1], "greater")) { if (argc >= 4) { return do_compare(argv[2], &argv[3], argc - 3, COMPARE_OPERATOR_GREATER); } else { PX4_ERR("not enough arguments.\nTry 'param greater PARAM_NAME 3'"); return 1; } } if (!strcmp(argv[1], "reset")) { if (argc >= 3) { return do_reset((const char **) &argv[2], argc - 2); } else { return do_reset(NULL, 0); } } if (!strcmp(argv[1], "reset_nostart")) { if (argc >= 3) { return do_reset_nostart((const char **) &argv[2], argc - 2); } else { return do_reset_nostart(NULL, 0); } } if (!strcmp(argv[1], "index_used")) { if (argc >= 3) { return do_show_index(argv[2], true); } else { PX4_ERR("no index provided"); return 1; } } if (!strcmp(argv[1], "index")) { if (argc >= 3) { return do_show_index(argv[2], false); } else { PX4_ERR("no index provided"); return 1; } } if (!strcmp(argv[1], "find")) { if (argc >= 3) { return do_find(argv[2]); } else { PX4_ERR("not enough arguments.\nTry 'param find PARAM_NAME'"); return 1; } } } PX4_INFO("expected a command, try 'load', 'import', 'show [-c] [<filter>]', 'set <param> <value>', 'compare',\n'index', 'index_used', 'find', 'greater', 'select', 'save', or 'reset' "); return 1; }
int param_main(int argc, char *argv[]) { if (argc >= 2) { if (!strcmp(argv[1], "save")) { if (argc >= 3) { return do_save(argv[2]); } else { if (param_save_default()) { warnx("Param export failed."); return 1; } else { return 0; } } } if (!strcmp(argv[1], "load")) { if (argc >= 3) { return do_load(argv[2]); } else { return do_load(param_get_default_file()); } } if (!strcmp(argv[1], "import")) { if (argc >= 3) { return do_import(argv[2]); } else { return do_import(param_get_default_file()); } } if (!strcmp(argv[1], "select")) { if (argc >= 3) { param_set_default_file(argv[2]); } else { param_set_default_file(NULL); } warnx("selected parameter default file %s", param_get_default_file()); return 0; } if (!strcmp(argv[1], "show")) { if (argc >= 3) { do_show(argv[2]); return 0; } else { do_show(NULL); return 0; } } if (!strcmp(argv[1], "set")) { if (argc >= 5) { /* if the fail switch is provided, fails the command if not found */ bool fail = !strcmp(argv[4], "fail"); return do_set(argv[2], argv[3], fail); } else if (argc >= 4) { return do_set(argv[2], argv[3], false); } else { warnx("not enough arguments.\nTry 'param set PARAM_NAME 3 [fail]'"); return 1; } } if (!strcmp(argv[1], "compare")) { if (argc >= 4) { return do_compare(argv[2], &argv[3], argc - 3); } else { warnx("not enough arguments.\nTry 'param compare PARAM_NAME 3'"); return 1; } } if (!strcmp(argv[1], "reset")) { if (argc >= 3) { return do_reset((const char **) &argv[2], argc - 2); } else { return do_reset(NULL, 0); } } if (!strcmp(argv[1], "reset_nostart")) { if (argc >= 3) { return do_reset_nostart((const char **) &argv[2], argc - 2); } else { return do_reset_nostart(NULL, 0); } } if (!strcmp(argv[1], "index_used")) { if (argc >= 3) { do_show_index(argv[2], true); } else { warnx("no index provided"); return 1; } } if (!strcmp(argv[1], "index")) { if (argc >= 3) { do_show_index(argv[2], false); } else { warnx("no index provided"); return 1; } } } warnx("expected a command, try 'load', 'import', 'show', 'set', 'compare', 'select' or 'save'"); return 1; }
int main(int argc, char *argv[]) { char *format = "auto"; char *optstring = "m:M:f:"; int c, opt_index = 0; int files = 0; char *kb_name = NULL; char *model[argc], *uri[argc]; char *model_default = NULL; int help=0; static struct option long_options[] = { { "model", 1, 0, 'm' }, { "model-default", 1, 0, 'M' }, { "format", 1, 0, 'f' }, }; for (int i= 0; i < argc; ++i) { model[i] = NULL; } while ((c = getopt_long (argc, argv, optstring, long_options, &opt_index)) != -1) { if (c == 'm') { model[files++] = optarg; } else if (c == 'M') { model_default = optarg; } else if (c == 'f') { format = optarg; } else { help = 1; fprintf(stderr, "Unknown parameter '%c' \n", c); fprintf(stderr, "Usage: %s <kbname> <rdf file/URI> ...\n", argv[0]); fprintf(stderr, " -m --model specify a model URI for the next RDF file\n"); fprintf(stderr, " -M --model-default specify a model URI for all RDF files\n"); fprintf(stderr, " -f --format specify an RDF syntax for the import\n"); exit(1); } } files = 0; for (int k = optind; k < argc; ++k) { if (!kb_name) { kb_name = argv[k]; } else { uri[files] = g_strdup(argv[k]); if (!model[files]) { if (!model_default) { model[files] = uri[files]; } else { model[files] = model_default; } } files++; } } if (help || !kb_name || files == 0) { help = 1; fprintf(stderr, "Usage: %s <kbname> <rdf file/URI> ...\n", argv[0]); fprintf(stderr, " -m --model specify a model URI for the next RDF file\n"); fprintf(stderr, " -M --model-default specify a model URI for all RDF files\n"); fprintf(stderr, " -f --format specify an RDF syntax for the import\n"); exit(1); } if (!g_thread_get_initialized()) g_thread_init(NULL); if (!fs_hash_uri) fs_hash_init(); //g_mem_set_vtable(glib_mem_profiler_table); //g_atexit(g_mem_profile); int res = do_import(kb_name,uri,model,format,files); #if 0 printf("press enter\n"); char foo; #endif exit(res); }
int param_main(int argc, char *argv[]) { if (argc >= 2) { if (!strcmp(argv[1], "save")) { if (argc >= 3) { do_save(argv[2]); } else { if (param_save_default()) { warnx("Param export failed."); exit(1); } else { exit(0); } } } if (!strcmp(argv[1], "load")) { if (argc >= 3) { do_load(argv[2]); } else { do_load(param_get_default_file()); } } if (!strcmp(argv[1], "import")) { if (argc >= 3) { do_import(argv[2]); } else { do_import(param_get_default_file()); } } if (!strcmp(argv[1], "select")) { if (argc >= 3) { param_set_default_file(argv[2]); } else { param_set_default_file(NULL); } warnx("selected parameter default file %s", param_get_default_file()); exit(0); } if (!strcmp(argv[1], "show")) { if (argc >= 3) { do_show(argv[2]); } else { do_show(NULL); } } if (!strcmp(argv[1], "set")) { if (argc >= 4) { do_set(argv[2], argv[3]); } else { errx(1, "not enough arguments.\nTry 'param set PARAM_NAME 3'"); } } if (!strcmp(argv[1], "compare")) { if (argc >= 4) { do_compare(argv[2], &argv[3], argc - 3); } else { errx(1, "not enough arguments.\nTry 'param compare PARAM_NAME 3'"); } } } errx(1, "expected a command, try 'load', 'import', 'show', 'set', 'compare', 'select' or 'save'"); }
void import_dialog(GtkWidget *w, gpointer data) { int result; GtkWidget *dialog, *hbox, *vbox, *label; GtkComboBox *computer; GtkEntry *device; GtkWidget *XMLchooser; device_data_t devicedata = { .devname = NULL, }; dialog = gtk_dialog_new_with_buttons("Import from dive computer", GTK_WINDOW(main_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); label = gtk_label_new("Import: \nLoad XML file or import directly from dive computer"); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 3); XMLchooser = xml_file_selector(vbox, dialog); computer = dive_computer_selector(vbox); device = dive_computer_device(vbox); hbox = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 3); devicedata.progress.bar = gtk_progress_bar_new(); gtk_container_add(GTK_CONTAINER(hbox), devicedata.progress.bar); gtk_widget_show_all(dialog); result = gtk_dialog_run(GTK_DIALOG(dialog)); switch (result) { int type; GtkTreeIter iter; GtkTreeModel *model; const char *comp; GSList *list; case GTK_RESPONSE_ACCEPT: /* what happened - did the user pick a file? In that case * we ignore whether a dive computer model was picked */ list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(XMLchooser)); if (g_slist_length(list) == 0) { if (!gtk_combo_box_get_active_iter(computer, &iter)) break; model = gtk_combo_box_get_model(computer); gtk_tree_model_get(model, &iter, 0, &comp, 1, &type, -1); devicedata.type = type; devicedata.name = comp; devicedata.devname = gtk_entry_get_text(device); do_import(&devicedata); } else { g_slist_foreach(list,do_import_file,NULL); g_slist_free(list); } break; default: break; } gtk_widget_destroy(dialog); report_dives(TRUE); }
void do_numpy_init_package() { do_import(); }