struct regex * compile_regex(struct buffer *b, int flags, int needed_sub) { struct regex *new_regex; size_t re_len; /* // matches the last RE */ if (size_buffer(b) == 0) { if (flags > 0) bad_prog(_(BAD_MODIF)); return NULL; } re_len = size_buffer(b); new_regex = ck_malloc(sizeof (struct regex) + re_len - 1); new_regex->flags = flags; memcpy (new_regex->re, get_buffer(b), re_len); #ifdef REG_PERL new_regex->sz = re_len; #else /* GNU regex does not process \t & co. */ new_regex->sz = normalize_text(new_regex->re, re_len, TEXT_REGEX); #endif compile_regex_1 (new_regex, needed_sub); return new_regex; }
/****************************** DoSwap *************************** * This is where the work will be done *************************************************************************************/ OSErr DoSwap( FILE *inFile, FILE *outFile ) { OSErr error = noErr; long theTimePt; void *inData, *outData; long bufSize; int elemSize; void *buf; int count; elemSize = sizeof( float ); bufSize = u.id.xs * u.id.ys * elemSize; buf = ck_malloc( bufSize, "swap buffer" ); for( count=0; count<u.id.zs; count++ ) { if( u.Verbose ) { printf( "." ); } error = ck_fread( buf, sizeof( char ), bufSize, inFile ); ILError( error, "DoSwap" ); error = vbyteswap( buf, u.id.xs * u.id.ys, T_FLOAT ); ILError( error, "DoSwap" ); error = ck_fwrite( buf, sizeof( char ), bufSize, outFile ); ILError( error, "DoSwap" ); } return error; }
void CreateRoot(void) { struct PageHdr *PagePtr; /* Install the header of new page */ PagePtr = (struct PageHdr *) malloc(sizeof(struct PageHdr)); ck_malloc(PagePtr, "PagePtr"); PagePtr->PgTypeID = LeafSymbol; PagePtr->PgNum = ROOT; PagePtr->PgNumOfNxtLfPg = NULLPAGENO; PagePtr->KeyListPtr = NULL; /* no keys yet */ FlushPage(PagePtr); /* fills in #bytes & #keys */ }
struct font_memo * intern_font (char * oleo_name, double scale) { struct font_names *names = find_font_name (oleo_name); struct font_memo *it = font_list; while (it) { if ((scale == font_list->scale) && (names == font_list->names)) return it; it = it->next; } it = (struct font_memo *)ck_malloc (sizeof (*it)); it->scale = scale; it->names = names; it->next = font_list; font_list = it; return it; }
void builtin_help (char * name) { char info_name[100]; struct info_buffer * ib; if (strlen (name) > sizeof (info_name) - 20) io_error_msg ("No built in help for %s.", name); sprintf (info_name, "_info_%s", name); ib = find_info (info_name); if (!ib) { char ** msg = forminfo_text (name); if (!msg) { msg = (char **)ck_malloc (sizeof (char *) * 2); msg[0] = mk_sprintf ("No built in help for %s.", name); msg[1] = 0; } ib = find_or_make_info (info_name); ib->len = parray_len (msg); ib->text = msg; } { char exp_name[200]; char command[250]; struct info_buffer * expanded; sprintf (exp_name, "_expanded_%s", info_name); expanded = find_or_make_info (exp_name); clear_info (expanded); expand_help_msg (expanded, ib); sprintf (command, "{set-info %s}", exp_name); run_string_as_macro (command); } }
void define_font (char * oleo_name, char * x_name, char * ps_name) { struct font_names * fn; for (fn = font_names; fn; fn = fn->next) if (!stricmp(fn->oleo_name, oleo_name)) { if (fn->x_name) free (fn->x_name); if (fn->ps_name) free (fn->ps_name); break; } if (!fn) { fn = (struct font_names *)ck_malloc (sizeof (*fn)); fn->oleo_name = strdup (oleo_name); fn->next = font_names; font_names = fn; } fn->x_name = strdup (x_name); fn->ps_name = strdup (ps_name); }
struct PageHdr *FetchPage(PAGENO Page) /* Page number of page to be fetched */ { struct PageHdr *PagePtr; struct KeyRecord *KeyNode, *KeyListTraverser; /* To traverse the list of keys */ int i; fetchPageCount++; PAGENO FindNumPagesInTree(void); /* check validity of "Page" */ if ((Page < 1) || (Page > FindNumPagesInTree())) { printf("FetchPage: Pagenum %d out of range (%d,%d)\n", (int) Page, (int) ROOT, (int) FindNumPagesInTree()); /* exit(-1); */ } /* Read in the page header */ PagePtr = (struct PageHdr *) malloc(sizeof(*PagePtr)); ck_malloc(PagePtr, "PagePtr"); fseek(fpbtree, (long) Page * PAGESIZE - PAGESIZE, 0); fread(&PagePtr->PgTypeID, sizeof(char), 1, fpbtree); fread(&PagePtr->PgNum, sizeof(PagePtr->PgNum), 1, fpbtree); if ((PagePtr->PgNum) != Page) { printf("FetchPage: corrupted Page %d\n", (int) Page); exit(-1); } if (IsLeaf(PagePtr)) fread(&PagePtr->PgNumOfNxtLfPg, sizeof(PagePtr->PgNumOfNxtLfPg), 1, fpbtree); fread(&PagePtr->NumBytes, sizeof(PagePtr->NumBytes), 1, fpbtree); fread(&PagePtr->NumKeys, sizeof(PagePtr->NumKeys), 1, fpbtree); PagePtr->KeyListPtr = NULL; if (IsNonLeaf(PagePtr)) fread(&PagePtr->PtrToFinalRtgPg, sizeof(PagePtr->PtrToFinalRtgPg), 1, fpbtree); /* Read in the keys */ KeyListTraverser = NULL; for (i = 0; i < PagePtr->NumKeys; i++) { KeyNode = (struct KeyRecord *) malloc(sizeof(*KeyNode)); ck_malloc(KeyNode, "KeyNode"); if (IsNonLeaf(PagePtr)) fread(&KeyNode->PgNum, sizeof(KeyNode->PgNum), 1, fpbtree); fread(&KeyNode->KeyLen, sizeof(KeyNode->KeyLen), 1, fpbtree); KeyNode->StoredKey = (char *) malloc((KeyNode->KeyLen) + 1); ck_malloc(KeyNode->StoredKey, "KeyNode->StoredKey in FetchPage()"); fread(KeyNode->StoredKey, sizeof(char), KeyNode->KeyLen, fpbtree); (*(KeyNode->StoredKey + KeyNode->KeyLen)) = '\0'; /* string terminator */ if (IsLeaf(PagePtr)) fread(&KeyNode->Posting, sizeof(KeyNode->Posting), 1, fpbtree); if (KeyListTraverser == NULL) { KeyListTraverser = KeyNode; PagePtr->KeyListPtr = KeyNode; } else { KeyListTraverser->Next = KeyNode; KeyListTraverser = KeyListTraverser->Next; } } if (PagePtr->NumKeys != 0) KeyListTraverser->Next = NULL; return (PagePtr); }
int G2A (int argc, char *argv[] ) { char origname[128]; // original name char newname [128]; // renumbered name char command [255]; // command buffer char *TempName; char *numstring; char ImageName[128]; int counter = 0; int number; char *p; char nameFileName[255]; char analyzeFileName[255]; char headerFileName[255]; char baseName[255]; short verbose = true; FILE *nameFile; FILE *TempFile; FILE *dataFile; FILE *procFile; FILE *headerFile; FILE *inFile; int i; IMAGE im; short count; short *dataBuff; Boolean DebugMode = false; static char id[] = "$Revision: 1.21 $$Date: 2006/06/09 18:40:34 $"; OSErr error = noErr; if( argc < 2 ) { print_usage( argv[0] ); } // setup an output file name, based on the last input file name sprintf( baseName, "%s", argv[argc-1] ); // output file name p = strrchr( baseName, 'I' ); *p = '\0'; // null terminate error = OpenProcFile( argc, argv, baseName, id, &procFile ); ILError( error, "Opening Proc file" ); sprintf( nameFileName, "%s.NAME_FILE", baseName ); fprintf( procFile, "Associated name file ... %s\n", nameFileName ); sprintf( headerFileName, "%s.GenesisHdrs", baseName ); fprintf( procFile, "Associated headers file ... %s\n", headerFileName ); // corrected names will be stored temporarily in nameFile error = CreateTempFile( &TempFile, &TempName ); ILError( error, TempName ); // use UC_ReadHeader to determine image dimensions, etc... error = UC_Readheader( argv[argc-1], &im ); if( error ) ILError( error, "Read Image" ); // rename the files and create name list into the file called TempName for( i=argc-1; i>0; i-- ) { strcpy( origname, argv[i] ); strcpy( newname, argv[i] ); numstring = strrchr( newname, 'I' ) + 1; number = atoi( numstring ); sprintf( numstring, "%0.3d.MR", number ); fprintf( TempFile, "%s\n", newname ); if( strcmp( origname, newname ) || DebugMode ) { if( verbose ) { printf( "i:%d\t%s --> %s\n", i, origname, newname ); } sprintf( command, "mv %s %s\n", origname, newname ); fprintf( procFile, "\tRenamed %s to %s\n", origname, newname ); system( command ); } } error = ck_fclose( TempFile ); ILError( error, TempName ); // Sort the contents of the temporary nameFile and place it into the permanent version sprintf( command, "sort %s > %s", TempName, nameFileName ); system( command ); if( false ) { DBG( command ); printf( "\nContents of name file\n" ); sprintf( command, "cat %s", nameFileName ); DBG( command ); system( command ); } // now, place the name of the header file at the beginning of a file */ error = CreateTempFile( &TempFile, &TempName ); ILError ( error, TempName ); fprintf( TempFile, "%s\n", headerFileName ); error = ck_fclose( TempFile ); ILError( error, TempName ); // add the file names to the end sprintf( command, "cat %s >> %s\n", nameFileName, TempName ); system( command ); // and rename this file sprintf( command, "mv %s %s\n", TempName, nameFileName ); system( command ); if( false ) { printf( "new Contents of name file" ); sprintf( command, "cat %s", nameFileName ); DBG( command ); system( command ); } im.dim.n_slices = argc - 1; error = CreateHeader( ANALYZE, &im, baseName ); if( error ) ILError( error, "Writing Header" ); sprintf( analyzeFileName, "%s.img", baseName ); error = ck_fopen( &dataFile, analyzeFileName, "wb" ); ILError( error, "data file" ); error = ck_fopen( &nameFile, nameFileName, "rb" ); ILError( error, "name file" ); error = ck_fopen( &headerFile, headerFileName, "wb" ); ILError( error, "header file" ); if( im.dim.x * im.dim.y * sizeof(short) < SIGHDRSIZE ) { dataBuff = (short *)ck_malloc( SIGHDRSIZE, "data buffer" ); } else { dataBuff = (short *)ck_malloc( im.dim.x * im.dim.y * sizeof(short), "data buffer" ); } count = fscanf( nameFile, "%s", headerFileName ); // just read past this. count = fscanf( nameFile, "%s", ImageName ); if( false ) { DBG( ImageName ); } printf( "\n\tPatience for a moment\n" ); while( count>0 ) { printf( "%d of %d complete\n", counter++, argc - 1 ); error = ck_fopen( &inFile, ImageName, "rb" ); ILError( error, "Opening image" ); error = ck_fread ( dataBuff, sizeof( char ), SIGHDRSIZE, inFile ); ILError( error, "Reading header" ); error = ck_fwrite( dataBuff, sizeof( char ), SIGHDRSIZE, headerFile ); ILError( error, "Writing image header" ); error = ck_fread ( dataBuff, sizeof( short ), im.dim.x * im.dim.y, inFile ); ILError( error, "Reading image data" ); error = ck_fwrite( dataBuff, sizeof( short ), im.dim.x * im.dim.y, dataFile ); ILError( error, "Writing image data" ); ck_fclose( inFile ); count = fscanf( nameFile, "%s", ImageName ); } printf( "\n\nCreated Analyze (4D) file: %s\n", analyzeFileName ); printf( "\tSave these files!: %s and %s\n\n", nameFileName, headerFileName ); printf( "To create corresponding genesis images from an analyze file named XXX.img, use:\n" ); printf( "\tAnalyze2Genesis -n %s -i XXX.img\n", nameFileName ); free( dataBuff ); error = ck_fclose( headerFile ); if( error ) ILError( error, headerFileName ); error = ck_fclose( nameFile ); if( error ) ILError( error, nameFileName ); error = ck_fclose( dataFile ); if( error ) ILError( error, analyzeFileName ); error = ck_fclose( procFile ); if( error ) ILError( error, "proc file" ); return error; }
/* * Extract a file from the archive. */ void extract_archive () { register char *data; int fd, check, namelen, written, openflag; long size; struct utimbuf acc_upd_times; register int skipcrud; register int i; /* int sparse_ind = 0;*/ union record *exhdr; struct saved_dir_info *tmp; /* int end_nulls; */ saverec (&head); /* Make sure it sticks around */ userec (head); /* And go past it in the archive */ decode_header (head, &hstat, &head_standard, 1); /* Snarf fields */ if ((f_confirm && !confirm ("extract", current_file_name)) || (f_exstdout && head->header.linkflag != LF_OLDNORMAL && head->header.linkflag != LF_NORMAL && head->header.linkflag != LF_CONTIG)) { if (head->header.isextended) skip_extended_headers (); skip_file ((long) hstat.st_size); saverec ((union record **) 0); return; } /* Print the record from 'head' and 'hstat' */ if (f_verbose) print_header (); /* * Check for fully specified pathnames and other atrocities. * * Note, we can't just make a pointer to the new file name, * since saverec() might move the header and adjust "head". * We have to start from "head" every time we want to touch * the header record. */ skipcrud = 0; while (!f_absolute_paths && '/' == current_file_name[skipcrud]) { static int warned_once = 0; skipcrud++; /* Force relative path */ if (!warned_once++) { msg ("Removing leading / from absolute path names in the archive."); } } switch (head->header.linkflag) { default: msg ("Unknown file type '%c' for %s, extracted as normal file", head->header.linkflag, skipcrud + current_file_name); /* FALL THRU */ /* * JK - What we want to do if the file is sparse is loop through * the array of sparse structures in the header and read in * and translate the character strings representing 1) the offset * at which to write and 2) how many bytes to write into numbers, * which we store into the scratch array, "sparsearray". This * array makes our life easier the same way it did in creating * the tar file that had to deal with a sparse file. * * After we read in the first five (at most) sparse structures, * we check to see if the file has an extended header, i.e., * if more sparse structures are needed to describe the contents * of the new file. If so, we read in the extended headers * and continue to store their contents into the sparsearray. */ case LF_SPARSE: sp_array_size = 10; sparsearray = (struct sp_array *) ck_malloc (sp_array_size * sizeof (struct sp_array)); for (i = 0; i < SPARSE_IN_HDR; i++) { sparsearray[i].offset = from_oct (1 + 12, head->header.sp[i].offset); sparsearray[i].numbytes = from_oct (1 + 12, head->header.sp[i].numbytes); if (!sparsearray[i].numbytes) break; } /* end_nulls = from_oct(1+12, head->header.ending_blanks);*/ if (head->header.isextended) { /* read in the list of extended headers and translate them into the sparsearray as before */ /* static */ int ind = SPARSE_IN_HDR; for (;;) { exhdr = findrec (); for (i = 0; i < SPARSE_EXT_HDR; i++) { if (i + ind > sp_array_size - 1) { /* * realloc the scratch area * since we've run out of room -- */ sparsearray = (struct sp_array *) ck_realloc (sparsearray, 2 * sp_array_size * (sizeof (struct sp_array))); sp_array_size *= 2; } if (!exhdr->ext_hdr.sp[i].numbytes) break; sparsearray[i + ind].offset = from_oct (1 + 12, exhdr->ext_hdr.sp[i].offset); sparsearray[i + ind].numbytes = from_oct (1 + 12, exhdr->ext_hdr.sp[i].numbytes); } if (!exhdr->ext_hdr.isextended) break; else { ind += SPARSE_EXT_HDR; userec (exhdr); } } userec (exhdr); } /* FALL THRU */ case LF_OLDNORMAL: case LF_NORMAL: case LF_CONTIG: /* * Appears to be a file. * See if it's really a directory. */ namelen = strlen (skipcrud + current_file_name) - 1; if (current_file_name[skipcrud + namelen] == '/') goto really_dir; /* FIXME, deal with protection issues */ again_file: openflag = (f_keep ? O_BINARY | O_NDELAY | O_WRONLY | O_CREAT | O_EXCL : O_BINARY | O_NDELAY | O_WRONLY | O_CREAT | O_TRUNC) | ((head->header.linkflag == LF_SPARSE) ? 0 : O_APPEND); /* * JK - The last | is a kludge to solve the problem * the O_APPEND flag causes with files we are * trying to make sparse: when a file is opened * with O_APPEND, it writes to the last place * that something was written, thereby ignoring * any lseeks that we have done. We add this * extra condition to make it able to lseek when * a file is sparse, i.e., we don't open the new * file with this flag. (Grump -- this bug caused * me to waste a good deal of time, I might add) */ if (f_exstdout) { fd = 1; goto extract_file; } if (f_unlink && !f_keep) { if (unlink(skipcrud + current_file_name) == -1) if (errno != ENOENT) msg_perror ("Could not unlink %s", skipcrud + current_file_name); } #ifdef O_CTG /* * Contiguous files (on the Masscomp) have to specify * the size in the open call that creates them. */ if (head->header.linkflag == LF_CONTIG) fd = open ((longname ? longname : head->header.name) + skipcrud, openflag | O_CTG, hstat.st_mode, hstat.st_size); else #endif { #ifdef NO_OPEN3 /* * On raw V7 we won't let them specify -k (f_keep), but * we just bull ahead and create the files. */ fd = creat ((longname ? longname : head->header.name) + skipcrud, hstat.st_mode); #else /* * With 3-arg open(), we can do this up right. */ fd = open (skipcrud + current_file_name, openflag, hstat.st_mode); #endif } if (fd < 0) { if (make_dirs (skipcrud + current_file_name)) goto again_file; msg_perror ("Could not create file %s", skipcrud + current_file_name); if (head->header.isextended) skip_extended_headers (); skip_file ((long) hstat.st_size); goto quit; } extract_file: if (head->header.linkflag == LF_SPARSE) { char *name; int namelen; /* * Kludge alert. NAME is assigned to header.name * because during the extraction, the space that * contains the header will get scribbled on, and * the name will get munged, so any error messages * that happen to contain the filename will look * REAL interesting unless we do this. */ namelen = strlen (skipcrud + current_file_name) + 1; name = (char *) ck_malloc ((sizeof (char)) * namelen); bcopy (skipcrud + current_file_name, name, namelen); size = hstat.st_size; extract_sparse_file (fd, &size, hstat.st_size, name); } else for (size = hstat.st_size; size > 0; size -= written) { /* long offset, numbytes;*/ if (f_multivol) { save_name = current_file_name; save_totsize = hstat.st_size; save_sizeleft = size; } /* * Locate data, determine max length * writeable, write it, record that * we have used the data, then check * if the write worked. */ data = findrec ()->charptr; if (data == NULL) { /* Check it... */ msg ("Unexpected EOF on archive file"); break; } /* * JK - If the file is sparse, use the sparsearray * that we created before to lseek into the new * file the proper amount, and to see how many * bytes we want to write at that position. */ /* if (head->header.linkflag == LF_SPARSE) { off_t pos; pos = lseek(fd, (off_t) sparsearray[sparse_ind].offset, 0); printf("%d at %d\n", (int) pos, sparse_ind); written = sparsearray[sparse_ind++].numbytes; } else*/ written = endofrecs ()->charptr - data; if (written > size) written = size; errno = 0; check = write (fd, data, written); /* * The following is in violation of strict * typing, since the arg to userec * should be a struct rec *. FIXME. */ userec ((union record *) (data + written - 1)); if (check == written) continue; /* * Error in writing to file. * Print it, skip to next file in archive. */ if (check < 0) msg_perror ("couldn't write to file %s", skipcrud + current_file_name); else msg ("could only write %d of %d bytes to file %s", check, written, skipcrud + current_file_name); skip_file ((long) (size - written)); break; /* Still do the close, mod time, chmod, etc */ } if (f_multivol) save_name = 0; /* If writing to stdout, don't try to do anything to the filename; it doesn't exist, or we don't want to touch it anyway */ if (f_exstdout) break; /* if (head->header.isextended) { register union record *exhdr; register int i; for (i = 0; i < 21; i++) { long offset; if (!exhdr->ext_hdr.sp[i].numbytes) break; offset = from_oct(1+12, exhdr->ext_hdr.sp[i].offset); written = from_oct(1+12, exhdr->ext_hdr.sp[i].numbytes); lseek(fd, offset, 0); check = write(fd, data, written); if (check == written) continue; } }*/ check = close (fd); if (check < 0) { msg_perror ("Error while closing %s", skipcrud + current_file_name); } set_filestat: /* * If we are root, set the owner and group of the extracted * file. This does what is wanted both on real Unix and on * System V. If we are running as a user, we extract as that * user; if running as root, we extract as the original owner. */ if (we_are_root || f_do_chown) { if (chown (skipcrud + current_file_name, hstat.st_uid, hstat.st_gid) < 0) { msg_perror ("cannot chown file %s to uid %d gid %d", skipcrud + current_file_name, hstat.st_uid, hstat.st_gid); } } /* * Set the modified time of the file. * * Note that we set the accessed time to "now", which * is really "the time we started extracting files". * unless f_gnudump is used, in which case .st_atime is used */ if (!f_modified) { /* fixme if f_gnudump should set ctime too, but how? */ if (f_gnudump) acc_upd_times.actime = hstat.st_atime; else acc_upd_times.actime = now; /* Accessed now */ acc_upd_times.modtime = hstat.st_mtime; /* Mod'd */ if (utime (skipcrud + current_file_name, &acc_upd_times) < 0) { msg_perror ("couldn't change access and modification times of %s", skipcrud + current_file_name); } } /* We do the utime before the chmod because some versions of utime are broken and trash the modes of the file. Since we then change the mode anyway, we don't care. . . */ /* * If '-k' is not set, open() or creat() could have saved * the permission bits from a previously created file, * ignoring the ones we specified. * Even if -k is set, if the file has abnormal * mode bits, we must chmod since writing or chown() has * probably reset them. * * If -k is set, we know *we* created this file, so the mode * bits were set by our open(). If the file is "normal", we * skip the chmod. This works because we did umask(0) if -p * is set, so umask will have left the specified mode alone. */ if ((!f_keep) || (hstat.st_mode & (S_ISUID | S_ISGID | S_ISVTX))) { if (chmod (skipcrud + current_file_name, notumask & (int) hstat.st_mode) < 0) { msg_perror ("cannot change mode of file %s to 0%o", skipcrud + current_file_name, notumask & (int) hstat.st_mode); } } quit: break; case LF_LINK: again_link: { struct stat st1, st2; if (f_unlink && !f_keep) { if (unlink(skipcrud + current_file_name) == -1) if (errno != ENOENT) msg_perror ("Could not unlink %s", skipcrud + current_file_name); } check = link (current_link_name, skipcrud + current_file_name); if (check == 0) break; if (make_dirs (skipcrud + current_file_name)) goto again_link; if (f_gnudump && errno == EEXIST) break; if (stat (current_link_name, &st1) == 0 && stat (current_file_name + skipcrud, &st2) == 0 && st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino) break; msg_perror ("Could not link %s to %s", skipcrud + current_file_name, current_link_name); } break; #ifdef S_ISLNK case LF_SYMLINK: again_symlink: if (f_unlink && !f_keep) { if (unlink(skipcrud + current_file_name) == -1) if (errno != ENOENT) msg_perror ("Could not unlink %s", skipcrud + current_file_name); } check = symlink (current_link_name, skipcrud + current_file_name); /* FIXME, don't worry uid, gid, etc... */ if (check == 0) break; if (make_dirs (current_file_name + skipcrud)) goto again_symlink; msg_perror ("Could not create symlink to %s", current_link_name); break; #endif #ifdef S_IFCHR case LF_CHR: hstat.st_mode |= S_IFCHR; goto make_node; #endif #ifdef S_IFBLK case LF_BLK: hstat.st_mode |= S_IFBLK; #endif #if defined(S_IFCHR) || defined(S_IFBLK) make_node: if (f_unlink && !f_keep) { if (unlink(skipcrud + current_file_name) == -1) if (errno != ENOENT) msg_perror ("Could not unlink %s", skipcrud + current_file_name); } check = mknod (current_file_name + skipcrud, (int) hstat.st_mode, (int) hstat.st_rdev); if (check != 0) { if (make_dirs (skipcrud + current_file_name)) goto make_node; msg_perror ("Could not make %s", current_file_name + skipcrud); break; }; goto set_filestat; #endif #ifdef S_ISFIFO /* If local system doesn't support FIFOs, use default case */ case LF_FIFO: make_fifo: if (f_unlink && !f_keep) { if (unlink(skipcrud + current_file_name) == -1) if (errno != ENOENT) msg_perror ("Could not unlink %s", skipcrud + current_file_name); } check = mkfifo (current_file_name + skipcrud, (int) hstat.st_mode); if (check != 0) { if (make_dirs (current_file_name + skipcrud)) goto make_fifo; msg_perror ("Could not make %s", skipcrud + current_file_name); break; }; goto set_filestat; #endif case LF_DIR: case LF_DUMPDIR: namelen = strlen (current_file_name + skipcrud) - 1; really_dir: /* Check for trailing /, and zap as many as we find. */ while (namelen && current_file_name[skipcrud + namelen] == '/') current_file_name[skipcrud + namelen--] = '\0'; if (f_gnudump) { /* Read the entry and delete files that aren't listed in the archive */ gnu_restore (skipcrud); } else if (head->header.linkflag == LF_DUMPDIR) skip_file ((long) (hstat.st_size)); again_dir: check = mkdir (skipcrud + current_file_name, (we_are_root ? 0 : 0300) | (int) hstat.st_mode); if (check != 0) { struct stat st1; if (make_dirs (skipcrud + current_file_name)) goto again_dir; /* If we're trying to create '.', let it be. */ if (current_file_name[skipcrud + namelen] == '.' && (namelen == 0 || current_file_name[skipcrud + namelen - 1] == '/')) goto check_perms; if (errno == EEXIST && stat (skipcrud + current_file_name, &st1) == 0 && (S_ISDIR (st1.st_mode))) break; msg_perror ("Could not create directory %s", skipcrud + current_file_name); break; } check_perms: if (!we_are_root && 0300 != (0300 & (int) hstat.st_mode)) { hstat.st_mode |= 0300; msg ("Added write and execute permission to directory %s", skipcrud + current_file_name); } /* * If we are root, set the owner and group of the extracted * file. This does what is wanted both on real Unix and on * System V. If we are running as a user, we extract as that * user; if running as root, we extract as the original owner. */ if (we_are_root || f_do_chown) { if (chown (skipcrud + current_file_name, hstat.st_uid, hstat.st_gid) < 0) { msg_perror ("cannot chown file %s to uid %d gid %d", skipcrud + current_file_name, hstat.st_uid, hstat.st_gid); } } if (!f_modified) { tmp = ((struct saved_dir_info *) ck_malloc (sizeof (struct saved_dir_info))); tmp->path = (char *) ck_malloc (strlen (skipcrud + current_file_name) + 1); strcpy (tmp->path, skipcrud + current_file_name); tmp->mode = hstat.st_mode; tmp->atime = hstat.st_atime; tmp->mtime = hstat.st_mtime; tmp->next = saved_dir_info_head; saved_dir_info_head = tmp; } else { /* This functions exactly as the code for set_filestat above. */ if ((!f_keep) || (hstat.st_mode & (S_ISUID | S_ISGID | S_ISVTX))) { if (chmod (skipcrud + current_file_name, notumask & (int) hstat.st_mode) < 0) { msg_perror ("cannot change mode of file %s to 0%o", skipcrud + current_file_name, notumask & (int) hstat.st_mode); } } } break; case LF_VOLHDR: if (f_verbose) { printf ("Reading %s\n", current_file_name); } break; case LF_NAMES: extract_mangle (head); break; case LF_MULTIVOL: msg ("Can't extract '%s'--file is continued from another volume\n", current_file_name); skip_file ((long) hstat.st_size); break; case LF_LONGNAME: case LF_LONGLINK: msg ("Visible long name error\n"); skip_file ((long) hstat.st_size); break; } /* We don't need to save it any longer. */ saverec ((union record **) 0);/* Unsave it */ }
int main(int argc, char **argv) { static char id[] = "$Revision: 1.5 $$Date: 2002/09/10 22:14:51 $"; char *invec, *outvec; /* image vectors */ int timePt; short rows = 0; short cols = 0; int slices; long MultImSize; /* size of one image */ short SmallX, SmallY; /* X and Y size of single image from multi-display */ int argp=EOF; char *in_fname = NULL; char *out_basename = NULL; char out_fname[128], procfname[128]; FILE *imFile; FILE *procFile; IMAGE im; short dSize; char typeString[40]; OSErr error = noErr; while ( (argp=getopt(argc,argv,"o:i:r:c:h?")) != EOF ) { switch( argp ) { case 'o': out_basename = optarg; break; case 'i': in_fname = optarg; break; case 'c': cols = atoi( optarg ); break; case 'r': rows = atoi( optarg ); break; case 'h': case '?': default: print_usage( argv[0] ); exit( -1 ); break; } } if( !out_basename || !in_fname || !rows || !cols ) { print_usage( argv[0] ); exit(-1); } error = UC_Readheader(in_fname, &im); if( error ) { ILError( error, "Reading Header" ); } switch( im.file_type ) { case BSHORT: dSize = get_datasize( T_USHORT ); sprintf( typeString, "bshort" ); break; case BUCHAR: dSize = get_datasize( T_UCHAR ); sprintf( typeString, "buchar" ); break; case BFLOAT: dSize = get_datasize( T_FLOAT ); sprintf( typeString, "bfloat" ); break; default: ILError( DATA_OUT_OF_RANGE, "unknown type" ); } /* Parse output file name and create proc file name */ strcpy( procfname, out_basename ); MultImSize= im.dim.x*im.dim.y; SmallX = im.dim.x / cols; SmallY = im.dim.y / rows; slices = rows * cols; /* Buffer allocation */ invec = ( char *)ck_malloc( MultImSize * dSize, "image vector" ); outvec = ( char *)ck_malloc( SmallX * SmallY * slices * dSize, "output vector" ); imFile = errfopen( in_fname, "rb" ); error = OpenProcFile( argc, argv, procfname, id, &procFile ); ILError( error, "Opening Proc file" ); for( timePt = 0; timePt < im.dim.timePts; timePt++ ) { int theSlice = 0; error = UC_Readimage( imFile, &im, invec, theSlice, timePt ); if( error ) { ILError( error, "Reading image" ); } // fool unmdisplay by treating all input as char error = unmdisplay( outvec, invec, SmallX * dSize, SmallY, slices, T_UCHAR ); if( error ) { ILError( error, "unmdisplay" ); } if( im.dim.timePts > 1 ) { sprintf( out_fname, "%s.%0.3d", out_basename, timePt+1 ); } else { sprintf( out_fname, "%s", out_basename ); } fprintf( procFile, "\tCreated %s.%s\n", out_fname, typeString ); error = WriteMGHImage( outvec, out_fname, SmallX, SmallY, (short)slices, im.data_type ); if( error ) { ILError( error, "Writing output image" ); } } error = ck_fclose( imFile ); if( error ) ILError( error, "input file" ); error = ck_fclose( procFile ); if( error ) ILError( error, "proc file" ); free( outvec ); free( invec ); return 0; }
/********************************** T2Fit ************************************ * This is where the work will be done *************************************************************************************/ OSErr T2Fit( FILE *inFile, FILE *outFile ) { OSErr error = noErr; long theTimePt; int i; float *inData, *outData, *T2, *intercept, *chi2, *Smoother; long VolSize, outVolBytes, inVolBytes; float te[ u.inIm.dim.timePts ]; unsigned char *theMask; short rules; u.NumOutImages = 0; VolSize = u.inIm.dim.isoX * u.inIm.dim.isoY * u.inIm.dim.n_slices; inVolBytes = VolSize * get_datasize( T_FLOAT ); outVolBytes = VolSize * get_datasize( u.outIm.data_type ); T2 = (float *)ck_malloc( inVolBytes, "Storage for R2" ); intercept = (float *)ck_malloc( inVolBytes, "Storage for intercept" ); chi2 = (float *)ck_malloc( inVolBytes, "Storage for chi2" ); outData = (float *)ck_malloc( outVolBytes, "Storage for output data" ); inData = (float *)ck_malloc( inVolBytes * u.inIm.dim.timePts, "Storage for input data" ); theMask = (unsigned char*)ck_malloc( VolSize * sizeof( unsigned char ), "Storage for theMask" ); if( u.Smooth ) { Smoother = (float *)ck_malloc( inVolBytes * 2, "Storage for smoothing" ); } // load up te vector if( u.Verbose ) { printf( "TE: " ); } for( i=0; i<u.inIm.dim.timePts; i++ ) { fscanf(u.TEFile ,"%f", &te[i]); if( u.Verbose ) { printf( "%0.3f ", te[i] ); } } // We will do everything in float SetImDatatype( &u.inIm, T_FLOAT ); // Load all of the images into a single matrix for ( theTimePt = 0; theTimePt < u.inIm.dim.timePts; theTimePt++ ) { error = GetSelectedVolume( inFile, &u.inIm, inData+theTimePt*VolSize, theTimePt ); RETURNONERROR; if( u.Smooth ) { vmov( inData+theTimePt*VolSize, 1, Smoother, 1, VolSize, T_FLOAT ); error = gaussSmooth( &u.inIm, Smoother, inData+theTimePt*VolSize, &u.xSmooth, &u.ySmooth, &u.zSmooth ); RETURNONERROR; } RETURNONERROR; } // threshold on first images if( u.autoThresh ) { error = autoMask( inData, theMask, VolSize, &u.threshold, &u.nonNoise, T_FLOAT ); RETURNONERROR; } else if( u.threshold != 0 ) { u.nonNoise = ThreshMask( inData, theMask, VolSize, &u.threshold, T_FLOAT ); } else { u.nonNoise = VolSize; } error = CalcT2( &u.inIm, inData, theMask, te, T2, intercept, chi2 ); RETURNONERROR; free( inData ); error = type_convert( T2, T_FLOAT, outData, u.outIm.data_type, VolSize, &u.outIm.theMinf, &u.outIm.theMaxf, &rules ); if( error && error != CONVERSION_ERROR ) return error; error = ck_fwrite( outData, 1, outVolBytes, outFile ); u.NumOutImages++; RETURNONERROR; error = type_convert( intercept, T_FLOAT, outData, u.outIm.data_type, VolSize, &u.outIm.theMinf, &u.outIm.theMaxf, &rules ); if( error && error != CONVERSION_ERROR ) return error; error = ck_fwrite( outData, 1, outVolBytes, outFile ); u.NumOutImages++; RETURNONERROR; if( u.Smooth ) { free( Smoother ); } // Make R2 image for( i=0; i<VolSize; i++ ) { if( T2[i] !=0 ) { T2[i] = 1/T2[i]; } } error = type_convert( T2, T_FLOAT, outData, u.outIm.data_type, VolSize, &u.outIm.theMinf, &u.outIm.theMaxf, &rules ); if( error && error != CONVERSION_ERROR ) return error; error = ck_fwrite( outData, 1, outVolBytes, outFile ); u.NumOutImages++; RETURNONERROR; error = type_convert( chi2, T_FLOAT, outData, u.outIm.data_type, VolSize, &u.outIm.theMinf, &u.outIm.theMaxf, &rules ); if( error && error != CONVERSION_ERROR ) return error; error = ck_fwrite( outData, 1, outVolBytes, outFile ); u.NumOutImages++; RETURNONERROR; fprintf( u.ProcFile, "Output file contains maps of T2, M0, R2 and chi2\n" ); fprintf( u.ProcFile, "TE's used: " ); for( i=0; i<u.inIm.dim.timePts; i++ ) { fprintf( u.ProcFile, "%0.3f ", te[i] ); } fprintf( u.ProcFile, "\n" ); fprintf( u.ProcFile, "Input data were intensity thresholded at %0.3f\n", u.threshold ); fprintf( u.ProcFile, "Non-Noise Points:\t%ld\n", u.nonNoise ); if( u.Smooth ) { fprintf( u.ProcFile, "Input images were smoothed with a width of %0.3f mm in x, %0.3f mm in y and %0.3f mm in z\n", u.xSmooth, u.ySmooth, u.zSmooth ); } fprintf( stderr, "Output file contains maps of T2, M0, R2 and chi2\n" ); fprintf( stderr, "TE's used: " ); for( i=0; i<u.inIm.dim.timePts; i++ ) { fprintf( stderr, "%0.3f ", te[i] ); } fprintf( stderr, "\n" ); fprintf( stderr, "Input data were intensity thresholded at %0.3f\n", u.threshold ); fprintf( stderr, "Non-Noise Points:\t%ld\n\n", u.nonNoise ); if( u.Smooth ) { fprintf( stderr, "Input images were smoothed with a width of %0.3f mm in x, %0.3f mm in y and %0.3f mm in z\n", u.xSmooth, u.ySmooth, u.zSmooth ); } free( theMask ); free( outData ); free( chi2 ); free( intercept ); free( T2 ); return error; }