|
|
/*
Modifications:
01.10.94 Joe Holman Added DISK_TO_START_NUMBERING_AT because we now have 2 bootdisks, thus we to start making floppies on disk # 3.01.11.94 Joe Holman Change value back to 2.04.04.94 Joe Holman Add debugging to LayoutDisks.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <time.h>
#include "general.h"
FILE* logFile;char* product;int useCdPath;
BOOL bAssigned[15000]; // should put this in Entry struct after Beta.
struct _list {
char name[15]; // name of file
int size; int csize; int disk; int priority; char nocompress[15];
};struct _list fileList[15000];int numFiles;int totalCompressed=0;int totalUnCompressed=0;
void Msg ( const char * szFormat, ... ) {
va_list vaArgs;
va_start ( vaArgs, szFormat ); vprintf ( szFormat, vaArgs ); vfprintf ( logFile, szFormat, vaArgs ); va_end ( vaArgs );}
void Header(argv)char* argv[];{ time_t t;
PRINT1("\n=========== LAYOUT =============\n") PRINT2("Input BOM: %s\n",argv[2]) PRINT2("Output Layout: %s\n",argv[3]) PRINT2("Product: %s\n",argv[4]) PRINT2("Floppy Size: %s\n",argv[5]) time(&t); PRINT2("Time: %s",ctime(&t)) PRINT1("================================\n\n");}
void Usage(){ printf("PURPOSE: Assigns files to disks and generates a layout file.\n"); printf("\n"); printf("PARAMETERS:\n"); printf("\n"); printf("[LogFile] - Path to append a log of actions and errors.\n"); printf("[InBom] - Path of BOM for which a layout is to be made.\n"); printf("[OutLayout] - Path of new layout.\n"); printf("[Product] - Product to lay out.\n"); printf(" NTFLOP = Windows NT on floppy\n"); printf(" LMFLOP = Lan Manager on floppy\n"); printf(" NTCD = Windows NT on CD\n"); printf(" LMCD = Lan Manager on CD\n"); printf(" SDK = Software Development Kit\n"); printf("[FloppySize] - Size in bytes of the second disk.\n\n");}
int __cdecl PrioritySizeNameCompare(const void*,const void*);
int Same(Entry * e1, Entry * e2) {
char *p1, *p2; BOOL bSame;
if (useCdPath) {
p1=e1->cdpath; p2=e2->cdpath; } else {
p1="x"; p2=p1; }
bSame = (!_stricmp(e1->name,e2->name)) && (!_stricmp(e1->path,e2->path)) && (!_stricmp(e1->source,e2->source)) && (!_stricmp(p1,p2));
if ( !bSame ) {
Msg ( "\n>>>>>>>\n" ); Msg ( "e1->name = %s\n", e1->name ); Msg ( "e2->name = %s\n", e2->name ); Msg ( "e1->path = %s\n", e1->path ); Msg ( "e2->path = %s\n", e2->path ); Msg ( "e1->source = %s\n", e1->source ); Msg ( "e2->source = %s\n", e2->source ); Msg ( "p1 = %s\n", p1 ); Msg ( "p2 = %s\n", p2 ); }
return ( bSame );}
BOOL FindFile ( char * name ) {
int i;
for ( i = 0; i < numFiles; ++i ) {
if ( _stricmp ( name, fileList[i].name ) == 0 ) {
return TRUE; // found the file in the file list
}
}
return FALSE; // did NOT find the file in the file list.
}
void AddFileToList ( char * name, int size, int csize, int disk, int priority, char * nocompress ) {
sprintf ( fileList[numFiles].name, "%s", name ); fileList[numFiles].size = size; fileList[numFiles].csize = csize; fileList[numFiles].disk = disk; fileList[numFiles].priority = priority; sprintf ( fileList[numFiles].nocompress, "%s", nocompress );
totalUnCompressed += fileList[numFiles].size; totalCompressed += fileList[numFiles].csize;
Msg ( "totalUncomp = %d, size = %d,totalComp = %d, csize = %d\n", totalUnCompressed, fileList[numFiles].size, totalCompressed, fileList[numFiles].csize );
if ( fileList[numFiles].size < fileList[numFiles].csize ) {
Msg ( "ER: %s compressed bigger than uncomp\n", fileList[numFiles].name ); }
++numFiles;
}
void MakeEntries ( Entry * e, int records ) {
int i; BOOL bInList;
int numFiles = 0;
for ( i = 0; i < records; i++ ) {
bInList = FindFile ( e[i].name );
if ( !bInList ) {
AddFileToList ( e[i].name, e[i].size, e[i].csize, e[i].disk, e[i].priority, e[i].nocompress ); } }
}
void ShowEntries ( void ) {
int i;
totalCompressed=0; totalUnCompressed=0;
for ( i = 0; i < numFiles; ++i ) {
Msg ( "#%d\t%s,nocomp=%d,comp=%d,priority=%d,disk=%d,%s\n", i, fileList[i].name, fileList[i].size, fileList[i].csize, fileList[i].priority, fileList[i].disk, fileList[i].nocompress );
totalCompressed+=fileList[i].csize; totalUnCompressed+=fileList[i].size; }
Msg ( "totalCompressed = %d, totalUnCompressed = %d\n\n\n", totalCompressed, totalUnCompressed );
}
//
// Returns TRUE if a file hasn't been assigned a disk #, ie. 0.
// Returns FALSE if all have been assigned.
//
BOOL FileUnAssigned ( void ) {
int i;
for ( i = 0; i < numFiles; ++i ) {
if ( fileList[i].disk == 0 ) {
return TRUE; }
}
return FALSE;
}
void StuffDiskNumIntoRecords ( void ) {
}
void LayoutAssignDisks(e,diskSize,records)Entry* e;int diskSize;int records;{
#define DISK_TO_START_NUMBERING_AT 1 // must start on disk #1 for all files.
//
//
// Do we REALLY need to use disk # assignment in BOM ?????
// With proper Priority, we shouldn't really need this...
//
//
//
//
int disk=DISK_TO_START_NUMBERING_AT; int freeSpace; int i, itemSize, totalUnassigned; int lastUnassignedPriority; int workingPriority;
//
// Make unique entries for each file for the product.
//
MakeEntries ( e, records ); ShowEntries ( );
// Priority values can be from 1-1000;
//
do {
// Free space left to begin with is the disk size.
//
freeSpace=diskSize - 512; // add in safety fudge factor...
Msg ( "\n\n\n\n\nInitial Disk #%d freeSpace = %d\n", disk, freeSpace );
// First, find all the files that
// are HARDCODED to go on this disk.
//
//
Msg ( "\n\n\nAnalyze HARDCODED disk #s...\n\n" ); for ( i=0; i < numFiles; i++) {
if ( fileList[i].disk == disk) {
if ( fileList[i].nocompress[1] == 'x' || fileList[i].nocompress[1] == 'X' ) {
freeSpace -= fileList[i].size;
Msg ( "freeSpace(nocomp) = %d, %d, %s, disk #%d, prio = %d\n", freeSpace, fileList[i].size, fileList[i].name, disk, fileList[i].priority );
} else {
freeSpace -= fileList[i].csize;
Msg ( "freeSpace(comp) = %d, %d, %s, disk #%d, prio = %d\n", freeSpace, fileList[i].csize, fileList[i].name, disk, fileList[i].priority ); } } }
// We have a big problem if our freespace is less than 0.
// I.E, too many disks have HARDCODED disk # for this disk.
//
if ( freeSpace < 0 ) {
Msg ( "FATAL ER: disk #%d freeSpace = %d\n", disk, freeSpace ); Msg ( ">>>> Too many files with HARDCODED disk #%d\n", disk); }
#define NOT_ASSIGNED_YET 0
#define MAX_GROUPING_NUM 1000
// Now let's deal with the PRIORITY.
//
Msg ( "\n\n\nAnalyze GROUPINGS...\n\n" ); workingPriority = 1; do {
for ( i = 0; i < numFiles; ++i ) {
int fileSize;
if ( fileList[i].disk == NOT_ASSIGNED_YET ) {
if ( fileList[i].nocompress[1] == 'x' || fileList[i].nocompress[1] == 'X' ) {
fileSize = fileList[i].size; } else { fileSize = fileList[i].csize; }
if ( fileList[i].priority <= workingPriority &&
freeSpace-fileSize > 0 ) {
freeSpace -= fileSize; fileList[i].disk = disk;
Msg ( "freespace(%s) = %d, %s, disk #%d, priority = %d, csize=%d,size=%d\n", (_stricmp(fileList[i].nocompress,"x")) ? "comp" : "nocomp", freeSpace, fileList[i].name, disk, workingPriority, fileList[i].csize, fileList[i].size ); }
}
}
++workingPriority;
if ( workingPriority > MAX_GROUPING_NUM ) {
break; }
//Msg ( "workingPriority = %d, freeSpace = %d, disk = %d\n",
// workingPriority, freeSpace, disk );
} while ( freeSpace > 0 && FileUnAssigned() );
Msg ( "Disk %d Excess Space: %d\n", disk, freeSpace );
++disk;
} while ( FileUnAssigned() );
ShowEntries ( ); StuffDiskNumIntoRecords ();
exit(0);
// # of unassigned files.
//
totalUnassigned = records;
//
//
// After BETA, rewrite the following algorithms to:
//
// o not use totalUnassigned.
// o to be better written algorithm below for laying out.
//
//
// Calculate the # of unassigned files, and initiate the disk #
// for each to be layed-out from.
//
for (i=0;i<records;i++) {
// If this file has specific disk # to be on, reduce the
// # of files to be assigned by 1.
//
if(e[i].disk>0) { totalUnassigned--; }
// Is this code ever executed ????
//
// this stuff is bs -- if this is the cd, we should detect that earlier
// and have a simple loop for that case. All files on the cd must be
// on disk 1.
//
// if(diskSize > CD_SIZE) {
// for(i=0; i<records; i++) {
// e[i].disk = 1;
// }
// }
//
if( (e[i].disk>=DISK_TO_START_NUMBERING_AT) && (diskSize>CD_SIZE)) {
e[i].disk=DISK_TO_START_NUMBERING_AT; bAssigned[i] = TRUE;
Msg ( "ever-executed?: %s, %d, %d\n", e[i].source, e[i].disk, diskSize ); } }
//
//
do {
// Free space left to begin with is the disk size.
//
freeSpace=diskSize - 512; // add in safety fudge factor...
Msg ( "freeSpace(init) = %d, %d\n", freeSpace, diskSize );
// First, find all the files that
// are HARDCODED to go on this disk.
//
//
for ( i=0; i<records; i++) {
//
// Rules: specific disk # assignment, next available i==0,
// or !Same (due to multiple entries in the bom
// for the same file, but used for different inf lines.
// >>> If we remove multiple entries in bom for same files
// this test can be removed.
//
// SAME() JUST WONT WORK IF E entries ARE NOT IN ALPHABETICALL ORDER.
// AND, that is just the CASE, some of them are not in ORDER,
// that's why we are getting some negative values for disk size.
//
if ( (e[i].disk==disk) && ((i==0) || !Same(&e[i],&e[i-1]))) {
if (!_stricmp(e[i].nocompress,"x")) { freeSpace-=e[i].size; Msg ( "freeSpace(nocomp) = %d, %d, %s, disk #%d, i = %d\n", freeSpace, e[i].size, e[i].name, disk, i ); } else { freeSpace-=e[i].csize; Msg ( "freeSpace(comp) = %d, %d, %s, disk #%d, i = %d\n", freeSpace, e[i].csize, e[i].name, disk, i ); } } }
// We have a big problem if our freespace is less than 0.
// I.E, too many disks have HARDCODED disk # for this disk.
//
if ( freeSpace < 0 ) {
Msg ( "FATAL ER: disk #%d freeSpace = %d\n", disk, freeSpace ); Msg ( ">>>> Too many files with HARDCODED disk #%d\n", disk); }
// Now, fill the floppies with files working with the Highest Priority.
//
lastUnassignedPriority=1000;
for ( i=0; i<records; i++) {
//
// If the file hasn't been assigned yet, ie. 0, figure the disk
// for it to live on.
//
if (e[i].disk==0) {
//
// WHEN WE GET RID OF MULTIPLE ENTRIES IN THE BOM FOR
// THE SAME FILE, WE CAN GET RID OF THE 'SAME' FUNCTION
// BECAUSE THIS LOOKS TO SEE THAT THE LAST FILE PROCESSED
// HAD THE SAME NAME (DUE TO INF MULTIPLE INSTANCES).
//
if ((i!=0) && Same(&e[i],&e[i-1])) {
// If we aren't on the 1st e entry AND
// we have the same filename, then just
// give the same disk # as PREVIOUSLY assigned.
//
e[i].disk=e[i-1].disk; bAssigned[i] = TRUE; Msg ( "Assign(same-as-last) %s: %d\n", e[i].name, e[i].disk ); } else {
// Get the size of the file in compressed or non-comp
// format.
//
itemSize = (!_stricmp(e[i].nocompress,"x")) ? e[i].size : e[i].csize;
// If the file can fit on the floppy,
// see if we can assign it to the disk #.
//
if ( freeSpace >= itemSize ) {
if ((e[i].priority<=lastUnassignedPriority) || ((e[i].priority==999) && (lastUnassignedPriority>9))) {
if ( e[i].priority <= lastUnassignedPriority) { Msg ( ">>> priority %d <= lastUnassignedPriority %d\n", e[i].priority, lastUnassignedPriority ); }
if ( (e[i].priority==999) && (lastUnassignedPriority>9) ) { Msg ( ">>> priority==999 && lastUnassignedPriority %d > 9\n", lastUnassignedPriority ); }
// Assign the disk #.
//
e[i].disk=disk; bAssigned[i] = TRUE; Msg ( "Assign(1) %s: %d\n", e[i].name, e[i].disk );
// Free space remaining...
//
freeSpace-=itemSize; Msg ( "freeSpace(3) = %d, %d\n", freeSpace, itemSize ); } } else if (lastUnassignedPriority==1000) {
// ???????
//
lastUnassignedPriority=e[i].priority;
Msg ( "?????ever get executed(2) - lastUnassignedPriority = %d\n", e[i].priority ); }
// Look for files that are TOO big to fit on media.
//
if ( itemSize >= diskSize) {
Msg ("FATAL ERROR: %s too big, %d bytes\n", e[i].name, itemSize );
// Assign the disk #, although invalid.
//
e[i].disk=999; bAssigned[i] = TRUE; Msg ( "Assign %s: %d\n", e[i].name, e[i].disk ); } }
// If the disk# is no longer 0, then file has been assigned.
//
if (e[i].disk) { totalUnassigned--; }
if ( freeSpace < 0 ) {
Msg ( "FATAL ER: freeSpace %d < 0\n", freeSpace );
} } }
// Tell the amount of space left on the disk.
//
//PRINT3("INFO Disk: %2.d Free Space: %7.d\n",disk,freeSpace)
Msg ( "Disk %d Free Space: %d\n", disk, freeSpace ); disk++;
} while (totalUnassigned>0); // continue until all files assigned.
//
// the above 'totalUnassigned' method is bad, what if the # gets
// off by some reason. better thing to do is have flag for
// each file saying bAssigned yet or not.
//
// Reduce the last disk # by 1.
//
disk--;
}
__cdecl main(argc,argv)int argc;char* argv[];{ FILE *outLayout; Entry *e; int records,i; char *buf;
if (argc!=6) { Usage(); return(1); } if ((logFile=fopen(argv[1],"a"))==NULL) { printf("ERROR Couldn't open log file %s\n",argv[1]); return(1); } Header(argv); LoadFile(argv[2],&buf,&e,&records,argv[4]);
if (MyOpenFile(&outLayout,argv[3],"wb")) return(1);
if (!_stricmp(argv[4],"ntflop") || !_stricmp(argv[4],"lmflop")) { useCdPath=0; } else { useCdPath=1; }
//
// munge the compress flag depending on the product type.
// if we are laying out floppies, then files are always
// compressed unless a special flag is set in the bom.
//
if(!useCdPath) { for (i=0;i<records;i++) { if(_strnicmp(e[i].nocompress,"xfloppy",7)) { //
// not xfloppy; not uncompressed.
//
e[i].nocompress = ""; } else { e[i].nocompress = "x"; } } }
#ifdef JOE
#else
qsort(e,records,sizeof(Entry),PrioritySizeNameCompare);
LayoutAssignDisks(e,atoi(argv[5]),records);#endif
i=0; while ((fputc(buf[i++],outLayout))!='\n'); for (i=0;i<records;i++) { EntryPrint(&e[i],outLayout); }
fclose(outLayout); fclose(logFile); free(e); return(0);}
int __cdecl PrioritySizeNameCompare(const void *v1, const void *v2){ int result; Entry *e1 = (Entry *)v1; Entry *e2 = (Entry *)v2;
if (e1->priority!=e2->priority) return(e1->priority-e2->priority); if (e1->size!=e2->size) return(e2->size-e1->size); if (result=_stricmp(e1->name,e2->name)) return(result); if (useCdPath) return(_stricmp(e1->cdpath,e2->cdpath)); else return(0); // always the same for floppies.
}
|
