char * match_routes(req_header * header){ int i; for(i = 0; i < NUM_ROUTES; i++){ if(!strcmp(routes[i].route, extract_path(header->path))){ printf("Routing to %s\n", extract_path(header->path)); char * content = handle_route(header, i); content = wrap_header(header, content); printf("%s\n", content); return content; } } //printf("did not find any matching routes...\n"); return return404(); }
void start_curl() { state = kDownloading; curl = curl_easy_init(); //assert(direct_ip.size()); std::string actual_url = redirect_url.size() ? redirect_url:url; char buf[1024]; sprintf(buf,"%s://%s%s%s", extract_proto(actual_url).c_str(), direct_ip.c_str(), extract_port(actual_url).c_str(), extract_path(actual_url).c_str()); curl_easy_setopt(curl, CURLOPT_URL, buf); sprintf(buf,"Host: %s%s",extract_host(actual_url).c_str(),extract_port(actual_url).c_str()); headers = curl_slist_append(headers,buf); curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, Request::GotData); curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)this); curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-airplay-agent/1.0"); curl_easy_setopt(curl,CURLOPT_CONNECTTIMEOUT, 15); curl_easy_setopt(curl,CURLOPT_TIMEOUT, 30); curl_easy_setopt(curl,CURLOPT_NOPROGRESS, 0); curl_easy_setopt(curl,CURLOPT_FOLLOWLOCATION, 0); curl_easy_setopt(curl,CURLOPT_HEADERFUNCTION, Request::GotHeaderStatic); curl_easy_setopt(curl,CURLOPT_HEADERDATA, this); curl_easy_setopt(curl,CURLOPT_PROGRESSFUNCTION, Request::GotProgressStatic); curl_easy_setopt(curl,CURLOPT_PROGRESSDATA, (void *)this); //curl_easy_setopt(curl,CURLOPT_VERBOSE,1); if( curlsh ) curl_easy_setopt(curl,CURLOPT_SHARE,curlsh); if( curlm ) curl_multi_add_handle(curlm, curl); }
HRESULT sdk_mesh::create(ID3D11Device* device, LPCTSTR file) { HRESULT hr; sdk_mesh_.reset(new CDXUTSDKMesh); tstring path = extract_path(file); SDKMESH_CALLBACKS11 callbacks; callbacks.pCreateTextureFromFile = &dune::load_texture_cb; callbacks.pCreateVertexBuffer = nullptr; callbacks.pCreateIndexBuffer = nullptr; callbacks.pContext = reinterpret_cast<void*>(&path); V_RETURN(sdk_mesh_->Create(device, file, false, &callbacks)); V_RETURN(cb_mesh_data_vs_.create(device)); V_RETURN(cb_mesh_data_ps_.create(device)); init_bb(sdk_mesh_->GetMeshBBoxCenter(0)); for (UINT i = 0; i < sdk_mesh_->GetNumMeshes(); ++i) { update_bb(sdk_mesh_->GetMeshBBoxCenter(i) - sdk_mesh_->GetMeshBBoxExtents(i)); update_bb(sdk_mesh_->GetMeshBBoxCenter(i) + sdk_mesh_->GetMeshBBoxExtents(i)); } return S_OK; }
void composite_mesh::create_from_dir(ID3D11Device* device, const tstring& pattern) { tstring absolute_pattern = make_absolute_path(pattern); tstring path = extract_path(tstring(absolute_pattern)); std::vector<WIN32_FIND_DATA> files; WIN32_FIND_DATA data; HANDLE h = FindFirstFile(absolute_pattern.c_str(), &data); if (h != INVALID_HANDLE_VALUE) { files.push_back(data); while(FindNextFile(h, &data)) files.push_back(data); } if (files.empty()) throw exception(tstring(L"Couldn't find ") + pattern); for (auto i = files.begin(); i != files.end(); ++i) { tstring file = path + tstring(i->cFileName); create(device, file.c_str()); } }
float pathfinding(t_paths *path, t_map *map) { t_paths *start; int end; int i; int *ke; end = 0; start = path; ke = init_ke(map, path); reinit_paths(path); path->visited = 1; path->visited_by = path->id; while (ke[0] && !end) { set_list_on_ke(&path, ke[0]); add_or_remove_from_ke(0, 0, ke); for (i = 0; path->neighboors[i] && !end; i++) if (!(path->neighboors[i])->visited) { add_or_remove_from_ke((path->neighboors[i])->id, 1, ke); (path->neighboors[i])->visited = 1; (path->neighboors[i])->visited_by = path->id; if ((path->neighboors[i])->pos[0] == map->fortress_pos[0] && (path->neighboors[i])->pos[1] == map->fortress_pos[1]) end = 1; } } return (extract_path(end, ke, path, start)); }
void ExtractorBase::extract (string const &content, string const &type, Object *object) const { namespace fs = boost::filesystem; fs::path path(fs::unique_path()); WriteFile(path.native(), content); extract_path(path.native(), type, object); fs::remove(path); }
void ExtractorBase::extract_url (string const &url, string const &type, Object *object) const { namespace fs = boost::filesystem; fs::path path = fs::unique_path(); int r = wget(url, path.native()); if (r != 0) { throw ExternalError(url); } extract_path(path.native(), type, object); fs::remove(path); }
static path_t* expand_pos(graphcut_workspace_t*w, posqueue_t*queue, node_t*pos, char reverse, unsigned char*mytree, unsigned char*othertree) { graph_t*graph = w->graph; int dir; if((mytree[NR(pos)]&(IN_TREE|ACTIVE)) != (IN_TREE|ACTIVE)) { /* this node got deleted or marked inactive in the meantime. ignore it */ DBG printf("node %d is deleted or inactive\n", NR(pos)); return 0; } halfedge_t*e = pos->edges; for(;e;e=e->next) { node_t*newpos = e->fwd->node; weight_t weight = reverse?e->fwd->weight:e->weight; if(mytree[NR(newpos)]) continue; // already known if(weight) { if(othertree[NR(newpos)]) { DBG printf("found connection: %d connects to %d\n", NR(pos), NR(newpos)); posqueue_addpos(queue, pos); mytree[NR(pos)] |= ACTIVE; // re-add, this vertex might have other connections path_t*path; if(reverse) { path = extract_path(w, othertree, mytree, newpos, pos, e->fwd); } else { path = extract_path(w, mytree, othertree, pos, newpos, e); } return path; } else { DBG printf("advance from %d to new pos %d\n", NR(pos), NR(newpos)); w->back[NR(newpos)] = e->fwd; e->used = 1; posqueue_addpos(queue, newpos); mytree[NR(newpos)] |= ACTIVE|IN_TREE; // add } } } /* if we can't expand this node anymore, it's now an inactive node */ mytree[NR(pos)] &= ~ACTIVE; return 0; }
static void output_combined_results (const struct Conv_Order_Data*const cod, const struct Integration_Test_Info*const int_test_info, const int error_type, const struct Simulation*const sim) { char error_ext[STRLEN_MIN]; switch (error_type) { case ERROR_STANDARD: strcpy(error_ext,"standard"); break; case ERROR_FUNCTIONAL: strcpy(error_ext,"functional"); break; default: EXIT_ERROR("Unsupported: %d.\n",error_type); break; } const char*const output_path = extract_path(compute_error_input_name_root(int_test_info,error_type,false,sim)); char output_name[STRLEN_MAX]; sprintf(output_name,"%s%c%s%c%s%s",output_path,'/',"l2errs+convergence",'_',error_ext,".txt"); const ptrdiff_t n_vars = cod->conv_orders->extents[2]; FILE* file = fopen_create_dir(output_name); // closed fprintf(file,"n_vars %2td\n",n_vars); fprintf(file,"ml_max %2d\n",ML_MAX); fprintf(file,"p_max %2d\n",P_MAX); struct Matrix_i tmp_i; struct Matrix_d tmp_d; fprintf(file,"\nCases Run\n"); set_const_Matrix_from_Multiarray_i((struct const_Matrix_i*)&tmp_i,cod->cases_run,0); print_to_file_Matrix_i(file,&tmp_i); fprintf(file,"\nMesh Size\n"); set_const_Matrix_from_Multiarray_d((struct const_Matrix_d*)&tmp_d,cod->h,0); print_to_file_Matrix_d(file,&tmp_d); fprintf(file,"\nL2 Errors\n\n"); for (int i = 0; i < n_vars; ++i) { fprintf(file,"%s\n",cod->var_names[i]); set_const_Matrix_from_Multiarray_d((struct const_Matrix_d*)&tmp_d,cod->l2_err,(ptrdiff_t[]){i}); print_to_file_Matrix_d(file,&tmp_d); } fprintf(file,"\nConvergence Orders\n\n"); for (int i = 0; i < n_vars; ++i) { fprintf(file,"%s\n",cod->var_names[i]); set_const_Matrix_from_Multiarray_d((struct const_Matrix_d*)&tmp_d,cod->conv_orders,(ptrdiff_t[]){i}); print_to_file_Matrix_d(file,&tmp_d); } fclose(file); }
static rc_t optionally_create_paths_in_output_filename( tool_ctx_t * tool_ctx ) { rc_t rc = 0; String path; if ( extract_path( tool_ctx -> output_filename, &path ) ) { /* the output-filename contains a path... */ if ( !dir_exists( tool_ctx -> dir, "%S", &path ) ) { /* this path does not ( yet ) exist, create it... */ rc = create_this_dir( tool_ctx -> dir, &path, true ); } } return rc; }
char * match_routes(req_header * header){ int i; int return_code = 200; for(i = 0; i < NUM_ROUTES; i++){ if(!strcmp(routes[i].route, extract_path(header->path))){ char * content = handle_route(header, i, &return_code); //if( == NULL){ // return return404(); //} content = wrap_header(header, content); printf("%s", content); return content; } } return return404(); }
//======================================================================================= // DocLocator implementation //======================================================================================= DocLocator::DocLocator(const string& locator) : m_fullLocator(locator) , m_protocol(k_unknown) , m_innerProtocol(k_none) , m_fullpath("") , m_path("") , m_innerFullPath("") , m_innerFile("") , m_fValid(false) { split_locator(locator); if (is_valid()) { extract_file(); extract_path(); } }
int main(int argc, char **argv) { char path [255]; char cap[255]; char cua[255]; strcpy(path, argv[1]); printf("El path es %s \n", path); if ( extract_path(path, cap, cua) ) { puts("Es un directori"); } else { puts("Es un fitxer"); } printf("El cap es: %s i la cua %s \n", cap, cua); }
int main(void) { int m, w, i, j; int path[MAX_NODES], len; /* clear graph */ for (i = 0; i < MAX_NODES; i++) { for (j = 0; j < MAX_NODES; j++) { graph[i][j] = DISCONNECT; } } /* read graph */ scanf("%d %d %d", &i, &j, &w); while (!(i == -1 && j == -1)) { assert(0 <= i && i < MAX_NODES && 0 <= j && j < MAX_NODES); graph[i][j] = /*graph[j][i] =*/ w; scanf("%d %d %d", &i, &j, &w); } floyd(); /* do queries */ scanf("%d %d", &i, &j); while (!(i == -1 && j == -1)) { assert(0 <= i && i < MAX_NODES && 0 <= j && j < MAX_NODES); printf("%d %d: %d\n", i, j, dist[i][j]); len = extract_path(i, j, path); for (m = 0; m < len; m++) { if (m) { printf(" "); } printf("%d", path[m]); } printf("\n"); scanf("%d %d", &i, &j); } return 0; }
FILE* fcFileOpener::try_open(const std::string &path, const std::string &name) { std::string fullpath ( path + "/" + name ); normalize_path( fullpath ); FILE *fp = fopen(fullpath.c_str(), "r"); if ( fp ) { _scannedfiles.insert( name ); std::string p = extract_path(fullpath); for(size_t i=0; i<_excludePaths.size(); i++){ size_t where = p.find(_excludePaths.at(i)); if(where != std::string::npos && where == 0) { // the matched file is locatd inside an excluded directory fclose ( fp ); return NULL; } } _matchedfiles.insert( fullpath ); return fp; } return NULL; }
int revparse__ext( git_object **object_out, git_reference **reference_out, size_t *identifier_len_out, git_repository *repo, const char *spec) { size_t pos = 0, identifier_len = 0; int error = -1, n; git_buf buf = GIT_BUF_INIT; git_reference *reference = NULL; git_object *base_rev = NULL; bool should_return_reference = true; assert(object_out && reference_out && repo && spec); *object_out = NULL; *reference_out = NULL; while (spec[pos]) { switch (spec[pos]) { case '^': should_return_reference = false; if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, false)) < 0) goto cleanup; if (spec[pos+1] == '{') { git_object *temp_object = NULL; if ((error = extract_curly_braces_content(&buf, spec, &pos)) < 0) goto cleanup; if ((error = handle_caret_curly_syntax(&temp_object, base_rev, git_buf_cstr(&buf))) < 0) goto cleanup; git_object_free(base_rev); base_rev = temp_object; } else { git_object *temp_object = NULL; if ((error = extract_how_many(&n, spec, &pos)) < 0) goto cleanup; if ((error = handle_caret_parent_syntax(&temp_object, base_rev, n)) < 0) goto cleanup; git_object_free(base_rev); base_rev = temp_object; } break; case '~': { git_object *temp_object = NULL; should_return_reference = false; if ((error = extract_how_many(&n, spec, &pos)) < 0) goto cleanup; if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, false)) < 0) goto cleanup; if ((error = handle_linear_syntax(&temp_object, base_rev, n)) < 0) goto cleanup; git_object_free(base_rev); base_rev = temp_object; break; } case ':': { git_object *temp_object = NULL; should_return_reference = false; if ((error = extract_path(&buf, spec, &pos)) < 0) goto cleanup; if (any_left_hand_identifier(base_rev, reference, identifier_len)) { if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, true)) < 0) goto cleanup; if ((error = handle_colon_syntax(&temp_object, base_rev, git_buf_cstr(&buf))) < 0) goto cleanup; } else { if (*git_buf_cstr(&buf) == '/') { if ((error = handle_grep_syntax(&temp_object, repo, NULL, git_buf_cstr(&buf) + 1)) < 0) goto cleanup; } else { /* * TODO: support merge-stage path lookup (":2:Makefile") * and plain index blob lookup (:i-am/a/blob) */ giterr_set(GITERR_INVALID, "unimplemented"); error = GIT_ERROR; goto cleanup; } } git_object_free(base_rev); base_rev = temp_object; break; } case '@': { if (spec[pos+1] == '{') { git_object *temp_object = NULL; if ((error = extract_curly_braces_content(&buf, spec, &pos)) < 0) goto cleanup; if ((error = ensure_base_rev_is_not_known_yet(base_rev)) < 0) goto cleanup; if ((error = handle_at_syntax(&temp_object, &reference, spec, identifier_len, repo, git_buf_cstr(&buf))) < 0) goto cleanup; if (temp_object != NULL) base_rev = temp_object; break; } else { /* Fall through */ } } default: if ((error = ensure_left_hand_identifier_is_not_known_yet(base_rev, reference)) < 0) goto cleanup; pos++; identifier_len++; } } if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, false)) < 0) goto cleanup; if (!should_return_reference) { git_reference_free(reference); reference = NULL; } *object_out = base_rev; *reference_out = reference; *identifier_len_out = identifier_len; error = 0; cleanup: if (error) { if (error == GIT_EINVALIDSPEC) giterr_set(GITERR_INVALID, "failed to parse revision specifier - Invalid pattern '%s'", spec); git_object_free(base_rev); git_reference_free(reference); } git_buf_free(&buf); return error; }
void WorkspaceGenerator_MSVC8::generate_source_files(MSVC8_Project &vcproj, const Project &project) { std::string chop_str = "Sources\\"; std::string::size_type chop_length = chop_str.length(); std::list<std::string>::iterator itCur, itNew; std::list<std::string> cur_path; std::vector<MSVC8_Filter *> filters; std::list<std::string>::const_iterator itFiles; for (itFiles = project.files.begin(); itFiles != project.files.end(); itFiles++) { std::string file = *itFiles; // cut off path to files: if (file.length() > chop_length && file.substr(0, chop_length) == chop_str) { file = file.substr(chop_length); } std::list<std::string> new_path = extract_path(file); itCur = cur_path.begin(); itNew = new_path.begin(); while (itCur != cur_path.end()) { if (itNew == new_path.end() || *itCur != *itNew) // path is no longer identical { while (itCur != cur_path.end()) { filters.pop_back(); itCur++; } break; } itCur++; itNew++; } while (itNew != new_path.end()) { std::string filter_name = *itNew; MSVC8_Filter *filter = new MSVC8_Filter; filter->name = filter_name; if (filters.empty()) vcproj.files.push_back(filter); else filters.back()->files.push_back(filter); filters.push_back(filter); itNew++; } cur_path = new_path; MSVC8_File *vcfile = new MSVC8_File; vcfile->relative_path = "..\\" + chop_str + file; if (filters.empty()) vcproj.files.push_back(vcfile); else filters.back()->files.push_back(vcfile); } for (itCur = cur_path.begin(); itCur != cur_path.end(); itCur++) filters.pop_back(); }
int main(int ac, char **av) { int fmt = 0; int ret = 0; int ac_offset = 0; const char *in_fmt = NULL; const char *out_fmt = NULL; mime_model_t in_type = MIME_MODEL_UNKNOWN; mime_model_t out_type = MIME_MODEL_UNKNOWN; struct bu_vls in_format = BU_VLS_INIT_ZERO; struct bu_vls in_path = BU_VLS_INIT_ZERO; struct bu_vls out_format = BU_VLS_INIT_ZERO; struct bu_vls out_path = BU_VLS_INIT_ZERO; struct bu_vls log = BU_VLS_INIT_ZERO; struct bu_vls input_opts = BU_VLS_INIT_ZERO; struct bu_vls output_opts = BU_VLS_INIT_ZERO; ac-=(ac>0); av+=(ac>0); // skip program name argv[0] if present ac_offset = (ac > 2) ? 2 : 0; // The last two argv entries must always be the input and output paths /* Handle anything else as options */ option::Stats stats(TopUsage, ac - ac_offset, av); option::Option *options = (option::Option *)bu_calloc(stats.options_max, sizeof(option::Option), "options"); option::Option *buffer= (option::Option *)bu_calloc(stats.buffer_max, sizeof(option::Option), "options"); option::Parser parse(TopUsage, ac - ac_offset, av, options, buffer); /* Now that we've parsed them, start using them */ if (options[HELP] || ac == 0) { if (options[HELP].arg) { int help_type_int = bu_file_mime(options[HELP].arg, MIME_MODEL); switch (help_type_int) { case MIME_MODEL_VND_FASTGEN: option::printUsage(std::cout, Fast4Usage); break; case MIME_MODEL_STL: option::printUsage(std::cout, STLUsage); break; default: option::printUsage(std::cout, TopUsage); break; } } else { option::printUsage(std::cout, TopUsage); // TODO - figure out how to get this info from each plugin to construct this table // on the fly... bu_log("\nSupported formats:\n"); bu_log(" ------------------------------------------------------------\n"); bu_log(" | Extension | File Format | Input | Output |\n"); bu_log(" |----------------------------------------------------------|\n"); bu_log(" | stl | STereoLithography | Yes | Yes |\n"); bu_log(" |------------|---------------------------|--------|--------|\n"); bu_log(" | obj | Wavefront Object | Yes | Yes |\n"); bu_log(" |------------|---------------------------|--------|--------|\n"); bu_log(" | step | STEP (AP203) | Yes | Yes |\n"); bu_log(" |------------|---------------------------|--------|--------|\n"); bu_log(" | iges | Initial Graphics | Yes | No |\n"); bu_log(" | | Exchange Specification | | |\n"); bu_log(" |----------------------------------------------------------|\n"); } goto cleanup; } /* Any args that weren't top level args will get passed to the * format specific arg processing routines, after we use the known * top level options and the path inputs to determine what the file * types in question are. Steps: * * 1. Reassemble the unknown args into strings. */ reassemble_argstr(&input_opts, &output_opts, options[UNKNOWN]); if (bu_vls_strlen(&input_opts) > 0) bu_log("Unknown options (input): %s\n", bu_vls_addr(&input_opts)); if (bu_vls_strlen(&output_opts) > 0) bu_log("Unknown options (output): %s\n", bu_vls_addr(&output_opts)); /* * 2. Use bu_argv_from_string to create new * arrays to be fed to the format specific option parsers.*/ /* TODO - determine whether we want to have a specific option prefix, * such as in- and out-, to identify an option as specific to the * input file format suboption parser only. i.e.: * * --in-tol=1.0 -> --tol=1.0 to the input file's suboptions only * --out-tol=2.0 -> --tol=2.0 to the input file's suboptions only * --tol=1.5 -> --tol=1.5 to both input and output suboptions * * consistent with top level --in-format and --out-format options * */ /* See if we have input and output files specified */ if (!extract_path(&in_path, av[ac-2])) { bu_vls_printf(&log, "Error: no input path identified: %s\n", av[ac-2]); ret = 1; } if (!extract_path(&out_path, av[ac-1])) { bu_vls_printf(&log, "Error: no output path identified: %s\n", av[ac-1]); ret = 1; } /* Make sure we have distinct input and output paths */ if (bu_vls_strlen(&in_path) > 0 && BU_STR_EQUAL(bu_vls_addr(&in_path), bu_vls_addr(&out_path))) { bu_vls_printf(&log, "Error: identical path specified for both input and output: %s\n", bu_vls_addr(&out_path)); ret = 1; } /* Find out what input file type we are dealing with */ if (options[IN_FORMAT]) { in_fmt = options[IN_FORMAT].arg; } else { /* If we aren't overridden by an option, it's worth doing file * introspection to see if the file contents identify the input * type solidly, provided we have that capability.*/ /* fake type introspection for testing: */ //bu_vls_sprintf(&in_format, "step"); } fmt = parse_model_string(&in_format, &log, in_fmt, av[ac-2]); in_type = (fmt < 0) ? MIME_MODEL_UNKNOWN : (mime_model_t)fmt; in_fmt = NULL; /* Identify output file type */ if (options[OUT_FORMAT]) out_fmt = options[OUT_FORMAT].arg; fmt = parse_model_string(&out_format, &log, out_fmt, av[ac-1]); out_type = (fmt < 0) ? MIME_MODEL_UNKNOWN : (mime_model_t)fmt; out_fmt = NULL; /* If we get to this point without knowing both input and output types, we've got a problem */ if (in_type == MIME_MODEL_UNKNOWN) { bu_vls_printf(&log, "Error: no format type identified for input path: %s\n", bu_vls_addr(&in_path)); ret = 1; } if (out_type == MIME_MODEL_UNKNOWN) { bu_vls_printf(&log, "Error: no format type identified for output path: %s\n", bu_vls_addr(&out_path)); ret = 1; } /* If everything isn't OK, we're done - report and clean up memory */ if (ret == 1) goto cleanup; /* If we've gotten this far, we know enough to try to convert. Until we * hook in conversion calls to libgcv, print a summary of the option * parsing results for debugging. */ in_fmt = bu_file_mime_str((int)in_type, MIME_MODEL); out_fmt = bu_file_mime_str((int)out_type, MIME_MODEL); bu_log("Input file format: %s\n", in_fmt); bu_log("Output file format: %s\n", out_fmt); bu_log("Input file path: %s\n", bu_vls_addr(&in_path)); bu_log("Output file path: %s\n", bu_vls_addr(&out_path)); switch (in_type) { case MIME_MODEL_VND_FASTGEN: fast4_arg_process(bu_vls_addr(&input_opts)); break; case MIME_MODEL_STL: stl_arg_process(bu_vls_addr(&input_opts)); default: break; } switch (out_type) { case MIME_MODEL_VND_FASTGEN: fast4_arg_process(bu_vls_addr(&output_opts)); break; case MIME_MODEL_STL: stl_arg_process(bu_vls_addr(&output_opts)); default: break; } /* Clean up */ cleanup: if (bu_vls_strlen(&log) > 0) bu_log("%s", bu_vls_addr(&log)); if (in_fmt) bu_free((char *)in_fmt, "input format string"); if (out_fmt) bu_free((char *)out_fmt, "output format string"); bu_free(options, "free options"); bu_free(buffer, "free buffer"); bu_vls_free(&in_format); bu_vls_free(&in_path); bu_vls_free(&out_format); bu_vls_free(&out_path); bu_vls_free(&log); bu_vls_free(&input_opts); bu_vls_free(&output_opts); return ret; }
/* get_bitpath() * ==================================================================== * Get the font path from the ASSIGN.SYS * If there is NO ASSIGN.SYS, we substitute C: or A: instead. * */ void get_bitpath( void ) { int i, sys_file; long j; int error; char *fname; int alen; olddma = Fgetdta(); Fsetdta( &newdma ); /* Point to OUR buffer */ strcpy( epath, "C:\\ASSIGN.SYS" ); epath[0] = GetBaseDrive(); bufptr = 0L; BufferSize = 0L; error = Fsfirst( epath, 0 ); /* Normal file search for 1st file */ if( error == 0 ) { /* found it! */ bufptr = calloc( 1, newdma.d_length * 2L ); if( bufptr ) { BufferSize = newdma.d_length; if( (sys_file = Fopen( epath, 0 )) < 0) { Fsetdta( olddma ); /* Point to OLD buffer */ if( bufptr ) { free( bufptr ); bufptr = 0L; } form_alert( 1, alert1 ); return; } path_found = FALSE; do { i = 0; alen = (int)Fread( sys_file, BufferSize, bufptr ); do { if( !strncmp( &bufptr[i], "path", 4) || !strncmp( &bufptr[i], "PATH", 4) ) { strcpy( epath, extract_path( &i, alen ) ); path_found = TRUE; goto done; } else { while(( bufptr[i] != '\n' ) && ( i < alen )) { ++i; /* Skip to newline */ } ++i; } } while( i < alen ); } while( alen == BufferSize ); done: Fclose( sys_file ); if( bufptr ) { free( bufptr ); bufptr = 0L; } j = strlen( epath ); if( epath[ j - 1 ] == '\\' ) epath[ j - 1 ] = '\0'; } else form_alert( 1, alert1 ); } Fsetdta( olddma ); /* Point to OLD buffer */ fname = &epath[0]; fname = strupr( fname ); }
int parse_model_string(struct bu_vls *format, struct bu_vls *log, const char *opt, const char *input) { int type_int = 0; mime_model_t type = MIME_MODEL_UNKNOWN; struct bu_vls format_cpy = BU_VLS_INIT_ZERO; struct bu_vls path = BU_VLS_INIT_ZERO; if (UNLIKELY(!input) || UNLIKELY(strlen(input) == 0)) return MIME_MODEL_UNKNOWN; /* If an external routine has specified a format string, that string will * override the file extension (but not an explicit option or format prefix. * Stash any local format string here for later processing. The idea is * to allow some other routine (say, an introspection of a file looking for * some signature string) to override a file extension based type identification. * Such introspection is beyond the scope of this function, but should override * the file extension mechanism. */ if (format) bu_vls_sprintf(&format_cpy, "%s", bu_vls_addr(format)); /* If we have an explicit option, that overrides any other format specifiers */ if (opt) { type_int = bu_file_mime(opt, MIME_MODEL); type = (type_int < 0) ? MIME_MODEL_UNKNOWN : (mime_model_t)type_int; if (type == MIME_MODEL_UNKNOWN) { /* Have prefix, but doesn't result in a known format - that's an error */ if (log) bu_vls_printf(log, "Error: unknown model format \"%s\" specified as an option.\n", opt); bu_vls_free(&format_cpy); return -1; } } /* Try for a format prefix */ if (extract_format_prefix(format, input)) { /* If we don't already have a valid type and we had a format prefix, * find out if it maps to a valid type */ if (type == MIME_MODEL_UNKNOWN && format) { /* Yes - see if the prefix specifies a model format */ type_int = bu_file_mime(bu_vls_addr(format), MIME_MODEL); type = (type_int < 0) ? MIME_MODEL_UNKNOWN : (mime_model_t)type_int; if (type == MIME_MODEL_UNKNOWN) { /* Have prefix, but doesn't result in a known format - that's an error */ if (log) bu_vls_printf(log, "Error: unknown model format \"%s\" specified as a format prefix.\n", bu_vls_addr(format)); bu_vls_free(&format_cpy); return -1; } } } /* If we don't already have a type and we were passed a format string, give it a try */ if (type == MIME_MODEL_UNKNOWN && format && bu_vls_strlen(&format_cpy) > 0) { bu_vls_sprintf(format, "%s", bu_vls_addr(&format_cpy)); type_int = bu_file_mime(bu_vls_addr(&format_cpy), MIME_MODEL); type = (type_int < 0) ? MIME_MODEL_UNKNOWN : (mime_model_t)type_int; if (type == MIME_MODEL_UNKNOWN) { /* Have prefix, but doesn't result in a known format - that's an error */ if (log) bu_vls_printf(log, "Error: unknown model format \"%s\" passed to parse_model_string.\n", bu_vls_addr(format)); bu_vls_free(&format_cpy); return -1; } } /* If we have no prefix or the prefix didn't map to a model type, try file extension */ if (type == MIME_MODEL_UNKNOWN && extract_path(&path, input)) { if (bu_path_component(format, bu_vls_addr(&path), PATH_EXTENSION)) { type_int = bu_file_mime(bu_vls_addr(format), MIME_MODEL); type = (type_int < 0) ? MIME_MODEL_UNKNOWN : (mime_model_t)type_int; if (type == MIME_MODEL_UNKNOWN) { /* Have file extension, but doesn't result in a known format - that's an error */ if (log) bu_vls_printf(log, "Error: file extension \"%s\" does not map to a known model format.\n", bu_vls_addr(format)); bu_vls_free(&format_cpy); bu_vls_free(&path); return -1; } } } bu_vls_free(&path); bu_vls_free(&format_cpy); return (int)type; }