Foam::IOdictionary::IOdictionary(const IOobject& io, const dictionary& dict)
:
regIOobject(io)
{
// Temporary warning
if (debug && io.readOpt() == IOobject::MUST_READ)
{
WarningIn
(
"IOdictionary::IOdictionary(const IOobject& const dictionary&)"
) << "Dictionary " << name()
<< " constructed with IOobject::MUST_READ"
" instead of IOobject::MUST_READ_IF_MODIFIED." << nl
<< "Use MUST_READ_IF_MODIFIED if you need automatic rereading."
<< endl;
}
// Everyone check or just master
bool masterOnly =
regIOobject::fileModificationChecking == timeStampMaster
|| regIOobject::fileModificationChecking == inotifyMaster;
// Check if header is ok for READ_IF_PRESENT
bool isHeaderOk = false;
if (io.readOpt() == IOobject::READ_IF_PRESENT)
{
if (masterOnly)
{
if (Pstream::master())
{
isHeaderOk = headerOk();
}
Pstream::scatter(isHeaderOk);
}
else
{
isHeaderOk = headerOk();
}
}
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| isHeaderOk
)
{
readFile(masterOnly);
}
else
{
dictionary::operator=(dict);
}
dictionary::name() = IOobject::objectPath();
}
Foam::IOList<T>::IOList(const IOobject& io)
:
regIOobject(io)
{
// Temporary warning
if (io.readOpt() == IOobject::MUST_READ_IF_MODIFIED)
{
WarningIn("IOList::IOList(const IOobject&)")
<< "IOList " << name()
<< " constructed with IOobject::MUST_READ_IF_MODIFIED"
" but IOList does not support automatic rereading."
<< endl;
}
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
IOPatchToPatchInterpolation<FromPatch, ToPatch>::IOPatchToPatchInterpolation
(
const IOobject& io,
const FromPatch& fromPatch,
const ToPatch& toPatch,
intersection::algorithm alg,
const intersection::direction dir
)
:
regIOobject(io),
PatchToPatchInterpolation<FromPatch, ToPatch>(fromPatch, toPatch, alg, dir)
{
if (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
{
Istream& is = readStream(typeName);
labelList* paPtr = new labelList(is);
FieldField<Field, scalar>* pwPtr = new FieldField<Field, scalar>(is);
scalarField* pdPtr = new scalarField(is);
labelList* faPtr = new labelList(is);
FieldField<Field, scalar>* fwPtr = new FieldField<Field, scalar>(is);
scalarField* fdPtr = new scalarField(is);
Info << "Setting weights from file" << endl;
this->setWeights(paPtr, pwPtr, pdPtr, faPtr, fwPtr, fdPtr);
}
}
Foam::solution::solution(const objectRegistry& obr, const fileName& dictName)
:
IOdictionary
(
IOobject
(
dictName,
obr.time().system(),
obr,
IOobject::READ_IF_PRESENT, // Allow default dictionary creation
IOobject::NO_WRITE
)
),
relaxationFactors_
(
ITstream("relaxationFactors", tokenList())()
),
defaultRelaxationFactor_(0),
solvers_(ITstream("solvers", tokenList())())
{
if (!headerOk())
{
if (debug)
{
InfoIn
(
"Foam::solution::solution(const objectRegistry& obr, "
"const fileName& dictName)"
) << "Solution dictionary not found. Adding default entries"
<< endl;
}
}
read();
}
Foam::IOList<T>::IOList(const IOobject& io)
:
regIOobject(io)
{
if
(
io.readOpt() == IOobject::MUST_READ
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
void Foam::polyTopoChanger::readModifiers()
{
if
(
readOpt() == IOobject::MUST_READ
|| readOpt() == IOobject::MUST_READ_IF_MODIFIED
|| (readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
if (readOpt() == IOobject::MUST_READ_IF_MODIFIED)
{
WarningIn("polyTopoChanger::readModifiers()")
<< "Specified IOobject::MUST_READ_IF_MODIFIED but class"
<< " does not support automatic rereading."
<< endl;
}
PtrList<polyMeshModifier>& modifiers = *this;
// Read modifiers
Istream& is = readStream(typeName);
PtrList<entry> patchEntries(is);
modifiers.setSize(patchEntries.size());
forAll(modifiers, modifierI)
{
modifiers.set
(
modifierI,
polyMeshModifier::New
(
patchEntries[modifierI].keyword(),
patchEntries[modifierI].dict(),
modifierI,
*this
)
);
}
// Check state of IOstream
is.check
(
"polyTopoChanger::polyTopoChanger"
"(const IOobject&, const polyMesh&)"
);
close();
}
Foam::featureEdgeMesh::featureEdgeMesh(const IOobject& io)
:
regIOobject(io),
edgeMesh(pointField(0), edgeList(0))
{
if
(
io.readOpt() == IOobject::MUST_READ
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
Foam::IOPtrList<T>::IOPtrList(const IOobject& io)
:
regIOobject(io)
{
if
(
io.readOpt() == IOobject::MUST_READ
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
PtrList<T>::read(readStream(typeName), INew<T>());
close();
}
}
Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const INew& inewt)
:
regIOobject(io)
{
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
PtrList<T>::read(readStream(typeName), inewt);
close();
}
}
Foam::IOEquationReader::IOEquationReader
(
const IOobject& io,
const bool showDataSourceInfo
)
:
regIOobject(io),
showDataSourceInfo_(showDataSourceInfo)
{
if
(
io.readOpt() == IOobject::MUST_READ
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
faSchemes::faSchemes(const objectRegistry& obr)
:
IOdictionary
(
IOobject
(
"faSchemes",
obr.time().system(),
obr,
// IOobject::MUST_READ,
IOobject::READ_IF_PRESENT, // Allow default dictionary creation
IOobject::NO_WRITE
)
),
ddtSchemes_(ITstream("ddtSchemes", tokenList())()),
defaultDdtScheme_("default", tokenList()),
d2dt2Schemes_(ITstream("d2dt2Schemes", tokenList())()),
defaultD2dt2Scheme_("default", tokenList()),
interpolationSchemes_(ITstream("interpolationSchemes", tokenList())()),
defaultInterpolationScheme_("default", tokenList()),
divSchemes_(ITstream("divSchemes", tokenList())()),
defaultDivScheme_("default", tokenList()),
gradSchemes_(ITstream("gradSchemes", tokenList())()),
defaultGradScheme_("default", tokenList()),
lnGradSchemes_(ITstream("lnGradSchemes", tokenList())()),
defaultLnGradScheme_("default", tokenList()),
laplacianSchemes_(ITstream("laplacianSchemes", tokenList())()),
defaultLaplacianScheme_("default", tokenList()),
fluxRequired_(ITstream("fluxRequired", tokenList())())
{
if (!headerOk())
{
if (debug)
{
InfoIn
(
"faSchemes::faSchemes(const objectRegistry& obr)"
) << "faSchemes dictionary not found. Creating default."
<< endl;
}
}
read();
}
Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const Xfer<PtrList<T> >& list)
:
regIOobject(io)
{
PtrList<T>::transfer(list());
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
PtrList<T>::read(readStream(typeName), INew<T>());
close();
}
}
Foam::IOField<Type>::IOField(const IOobject& io)
:
regIOobject(io)
{
// Check for MUST_READ_IF_MODIFIED
warnNoRereading<IOField<Type>>();
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
topoSet::topoSet(const IOobject& obj, const word& wantedType)
:
regIOobject(obj)
{
if
(
readOpt() == IOobject::MUST_READ
|| (
readOpt() == IOobject::READ_IF_PRESENT
&& headerOk()
)
)
{
if (readStream(wantedType).good())
{
readStream(wantedType) >> static_cast<labelHashSet&>(*this);
close();
}
}
Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const PtrList<T>& list)
:
regIOobject(io)
{
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
PtrList<T>::read(readStream(typeName), INew<T>());
close();
}
else
{
PtrList<T>::operator=(list);
}
}
bool faSchemes::read()
{
bool readOk = false;
if (headerOk())
{
readOk = regIOobject::read();
}
if (readOk)
{
const dictionary& dict = schemesDict();
// ddt Schemes
if (dict.found("ddtSchemes"))
{
ddtSchemes_ = dict.subDict("ddtSchemes");
}
else
{
ddtSchemes_.add("default", "none");
}
if
(
ddtSchemes_.found("default")
&& word(ddtSchemes_.lookup("default")) != "none"
)
{
defaultDdtScheme_ = ddtSchemes_.lookup("default");
}
// d2dt2 schemes
if (dict.found("d2dt2Schemes"))
{
d2dt2Schemes_ = dict.subDict("d2dt2Schemes");
}
else if (dict.found("timeScheme"))
{
// For backward compatibility.
// The timeScheme will be deprecated with warning or removed in 2.4.
word timeSchemeName(dict.lookup("timeScheme"));
if (timeSchemeName == "EulerImplicit")
{
timeSchemeName = "Euler";
}
else if (timeSchemeName == "SteadyState")
{
timeSchemeName = "steadyState";
}
if (d2dt2Schemes_.found("default"))
{
d2dt2Schemes_.remove("default");
}
d2dt2Schemes_.add("default", timeSchemeName);
}
else
{
d2dt2Schemes_.add("default", "none");
}
if
(
d2dt2Schemes_.found("default")
&& word(d2dt2Schemes_.lookup("default")) != "none"
)
{
defaultD2dt2Scheme_ = d2dt2Schemes_.lookup("default");
}
// Interpolation schemes
if (dict.found("interpolationSchemes"))
{
interpolationSchemes_ = dict.subDict("interpolationSchemes");
}
else
{
interpolationSchemes_.add("default", "linear");
}
if
(
interpolationSchemes_.found("default")
&& word(interpolationSchemes_.lookup("default")) != "none"
)
{
defaultInterpolationScheme_ =
interpolationSchemes_.lookup("default");
}
// Div schemes
if (dict.found("divSchemes"))
{
divSchemes_ = dict.subDict("divSchemes");
}
else
{
divSchemes_.add("default", "none");
}
if
(
divSchemes_.found("default")
&& word(divSchemes_.lookup("default")) != "none"
)
{
defaultDivScheme_ = divSchemes_.lookup("default");
}
// Grad schemes
if (dict.found("gradSchemes"))
{
gradSchemes_ = dict.subDict("gradSchemes");
}
else
{
gradSchemes_.add("default", "none");
}
if
(
gradSchemes_.found("default")
&& word(gradSchemes_.lookup("default")) != "none"
)
{
defaultGradScheme_ = gradSchemes_.lookup("default");
}
// lnGrad schemes
if (dict.found("lnGradSchemes"))
{
lnGradSchemes_ = dict.subDict("lnGradSchemes");
}
else
{
lnGradSchemes_.add("default", "corrected");
}
if
(
lnGradSchemes_.found("default")
&& word(lnGradSchemes_.lookup("default")) != "none"
)
{
defaultLnGradScheme_ = lnGradSchemes_.lookup("default");
}
// laplacian schemes
if (dict.found("laplacianSchemes"))
{
laplacianSchemes_ = dict.subDict("laplacianSchemes");
}
else
{
laplacianSchemes_.add("default", "none");
}
if
(
laplacianSchemes_.found("default")
&& word(laplacianSchemes_.lookup("default")) != "none"
)
{
defaultLaplacianScheme_ = laplacianSchemes_.lookup("default");
}
// Flux required
if (dict.found("fluxRequired"))
{
fluxRequired_ = dict.subDict("fluxRequired");
}
}
return readOk;
}
Foam::fvSchemes::fvSchemes(const objectRegistry& obr)
:
IOdictionary
(
IOobject
(
"fvSchemes",
obr.time().system(),
obr,
// IOobject::MUST_READ,
IOobject::READ_IF_PRESENT, // Allow default dictionary creation
IOobject::NO_WRITE
)
),
ddtSchemes_
(
ITstream
(
objectPath() + "::ddtSchemes",
tokenList()
)()
),
defaultDdtScheme_
(
ddtSchemes_.name() + "::default",
tokenList()
),
d2dt2Schemes_
(
ITstream
(
objectPath() + "::d2dt2Schemes",
tokenList()
)()
),
defaultD2dt2Scheme_
(
d2dt2Schemes_.name() + "::default",
tokenList()
),
interpolationSchemes_
(
ITstream
(
objectPath() + "::interpolationSchemes",
tokenList()
)()
),
defaultInterpolationScheme_
(
interpolationSchemes_.name() + "::default",
tokenList()
),
divSchemes_
(
ITstream
(
objectPath() + "::divSchemes",
tokenList()
)()
),
defaultDivScheme_
(
divSchemes_.name() + "::default",
tokenList()
),
gradSchemes_
(
ITstream
(
objectPath() + "::gradSchemes",
tokenList()
)()
),
defaultGradScheme_
(
gradSchemes_.name() + "::default",
tokenList()
),
snGradSchemes_
(
ITstream
(
objectPath() + "::snGradSchemes",
tokenList()
)()
),
defaultSnGradScheme_
(
snGradSchemes_.name() + "::default",
tokenList()
),
laplacianSchemes_
(
ITstream
(
objectPath() + "::laplacianSchemes",
tokenList()
)()
),
defaultLaplacianScheme_
(
laplacianSchemes_.name() + "::default",
tokenList()
),
fluxRequired_
(
ITstream
(
objectPath() + "::fluxRequired",
tokenList()
)()
),
defaultFluxRequired_(false),
cacheFields_
(
ITstream
(
objectPath() + "::cacheFields",
tokenList()
)()
)
{
if (!headerOk())
{
if (debug)
{
InfoIn
(
"fvSchemes::fvSchemes(const objectRegistry& obr)"
) << "fvSchemes dictionary not found. Creating default."
<< endl;
}
regIOobject::write();
}
read();
}
Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh(const IOobject& io)
:
regIOobject(io),
edgeMesh(pointField(0), edgeList(0)),
concaveStart_(0),
mixedStart_(0),
nonFeatureStart_(0),
internalStart_(0),
flatStart_(0),
openStart_(0),
multipleStart_(0),
normals_(0),
edgeDirections_(0),
edgeNormals_(0),
featurePointNormals_(0),
featurePointEdges_(0),
regionEdges_(0),
pointTree_(),
edgeTree_(),
edgeTreesByType_()
{
if
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
if (readOpt() == IOobject::MUST_READ_IF_MODIFIED)
{
WarningIn
(
"extendedFeatureEdgeMesh::extendedFeatureEdgeMesh"
"(const IOobject&)"
) << "Specified IOobject::MUST_READ_IF_MODIFIED but class"
<< " does not support automatic rereading."
<< endl;
}
Istream& is = readStream(typeName);
is >> *this
>> concaveStart_
>> mixedStart_
>> nonFeatureStart_
>> internalStart_
>> flatStart_
>> openStart_
>> multipleStart_
>> normals_
>> edgeNormals_
>> featurePointNormals_
>> featurePointEdges_
>> regionEdges_;
close();
{
// Calculate edgeDirections
const edgeList& eds(edges());
const pointField& pts(points());
edgeDirections_.setSize(eds.size());
forAll(eds, eI)
{
edgeDirections_[eI] = eds[eI].vec(pts);
}
edgeDirections_ /= mag(edgeDirections_);
}
}
Foam::fvSchemes::fvSchemes(const objectRegistry& obr)
:
IOdictionary
(
IOobject
(
"fvSchemes",
obr.time().system(),
obr,
(
obr.readOpt() == IOobject::MUST_READ
|| obr.readOpt() == IOobject::READ_IF_PRESENT
? IOobject::MUST_READ_IF_MODIFIED
: obr.readOpt()
),
IOobject::NO_WRITE
)
),
ddtSchemes_
(
ITstream
(
objectPath() + ".ddtSchemes",
tokenList()
)()
),
defaultDdtScheme_
(
ddtSchemes_.name() + ".default",
tokenList()
),
d2dt2Schemes_
(
ITstream
(
objectPath() + ".d2dt2Schemes",
tokenList()
)()
),
defaultD2dt2Scheme_
(
d2dt2Schemes_.name() + ".default",
tokenList()
),
interpolationSchemes_
(
ITstream
(
objectPath() + ".interpolationSchemes",
tokenList()
)()
),
defaultInterpolationScheme_
(
interpolationSchemes_.name() + ".default",
tokenList()
),
divSchemes_
(
ITstream
(
objectPath() + ".divSchemes",
tokenList()
)()
),
defaultDivScheme_
(
divSchemes_.name() + ".default",
tokenList()
),
gradSchemes_
(
ITstream
(
objectPath() + ".gradSchemes",
tokenList()
)()
),
defaultGradScheme_
(
gradSchemes_.name() + ".default",
tokenList()
),
snGradSchemes_
(
ITstream
(
objectPath() + ".snGradSchemes",
tokenList()
)()
),
defaultSnGradScheme_
(
snGradSchemes_.name() + ".default",
tokenList()
),
laplacianSchemes_
(
ITstream
(
objectPath() + ".laplacianSchemes",
tokenList()
)()
),
defaultLaplacianScheme_
(
laplacianSchemes_.name() + ".default",
tokenList()
),
fluxRequired_
(
ITstream
(
objectPath() + ".fluxRequired",
tokenList()
)()
),
defaultFluxRequired_(false),
steady_(false)
{
if
(
readOpt() == IOobject::MUST_READ
|| readOpt() == IOobject::MUST_READ_IF_MODIFIED
|| (readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
read(schemesDict());
}
}
/* Parse an IMD image. This sets up sim_imd to be able to do sector read/write and
* track write.
*/
static t_stat diskParse(DISK_INFO *myDisk, uint32 isVerbose)
{
uint8 comment[256];
uint8 sectorMap[256];
uint8 sectorHeadMap[256];
uint8 sectorCylMap[256];
uint32 sectorSize, sectorHeadwithFlags, sectRecordType;
uint32 i;
uint8 start_sect;
uint32 TotalSectorCount = 0;
IMD_HEADER imd;
if(myDisk == NULL) {
return (SCPE_OPENERR);
}
memset(myDisk->track, 0, (sizeof(TRACK_INFO)*MAX_CYL*MAX_HEAD));
if (commentParse(myDisk, comment, sizeof(comment)) != SCPE_OK) {
return (SCPE_OPENERR);
}
if(isVerbose)
sim_printf("%s\n", comment);
myDisk->nsides = 1;
myDisk->ntracks = 0;
myDisk->flags = 0; /* Make sure all flags are clear. */
if(feof(myDisk->file)) {
sim_printf("SIM_IMD: Disk image is blank, it must be formatted.\n");
return (SCPE_OPENERR);
}
do {
sim_debug(myDisk->debugmask, myDisk->device, "start of track %d at file offset %ld\n", myDisk->ntracks, ftell(myDisk->file));
sim_fread(&imd, 1, 5, myDisk->file);
if (feof(myDisk->file))
break;
sectorSize = 128 << imd.sectsize;
sectorHeadwithFlags = imd.head; /*AGN save the head and flags */
imd.head &= 1 ; /*AGN mask out flag bits to head 0 or 1 */
sim_debug(myDisk->debugmask, myDisk->device, "Track %d:\n", myDisk->ntracks);
sim_debug(myDisk->debugmask, myDisk->device, "\tMode=%d, Cyl=%d, Head=%d(%d), #sectors=%d, sectsize=%d (%d bytes)\n", imd.mode, imd.cyl, sectorHeadwithFlags, imd.head, imd.nsects, imd.sectsize, sectorSize);
if (!headerOk(imd)) {
sim_printf("SIM_IMD: Corrupt header.\n");
return (SCPE_OPENERR);
}
if((imd.head + 1) > myDisk->nsides) {
myDisk->nsides = imd.head + 1;
}
myDisk->track[imd.cyl][imd.head].mode = imd.mode;
myDisk->track[imd.cyl][imd.head].nsects = imd.nsects;
myDisk->track[imd.cyl][imd.head].sectsize = sectorSize;
if (sim_fread(sectorMap, 1, imd.nsects, myDisk->file) != imd.nsects) {
sim_printf("SIM_IMD: Corrupt file [Sector Map].\n");
return (SCPE_OPENERR);
}
myDisk->track[imd.cyl][imd.head].start_sector = imd.nsects;
sim_debug(myDisk->debugmask, myDisk->device, "\tSector Map: ");
for(i=0;i<imd.nsects;i++) {
sim_debug(myDisk->debugmask, myDisk->device, "%d ", sectorMap[i]);
if(sectorMap[i] < myDisk->track[imd.cyl][imd.head].start_sector) {
myDisk->track[imd.cyl][imd.head].start_sector = sectorMap[i];
}
}
sim_debug(myDisk->debugmask, myDisk->device, ", Start Sector=%d", myDisk->track[imd.cyl][imd.head].start_sector);
if(sectorHeadwithFlags & IMD_FLAG_SECT_HEAD_MAP) {
if (sim_fread(sectorHeadMap, 1, imd.nsects, myDisk->file) != imd.nsects) {
sim_printf("SIM_IMD: Corrupt file [Sector Head Map].\n");
return (SCPE_OPENERR);
}
sim_debug(myDisk->debugmask, myDisk->device, "\tSector Head Map: ");
for(i=0;i<imd.nsects;i++) {
sim_debug(myDisk->debugmask, myDisk->device, "%d ", sectorHeadMap[i]);
}
sim_debug(myDisk->debugmask, myDisk->device, "\n");
} else {
/* Default Head is physical head for each sector */
for(i=0;i<imd.nsects;i++) {
sectorHeadMap[i] = imd.head;
};
}
if(sectorHeadwithFlags & IMD_FLAG_SECT_CYL_MAP) {
if (sim_fread(sectorCylMap, 1, imd.nsects, myDisk->file) != imd.nsects) {
sim_printf("SIM_IMD: Corrupt file [Sector Cyl Map].\n");
return (SCPE_OPENERR);
}
sim_debug(myDisk->debugmask, myDisk->device, "\tSector Cyl Map: ");
for(i=0;i<imd.nsects;i++) {
sim_debug(myDisk->debugmask, myDisk->device, "%d ", sectorCylMap[i]);
}
sim_debug(myDisk->debugmask, myDisk->device, "\n");
} else {
/* Default Cyl Map is physical cylinder for each sector */
for(i=0;i<imd.nsects;i++) {
sectorCylMap[i] = imd.cyl;
}
}
sim_debug(myDisk->debugmask, myDisk->device, "\nSector data at offset 0x%08lx\n", ftell(myDisk->file));
/* Build the table with location 0 being the start sector. */
start_sect = myDisk->track[imd.cyl][imd.head].start_sector;
/* Now read each sector */
for(i=0;i<imd.nsects;i++) {
TotalSectorCount++;
sim_debug(myDisk->debugmask, myDisk->device, "Sector Phys: %d/Logical: %d: %d bytes: ", i, sectorMap[i], sectorSize);
sectRecordType = fgetc(myDisk->file);
/* AGN Logical head mapping */
myDisk->track[imd.cyl][imd.head].logicalHead[i] = sectorHeadMap[i];
/* AGN Logical cylinder mapping */
myDisk->track[imd.cyl][imd.head].logicalCyl[i] = sectorCylMap[i];
switch(sectRecordType) {
case SECT_RECORD_UNAVAILABLE: /* Data could not be read from the original media */
if (sectorMap[i]-start_sect < MAX_SPT)
myDisk->track[imd.cyl][imd.head].sectorOffsetMap[sectorMap[i]-start_sect] = 0xBADBAD;
else {
sim_printf("SIM_IMD: ERROR: Illegal sector offset %d\n", sectorMap[i]-start_sect);
return (SCPE_OPENERR);
}
break;
case SECT_RECORD_NORM: /* Normal Data */
case SECT_RECORD_NORM_DAM: /* Normal Data with deleted address mark */
case SECT_RECORD_NORM_ERR: /* Normal Data with read error */
case SECT_RECORD_NORM_DAM_ERR: /* Normal Data with deleted address mark with read error */
/* sim_debug(myDisk->debugmask, myDisk->device, "Uncompressed Data\n"); */
if (sectorMap[i]-start_sect < MAX_SPT) {
myDisk->track[imd.cyl][imd.head].sectorOffsetMap[sectorMap[i]-start_sect] = ftell(myDisk->file);
sim_fseek(myDisk->file, sectorSize, SEEK_CUR);
}
else {
sim_printf("SIM_IMD: ERROR: Illegal sector offset %d\n", sectorMap[i]-start_sect);
return (SCPE_OPENERR);
}
break;
case SECT_RECORD_NORM_COMP: /* Compressed Normal Data */
case SECT_RECORD_NORM_DAM_COMP: /* Compressed Normal Data with deleted address mark */
case SECT_RECORD_NORM_COMP_ERR: /* Compressed Normal Data */
case SECT_RECORD_NORM_DAM_COMP_ERR: /* Compressed Normal Data with deleted address mark */
if (sectorMap[i]-start_sect < MAX_SPT) {
myDisk->track[imd.cyl][imd.head].sectorOffsetMap[sectorMap[i]-start_sect] = ftell(myDisk->file);
myDisk->flags |= FD_FLAG_WRITELOCK; /* Write-protect the disk if any sectors are compressed. */
if (1) {
uint8 cdata = fgetc(myDisk->file);
sim_debug(myDisk->debugmask, myDisk->device, "Compressed Data = 0x%02x\n", cdata);
}
}
else {
sim_printf("SIM_IMD: ERROR: Illegal sector offset %d\n", sectorMap[i]-start_sect);
return (SCPE_OPENERR);
}
break;
default:
sim_printf("SIM_IMD: ERROR: unrecognized sector record type %d\n", sectRecordType);
return (SCPE_OPENERR);
break;
}
sim_debug(myDisk->debugmask, myDisk->device, "\n");
}
myDisk->ntracks++;
} while (!feof(myDisk->file));
sim_debug(myDisk->debugmask, myDisk->device, "Processed %d sectors\n", TotalSectorCount);
for(i=0;i<myDisk->ntracks;i++) {
uint8 j;
sim_debug(myDisk->verbosedebugmask, myDisk->device, "Track %02d: ", i);
for(j=0;j<imd.nsects;j++) {
sim_debug(myDisk->verbosedebugmask, myDisk->device, "0x%06x ", myDisk->track[i][0].sectorOffsetMap[j]);
}
sim_debug(myDisk->verbosedebugmask, myDisk->device, "\n");
}
if(myDisk->flags & FD_FLAG_WRITELOCK) {
sim_printf("Disk write-protected because the image contains compressed sectors. Use IMDU to uncompress.\n");
}
return SCPE_OK;
}