mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1615 lines
48 KiB
1615 lines
48 KiB
|
|
#include "sfs-hide.h"
|
|
#include "sfs-main.h"
|
|
#include "sfs-file.h"
|
|
#include "sfs-scan.h"
|
|
#include "sfs-pack.h"
|
|
#include "sfs-gate.h"
|
|
#include "sfs-tree.h"
|
|
#include "sfs-seek.h"
|
|
|
|
#define LeftBraceStackSpan 64
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Prototype Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
void PackControlInformation ( IEB_Scan * s );
|
|
|
|
static void CompletePackingProcess ( IEB_Scan * s );
|
|
static void IncludeChangeFileLocksRequest ( IEB_Scan * s );
|
|
static void IncludeChangeFilePointerRequest ( IEB_Scan * s );
|
|
static void IncludeCloseFileRequest ( IEB_Scan * s );
|
|
static void IncludeCollateFileRequest ( IEB_Scan * s );
|
|
static void IncludeCollateGroupRequest ( IEB_Scan * s );
|
|
static void IncludeCommandBlockHeader ( CCB_Header * h, IEB_Scan * s );
|
|
static void IncludeCreateRecordRequest ( IEB_Scan * s );
|
|
static void IncludeCreateRecordsRequest ( IEB_Scan * s );
|
|
static void IncludeDeleteFileRequest ( IEB_Scan * s );
|
|
static void IncludeFileDefinition ( IEB_Scan * s );
|
|
static void IncludeGenericTypeRequest ( IEB_Scan * s );
|
|
static void IncludeLeftBraceRequest ( IEB_Scan * s );
|
|
static void IncludeOnErrorRequest ( IEB_Scan * s );
|
|
|
|
static void IncludeOnTimeoutRequest ( IEB_Scan * s );
|
|
static void IncludeOpenFileRequest ( IEB_Scan * s );
|
|
static void IncludeProcessDefinition ( IEB_Scan * s );
|
|
static void IncludePrototypeDefinition ( IEB_Scan * s );
|
|
static void IncludeQueryFileRequest ( IEB_Scan * s );
|
|
static void IncludeReadFileRequest ( IEB_Scan * s );
|
|
static void IncludeRecordGroupRequest ( IEB_Scan * s );
|
|
static void IncludeRepeatRequest ( IEB_Scan * s );
|
|
static void IncludeRightBraceRequest ( IEB_Scan * s );
|
|
static void IncludeSemaphoreDefinition ( IEB_Scan * s );
|
|
static void IncludeSemaphoreBaseRequest ( IEB_Scan * s );
|
|
static void IncludeSemaphoreWaitRequest ( IEB_Scan * s );
|
|
|
|
static void IncludeSleepRequest ( IEB_Scan * s );
|
|
static void IncludeTimerDefinition ( IEB_Scan * s );
|
|
static void IncludeTimerGroupRequest ( IEB_Scan * s );
|
|
static void IncludeTruncateFileRequest ( IEB_Scan * s );
|
|
static void IncludeTypeCommentRequest ( IEB_Scan * s );
|
|
static void IncludeUtilityRequest ( IEB_Scan * s );
|
|
static void IncludeWriteFileRequest ( IEB_Scan * s );
|
|
|
|
static void InitiatePackingProcess ( IEB_Scan * s );
|
|
|
|
static void NotifyAndActAsProper ( WORD ErrorDescriptor );
|
|
|
|
static void SplitAuxiliaryClassRequests ( IEB_Scan * s );
|
|
static void SplitCollateGroupRequests ( IEB_Scan * s );
|
|
static void SplitCreateGroupRequests ( IEB_Scan * s );
|
|
static void SplitDefineClassRequests ( IEB_Scan * s );
|
|
static void SplitFileClassRequests ( IEB_Scan * s );
|
|
static void SplitFlowClassRequests ( IEB_Scan * s );
|
|
static void SplitGenericFileGroupRequests ( IEB_Scan * s );
|
|
static void SplitOpenFileGroupRequests ( IEB_Scan * s );
|
|
static void SplitRecordGroupRequests ( IEB_Scan * s );
|
|
static void SplitScanClassRequests ( IEB_Scan * s );
|
|
static void SplitSemaphoreClassRequests ( IEB_Scan * s );
|
|
static void SplitSemaphoreBaseGroup ( IEB_Scan * s );
|
|
static void SplitSemaphoreWaitGroup ( IEB_Scan * s );
|
|
static void SplitTimerClassRequests ( IEB_Scan * s );
|
|
static void SplitTypeGroupRequests ( IEB_Scan * s );
|
|
static void SplitUtilityGroupRequests ( IEB_Scan * s );
|
|
static void InitializeSemaphore ( SCB_Semaphore * s );
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Other Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
extern IEB_Gate * IEB_GatePointer;
|
|
|
|
CCB_Header * CCB_HeaderTrackPointer;
|
|
FCB_File * FCB_FileTrackPointer;
|
|
OCB_OnError * OCB_OnErrorTrackPointer;
|
|
OCB_OnTimeout * OCB_OnTimeoutTrackPointer;
|
|
|
|
PCB_Process * PCB_ProcessTrackPointer;
|
|
PCB_Prototype * PCB_PrototypeTrackPointer;
|
|
SCB_Semaphore * SCB_SemaphoreTrackPointer;
|
|
TCB_Timer * TCB_TimerTrackPointer;
|
|
|
|
IEB_Seek IEB_seek;
|
|
|
|
IEB_Scan * IEB_ScanPointer;
|
|
IEB_Seek * IEB_SeekPointer;
|
|
|
|
BYTE FileExtrinsicKey;
|
|
BYTE FileIntrinsicKey;
|
|
|
|
BYTE ProcessExtrinsicKey;
|
|
BYTE ProcessIntrinsicKey;
|
|
|
|
BYTE PrototypeExtrinsicKey;
|
|
BYTE PrototypeIntrinsicKey;
|
|
|
|
BYTE SemaphoreExtrinsicKey;
|
|
BYTE SemaphoreIntrinsicKey;
|
|
|
|
BYTE TimerExtrinsicKey;
|
|
BYTE TimerIntrinsicKey;
|
|
|
|
CCB_Header * LeftBraceStack[ LeftBraceStackSpan ];
|
|
|
|
BYTE LeftBraceStackIndex;
|
|
BYTE PackErrorLevel;
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void PackControlInformation ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_ScanPointer = s;
|
|
|
|
switch ( s -> RequestClass )
|
|
{
|
|
case AuxiliaryClass:
|
|
SplitAuxiliaryClassRequests ( s );
|
|
break;
|
|
|
|
case DefineClass:
|
|
SplitDefineClassRequests ( s );
|
|
break;
|
|
|
|
case FileClass:
|
|
SplitFileClassRequests ( s );
|
|
break;
|
|
|
|
case FlowClass:
|
|
SplitFlowClassRequests ( s );
|
|
break;
|
|
|
|
case ScanClass:
|
|
SplitScanClassRequests ( s );
|
|
break;
|
|
|
|
case SemaphoreClass:
|
|
SplitSemaphoreClassRequests ( s );
|
|
break;
|
|
|
|
case TimerClass:
|
|
SplitTimerClassRequests ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorClassNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitAuxiliaryClassRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestGroup )
|
|
{
|
|
case CollateGroup:
|
|
SplitCollateGroupRequests ( s );
|
|
break;
|
|
|
|
case CreateGroup:
|
|
SplitCreateGroupRequests ( s );
|
|
break;
|
|
|
|
case RecordGroup:
|
|
SplitRecordGroupRequests ( s );
|
|
break;
|
|
|
|
case TypeGroup:
|
|
SplitTypeGroupRequests ( s );
|
|
break;
|
|
|
|
case UtilityGroup:
|
|
SplitUtilityGroupRequests ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorGroupNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitCollateGroupRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case CollateRecordsRequest:
|
|
IncludeGenericTypeRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitCreateGroupRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case ClearCreateFlagRequest:
|
|
IncludeGenericTypeRequest ( s );
|
|
break;
|
|
|
|
case CreateNextRecordRequest:
|
|
IncludeGenericTypeRequest ( s );
|
|
break;
|
|
|
|
case CreateRecordRequest:
|
|
IncludeCreateRecordRequest ( s );
|
|
break;
|
|
|
|
case CreateRecordsRequest:
|
|
IncludeCreateRecordsRequest ( s );
|
|
break;
|
|
|
|
case SetCreateFlagRequest:
|
|
IncludeGenericTypeRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitDefineClassRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case DefineFileRequest:
|
|
IncludeFileDefinition ( s );
|
|
break;
|
|
|
|
case DefineProcessRequest:
|
|
IncludeProcessDefinition ( s );
|
|
break;
|
|
|
|
case DefinePrototypeRequest:
|
|
IncludePrototypeDefinition ( s );
|
|
break;
|
|
|
|
case DefineSemaphoreRequest:
|
|
IncludeSemaphoreDefinition ( s );
|
|
break;
|
|
|
|
case DefineTimerRequest:
|
|
IncludeTimerDefinition ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitFileClassRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestGroup )
|
|
{
|
|
case FilePointerGroup:
|
|
IncludeChangeFilePointerRequest ( s );
|
|
break;
|
|
|
|
case FileLocksGroup:
|
|
IncludeChangeFileLocksRequest ( s );
|
|
break;
|
|
|
|
case GenericFileGroup:
|
|
SplitGenericFileGroupRequests ( s );
|
|
break;
|
|
|
|
case GenericFilesGroup:
|
|
IncludeGenericTypeRequest ( s );
|
|
break;
|
|
|
|
case OpenFileGroup:
|
|
SplitOpenFileGroupRequests ( s );
|
|
break;
|
|
|
|
case ReadFileGroup:
|
|
IncludeReadFileRequest ( s );
|
|
break;
|
|
|
|
case WriteFileGroup:
|
|
IncludeWriteFileRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorGroupNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitFlowClassRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestGroup )
|
|
{
|
|
case BraceGroup:
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case LeftBraceRequest:
|
|
IncludeLeftBraceRequest ( s );
|
|
break;
|
|
|
|
case RightBraceRequest:
|
|
IncludeRightBraceRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case OnErrorGroup:
|
|
IncludeOnErrorRequest ( s );
|
|
break;
|
|
|
|
case OnTimeoutGroup:
|
|
IncludeOnTimeoutRequest ( s );
|
|
break;
|
|
|
|
case RepeatGroup:
|
|
IncludeRepeatRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorGroupNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitGenericFileGroupRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case CloseFileRequest:
|
|
IncludeCloseFileRequest ( s );
|
|
break;
|
|
|
|
case DeleteFileRequest:
|
|
IncludeDeleteFileRequest ( s );
|
|
break;
|
|
|
|
case QueryFileRequest:
|
|
IncludeQueryFileRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitOpenFileGroupRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case OpenFileRequest:
|
|
IncludeOpenFileRequest ( s );
|
|
break;
|
|
|
|
case TruncateFileRequest:
|
|
IncludeTruncateFileRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitRecordGroupRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case AppendRecordRequest:
|
|
IncludeRecordGroupRequest ( s );
|
|
break;
|
|
|
|
case CollateFileRequest:
|
|
IncludeCollateFileRequest ( s );
|
|
break;
|
|
|
|
case CopyRecordRequest:
|
|
IncludeRecordGroupRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitScanClassRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case CompletePackingRequest:
|
|
CompletePackingProcess ( s );
|
|
break;
|
|
|
|
case ExecutionSectionRequest:
|
|
break;
|
|
|
|
case PrototypeSectionRequest:
|
|
InitiatePackingProcess ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitSemaphoreClassRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestGroup )
|
|
{
|
|
case BaseGroup:
|
|
SplitSemaphoreBaseGroup ( s );
|
|
break;
|
|
|
|
case WaitGroup:
|
|
SplitSemaphoreWaitGroup ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorGroupNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitSemaphoreBaseGroup ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case ClearSemaphoreRequest:
|
|
IncludeSemaphoreBaseRequest ( s );
|
|
break;
|
|
|
|
case SetSemaphoreRequest:
|
|
IncludeSemaphoreBaseRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitSemaphoreWaitGroup ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case RequestSemaphoreRequest:
|
|
IncludeSemaphoreWaitRequest ( s );
|
|
break;
|
|
|
|
case SetSemaphoreAndWaitRequest:
|
|
IncludeSemaphoreWaitRequest ( s );
|
|
break;
|
|
|
|
case WaitForSemaphoreRequest:
|
|
IncludeSemaphoreWaitRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitTimerClassRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestGroup )
|
|
{
|
|
case SleepGroup:
|
|
IncludeSleepRequest ( s );
|
|
break;
|
|
|
|
case TimerGroup:
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case ReadTimerRequest:
|
|
IncludeTimerGroupRequest ( s );
|
|
break;
|
|
|
|
case StartTimerRequest:
|
|
IncludeTimerGroupRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case TimersGroup:
|
|
IncludeGenericTypeRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorGroupNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitTypeGroupRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case TypeCommentRequest:
|
|
IncludeTypeCommentRequest ( s );
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void SplitUtilityGroupRequests ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
switch ( s -> RequestCode )
|
|
{
|
|
case AppendFileRequest:
|
|
break;
|
|
|
|
case CollateFilesRequest:
|
|
break;
|
|
|
|
case CopyFileRequest:
|
|
break;
|
|
|
|
default:
|
|
NotifyAndActAsProper ( ErrorRequestNotSupported );
|
|
break;
|
|
}
|
|
IncludeUtilityRequest ( s );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeChangeFileLocksRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_ChangeFileLocks * r;
|
|
|
|
// file availability ...
|
|
// first determine size needed to accommodate all data ...
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_ChangeFileLocks ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
r = ( CCB_ChangeFileLocks * ) h;
|
|
// copy all data in list s -> FileLockList ... in two loops ...
|
|
|
|
// r -> FileLockCount = s -> FileLockCount;
|
|
// r -> FileUnlockCount = s -> FileUnlockCount;
|
|
|
|
// to be finished later ...
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeChangeFilePointerRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_ChangeFilePointer * c;
|
|
FCB_File * f;
|
|
IEB_Seek * q;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> FileExtrinsicKey;
|
|
|
|
if ( f = SeekFileControlBlock ( q ) )
|
|
{
|
|
h = ( CCB_Header * ) AllocateControlBlock (sizeof(CCB_ChangeFilePointer));
|
|
IncludeCommandBlockHeader ( h, s );
|
|
c = ( CCB_ChangeFilePointer * ) h;
|
|
|
|
c -> FileExtrinsicKey = f -> FileExtrinsicKey;
|
|
c -> FileIntrinsicKey = f -> FileIntrinsicKey;
|
|
|
|
switch ( s -> FileOffPoint )
|
|
{
|
|
case OffPointBegin:
|
|
c -> FileOffPoint = FILE_BEGIN;
|
|
break;
|
|
|
|
case OffPointCurrent:
|
|
c -> FileOffPoint = FILE_CURRENT;
|
|
break;
|
|
|
|
case OffPointEnd:
|
|
c -> FileOffPoint = FILE_END;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
c -> FileOffset = s -> FileOffset;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorFileUndefined );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeCloseFileRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_CloseFile * c;
|
|
FCB_File * f;
|
|
IEB_Seek * q;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> FileExtrinsicKey;
|
|
|
|
if ( f = SeekFileControlBlock ( q ) )
|
|
{
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_CloseFile ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
c = ( CCB_CloseFile * ) h;
|
|
|
|
c -> FileExtrinsicKey = f -> FileExtrinsicKey;
|
|
c -> FileIntrinsicKey = f -> FileIntrinsicKey;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorFileUndefined );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeCollateFileRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_CollateFile * c;
|
|
FCB_File * f;
|
|
IEB_Seek * q;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_CollateFile ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
c = ( CCB_CollateFile * ) h;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> FileExtrinsicKey;
|
|
|
|
if ( f = SeekFileControlBlock ( q ) )
|
|
{
|
|
c -> FileExtrinsicKey = f -> FileExtrinsicKey;
|
|
c -> FileIntrinsicKey = f -> FileIntrinsicKey;
|
|
|
|
c -> Count = s -> Count;
|
|
c -> PatternIndex = s -> PatternIndex;
|
|
c -> RecordSize = s -> RecordSize;
|
|
c -> SchemeIndex = s -> SchemeIndex;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorFileUndefined );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeCollateGroupRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h; // Delete it later & CCB_Collate as well ...
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Collate ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeCommandBlockHeader ( CCB_Header * h, IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * q;
|
|
|
|
if ( q = CCB_HeaderTrackPointer )
|
|
q -> CCB_HeaderNextInChain = h;
|
|
else
|
|
PCB_ProcessTrackPointer -> CCB_CommandChainEntryPoint = h;
|
|
|
|
h -> CCB_HeaderNextInChain = NULL;
|
|
h -> CCB_HeaderBackInChain = q;
|
|
|
|
h -> ProcessExtrinsicKey = ProcessExtrinsicKey;
|
|
h -> ProcessIntrinsicKey = ProcessIntrinsicKey;
|
|
|
|
h -> RequestCode = s -> RequestCode;
|
|
h -> RequestGroup = s -> RequestGroup;
|
|
h -> RequestClass = s -> RequestClass;
|
|
h -> RequestModifiers = s -> RequestModifiers;
|
|
h -> RequestReferenceLine = s -> RequestReferenceLine;
|
|
|
|
CCB_HeaderTrackPointer = h;
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeCreateRecordRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_CreateRecord * r;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_CreateRecord ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
r = ( CCB_CreateRecord * ) h;
|
|
r -> RecordIndex = s -> RecordIndex;
|
|
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeCreateRecordsRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_CreateRecords * r;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_CreateRecords ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
r = ( CCB_CreateRecords * ) h;
|
|
r -> BufferIndex = s -> BufferIndex;
|
|
r -> PatternIndex = s -> PatternIndex;
|
|
r -> RecordSize = s -> RecordSize;
|
|
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeDeleteFileRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_DeleteFile * c;
|
|
FCB_File * f;
|
|
IEB_Seek * q;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> FileExtrinsicKey;
|
|
|
|
// or make a generic request ?
|
|
// it should be different depending on whether the file is defined in
|
|
// this or in an outside process ...
|
|
|
|
// it is the one found by Seek
|
|
// or delayed one if from another process ...
|
|
|
|
if ( f = SeekFileControlBlock ( q ) )
|
|
{
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_DeleteFile ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
c = ( CCB_DeleteFile * ) h;
|
|
c -> FileExtrinsicKey = f -> FileExtrinsicKey;
|
|
c -> FileIntrinsicKey = f -> FileIntrinsicKey;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorFileUndefined );
|
|
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeFileDefinition ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
FCB_File * f;
|
|
PCB_Process * p;
|
|
IEB_Seek * q;
|
|
TEXT * t;
|
|
|
|
// generalize it later to include looking up outside this process...
|
|
|
|
p = PCB_ProcessTrackPointer;
|
|
q = IEB_SeekPointer;
|
|
q -> PCB_ProcessToLookUp = p;
|
|
q -> ProcessToLookUpKey = p -> ProcessExtrinsicKey;
|
|
q -> ProcessRequestorKey = p -> ProcessExtrinsicKey;
|
|
q -> SearchKeyToUse = s -> FileExtrinsicKey;
|
|
q -> SearchKeyType = ExtrinsicKey;
|
|
|
|
if ( SeekFileControlBlock ( q ) )
|
|
NotifyAndActAsProper ( ErrorFileRedefinition );
|
|
else
|
|
{
|
|
t = AccommodateTextString ( s -> FileNamePointer );
|
|
f = ( FCB_File * ) AllocateControlBlock ( sizeof ( FCB_File ) );
|
|
f -> FCB_FileBackInChain = FCB_FileTrackPointer;
|
|
if ( FileIntrinsicKey )
|
|
FCB_FileTrackPointer -> FCB_FileNextInChain = f;
|
|
else
|
|
p -> FCB_FileChainEntryPoint = f;
|
|
|
|
f -> ProcessExtrinsicKey = ProcessExtrinsicKey; // new
|
|
f -> ProcessIntrinsicKey = ProcessIntrinsicKey; // new
|
|
|
|
f -> FileNamePointer = t;
|
|
f -> FileExtrinsicKey = s -> FileExtrinsicKey;
|
|
f -> FileIntrinsicKey = ++ FileIntrinsicKey;
|
|
FCB_FileTrackPointer = f;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeGenericTypeRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Command ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeLeftBraceRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_Brace * r;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Brace ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
r = ( CCB_Brace * ) h;
|
|
r -> CounterpartOfThisBrace = NULL;
|
|
|
|
if ( LeftBraceStackIndex < LeftBraceStackSpan )
|
|
{
|
|
LeftBraceStack[ LeftBraceStackIndex ++ ] = h;
|
|
r -> BraceNestingLevel = LeftBraceStackIndex;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorStackOverflow );
|
|
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeOnErrorRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
OCB_OnError * q;
|
|
CCB_Brace * r;
|
|
|
|
if ( h = CCB_HeaderTrackPointer )
|
|
if ( h -> RequestCode == RightBraceRequest )
|
|
{
|
|
q = ( OCB_OnError * ) AllocateControlBlock ( sizeof ( OCB_OnError ) );
|
|
r = ( CCB_Brace * ) h;
|
|
|
|
if ( OCB_OnErrorTrackPointer )
|
|
OCB_OnErrorTrackPointer -> OCB_OnErrorNextInChain = q;
|
|
else
|
|
PCB_ProcessTrackPointer -> OCB_OnErrorChainEntryPoint = q;
|
|
|
|
q -> OCB_OnErrorBackInChain = OCB_OnErrorTrackPointer;
|
|
q -> OnErrorLowerBoundary = r -> CounterpartOfThisBrace;
|
|
q -> OnErrorUpperBoundary = h;
|
|
q -> OnErrorModifiers = s -> RequestModifiers;
|
|
|
|
OCB_OnErrorTrackPointer = q;
|
|
}
|
|
NotifyAndActAsProper ( ErrorRequestOutOfSequence );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeOnTimeoutRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
OCB_OnTimeout * q;
|
|
CCB_Brace * r;
|
|
|
|
if ( h = CCB_HeaderTrackPointer )
|
|
if ( h -> RequestCode == RightBraceRequest )
|
|
{
|
|
q = ( OCB_OnTimeout * ) AllocateControlBlock ( sizeof ( OCB_OnTimeout ) );
|
|
r = ( CCB_Brace * ) h;
|
|
|
|
if ( OCB_OnTimeoutTrackPointer )
|
|
OCB_OnTimeoutTrackPointer -> OCB_OnTimeoutNextInChain = q;
|
|
else
|
|
PCB_ProcessTrackPointer -> OCB_OnTimeoutChainEntryPoint = q;
|
|
|
|
q -> OCB_OnTimeoutBackInChain = OCB_OnTimeoutTrackPointer;
|
|
q -> OnTimeoutLowerBoundary = r -> CounterpartOfThisBrace;
|
|
q -> OnTimeoutUpperBoundary = h;
|
|
q -> OnTimeoutModifiers = s -> RequestModifiers;
|
|
|
|
OCB_OnTimeoutTrackPointer = q;
|
|
}
|
|
NotifyAndActAsProper ( ErrorRequestOutOfSequence );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeOpenFileRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_OpenFile * f;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_OpenFile ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
f = ( CCB_OpenFile * ) h; // or make a generic request ??????
|
|
// it should be different depending on whether the file is defined in this
|
|
// or in an outside process ...
|
|
|
|
f -> FileExtrinsicKey = s -> FileExtrinsicKey;
|
|
f -> FileIntrinsicKey = FileIntrinsicKey; // it is the one found by Seek
|
|
// or delayed one if from another process ...
|
|
f -> PrototypeExtrinsicKey = s -> PrototypeExtrinsicKey;
|
|
|
|
f -> FileSize = s -> FileSize;
|
|
f -> RecordSize = s -> RecordSize;
|
|
f -> ScanChangeFlags = s -> ScanChangeFlags;
|
|
f -> ScanTraceFlags = s -> ScanTraceFlags;
|
|
|
|
f -> AttributesChosen = s -> AttributesChosen;
|
|
f -> AttributesDefined = s -> AttributesDefined;
|
|
|
|
f -> OpenFlagsChosen = s -> OpenFlagsChosen;
|
|
f -> AccessModeChosen = s -> AccessModeChosen;
|
|
f -> ShareModeChosen = s -> ShareModeChosen;
|
|
|
|
f -> LocalityFlagsChosen = s -> LocalityFlagsChosen;
|
|
f -> LocalityFlagsDefined = s -> LocalityFlagsDefined;
|
|
|
|
f -> OtherFlagsChosen = s -> OtherFlagsChosen;
|
|
f -> OtherFlagsDefined = s -> OtherFlagsDefined;
|
|
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeProcessDefinition ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Seek * q;
|
|
PCB_Process * p;
|
|
|
|
if ( ProcessIntrinsicKey && LeftBraceStackIndex )
|
|
NotifyAndActAsProper ( ErrorUnbalancedBraces );
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> ProcessExtrinsicKey;
|
|
|
|
if ( SeekProcessControlBlock ( q ) )
|
|
NotifyAndActAsProper ( ErrorProcessRedefinition );
|
|
else
|
|
{
|
|
p = ( PCB_Process * ) AllocateControlBlock ( sizeof ( PCB_Process ) );
|
|
p -> ProcessExtrinsicKey = s -> ProcessExtrinsicKey;
|
|
p -> PCB_ProcessBackInChain = PCB_ProcessTrackPointer;
|
|
ProcessExtrinsicKey = s -> ProcessExtrinsicKey;
|
|
|
|
if ( ProcessIntrinsicKey )
|
|
PCB_ProcessTrackPointer -> PCB_ProcessNextInChain = p;
|
|
else
|
|
IEB_GatePointer -> PCB_ProcessChainEntryPoint = p;
|
|
|
|
p -> ProcessIntrinsicKey = ++ ProcessIntrinsicKey;
|
|
p -> ScanTraceFlags = s -> ScanTraceFlags;
|
|
p -> BufferSpace = s -> BufferSpace;
|
|
PCB_ProcessTrackPointer = p;
|
|
|
|
CCB_HeaderTrackPointer = NULL;
|
|
FCB_FileTrackPointer = NULL;
|
|
OCB_OnErrorTrackPointer = NULL;
|
|
OCB_OnTimeoutTrackPointer = NULL;
|
|
TCB_TimerTrackPointer = NULL;
|
|
|
|
FileIntrinsicKey = Zero;
|
|
TimerIntrinsicKey = Zero;
|
|
|
|
LeftBraceStackIndex = Zero;
|
|
|
|
q -> PCB_ProcessToLookUp = p;
|
|
q -> PCB_ProcessRequestor = p;
|
|
|
|
q -> ProcessToLookUpKey = s -> ProcessExtrinsicKey;
|
|
q -> ProcessRequestorKey = s -> ProcessExtrinsicKey;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludePrototypeDefinition ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Seek * q;
|
|
PCB_Prototype * p;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> PrototypeExtrinsicKey;
|
|
|
|
if ( SeekPrototypeControlBlock ( q ) )
|
|
NotifyAndActAsProper ( ErrorPrototypeRedefinition );
|
|
else
|
|
{
|
|
p = ( PCB_Prototype * ) AllocateControlBlock ( sizeof ( PCB_Prototype ) );
|
|
p -> PrototypeExtrinsicKey = s -> PrototypeExtrinsicKey;
|
|
p -> PCB_PrototypeBackInChain = PCB_PrototypeTrackPointer;
|
|
|
|
if ( PrototypeIntrinsicKey )
|
|
PCB_PrototypeTrackPointer -> PCB_PrototypeNextInChain = p;
|
|
else
|
|
IEB_GatePointer -> PCB_PrototypeChainEntryPoint = p;
|
|
|
|
PCB_PrototypeTrackPointer = p;
|
|
p -> PrototypeIntrinsicKey = ++ PrototypeIntrinsicKey;
|
|
|
|
p -> AttributesChosen = s -> AttributesChosen;
|
|
p -> AttributesDefined = s -> AttributesDefined;
|
|
|
|
p -> OpenFlagsChosen = s -> OpenFlagsChosen;
|
|
p -> AccessModeChosen = s -> AccessModeChosen;
|
|
p -> ShareModeChosen = s -> ShareModeChosen;
|
|
|
|
p -> LocalityFlagsChosen = s -> LocalityFlagsChosen;
|
|
p -> LocalityFlagsDefined = s -> LocalityFlagsDefined;
|
|
|
|
p -> OtherFlagsChosen = s -> OtherFlagsChosen;
|
|
p -> OtherFlagsDefined = s -> OtherFlagsDefined;
|
|
|
|
p -> ScanChangeFlags = s -> ScanChangeFlags;
|
|
p -> ScanTraceFlags = s -> ScanTraceFlags;
|
|
|
|
p -> FileSize = s -> FileSize;
|
|
p -> RecordSize = s -> RecordSize;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeQueryFileRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_QueryFile * f;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_QueryFile ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
f = ( CCB_QueryFile * ) h; // or make a generic request ??????
|
|
// it should be different depending on whether the file is defined in this
|
|
// or in an outside process ...
|
|
|
|
f -> FileExtrinsicKey = s -> FileExtrinsicKey;
|
|
f -> FileIntrinsicKey = FileIntrinsicKey; // it is the one found by Seek
|
|
// or delayed one if from another process ...
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeReadFileRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_ReadFile * f;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_ReadFile ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
f = ( CCB_ReadFile * ) h; // or make a generic request ??????
|
|
// it should be different depending on whether the file is defined in this
|
|
// or in an outside process ...
|
|
|
|
f -> FileExtrinsicKey = s -> FileExtrinsicKey;
|
|
f -> FileIntrinsicKey = FileIntrinsicKey; // it is the one found by Seek
|
|
// or delayed one if from another process ...
|
|
f -> SemaphoreExtrinsicKey = s -> SemaphoreExtrinsicKey;
|
|
f -> RecordSize = s -> RecordSize;
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeRecordGroupRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_Record * c;
|
|
FCB_File * f;
|
|
IEB_Seek * q;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Record ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
c = ( CCB_Record * ) h;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> FileExtrinsicKey;
|
|
|
|
if ( f = SeekFileControlBlock ( q ) )
|
|
{
|
|
c -> FileExtrinsicKey = f -> FileExtrinsicKey;
|
|
c -> FileIntrinsicKey = f -> FileIntrinsicKey;
|
|
|
|
c -> RecordSize = s -> RecordSize;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorFileUndefined );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeRepeatRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h, * q;
|
|
CCB_Repeat * r;
|
|
|
|
if ( q = CCB_HeaderTrackPointer )
|
|
if ( q -> RequestCode == RightBraceRequest )
|
|
{
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Repeat ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
r = ( CCB_Repeat * ) h;
|
|
r -> RepeatCurrentValue = Zero;
|
|
r -> RepeatControlValue = s -> RepeatControlValue;
|
|
if ( q = ( ( CCB_Brace * ) q ) -> CounterpartOfThisBrace )
|
|
{
|
|
if ( s -> RequestModifiers & RepeatOnTimer )
|
|
q -> RequestModifiers |= RepeatOnTimer;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorRequestInconsistent );
|
|
return;
|
|
}
|
|
NotifyAndActAsProper ( ErrorRequestOutOfSequence );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeRightBraceRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_Brace * r;
|
|
CCB_Brace * c;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Brace ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
r = ( CCB_Brace * ) h;
|
|
|
|
if ( LeftBraceStackIndex > Zero )
|
|
{
|
|
r -> CounterpartOfThisBrace = LeftBraceStack[ -- LeftBraceStackIndex ];
|
|
c = ( CCB_Brace * ) ( r -> CounterpartOfThisBrace );
|
|
c -> CounterpartOfThisBrace = h;
|
|
r -> BraceNestingLevel = c -> BraceNestingLevel;
|
|
}
|
|
else
|
|
{
|
|
r -> CounterpartOfThisBrace = NULL;
|
|
NotifyAndActAsProper ( ErrorStackUnderflow );
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeSemaphoreDefinition ( IEB_Scan * p )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Seek * q;
|
|
SCB_Semaphore * s;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = p -> SemaphoreExtrinsicKey;
|
|
|
|
if ( SeekSemaphoreControlBlock ( q ) )
|
|
NotifyAndActAsProper ( ErrorSemaphoreRedefinition );
|
|
else
|
|
{
|
|
s = ( SCB_Semaphore * ) AllocateControlBlock ( sizeof ( SCB_Semaphore ) );
|
|
s -> SCB_SemaphoreBackInChain = SCB_SemaphoreTrackPointer;
|
|
|
|
if ( SemaphoreIntrinsicKey )
|
|
SCB_SemaphoreTrackPointer -> SCB_SemaphoreNextInChain = s;
|
|
else
|
|
IEB_GatePointer -> SCB_SemaphoreChainEntryPoint = s;
|
|
|
|
SCB_SemaphoreTrackPointer = s;
|
|
|
|
InitializeSemaphore ( s );
|
|
|
|
s -> SemaphoreExtrinsicKey = p -> SemaphoreExtrinsicKey;
|
|
s -> SemaphoreIntrinsicKey = ++ SemaphoreIntrinsicKey;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeSemaphoreBaseRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Seek * q;
|
|
CCB_Header * h;
|
|
CCB_Semaphore * r;
|
|
SCB_Semaphore * p;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> SemaphoreExtrinsicKey;
|
|
|
|
if ( p = SeekSemaphoreControlBlock ( q ) )
|
|
{
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Semaphore ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
r = ( CCB_Semaphore * ) h;
|
|
r -> SemaphoreExtrinsicKey = s -> SemaphoreExtrinsicKey;
|
|
r -> SemaphoreIntrinsicKey = p -> SemaphoreIntrinsicKey;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorSemaphoreUndefined );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeSemaphoreWaitRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Seek * q;
|
|
CCB_Header * h;
|
|
CCB_WaitForSemaphore * r;
|
|
SCB_Semaphore * p;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> SemaphoreExtrinsicKey;
|
|
|
|
if ( p = SeekSemaphoreControlBlock ( q ) )
|
|
{
|
|
h = ( CCB_Header * )AllocateControlBlock( sizeof( CCB_WaitForSemaphore ));
|
|
IncludeCommandBlockHeader ( h, s );
|
|
r = ( CCB_WaitForSemaphore * ) h;
|
|
r -> SemaphoreExtrinsicKey = s -> SemaphoreExtrinsicKey;
|
|
r -> SemaphoreIntrinsicKey = p -> SemaphoreIntrinsicKey;
|
|
r -> Timeout = s -> Timeout;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorSemaphoreUndefined );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeSleepRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_Sleep * r;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Sleep ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
r = ( CCB_Sleep * ) h;
|
|
r -> TimeToSleep = s -> TimeToSleep;
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeTimerDefinition ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Seek * q;
|
|
TCB_Timer * t;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> TimerExtrinsicKey;
|
|
|
|
if ( SeekTimerControlBlock ( q ) )
|
|
NotifyAndActAsProper ( ErrorTimerRedefinition );
|
|
else
|
|
{
|
|
t = ( TCB_Timer * ) AllocateControlBlock ( sizeof ( TCB_Timer ) );
|
|
t -> TCB_TimerBackInChain = TCB_TimerTrackPointer;
|
|
|
|
if ( TimerIntrinsicKey )
|
|
TCB_TimerTrackPointer -> TCB_TimerNextInChain = t;
|
|
else
|
|
PCB_ProcessTrackPointer -> TCB_TimerChainEntryPoint = t;
|
|
|
|
TCB_TimerTrackPointer = t;
|
|
|
|
t -> TimerExtrinsicKey = s -> TimerExtrinsicKey;
|
|
t -> TimerIntrinsicKey = ++ TimerIntrinsicKey;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeTimerGroupRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Seek * q;
|
|
CCB_Header * h;
|
|
CCB_Timer * r;
|
|
TCB_Timer * t;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> TimerExtrinsicKey;
|
|
|
|
if ( t = SeekTimerControlBlock ( q ) )
|
|
{
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Timer ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
r = ( CCB_Timer * ) h;
|
|
r -> TimerExtrinsicKey = t -> TimerExtrinsicKey;
|
|
r -> TimerIntrinsicKey = t -> TimerIntrinsicKey;
|
|
}
|
|
else
|
|
NotifyAndActAsProper ( ErrorTimerUndefined );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeTruncateFileRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_TruncateFile * f;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_TruncateFile ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
f = ( CCB_TruncateFile * ) h; // or make a generic request ??????
|
|
// it should be different depending on whether the file is defined in this
|
|
// or in an outside process ...
|
|
|
|
f -> FileExtrinsicKey = s -> FileExtrinsicKey;
|
|
f -> FileIntrinsicKey = FileIntrinsicKey; // it is the one found by Seek
|
|
// or delayed one if from another process ...
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeTypeCommentRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_Comment * r;
|
|
|
|
TEXT * t;
|
|
|
|
t = AccommodateTextString ( s -> CommentTextPointer );
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Comment ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
r = ( CCB_Comment * ) h;
|
|
r -> CommentTextPointer = t;
|
|
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeUtilityRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_Utility * c;
|
|
FCB_File * f;
|
|
IEB_Seek * q;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_Utility ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
c = ( CCB_Utility * ) h;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> SearchKeyToUse = s -> SourceExtrinsicKey;
|
|
|
|
if ( f = SeekFileControlBlock ( q ) )
|
|
{
|
|
c -> SourceExtrinsicKey = f -> FileExtrinsicKey;
|
|
c -> SourceIntrinsicKey = f -> FileIntrinsicKey;
|
|
|
|
q -> SearchKeyToUse = s -> TargetExtrinsicKey;
|
|
|
|
if ( f = SeekFileControlBlock ( q ) )
|
|
{
|
|
c -> TargetExtrinsicKey = f -> FileExtrinsicKey;
|
|
c -> TargetIntrinsicKey = f -> FileIntrinsicKey;
|
|
|
|
c -> Count = s -> Count;
|
|
c -> PatternIndex = s -> PatternIndex;
|
|
c -> RecordSize = s -> RecordSize;
|
|
c -> SchemeIndex = s -> SchemeIndex;
|
|
}
|
|
return;
|
|
}
|
|
NotifyAndActAsProper ( ErrorFileUndefined );
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void IncludeWriteFileRequest ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
CCB_Header * h;
|
|
CCB_WriteFile * c;
|
|
|
|
h = ( CCB_Header * ) AllocateControlBlock ( sizeof ( CCB_WriteFile ) );
|
|
IncludeCommandBlockHeader ( h, s );
|
|
|
|
c = ( CCB_WriteFile * ) h; // or make a generic request ??????
|
|
// it should be different depending on whether the file is defined in this
|
|
// or in an outside process ...
|
|
|
|
c -> FileExtrinsicKey = s -> FileExtrinsicKey;
|
|
c -> FileIntrinsicKey = FileIntrinsicKey; // it is the one found by Seek
|
|
// or delayed one if from another process ...
|
|
c -> SemaphoreExtrinsicKey = s -> SemaphoreExtrinsicKey;
|
|
c -> RecordSize = s -> RecordSize;
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void InitiatePackingProcess ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Seek * q;
|
|
|
|
// printf ( "\r\n.. .. .. Starting packing control information\r\n\n" );
|
|
|
|
PackErrorLevel = Reset;
|
|
IEB_SeekPointer = &IEB_seek;
|
|
|
|
q = IEB_SeekPointer;
|
|
q -> ProcessToLookUpKey = Zero;
|
|
q -> ProcessRequestorKey = Zero;
|
|
q -> SearchKeyType = ExtrinsicKey;
|
|
|
|
ProcessIntrinsicKey = Zero;
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void CompletePackingProcess ( IEB_Scan * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Gate * g;
|
|
|
|
printf ( "\r\n.. .. .. Completing control information\r\n\n" );
|
|
|
|
if ( ProcessIntrinsicKey && LeftBraceStackIndex )
|
|
NotifyAndActAsProper ( ErrorUnbalancedBraces );
|
|
|
|
// CheckFileCrossReferences ();
|
|
|
|
g = IEB_GatePointer;
|
|
|
|
g -> ProcessesToRun = ProcessIntrinsicKey;
|
|
s -> PackErrorLevel = PackErrorLevel;
|
|
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void NotifyAndActAsProper ( WORD ErrorDescriptor )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
IEB_Scan * s;
|
|
|
|
s = IEB_ScanPointer;
|
|
|
|
switch ( ErrorDescriptor ) // compress later ...
|
|
{
|
|
case ErrorFileRedefinition:
|
|
printf ( "\r\n .. line ... file ... redefinition" );
|
|
break;
|
|
|
|
case ErrorProcessRedefinition:
|
|
printf ( "\r\n .. line ... process ... redefinition" );
|
|
break;
|
|
|
|
case ErrorPrototypeRedefinition:
|
|
printf ( "\r\n .. line ... prototype ... redefinition" );
|
|
break;
|
|
|
|
case ErrorSemaphoreRedefinition:
|
|
printf ( "\r\n .. line ... semaphore ... redefinition" );
|
|
break;
|
|
|
|
case ErrorTimerRedefinition:
|
|
printf ( "\r\n .. line ... timer ... redefinition" );
|
|
break;
|
|
|
|
case ErrorFileUndefined:
|
|
printf ( "\r\n .. line ... file ... undefined" );
|
|
break;
|
|
|
|
case ErrorProcessUndefined:
|
|
printf ( "\r\n .. line ... process ... Undefined" );
|
|
break;
|
|
|
|
case ErrorPrototypeUndefined:
|
|
printf ( "\r\n .. line ... prototype ... Undefined" );
|
|
break;
|
|
|
|
case ErrorSemaphoreUndefined:
|
|
printf ( "\r\n .. line ... semaphore ... Undefined" );
|
|
break;
|
|
|
|
case ErrorTimerUndefined:
|
|
printf ( "\r\n .. line ... timer ... Undefined" );
|
|
break;
|
|
|
|
case ErrorUnbalancedBraces:
|
|
printf ( "\r\n .. line %u - ", s -> RequestReferenceLine );
|
|
printf ( "unbalanced braces in process definition" );
|
|
break;
|
|
|
|
case ErrorCreateEvent:
|
|
printf( "\r\n CreateEvent failed (error %d).\n", GetLastError() );
|
|
break;
|
|
|
|
default:
|
|
printf ( "\r\n.. .. .. Error %u has occurred.", ErrorDescriptor );
|
|
printf ( "\r\n.. Request Class = %0.2x", s -> RequestClass );
|
|
printf ( "\r\n.. Request Group = %0.2x", s -> RequestGroup );
|
|
printf ( "\r\n.. Request Code = %0.2x", s -> RequestCode );
|
|
break;
|
|
}
|
|
//s -> PackErrorFlags = PackErrorFlags;
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
void InitializeSemaphore ( SCB_Semaphore * s )
|
|
/*---------------------------------------------------------------------------------*/
|
|
{
|
|
SECURITY_ATTRIBUTES sa = { sizeof ( SECURITY_ATTRIBUTES ),
|
|
NULL,
|
|
TRUE };
|
|
|
|
s -> Lights = CreateEvent ( &sa, FALSE, TRUE, NULL );
|
|
|
|
if ( s == INVALID_HANDLE_VALUE )
|
|
{
|
|
NotifyAndActAsProper ( ErrorCreateEvent );
|
|
}
|
|
}
|