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;
}
