BOOL CFileDetailDialogName::OnApply()
{
if (!m_bDataChanged)
RenameFile();
return CResizablePage::OnApply();
}
main()
{
static char text[MAXSEARCH]; /* Pointer to buffer for search text */
static char date_time[19]; /* Receive file date and time */
int err, mode, handle, len; /* Codes, file handle, bytes read */
int row, col, ch; /* Cursor coordinates, kb character */
int i, j, attr; /* Index variables, file attribute */
int disp_attr; /* Display attribute */
char *spec, *ptr, *buffer; /* File spec, char match, read buffer */
long dsize, disk_use; /* Disk size and usage */
struct DISKSTAT disk; /* Structure for disk size params */
static char copy_msg[] =
{
"Files can be copied or moved in 2 different modes:\n" \
" 0 - overwrite target file if it exists\n" \
" 1 - abort if target file exists\n\n" \
"Mode 1 is supported only with DOS versions 3.0 or higher.\n"
};
static char move_msg[] =
{
"Quick Move uses DOS function 56h (Rename File) to effectively " \
"move a file from\none directory to another directory on the " \
"same drive. It copies the entry\nfrom the source directory to " \
"the target directory, but does not physically\ncopy the file.\n\n" \
"Source and target specifications must be given in full, " \
"including filenames,\neven if the names are the same."
};
static char grep_msg[] =
{
"The Find Text option uses the StrFindChar and StrCompare procedures " \
"to locate\na text string within specified files, like Unix's " \
"\"grep\" command. Find Text\nis limited to case-sensitive searches " \
"within the current directory.\n\nEnter the desired search string " \
"without quotation marks. When specifying the\nfilename, use " \
"wildcard characters to expand the search to a group of files --\n" \
"for example, \"*.*\" searches all files within the current " \
"directory, \"*.bat\"\nlimits the search to batch files, and so forth."
};
static char attr_msg[] =
{
"\t\t\t1 normal \n" \
"\t\t\t2 read-only \n" \
"\t\t\t3 hidden \n" \
"\t\t\t4 system \n" \
"\t\t\t volume \n" \
"\t\t\t subdirectory\n" \
"\t\t\t5 archive \n"
};
GetVidConfig();
ReadCharAttr( &disp_attr );
clear_scrn( disp_attr, 0, 24 );
SetCurPos( 8, 0 );
puts( "Welcome to the FILEDEMO program.\n\n\nThis program is meant " \
"to encourage experimentation while demonstrating how to\naccess " \
"DOS from assembly-language procedures. As a safety precaution, " \
"however,\nwe suggest you DO NOT experiment with files that " \
"cannot easily be replaced." );
press();
do
{
/* Display current drive and directory */
clear_scrn( disp_attr, 0, 24 );
SetCurPos( 0, 0 );
printf( "Current Directory: %c:\\", (char)(GetCurDrive() + 'A') );
GetCurDir( source );
puts( source );
/* Display DOS version */
SetCurPos( 1, 0 );
printf( "DOS Version: %2.1f", ( (float) GetVer() ) / 100 );
/* Display disk statistics for current drive */
SetCurPos( 0, 58 );
GetDiskSize( 0, &disk );
dsize = (long)disk.bytes * disk.sects * disk.total;
disk_use = (long)(disk.total - disk.avail) * disk.bytes * disk.sects;
printf( "Disk Size: %6lu K", dsize / 1024 );
SetCurPos( 1, 58 );
printf( "Disk Use: %6lu K", disk_use / 1024 );
/* Display menu and poll for keystroke */
clear_scrn( disp_attr, 2, 23 );
SetCurPos( 5, 0 );
puts( " \t *** FILE " \
"Demonstration Program ***" );
SetCurPos( 7, 0 );
puts( " \tA List Directory \t\tH Get/Set File Attribute" );
puts( " \tB Copy File \t\tI Get File Date and Time" );
puts( " \tC Move File \t\tJ Rename File" );
puts( " \tD Make Subdirectory \t\tK Delete File" );
puts( " \tE Remove Subdirectory \t\tL Create Unique File" );
puts( " \tF Change Default Drive \t\tM Quick Move" );
puts( " \tG Change Directory \t\tN Find Text" );
printf( "\n\n\tSelect an option, or press ESC to quit: " );
ch = getch();
switch( (ch = toupper( ch )) )
{
/* List first 60 files in specified directory */
case 'A':
err = list_dir( get_spec( 1 ), disp_attr );
if( !err )
press();
break;
/* Copy or Move File according to requested mode:
* 0 = overwrite target
* 1 = abort if target exists
* If Move requested, delete source file after copy.
*/
case 'B':
case 'C':
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 9, 0 );
puts( copy_msg );
mode = -1;
while( (mode < 0) || (mode > 1) )
{
SetCurPos( 16, 0 );
printf( "Enter copy mode: " );
mode = (int)(getche() - '0');
}
spec = get_spec( 2 ); /* Get source */
strcpy( source, spec ); /* Save in buffer */
spec = get_spec( 3 ); /* Get target */
err = CopyFile( mode, source, spec );
if( (ch == 'C') && !err )
err = DelFile( source );
break;
/* Make Directory */
case 'D':
err = MakeDir( get_spec( 1 ) );
break;
/* Remove Directory */
case 'E':
err = RemoveDir( get_spec( 1 ) );
break;
/* Change Default Drive */
case 'F':
SetCurPos( 18, 0 );
printf( "Enter new drive letter: " );
ch = getch();
ch = toupper( ch );
ChangeDrive( ch );
err = 0;
break;
/* Change Directory */
case 'G':
err = ChangeDir( get_spec( 1 ) );
break;
/* Get and Set File Attributes */
case 'H':
strcpy( source, get_spec( 3 ) );
if( (err = GetAttribute( source )) != -1 )
{
attr = err;
if( !attr )
attr_msg[6] = '*';
else
attr_msg[6] = ' ';
for( j = 1, i = 27; j <= 32; j <<= 1, i+= 21 )
{
attr_msg[i] = ' ';
if( attr & j )
attr_msg[i] = '*';
}
err = 0;
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 7, 0 );
puts( attr_msg );
printf( "\n\nToggle attribute bits by selecting 1-5, " \
"or any other key to exit: " );
mode = (int)( getch() - '0' );
if( (mode > 0) && (mode < 6) )
{
switch( --mode )
{
case 0:
attr = 0;
break;
case 1:
case 2:
case 3:
attr = attr ^ (1 << (--mode) );
break;
case 4:
attr = attr ^ 32;
}
err = SetAttribute( attr, source );
}
}
break;
/* Get File Date and Time */
case 'I':
if( (handle = OpenFile( 0, get_spec( 3 ) )) == -1 )
err = 1;
else
err = 0;
if( !err )
{
if( !(err = GetFileTime( handle, date_time )) )
{
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 12, 10 );
printf( "File's date and time stamp: %s", date_time );
CloseFile( handle );
press();
}
}
break;
/* Rename File */
case 'J':
strcpy( source, get_spec( 2 ) );
err = RenameFile( source, get_spec( 3 ) );
break;
/* Delete File */
case 'K':
err = DelFile( get_spec( 3 ) );
break;
/* Create File with Unique Name */
case 'L':
strcpy( source, get_spec( 1 ) );
handle = UniqueFile( 0, source ); /* Normal file attr = 0 */
if( handle >= 0 )
{
printf( "\n\nDOS creates file %s", source );
press();
err = 0;
}
else err = 1;
break;
/* Quick Move from one directory to another */
case 'M':
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 8, 0 );
puts( move_msg );
strcpy( source, get_spec( 2 ) );
err = RenameFile( source, get_spec( 3 ) );
break;
/* Search files for specified text */
case 'N':
clear_scrn( disp_attr, 2, 17 );
buffer = (char *) malloc( BUFFSIZE + 1 );
if( buffer == NULL )
{
SetCurPos( 12, 26 );
puts( "Insufficient memory for option" );
err = 1;
break;
}
SetCurPos( 7, 0 );
puts( grep_msg );
SetCurPos( 18, 0 );
printf( "Enter search text: " );
GetStr( text, MAXSEARCH );
/* Find first data file. */
if( err = FindFirst( 0, get_spec( 3 ), &file ) )
{
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 12, 24 );
puts( "No files found matching specification" );
}
/* If file found, initialize screen coordinates and
* open file for reading.
*/
else
{
clear_scrn( disp_attr, 2, 17 );
row = 6;
col = 0;
do
{
if( (handle = OpenFile( 0, file.filename )) != -1 )
{
/* If file opened successfully, read a block
* of BUFFSIZE bytes. If end-of-file encountered
* (number of bytes read not equal to BUFFSIZE)
* or read error, set error flag to break loop.
* Terminate block with a NULL character to
* make it an ASCIIZ string.
*/
err = 0;
while( !err )
{
len = ReadFile( handle, BUFFSIZE, buffer );
if( (len == 0) || (len != BUFFSIZE) )
++err;
ptr = buffer;
*( ptr + len ) = 0;
/* Search block for first character in text */
while( spec = StrFindChar( text[0], ptr, 0 ) )
{
/* If initial character found, compare
* remaining characters in search text.
* If all characters match, display file
* name and break out of loop.
*/
ptr = StrCompare( ++spec, &text[1],
(strlen( text ) - 1) );
if( !ptr )
{
SetCurPos( row++, col );
puts( file.filename );
if( row == 16)
{
row = 6;
col += 20;
}
err = 1;
break;
}
}
}
CloseFile( handle );
}
else
{
err = 1;
break;
}
} while( !FindNext( &file ) );
if( (row == 6) && (col == 0) )
{
SetCurPos( 12, 22 );
puts( "Text not found in specified file(s)" );
}
press();
err = 0;
}
free( buffer ); /* Free allocated block */
break;
default:
continue;
}
if( err )
{
clear_scrn( disp_attr, 24, 24 );
SetCurPos( 24, 0 );
printf( "*** Error ***\a" );
press();
}
} while( ch != ESCAPE ); /* Exit if ESC key pressed */
clear_scrn( disp_attr, 0, 24 ); /* Clear screen before exit */
SetCurPos( 23, 0 ); /* and set cursor to bottom */
return( 0 );
}
bool RecVolumes3::Restore(RAROptions *Cmd,const wchar *Name,bool Silent)
{
wchar ArcName[NM];
wcscpy(ArcName,Name);
wchar *Ext=GetExt(ArcName);
bool NewStyle=false;
bool RevName=Ext!=NULL && wcsicomp(Ext,L".rev")==0;
if (RevName)
{
for (int DigitGroup=0;Ext>ArcName && DigitGroup<3;Ext--)
if (!IsDigit(*Ext))
if (IsDigit(*(Ext-1)) && (*Ext=='_' || DigitGroup<2))
DigitGroup++;
else
if (DigitGroup<2)
{
NewStyle=true;
break;
}
while (IsDigit(*Ext) && Ext>ArcName+1)
Ext--;
wcscpy(Ext,L"*.*");
FindFile Find;
Find.SetMask(ArcName);
FindData fd;
while (Find.Next(&fd))
{
Archive Arc(Cmd);
if (Arc.WOpen(fd.Name) && Arc.IsArchive(true))
{
wcscpy(ArcName,fd.Name);
break;
}
}
}
Archive Arc(Cmd);
if (!Arc.WCheckOpen(ArcName))
return false;
if (!Arc.Volume)
{
#ifndef SILENT
Log(ArcName,St(MNotVolume),ArcName);
#endif
return false;
}
bool NewNumbering=Arc.NewNumbering;
Arc.Close();
wchar *VolNumStart=VolNameToFirstName(ArcName,ArcName,NewNumbering);
wchar RecVolMask[NM];
wcscpy(RecVolMask,ArcName);
size_t BaseNamePartLength=VolNumStart-ArcName;
wcscpy(RecVolMask+BaseNamePartLength,L"*.rev");
#ifndef SILENT
int64 RecFileSize=0;
#endif
// We cannot display "Calculating CRC..." message here, because we do not
// know if we'll find any recovery volumes. We'll display it after finding
// the first recovery volume.
bool CalcCRCMessageDone=false;
FindFile Find;
Find.SetMask(RecVolMask);
FindData RecData;
int FileNumber=0,RecVolNumber=0,FoundRecVolumes=0,MissingVolumes=0;
wchar PrevName[NM];
while (Find.Next(&RecData))
{
wchar *CurName=RecData.Name;
int P[3];
if (!RevName && !NewStyle)
{
NewStyle=true;
wchar *Dot=GetExt(CurName);
if (Dot!=NULL)
{
int LineCount=0;
Dot--;
while (Dot>CurName && *Dot!='.')
{
if (*Dot=='_')
LineCount++;
Dot--;
}
if (LineCount==2)
NewStyle=false;
}
}
if (NewStyle)
{
if (!CalcCRCMessageDone)
{
#ifndef SILENT
mprintf(St(MCalcCRCAllVol));
#endif
CalcCRCMessageDone=true;
}
#ifndef SILENT
mprintf(L"\n%s",CurName);
#endif
File CurFile;
CurFile.TOpen(CurName);
CurFile.Seek(0,SEEK_END);
int64 Length=CurFile.Tell();
CurFile.Seek(Length-7,SEEK_SET);
for (int I=0;I<3;I++)
P[2-I]=CurFile.GetByte()+1;
uint FileCRC=0;
for (int I=0;I<4;I++)
FileCRC|=CurFile.GetByte()<<(I*8);
uint CalcCRC;
CalcFileSum(&CurFile,&CalcCRC,NULL,Cmd->Threads,Length-4);
if (FileCRC!=CalcCRC)
{
#ifndef SILENT
mprintf(St(MCRCFailed),CurName);
#endif
continue;
}
}
else
{
wchar *Dot=GetExt(CurName);
if (Dot==NULL)
continue;
bool WrongParam=false;
for (size_t I=0;I<ASIZE(P);I++)
{
do
{
Dot--;
} while (IsDigit(*Dot) && Dot>=CurName+BaseNamePartLength);
P[I]=atoiw(Dot+1);
if (P[I]==0 || P[I]>255)
WrongParam=true;
}
if (WrongParam)
continue;
}
if (P[1]+P[2]>255)
continue;
if (RecVolNumber!=0 && RecVolNumber!=P[1] || FileNumber!=0 && FileNumber!=P[2])
{
#ifndef SILENT
Log(NULL,St(MRecVolDiffSets),CurName,PrevName);
#endif
return(false);
}
RecVolNumber=P[1];
FileNumber=P[2];
wcscpy(PrevName,CurName);
File *NewFile=new File;
NewFile->TOpen(CurName);
SrcFile[FileNumber+P[0]-1]=NewFile;
FoundRecVolumes++;
#ifndef SILENT
if (RecFileSize==0)
RecFileSize=NewFile->FileLength();
#endif
}
#ifndef SILENT
if (!Silent || FoundRecVolumes!=0)
{
mprintf(St(MRecVolFound),FoundRecVolumes);
}
#endif
if (FoundRecVolumes==0)
return(false);
bool WriteFlags[256];
memset(WriteFlags,0,sizeof(WriteFlags));
wchar LastVolName[NM];
*LastVolName=0;
for (int CurArcNum=0;CurArcNum<FileNumber;CurArcNum++)
{
Archive *NewFile=new Archive(Cmd);
bool ValidVolume=FileExist(ArcName);
if (ValidVolume)
{
NewFile->TOpen(ArcName);
ValidVolume=NewFile->IsArchive(false);
if (ValidVolume)
{
while (NewFile->ReadHeader()!=0)
{
if (NewFile->GetHeaderType()==HEAD_ENDARC)
{
#ifndef SILENT
mprintf(L"\n%s",ArcName);
#endif
if (NewFile->EndArcHead.DataCRC)
{
uint CalcCRC;
CalcFileSum(NewFile,&CalcCRC,NULL,Cmd->Threads,NewFile->CurBlockPos);
if (NewFile->EndArcHead.ArcDataCRC!=CalcCRC)
{
ValidVolume=false;
#ifndef SILENT
mprintf(St(MCRCFailed),ArcName);
#endif
}
}
break;
}
NewFile->SeekToNext();
}
}
if (!ValidVolume)
{
NewFile->Close();
wchar NewName[NM];
wcscpy(NewName,ArcName);
wcscat(NewName,L".bad");
#ifndef SILENT
mprintf(St(MBadArc),ArcName);
mprintf(St(MRenaming),ArcName,NewName);
#endif
RenameFile(ArcName,NewName);
}
NewFile->Seek(0,SEEK_SET);
}
if (!ValidVolume)
{
// It is important to return 'false' instead of aborting here,
// so if we are called from extraction, we will be able to continue
// extracting. It may happen if .rar and .rev are on read-only disks
// like CDs.
if (!NewFile->Create(ArcName))
{
// We need to display the title of operation before the error message,
// to make clear for user that create error is related to recovery
// volumes. This is why we cannot use WCreate call here. Title must be
// before create error, not after that.
#ifndef SILENT
mprintf(St(MReconstructing));
#endif
ErrHandler.CreateErrorMsg(NULL,ArcName);
return false;
}
WriteFlags[CurArcNum]=true;
MissingVolumes++;
if (CurArcNum==FileNumber-1)
wcscpy(LastVolName,ArcName);
#ifndef SILENT
mprintf(St(MAbsNextVol),ArcName);
#endif
}
SrcFile[CurArcNum]=(File*)NewFile;
NextVolumeName(ArcName,ASIZE(ArcName),!NewNumbering);
}
#ifndef SILENT
mprintf(St(MRecVolMissing),MissingVolumes);
#endif
if (MissingVolumes==0)
{
#ifndef SILENT
mprintf(St(MRecVolAllExist));
#endif
return false;
}
if (MissingVolumes>FoundRecVolumes)
{
#ifndef SILENT
mprintf(St(MRecVolCannotFix));
#endif
return false;
}
#ifndef SILENT
mprintf(St(MReconstructing));
#endif
int TotalFiles=FileNumber+RecVolNumber;
int Erasures[256],EraSize=0;
for (int I=0;I<TotalFiles;I++)
if (WriteFlags[I] || SrcFile[I]==NULL)
Erasures[EraSize++]=I;
#ifndef SILENT
int64 ProcessedSize=0;
#ifndef GUI
int LastPercent=-1;
mprintf(L" ");
#endif
#endif
// Size of per file buffer.
size_t RecBufferSize=TotalBufferSize/TotalFiles;
#ifdef RAR_SMP
uint ThreadNumber=Cmd->Threads;
RSEncode rse[MaxPoolThreads];
#else
uint ThreadNumber=1;
RSEncode rse[1];
#endif
for (uint I=0;I<ThreadNumber;I++)
rse[I].Init(RecVolNumber);
while (true)
{
Wait();
int MaxRead=0;
for (int I=0;I<TotalFiles;I++)
if (WriteFlags[I] || SrcFile[I]==NULL)
memset(&Buf[I*RecBufferSize],0,RecBufferSize);
else
{
int ReadSize=SrcFile[I]->Read(&Buf[I*RecBufferSize],RecBufferSize);
if ((size_t)ReadSize!=RecBufferSize)
memset(&Buf[I*RecBufferSize+ReadSize],0,RecBufferSize-ReadSize);
if (ReadSize>MaxRead)
MaxRead=ReadSize;
}
if (MaxRead==0)
break;
#ifndef SILENT
int CurPercent=ToPercent(ProcessedSize,RecFileSize);
if (!Cmd->DisablePercentage && CurPercent!=LastPercent)
{
mprintf(L"\b\b\b\b%3d%%",CurPercent);
LastPercent=CurPercent;
}
ProcessedSize+=MaxRead;
#endif
int BlockStart=0;
int BlockSize=MaxRead/ThreadNumber;
if (BlockSize<0x100)
BlockSize=MaxRead;
for (uint CurThread=0;BlockStart<MaxRead;CurThread++)
{
// Last thread processes all left data including increasement
// from rounding error.
if (CurThread==ThreadNumber-1)
BlockSize=MaxRead-BlockStart;
RSEncode *curenc=rse+CurThread;
curenc->Buf=&Buf[0];
curenc->BufStart=BlockStart;
curenc->BufEnd=BlockStart+BlockSize;
curenc->FileNumber=TotalFiles;
curenc->RecBufferSize=RecBufferSize;
curenc->Erasures=Erasures;
curenc->EraSize=EraSize;
#ifdef RAR_SMP
if (ThreadNumber>1)
RSThreadPool->AddTask(RSDecodeThread,(void*)curenc);
else
curenc->DecodeBuf();
#else
curenc->DecodeBuf();
#endif
BlockStart+=BlockSize;
}
#ifdef RAR_SMP
RSThreadPool->WaitDone();
#endif // RAR_SMP
for (int I=0;I<FileNumber;I++)
if (WriteFlags[I])
SrcFile[I]->Write(&Buf[I*RecBufferSize],MaxRead);
}
for (int I=0;I<RecVolNumber+FileNumber;I++)
if (SrcFile[I]!=NULL)
{
File *CurFile=SrcFile[I];
if (NewStyle && WriteFlags[I])
{
int64 Length=CurFile->Tell();
CurFile->Seek(Length-7,SEEK_SET);
for (int J=0;J<7;J++)
CurFile->PutByte(0);
}
CurFile->Close();
SrcFile[I]=NULL;
}
if (*LastVolName!=0)
{
// Truncate the last volume to its real size.
Archive Arc(Cmd);
if (Arc.Open(LastVolName,FMF_UPDATE) && Arc.IsArchive(true) &&
Arc.SearchBlock(HEAD_ENDARC))
{
Arc.Seek(Arc.NextBlockPos,SEEK_SET);
char Buf[8192];
int ReadSize=Arc.Read(Buf,sizeof(Buf));
int ZeroCount=0;
while (ZeroCount<ReadSize && Buf[ZeroCount]==0)
ZeroCount++;
if (ZeroCount==ReadSize)
{
Arc.Seek(Arc.NextBlockPos,SEEK_SET);
Arc.Truncate();
}
}
}
#if !defined(GUI) && !defined(SILENT)
if (!Cmd->DisablePercentage)
mprintf(L"\b\b\b\b100%%");
if (!Silent && !Cmd->DisableDone)
mprintf(St(MDone));
#endif
return true;
}
SegmentsX *SplitWays(WaysX *waysx,NodesX *nodesx,int keep)
{
SegmentsX *segmentsx;
index_t i;
int fd,nfd;
char *name=NULL;
int namelen=0;
/* Print the start message */
printf_first("Splitting Ways: Ways=0 Segments=0");
segmentsx=NewSegmentList();
/* Re-open the file read-only and a new file writeable */
waysx->fd=ReOpenFileBuffered(waysx->filename_tmp);
if(keep)
RenameFile(waysx->filename_tmp,waysx->filename);
else
DeleteFile(waysx->filename_tmp);
fd=OpenFileBufferedNew(waysx->filename_tmp);
nfd=OpenFileBufferedNew(waysx->nfilename_tmp);
/* Loop through the ways and create the segments and way names */
for(i=0;i<waysx->number;i++)
{
WayX wayx;
FILESORT_VARINT size;
node_t node,prevnode=NO_NODE_ID;
index_t index,previndex=NO_NODE;
ReadFileBuffered(waysx->fd,&size,FILESORT_VARSIZE);
ReadFileBuffered(waysx->fd,&wayx,sizeof(WayX));
waysx->allow|=wayx.way.allow;
while(!ReadFileBuffered(waysx->fd,&node,sizeof(node_t)) && node!=NO_NODE_ID)
{
index=IndexNodeX(nodesx,node);
if(prevnode==node)
{
logerror("Way %"Pway_t" contains node %"Pnode_t" that is connected to itself.\n",logerror_way(wayx.id),logerror_node(node));
}
else if(index==NO_NODE)
{
logerror("Way %"Pway_t" contains node %"Pnode_t" that does not exist in the Routino database.\n",logerror_way(wayx.id),logerror_node(node));
}
else if(previndex==NO_NODE)
;
else
{
distance_t segment_flags=0;
if(wayx.way.type&Highway_OneWay)
segment_flags|=ONEWAY_1TO2;
if(wayx.way.type&Highway_Area)
segment_flags|=SEGMENT_AREA;
AppendSegmentList(segmentsx,i,previndex,index,segment_flags);
}
prevnode=node;
previndex=index;
size-=sizeof(node_t);
}
size-=sizeof(node_t)+sizeof(WayX);
if(namelen<size)
name=(char*)realloc((void*)name,namelen=size);
ReadFileBuffered(waysx->fd,name,size);
WriteFileBuffered(fd,&wayx,sizeof(WayX));
size+=sizeof(index_t);
WriteFileBuffered(nfd,&size,FILESORT_VARSIZE);
WriteFileBuffered(nfd,&i,sizeof(index_t));
WriteFileBuffered(nfd,name,size-sizeof(index_t));
if(!((i+1)%1000))
printf_middle("Splitting Ways: Ways=%"Pindex_t" Segments=%"Pindex_t,i+1,segmentsx->number);
}
FinishSegmentList(segmentsx);
if(name) free(name);
/* Close the files */
waysx->fd=CloseFileBuffered(waysx->fd);
CloseFileBuffered(fd);
CloseFileBuffered(nfd);
/* Print the final message */
printf_last("Split Ways: Ways=%"Pindex_t" Segments=%"Pindex_t,waysx->number,segmentsx->number);
return(segmentsx);
}
