int main(int argc, char **argv) { char *mapp; char **tab; int i; i = 0; if (argc != 2 || open(argv[1], O_RDONLY) == -1) { ft_putstr("error\n"); return (0); } tab = tetritab(argv[1]); if (entrycheck(tab) == 0 || filecheck(argv[1]) == 0 || tabcount(tab) > 26) { ft_putstr("error\n"); return (0); } else { tab = alphaconvert(tetriconvert(tab)); mapp = squarefind(tab); ft_putstr(mapp); } return (0); }
BOOL CGeometryProcDoc::OnOpenDocument(LPCTSTR lpszPathName) { CString fn = lpszPathName; char* filename = NULL; auto UnicodeToAnsi = [](char** file, CString& fn) { int P_Length = fn.GetLength(); int nBytes = WideCharToMultiByte(CP_ACP, 0, fn, P_Length, NULL, 0, NULL, NULL); *file = new char[nBytes + 1]; memset(*file, 0, P_Length + 1); WideCharToMultiByte(CP_OEMCP, 0, fn, P_Length, *file, nBytes, NULL, NULL); }; UnicodeToAnsi(&filename, fn); string filecheck(filename); filecheck = filecheck.substr(filecheck.size()-4); std::transform(filecheck.begin(), filecheck.end(), filecheck.begin(), tolower); if (filecheck == (".stl")) { TriMesh* mesh = NULL; mesh = TriMesh::read_stl_helper(filename); mesh->need_bbox(); meshes.push_back(mesh); Current_mesh = meshes.size() - 1; return TRUE; } return FALSE; }
//append a file void append( int argc, char *argv[]) { int file, fd; char fname[16]; struct stat info; struct ar_hdr hdr; int flag = 0; if (!(filecheck(argv[2]))){ printf("%s dose not exist. Creating new Archive.\n",argv[2]); } else { printf("%s open.\n", argv[2]); } fd = open(argv[2], O_CREAT | O_APPEND | O_WRONLY, 0666); if(flag){ printf("myar: %s: creating\n", argv[2]); write(fd, ARMAG, SARMAG); } printf("myar: %s\n", argv[2]); lseek(fd, 0, SEEK_END); for(int i = 3;i < argc; i++) { if ((file = open(argv[i], O_RDONLY)) < 0) { printf("myar: %s: No such file or directory\n",argv[i]); break; } printf("myar: testloop %s\n",argv[i]); if (fstat(file, &info) == 0) { strcpy(fname, argv[i]); sprintf(hdr.ar_name, "%-11s", strcat(fname,"\0")); sprintf(hdr.ar_date, "%-15u", (uint32_t) info.st_mtime); sprintf(hdr.ar_uid, "%-10u", (uint32_t) info.st_uid); sprintf(hdr.ar_gid, "%-10u", (uint32_t) info.st_gid); sprintf(hdr.ar_mode, "%-10o", (uint32_t) info.st_mode); sprintf(hdr.ar_size, "%-10u", (uint32_t) info.st_size); memcpy(hdr.ar_fmag, ARFMAG, sizeof(hdr.ar_fmag)); write(fd, (char*) &hdr, sizeof(hdr)); write(fd, &ARFMAG, 2); } else { printf("myar: unable to archive %c.\n", fname[i]); exit(EXIT_FAILURE); } char buff[info.st_size]; int buffering = sizeof(buff); read(file, buff, buffering); write(fd, buff, buffering); if (info.st_size % 2) { write(fd, "\n", 1); } close(file); } }
/* * Initilize drifile object and check file * file : file name array * cnt : number in file name array * mmapping: mmap file or not * return: drifile object */ drifiles *dri_init(char **file, int cnt, boolean mmapping) { drifiles *d = g_new0(drifiles, 1); FILE *fp; int i; boolean gotmap = FALSE; long filesize; char **filetop = file; for (i = 0; i < cnt; i++) { if (*(file + i) == NULL) continue; /* open check */ if (NULL == (fp = fopen(*(file + i), "r"))) { SYSERROR("File %s is not found\n", *(file + i)); } /* check is drifile or noe */ if (!filecheck(fp)) { SYSERROR("File %s is not dri file\n", *(file + i)); } /* get file map */ if (!gotmap) { get_filemap(d, fp); gotmap = TRUE; } /* get pointer */ get_fileptr(d, fp, i); /* get file size for mmap */ filesize = getfilesize(fp); /* copy filenme */ d->fnames[i] = strdup(*(file + i)); /* close */ fclose(fp); /* mmap */ if (mmapping) { int fd; if (0 > (fd = open(*(file + i), O_RDONLY))) { SYSERROR("open: %s\n", strerror(errno)); } if (MAP_FAILED == (d->mmapadr[i] = mmap(0, filesize, PROT_READ, MAP_SHARED, fd, 0))) { WARNING("mmap: %s\n", strerror(errno)); close(fd); mmapping = d->mmapped = FALSE; i = 0; file = filetop; /* retry */ continue; } d->mmapped = TRUE; } } return d; }
int main(int argc, char **argv) { if (argc != 2) { usage(); return 2; } if (!(checkstream = fopen(argv[1], "r"))) { fprintf(stderr, "filecheck: unable to open file '%s' for reading.\n", argv[1]); return 2; } return filecheck(argv[1], &check_in, "<stdin>", &in, &out, &err); }
void MainWindow::setSizeLabel(const QString &fileName) { if (fileName != "") { QFile filecheck(fileName); if(filecheck.exists()) { int size = filecheck.size() / (1024*1024); fileSize->setText("(<b>" + QString::number(size) + " MB</b>)" ); } } else { fileSize->setText(""); } return; }
bool config_check(const char *filename) { char tmp[512]; if(!js) { warning("javascript is not initialized"); warning("no configuration is loaded"); return(false); } snprintf(tmp, 512, "%s/.freej/%s", getenv("HOME"), filename); if(filecheck(tmp)) { js->open(tmp); return(true); } snprintf(tmp, 512, "/etc/freej/%s", filename); if(filecheck(tmp)) { js->open(tmp); return(true); } #ifdef HAVE_DARWIN snprintf(tmp, 512, "%s/%s", "CHANGEME", filename); #else snprintf(tmp, 512, "%s/%s", DATADIR, filename); #endif if(filecheck(tmp)) { js->open(tmp); return(true); } snprintf(tmp, 512, "/usr/lib/freej/%s", filename); if(filecheck(tmp)) { js->open(tmp); return(true); } snprintf(tmp, 512, "/usr/local/lib/freej/%s", filename); if(filecheck(tmp)) { js->open(tmp); return(true); } snprintf(tmp, 512, "/opt/video/lib/freej/%s", filename); if(filecheck(tmp)) { js->open(tmp); return(true); } return(false); }
int getapikey(char* apikey, char* fname){ // Check if vtconfig exists if(!filecheck(fname)){ printf("No vtconfig found!\n"); printf("First start? Enter apikey here: "); // fgets puts his own nullterminator, so the char array is 65 bytes long, so the first 64 bytes are filled with the apikey fgets(apikey, APIKEY_SIZE, stdin); // checking if the API-key is valid int i; for(i = 0; i < 65; i++){ if(!isxdigit(apikey[i])){ printf("Error, the API-Key is not valid!\n"); printf("The API-Key must contain hexdigits\n"); return 0; } } FILE *f = fopen(fname, "w"); // Write apikey to config for next start if(f == NULL){ printf("Error while opening the %s. Please check the file permissions \n", fname); return 0; } fprintf(f, apikey); fclose(f); } else{ FILE *f = fopen(fname, "r"); // Read out key if file already exists if(f == NULL){ printf("Error while opening the %s. Please check the file permissions \n", fname); return 0; } fgets(apikey, APIKEY_SIZE, f); fclose(f); return 1; } }
int main(int argc, char *argv[]) { int continuing = 0; int count; int scores_only = 0; int i; #ifndef NOGETOPT while(( i= getopt( argc, argv, "dsh")) != -1) { switch (i) { case 'd': #ifdef DEBUG DG_debug_flag++; #endif break; case 's': scores_only = 1; break; case 'h': #ifdef DEBUG printf("Usage: omega [-shd] [savefile]\n"); #else printf("Usage: omega [-sh] [savefile]\n"); #endif printf("Options:\n"); printf(" -s Display high score list\n"); printf(" -h Display this message\n"); #ifdef DEBUG printf(" -d Enable debug mode\n"); #endif exit(0); break; case '?': /* error parsing args... ignore? */ printf("'%c' is an invalid option, ignoring\n", optopt ); break; } } if (optind >= argc ) { /* no save file given */ #if defined( BSD ) || defined( SYSV ) sprintf( SaveFileName, "Omega%d", getuid() ); #else strcpy( SaveFileName,"Omega"); #endif } else { /* savefile given */ continuing = 1; strcpy(SaveFileName,argv[optind]); } #else /* alternate code for people who don't support getopt() -- no enhancement */ if (argc ==2) { strcpy( SaveFileName, argv[1]); continuing = 1; } else { strcpy( SaveFileName,"Omega"); } #endif /* always catch ^c and hang-up signals */ #ifdef SIGINT signal(SIGINT,signalquit); #endif #ifdef SIGHUP signal(SIGHUP,signalsave); #endif #ifndef MSDOS if (CATCH_SIGNALS) { signal(SIGQUIT,signalexit); signal(SIGILL,signalexit); #ifdef DEBUG if( DG_debug_flag ) { #endif signal(SIGTRAP,signalexit); signal(SIGFPE,signalexit); signal(SIGSEGV,signalexit); #ifdef DEBUG } #endif #ifdef SIGIOT signal(SIGIOT,signalexit); #endif #ifdef SIGABRT signal(SIGABRT,signalexit); #endif #ifdef SIGEMT signal(SIGEMT,signalexit); #endif #ifdef SIGBUS signal(SIGBUS,signalexit); #endif #ifdef SIGSYS signal(SIGSYS,signalexit); #endif } #endif #ifndef FIXED_OMEGALIB if (!(Omegalib = getenv("OMEGALIB"))) #endif Omegalib = OMEGALIB; /* if filecheck is 0, some necessary data files are missing */ if (filecheck() == 0) exit(0); /* all kinds of initialization */ init_perms(); initgraf(); #ifndef MSDOS_SUPPORTED_ANTIQUE initdirs(); #endif initrand(E_RANDOM, 0); initspells(); #ifdef DEBUG /* initialize debug log file */ DG_debug_log = fopen( "/tmp/omega_dbg_log", "a" ); assert( DG_debug_log ); /* WDT :) */ setvbuf( DG_debug_log, NULL, _IOLBF, 0); fprintf(DG_debug_log, "############## new game started ##############\n"); #endif for (count = 0; count < STRING_BUFFER_SIZE; count++) strcpy(Stringbuffer[count],"<nothing>"); #ifdef SAVE_LEVELS msdos_init(); #endif omega_title(); showscores(); if (scores_only ) { endgraf(); exit(0); } /* game restore attempts to restore game if there is an argument */ if (continuing) { game_restore(SaveFileName); mprint("Your adventure continues...."); } else { /* monsters initialized in game_restore if game is being restored */ /* items initialized in game_restore if game is being restored */ inititem(TRUE); Date = random_range(360); Phase = random_range(24); #ifdef NEW_BANK bank_init(); #else strcpy(Password,""); #endif continuing = initplayer(); /* RM: 04-19-2000 loading patch */ } if (!continuing) { init_world(); /* RM: 04-19-2000 loading patch */ mprint("'?' for help or commandlist, 'Q' to quit."); } timeprint(); calc_melee(); if (Current_Environment != E_COUNTRYSIDE) showroom(Level->site[Player.x][Player.y].roomnumber); else terrain_check(FALSE); if (optionp(SHOW_COLOUR)) colour_on(); else colour_off(); screencheck(Player.x,Player.y); /* game cycle */ if (!continuing) time_clock(TRUE); while (TRUE) { if (Current_Environment == E_COUNTRYSIDE) p_country_process(); else time_clock(FALSE); } }
molecule_t *read_insertion_molecules(system_t *system) { int j; molecule_t *molecules, *molecule_ptr; atom_t *atom_ptr, *prev_atom_ptr; char linebuf[MAXLINE], *n; FILE *fp; char token_atom[MAXLINE], token_atomid[MAXLINE], token_atomtype[MAXLINE], token_moleculetype[MAXLINE], token_frozen[MAXLINE], token_moleculeid[MAXLINE], token_x[MAXLINE], token_y[MAXLINE], token_z[MAXLINE], token_mass[MAXLINE], token_charge[MAXLINE], token_alpha[MAXLINE], token_epsilon[MAXLINE], token_sigma[MAXLINE], token_omega[MAXLINE], token_gwp_alpha[MAXLINE], token_c6[MAXLINE], token_c8[MAXLINE], token_c10[MAXLINE], token_c9[MAXLINE]; int current_frozen, current_adiabatic, current_spectre, current_target, current_moleculeid, current_atomid, current_site_neighbor; double current_x, current_y, current_z, current_mass, current_charge, current_alpha, current_epsilon, current_sigma, current_omega, current_gwp_alpha, current_c6, current_c8, current_c10, current_c9; int atom_counter; // allocate the start of the list molecules = calloc(1, sizeof(molecule_t)); memnullcheck(molecules,sizeof(molecule_t),__LINE__-1, __FILE__); molecule_ptr = molecules; molecule_ptr->id = 1; molecule_ptr->atoms = calloc(1, sizeof(atom_t)); memnullcheck(molecule_ptr->atoms,sizeof(atom_t),__LINE__-1, __FILE__); atom_ptr = molecule_ptr->atoms; prev_atom_ptr = atom_ptr; // open the molecule input file fp = fopen(system->insert_input, "r"); filecheck(fp,system->insert_input,READ); // clear the linebuffer and read the tokens in atom_counter = 0; memset(linebuf, 0, MAXLINE); n = fgets(linebuf, MAXLINE, fp); while(n) { // clear the tokens memset( token_atom, 0, MAXLINE); memset( token_atomid, 0, MAXLINE); memset( token_atomtype, 0, MAXLINE); memset( token_moleculetype, 0, MAXLINE); memset( token_frozen, 0, MAXLINE); memset( token_moleculeid, 0, MAXLINE); memset( token_x, 0, MAXLINE); memset( token_y, 0, MAXLINE); memset( token_z, 0, MAXLINE); memset( token_mass, 0, MAXLINE); memset( token_charge, 0, MAXLINE); memset( token_alpha, 0, MAXLINE); memset( token_epsilon, 0, MAXLINE); memset( token_sigma, 0, MAXLINE); memset( token_omega, 0, MAXLINE); memset( token_gwp_alpha, 0, MAXLINE); memset(token_c6, 0, MAXLINE); memset(token_c8, 0, MAXLINE); memset(token_c10, 0, MAXLINE); memset(token_c9, 0, MAXLINE); // parse the input line sscanf(linebuf, "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s\n", token_atom, token_atomid, token_atomtype, token_moleculetype, token_frozen, token_moleculeid, token_x, token_y, token_z, token_mass, token_charge, token_alpha, token_epsilon, token_sigma, token_omega, token_gwp_alpha, token_c6, token_c8, token_c10, token_c9 ); if(!strcasecmp(token_atom, "ATOM") && strcasecmp(token_moleculetype, "BOX")) { current_frozen = 0; current_adiabatic = 0; current_spectre = 0; current_target = 0; if(!strcasecmp(token_frozen, "F")) current_frozen = 1; if(!strcasecmp(token_frozen, "A")) current_adiabatic = 1; if(!strcasecmp(token_frozen, "S")) current_spectre = 1; if(!strcasecmp(token_frozen, "T")) current_target = 1; current_moleculeid = atoi(token_moleculeid); current_atomid = atoi(token_atomid); current_x = atof(token_x); current_y = atof(token_y); current_z = atof(token_z); current_mass = atof(token_mass); // mass in amu current_charge = atof(token_charge); current_charge *= E2REDUCED; // convert charge into reduced units current_alpha = atof(token_alpha); current_epsilon = atof(token_epsilon); current_sigma = atof(token_sigma); current_omega = atof(token_omega); current_gwp_alpha = atof(token_gwp_alpha); current_c6 = atof(token_c6); current_c8 = atof(token_c8); current_c10 = atof(token_c10); current_c9 = atof(token_c9); if ( system->cdvdw_sig_repulsion ) { if ( current_epsilon != 1.0 ) { error("warning: setting epsilon to 1.0 (due to sig_repulsion)\n"); current_epsilon = 1.0; } } else if ( system->polarvdw ) { if ( current_sigma != 1.0 ) { error("warning: setting sigma to 1.0 (due to polarvdw)\n"); current_sigma = 1.0; } } // Functionality of site_neighbor disabled in favor of omega/gwp_alpha parameters // Current behavior is to default to atom 0, typically the center of mass for // the molecule. current_site_neighbor = 0; if(current_frozen) current_charge *= system->scale_charge; if(molecule_ptr->id != current_moleculeid) { molecule_ptr->next = calloc(1, sizeof(molecule_t)); memnullcheck(molecule_ptr->next,sizeof(molecule_t),__LINE__-1, __FILE__); molecule_ptr = molecule_ptr->next; molecule_ptr->atoms = calloc(1, sizeof(atom_t)); memnullcheck(molecule_ptr->atoms,sizeof(atom_t),__LINE__-1, __FILE__); prev_atom_ptr->next = NULL; free(atom_ptr); atom_ptr = molecule_ptr->atoms; } strcpy(molecule_ptr->moleculetype, token_moleculetype); molecule_ptr->id = current_moleculeid; molecule_ptr->frozen = current_frozen; molecule_ptr->adiabatic = current_adiabatic; molecule_ptr->spectre = current_spectre; molecule_ptr->target = current_target; molecule_ptr->mass += current_mass; #ifdef QM_ROTATION /* if quantum rot calc. enabled, allocate the necessary structures */ if(system->quantum_rotation && !molecule_ptr->frozen && !molecule_ptr->quantum_rotational_energies ) allocqmrotation(system,molecule_ptr); #endif /* QM_ROTATION */ #ifdef XXX /* if quantum vib calc. enabled, allocate the necessary structures */ if(system->quantum_vibration && !molecule_ptr->frozen) allocqmvibration(system,molecule_ptr); #endif /* XXX */ ++atom_counter; atom_ptr->id = atom_counter; atom_ptr->bond_id = current_atomid; memset(atom_ptr->atomtype, 0, MAXLINE); strcpy(atom_ptr->atomtype, token_atomtype); atom_ptr->frozen = current_frozen; atom_ptr->adiabatic = current_adiabatic; atom_ptr->spectre = current_spectre; atom_ptr->target = current_target; atom_ptr->pos[0] = current_x; atom_ptr->pos[1] = current_y; atom_ptr->pos[2] = current_z; atom_ptr->mass = current_mass; atom_ptr->charge = current_charge; atom_ptr->polarizability = current_alpha; atom_ptr->epsilon = current_epsilon; atom_ptr->sigma = current_sigma; atom_ptr->omega = current_omega; atom_ptr->gwp_alpha = current_gwp_alpha; atom_ptr->c6 = current_c6; atom_ptr->c8 = current_c8; atom_ptr->c10 = current_c10; atom_ptr->c9 = current_c9; if(current_gwp_alpha != 0.) atom_ptr->gwp_spin = 1; else atom_ptr->gwp_spin = 0; atom_ptr->site_neighbor_id = current_site_neighbor; atom_ptr->next = calloc(1, sizeof(atom_t)); memnullcheck(atom_ptr->next,sizeof(atom_t),__LINE__-1, __FILE__); prev_atom_ptr = atom_ptr; atom_ptr = atom_ptr->next; } memset(linebuf, 0, MAXLINE); n = fgets(linebuf, MAXLINE, fp); } // terminate the atom list prev_atom_ptr->next = NULL; free(atom_ptr); // Count the molecules and create an array of pointers, where each pointer // points directly to a molecule in the linked list. While counting the // molecules, check to see whether or not each sorbate is included in the // sorbate statistics list, if it is not, we will create an entry for it // so that each unique class of sorbate will have its own node in the stats // list. ///////////////////////////////////////////////////////////////////////////// // count int molecule_counter = 0; for(molecule_ptr = molecules; molecule_ptr; molecule_ptr = molecule_ptr->next) { molecule_counter++; // Check to see if this molecule is a new sorbate. if( sorbateIs_Not_InList(system, molecule_ptr->moleculetype) ) { system->sorbateCount++; addSorbateToList(system, molecule_ptr->moleculetype); for ( j=0; j<system->sorbateCount; j++ ) { if( !strcasecmp( system->sorbateInfo[j].id, molecule_ptr->moleculetype )){ system->sorbateInfo[j].mass = molecule_ptr->mass; break; } } } } // allocate space for array that will give direct access to insertion-candidate // molecules in the linked list. system->insertion_molecules_array = malloc( molecule_counter * sizeof(molecule_t*) ); memnullcheck(system->insertion_molecules_array, molecule_counter*sizeof(molecule_t *), __LINE__-1, __FILE__); // point array pointers to their corresponding molecules molecule_counter=0; for(molecule_ptr = molecules; molecule_ptr; molecule_ptr = molecule_ptr->next) { system->insertion_molecules_array[ molecule_counter ] = molecule_ptr; molecule_counter++; } system->num_insertion_molecules = molecule_counter; // ERROR CHECKING OF SOME SORT MAY NEED TO GO HERE // WHAT'S ALLOWED/DISALLOWED FOR INSERTED MOLECULES? ///////////////////////////////////////////////////////// fclose(fp); return(molecules); }
std::pair <bool,bool> OBJECTLOADER::ContinueObjectLoad( TRACK* track, std::map <std::string, MODEL_JOE03> & model_library, std::map <std::string, TEXTURE_GL> & texture_library, std::list <TRACK_OBJECT> & objects, const std::string & texture_size) { std::string model_name; if (error) return std::pair <bool,bool> (true, false); if (!(GetParam(objectfile, model_name))) { info_output << "Track loaded: " << model_library.size() << " models, " << texture_library.size() << " textures, " << /*surfaces.size() << " surfaces" << */std::endl; return std::pair <bool,bool> (false, false); } assert(objectfile.good()); std::string diffuse_texture_name; bool mipmap; bool nolighting; bool skybox; int transparent_blend; float bump_wavelength; float bump_amplitude; bool driveable; bool collideable; float friction_notread; float friction_tread; float rolling_resistance; float rolling_drag; bool isashadow(false); int clamptexture(0); int surface_type(2); std::string otherjunk; GetParam(objectfile, diffuse_texture_name); GetParam(objectfile, mipmap); GetParam(objectfile, nolighting); GetParam(objectfile, skybox); GetParam(objectfile, transparent_blend); GetParam(objectfile, bump_wavelength); GetParam(objectfile, bump_amplitude); GetParam(objectfile, driveable); GetParam(objectfile, collideable); GetParam(objectfile, friction_notread); GetParam(objectfile, friction_tread); GetParam(objectfile, rolling_resistance); GetParam(objectfile, rolling_drag); if (params_per_object >= 15) GetParam(objectfile, isashadow); if (params_per_object >= 16) GetParam(objectfile, clamptexture); if (params_per_object >= 17) GetParam(objectfile, surface_type); for (int i = 0; i < params_per_object - expected_params; i++) GetParam(objectfile, otherjunk); MODEL * model(NULL); if (model_library.find(model_name) == model_library.end()) { if (packload) { if (!model_library[model_name].Load(model_name, error_output, true, &pack)) { error_output << "Error loading model: " << objectpath + "/" + model_name << " from pack " << objectpath + "/objects.jpk" << std::endl; return std::pair <bool, bool> (true, false); //fail the entire track loading } } else/**/ { if (!model_library[model_name].Load(objectpath + "/" + model_name, /*NULL,*/ error_output)) { error_output << "Error loading model: " << objectpath + "/" + model_name << std::endl; return std::pair <bool, bool> (true, false); //fail the entire track loading } } model = &model_library[model_name]; } bool skip = false; bool bNewMtr = false;/// if (dynamicshadowsenabled && isashadow) skip = true; if (texture_library.find(diffuse_texture_name) == texture_library.end()) { bNewMtr = true;/// TEXTUREINFO texinfo; texinfo.SetName(objectpath + "/" + diffuse_texture_name); texinfo.SetMipMap(mipmap || anisotropy); //always mipmap if anisotropy is on texinfo.SetAnisotropy(anisotropy); bool clampu = clamptexture == 1 || clamptexture == 2; bool clampv = clamptexture == 1 || clamptexture == 3; texinfo.SetRepeat(!clampu, !clampv); if (!texture_library[diffuse_texture_name].Load(texinfo, error_output, texture_size)) { error_output << "Error loading texture: " << objectpath + "/" + diffuse_texture_name << ", skipping object " << model_name << " and continuing" << std::endl; skip = true; //fail the loading of this model only } } if (!skip) { reseatable_reference <TEXTURE_GL> miscmap1; std::string miscmap1_texture_name = diffuse_texture_name.substr(0,std::max(0,(int)diffuse_texture_name.length()-4)); miscmap1_texture_name += std::string("-misc1.png"); if (texture_library.find(miscmap1_texture_name) == texture_library.end()) { TEXTUREINFO texinfo; std::string filepath = objectpath + "/" + miscmap1_texture_name; texinfo.SetName(filepath); texinfo.SetMipMap(mipmap); texinfo.SetAnisotropy(anisotropy); std::ifstream filecheck(filepath.c_str()); if (filecheck) { if (!texture_library[miscmap1_texture_name].Load(texinfo, error_output, texture_size)) { error_output << "Error loading texture: " << objectpath + "/" + miscmap1_texture_name << " for object " << model_name << ", continuing" << std::endl; texture_library.erase(miscmap1_texture_name); //don't fail, this isn't a critical error } else miscmap1 = texture_library[miscmap1_texture_name]; } } else miscmap1 = texture_library.find(miscmap1_texture_name)->second; TEXTURE_GL * diffuse = &texture_library[diffuse_texture_name]; TRACK_OBJECT object(model, diffuse, /*surfacePtr*/collideable || driveable ); objects.push_back(object); ///------------- push for ogre //bool mipmap; bool nolighting; //bool isashadow(false); //int clamptexture(0); OGRE_MESH om; om.found = true; om.sky = skybox; om.alpha = transparent_blend; om.newMtr = bNewMtr; om.name = model_name; om.material = diffuse_texture_name; om.mesh = &model->mesh; track->ogre_meshes.push_back(om);/// } return std::pair <bool, bool> (false, true); }
int main (int argc, char *argv[]) { int error; struct REGEX_INTERNAL_Automaton *a; unsigned int i; const char *filename = "test_graph.dot"; const char *regex[12] = { "ab(c|d)+c*(a(b|c)+d)+(bla)+", "(bla)*", "b(lab)*la", "(ab)*", "ab(c|d)+c*(a(b|c)+d)+(bla)(bla)*", "z(abc|def)?xyz", "1*0(0|1)*", "a*b*", "a+X*y+c|p|R|Z*K*y*R+w|Y*6+n+h*k*w+V*F|W*B*e*", "a", "a|b", "PADPADPADPADPADPabcdefghixxxxxxxxxxxxxjklmnop*qstoisdjfguisdfguihsdfgbdsuivggsd" }; GNUNET_log_setup ("test-regex", "WARNING", NULL); error = 0; for (i = 0; i < 12; i++) { /* Check NFA graph creation */ a = REGEX_INTERNAL_construct_nfa (regex[i], strlen (regex[i])); REGEX_TEST_automaton_save_graph (a, filename, REGEX_TEST_GRAPH_DEFAULT); REGEX_INTERNAL_automaton_destroy (a); error += filecheck (filename); a = REGEX_INTERNAL_construct_nfa (regex[i], strlen (regex[i])); REGEX_TEST_automaton_save_graph (a, filename, REGEX_TEST_GRAPH_DEFAULT | REGEX_TEST_GRAPH_VERBOSE); REGEX_INTERNAL_automaton_destroy (a); error += filecheck (filename); a = REGEX_INTERNAL_construct_nfa (regex[i], strlen (regex[i])); REGEX_TEST_automaton_save_graph (a, filename, REGEX_TEST_GRAPH_DEFAULT | REGEX_TEST_GRAPH_COLORING); REGEX_INTERNAL_automaton_destroy (a); error += filecheck (filename); a = REGEX_INTERNAL_construct_nfa (regex[i], strlen (regex[i])); REGEX_TEST_automaton_save_graph (a, filename, REGEX_TEST_GRAPH_DEFAULT | REGEX_TEST_GRAPH_VERBOSE | REGEX_TEST_GRAPH_COLORING); REGEX_INTERNAL_automaton_destroy (a); error += filecheck (filename); /* Check DFA graph creation */ a = REGEX_INTERNAL_construct_dfa (regex[i], strlen (regex[i]), 0); REGEX_TEST_automaton_save_graph (a, filename, REGEX_TEST_GRAPH_DEFAULT); REGEX_INTERNAL_automaton_destroy (a); error += filecheck (filename); a = REGEX_INTERNAL_construct_dfa (regex[i], strlen (regex[i]), 0); REGEX_TEST_automaton_save_graph (a, filename, REGEX_TEST_GRAPH_DEFAULT | REGEX_TEST_GRAPH_VERBOSE); REGEX_INTERNAL_automaton_destroy (a); error += filecheck (filename); a = REGEX_INTERNAL_construct_dfa (regex[i], strlen (regex[i]), 0); REGEX_TEST_automaton_save_graph (a, filename, REGEX_TEST_GRAPH_DEFAULT | REGEX_TEST_GRAPH_COLORING); REGEX_INTERNAL_automaton_destroy (a); error += filecheck (filename); a = REGEX_INTERNAL_construct_dfa (regex[i], strlen (regex[i]), 4); REGEX_TEST_automaton_save_graph (a, filename, REGEX_TEST_GRAPH_DEFAULT); REGEX_INTERNAL_automaton_destroy (a); error += filecheck (filename); } return error; }