void WinHttpStream::initRequest() { TextParser<wchar_t> parser; if (!parser(L"%1://%[*-_.a-zA-Z0-9:@]2%%[/](*)*3",url)) throw FileOpenError(THISLOCATION,ERROR_FILE_NOT_FOUND,url); String protocol = parser[1].str(); String hostident = parser[2].str(); String::SplitIterator hostidentsplit = hostident.split('@'); String ident; String domain; domain = hostidentsplit.getNext(); while (hostidentsplit.hasItems()) { ident = ident + domain + ConstStrW('@'); domain = hostidentsplit.getNext(); } String path = parser[3].str(); natural port; String username; String password; bool secure; if (parser( L"%1:%u2",domain)) { domain = parser[1].str(); port = parser[2]; secure = false; } else if (protocol == ConstStrW(L"http")) { port = INTERNET_DEFAULT_HTTP_PORT; secure = false; } else if (protocol == ConstStrW(L"https")) { port = INTERNET_DEFAULT_HTTPS_PORT; secure = true; } else throw FileOpenError(THISLOCATION,ERROR_NOT_FOUND,url); if (!ident.empty()) { if (parser(L"%1:%2@",ident)) { username = parser[1].str(); password = parser[2].str(); } else { throw FileMsgException(THISLOCATION,0,url,"Invalid identification field in the url"); } } DWORD accessType; switch (settings.proxyMode) { case pmManual: accessType = INTERNET_OPEN_TYPE_PROXY; case pmDirect: accessType = INTERNET_OPEN_TYPE_DIRECT; case pmAuto: accessType = INTERNET_OPEN_TYPE_PRECONFIG; } TextFormatBuff<wchar_t> fmt; String proxyName; if (accessType == INTERNET_OPEN_TYPE_PROXY) { fmt(L"%1:%2") << settings.proxyAddr << settings.proxyPort; proxyName = fmt.write(); } if (hInternet) InternetCloseHandle(hInternet); hInternet = InternetOpenW(settings.userAgent.cStr(),accessType,proxyName.cStr(),0,0); if (hInternet == 0) throw FileMsgException(THISLOCATION,GetLastError(),url,"Cannot initialize WinInet"); if (hConnect) InternetCloseHandle(hConnect); hConnect = InternetConnectW(hInternet,domain.cStr(),(INTERNET_PORT)port, username.empty()?0:username.cStr(), password.empty()?0:password.cStr(), INTERNET_SERVICE_HTTP ,0,0); if (hConnect == 0) throw FileMsgException(THISLOCATION,GetLastError(),url,"Cannot connect remote site"); DWORD reqFlags = INTERNET_FLAG_NO_UI |INTERNET_FLAG_HYPERLINK ; if (redirDisabled) reqFlags|=INTERNET_FLAG_NO_AUTO_REDIRECT ; if (!settings.cookiesEnabled) reqFlags|=INTERNET_FLAG_NO_COOKIES; if (secure) reqFlags|=INTERNET_FLAG_SECURE; hHTTPConn = HttpOpenRequestW(hConnect,String(method).cStr(),path.cStr(), 0,0,0,reqFlags,0); if (hHTTPConn == 0) throw FileMsgException(THISLOCATION,GetLastError(),url,"Cannot connect remote site"); AutoArray<wchar_t> hdrall; for (HeaderMap::Iterator iter = hdrmap.getFwIter(); iter.hasItems();) { const HeaderMap::Entity &e = iter.getNext(); fmt(L"%1: %2\n") << e.key << e.value; hdrall.append(fmt.write()); } if (!hdrall.empty() && !HttpAddRequestHeadersW(hHTTPConn,hdrall.data(),(DWORD)hdrall.length(),HTTP_ADDREQ_FLAG_REPLACE|HTTP_ADDREQ_FLAG_ADD)) throw FileMsgException(THISLOCATION,GetLastError(),url,"AddRequest failed"); if (!HttpSendRequestW(hHTTPConn,0,0,postBuffer.data(),(DWORD)postBuffer.length())) { bool stillError = true; DWORD dwError = GetLastError(); if (dwError == ERROR_INTERNET_INVALID_CA && settings.allowUntrustedCert) { DWORD dwFlags; DWORD dwBuffLen = sizeof(dwFlags); InternetQueryOption (hHTTPConn, INTERNET_OPTION_SECURITY_FLAGS, (LPVOID)&dwFlags, &dwBuffLen); dwFlags |= SECURITY_FLAG_IGNORE_UNKNOWN_CA; InternetSetOption (hHTTPConn, INTERNET_OPTION_SECURITY_FLAGS, &dwFlags, sizeof (dwFlags) ); if (HttpSendRequestW(hHTTPConn,0,0,postBuffer.data(),(DWORD)postBuffer.length())) stillError = false; } if (stillError) throw FileMsgException(THISLOCATION,GetLastError(),url,"Failed to SendRequest"); } postBuffer.clear(); }
void GDScriptLanguage::auto_indent_code(String& p_code,int p_from_line,int p_to_line) const { Vector<String> lines = p_code.split("\n"); List<int> indent_stack; for(int i=0;i<lines.size();i++) { String l = lines[i]; int tc=0; for(int j=0;j<l.length();j++) { if (l[j]==' ' || l[j]=='\t') { tc++; } else { break; } } String st = l.substr(tc,l.length()).strip_edges(); if (st=="" || st.begins_with("#")) continue; //ignore! int ilevel=0; if (indent_stack.size()) { ilevel=indent_stack.back()->get(); } if (tc>ilevel) { indent_stack.push_back(tc); } else if (tc<ilevel) { while(indent_stack.size() && indent_stack.back()->get()>tc) { indent_stack.pop_back(); } if (indent_stack.size() && indent_stack.back()->get()!=tc) indent_stack.push_back(tc); //this is not right but gets the job done } if (i>=p_from_line) { l=""; for(int j=0;j<indent_stack.size();j++) l+="\t"; l+=st; } else if (i>p_to_line) { break; } //print_line(itos(indent_stack.size())+","+itos(tc)+": "+l); lines[i]=l; } p_code=""; for(int i=0;i<lines.size();i++) { if (i>0) p_code+="\n"; p_code+=lines[i]; } }
ExitCodes main_(int, const char**) override { //------------------------------------------------------------- // parsing parameters //------------------------------------------------------------- String in(getStringOption_("in")); String out(getStringOption_("out")); String feature_out(getStringOption_("feature_out")); String pair_in(getStringOption_("pair_in")); double mass_tolerance(getDoubleOption_("mass_tolerance")); double RT_tolerance(getDoubleOption_("RT_tolerance")); double RT_pair_tolerance(getDoubleOption_("RT_pair_tolerance")); //------------------------------------------------------------- // reading input //------------------------------------------------------------- FeatureMap all_mrm_features; FeatureXMLFile().load(in, all_mrm_features); // read pair file ifstream is(pair_in.c_str()); String line; Map<double, Map<double, vector<SILAC_pair> > > pairs; while (getline(is, line)) { line.trim(); if (line.empty() || line[0] == '#') { continue; } vector<String> split; line.split(' ', split); if (split.empty()) { line.split('\t', split); } if (split.size() != 5) { cerr << "missformated line ('" << line << "') should be (space separated) 'prec-m/z-light prec-m/z-heavy frag-m/z-light frag-m/z-heavy rt'" << endl; continue; } SILAC_pair p; double prec_mz_light = split[0].toDouble(); double prec_mz_heavy = split[1].toDouble(); p.mz_light = split[2].toDouble(); p.mz_heavy = split[3].toDouble(); p.rt = split[4].toDouble(); pairs[prec_mz_light][prec_mz_heavy].push_back(p); } is.close(); //------------------------------------------------------------- // calculations //------------------------------------------------------------- ConsensusMap results_map; results_map.getColumnHeaders()[0].label = "light"; results_map.getColumnHeaders()[0].filename = in; results_map.getColumnHeaders()[1].label = "heavy"; results_map.getColumnHeaders()[1].filename = in; // collect the different MRM XIC pairs for each SILAC pair as quantlets // then calculate the ratio over the quanlets and calculate some statistics FeatureMap all_features; for (Map<double, Map<double, vector<SILAC_pair> > >::ConstIterator it1 = pairs.begin(); it1 != pairs.end(); ++it1) { for (Map<double, vector<SILAC_pair> >::ConstIterator it2 = it1->second.begin(); it2 != it1->second.end(); ++it2) { vector<SILACQuantitation> quantlets; writeDebug_("Analyzing SILAC pair: " + String(it1->first) + " <-> " + String(it2->first), 3); Size idx = 0; for (vector<SILAC_pair>::const_iterator pit = it2->second.begin(); pit != it2->second.end(); ++pit, ++idx) { FeatureMap feature_map_light, feature_map_heavy; for (FeatureMap::const_iterator it = all_mrm_features.begin(); it != all_mrm_features.end(); ++it) { if (fabs((double)it->getMetaValue("MZ") - it1->first) < mass_tolerance && fabs(it->getMZ() - pit->mz_light) < mass_tolerance && fabs(it->getRT() - pit->rt) < RT_tolerance) { feature_map_light.push_back(*it); } if (fabs((double)it->getMetaValue("MZ") - it2->first) < mass_tolerance && fabs(it->getMZ() - pit->mz_heavy) < mass_tolerance && fabs(it->getRT() - pit->rt) < RT_tolerance) { feature_map_heavy.push_back(*it); } } // search if feature maps to m/z value of pair vector<MatchedFeature> light, heavy; for (FeatureMap::const_iterator fit = feature_map_light.begin(); fit != feature_map_light.end(); ++fit) { all_features.push_back(*fit); light.push_back(MatchedFeature(*fit, idx)); } for (FeatureMap::const_iterator fit = feature_map_heavy.begin(); fit != feature_map_heavy.end(); ++fit) { all_features.push_back(*fit); heavy.push_back(MatchedFeature(*fit, idx)); } if (!heavy.empty() && !light.empty()) { writeDebug_("Finding best feature pair out of " + String(light.size()) + " light and " + String(heavy.size()) + " heavy matching features.", 1); // now find "good" matches, means the pair with the smallest m/z deviation Feature best_light, best_heavy; double best_deviation(numeric_limits<double>::max()); Size best_idx(it2->second.size()); for (vector<MatchedFeature>::const_iterator fit1 = light.begin(); fit1 != light.end(); ++fit1) { for (vector<MatchedFeature>::const_iterator fit2 = heavy.begin(); fit2 != heavy.end(); ++fit2) { if (fit1->idx != fit2->idx || fabs(fit1->f.getRT() - fit2->f.getRT()) > RT_pair_tolerance) { continue; } double deviation(0); deviation = fabs(fit1->f.getMZ() - it2->second[fit1->idx].mz_light) + fabs(fit2->f.getMZ() - it2->second[fit2->idx].mz_heavy); if (deviation < best_deviation && deviation < mass_tolerance) { best_light = fit1->f; best_heavy = fit2->f; best_idx = fit1->idx; } } } if (best_idx == it2->second.size()) { continue; } ConsensusFeature SILAC_feature; SILAC_feature.setMZ((best_light.getMZ() + best_heavy.getMZ()) / 2.0); SILAC_feature.setRT((best_light.getRT() + best_heavy.getRT()) / 2.0); SILAC_feature.insert(0, best_light); SILAC_feature.insert(1, best_heavy); results_map.push_back(SILAC_feature); quantlets.push_back(SILACQuantitation(best_light.getIntensity(), best_heavy.getIntensity(), best_idx)); writeDebug_("Ratio of XIC: " + String(best_heavy.getIntensity() / best_light.getIntensity()) + " " + String(best_light.getMZ()) + " <-> " + String(best_heavy.getMZ()) + " @" + String(SILAC_feature.getRT()) + " RT-heavy=" + String(best_heavy.getRT()) + ", RT-light=" + String(best_light.getRT()) + ", RT-diff=" + String(best_heavy.getRT() - best_light.getRT()) + " avg. int " + String((best_heavy.getIntensity() + best_light.getIntensity()) / 2.0), 1); } } writeDebug_("Quantitation of pair " + String(it1->first) + " <-> " + String(it2->first) + " (#XIC pairs for quantation=" + String(quantlets.size()) + ")", 1); if (quantlets.empty()) { continue; } // simply add up all intensities and calculate the final ratio double light_sum(0), heavy_sum(0); vector<double> light_ints, heavy_ints, ratios; for (vector<SILACQuantitation>::const_iterator qit1 = quantlets.begin(); qit1 != quantlets.end(); ++qit1) { light_sum += qit1->light_intensity; light_ints.push_back(qit1->light_intensity); heavy_sum += qit1->heavy_intensity; heavy_ints.push_back(qit1->heavy_intensity); ratios.push_back(qit1->heavy_intensity / qit1->light_intensity * (qit1->heavy_intensity + qit1->light_intensity)); } double absdev_ratios = Math::absdev(ratios.begin(), ratios.begin() + (ratios.size()) / (light_sum + heavy_sum)); cout << "Ratio: " << it1->first << " <-> " << it2->first << " @ " << it2->second.begin()->rt << " s, ratio(h/l) " << heavy_sum / light_sum << " +/- " << absdev_ratios << " " << "(#XIC-pairs for quantation: " + String(ratios.size()) + " )" << endl; } } //------------------------------------------------------------- // writing output //------------------------------------------------------------- if (feature_out != "") { FeatureXMLFile().store(feature_out, all_features); } writeDebug_("Writing output", 1); ConsensusXMLFile().store(out, results_map); return EXECUTION_OK; }
RES ResourceFormatLoaderTheme::load(const String &p_path,const String& p_original_path) { Error err; FileAccess *f = FileAccess::open(p_path,FileAccess::READ,&err); ERR_EXPLAIN("Unable to open theme file: "+p_path); ERR_FAIL_COND_V(err,RES()); String base_path = p_path.get_base_dir(); Ref<Theme> theme( memnew( Theme ) ); Map<StringName,Variant> library; bool reading_library=false; int line=0; while(!f->eof_reached()) { String l = f->get_line().strip_edges(); line++; int comment = l.find(";"); if (comment!=-1) l=l.substr(0,comment); if (l=="") continue; if (l.begins_with("[")) { if (l=="[library]") { reading_library=true; } else if (l=="[theme]") { reading_library=false; } else { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Unknown section type: '"+l+"'."); ERR_FAIL_V(RES()); } continue; } int eqpos = l.find("="); if (eqpos==-1) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Expected '='."); ERR_FAIL_V(RES()); } String right=l.substr(eqpos+1,l.length()).strip_edges(); if (right=="") { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Expected value after '='."); ERR_FAIL_V(RES()); } Variant value; if (right.is_valid_integer()) { //is number value = right.to_int(); } else if (right.is_valid_html_color()) { //is html color value = Color::html(right); } else if (right.begins_with("@")) { //reference String reference = right.substr(1,right.length()); if (!library.has(reference)) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid reference to '"+reference+"'."); ERR_FAIL_V(RES()); } value=library[reference]; } else if (right.begins_with("default")) { //use default //do none } else { //attempt to parse a constructor int popenpos = right.find("("); if (popenpos==-1) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid constructor syntax: "+right); ERR_FAIL_V(RES()); } int pclosepos = right.find_last(")"); if (pclosepos==-1) { ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid constructor parameter syntax: "+right); ERR_FAIL_V(RES()); } String type = right.substr(0,popenpos); String param = right.substr(popenpos+1,pclosepos-popenpos-1); if (type=="icon") { String path; if (param.is_abs_path()) path=param; else path=base_path+"/"+param; Ref<Texture> texture = ResourceLoader::load(path); if (!texture.is_valid()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Couldn't find icon at path: "+path); ERR_FAIL_V(RES()); } value=texture; } else if (type=="sbox") { String path; if (param.is_abs_path()) path=param; else path=base_path+"/"+param; Ref<StyleBox> stylebox = ResourceLoader::load(path); if (!stylebox.is_valid()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Couldn't find stylebox at path: "+path); ERR_FAIL_V(RES()); } value=stylebox; } else if (type=="sboxt") { Vector<String> params = param.split(","); if (params.size()!=5 && params.size()!=9) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid param count for sboxt(): '"+right+"'."); ERR_FAIL_V(RES()); } String path=params[0]; if (!param.is_abs_path()) path=base_path+"/"+path; Ref<Texture> tex = ResourceLoader::load(path); if (tex.is_null()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Could not open texture for sboxt at path: '"+params[0]+"'."); ERR_FAIL_V(RES()); } Ref<StyleBoxTexture> sbtex( memnew(StyleBoxTexture) ); sbtex->set_texture(tex); for(int i=0;i<4;i++) { if (!params[i+1].is_valid_integer()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid expand margin parameter for sboxt #"+itos(i+1) +", expected integer constant, got: '"+params[i+1]+"'."); ERR_FAIL_V(RES()); } int margin = params[i+1].to_int(); sbtex->set_expand_margin_size(Margin(i),margin); } if (params.size()==9) { for(int i=0;i<4;i++) { if (!params[i+5].is_valid_integer()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid expand margin parameter for sboxt #"+itos(i+5) +", expected integer constant, got: '"+params[i+5]+"'."); ERR_FAIL_V(RES()); } int margin = params[i+5].to_int(); sbtex->set_margin_size(Margin(i),margin); } } value = sbtex; } else if (type=="sboxf") { Vector<String> params = param.split(","); if (params.size()<2) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid param count for sboxf(): '"+right+"'."); ERR_FAIL_V(RES()); } Ref<StyleBoxFlat> sbflat( memnew(StyleBoxFlat) ); if (!params[0].is_valid_integer()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Expected integer numeric constant for parameter 0 (border size)."); ERR_FAIL_V(RES()); } sbflat->set_border_size(params[0].to_int()); if (!params[0].is_valid_integer()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Expected integer numeric constant for parameter 0 (border size)."); ERR_FAIL_V(RES()); } int left = MIN( params.size()-1, 3 ); int ccodes=0; for(int i=0;i<left;i++) { if (params[i+1].is_valid_html_color()) ccodes++; else break; } Color normal; Color bright; Color dark; if (ccodes<1) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Expected at least 1, 2 or 3 html color codes."); ERR_FAIL_V(RES()); } else if (ccodes==1) { normal=Color::html(params[1]); bright=Color::html(params[1]); dark=Color::html(params[1]); } else if (ccodes==2) { normal=Color::html(params[1]); bright=Color::html(params[2]); dark=Color::html(params[2]); } else { normal=Color::html(params[1]); bright=Color::html(params[2]); dark=Color::html(params[3]); } sbflat->set_dark_color(dark); sbflat->set_light_color(bright); sbflat->set_bg_color(normal); if (params.size()==ccodes+5) { //margins for(int i=0;i<4;i++) { if (!params[i+ccodes+1].is_valid_integer()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid expand margin parameter for sboxf #"+itos(i+ccodes+1) +", expected integer constant, got: '"+params[i+ccodes+1]+"'."); ERR_FAIL_V(RES()); } // int margin = params[i+ccodes+1].to_int(); //sbflat->set_margin_size(Margin(i),margin); } } else if (params.size()!=ccodes+1) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid amount of margin parameters for sboxt."); ERR_FAIL_V(RES()); } value=sbflat; } else { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid constructor type: '"+type+"'."); ERR_FAIL_V(RES()); } } //parse left and do something with it String left= l.substr(0,eqpos); if (reading_library) { left=left.strip_edges(); if (!left.is_valid_identifier()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": <LibraryItem> is not a valid identifier."); ERR_FAIL_V(RES()); } if (library.has(left)) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Already in library: '"+left+"'."); ERR_FAIL_V(RES()); } library[left]=value; } else { int pointpos = left.find("."); if (pointpos==-1) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Expected 'control.item=..' assign syntax."); ERR_FAIL_V(RES()); } String control=left.substr(0,pointpos).strip_edges(); if (!control.is_valid_identifier()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": <Control> is not a valid identifier."); ERR_FAIL_V(RES()); } String item=left.substr(pointpos+1,left.size()).strip_edges(); if (!item.is_valid_identifier()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": <Item> is not a valid identifier."); ERR_FAIL_V(RES()); } if (value.get_type()==Variant::NIL) { //try to use exiting if (Theme::get_default()->has_stylebox(item,control)) value=Theme::get_default()->get_stylebox(item,control); else if (Theme::get_default()->has_font(item,control)) value=Theme::get_default()->get_font(item,control); else if (Theme::get_default()->has_icon(item,control)) value=Theme::get_default()->get_icon(item,control); else if (Theme::get_default()->has_color(item,control)) value=Theme::get_default()->get_color(item,control); else if (Theme::get_default()->has_constant(item,control)) value=Theme::get_default()->get_constant(item,control); else { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Default not present for: '"+control+"."+item+"'."); ERR_FAIL_V(RES()); } } if (value.get_type()==Variant::OBJECT) { Ref<Resource> res = value; if (!res.is_valid()) { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid resource (NULL)."); ERR_FAIL_V(RES()); } if (res->cast_to<StyleBox>()) { theme->set_stylebox(item,control,res); } else if (res->cast_to<Font>()) { theme->set_font(item,control,res); } else if (res->cast_to<Font>()) { theme->set_font(item,control,res); } else if (res->cast_to<Texture>()) { theme->set_icon(item,control,res); } else { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Invalid resource type."); ERR_FAIL_V(RES()); } } else if (value.get_type()==Variant::COLOR) { theme->set_color(item,control,value); } else if (value.get_type()==Variant::INT) { theme->set_constant(item,control,value); } else { memdelete(f); ERR_EXPLAIN(p_path+":"+itos(line)+": Couldn't even determine what this setting is! what did you do!?"); ERR_FAIL_V(RES()); } } } f->close(); memdelete(f); return theme; }
static Error _parse_material_library(const String &p_path, Map<String, Ref<SpatialMaterial> > &material_map, List<String> *r_missing_deps) { FileAccessRef f = FileAccess::open(p_path, FileAccess::READ); ERR_FAIL_COND_V(!f, ERR_CANT_OPEN); Ref<SpatialMaterial> current; String current_name; String base_path = p_path.get_base_dir(); while (true) { String l = f->get_line().strip_edges(); if (l.begins_with("newmtl ")) { //vertex current_name = l.replace("newmtl", "").strip_edges(); current.instance(); current->set_name(current_name); material_map[current_name] = current; } else if (l.begins_with("Ka ")) { //uv print_line("Warning: Ambient light for material '" + current_name + "' is ignored in PBR"); } else if (l.begins_with("Kd ")) { //normal ERR_FAIL_COND_V(current.is_null(), ERR_FILE_CORRUPT); Vector<String> v = l.split(" ", false); ERR_FAIL_COND_V(v.size() < 4, ERR_INVALID_DATA); Color c = current->get_albedo(); c.r = v[1].to_float(); c.g = v[2].to_float(); c.b = v[3].to_float(); current->set_albedo(c); } else if (l.begins_with("Ks ")) { //normal ERR_FAIL_COND_V(current.is_null(), ERR_FILE_CORRUPT); Vector<String> v = l.split(" ", false); ERR_FAIL_COND_V(v.size() < 4, ERR_INVALID_DATA); float r = v[1].to_float(); float g = v[2].to_float(); float b = v[3].to_float(); float metalness = MAX(r, MAX(g, b)); current->set_metallic(metalness); } else if (l.begins_with("Ns ")) { //normal ERR_FAIL_COND_V(current.is_null(), ERR_FILE_CORRUPT); Vector<String> v = l.split(" ", false); ERR_FAIL_COND_V(v.size() != 2, ERR_INVALID_DATA); float s = v[1].to_float(); current->set_metallic((1000.0 - s) / 1000.0); } else if (l.begins_with("d ")) { //normal ERR_FAIL_COND_V(current.is_null(), ERR_FILE_CORRUPT); Vector<String> v = l.split(" ", false); ERR_FAIL_COND_V(v.size() != 2, ERR_INVALID_DATA); float d = v[1].to_float(); Color c = current->get_albedo(); c.a = d; current->set_albedo(c); if (c.a < 0.99) { current->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); } } else if (l.begins_with("Tr ")) { //normal ERR_FAIL_COND_V(current.is_null(), ERR_FILE_CORRUPT); Vector<String> v = l.split(" ", false); ERR_FAIL_COND_V(v.size() != 2, ERR_INVALID_DATA); float d = v[1].to_float(); Color c = current->get_albedo(); c.a = 1.0 - d; current->set_albedo(c); if (c.a < 0.99) { current->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true); } } else if (l.begins_with("map_Ka ")) { //uv print_line("Warning: Ambient light texture for material '" + current_name + "' is ignored in PBR"); } else if (l.begins_with("map_Kd ")) { //normal ERR_FAIL_COND_V(current.is_null(), ERR_FILE_CORRUPT); String p = l.replace("map_Kd", "").replace("\\", "/").strip_edges(); String path = base_path.plus_file(p); Ref<Texture> texture = ResourceLoader::load(path); if (texture.is_valid()) { current->set_texture(SpatialMaterial::TEXTURE_ALBEDO, texture); } else if (r_missing_deps) { r_missing_deps->push_back(path); } } else if (l.begins_with("map_Ks ")) { //normal ERR_FAIL_COND_V(current.is_null(), ERR_FILE_CORRUPT); String p = l.replace("map_Ks", "").replace("\\", "/").strip_edges(); String path = base_path.plus_file(p); Ref<Texture> texture = ResourceLoader::load(path); if (texture.is_valid()) { current->set_texture(SpatialMaterial::TEXTURE_METALLIC, texture); } else if (r_missing_deps) { r_missing_deps->push_back(path); } } else if (l.begins_with("map_Ns ")) { //normal ERR_FAIL_COND_V(current.is_null(), ERR_FILE_CORRUPT); String p = l.replace("map_Ns", "").replace("\\", "/").strip_edges(); String path = base_path.plus_file(p); Ref<Texture> texture = ResourceLoader::load(path); if (texture.is_valid()) { current->set_texture(SpatialMaterial::TEXTURE_ROUGHNESS, texture); } else if (r_missing_deps) { r_missing_deps->push_back(path); } } else if (l.begins_with("map_bump ")) { //normal ERR_FAIL_COND_V(current.is_null(), ERR_FILE_CORRUPT); String p = l.replace("map_bump", "").replace("\\", "/").strip_edges(); String path = base_path.plus_file(p); Ref<Texture> texture = ResourceLoader::load(path); if (texture.is_valid()) { current->set_feature(SpatialMaterial::FEATURE_NORMAL_MAPPING, true); current->set_texture(SpatialMaterial::TEXTURE_NORMAL, texture); } else if (r_missing_deps) { r_missing_deps->push_back(path); } } else if (f->eof_reached()) { break; } } return OK; }
String File::absolutePath(const String &filePath) { String path = normalizePath(filePath); if(path.isEmpty()) return String(); String base; unsigned int start; #if WITCHENGINE_PLATFORM == WITCHENGINE_PLATFORM_WIN32 || WITCHENGINE_PLATFORM == WITCHENGINE_PLATFORM_WIN64 if(path.match("?:*")) start = 1; else if(path.match("\\\\*")) { base = "\\\\"; start = 2; } else if(path.startsWith('\\')) { String drive = Directory::current().substrTo('\\'); String end = path.substr(1, -1); if(end.isEmpty()) path = drive; else path = drive + '\\' + end; start = 1; } else { // Throw an exception. return path; } #else base = ''; start = 0; #endif static String upDir = WITCH_DIRECTORY_SEPARATOR + String('.'); if(path.find(upDir) == String::npos) return path; std::vector<String> sep; if(path.split(sep, WITCH_DIRECTORY_SEPARATOR) <= 1) return path; unsigned int pathLen = base.size(); for(unsigned int i = 0; i < sep.size(); ++i) { if(sep[i] == '.') sep.erase(sep.begin() + i--); else if(sep[i] == "..") { if(i > start) sep.erase(sep.begin() - i--); sep.erase(sep.begin() + i--); } else pathLen += sep[i].size(); } pathLen += sep.size() - 1; String stream; stream.reserve(pathLen); stream.append(base); for(unsigned int i = 0; i < sep.size(); ++i) { stream.append(sep[i]); if(i != sep.size() - 1) stream.append(WITCH_DIRECTORY_SEPARATOR); } return stream; }
P<BundleData> DirBundleLoader::loadBundle(String location) { P<BundleData> bundleData = new BundleData(); bundleData->setLocation(location); String path = location; path.append(L"\\META-INF\\MANIFEST.MF"); P<File> file = new File(path); P<Manifest> mf = new Manifest(file); P<Map<String,String>> entries = mf->getEntries(); String symbolicName = entries->get(Constants::BUNDLE_SYMBOLICNAME); if (symbolicName == (String)null || symbolicName.equals(L"") ) { throw BundleException(String(L"Bundle symbolic name not found: ") + file->getAbsolutePath()); } //if (framework->getBundle(symbolicName) != null) //{ // throw BundleException(String(L"Bundle(SymbolicName: ") + symbolicName + String(L") already exists: ") + file->getAbsolutePath()); // } bundleData->setSymbolicName(symbolicName); //get Bundle-Name String name = entries->get(Constants::BUNDLE_NAME); if (name == (String)null || name.equals(L"")) { name = File(location).getName(); } bundleData->setName(name); // Validate the bundle activator. String activator = entries->get(Constants::BUNDLE_ACTIVATOR); if (activator == (String)null || symbolicName.equals(L"") ) { throw BundleException(String(L"Bundle activator definition not found: ") + file->getAbsolutePath()); } bundleData->setActivator(activator); String nativeLib = entries->get(Constants::BUNDLE_NATIVE_LIB); if (nativeLib == (String)null || nativeLib.equals(L"") ) { nativeLib = name + String(L".dll"); } nativeLib = String(location) + String(L"\\") + nativeLib; bundleData->setNativeLib(nativeLib); //P<Library> lib= new DllLibrary(); //lib->load(this->nativeLib); //if (!lib->containsClass(activator)) //{ // throw BundleException(String(L"Bundle activator class(\"") + activator + String(L"\") not found: ") + file->getAbsolutePath()); // } //lib->free(); String description = entries->get(Constants::BUNDLE_DESCRIPTION); if (description == (String)null || description.equals(L"")) { description = L""; } bundleData->setDescription(description); // Parse classpaths String classpath = entries->get(Constants::BUNDLE_CLASSPATH); P<Array<String>> classPaths = null; if (classpath != null) { Array<String> theClassPaths =classpath.split(L","); int size = theClassPaths.size(); classPaths = new Array<String>(size); for (int i = 0; i < size; i++) { String theClassPath =theClassPaths.get(i); // Check the classpath entry bool entryExists = false; String theRealPath = generateURL(location, theClassPath); File theFile(theRealPath); entryExists = theFile.exists(); if (entryExists) { classPaths->set(i, theFile.getCanonicalPath()); } else { throw BundleException(String(L"Classpath(\"") + theClassPath + String(L"\") not found: ") + file->getAbsolutePath()); } } } else { classPaths = new Array<String>(); } bundleData->setClassPaths(classPaths); // Parse export packages String exportPackages = entries->get(Constants::EXPORT_PACKAGE); Array<String> exportedPackages; if (exportPackages != null) { exportedPackages =exportPackages.split(L","); } else { exportedPackages = Array<String>(); } bundleData->setExportedPackages(new Array<String>(exportedPackages)); // Parse import packages, nee String importpackages = entries->get(Constants::IMPORT_PACKAGE); Array<String> importedPackages; if (importpackages != null) { importedPackages =importpackages.split(L","); } else { importedPackages = Array<String>(); } bundleData->setImportedPackages(new Array<String>(importedPackages)); // Parse reuqired extensions String requiredbundles = entries->get(Constants::REQUIRE_BUNDLE); Array<String> requiredBundles; if (requiredbundles != null) { requiredBundles =requiredbundles.split(L","); } else { requiredBundles = Array<String>(); } bundleData->setRequiredBundles(new Array<String>(requiredBundles)); return bundleData; }
Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entity *targetEntity, int entityFileVersion) { Entity *entity = NULL; ObjectEntry *entityType = (*entry)["type"]; if(entityType) { if(entityType->stringVal == "SceneEntityInstance") { ObjectEntry *instanceEntry = (*entry)["SceneEntityInstance"]; String filePath = (*instanceEntry)["filePath"]->stringVal; SceneEntityInstance *instance = new SceneEntityInstance(parentScene, filePath); entity = instance; } else if(entityType->stringVal == "SceneSprite") { ObjectEntry *spriteEntry = (*entry)["SceneSprite"]; String filePath = (*spriteEntry)["filePath"]->stringVal; SceneSprite *sprite = new SceneSprite(filePath); String animName = (*spriteEntry)["anim"]->stringVal; sprite->playAnimation(animName, -1, false); entity = sprite; applySceneMesh((*entry)["SceneMesh"], sprite); } else if(entityType->stringVal == "SceneLabel") { ObjectEntry *labelEntry = (*entry)["SceneLabel"]; String text = (*labelEntry)["text"]->stringVal; String font = (*labelEntry)["font"]->stringVal; int size = (*labelEntry)["size"]->intVal; Number actualHeight = (*labelEntry)["actualHeight"]->intVal; int aaMode = (*labelEntry)["aaMode"]->intVal; SceneLabel *label = new SceneLabel(text, size, font, aaMode, actualHeight); label->setAnchorPoint(0.0, 0.0, 0.0); label->snapToPixels = false; label->positionAtBaseline = false; applySceneMesh((*entry)["SceneMesh"], label); if(label->getLocalShaderOptions()) { label->getLocalShaderOptions()->clearTexture("diffuse"); label->getLocalShaderOptions()->addTexture("diffuse", label->getTexture()); } entity = label; } else if(entityType->stringVal == "SceneParticleEmitter") { ObjectEntry *emitterEntry = (*entry)["SceneParticleEmitter"]; SceneParticleEmitter *emitter = new SceneParticleEmitter(1, 1, 1); emitter->setParticleType((*emitterEntry)["type"]->intVal); emitter->setParticleSpeed((*emitterEntry)["speed"]->NumberVal); emitter->setParticleCount((*emitterEntry)["count"]->intVal); emitter->setParticleLifetime((*emitterEntry)["lifetime"]->NumberVal); emitter->setParticleSize((*emitterEntry)["size"]->NumberVal); emitter->setParticlesInWorldSpace((*emitterEntry)["world"]->boolVal); emitter->setLoopParticles((*emitterEntry)["loop"]->boolVal); emitter->setParticleRotationSpeed(Vector3((*emitterEntry)["rX"]->NumberVal, (*emitterEntry)["rY"]->NumberVal, (*emitterEntry)["rZ"]->NumberVal)); emitter->setGravity(Vector3((*emitterEntry)["gX"]->NumberVal, (*emitterEntry)["gY"]->NumberVal, (*emitterEntry)["gZ"]->NumberVal)); emitter->setParticleDirection(Vector3((*emitterEntry)["dirX"]->NumberVal, (*emitterEntry)["dirY"]->NumberVal, (*emitterEntry)["dirZ"]->NumberVal)); emitter->setEmitterSize(Vector3((*emitterEntry)["eX"]->NumberVal, (*emitterEntry)["eY"]->NumberVal, (*emitterEntry)["eZ"]->NumberVal)); emitter->setDirectionDeviation(Vector3((*emitterEntry)["devX"]->NumberVal, (*emitterEntry)["devY"]->NumberVal, (*emitterEntry)["devZ"]->NumberVal)); emitter->setPerlinEnabled((*emitterEntry)["perlin"]->boolVal); if(emitter->getPerlinEnabled()) { emitter->setPerlinValue(Vector3((*emitterEntry)["pX"]->NumberVal, (*emitterEntry)["pY"]->NumberVal, (*emitterEntry)["pZ"]->NumberVal)); } emitter->useColorCurves = (*emitterEntry)["useColorCurves"]->boolVal; emitter->useScaleCurve = (*emitterEntry)["useScaleCurve"]->boolVal; parseObjectIntoCurve((*emitterEntry)["colorCurveR"], &emitter->colorCurveR); parseObjectIntoCurve((*emitterEntry)["colorCurveG"], &emitter->colorCurveG); parseObjectIntoCurve((*emitterEntry)["colorCurveB"], &emitter->colorCurveB); parseObjectIntoCurve((*emitterEntry)["colorCurveA"], &emitter->colorCurveA); parseObjectIntoCurve((*emitterEntry)["scaleCurve"], &emitter->scaleCurve); applySceneMesh((*entry)["SceneMesh"], emitter); entity = emitter; } else if(entityType->stringVal == "SceneLight") { ObjectEntry *lightEntry = (*entry)["SceneLight"]; if(lightEntry) { int lightType = (*lightEntry)["type"]->intVal; SceneLight *newLight = new SceneLight(lightType, parentScene, 0); newLight->setIntensity((*lightEntry)["intensity"]->NumberVal); ObjectEntry *importanceEntry = (*lightEntry)["importance"]; if(importanceEntry) { newLight->setLightImportance(importanceEntry->intVal); } newLight->lightColor.setColor((*lightEntry)["cR"]->NumberVal, (*lightEntry)["cG"]->NumberVal, (*lightEntry)["cB"]->NumberVal, (*lightEntry)["cA"]->NumberVal); newLight->specularLightColor.setColor((*lightEntry)["scR"]->NumberVal, (*lightEntry)["scG"]->NumberVal, (*lightEntry)["scB"]->NumberVal, (*lightEntry)["scA"]->NumberVal); newLight->setAttenuation((*lightEntry)["cAtt"]->NumberVal, (*lightEntry)["lAtt"]->NumberVal, (*lightEntry)["qAtt"]->NumberVal); if(newLight->getType() == SceneLight::SPOT_LIGHT) { newLight->setSpotlightProperties((*lightEntry)["spotCutoff"]->NumberVal, (*lightEntry)["spotExponent"]->NumberVal); if((*lightEntry)["shadows"]->boolVal) { newLight->enableShadows(true, (*lightEntry)["shadowmapRes"]->intVal); newLight->setShadowMapFOV((*lightEntry)["shadowmapFOV"]->NumberVal); } } parentScene->addLight(newLight); entity = newLight; } } else if(entityType->stringVal == "ScenePrimitive") { ObjectEntry *scenePrimitiveEntry = (*entry)["ScenePrimitive"]; int pType = (*scenePrimitiveEntry)["type"]->intVal; Number p1 = (*scenePrimitiveEntry)["p1"]->NumberVal; Number p2 = (*scenePrimitiveEntry)["p2"]->NumberVal; Number p3 = (*scenePrimitiveEntry)["p3"]->NumberVal; Number p4 = (*scenePrimitiveEntry)["p4"]->NumberVal; Number p5 = (*scenePrimitiveEntry)["p5"]->NumberVal; ScenePrimitive *primitive = new ScenePrimitive(pType, p1, p2, p3, p4, p5); entity = primitive; applySceneMesh((*entry)["SceneMesh"], primitive); } else if(entityType->stringVal == "SceneMesh") { ObjectEntry *meshEntry = (*entry)["SceneMesh"]; if(meshEntry) { ObjectEntry *fileName = (*meshEntry)["file"]; if(fileName) { SceneMesh *newMesh = new SceneMesh(fileName->stringVal); applySceneMesh(meshEntry, newMesh); entity = newMesh; } } } else if(entityType->stringVal == "SceneSound") { ObjectEntry *soundEntry = (*entry)["SceneSound"]; String filePath = (*soundEntry)["filePath"]->stringVal; Number refDistance = (*soundEntry)["refDistance"]->NumberVal; Number maxDistance = (*soundEntry)["maxDistance"]->NumberVal; Number volume = (*soundEntry)["volume"]->NumberVal; Number pitch = (*soundEntry)["pitch"]->NumberVal; SceneSound *sound = new SceneSound(filePath, refDistance, maxDistance); sound->getSound()->setVolume(volume); sound->getSound()->setPitch(pitch); entity = sound; } else if(entityType->stringVal == "Camera") { ObjectEntry *cameraEntry = (*entry)["Camera"]; Camera *camera = new Camera(parentScene); camera->setExposureLevel((*cameraEntry)["exposure"]->NumberVal); camera->setClippingPlanes((*cameraEntry)["nearClip"]->NumberVal, (*cameraEntry)["farClip"]->NumberVal); camera->setOrthoMode((*cameraEntry)["ortho"]->boolVal); if(camera->getOrthoMode()) { camera->setOrthoSizeMode((*cameraEntry)["sizeMode"]->intVal); camera->setOrthoSize((*cameraEntry)["orthoWidth"]->NumberVal, (*cameraEntry)["orthoHeight"]->NumberVal); } else { camera->setFOV((*cameraEntry)["fov"]->NumberVal); } entity = camera; } } if(!entity) { if(targetEntity) { entity = targetEntity; } else { entity = new Entity(); } } entity->ownsChildren = true; Vector3 bBox; entry->readNumber("bbX", &bBox.x); entry->readNumber("bbY", &bBox.y); entry->readNumber("bbZ", &bBox.z); entity->setLocalBoundingBox(bBox); entity->color.r = (*entry)["cR"]->NumberVal; entity->color.g = (*entry)["cG"]->NumberVal; entity->color.b = (*entry)["cB"]->NumberVal; entity->color.a = (*entry)["cA"]->NumberVal; if(!targetEntity) { entity->blendingMode = (*entry)["blendMode"]->intVal; entity->setScale((*entry)["sX"]->NumberVal, (*entry)["sY"]->NumberVal, (*entry)["sZ"]->NumberVal); entity->setPosition((*entry)["pX"]->NumberVal, (*entry)["pY"]->NumberVal, (*entry)["pZ"]->NumberVal); if(entityFileVersion > 1) { entity->setRotationQuat((*entry)["rW"]->NumberVal, (*entry)["rX"]->NumberVal, (*entry)["rY"]->NumberVal, (*entry)["rZ"]->NumberVal); } else { entity->setRotationEuler(Vector3((*entry)["rX"]->NumberVal, (*entry)["rY"]->NumberVal, (*entry)["rZ"]->NumberVal)); } } if((*entry)["id"]->stringVal != "") { entity->id = (*entry)["id"]->stringVal; } if((*entry)["layerID"]) { entity->layerID = (unsigned int)((*entry)["layerID"]->intVal); } String tagString = (*entry)["tags"]->stringVal; if(tagString != "") { std::vector<String> tags = tagString.split(","); for(int i=0; i < tags.size(); i++) { entity->addTag(tags[i]); } } ObjectEntry *props = (*entry)["props"]; if(props) { for(int i=0; i < props->length; i++) { ObjectEntry *prop = ((*props))[i]; if(prop) { entity->setEntityProp((*prop)["name"]->stringVal, (*prop)["value"]->stringVal); } } } ObjectEntry *children = (*entry)["children"]; if(children) { for(int i=0; i < children->length; i++) { ObjectEntry *childEntry = ((*children))[i]; ScreenEntity *childEntity = loadObjectEntryIntoEntity(childEntry, NULL, entityFileVersion); entity->addChild(childEntity); } } return entity; }
int main(int argc, char** argv) { String a; a = "Testing..."; cout << a << endl; cout << "length: " << a.length() << endl; cout << "capacity: " << a.capacity() << endl; a = a + "one two three"; cout << a << endl; cout << "length: " << a.length() << endl; cout << "capacity: " << a.capacity() << endl; a = "stuff on the front:" + a; cout << a << endl; cout << "length: " << a.length() << endl; cout << "capacity: " << a.capacity() << endl; long intval = 0; if (String("32").parseInt(intval)) cout << "Converting '32' to int: " << intval << endl; else cout << "Error converting string to int.\n"; double doubleval = 0.0; String("3.141592654").parseDouble(doubleval); cout << "Converting 3.141592654 to double: " << doubleval << endl; long hexval = 0; if (String("0x34ab").parseHex(hexval)) cout << "Converting 0x34ab to " << hexval << " (Should be 13483)" << endl; else cout << "Hex conversion failed.\n"; String tflag("true"); String fflag("false"); bool boolval; tflag.parseBool(boolval); if (boolval) cout << "This should have been true (and was)" << endl; else cout << "tflag was false and should have been true." << endl; fflag.parseBool(boolval); if (boolval) cout << "fflag should have been false and wasn't." << endl; else cout << "fflag was false and should have been." << endl; char c; a.charAt(3, c); cout << "\nCharacter at position 3: '" << c << "' \n"; String b("cat"); String d = "cat"; if (b == d) cout << "Yup, equal.\n"; else cout << "Nope, not equal.\n"; if (b == "fark") cout << b << " is less than fark\n"; cout << a.toLower() << endl; cout << a.toUpper() << endl; cout << "Substring..." << endl; String substr_test = "this is a weird string. Much odd."; cout << substr_test.substring(4, 4) << endl; cout << "Regular Expressions\n"; String astring = "This is a test."; if (astring.matches("is a")) cout << " Matched!\n"; else cout << " Didn't match.\n"; String csvstuff = "3.1415 2.71828 42 testing"; ArrayList<String> fields = csvstuff.split(" +"); }
void PepNovoOutfile::getSearchEngineAndVersion( const String & pepnovo_output_without_parameters_filename, ProteinIdentification & protein_identification) { ifstream pepnovo_output_without_parameters(pepnovo_output_without_parameters_filename.c_str()); if (!pepnovo_output_without_parameters) { throw Exception::FileNotFound(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, pepnovo_output_without_parameters_filename); } ProteinIdentification::SearchParameters search_param; // searching for something like this: PepNovo v1.03 String line; vector<String> substrings; while (getline(pepnovo_output_without_parameters, line)) { if (!line.empty() && (line[line.length() - 1] < 33)) line.resize(line.length() - 1); line.trim(); if (line.empty()) continue; if (line.hasPrefix("PepNovo")) { line.split(',', substrings); if (substrings.size() == 2) //previous version of PepNovo { protein_identification.setSearchEngine(substrings[0].trim()); protein_identification.setSearchEngineVersion(substrings[1].trim()); //else something is strange and we use defaults later } else { line.split(' ', substrings); if (substrings.size() == 3) { protein_identification.setSearchEngine(substrings[0].trim()); protein_identification.setSearchEngineVersion(substrings[2].trim()); //else something is strange and we use defaults later } } } if (line.hasPrefix("PM")) { line.split(' ', substrings); search_param.precursor_mass_tolerance = substrings.back().toFloat(); } if (line.hasPrefix("Fragment")) { line.split(' ', substrings); search_param.fragment_mass_tolerance = substrings.back().toFloat(); } if (line.hasPrefix("PTM")) { line.split(':', substrings); substrings.erase(substrings.begin()); for (vector<String>::iterator ptm_it = substrings.begin(); ptm_it != substrings.end(); ++ptm_it) { ptm_it->trim(); } if (!substrings.empty() && substrings[0] != "None") { search_param.variable_modifications = substrings; } } if (line.hasPrefix(">>")) { break; } } protein_identification.setSearchParameters(search_param); }
/** -------------------------------------------------------------------- * Add new cookie to existing set. **/ void setCookies(Document* doc/*document*/, const KURL& url, const String& value) { int i, j, len; const int n = 7; String result, key1, key2, f[n], inCookie, outCookie; Vector<String> field; // printf("%s: input: %08X %s\n%s\n\n", __func__, (unsigned)doc, url.string().utf8().data(), value.utf8().data()); if (value.length() == 0) return; String host = url.host(); if (doc) { Vector<String> param; f[0] = ""; f[1] = "TRUE"; f[2] = ""; f[3] = "FALSE"; f[4] = "0"; f[5] = ""; f[6] = ""; bool ok = false; value.split(';', param); len = param.size(); for (i = 0; i < len; i++) { param[i] = param[i].stripWhiteSpace(); if (param[i] == "secure") { f[3] = "TRUE"; continue; } param[i].split('=', field); if (field.size() < 2) return; field[0] = field[0].stripWhiteSpace(); field[1] = field[1].stripWhiteSpace(); if (field[0] == "domain") { // if (!host.endsWith(field[1], false)) // return; f[0] = field[1]; } else if (field[0] == "path") { f[2] = field[1]; } else if (field[0] == "expires") { // --- Only GMT zone is valid --- time_t date = curl_getdate(field[1].utf8().data(), NULL); if (date < 0) date = 0; f[4] = String::number(date); } else { f[5] = field[0]; f[6] = field[1]; ok = true; } } if (!ok) return; // --- Defaults --- if (f[0].isEmpty()) f[0] = host; if (f[2].isEmpty()) f[2] = url.path(); result = f[0]; for (i = 1; i < n; i++) result += "\t" + f[i]; key1 = f[0] + f[2] + f[5]; } else { value.split('\t', true, field); if (field.size() != n) return; if (!host.endsWith(field[0], false)) return; key1 = field[0] + field[2] + field[5]; result = value; } // --- Remove existing entry --- inCookie = cookieJar.get(host); if (!inCookie.isEmpty()) { inCookie.split('\t', true, field); len = field.size(); for (j = 0; j < len; j += n) { key2 = field[j] + field[j + 2] + field[j + 5]; if (key1 == key2) continue; for (i = 0; i < n; i++) outCookie += "\t" + field[j + i]; } outCookie = result + outCookie; } else outCookie = result; // printf("%s: result: host=%s, cookie=%s\n\n", __func__, host.utf8().data(), outCookie.utf8().data()); cookieJar.set(host, outCookie); if (doc) { int cookieJarStatus = getCookieJarStatus(); if (cookieJarStatus <= COOKIE_JAR_OK) setCookieJarStatus(COOKIE_JAR_DIRTY); } }
int main(int argc, char **argv) { PHYSFS_init(argv[0]); #if defined(__APPLE__) && defined(__MACH__) uint32_t bufsize = 2048; char path[bufsize]; _NSGetExecutablePath(path, &bufsize); String basePath = path; vector<String> cpts = basePath.split("/"); String installPath = ""; for(int i=0; i < cpts.size() - 2; i++) { installPath = installPath + cpts[i]; installPath += String("/"); } #elif defined (_WINDOWS) char path[2049]; TCHAR tpath[2049]; GetModuleFileName(NULL, (LPWSTR)tpath, 2048); wtoc(path, tpath, 2048); String basePath = path; vector<String> cpts = basePath.split("\\"); String installPath = ""; for(int i=0; i < cpts.size() - 2; i++) { installPath = installPath + cpts[i]; installPath += String("\\"); } #else String basePath = PHYSFS_getBaseDir(); vector<String> cpts = basePath.split("/"); String installPath = ""; for(int i=0; i < cpts.size() - 2; i++) { installPath = installPath + cpts[i]; installPath += String("/"); } #endif printf("Polycode build tool v0.8.2\n"); for(int i=0; i < argc; i++) { String argString = String(argv[i]); vector<String> bits = argString.split("="); if(bits.size() == 2) { BuildArg arg; arg.name = bits[0]; arg.value = bits[1]; // printf("arg: %s=%s\n", arg.name.c_str(), arg.value.c_str()); args.push_back(arg); } } if(getArg("--config") == "") { printf("\n\nInput config XML missing. Use --config=path to specify.\n\n"); return 1; } if(getArg("--out") == "") { printf("\n\nOutput file not specified. Use --out=outfile.polyapp to specify.\n\n"); return 1; } char dirPath[4099]; #if defined(__APPLE__) && defined(__MACH__) getcwd(dirPath, sizeof(dirPath)); #elif defined (_WINDOWS) TCHAR tdirpath[4099]; GetCurrentDirectory(4098, (LPWSTR)tdirpath); wtoc(dirPath, tdirpath, 4098); #else getcwd(dirPath, sizeof(dirPath)); #endif String currentPath = String(dirPath); String configPath = getArg("--config"); String finalPath = configPath; if(configPath[0] != '/' && configPath[1] !=':') { #ifdef _WINDOWS finalPath = currentPath+"\\"+configPath; #else finalPath = currentPath+"/"+configPath; #endif } printf("Reading config file from %s\n", finalPath.c_str()); Object configFile; if(!configFile.loadFromXML(finalPath)) { printf("Specified config file doesn't exist!\n"); return 1; } printf("OK!\n"); // start required params String entryPoint; int defaultWidth; int defaultHeight; int frameRate = 60; int antiAliasingLevel = 0; int anisotropyLevel = 0; bool vSync = false; bool fullScreen = false; float backgroundColorR = 0.2; float backgroundColorG = 0.2; float backgroundColorB = 0.2; String textureFiltering = "linear"; if(configFile.root["entryPoint"]) { printf("Entry point: %s\n", configFile.root["entryPoint"]->stringVal.c_str()); entryPoint = configFile.root["entryPoint"]->stringVal; } else { printf("Required parameter: \"entryPoint\" is missing from config file!\n"); return 1; } if(configFile.root["defaultWidth"]) { printf("Width: %d\n", configFile.root["defaultWidth"]->intVal); defaultWidth = configFile.root["defaultWidth"]->intVal; } else { printf("Required parameter: \"defaultWidth\" is missing from config file!\n"); return 1; } if(configFile.root["defaultHeight"]) { printf("Height: %d\n", configFile.root["defaultHeight"]->intVal); defaultHeight = configFile.root["defaultHeight"]->intVal; } else { printf("Required parameter: \"defaultHeight\" is missing from config file!\n"); return 1; } // start optional params if(configFile.root["frameRate"]) { printf("Frame rate: %d\n", configFile.root["frameRate"]->intVal); frameRate = configFile.root["frameRate"]->intVal; } if(configFile.root["textureFiltering"]) { printf("Filtering mode: %s\n", configFile.root["textureFiltering"]->stringVal.c_str()); textureFiltering = configFile.root["textureFiltering"]->stringVal; } if(configFile.root["antiAliasingLevel"]) { printf("Anti-aliasing level: %d\n", configFile.root["antiAliasingLevel"]->intVal); antiAliasingLevel = configFile.root["antiAliasingLevel"]->intVal; } if(configFile.root["anisotropyLevel"]) { printf("Anisotropy level: %d\n", configFile.root["anisotropyLevel"]->intVal); anisotropyLevel = configFile.root["anisotropyLevel"]->intVal; } if(configFile.root["vSync"]) { vSync = configFile.root["vSync"]->boolVal; if(vSync) { printf("V-Sync: true\n"); } else { printf("V-Sync: false\n"); } } if(configFile.root["fullScreen"]) { fullScreen = configFile.root["fullScreen"]->boolVal; if(fullScreen) { printf("Full-screen: true\n"); } else { printf("Full-screen: false\n"); } } if(configFile.root["backgroundColor"]) { ObjectEntry *color = configFile.root["backgroundColor"]; if((*color)["red"] && (*color)["green"] && (*color)["blue"]) { backgroundColorR = (*color)["red"]->NumberVal; backgroundColorG = (*color)["green"]->NumberVal; backgroundColorB = (*color)["blue"]->NumberVal; printf("Background color: %f %f %f\n", backgroundColorR, backgroundColorG, backgroundColorB); } else { printf("backgroundColor node specified, but missing all three color attributes (red,green,blue). Ignoring.\n"); } } zipFile z = zipOpen(getArg("--out").c_str(), 0); Object runInfo; runInfo.root.name = "PolycodeApp"; runInfo.root.addChild("entryPoint", entryPoint); runInfo.root.addChild("defaultHeight", defaultHeight); runInfo.root.addChild("defaultWidth", defaultWidth); runInfo.root.addChild("frameRate", frameRate); runInfo.root.addChild("antiAliasingLevel", antiAliasingLevel); runInfo.root.addChild("anisotropyLevel", anisotropyLevel); runInfo.root.addChild("vSync", vSync); runInfo.root.addChild("fullScreen", fullScreen); runInfo.root.addChild("textureFiltering", String(textureFiltering)); ObjectEntry *color = runInfo.root.addChild("backgroundColor"); color->addChild("red", backgroundColorR); color->addChild("green", backgroundColorG); color->addChild("blue", backgroundColorB); if(configFile.root["fonts"]) { runInfo.root.addChild(configFile.root["fonts"]); } if(configFile.root["modules"]) { #ifdef _WINDOWS String modulesPath = installPath + "Modules\\"; #else String modulesPath = installPath + "Modules/"; #endif ObjectEntry *modules = configFile.root["modules"]; if(modules) { for(int i=0; i < modules->length; i++) { printf("Adding module: %s\n", (*modules)[i]->stringVal.c_str()); String modulePath = modulesPath + (*modules)[i]->stringVal; #ifdef _WINDOWS String moduleAPIPath = modulePath + "\\API"; String moduleLibPath = modulePath + "\\Lib"; moduleAPIPath = moduleAPIPath.replace("\\", "/"); moduleAPIPath = moduleAPIPath.substr(2, moduleAPIPath.length() - 2); moduleLibPath = moduleLibPath.replace("\\", "/"); moduleLibPath = moduleLibPath.substr(2, moduleLibPath.length() - 2); #else String moduleAPIPath = modulePath + "/API"; String moduleLibPath = modulePath + "/Lib"; #endif printf("Path:%s\n", moduleAPIPath.c_str()); addFolderToZip(z, moduleAPIPath, "", false); addFolderToZip(z, moduleLibPath, "__lib", false); //String module = configFile.root["entryPoint"]->stringVal; } runInfo.root.addChild(configFile.root["modules"]); } } if(configFile.root["packedItems"]) { ObjectEntry *packed = configFile.root["packedItems"]; if(packed) { for(int i=0; i < packed->length; i++) { ObjectEntry *entryPath = (*(*packed)[i])["path"]; ObjectEntry *entryType = (*(*packed)[i])["type"]; ObjectEntry *entrySource = (*(*packed)[i])["source"]; if(entryPath && entryType) { if (!entrySource) entrySource = entryPath; if(entryType->stringVal == "folder") { addFolderToZip(z, entrySource->stringVal, entryPath->stringVal, false); } else { addFileToZip(z, entrySource->stringVal, entryPath->stringVal, false); } } } runInfo.root.addChild(configFile.root["packedItems"]); } } runInfo.saveToXML("runinfo_tmp_zzzz.polyrun"); addFileToZip(z, "runinfo_tmp_zzzz.polyrun", "runinfo.polyrun", true); //addFolderToZip(z, getArg("--project"), ""); zipClose(z, ""); #ifdef _WINDOWS char *buffer = _getcwd(NULL, 0); String workingDir = String(buffer); free(buffer); OSBasics::removeItem(workingDir+"/runinfo_tmp_zzzz.polyrun"); #else OSBasics::removeItem("runinfo_tmp_zzzz.polyrun"); #endif return 0; }
void EditorFileSystem::_scan_scenes() { ERR_FAIL_COND(!scanning || scandir); //read .fscache HashMap<String,FileCache> file_cache; HashMap<String,DirCache> dir_cache; DirCache *dc=NULL; String cpath; sources_changed.clear(); String project=Globals::get_singleton()->get_resource_path(); FileAccess *f =FileAccess::open(project+"/.fscache",FileAccess::READ); if (f) { //read the disk cache while(!f->eof_reached()) { String l = f->get_line().strip_edges(); if (l==String()) continue; if (l.begins_with("::")) { Vector<String> split = l.split("::"); ERR_CONTINUE( split.size() != 3); String name = split[1]; dir_cache[name]=DirCache(); dc=&dir_cache[name]; dc->modification_time=split[2].to_int64(); if (name!="res://") { cpath=name+"/"; int sp=name.find_last("/"); if (sp==5) sp=6; String pd = name.substr(0,sp); DirCache *dcp = dir_cache.getptr(pd); ERR_CONTINUE(!dcp); dcp->subdirs.insert(name.get_file()); } else { cpath=name; } } else { Vector<String> split = l.split("::"); ERR_CONTINUE( split.size() != 4); String name = split[0]; String file; if (!name.begins_with("res://")) { file=name; name=cpath+name; } else { file=name.get_file(); } FileCache fc; fc.type=split[1]; fc.modification_time=split[2].to_int64(); String meta = split[3].strip_edges(); fc.meta.enabled=false; if (meta.find("<>")!=-1){ Vector<String> spl = meta.split("<>"); int sc = spl.size()-1; if (sc%3==0){ fc.meta.enabled=true; fc.meta.import_editor=spl[0]; fc.meta.sources.resize(sc/3); for(int i=0;i<fc.meta.sources.size();i++) { fc.meta.sources[i].path=spl[1+i*3+0]; fc.meta.sources[i].md5=spl[1+i*3+1]; fc.meta.sources[i].modified_time=spl[1+i*3+2].to_int64(); } } } file_cache[name]=fc; ERR_CONTINUE(!dc); dc->files.insert(file); } } f->close(); memdelete(f); } total=0; DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); //da->change_dir( Globals::get_singleton()->get_resource_path() ); List<String> extensionsl; ResourceLoader::get_recognized_extensions_for_type("",&extensionsl); Set<String> extensions; for(List<String>::Element *E = extensionsl.front();E;E=E->next()) { extensions.insert(E->get()); } EditorProgressBG scan_progress("efs","ScanFS",100); md_count=0; scandir=_scan_dir(da,extensions,"",0,1,"",file_cache,dir_cache,scan_progress); memdelete(da); if (abort_scan && scandir) { memdelete(scandir); scandir=NULL; } //save back the findings f=FileAccess::open(project+"/.fscache",FileAccess::WRITE); _save_type_cache_fs(scandir,f); f->close(); memdelete(f); scanning=false; }
void EditorExportPlatformBB10::_device_poll_thread(void *ud) { EditorExportPlatformBB10 *ea=(EditorExportPlatformBB10 *)ud; while(!ea->quit_request) { String bb_deploy=EditorSettings::get_singleton()->get("export/blackberry/host_tools"); bb_deploy=bb_deploy.plus_file("blackberry-deploy"); bool windows = OS::get_singleton()->get_name()=="Windows"; if (windows) bb_deploy+=".bat"; if (FileAccess::exists(bb_deploy)) { Vector<Device> devices; for (int i=0;i<MAX_DEVICES;i++) { String host = EditorSettings::get_singleton()->get("export/blackberry/device_"+itos(i+1)+"/host"); if (host==String()) continue; String pass = EditorSettings::get_singleton()->get("export/blackberry/device_"+itos(i+1)+"/password"); if (pass==String()) continue; List<String> args; args.push_back("-listDeviceInfo"); args.push_back(host); args.push_back("-password"); args.push_back(pass); int ec; String dp; Error err = OS::get_singleton()->execute(bb_deploy,args,true,NULL,&dp,&ec); if (err==OK && ec==0) { Device dev; dev.index=i; String descr; Vector<String> ls=dp.split("\n"); for(int i=0;i<ls.size();i++) { String l = ls[i].strip_edges(); if (l.begins_with("modelfullname::")) { dev.name=l.get_slice("::",1); descr+="Model: "+dev.name+"\n"; } if (l.begins_with("modelnumber::")) { String s = l.get_slice("::",1); dev.name+=" ("+s+")"; descr+="Model Number: "+s+"\n"; } if (l.begins_with("scmbundle::")) descr+="OS Version: "+l.get_slice("::",1)+"\n"; if (l.begins_with("[n]debug_token_expiration::")) descr+="Debug Token Expires:: "+l.get_slice("::",1)+"\n"; } dev.description=descr; devices.push_back(dev); } } bool changed=false; ea->device_lock->lock(); if (ea->devices.size()!=devices.size()) { changed=true; } else { for(int i=0;i<ea->devices.size();i++) { if (ea->devices[i].index!=devices[i].index) { changed=true; break; } } } if (changed) { ea->devices=devices; ea->devices_changed=true; } ea->device_lock->unlock(); } uint64_t wait = 3000000; uint64_t time = OS::get_singleton()->get_ticks_usec(); while(OS::get_singleton()->get_ticks_usec() - time < wait ) { OS::get_singleton()->delay_usec(1000); if (ea->quit_request) break; } } }
void EditorFileSystem::_scan_filesystem() { ERR_FAIL_COND(!scanning || new_filesystem); //read .fscache String cpath; sources_changed.clear(); file_cache.clear(); String project = ProjectSettings::get_singleton()->get_resource_path(); String fscache = EditorSettings::get_singleton()->get_project_settings_path().plus_file("filesystem_cache3"); FileAccess *f = FileAccess::open(fscache, FileAccess::READ); if (f) { //read the disk cache while (!f->eof_reached()) { String l = f->get_line().strip_edges(); if (l == String()) continue; if (l.begins_with("::")) { Vector<String> split = l.split("::"); ERR_CONTINUE(split.size() != 3); String name = split[1]; cpath = name; } else { Vector<String> split = l.split("::"); ERR_CONTINUE(split.size() != 6); String name = split[0]; String file; file = name; name = cpath.plus_file(name); FileCache fc; fc.type = split[1]; fc.modification_time = split[2].to_int64(); fc.import_modification_time = split[3].to_int64(); fc.import_valid = split[4].to_int64() != 0; String deps = split[5].strip_edges(); if (deps.length()) { Vector<String> dp = deps.split("<>"); for (int i = 0; i < dp.size(); i++) { String path = dp[i]; fc.deps.push_back(path); } } file_cache[name] = fc; } } f->close(); memdelete(f); } String update_cache = EditorSettings::get_singleton()->get_project_settings_path().plus_file("filesystem_update3"); if (FileAccess::exists(update_cache)) { { FileAccessRef f = FileAccess::open(update_cache, FileAccess::READ); String l = f->get_line().strip_edges(); while (l != String()) { file_cache.erase(l); //erase cache for this, so it gets updated l = f->get_line().strip_edges(); } } DirAccessRef d = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); d->remove(update_cache); //bye bye update cache } EditorProgressBG scan_progress("efs", "ScanFS", 1000); ScanProgress sp; sp.low = 0; sp.hi = 1; sp.progress = &scan_progress; new_filesystem = memnew(EditorFileSystemDirectory); new_filesystem->parent = NULL; DirAccess *d = DirAccess::create(DirAccess::ACCESS_RESOURCES); d->change_dir("res://"); _scan_new_dir(new_filesystem, d, sp); file_cache.clear(); //clear caches, no longer needed memdelete(d); f = FileAccess::open(fscache, FileAccess::WRITE); _save_filesystem_cache(new_filesystem, f); f->close(); memdelete(f); scanning = false; }
Vec2i GLContext::drawLabel(const String& str, const Vec4f& pos, const Vec2f& align, U32 fgABGR, U32 bgABGR) { // Split the string into lines. Array<String> lines; str.split('\n', lines, true); while (lines.getSize() && !lines.getLast().getLength()) lines.removeLast(); // Compute metrics. Vec2i strSize = 0; for (int i = 0; i < lines.getSize(); i++) { if (!lines[i].getLength()) lines[i] = " "; // To avoid lineSize.y being zero. Vec2i lineSize = getStringSize(lines[i]); strSize.x = max(strSize.x, lineSize.x); strSize.y += lineSize.y; } // Empty or fully transparent => skip. if (strSize.x <= 0 || strSize.y <= 0 || ((fgABGR | bgABGR) & 0xFF000000) == 0) return strSize; // Initialize GL state. glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT); glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Draw each line. Vec4f fgColor = Vec4f::fromABGR(fgABGR); Vec4f bgColor = Vec4f::fromABGR(bgABGR); Vec2f linePos(0.0f, (F32)strSize.y); for (int i = 0; i < lines.getSize(); i++) { Vec2i lineSize = (lines.getSize() == 1) ? strSize : getStringSize(lines[i]); if (lineSize.x <= 0 || lineSize.y <= 0) continue; linePos.y -= (F32)lineSize.y; const Vec2i& texSize = uploadString(lines[i], lineSize); Vec4f tpos = m_vgXform * pos; Vec2f pixel = m_viewScale * tpos.w; tpos.x += (linePos.x - align.x * (F32)lineSize.x) * pixel.x; tpos.y += (linePos.y - align.y * (F32)strSize.y) * pixel.y; tpos.x = floor((tpos.x + tpos.w) / pixel.x + 0.5f) * pixel.x - tpos.w; tpos.y = floor((tpos.y + tpos.w) / pixel.y + 0.5f) * pixel.y - tpos.w; if (bgColor.w > 0.0f) for (int j = -1; j <= 1; j++) for (int k = -1; k <= 1; k++) drawString(tpos + Vec4f(Vec2f((F32)j, (F32)k) * pixel, 0.0f, 0.0f), lineSize, texSize, bgColor); if (fgColor.w > 0.0f) drawString(tpos, lineSize, texSize, fgColor); } // Clean up. glPopAttrib(); checkErrors(); return strSize; }
void ProjectExportDialog::_edit_preset(int p_index) { if (p_index < 0 || p_index >= presets->get_item_count()) { name->set_text(""); name->set_editable(false); runnable->set_disabled(true); parameters->edit(NULL); delete_preset->set_disabled(true); sections->hide(); patches->clear(); export_error->hide(); export_templates_error->hide(); return; } Ref<EditorExportPreset> current = EditorExport::get_singleton()->get_export_preset(p_index); ERR_FAIL_COND(current.is_null()); updating = true; presets->select(p_index); sections->show(); name->set_editable(true); delete_preset->set_disabled(false); name->set_text(current->get_name()); runnable->set_disabled(false); runnable->set_pressed(current->is_runnable()); parameters->edit(current.ptr()); export_filter->select(current->get_export_filter()); include_filters->set_text(current->get_include_filter()); exclude_filters->set_text(current->get_exclude_filter()); patches->clear(); TreeItem *patch_root = patches->create_item(); Vector<String> patchlist = current->get_patches(); for (int i = 0; i < patchlist.size(); i++) { TreeItem *patch = patches->create_item(patch_root); patch->set_cell_mode(0, TreeItem::CELL_MODE_CHECK); String file = patchlist[i].get_file(); patch->set_editable(0, true); patch->set_text(0, file.get_file().replace("*", "")); if (file.ends_with("*")) patch->set_checked(0, true); patch->set_tooltip(0, patchlist[i]); patch->set_metadata(0, i); patch->add_button(0, get_icon("Remove", "EditorIcons"), 0); patch->add_button(0, get_icon("folder", "FileDialog"), 1); } TreeItem *patch_add = patches->create_item(patch_root); patch_add->set_metadata(0, patchlist.size()); if (patchlist.size() == 0) patch_add->set_text(0, "Add initial export.."); else patch_add->set_text(0, "Add previous patches.."); patch_add->add_button(0, get_icon("folder", "FileDialog"), 1); _fill_resource_tree(); bool needs_templates; String error; if (!current->get_platform()->can_export(current, error, needs_templates)) { if (error != String()) { Vector<String> items = error.split("\n"); error = ""; for (int i = 0; i < items.size(); i++) { if (i > 0) error += "\n"; error += " - " + items[i]; } export_error->set_text(error); export_error->show(); } else { export_error->hide(); } if (needs_templates) export_templates_error->show(); else export_templates_error->hide(); export_button->set_disabled(true); } else { export_error->hide(); export_templates_error->hide(); export_button->set_disabled(false); } custom_features->set_text(current->get_custom_features()); _update_feature_list(); updating = false; }
Material *MaterialManager::materialFromXMLNode(TiXmlNode *node) { String mname = node->ToElement()->Attribute("name"); TiXmlNode* pChild, *pChild2,*pChild3; Shader *materialShader; ShaderBinding *newShaderBinding; vector<Shader*> materialShaders; vector<ShaderBinding*> newShaderBindings; vector<ShaderRenderTarget*> renderTargets; Material *newMaterial = new Material(mname); for (pChild3 = node->FirstChild(); pChild3 != 0; pChild3 = pChild3->NextSibling()) { if(strcmp(pChild3->Value(), "rendertargets") == 0) { for (pChild = pChild3->FirstChild(); pChild != 0; pChild = pChild->NextSibling()) { if(strcmp(pChild->Value(), "rendertarget") == 0) { ShaderRenderTarget *newTarget = new ShaderRenderTarget; newTarget->id = pChild->ToElement()->Attribute("id"); newTarget->width = CoreServices::getInstance()->getRenderer()->getXRes(); newTarget->height = CoreServices::getInstance()->getRenderer()->getYRes(); newTarget->sizeMode = ShaderRenderTarget::SIZE_MODE_PIXELS; if(pChild->ToElement()->Attribute("width") && pChild->ToElement()->Attribute("height")) { newTarget->width = atof(pChild->ToElement()->Attribute("width")); newTarget->height = atof(pChild->ToElement()->Attribute("height")); if(pChild->ToElement()->Attribute("sizeMode")) { if(strcmp(pChild->ToElement()->Attribute("sizeMode"), "normalized") == 0) { if(newTarget->width > 1.0f) newTarget->width = 1.0f; if(newTarget->height > 1.0f) newTarget->height = 1.0f; newTarget->width = ((Number)CoreServices::getInstance()->getRenderer()->getXRes()) * newTarget->width; newTarget->height = ((Number)CoreServices::getInstance()->getRenderer()->getYRes()) * newTarget->height; } } } // Texture *newTexture = CoreServices::getInstance()->getMaterialManager()->createNewTexture(newTarget->width, newTarget->height, true); Texture *newTexture, *temp; CoreServices::getInstance()->getRenderer()->createRenderTextures(&newTexture, &temp, (int)newTarget->width, (int)newTarget->height); newTexture->setResourceName(newTarget->id); //CoreServices::getInstance()->getResourceManager()->addResource(newTexture); newTarget->texture = newTexture; renderTargets.push_back(newTarget); } } } } for (pChild3 = node->FirstChild(); pChild3 != 0; pChild3 = pChild3->NextSibling()) { if(strcmp(pChild3->Value(), "specularValue") == 0) { newMaterial->specularValue = atof(pChild3->ToElement()->GetText()); } if(strcmp(pChild3->Value(), "specularColor") == 0) { String value = pChild3->ToElement()->GetText(); vector<String> values = value.split(" "); if(values.size() == 4) { newMaterial->specularColor.setColor(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str()),atof(values[3].c_str())); } else { Logger::log("Error: Incorrect number of values for specularColor (%d provided)!\n", values.size()); } } if(strcmp(pChild3->Value(), "diffuseColor") == 0) { String value = pChild3->ToElement()->GetText(); vector<String> values = value.split(" "); if(values.size() == 4) { newMaterial->diffuseColor.setColor(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str()),atof(values[3].c_str())); } else { Logger::log("Error: Incorrect number of values for diffuseColor (%d provided)!\n", values.size()); } } if(strcmp(pChild3->Value(), "shader") == 0) { materialShader = setShaderFromXMLNode(pChild3); if(materialShader) { newShaderBinding = materialShader->createBinding(); materialShaders.push_back(materialShader); newShaderBindings.push_back(newShaderBinding); for (pChild = pChild3->FirstChild(); pChild != 0; pChild = pChild->NextSibling()) { if(strcmp(pChild->Value(), "params") == 0) { for (pChild2 = pChild->FirstChild(); pChild2 != 0; pChild2 = pChild2->NextSibling()) { if(strcmp(pChild2->Value(), "param") == 0){ String pname = pChild2->ToElement()->Attribute("name"); String ptype = pChild2->ToElement()->Attribute("type"); String pvalue = pChild2->ToElement()->Attribute("value"); newShaderBinding->addParam(ptype, pname, pvalue); } } } if(strcmp(pChild->Value(), "targettextures") == 0) { for (pChild2 = pChild->FirstChild(); pChild2 != 0; pChild2 = pChild2->NextSibling()) { if(strcmp(pChild2->Value(), "targettexture") == 0){ RenderTargetBinding* newBinding = new RenderTargetBinding; newBinding->id = pChild2->ToElement()->Attribute("id"); newBinding->name = ""; if(pChild2->ToElement()->Attribute("name")) { newBinding->name = pChild2->ToElement()->Attribute("name"); } String mode = pChild2->ToElement()->Attribute("mode"); if(strcmp(mode.c_str(), "in") == 0) { newBinding->mode = RenderTargetBinding::MODE_IN; } else { newBinding->mode = RenderTargetBinding::MODE_OUT; } newShaderBinding->addRenderTargetBinding(newBinding); //Texture *texture = (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, newBinding->id); // newBinding->texture = texture; for(int l=0; l < renderTargets.size(); l++) { if(renderTargets[l]->id == newBinding->id) { printf("Assigning texture to %s\n", newBinding->id.c_str()); newBinding->texture = renderTargets[l]->texture; newBinding->width = renderTargets[l]->width; newBinding->height = renderTargets[l]->height; } } if(newBinding->mode == RenderTargetBinding::MODE_IN) { newShaderBinding->addTexture(newBinding->name, newBinding->texture); } } } } if(strcmp(pChild->Value(), "textures") == 0) { for (pChild2 = pChild->FirstChild(); pChild2 != 0; pChild2 = pChild2->NextSibling()) { if(strcmp(pChild2->Value(), "texture") == 0){ String tname = ""; if(pChild2->ToElement()->Attribute("name")) { tname = pChild2->ToElement()->Attribute("name"); } newShaderBinding->addTexture(tname, (Texture*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_TEXTURE, pChild2->ToElement()->GetText())); } if(strcmp(pChild2->Value(), "cubemap") == 0){ String tname = ""; if(pChild2->ToElement()->Attribute("name")) { tname = pChild2->ToElement()->Attribute("name"); } newShaderBinding->addCubemap(tname, (Cubemap*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_CUBEMAP, pChild2->ToElement()->GetText())); } } } } } } } for(int i=0; i< materialShaders.size(); i++) { newMaterial->addShader(materialShaders[i],newShaderBindings[i]); } for(int i=0; i< renderTargets.size(); i++) { newMaterial->addShaderRenderTarget(renderTargets[i]); } return newMaterial; }
Error HTTPClient::poll(){ switch(status) { case STATUS_RESOLVING: { ERR_FAIL_COND_V(resolving==IP::RESOLVER_INVALID_ID,ERR_BUG); IP::ResolverStatus rstatus = IP::get_singleton()->get_resolve_item_status(resolving); switch(rstatus) { case IP::RESOLVER_STATUS_WAITING: return OK; //still resolving case IP::RESOLVER_STATUS_DONE: { IP_Address host = IP::get_singleton()->get_resolve_item_address(resolving); Error err = tcp_connection->connect(host,conn_port); IP::get_singleton()->erase_resolve_item(resolving); resolving=IP::RESOLVER_INVALID_ID; if (err) { status=STATUS_CANT_CONNECT; return err; } status=STATUS_CONNECTING; } break; case IP::RESOLVER_STATUS_NONE: case IP::RESOLVER_STATUS_ERROR: { IP::get_singleton()->erase_resolve_item(resolving); resolving=IP::RESOLVER_INVALID_ID; close(); status=STATUS_CANT_RESOLVE; return ERR_CANT_RESOLVE; } break; } } break; case STATUS_CONNECTING: { StreamPeerTCP::Status s = tcp_connection->get_status(); switch(s) { case StreamPeerTCP::STATUS_CONNECTING: { return OK; //do none } break; case StreamPeerTCP::STATUS_CONNECTED: { status=STATUS_CONNECTED; return OK; } break; case StreamPeerTCP::STATUS_ERROR: case StreamPeerTCP::STATUS_NONE: { close(); status=STATUS_CANT_CONNECT; return ERR_CANT_CONNECT; } break; } } break; case STATUS_CONNECTED: { //request something please return OK; } break; case STATUS_REQUESTING: { while(true) { uint8_t byte; int rec=0; Error err = connection->get_partial_data(&byte,1,rec); if (err!=OK) { close(); status=STATUS_CONNECTION_ERROR; return ERR_CONNECTION_ERROR; } if (rec==0) return OK; //keep trying! response_str.push_back(byte); int rs = response_str.size(); if ( (rs>=2 && response_str[rs-2]=='\n' && response_str[rs-1]=='\n') || (rs>=4 && response_str[rs-4]=='\r' && response_str[rs-3]=='\n' && rs>=4 && response_str[rs-2]=='\r' && response_str[rs-1]=='\n') ) { //end of response, parse. response_str.push_back(0); String response; response.parse_utf8((const char*)response_str.ptr()); print_line("END OF RESPONSE? :\n"+response+"\n------"); Vector<String> responses = response.split("\n"); body_size=0; chunked=false; body_left=0; chunk_left=0; response_headers.clear(); response_num = RESPONSE_OK; for(int i=0;i<responses.size();i++) { String s = responses[i].strip_edges(); if (s.length()==0) continue; if (s.begins_with("Content-Length:")) { body_size = s.substr(s.find(":")+1,s.length()).strip_edges().to_int(); body_left=body_size; } if (s.begins_with("Transfer-Encoding:")) { String encoding = s.substr(s.find(":")+1,s.length()).strip_edges(); print_line("TRANSFER ENCODING: "+encoding); if (encoding=="chunked") { chunked=true; } } if (i==0 && responses[i].begins_with("HTTP")) { String num = responses[i].get_slice(" ",1); response_num=num.to_int(); } else { response_headers.push_back(s); } } if (body_size==0 && !chunked) { status=STATUS_CONNECTED; //ask for something again? } else { status=STATUS_BODY; } return OK; } } //wait for response return OK; } break; case STATUS_DISCONNECTED: { return ERR_UNCONFIGURED; } break; case STATUS_CONNECTION_ERROR: { return ERR_CONNECTION_ERROR; } break; case STATUS_CANT_CONNECT: { return ERR_CANT_CONNECT; } break; case STATUS_CANT_RESOLVE: { return ERR_CANT_RESOLVE; } break; } return OK; }
void List::loadFromPath(const String& folder) { String path; IO::Canonicalize(path, folder); if (pOptDebug) std::cout << "[yuni-config][debug] :: reading `" << path << "`" << std::endl; VersionInfo::Settings info; info.mapping = mappingStandard; String s; s << path << SEP << "yuni.version"; if (not IO::File::Exists(s)) { s.clear() << path << SEP << "include" << SEP << "yuni" << SEP << "yuni.version"; if (not IO::File::Exists(s)) { info.mapping = mappingSVNSources; s.clear() << path << SEP << "src" << SEP << "yuni" << SEP << "yuni.version"; if (not IO::File::Exists(s)) { if (pOptDebug) std::cout << "[yuni-config][debug] :: " << s << " not found" << std::endl; return; } } } IO::File::Stream file; if (file.open(s)) { String key; String value; Version version; // A buffer. The given capacity will be the maximum length for a single line Clob buffer; buffer.reserve(8000); while (file.readline(buffer)) { buffer.extractKeyValue(key, value); if (key.empty() || key == "[") continue; if (key == "version.hi") version.hi = value.to<unsigned int>(); if (key == "version.lo") version.lo = value.to<unsigned int>(); if (key == "version.rev") version.revision = value.to<unsigned int>(); if (key == "version.target") info.compilationMode = value; if (key == "modules.available") value.split(info.modules, ";\"', \t", false); if (key == "support.opengl") info.supportOpenGL = value.to<bool>(); if (key == "support.directx") info.supportDirectX = value.to<bool>(); if (key == "redirect") loadFromPath(value); if (key == "path.include") { if (not value.empty()) info.includePath.push_back(value); } if (key == "path.lib") { if (not value.empty()) info.libPath.push_back(value); } } if (not version.null() and not info.modules.empty()) { info.path = path; info.compiler = pCompiler; pList[version] = info; if (pOptDebug) { std::cout << "[yuni-config][debug] - found installation `" << path << "` (" << version << ")" << std::endl; } } else { std::cerr << "error: " << s << ": invalid file"; if (version.null()) std::cerr << " (invalid version)" << std::endl; else if (info.modules.empty()) std::cerr << " (no module)" << std::endl; } } }
int main(int argc, char** argv) { RemoveCrashDump removeCrashDump; #ifdef OS_Darwin struct rlimit rlp; if (getrlimit(RLIMIT_NOFILE, &rlp) == 0) { if (rlp.rlim_cur < 1000) { rlp.rlim_cur = 1000; setrlimit(RLIMIT_NOFILE, &rlp); } } #endif { pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_getstacksize(&attr, &defaultStackSize); pthread_attr_destroy(&attr); if (defaultStackSize < 1024 * 1024 * 4) { // 4 megs should be enough for everyone right? defaultStackSize = 1024 * 1024 * 4; } } Rct::findExecutablePath(*argv); struct option opts[] = { { "help", no_argument, 0, 'h' }, { "version", no_argument, 0, 2 }, { "include-path", required_argument, 0, 'I' }, { "isystem", required_argument, 0, 's' }, { "define", required_argument, 0, 'D' }, { "log-file", required_argument, 0, 'L' }, { "crash-dump-file", required_argument, 0, 19 }, { "setenv", required_argument, 0, 'e' }, { "no-Wall", no_argument, 0, 'W' }, { "Weverything", no_argument, 0, 'u' }, { "cache-AST", required_argument, 0, 'A' }, { "verbose", no_argument, 0, 'v' }, { "job-count", required_argument, 0, 'j' }, { "header-error-job-count", required_argument, 0, 'H' }, { "test", required_argument, 0, 't' }, { "test-timeout", required_argument, 0, 'z' }, { "clean-slate", no_argument, 0, 'C' }, { "disable-sighandler", no_argument, 0, 'x' }, { "silent", no_argument, 0, 'S' }, { "exclude-filter", required_argument, 0, 'X' }, { "socket-file", required_argument, 0, 'n' }, { "config", required_argument, 0, 'c' }, { "no-rc", no_argument, 0, 'N' }, { "data-dir", required_argument, 0, 'd' }, { "ignore-printf-fixits", no_argument, 0, 'F' }, { "no-unlimited-errors", no_argument, 0, 'f' }, { "block-argument", required_argument, 0, 'G' }, { "no-spell-checking", no_argument, 0, 'l' }, { "large-by-value-copy", required_argument, 0, 'r' }, { "disallow-multiple-sources", no_argument, 0, 'm' }, { "no-startup-project", no_argument, 0, 'o' }, { "no-no-unknown-warnings-option", no_argument, 0, 'Y' }, { "ignore-compiler", required_argument, 0, 'b' }, { "watch-system-paths", no_argument, 0, 'w' }, { "rp-visit-file-timeout", required_argument, 0, 'Z' }, { "rp-indexer-message-timeout", required_argument, 0, 'T' }, { "rp-connect-timeout", required_argument, 0, 'O' }, { "rp-connect-attempts", required_argument, 0, 3 }, { "rp-nice-value", required_argument, 0, 'a' }, { "thread-stack-size", required_argument, 0, 'k' }, { "suspend-rp-on-crash", no_argument, 0, 'q' }, { "rp-log-to-syslog", no_argument, 0, 7 }, { "start-suspended", no_argument, 0, 'Q' }, { "separate-debug-and-release", no_argument, 0, 'E' }, { "max-crash-count", required_argument, 0, 'K' }, { "completion-cache-size", required_argument, 0, 'i' }, { "completion-no-filter", no_argument, 0, 8 }, { "extra-compilers", required_argument, 0, 'U' }, { "allow-Wpedantic", no_argument, 0, 'P' }, { "enable-compiler-manager", no_argument, 0, 'R' }, { "enable-NDEBUG", no_argument, 0, 'g' }, { "progress", no_argument, 0, 'p' }, { "max-file-map-cache-size", required_argument, 0, 'y' }, #ifdef OS_FreeBSD { "filemanager-watch", no_argument, 0, 'M' }, #else { "no-filemanager-watch", no_argument, 0, 'M' }, #endif { "no-filemanager", no_argument, 0, 15 }, { "no-file-lock", no_argument, 0, 13 }, { "pch-enabled", no_argument, 0, 14 }, { "no-filesystem-watcher", no_argument, 0, 'B' }, { "arg-transform", required_argument, 0, 'V' }, { "no-comments", no_argument, 0, 1 }, #ifdef RTAGS_HAS_LAUNCHD { "launchd", no_argument, 0, 4 }, #endif { "inactivity-timeout", required_argument, 0, 5 }, { "daemon", no_argument, 0, 6 }, { "log-file-log-level", required_argument, 0, 9 }, { "watch-sources-only", no_argument, 0, 10 }, { "debug-locations", no_argument, 0, 11 }, { "validate-file-maps", no_argument, 0, 16 }, { "tcp-port", required_argument, 0, 12 }, { "rp-path", required_argument, 0, 17 }, { "log-timestamp", no_argument, 0, 18 }, { "root", required_argument, 0, 20 }, { 0, 0, 0, 0 } }; const String shortOptions = Rct::shortOptions(opts); if (getenv("RTAGS_DUMP_UNUSED")) { String unused; for (int i=0; i<26; ++i) { if (!shortOptions.contains('a' + i)) unused.append('a' + i); if (!shortOptions.contains('A' + i)) unused.append('A' + i); } printf("Unused: %s\n", unused.constData()); for (int i=0; opts[i].name; ++i) { if (opts[i].name) { if (!opts[i].val) { printf("No shortoption for %s\n", opts[i].name); } else if (opts[i].name[0] != opts[i].val) { printf("Not ideal option for %s|%c\n", opts[i].name, opts[i].val); } } } return 0; } bool daemon = false; List<String> argCopy; List<char*> argList; { bool norc = false; Path rcfile = Path::home() + ".rdmrc"; opterr = 0; StackBuffer<128, char*> originalArgv(argc); memcpy(originalArgv, argv, sizeof(char*) * argc); /* getopt will molest argv by moving pointers around when it sees * fit. Their idea of an optional argument is different from ours so we * have to take a copy of argv before they get their sticky fingers all * over it. * * We think this should be okay for an optional argument: * -s something * * They only populate optarg if you do: * -ssomething. * * We don't want to copy argv into argList before processing rc files * since command line args should take precedence over things in rc * files. * */ while (true) { const int c = getopt_long(argc, argv, shortOptions.constData(), opts, 0); if (c == -1) break; switch (c) { case 'N': norc = true; break; case 'c': rcfile = optarg; break; default: break; } } opterr = 1; argList.append(argv[0]); if (!norc) { String rc = Path("/etc/rdmrc").readAll(); if (!rc.isEmpty()) { for (const String& s : rc.split('\n')) { if (!s.isEmpty() && !s.startsWith('#')) argCopy += s.split(' '); } } if (!rcfile.isEmpty()) { rc = rcfile.readAll(); if (!rc.isEmpty()) { for (const String& s : rc.split('\n')) { if (!s.isEmpty() && !s.startsWith('#')) argCopy += s.split(' '); } } } const int s = argCopy.size(); for (int i=0; i<s; ++i) { String &arg = argCopy.at(i); if (!arg.isEmpty()) argList.append(arg.data()); } } for (int i=1; i<argc; ++i) argList.append(originalArgv[i]); optind = 1; } Server::Options serverOpts; serverOpts.threadStackSize = defaultStackSize; serverOpts.socketFile = String::format<128>("%s.rdm", Path::home().constData()); serverOpts.jobCount = std::max(2, ThreadPool::idealThreadCount()); serverOpts.headerErrorJobCount = -1; serverOpts.rpVisitFileTimeout = DEFAULT_RP_VISITFILE_TIMEOUT; serverOpts.rpIndexDataMessageTimeout = DEFAULT_RP_INDEXER_MESSAGE_TIMEOUT; serverOpts.rpConnectTimeout = DEFAULT_RP_CONNECT_TIMEOUT; serverOpts.rpConnectAttempts = DEFAULT_RP_CONNECT_ATTEMPTS; serverOpts.maxFileMapScopeCacheSize = DEFAULT_RDM_MAX_FILE_MAP_CACHE_SIZE; serverOpts.rpNiceValue = INT_MIN; serverOpts.options = Server::Wall|Server::SpellChecking; serverOpts.maxCrashCount = DEFAULT_MAX_CRASH_COUNT; serverOpts.completionCacheSize = DEFAULT_COMPLETION_CACHE_SIZE; serverOpts.rp = defaultRP(); strcpy(crashDumpFilePath, "crash.dump"); #ifdef OS_FreeBSD serverOpts.options |= Server::NoFileManagerWatch; #endif // #ifndef NDEBUG // serverOpts.options |= Server::SuspendRPOnCrash; // #endif serverOpts.dataDir = String::format<128>("%s.rtags", Path::home().constData()); const char *logFile = 0; Flags<LogFlag> logFlags = DontRotate|LogStderr; LogLevel logLevel(LogLevel::Error); LogLevel logFileLogLevel(LogLevel::Error); bool sigHandler = true; assert(Path::home().endsWith('/')); int argCount = argList.size(); char **args = argList.data(); bool defaultDataDir = true; int inactivityTimeout = 0; while (true) { const int c = getopt_long(argCount, args, shortOptions.constData(), opts, 0); if (c == -1) break; switch (c) { case 'N': case 'c': // ignored break; case 'S': logLevel = LogLevel::None; break; case 'X': serverOpts.excludeFilters += String(optarg).split(';'); break; case 'G': serverOpts.blockedArguments << optarg; break; case 1: serverOpts.options |= Server::NoComments; break; case 10: serverOpts.options |= Server::WatchSourcesOnly; break; case 11: if (!strcmp(optarg, "clear") || !strcmp(optarg, "none")) { serverOpts.debugLocations.clear(); } else { serverOpts.debugLocations << optarg; } break; case 12: serverOpts.tcpPort = atoi(optarg); if (!serverOpts.tcpPort) { fprintf(stderr, "Invalid port %s for --tcp-port\n", optarg); return 1; } break; case 13: serverOpts.options |= Server::NoFileLock; break; case 14: serverOpts.options |= Server::PCHEnabled; break; case 15: serverOpts.options |= Server::NoFileManager; break; case 16: serverOpts.options |= Server::ValidateFileMaps; break; case 17: serverOpts.rp = optarg; if (serverOpts.rp.isFile()) serverOpts.rp.resolve(); break; case 18: logFlags |= LogTimeStamp; break; case 19: strcpy(crashDumpFilePath, optarg); break; case 20: serverOpts.root = optarg; if (!serverOpts.root.resolve() || !serverOpts.root.isDir()) { fprintf(stderr, "%s is not a directory\n", optarg); return 1; } break; case 2: fprintf(stdout, "%s\n", RTags::versionString().constData()); return 0; case 6: daemon = true; logLevel = LogLevel::None; break; case 9: if (!strcasecmp(optarg, "verbose-debug")) { logFileLogLevel = LogLevel::VerboseDebug; } else if (!strcasecmp(optarg, "debug")) { logFileLogLevel = LogLevel::Debug; } else if (!strcasecmp(optarg, "warning")) { logFileLogLevel = LogLevel::Warning; } else if (!strcasecmp(optarg, "error")) { logFileLogLevel = LogLevel::Error; } else { fprintf(stderr, "Unknown log level: %s options are error, warning, debug or verbose-debug\n", optarg); return 1; } break; case 'U': serverOpts.extraCompilers.append(std::regex(optarg)); break; case 'E': serverOpts.options |= Server::SeparateDebugAndRelease; break; case 'g': serverOpts.options |= Server::EnableNDEBUG; break; case 'Q': serverOpts.options |= Server::StartSuspended; break; case 'Z': serverOpts.rpVisitFileTimeout = atoi(optarg); if (serverOpts.rpVisitFileTimeout < 0) { fprintf(stderr, "Invalid argument to -Z %s\n", optarg); return 1; } if (!serverOpts.rpVisitFileTimeout) serverOpts.rpVisitFileTimeout = -1; break; case 'y': serverOpts.maxFileMapScopeCacheSize = atoi(optarg); if (serverOpts.maxFileMapScopeCacheSize <= 0) { fprintf(stderr, "Invalid argument to -y %s\n", optarg); return 1; } break; case 'O': serverOpts.rpConnectTimeout = atoi(optarg); if (serverOpts.rpConnectTimeout < 0) { fprintf(stderr, "Invalid argument to -O %s\n", optarg); return 1; } break; case 3: serverOpts.rpConnectAttempts = atoi(optarg); if (serverOpts.rpConnectAttempts <= 0) { fprintf(stderr, "Invalid argument to --rp-connect-attempts %s\n", optarg); return 1; } break; case 'k': serverOpts.threadStackSize = atoi(optarg); if (serverOpts.threadStackSize < 0) { fprintf(stderr, "Invalid argument to -k %s\n", optarg); return 1; } break; case 'b': serverOpts.ignoredCompilers.insert(Path::resolved(optarg)); break; case 't': { Path test(optarg); if (!test.resolve() || !test.isFile()) { fprintf(stderr, "%s doesn't seem to be a file\n", optarg); return 1; } serverOpts.tests += test; break; } case 'z': serverOpts.testTimeout = atoi(optarg); if (serverOpts.testTimeout <= 0) { fprintf(stderr, "Invalid argument to -z %s\n", optarg); return 1; } break; case 'n': serverOpts.socketFile = optarg; break; case 'd': defaultDataDir = false; serverOpts.dataDir = String::format<128>("%s", Path::resolved(optarg).constData()); break; case 'h': usage(stdout); return 0; case 'Y': serverOpts.options |= Server::NoNoUnknownWarningsOption; break; case 'p': serverOpts.options |= Server::Progress; break; case 'R': serverOpts.options |= Server::EnableCompilerManager; break; case 'm': serverOpts.options |= Server::DisallowMultipleSources; break; case 'o': serverOpts.options |= Server::NoStartupCurrentProject; break; case 'w': serverOpts.options |= Server::WatchSystemPaths; break; case 'q': serverOpts.options |= Server::SuspendRPOnCrash; break; case 'M': #ifdef OS_FreeBSD serverOpts.options &= ~Server::NoFileManagerWatch; #else serverOpts.options |= Server::NoFileManagerWatch; #endif break; case 'B': serverOpts.options |= Server::NoFileSystemWatch; break; case 'V': serverOpts.argTransform = Process::findCommand(optarg); if (strlen(optarg) && serverOpts.argTransform.isEmpty()) { fprintf(stderr, "Invalid argument to -V. Can't resolve %s", optarg); return 1; } break; case 'F': serverOpts.options |= Server::IgnorePrintfFixits; break; case 'f': serverOpts.options |= Server::NoUnlimitedErrors; break; case 'l': serverOpts.options &= ~Server::SpellChecking; break; case 'W': serverOpts.options &= ~Server::Wall; break; case 'u': serverOpts.options |= Server::Weverything; break; case 'P': serverOpts.options |= Server::AllowPedantic; break; case 'C': serverOpts.options |= Server::ClearProjects; break; case 'e': putenv(optarg); break; case 'x': sigHandler = false; break; case 'K': serverOpts.maxCrashCount = atoi(optarg); if (serverOpts.maxCrashCount <= 0) { fprintf(stderr, "Invalid argument to -K %s\n", optarg); return 1; } break; case 'i': serverOpts.completionCacheSize = atoi(optarg); if (serverOpts.completionCacheSize <= 0) { fprintf(stderr, "Invalid argument to -i %s\n", optarg); return 1; } break; case 'T': serverOpts.rpIndexDataMessageTimeout = atoi(optarg); if (serverOpts.rpIndexDataMessageTimeout <= 0) { fprintf(stderr, "Can't parse argument to -T %s.\n", optarg); return 1; } break; case 'a': { bool ok; serverOpts.rpNiceValue = String(optarg).toLong(&ok); if (!ok) { fprintf(stderr, "Can't parse argument to -a %s.\n", optarg); return 1; } break; } case 'j': { bool ok; serverOpts.jobCount = String(optarg).toULong(&ok); if (!ok) { fprintf(stderr, "Can't parse argument to -j %s. -j must be a positive integer.\n", optarg); return 1; } break; } case 'H': { bool ok; serverOpts.headerErrorJobCount = String(optarg).toULong(&ok); if (!ok) { fprintf(stderr, "Can't parse argument to -H %s. -H must be a positive integer.\n", optarg); return 1; } break; } case 'r': { int large = atoi(optarg); if (large <= 0) { fprintf(stderr, "Can't parse argument to -r %s\n", optarg); return 1; } serverOpts.defaultArguments.append("-Wlarge-by-value-copy=" + String(optarg)); // ### not quite working break; } case 'D': { const char *eq = strchr(optarg, '='); Source::Define def; if (!eq) { def.define = optarg; } else { def.define = String(optarg, eq - optarg); def.value = eq + 1; } serverOpts.defines.append(def); break; } case 'I': serverOpts.includePaths.append(Source::Include(Source::Include::Type_Include, Path::resolved(optarg))); break; case 's': serverOpts.includePaths.append(Source::Include(Source::Include::Type_System, Path::resolved(optarg))); break; case 'L': logFile = optarg; logLevel = LogLevel::None; break; case 'v': if (logLevel != LogLevel::None) ++logLevel; break; #ifdef RTAGS_HAS_LAUNCHD case 4: serverOpts.options |= Server::Launchd; break; #endif case 5: inactivityTimeout = atoi(optarg); // seconds. if (inactivityTimeout <= 0) { fprintf(stderr, "Invalid argument to --inactivity-timeout %s\n", optarg); return 1; } break; case 7: serverOpts.options |= Server::RPLogToSyslog; break; case 8: serverOpts.options |= Server::CompletionsNoFilter; break; case '?': { fprintf(stderr, "Run rdm --help for help\n"); return 1; } } } if (optind < argCount) { fprintf(stderr, "rdm: unexpected option -- '%s'\n", args[optind]); return 1; } if (daemon) { switch (fork()) { case -1: fprintf(stderr, "Failed to fork (%d) %s\n", errno, strerror(errno)); return 1; case 0: setsid(); switch (fork()) { case -1: fprintf(stderr, "Failed to fork (%d) %s\n", errno, strerror(errno)); return 1; case 0: break; default: return 0; } break; default: return 0; } } if (serverOpts.excludeFilters.isEmpty()) serverOpts.excludeFilters = String(EXCLUDEFILTER_DEFAULT).split(';'); if (!serverOpts.headerErrorJobCount) { serverOpts.headerErrorJobCount = std::max<size_t>(1, serverOpts.jobCount / 2); } else { serverOpts.headerErrorJobCount = std::min(serverOpts.headerErrorJobCount, serverOpts.jobCount); } if (sigHandler) { signal(SIGSEGV, signalHandler); signal(SIGBUS, signalHandler); signal(SIGILL, signalHandler); signal(SIGABRT, signalHandler); } // Shell-expand logFile Path logPath(logFile); logPath.resolve(); if (!initLogging(argv[0], logFlags, logLevel, logPath.constData(), logFileLogLevel)) { fprintf(stderr, "Can't initialize logging with %d %s %s\n", logLevel.toInt(), logFile ? logFile : "", logFlags.toString().constData()); return 1; } #ifdef RTAGS_HAS_LAUNCHD if (serverOpts.options & Server::Launchd) { // Clamp inactivity timeout. launchd starts to worry if the // process runs for less than 10 seconds. static const int MIN_INACTIVITY_TIMEOUT = 15; // includes // fudge factor. if (inactivityTimeout < MIN_INACTIVITY_TIMEOUT) { inactivityTimeout = MIN_INACTIVITY_TIMEOUT; fprintf(stderr, "launchd mode - clamped inactivity timeout to %d to avoid launchd warnings.\n", inactivityTimeout); } } #endif EventLoop::SharedPtr loop(new EventLoop); loop->init(EventLoop::MainEventLoop|EventLoop::EnableSigIntHandler|EventLoop::EnableSigTermHandler); std::shared_ptr<Server> server(new Server); if (!serverOpts.tests.isEmpty()) { char buf[1024]; Path path; while (true) { strcpy(buf, "/tmp/rtags-test-XXXXXX"); if (!mkdtemp(buf)) { fprintf(stderr, "Failed to mkdtemp (%d)\n", errno); return 1; } path = buf; path.resolve(); break; } serverOpts.dataDir = path; strcpy(buf, "/tmp/rtags-sock-XXXXXX"); const int fd = mkstemp(buf); if (fd == -1) { fprintf(stderr, "Failed to mkstemp (%d)\n", errno); return 1; } close(fd); serverOpts.socketFile = buf; serverOpts.socketFile.resolve(); } if (defaultDataDir) { Path migration = String::format<128>("%s.rtags-file", Path::home().constData()); if (migration.isDir()) { Rct::removeDirectory(serverOpts.dataDir); rename(migration.constData(), serverOpts.dataDir.constData()); error() << "Migrated datadir from ~/.rtags-file ~/.rtags"; } } serverOpts.dataDir = serverOpts.dataDir.ensureTrailingSlash(); #ifdef HAVE_BACKTRACE if (strlen(crashDumpFilePath)) { if (crashDumpFilePath[0] != '/') { const String f = crashDumpFilePath; snprintf(crashDumpFilePath, sizeof(crashDumpFilePath), "%s%s", serverOpts.dataDir.constData(), f.constData()); } snprintf(crashDumpTempFilePath, sizeof(crashDumpTempFilePath), "%s.tmp", crashDumpFilePath); Path::mkdir(serverOpts.dataDir); crashDumpFile = fopen(crashDumpTempFilePath, "w"); if (!crashDumpFile) { fprintf(stderr, "Couldn't open temp file %s for write (%d)", crashDumpTempFilePath, errno); return 1; } } #endif if (!server->init(serverOpts)) { cleanupLogging(); return 1; } if (!serverOpts.tests.isEmpty()) { return server->runTests() ? 0 : 1; } loop->setInactivityTimeout(inactivityTimeout * 1000); loop->exec(); const int ret = server->exitCode(); server.reset(); cleanupLogging(); return ret; }
static void engine_handle_cmd(struct android_app* app, int32_t cmd) { struct engine* engine = (struct engine*)app->userData; // LOGI("**** CMD %i\n",cmd); switch (cmd) { case APP_CMD_SAVE_STATE: // The system has asked us to save our current state. Do so. //engine->app->savedState = malloc(sizeof(struct saved_state)); //*((struct saved_state*)engine->app->savedState) = engine->state; //engine->app->savedStateSize = sizeof(struct saved_state); break; case APP_CMD_CONFIG_CHANGED: case APP_CMD_WINDOW_RESIZED: { #if 0 // android blows if (engine->display_active) { EGLint w,h; eglQuerySurface(engine->display, engine->surface, EGL_WIDTH, &w); eglQuerySurface(engine->display, engine->surface, EGL_HEIGHT, &h); engine->os->init_video_mode(w,h); //print_line("RESIZED VIDEO MODE: "+itos(w)+","+itos(h)); engine_draw_frame(engine); } #else if (engine->display_active) { EGLint w,h; eglQuerySurface(engine->display, engine->surface, EGL_WIDTH, &w); eglQuerySurface(engine->display, engine->surface, EGL_HEIGHT, &h); // if (w==engine->os->get_video_mode().width && h==engine->os->get_video_mode().height) // break; engine_term_display(engine); } engine->os->reload_gfx(); engine_draw_frame(engine); engine->animating=1; /* EGLint w,h; eglQuerySurface(engine->display, engine->surface, EGL_WIDTH, &w); eglQuerySurface(engine->display, engine->surface, EGL_HEIGHT, &h); engine->os->init_video_mode(w,h); //print_line("RESIZED VIDEO MODE: "+itos(w)+","+itos(h)); }*/ #endif } break; case APP_CMD_INIT_WINDOW: //The window is being shown, get it ready. // LOGI("INIT WINDOW"); if (engine->app->window != NULL) { if (engine->os==NULL) { //do initialization here, when there's OpenGL! hackish but the only way engine->os = new OS_Android(_gfx_init,engine); // char *args[]={"-test","gui",NULL}; __android_log_print(ANDROID_LOG_INFO,"godot","pre asdasd setup..."); #if 0 Error err = Main::setup("apk",2,args); #else Error err = Main::setup("apk",0,NULL); String modules = GlobalConfig::get_singleton()->get("android/modules"); Vector<String> mods = modules.split(",",false); mods.push_back("GodotOS"); __android_log_print(ANDROID_LOG_INFO,"godot","mod count: %i",mods.size()); if (mods.size()) { jclass activityClass = engine->jni->FindClass("android/app/NativeActivity"); jmethodID getClassLoader = engine->jni->GetMethodID(activityClass,"getClassLoader", "()Ljava/lang/ClassLoader;"); jobject cls = engine->jni->CallObjectMethod(app->activity->clazz, getClassLoader); jclass classLoader = engine->jni->FindClass("java/lang/ClassLoader"); jmethodID findClass = engine->jni->GetMethodID(classLoader, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;"); static JNINativeMethod methods[] = { {"registerSingleton", "(Ljava/lang/String;Ljava/lang/Object;)V",(void *)&Java_org_godotengine_godot_Godot_registerSingleton}, {"registerMethod", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;)V",(void *)&Java_org_godotengine_godot_Godot_registerMethod}, {"getGlobal", "(Ljava/lang/String;)Ljava/lang/String;", (void *)&Java_org_godotengine_godot_Godot_getGlobal}, }; jstring gstrClassName = engine->jni->NewStringUTF("org/godotengine/godot/Godot"); jclass GodotClass = (jclass)engine->jni->CallObjectMethod(cls, findClass, gstrClassName); __android_log_print(ANDROID_LOG_INFO,"godot","godot ****^*^*?^*^*class data %x",GodotClass); engine->jni->RegisterNatives(GodotClass,methods,sizeof(methods)/sizeof(methods[0])); for (int i=0;i<mods.size();i++) { String m = mods[i]; //jclass singletonClass = engine->jni->FindClass(m.utf8().get_data()); jstring strClassName = engine->jni->NewStringUTF(m.utf8().get_data()); jclass singletonClass = (jclass)engine->jni->CallObjectMethod(cls, findClass, strClassName); __android_log_print(ANDROID_LOG_INFO,"godot","****^*^*?^*^*class data %x",singletonClass); jmethodID initialize = engine->jni->GetStaticMethodID(singletonClass, "initialize", "(Landroid/app/Activity;)Lorg/godotengine/godot/Godot$SingletonBase;"); jobject obj = engine->jni->CallStaticObjectMethod(singletonClass,initialize,app->activity->clazz); __android_log_print(ANDROID_LOG_INFO,"godot","****^*^*?^*^*class instance %x",obj); jobject gob = engine->jni->NewGlobalRef(obj); } } #endif if (!Main::start()) return; //should exit instead and print the error engine->os->main_loop_begin(); } else { //i guess recreate resources? engine->os->reload_gfx(); } engine->animating=1; engine_draw_frame(engine); } break; case APP_CMD_TERM_WINDOW: // The window is being hidden or closed, clean it up. // LOGI("TERM WINDOW"); engine_term_display(engine); break; case APP_CMD_GAINED_FOCUS: // When our app gains focus, we start monitoring the accelerometer. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->accelerometerSensor); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->accelerometerSensor, (1000L/60)*1000); } // Also start monitoring the magnetometer. if (engine->magnetometerSensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->magnetometerSensor); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->magnetometerSensor, (1000L/60)*1000); } // And the gyroscope. if (engine->gyroscopeSensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->gyroscopeSensor); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->gyroscopeSensor, (1000L/60)*1000); } engine->animating = 1; break; case APP_CMD_LOST_FOCUS: // When our app loses focus, we stop monitoring the sensors. // This is to avoid consuming battery while not being used. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->accelerometerSensor); } if (engine->magnetometerSensor != NULL) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->magnetometerSensor); } if (engine->gyroscopeSensor != NULL) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->gyroscopeSensor); } // Also stop animating. engine->animating = 0; engine_draw_frame(engine); break; } }
static Error _parse_obj(const String &p_path, List<Ref<Mesh> > &r_meshes, bool p_single_mesh, bool p_generate_tangents, Vector3 p_scale_mesh, List<String> *r_missing_deps) { FileAccessRef f = FileAccess::open(p_path, FileAccess::READ); ERR_FAIL_COND_V(!f, ERR_CANT_OPEN); Ref<ArrayMesh> mesh; mesh.instance(); bool generate_tangents = p_generate_tangents; Vector3 scale_mesh = p_scale_mesh; bool flip_faces = false; //bool flip_faces = p_options["force/flip_faces"]; //bool force_smooth = p_options["force/smooth_shading"]; //bool weld_vertices = p_options["force/weld_vertices"]; //float weld_tolerance = p_options["force/weld_tolerance"]; Vector<Vector3> vertices; Vector<Vector3> normals; Vector<Vector2> uvs; String name; Map<String, Map<String, Ref<SpatialMaterial> > > material_map; Ref<SurfaceTool> surf_tool = memnew(SurfaceTool); surf_tool->begin(Mesh::PRIMITIVE_TRIANGLES); String current_material_library; String current_material; String current_group; while (true) { String l = f->get_line().strip_edges(); if (l.begins_with("v ")) { //vertex Vector<String> v = l.split(" ", false); ERR_FAIL_COND_V(v.size() < 4, ERR_FILE_CORRUPT); Vector3 vtx; vtx.x = v[1].to_float() * scale_mesh.x; vtx.y = v[2].to_float() * scale_mesh.y; vtx.z = v[3].to_float() * scale_mesh.z; vertices.push_back(vtx); } else if (l.begins_with("vt ")) { //uv Vector<String> v = l.split(" ", false); ERR_FAIL_COND_V(v.size() < 3, ERR_FILE_CORRUPT); Vector2 uv; uv.x = v[1].to_float(); uv.y = 1.0 - v[2].to_float(); uvs.push_back(uv); } else if (l.begins_with("vn ")) { //normal Vector<String> v = l.split(" ", false); ERR_FAIL_COND_V(v.size() < 4, ERR_FILE_CORRUPT); Vector3 nrm; nrm.x = v[1].to_float(); nrm.y = v[2].to_float(); nrm.z = v[3].to_float(); normals.push_back(nrm); } else if (l.begins_with("f ")) { //vertex Vector<String> v = l.split(" ", false); ERR_FAIL_COND_V(v.size() < 4, ERR_FILE_CORRUPT); //not very fast, could be sped up Vector<String> face[3]; face[0] = v[1].split("/"); face[1] = v[2].split("/"); ERR_FAIL_COND_V(face[0].size() == 0, ERR_FILE_CORRUPT); ERR_FAIL_COND_V(face[0].size() != face[1].size(), ERR_FILE_CORRUPT); for (int i = 2; i < v.size() - 1; i++) { face[2] = v[i + 1].split("/"); ERR_FAIL_COND_V(face[0].size() != face[2].size(), ERR_FILE_CORRUPT); for (int j = 0; j < 3; j++) { int idx = j; if (!flip_faces && idx < 2) { idx = 1 ^ idx; } if (face[idx].size() == 3) { int norm = face[idx][2].to_int() - 1; if (norm < 0) norm += normals.size() + 1; ERR_FAIL_INDEX_V(norm, normals.size(), ERR_FILE_CORRUPT); surf_tool->add_normal(normals[norm]); } if (face[idx].size() >= 2 && face[idx][1] != String()) { int uv = face[idx][1].to_int() - 1; if (uv < 0) uv += uvs.size() + 1; ERR_FAIL_INDEX_V(uv, uvs.size(), ERR_FILE_CORRUPT); surf_tool->add_uv(uvs[uv]); } int vtx = face[idx][0].to_int() - 1; if (vtx < 0) vtx += vertices.size() + 1; ERR_FAIL_INDEX_V(vtx, vertices.size(), ERR_FILE_CORRUPT); Vector3 vertex = vertices[vtx]; //if (weld_vertices) // vertex.snap(Vector3(weld_tolerance, weld_tolerance, weld_tolerance)); surf_tool->add_vertex(vertex); } face[1] = face[2]; } } else if (l.begins_with("s ")) { //smoothing String what = l.substr(2, l.length()).strip_edges(); if (what == "off") surf_tool->add_smooth_group(false); else surf_tool->add_smooth_group(true); } else if (/*l.begins_with("g ") ||*/ l.begins_with("usemtl ") || (l.begins_with("o ") || f->eof_reached())) { //commit group to mesh //groups are too annoying if (surf_tool->get_vertex_array().size()) { //another group going on, commit it if (normals.size() == 0) { surf_tool->generate_normals(); } if (generate_tangents && uvs.size()) { surf_tool->generate_tangents(); } surf_tool->index(); print_line("current material library " + current_material_library + " has " + itos(material_map.has(current_material_library))); print_line("current material " + current_material + " has " + itos(material_map.has(current_material_library) && material_map[current_material_library].has(current_material))); if (material_map.has(current_material_library) && material_map[current_material_library].has(current_material)) { surf_tool->set_material(material_map[current_material_library][current_material]); } mesh = surf_tool->commit(mesh); if (current_material != String()) { mesh->surface_set_name(mesh->get_surface_count() - 1, current_material.get_basename()); } else if (current_group != String()) { mesh->surface_set_name(mesh->get_surface_count() - 1, current_group); } print_line("Added surface :" + mesh->surface_get_name(mesh->get_surface_count() - 1)); surf_tool->clear(); surf_tool->begin(Mesh::PRIMITIVE_TRIANGLES); } if (l.begins_with("o ") || f->eof_reached()) { if (!p_single_mesh) { mesh->set_name(name); r_meshes.push_back(mesh); mesh.instance(); current_group = ""; current_material = ""; } } if (f->eof_reached()) { break; } if (l.begins_with("o ")) { name = l.substr(2, l.length()).strip_edges(); } if (l.begins_with("usemtl ")) { current_material = l.replace("usemtl", "").strip_edges(); } if (l.begins_with("g ")) { current_group = l.substr(2, l.length()).strip_edges(); } } else if (l.begins_with("mtllib ")) { //parse material current_material_library = l.replace("mtllib", "").strip_edges(); if (!material_map.has(current_material_library)) { Map<String, Ref<SpatialMaterial> > lib; Error err = _parse_material_library(current_material_library, lib, r_missing_deps); if (err == ERR_CANT_OPEN) { String dir = p_path.get_base_dir(); err = _parse_material_library(dir.plus_file(current_material_library), lib, r_missing_deps); } if (err == OK) { material_map[current_material_library] = lib; } } } } if (p_single_mesh) { r_meshes.push_back(mesh); } return OK; }
bool PluginPackage::fetchInfo() { DWORD versionInfoSize, zeroHandle; versionInfoSize = GetFileVersionInfoSizeW(const_cast<UChar*>(m_path.charactersWithNullTermination()), &zeroHandle); if (versionInfoSize == 0) return false; OwnArrayPtr<char> versionInfoData(new char[versionInfoSize]); if (!GetFileVersionInfoW(const_cast<UChar*>(m_path.charactersWithNullTermination()), 0, versionInfoSize, versionInfoData.get())) return false; m_name = getVersionInfo(versionInfoData.get(), "ProductName"); m_description = getVersionInfo(versionInfoData.get(), "FileDescription"); if (m_name.isNull() || m_description.isNull()) return false; VS_FIXEDFILEINFO* info; UINT infoSize; if (!VerQueryValue(versionInfoData.get(), TEXT("\\"), (LPVOID*) &info, &infoSize) || infoSize < sizeof(VS_FIXEDFILEINFO)) return false; m_moduleVersion.leastSig = info->dwFileVersionLS; m_moduleVersion.mostSig = info->dwFileVersionMS; if (isPluginBlacklisted()) return false; Vector<String> types; getVersionInfo(versionInfoData.get(), "MIMEType").split('|', types); Vector<String> extensionLists; getVersionInfo(versionInfoData.get(), "FileExtents").split('|', extensionLists); Vector<String> descriptions; getVersionInfo(versionInfoData.get(), "FileOpenName").split('|', descriptions); for (unsigned i = 0; i < types.size(); i++) { String type = types[i].lower(); String description = i < descriptions.size() ? descriptions[i] : ""; String extensionList = i < extensionLists.size() ? extensionLists[i] : ""; Vector<String> extensionsVector; extensionList.split(',', extensionsVector); // Get rid of the extension list that may be at the end of the description string. int pos = description.find("(*"); if (pos != -1) { // There might be a space that we need to get rid of. if (pos > 1 && description[pos - 1] == ' ') pos--; description = description.left(pos); } // Determine the quirks for the MIME types this plug-in supports determineQuirks(type); m_mimeToExtensions.add(type, extensionsVector); m_mimeToDescriptions.add(type, description); } return true; }
void UvaErdo() { int scenarios, papers = 0, names = 0; int scenario; Scanner *scanIn = new Scanner(); String s = scanIn->nextLine(); scenarios = Integer->parseInt(s->trim()); for (scenario = 1; scenario <= scenarios; scenario++) { printf("Scenario %d\n", scenario); String nextLine = scanIn->nextLine(); String s2[] = nextLine->split(" "); int i = 0; for (; s2[i] != null; i++) { try { papers = Integer.parseInt(s2[i].trim()); #ifdef DEBUG printf("\tConverted '%s' to %d\n", s2[i].trim(), papers); #endif break; } catch (NumberFormatException e) { } } i++; for (; i < s2.length; i++) { try { names = Integer.parseInt(s2[i].trim()); #ifdef DEBUG printf("\tConverted '%s' to %d\n", s2[i].trim(), names); #endif break; } catch (NumberFormatException e) { } } #ifdef DEBUG printf("\tConverted '%s' to %d papers and %d names\n", nextLine, papers, names); #endif readPapers(papers, scanIn); #ifdef DEBUG printf("Scenario %d\n", scenario); #endif List<Entry<String, Author>> theMap = new ArrayList<Map.Entry<String, Author>>(names); Set<Author> targets = new TreeSet<Author>(); readCases(names, scanIn, theMap, targets); if (Author.erdosPtr != null) { Author.erdosPtr.process(targets); #ifdef DEBUG printf("Author::erdosPtr not null\n"); #endif } for (Entry<String, Author> it : theMap) { Author a = it.getValue(); String bigname = it.getKey(); if (a == null) { printf("%s infinity\n", bigname); } else { int d = a.depht; if (d <= 0 && Author.erdosPtr != a) { printf("%s, %s infinity\n", a.lname, a.fname); } else { printf("%s, %s %d\n", a.lname, a.fname, d); } } } theMap.clear(); Author.freeMemory(); } }
void MzTabModificationList::fromCellString(const String& s) { String lower = s; lower.toLower().trim(); if (lower == "null") { setNull(true); } else { String ss = s; std::vector<String> fields; if (!ss.hasSubstring("[")) // no parameters { ss.split(",", fields); for (Size i = 0; i != fields.size(); ++i) { MzTabModification ms; ms.fromCellString(fields[i]); entries_.push_back(ms); } } else { // example string: 3|4[a,b,,v]|8[,,"blabla, [bla]",v],1|2|3[a,b,,v]-mod:123 // we don't want to split at the , inside of [ ] MzTabParameter brackets. // Additionally, and we don't want to recognise quoted brackets inside the MzTabParameter where they can occur in quoted text (see example string) bool in_param_bracket = false; bool in_quotes = false; for (Size pos = 0; pos != ss.size(); ++pos) { // param_bracket state if (ss[pos] == '[' && !in_quotes) { in_param_bracket = true; continue; } if (ss[pos] == ']' && !in_quotes) { in_param_bracket = false; continue; } // quote state if (ss[pos] == '\"') { in_quotes = !in_quotes; continue; } // comma in param bracket if (ss[pos] == ',' && !in_quotes && in_param_bracket) { ss[pos] = ((char)007); // use ASCII bell as temporary separator continue; } } // now the split at comma is save ss.split(",", fields); for (Size i = 0; i != fields.size(); ++i) { fields[i].substitute(((char)007), ','); // resubstitute comma after split MzTabModification ms; ms.fromCellString(fields[i]); entries_.push_back(ms); } } } }
Error Main::setup(const char *execpath,int argc, char *argv[],bool p_second_phase) { RID_OwnerBase::init_rid(); OS::get_singleton()->initialize_core(); ObjectTypeDB::init(); MAIN_PRINT("Main: Initialize CORE"); register_core_types(); register_core_driver_types(); MAIN_PRINT("Main: Initialize Globals"); Thread::_main_thread_id = Thread::get_caller_ID(); globals = memnew( Globals ); input_map = memnew( InputMap ); path_remap = memnew( PathRemap ); translation_server = memnew( TranslationServer ); performance = memnew( Performance ); globals->add_singleton(Globals::Singleton("Performance",performance)); MAIN_PRINT("Main: Parse CMDLine"); /* argument parsing and main creation */ List<String> args; List<String> main_args; for(int i=0;i<argc;i++) { args.push_back(String::utf8(argv[i])); } List<String>::Element *I=args.front(); I=args.front(); while (I) { I->get()=unescape_cmdline(I->get().strip_escapes()); // print_line("CMD: "+I->get()); I=I->next(); } I=args.front(); video_mode = OS::get_singleton()->get_default_video_mode(); String video_driver=""; String audio_driver=""; String game_path="."; String debug_mode; String debug_host; String main_pack; bool quiet_stdout=false; int rtm=-1; String remotefs; String remotefs_pass; String screen = ""; List<String> pack_list; Vector<String> breakpoints; bool use_custom_res=true; bool force_res=false; I=args.front(); packed_data = PackedData::get_singleton(); if (!packed_data) packed_data = memnew(PackedData); #ifdef MINIZIP_ENABLED //XXX: always get_singleton() == 0x0 zip_packed_data = ZipArchive::get_singleton(); //TODO: remove this temporary fix if (!zip_packed_data) { zip_packed_data = memnew(ZipArchive); } packed_data->add_pack_source(zip_packed_data); #endif bool editor=false; while(I) { List<String>::Element *N=I->next(); if (I->get() == "-noop") { // no op } else if (I->get()=="-h" || I->get()=="--help" || I->get()=="/?") { // resolution goto error; } else if (I->get()=="-r") { // resolution if (I->next()) { String vm=I->next()->get(); if (vm.find("x")==-1) { // invalid parameter format goto error; } int w=vm.get_slice("x",0).to_int(); int h=vm.get_slice("x",1).to_int(); if (w==0 || h==0) { goto error; } video_mode.width=w; video_mode.height=h; force_res=true; N=I->next()->next(); } else { goto error; } } else if (I->get()=="-p") { // position if (I->next()) { String vm=I->next()->get(); if (vm.find("x")==-1) { // invalid parameter format goto error; } int x=vm.get_slice("x",0).to_int(); int y=vm.get_slice("x",1).to_int(); init_custom_pos=Point2(x,y); init_use_custom_pos=true; force_res=true; N=I->next()->next(); } else { goto error; } } else if (I->get()=="-mx") { // video driver init_maximized=true; } else if (I->get()=="-vd") { // video driver if (I->next()) { video_driver=I->next()->get(); N=I->next()->next(); } else { goto error; } } else if (I->get()=="-lang") { // language if (I->next()) { locale=I->next()->get(); N=I->next()->next(); } else { goto error; } } else if (I->get()=="-rfs") { // language if (I->next()) { remotefs=I->next()->get(); N=I->next()->next(); } else { goto error; } } else if (I->get()=="-rfs_pass") { // language if (I->next()) { remotefs_pass=I->next()->get(); N=I->next()->next(); } else { goto error; } } else if (I->get()=="-rthread") { // language if (I->next()) { if (I->next()->get()=="safe") rtm=OS::RENDER_THREAD_SAFE; else if (I->next()->get()=="unsafe") rtm=OS::RENDER_THREAD_UNSAFE; else if (I->next()->get()=="separate") rtm=OS::RENDER_SEPARATE_THREAD; N=I->next()->next(); } else { goto error; } } else if (I->get()=="-ad") { // video driver if (I->next()) { audio_driver=I->next()->get(); N=I->next()->next(); } else { goto error; } } else if (I->get()=="-f") { // fullscreen //video_mode.fullscreen=false; init_fullscreen=true; } else if (I->get()=="-e" || I->get()=="-editor") { // fonud editor editor=true; init_maximized=true; } else if (I->get()=="-nowindow") { // fullscreen OS::get_singleton()->set_no_window_mode(true); } else if (I->get()=="-quiet") { // fullscreen quiet_stdout=true; } else if (I->get()=="-v") { // fullscreen OS::get_singleton()->_verbose_stdout=true; } else if (I->get()=="-path") { // resolution if (I->next()) { String p = I->next()->get(); if (OS::get_singleton()->set_cwd(p)==OK) { //nothing } else { game_path=I->next()->get(); //use game_path instead } N=I->next()->next(); } else { goto error; } } else if (I->get()=="-bp") { // /breakpoints if (I->next()) { String bplist = I->next()->get(); breakpoints= bplist.split(","); N=I->next()->next(); } else { goto error; } } else if (I->get()=="-fdelay") { // resolution if (I->next()) { OS::get_singleton()->set_frame_delay(I->next()->get().to_int()); N=I->next()->next(); } else { goto error; } } else if (I->get()=="-timescale") { // resolution if (I->next()) { OS::get_singleton()->set_time_scale(I->next()->get().to_double()); N=I->next()->next(); } else { goto error; } } else if (I->get() == "-pack") { if (I->next()) { pack_list.push_back(I->next()->get()); N = I->next()->next(); } else { goto error; }; } else if (I->get() == "-main_pack") { if (I->next()) { main_pack=I->next()->get(); N = I->next()->next(); } else { goto error; }; } else if (I->get()=="-debug" || I->get()=="-d") { debug_mode="local"; } else if (I->get()=="-editor_scene") { if (I->next()) { Globals::get_singleton()->set("editor_scene",game_path=I->next()->get()); } else { goto error; } } else if (I->get()=="-rdebug") { if (I->next()) { debug_mode="remote"; debug_host=I->next()->get(); if (debug_host.find(":")==-1) //wrong host goto error; N=I->next()->next(); } else { goto error; } } else { //test for game path bool gpfound=false; if (!I->get().begins_with("-") && game_path=="") { DirAccess* da = DirAccess::open(I->get()); if (da!=NULL) { game_path=I->get(); gpfound=true; memdelete(da); } } if (!gpfound) { main_args.push_back(I->get()); } } I=N; } GLOBAL_DEF("debug/max_remote_stdout_chars_per_second",2048); if (debug_mode == "remote") { ScriptDebuggerRemote *sdr = memnew( ScriptDebuggerRemote ); uint16_t debug_port = GLOBAL_DEF("debug/remote_port",6007); if (debug_host.find(":")!=-1) { debug_port=debug_host.get_slicec(':',1).to_int(); debug_host=debug_host.get_slicec(':',0); } Error derr = sdr->connect_to_host(debug_host,debug_port); if (derr!=OK) { memdelete(sdr); } else { script_debugger=sdr; } } else if (debug_mode=="local") { script_debugger = memnew( ScriptDebuggerLocal ); } if (remotefs!="") { file_access_network_client=memnew(FileAccessNetworkClient); int port; if (remotefs.find(":")!=-1) { port=remotefs.get_slicec(':',1).to_int(); remotefs=remotefs.get_slicec(':',0); } else { port=6010; } Error err = file_access_network_client->connect(remotefs,port,remotefs_pass); if (err) { OS::get_singleton()->printerr("Could not connect to remotefs: %s:%i\n",remotefs.utf8().get_data(),port); goto error; } FileAccess::make_default<FileAccessNetwork>(FileAccess::ACCESS_RESOURCES); } if (script_debugger) { //there is a debugger, parse breakpoints for(int i=0;i<breakpoints.size();i++) { String bp = breakpoints[i]; int sp=bp.find_last(":"); if (sp==-1) { ERR_EXPLAIN("Invalid breakpoint: '"+bp+"', expected file:line format."); ERR_CONTINUE(sp==-1); } script_debugger->insert_breakpoint(bp.substr(sp+1,bp.length()).to_int(),bp.substr(0,sp)); } } #ifdef TOOLS_ENABLED if (editor) { packed_data->set_disabled(true); globals->set_disable_platform_override(true); } #endif if (globals->setup(game_path,main_pack)!=OK) { #ifdef TOOLS_ENABLED editor=false; #else OS::get_singleton()->print("error: Couldn't load game path '%s'\n",game_path.ascii().get_data()); goto error; #endif } if (editor) { main_args.push_back("-editor"); use_custom_res=false; } if (bool(Globals::get_singleton()->get("application/disable_stdout"))) { quiet_stdout=true; } if (bool(Globals::get_singleton()->get("application/disable_stderr"))) { _print_error_enabled = false; }; if (quiet_stdout) _print_line_enabled=false; OS::get_singleton()->set_cmdline(execpath, main_args); #ifdef TOOLS_ENABLED if (main_args.size()==0 && (!Globals::get_singleton()->has("application/main_loop_type")) && (!Globals::get_singleton()->has("application/main_scene") || String(Globals::get_singleton()->get("application/main_scene"))=="")) use_custom_res=false; //project manager (run without arguments) #endif input_map->load_from_globals(); if (video_driver=="") // specified in engine.cfg video_driver=_GLOBAL_DEF("display/driver",Variant((const char*)OS::get_singleton()->get_video_driver_name(0))); if (!force_res && use_custom_res && globals->has("display/width")) video_mode.width=globals->get("display/width"); if (!force_res &&use_custom_res && globals->has("display/height")) video_mode.height=globals->get("display/height"); if (use_custom_res && globals->has("display/fullscreen")) video_mode.fullscreen=globals->get("display/fullscreen"); if (use_custom_res && globals->has("display/resizable")) video_mode.resizable=globals->get("display/resizable"); if (!force_res && use_custom_res && globals->has("display/test_width") && globals->has("display/test_height")) { int tw = globals->get("display/test_width"); int th = globals->get("display/test_height"); if (tw>0 && th>0) { video_mode.width=tw; video_mode.height=th; } } GLOBAL_DEF("display/width",video_mode.width); GLOBAL_DEF("display/height",video_mode.height); GLOBAL_DEF("display/fullscreen",video_mode.fullscreen); GLOBAL_DEF("display/resizable",video_mode.resizable); GLOBAL_DEF("display/test_width",0); GLOBAL_DEF("display/test_height",0); if (rtm==-1) { rtm=GLOBAL_DEF("render/thread_model",OS::RENDER_THREAD_SAFE); if (rtm>=1) //hack for now rtm=1; } if (rtm>=0 && rtm<3) OS::get_singleton()->_render_thread_mode=OS::RenderThreadMode(rtm); /* Determine Video Driver */ if (audio_driver=="") // specified in engine.cfg audio_driver=GLOBAL_DEF("audio/driver",OS::get_singleton()->get_audio_driver_name(0)); for (int i=0;i<OS::get_singleton()->get_video_driver_count();i++) { if (video_driver==OS::get_singleton()->get_video_driver_name(i)) { video_driver_idx=i; break; } } if (video_driver_idx<0) { OS::get_singleton()->alert( "Invalid Video Driver: "+video_driver ); video_driver_idx = 0; //goto error; } for (int i=0;i<OS::get_singleton()->get_audio_driver_count();i++) { if (audio_driver==OS::get_singleton()->get_audio_driver_name(i)) { audio_driver_idx=i; break; } } if (audio_driver_idx<0) { OS::get_singleton()->alert( "Invalid Audio Driver: "+audio_driver ); goto error; } { String orientation = GLOBAL_DEF("display/orientation","landscape"); if (orientation=="portrait") OS::get_singleton()->set_screen_orientation(OS::SCREEN_PORTRAIT); else if (orientation=="reverse_landscape") OS::get_singleton()->set_screen_orientation(OS::SCREEN_REVERSE_LANDSCAPE); else if (orientation=="reverse_portrait") OS::get_singleton()->set_screen_orientation(OS::SCREEN_REVERSE_PORTRAIT); else if (orientation=="sensor_landscape") OS::get_singleton()->set_screen_orientation(OS::SCREEN_SENSOR_LANDSCAPE); else if (orientation=="sensor_portrait") OS::get_singleton()->set_screen_orientation(OS::SCREEN_SENSOR_PORTRAIT); else if (orientation=="sensor") OS::get_singleton()->set_screen_orientation(OS::SCREEN_SENSOR); else OS::get_singleton()->set_screen_orientation(OS::SCREEN_LANDSCAPE); } OS::get_singleton()->set_iterations_per_second(GLOBAL_DEF("physics/fixed_fps",60)); OS::get_singleton()->set_target_fps(GLOBAL_DEF("application/target_fps",0)); if (!OS::get_singleton()->_verbose_stdout) //overrided OS::get_singleton()->_verbose_stdout=GLOBAL_DEF("debug/verbose_stdout",false); message_queue = memnew( MessageQueue ); Globals::get_singleton()->register_global_defaults(); if (p_second_phase) return setup2(); return OK; error: video_driver=""; audio_driver=""; game_path=""; args.clear(); main_args.clear(); print_help(execpath); if (performance) memdelete(performance); if (input_map) memdelete(input_map); if (translation_server) memdelete( translation_server ); if (globals) memdelete(globals); if (script_debugger) memdelete(script_debugger); if (packed_data) memdelete(packed_data); if (file_access_network_client) memdelete(file_access_network_client); // Note 1: *zip_packed_data live into *packed_data // Note 2: PackedData::~PackedData destroy this. //#ifdef MINIZIP_ENABLED // if (zip_packed_data) // memdelete( zip_packed_data ); //#endif unregister_core_types(); OS::get_singleton()->_cmdline.clear(); if (message_queue) memdelete( message_queue); OS::get_singleton()->finalize_core(); locale=String(); return ERR_INVALID_PARAMETER; }
bool EditorFileSystem::_find_file(const String &p_file, EditorFileSystemDirectory **r_d, int &r_file_pos) const { //todo make faster if (!filesystem || scanning) return false; String f = ProjectSettings::get_singleton()->localize_path(p_file); if (!f.begins_with("res://")) return false; f = f.substr(6, f.length()); f = f.replace("\\", "/"); Vector<String> path = f.split("/"); if (path.size() == 0) return false; String file = path[path.size() - 1]; path.resize(path.size() - 1); EditorFileSystemDirectory *fs = filesystem; for (int i = 0; i < path.size(); i++) { if (path[i].begins_with(".")) return false; int idx = -1; for (int j = 0; j < fs->get_subdir_count(); j++) { if (fs->get_subdir(j)->get_name() == path[i]) { idx = j; break; } } if (idx == -1) { //does not exist, create i guess? EditorFileSystemDirectory *efsd = memnew(EditorFileSystemDirectory); efsd->name = path[i]; efsd->parent = fs; int idx2 = 0; for (int j = 0; j < fs->get_subdir_count(); j++) { if (efsd->name < fs->get_subdir(j)->get_name()) break; idx2++; } if (idx2 == fs->get_subdir_count()) fs->subdirs.push_back(efsd); else fs->subdirs.insert(idx2, efsd); fs = efsd; } else { fs = fs->get_subdir(idx); } } int cpos = -1; for (int i = 0; i < fs->files.size(); i++) { if (fs->files[i]->file == file) { cpos = i; break; } } r_file_pos = cpos; *r_d = fs; if (cpos != -1) { return true; } else { return false; } }
RES TranslationLoaderPO::load_translation(FileAccess *f, Error *r_error, const String &p_path) { enum Status { STATUS_NONE, STATUS_READING_ID, STATUS_READING_STRING, }; Status status = STATUS_NONE; String msg_id; String msg_str; String config; if (r_error) *r_error = ERR_FILE_CORRUPT; Ref<Translation> translation = Ref<Translation>(memnew(Translation)); int line = 1; bool skip_this; bool skip_next; while (true) { String l = f->get_line(); if (f->eof_reached()) { if (status == STATUS_READING_STRING) { if (msg_id != "") { if (!skip_this) translation->add_message(msg_id, msg_str); } else if (config == "") config = msg_str; break; } else if (status == STATUS_NONE) break; memdelete(f); ERR_EXPLAIN(p_path + ":" + itos(line) + " Unexpected EOF while reading 'msgid' at file: "); ERR_FAIL_V(RES()); } l = l.strip_edges(); if (l.begins_with("msgid")) { if (status == STATUS_READING_ID) { memdelete(f); ERR_EXPLAIN(p_path + ":" + itos(line) + " Unexpected 'msgid', was expecting 'msgstr' while parsing: "); ERR_FAIL_V(RES()); } if (msg_id != "") { if (!skip_this) translation->add_message(msg_id, msg_str); } else if (config == "") config = msg_str; l = l.substr(5, l.length()).strip_edges(); status = STATUS_READING_ID; msg_id = ""; msg_str = ""; skip_this = skip_next; skip_next = false; } if (l.begins_with("msgstr")) { if (status != STATUS_READING_ID) { memdelete(f); ERR_EXPLAIN(p_path + ":" + itos(line) + " Unexpected 'msgstr', was expecting 'msgid' while parsing: "); ERR_FAIL_V(RES()); } l = l.substr(6, l.length()).strip_edges(); status = STATUS_READING_STRING; } if (l == "" || l.begins_with("#")) { if (l.find("fuzzy") != -1) { skip_next = true; } line++; continue; //nothing to read or comment } if (!l.begins_with("\"") || status == STATUS_NONE) { //not a string? failure! ERR_EXPLAIN(p_path + ":" + itos(line) + " Invalid line '" + l + "' while parsing: "); ERR_FAIL_V(RES()); } l = l.substr(1, l.length()); //find final quote int end_pos = -1; for (int i = 0; i < l.length(); i++) { if (l[i] == '"' && (i == 0 || l[i - 1] != '\\')) { end_pos = i; break; } } if (end_pos == -1) { ERR_EXPLAIN(p_path + ":" + itos(line) + " Expected '\"' at end of message while parsing file: "); ERR_FAIL_V(RES()); } l = l.substr(0, end_pos); l = l.c_unescape(); if (status == STATUS_READING_ID) msg_id += l; else msg_str += l; line++; } f->close(); memdelete(f); if (config == "") { ERR_EXPLAIN("No config found in file: " + p_path); ERR_FAIL_V(RES()); } Vector<String> configs = config.split("\n"); for (int i = 0; i < configs.size(); i++) { String c = configs[i].strip_edges(); int p = c.find(":"); if (p == -1) continue; String prop = c.substr(0, p).strip_edges(); String value = c.substr(p + 1, c.length()).strip_edges(); if (prop == "X-Language") { translation->set_locale(value); } } if (r_error) *r_error = OK; return translation; }
void WebCLProgram::build(const RefPtr<WebCLDeviceList> devices, const String& buildOptions, PassOwnPtr<WebCLCallback> callback, ExceptionState& es) { cl_int err = 0; cl_device_id cl_device = NULL; if (m_cl_program == NULL) { printf("Error: Invalid program object\n"); es.throwWebCLException( WebCLException::INVALID_PROGRAM, WebCLException::invalidProgramMessage); return ; } if (buildOptions.length() > 0) { DEFINE_STATIC_LOCAL(AtomicString, buildOptionDashD, ("-D", AtomicString::ConstructFromLiteral)); DEFINE_STATIC_LOCAL(HashSet<AtomicString>, webCLSupportedBuildOptions, ()); if (webCLSupportedBuildOptions.isEmpty()) { webCLSupportedBuildOptions.add( AtomicString("-cl-opt-disable", AtomicString::ConstructFromLiteral)); webCLSupportedBuildOptions.add( AtomicString("-cl-single-precision-constant", AtomicString::ConstructFromLiteral)); webCLSupportedBuildOptions.add( AtomicString("-cl-denorms-are-zero", AtomicString::ConstructFromLiteral)); webCLSupportedBuildOptions.add( AtomicString("-cl-mad-enable", AtomicString::ConstructFromLiteral)); webCLSupportedBuildOptions.add( AtomicString("-cl-no-signed-zeros", AtomicString::ConstructFromLiteral)); webCLSupportedBuildOptions.add( AtomicString("-cl-unsafe-math-optimizations", AtomicString::ConstructFromLiteral)); webCLSupportedBuildOptions.add( AtomicString("-cl-finite-math-only", AtomicString::ConstructFromLiteral)); webCLSupportedBuildOptions.add( AtomicString("-cl-fast-relaxed-math", AtomicString::ConstructFromLiteral)); webCLSupportedBuildOptions.add( AtomicString("-w", AtomicString::ConstructFromLiteral)); webCLSupportedBuildOptions.add( AtomicString("-Werror", AtomicString::ConstructFromLiteral)); } Vector<String> webCLBuildOptionsVector; buildOptions.split(" ", false /* allowEmptyEntries */, webCLBuildOptionsVector); for (size_t i = 0; i < webCLBuildOptionsVector.size(); i++) { // Every build option must start with a hyphen. if (!webCLBuildOptionsVector[i].startsWith("-")) { es.throwWebCLException( WebCLException::INVALID_BUILD_OPTIONS, WebCLException::invalidBuildOptionsMessage); return; } if (webCLSupportedBuildOptions.contains( AtomicString(webCLBuildOptionsVector[i]))) continue; /* If the token begins with "-D" it can be one of "-D NAME" or "-D name=definition". Currently OpenCL specification does not state any restriction adding spaces in between.So on encounter of a token starting with "-D" we skip validation till we reach next build option. Pushing the validation of "-D" options to underlying OpenCL. */ if (webCLBuildOptionsVector[i].startsWith(buildOptionDashD)) { size_t j; for (j = ++i; j < webCLBuildOptionsVector.size() && !webCLBuildOptionsVector[j].startsWith("-"); ++j){} i = --j; continue; } es.throwWebCLException( WebCLException::INVALID_BUILD_OPTIONS, WebCLException::invalidBuildOptionsMessage); return; } }