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.
1265 lines
39 KiB
1265 lines
39 KiB
|
|
#include "sfs-hide.h"
|
|
#include "sfs-main.h"
|
|
#include "sfs-tree.h"
|
|
|
|
#define T ( TREE * )
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Using Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF NoUsingLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, Zero, NULL } };
|
|
|
|
LEAF UsingPatternLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, UsingFlag | PatternFlag | Zero, NULL },
|
|
{ Zero, Zero, Zero, UsingFlag | PatternFlag | ExceptFlag, "except:" } };
|
|
|
|
LEAF UsingPrototypeLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, UsingFlag | PrototypeFlag | Zero, NULL },
|
|
{ Zero, Zero, Zero, UsingFlag | PrototypeFlag | ExceptFlag, "except:" } };
|
|
|
|
LEAF UsingSchemeLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, UsingFlag | SchemeFlag | Zero, NULL },
|
|
{ Zero, Zero, Zero, UsingFlag | SchemeFlag | ExceptFlag, "except:" } };
|
|
|
|
LEAF UsingSemaphoreLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, UsingFlag | SemaphoreFlag | Zero, NULL },
|
|
{ Zero, Zero, Zero, UsingFlag | SemaphoreFlag | ExceptFlag, "except:" } };
|
|
|
|
LEAF UsingSuiteLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, UsingSuiteFlag, NULL } };
|
|
|
|
TREE UsingPatternTrees[] = {
|
|
|
|
{ Leaf | List, 2, T UsingPatternLeaves, "pattern" },
|
|
{ Leaf | List, 2, T UsingPrototypeLeaves, "prototype" },
|
|
{ Leaf | List, 2, T UsingSchemeLeaves, "scheme" },
|
|
{ Leaf | List, 2, T UsingSemaphoreLeaves, "semaphore" } };
|
|
|
|
TREE UsingTrees[] = {
|
|
|
|
{ Leaf | List, 1, T NoUsingLeaves, NULL },
|
|
{ Tree | Text, 4, UsingPatternTrees, "using" },
|
|
{ Leaf | List, 1, T UsingSuiteLeaves, "using:" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* In Process Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF InNoProcessLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, Zero, NULL } };
|
|
|
|
LEAF InProcessLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, ProcessFlag, "process" } };
|
|
|
|
TREE InProcessTrees[] = {
|
|
|
|
{ Leaf | List, 1, T InNoProcessLeaves, NULL },
|
|
{ Leaf | Text, 1, T InProcessLeaves, "in" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* File Common Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF CompletionLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, Zero, NULL },
|
|
{ Zero, Zero, Zero, AsynchronousFlag, "asynchronously" } };
|
|
|
|
LEAF FileReferenceLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, Zero, "file" } };
|
|
|
|
TREE FileCommonJoinTrees[] = {
|
|
|
|
{ Tree | List, 2, InProcessTrees, NULL },
|
|
{ Leaf | List, 2, T CompletionLeaves, NULL },
|
|
{ Tree | List, 3, UsingTrees, NULL } };
|
|
|
|
TREE FileCommonTrees[] = {
|
|
|
|
{ Tree | Join, 3, FileCommonJoinTrees, "file" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Other Common Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF TimeUnitLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, TimeInHour, "hour" },
|
|
{ Zero, Zero, Zero, TimeInHours, "hours" },
|
|
{ Zero, Zero, Zero, TimeInMinutes, "min" },
|
|
{ Zero, Zero, Zero, TimeInMilliseconds, "msec" },
|
|
{ Zero, Zero, Zero, TimeInSeconds, "sec" } };
|
|
|
|
LEAF YesNoLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, OptionChosenNo, "no" },
|
|
{ Zero, Zero, Zero, OptionChosenYes, "yes" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Append Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF AppendFileLeaves[] = {
|
|
|
|
{ AppendFileRequest, UtilityGroup, AuxiliaryClass, Zero, NULL } };
|
|
|
|
LEAF AppendRecordLeaves[] = {
|
|
|
|
{ AppendRecordRequest, RecordGroup, AuxiliaryClass, Zero, NULL } };
|
|
|
|
|
|
TREE AppendFileTrees[] = {
|
|
|
|
{ Leaf | List, 1, T AppendFileLeaves, NULL },
|
|
{ Leaf | Text, 1, T FileReferenceLeaves, NULL },
|
|
{ Leaf | Text, 1, T FileReferenceLeaves, "to" },
|
|
{ Tree | List, 3, UsingTrees, NULL } };
|
|
|
|
TREE AppendRecordTrees[] = {
|
|
|
|
{ Leaf | List, 1, T AppendRecordLeaves, NULL },
|
|
{ Leaf | Text, 1, T FileReferenceLeaves, "to" },
|
|
{ Tree | List, 3, UsingTrees, NULL } };
|
|
|
|
TREE AppendTrees[] = {
|
|
|
|
{ Tree | Join, 4, AppendFileTrees, NULL },
|
|
{ Tree | Join, 3, AppendRecordTrees, "record" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Begin Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF BeginReadingLeaves[] = {
|
|
|
|
{ BeginReadingFileRequest, ReadFileGroup, FileClass, Zero, NULL } };
|
|
|
|
LEAF BeginWritingLeaves[] = {
|
|
|
|
{ BeginWritingFileRequest, WriteFileGroup, FileClass, Zero, NULL } };
|
|
|
|
TREE BeginReadingTrees[] = {
|
|
|
|
{ Leaf | List, 1, T BeginReadingLeaves, NULL },
|
|
{ Tree | Text, 1, FileCommonTrees, NULL } };
|
|
|
|
TREE BeginWritingTrees[] = {
|
|
|
|
{ Leaf | List, 1, T BeginWritingLeaves, NULL },
|
|
{ Tree | Text, 1, FileCommonTrees, NULL } };
|
|
|
|
TREE BeginTrees[] = {
|
|
|
|
{ Tree | Join, 2, BeginReadingTrees, "reading" },
|
|
{ Tree | Join, 2, BeginWritingTrees, "writing" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Change Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF ChangeFileLocksLeaves[] = {
|
|
|
|
{ ChangeFileLocksRequest, FileLocksGroup, FileClass, Zero, NULL } };
|
|
|
|
LEAF ChangeFilePointerLeaves[] = {
|
|
|
|
{ ChangeFilePointerRequest, FilePointerGroup, FileClass, Zero, NULL } };
|
|
|
|
TREE ChangeFileLocksTrees[] = {
|
|
|
|
{ Leaf | List, 1, T ChangeFileLocksLeaves, "for" },
|
|
{ Tree | Text, 1, FileCommonTrees, NULL } };
|
|
|
|
TREE ChangeFilePointerTrees[] = {
|
|
|
|
{ Leaf | List, 1, T ChangeFilePointerLeaves, "for" },
|
|
{ Tree | Text, 1, FileCommonTrees, NULL } };
|
|
|
|
TREE ChangeFileTrees[] = {
|
|
|
|
{ Tree | Join, 2, ChangeFileLocksTrees, "locks" },
|
|
{ Tree | Join, 2, ChangeFilePointerTrees, "pointer" } };
|
|
|
|
TREE ChangeTrees[] = {
|
|
|
|
{ Tree | List, 2, ChangeFileTrees, "file" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Clear Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF ClearSemaphoreLeaves[] = {
|
|
|
|
{ ClearSemaphoreRequest, BaseGroup, SemaphoreClass, Zero, NULL } };
|
|
|
|
LEAF ClearCreateLeaves[] = {
|
|
|
|
{ ClearCreateFlagRequest, CreateGroup, AuxiliaryClass, Zero, "flag" } };
|
|
|
|
TREE ClearTrees[] = {
|
|
|
|
{ Leaf | List, 1, T ClearCreateLeaves, "create" },
|
|
{ Leaf | Text, 1, T ClearSemaphoreLeaves, "semaphore" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Close Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF CloseFileLeaves[] = {
|
|
|
|
{ CloseFileRequest, GenericFileGroup, FileClass, Zero, NULL } };
|
|
|
|
LEAF CloseFilesLeaves[] = {
|
|
|
|
{ CloseFilesRequest, GenericFilesGroup, FileClass, Zero, NULL } };
|
|
|
|
TREE CloseOneFileTrees[] = {
|
|
|
|
{ Leaf | List, 1, T CloseFileLeaves, NULL },
|
|
{ Tree | List, 2, InProcessTrees, NULL } };
|
|
|
|
TREE CloseFileTrees[] = {
|
|
|
|
{ Tree | Join, 2, CloseOneFileTrees, NULL } };
|
|
|
|
TREE CloseFilesTrees[] = {
|
|
|
|
{ Leaf | List, 1, T CloseFilesLeaves, NULL },
|
|
{ Tree | List, 2, InProcessTrees, NULL } };
|
|
|
|
TREE CloseTrees[] = {
|
|
|
|
{ Tree | Text, 1, CloseFileTrees, "file" },
|
|
{ Tree | Join, 2, CloseFilesTrees, "files" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Collate Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF CollateFileLeaves[] = {
|
|
|
|
{ CollateFileRequest, RecordGroup, AuxiliaryClass, Zero, "records" } };
|
|
|
|
LEAF CollateFilesLeaves[] = {
|
|
|
|
{ CollateFilesRequest, UtilityGroup, AuxiliaryClass, Zero, NULL } };
|
|
|
|
LEAF CollateRecordsLeaves[] = {
|
|
|
|
{ CollateRecordsRequest, CollateGroup, AuxiliaryClass, Zero, NULL } };
|
|
|
|
TREE CollateFilesTrees[] = {
|
|
|
|
{ Leaf | Text, 1, T FileReferenceLeaves, NULL },
|
|
{ Leaf | List, 1, T CollateFilesLeaves, NULL } };
|
|
|
|
TREE CollateFileAndTrees[] = {
|
|
|
|
{ Tree | Join, 2, CollateFilesTrees, NULL },
|
|
{ Leaf | List, 1, T CollateFileLeaves, "created" } };
|
|
|
|
TREE CollateFileTrees[] = {
|
|
|
|
{ Leaf | Text, 1, T FileReferenceLeaves, NULL },
|
|
{ Tree | List, 2, CollateFileAndTrees, "and" },
|
|
{ Tree | List, 3, UsingTrees, NULL } };
|
|
|
|
TREE CollateTrees[] = {
|
|
|
|
{ Tree | Join, 3, CollateFileTrees, NULL },
|
|
{ Leaf | List, 1, T CollateRecordsLeaves, "records" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Continue Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF ContinueReadingLeaves[] = {
|
|
|
|
{ ContinueReadingFileRequest, ReadFileGroup, FileClass, Zero, NULL } };
|
|
|
|
LEAF ContinueWritingLeaves[] = {
|
|
|
|
{ ContinueWritingFileRequest, WriteFileGroup, FileClass, Zero, NULL } };
|
|
|
|
TREE ContinueReadingTrees[] = {
|
|
|
|
{ Leaf | List, 1, T ContinueReadingLeaves, NULL },
|
|
{ Tree | Text, 1, FileCommonTrees, NULL } };
|
|
|
|
TREE ContinueWritingTrees[] = {
|
|
|
|
{ Leaf | List, 1, T ContinueWritingLeaves, NULL },
|
|
{ Tree | Text, 1, FileCommonTrees, NULL } };
|
|
|
|
TREE ContinueTrees[] = {
|
|
|
|
{ Tree | Join, 2, ContinueReadingTrees, "reading" },
|
|
{ Tree | Join, 2, ContinueWritingTrees, "writing" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Copy Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF CopyFileLeaves[] = {
|
|
|
|
{ CopyFileRequest, UtilityGroup, AuxiliaryClass, Zero, NULL } };
|
|
|
|
LEAF CopyRecordLeaves[] = {
|
|
|
|
{ CopyRecordRequest, RecordGroup, AuxiliaryClass, Zero, NULL } };
|
|
|
|
|
|
TREE CopyFileTrees[] = {
|
|
|
|
{ Leaf | List, 1, T CopyFileLeaves, NULL },
|
|
{ Leaf | Text, 1, T FileReferenceLeaves, NULL },
|
|
{ Leaf | Text, 1, T FileReferenceLeaves, "to" },
|
|
{ Tree | List, 3, UsingTrees, NULL } };
|
|
|
|
TREE CopyRecordTrees[] = {
|
|
|
|
{ Leaf | List, 1, T CopyRecordLeaves, NULL },
|
|
{ Leaf | Text, 1, T FileReferenceLeaves, "to" },
|
|
{ Tree | List, 3, UsingTrees, NULL } };
|
|
|
|
TREE CopyTrees[] = {
|
|
|
|
{ Tree | Join, 4, CopyFileTrees, NULL },
|
|
{ Tree | Join, 3, CopyRecordTrees, "record" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Create Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF CreateNextRecordLeaves[] = {
|
|
|
|
{ CreateNextRecordRequest, CreateGroup, AuxiliaryClass, Zero, "record" } };
|
|
|
|
LEAF CreateRecordLeaves[] = {
|
|
|
|
{ CreateRecordRequest, CreateGroup, AuxiliaryClass, Zero, NULL } };
|
|
|
|
LEAF CreateRecordsLeaves[] = {
|
|
|
|
{ CreateRecordsRequest, CreateGroup, AuxiliaryClass, Zero, NULL } };
|
|
|
|
TREE CreateRecordsTrees[] = {
|
|
|
|
{ Leaf | List, 1, T CreateRecordsLeaves, NULL },
|
|
{ Tree | List, 3, UsingTrees, NULL } };
|
|
|
|
TREE CreateTrees[] = {
|
|
|
|
{ Leaf | List, 1, T CreateNextRecordLeaves, "next" },
|
|
{ Leaf | Text, 1, T CreateRecordLeaves, "record" },
|
|
{ Tree | Join, 2, CreateRecordsTrees, "records" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Delete Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF DeleteFileLeaves[] = {
|
|
|
|
{ DeleteFileRequest, GenericFileGroup, FileClass, Zero, NULL } };
|
|
|
|
LEAF DeleteFilesLeaves[] = {
|
|
|
|
{ DeleteFilesRequest, GenericFilesGroup, FileClass, Zero, NULL } };
|
|
|
|
TREE DeleteOneFileTrees[] = {
|
|
|
|
{ Leaf | List, 1, T DeleteFileLeaves, NULL },
|
|
{ Tree | List, 2, InProcessTrees, NULL } };
|
|
|
|
TREE DeleteFileTrees[] = {
|
|
|
|
{ Tree | Join, 2, DeleteOneFileTrees, NULL } };
|
|
|
|
TREE DeleteFilesTrees[] = {
|
|
|
|
{ Leaf | List, 1, T DeleteFilesLeaves, NULL },
|
|
{ Tree | List, 2, InProcessTrees, NULL } };
|
|
|
|
TREE DeleteTrees[] = {
|
|
|
|
{ Tree | Text, 1, DeleteFileTrees, "file" },
|
|
{ Tree | Join, 2, DeleteFilesTrees, "files" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* End Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF EndReadingLeaves[] = {
|
|
|
|
{ EndReadingFileRequest, ReadFileGroup, FileClass, Zero, NULL } };
|
|
|
|
LEAF EndWritingLeaves[] = {
|
|
|
|
{ EndWritingFileRequest, WriteFileGroup, FileClass, Zero, NULL } };
|
|
|
|
TREE EndReadingTrees[] = {
|
|
|
|
{ Leaf | List, 1, T EndReadingLeaves, NULL },
|
|
{ Tree | Text, 1, FileCommonTrees, NULL } };
|
|
|
|
TREE EndWritingTrees[] = {
|
|
|
|
{ Leaf | List, 1, T EndWritingLeaves, NULL },
|
|
{ Tree | Text, 1, FileCommonTrees, NULL } };
|
|
|
|
TREE EndTrees[] = {
|
|
|
|
{ Tree | Join, 2, EndReadingTrees, "reading" },
|
|
{ Tree | Join, 2, EndWritingTrees, "writing" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* File Access Mode Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF FileAccessModeLeaves[] = {
|
|
|
|
{ FileAccessModeSet, AccessModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF FileAccessModeReadLeaves[] = {
|
|
|
|
{ AccessModeReadOnly, AccessModeGroup, ParameterClass, Zero, "only" },
|
|
{ AccessModeReadWrite, AccessModeGroup, ParameterClass, Zero, "write" } };
|
|
|
|
LEAF FileAccessModeWriteLeaves[] = {
|
|
|
|
{ AccessModeWriteOnly, AccessModeGroup, ParameterClass, Zero, "only" } };
|
|
|
|
TREE FileAccessModeEqualTrees[] = {
|
|
|
|
{ Leaf | List, 2, T FileAccessModeReadLeaves, "read" },
|
|
{ Leaf | List, 1, T FileAccessModeWriteLeaves, "write" } };
|
|
|
|
TREE FileAccessModeTrees[] = {
|
|
|
|
{ Tree | List, 2, FileAccessModeEqualTrees, "=" } };
|
|
|
|
TREE FileAccessTrees[] = {
|
|
|
|
{ Tree | List, 1, FileAccessModeTrees, "mode" },
|
|
{ Leaf | List, 1, T FileAccessModeLeaves, "mode:" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* File Attributes Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF FileAttributesLeaves[] = {
|
|
|
|
{ FileAttributeSet, AttributeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
|
|
LEAF FileArchivedLeaves[] = {
|
|
|
|
{ FileArchived, AttributeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
TREE FileArchivedTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FileArchivedLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
|
|
LEAF FileHiddenLeaves[] = {
|
|
|
|
{ FileHidden, AttributeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
TREE FileHiddenTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FileHiddenLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
|
|
LEAF FileNormalLeaves[] = {
|
|
|
|
{ FileNormal, AttributeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
TREE FileNormalTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FileNormalLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
|
|
LEAF FileReadOnlyLeaves[] = {
|
|
|
|
{ FileReadOnly, AttributeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
TREE FileReadOnlyTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FileReadOnlyLeaves, "only" },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
|
|
LEAF FileSystemLeaves[] = {
|
|
|
|
{ FileSystem, AttributeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
TREE FileSystemTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FileSystemLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* File Mode Flags Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF FileModeFlagsLeaves[] = {
|
|
|
|
{ FileModeFlagsSet, OtherModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF CacheModeLeaves[] = {
|
|
|
|
{ CacheFlag, OtherModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF DASD_ModeLeaves[] = {
|
|
|
|
{ DASD_Flag, OtherModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF FailOnErrorModeLeaves[] = {
|
|
|
|
{ FailOnErrorFlag, OtherModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF InheritanceModeLeaves[] = {
|
|
|
|
{ InheritanceFlag, OtherModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF LocalityModeLeaves[] = {
|
|
|
|
{ LocalityFlag, LocalityModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF RandomModeLeaves[] = {
|
|
|
|
{ RandomFlag, LocalityModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF RandomSequentialModeLeaves[] = {
|
|
|
|
{ RandomSequentialFlag, LocalityModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF SequentialModeLeaves[] = {
|
|
|
|
{ SequentialFlag, LocalityModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
|
|
TREE CacheModeTrees[] = {
|
|
|
|
{ Leaf | List, 1, T CacheModeLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
TREE DASD_ModeTrees[] = {
|
|
|
|
{ Leaf | List, 1, T DASD_ModeLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
TREE FailOnModeTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FailOnErrorModeLeaves, "error" },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
TREE FailModeTrees[] = {
|
|
|
|
{ Tree | Join, 2, FailOnModeTrees, "on" } };
|
|
|
|
TREE InheritanceModeTrees[] = {
|
|
|
|
{ Leaf | List, 1, T InheritanceModeLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
TREE LocalityModeTrees[] = {
|
|
|
|
{ Leaf | List, 1, T LocalityModeLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
TREE RandomOnlyModeTrees[] = {
|
|
|
|
{ Leaf | List, 1, T RandomModeLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
TREE RandomSequentialModeTrees[] = {
|
|
|
|
{ Leaf | List, 1, T RandomSequentialModeLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
TREE RandomModeTrees[] = {
|
|
|
|
{ Tree | Join, 2, RandomOnlyModeTrees, NULL },
|
|
{ Tree | Join, 2, RandomSequentialModeTrees, "sequential" } };
|
|
|
|
TREE SequentialModeTrees[] = {
|
|
|
|
{ Leaf | List, 1, T SequentialModeLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
TREE AllOtherModeTrees[] = {
|
|
|
|
{ Tree | Join, 2, DASD_ModeTrees, "DASD" },
|
|
{ Tree | Join, 2, CacheModeTrees, "cache" },
|
|
{ Tree | List, 1, FailModeTrees, "fail" },
|
|
{ Tree | Join, 2, InheritanceModeTrees, "inheritance" },
|
|
{ Tree | Join, 2, LocalityModeTrees, "locality" },
|
|
{ Tree | List, 2, RandomModeTrees, "random" },
|
|
{ Tree | Join, 2, SequentialModeTrees, "sequential" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* File Open Flags Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF FileOpenFlagsLeaves[] = {
|
|
|
|
{ FileOpenFlagsSet, OpenFlagsGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF FileOpenFlagsCreateLeaves[] = {
|
|
|
|
{ OpenFlagsCreate, OpenFlagsGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF FileOpenFlagsOpenLeaves[] = {
|
|
|
|
{ OpenFlagsOpen, OpenFlagsGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF FileOpenFlagsOpenCreateLeaves[] = {
|
|
|
|
{ OpenFlagsOpenCreate, OpenFlagsGroup, ParameterClass, Zero, "create" } };
|
|
|
|
LEAF FileOpenFlagsTruncateLeaves[] = {
|
|
|
|
{ OpenFlagsTruncate, OpenFlagsGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF FileOpenFlagsTruncateCreateLeaf[] = {
|
|
|
|
{ OpenFlagsTruncateCreate, OpenFlagsGroup, ParameterClass, Zero, "create" } };
|
|
|
|
TREE FileOpenFlagsOpenTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FileOpenFlagsOpenLeaves, NULL },
|
|
{ Leaf | List, 1, T FileOpenFlagsOpenCreateLeaves, "|" } };
|
|
|
|
TREE FileOpenFlagsTruncateTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FileOpenFlagsTruncateLeaves, NULL },
|
|
{ Leaf | List, 1, T FileOpenFlagsTruncateCreateLeaf, "|" } };
|
|
|
|
TREE FileOpenFlagsEqualTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FileOpenFlagsCreateLeaves, "create" },
|
|
{ Tree | List, 2, FileOpenFlagsOpenTrees, "open" },
|
|
{ Tree | List, 2, FileOpenFlagsTruncateTrees, "truncate" } };
|
|
|
|
TREE FileOpenFlagsTrees[] = {
|
|
|
|
{ Tree | List, 3, FileOpenFlagsEqualTrees, "=" } };
|
|
|
|
TREE FileOpenTrees[] = {
|
|
|
|
{ Tree | List, 1, FileOpenFlagsTrees, "flags" },
|
|
{ Leaf | List, 1, T FileOpenFlagsLeaves, "flags:" } };
|
|
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* File Share Mode Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF FileShareModeLeaves[] = {
|
|
|
|
{ FileShareModeSet, ShareModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF FileShareModeDenyNoneLeaves[] = {
|
|
|
|
{ ShareModeDenyNone, ShareModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF FileShareModeDenyReadLeaves[] = {
|
|
|
|
{ ShareModeDenyRead, ShareModeGroup, ParameterClass, Zero, NULL },
|
|
{ ShareModeDenyReadWrite, ShareModeGroup, ParameterClass, Zero, "write" } };
|
|
|
|
LEAF FileShareModeDenyWriteLeaves[] = {
|
|
|
|
{ ShareModeDenyWrite, ShareModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
TREE FileShareModeDenyTrees[] = {
|
|
|
|
{ Leaf | List, 1, T FileShareModeDenyNoneLeaves, "none" },
|
|
{ Leaf | List, 2, T FileShareModeDenyReadLeaves, "read" },
|
|
{ Leaf | List, 1, T FileShareModeDenyWriteLeaves, "write" } };
|
|
|
|
TREE FileShareModeEqualTrees[] = {
|
|
|
|
{ Tree | List, 3, FileShareModeDenyTrees, "deny" } };
|
|
|
|
TREE FileShareModeTrees[] = {
|
|
|
|
{ Tree | List, 1, FileShareModeEqualTrees, "=" } };
|
|
|
|
TREE FileShareTrees[] = {
|
|
|
|
{ Tree | List, 1, FileShareModeTrees, "mode" },
|
|
{ Leaf | List, 1, T FileShareModeLeaves, "mode:" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* File Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF FileSizeLeaves[] = {
|
|
|
|
{ FileSizeValue, QuadSizeGroup, ParameterClass, Zero, "=" } };
|
|
|
|
|
|
TREE FileTrees[] = {
|
|
|
|
{ Tree | List, 2, FileAccessTrees, "access" },
|
|
{ Tree | Join, 2, FileArchivedTrees, "archived" },
|
|
{ Leaf | List, 1, T FileAttributesLeaves, "attributes:" },
|
|
{ Tree | Join, 2, FileHiddenTrees, "hidden" },
|
|
{ Leaf | List, 1, T FileModeFlagsLeaves, "mode" },
|
|
{ Tree | Join, 2, FileNormalTrees, "normal" },
|
|
{ Tree | List, 2, FileOpenTrees, "open" },
|
|
{ Tree | Join, 2, FileReadOnlyTrees, "read" },
|
|
{ Tree | List, 2, FileShareTrees, "share" },
|
|
{ Leaf | Text, 1, T FileSizeLeaves, "size" },
|
|
{ Tree | Join, 2, FileSystemTrees, "system" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Lock Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF LockLengthLeaves[] = {
|
|
|
|
{ LockLengthValue, QuadSizeGroup, ParameterClass, Zero, "=" } };
|
|
|
|
LEAF LockShareLeaves[] = {
|
|
|
|
{ LockShare, FileLocksGroup, ParameterClass, OptionChosenNo, "no" },
|
|
{ LockShare, FileLocksGroup, ParameterClass, OptionChosenYes, "read" } };
|
|
|
|
LEAF LockStartLeaves[] = {
|
|
|
|
{ LockStartValue, QuadSizeGroup, ParameterClass, Zero, "=" } };
|
|
|
|
TREE LockShareTrees[] = {
|
|
|
|
{ Leaf | List, 2, T LockShareLeaves, "=" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* On Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF OnOptionExitLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, OnOptionExit, NULL } };
|
|
|
|
LEAF OnOptionPauseLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, OnOptionPause | Zero, NULL },
|
|
{ Zero, Zero, Zero, OnOptionPause | OnOptionExit, "exit" },
|
|
{ Zero, Zero, Zero, OnOptionPause | OnOptionRepeat, "repeat" } };
|
|
|
|
LEAF OnOptionRepeatLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, OnOptionRepeat, NULL } };
|
|
|
|
LEAF OnErrorLeaves[] = {
|
|
|
|
{ OnErrorRequest, OnErrorGroup, FlowClass, Zero, NULL } };
|
|
|
|
LEAF OnTimeoutLeaves[] = {
|
|
|
|
{ OnTimeoutRequest, OnTimeoutGroup, FlowClass, Zero, NULL } };
|
|
|
|
TREE OnOptionTrees[] = {
|
|
|
|
{ Leaf | List, 1, T OnOptionExitLeaves, "exit" },
|
|
{ Leaf | List, 3, T OnOptionPauseLeaves, "pause" },
|
|
{ Leaf | List, 1, T OnOptionRepeatLeaves, "repeat" } };
|
|
|
|
TREE OnErrorTrees[] = {
|
|
|
|
{ Leaf | List, 1, T OnErrorLeaves, NULL },
|
|
{ Tree | List, 3, OnOptionTrees, NULL } };
|
|
|
|
TREE OnTimeoutTrees[] = {
|
|
|
|
{ Leaf | List, 1, T OnTimeoutLeaves, NULL },
|
|
{ Tree | List, 3, OnOptionTrees, NULL } };
|
|
|
|
TREE OnTrees[] = {
|
|
|
|
{ Tree | Join, 2, OnErrorTrees, "error" },
|
|
{ Tree | Join, 2, OnTimeoutTrees, "timeout" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Open Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF OpenFileLeaves[] = {
|
|
|
|
{ OpenFileRequest, OpenFileGroup, FileClass, Zero, NULL } };
|
|
|
|
LEAF OpenFilesLeaves[] = {
|
|
|
|
{ OpenFilesRequest, GenericFilesGroup, FileClass, Zero, NULL } };
|
|
|
|
TREE OpenFileTrees[] = {
|
|
|
|
{ Tree | Text, 1, FileCommonTrees, NULL },
|
|
{ Leaf | List, 1, T OpenFileLeaves, NULL } };
|
|
|
|
TREE OpenFilesTrees[] = {
|
|
|
|
{ Leaf | List, 1, T OpenFilesLeaves, NULL },
|
|
{ Tree | List, 2, InProcessTrees, NULL } };
|
|
|
|
TREE OpenTrees[] = {
|
|
|
|
{ Tree | Join, 2, OpenFileTrees, NULL },
|
|
{ Tree | Join, 2, OpenFilesTrees, "files" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Query Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF QueryFileLeaves[] = {
|
|
|
|
{ QueryFileRequest, GenericFileGroup, FileClass, Zero, "info" } };
|
|
|
|
LEAF QueryFilesLeaves[] = {
|
|
|
|
{ QueryFilesRequest, GenericFilesGroup, FileClass, Zero, "info" } };
|
|
|
|
TREE QueryOneFileTrees[] = {
|
|
|
|
{ Leaf | List, 1, T QueryFileLeaves, NULL },
|
|
{ Tree | List, 2, InProcessTrees, NULL } };
|
|
|
|
|
|
TREE QueryFileTrees[] = {
|
|
|
|
{ Tree | Join, 2, QueryOneFileTrees, NULL } };
|
|
|
|
TREE QueryFilesTrees[] = {
|
|
|
|
{ Leaf | List, 1, T QueryFilesLeaves, NULL },
|
|
{ Tree | List, 2, InProcessTrees, NULL } };
|
|
|
|
TREE QueryTrees[] = {
|
|
|
|
{ Tree | Text, 1, QueryFileTrees, "file" },
|
|
{ Tree | Join, 2, QueryFilesTrees, "files" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Read Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF ReadFileLeaves[] = {
|
|
|
|
{ ReadFileRequest, ReadFileGroup, FileClass, Zero, NULL } };
|
|
|
|
LEAF ReadTimerLeaves[] = {
|
|
|
|
{ ReadTimerRequest, TimerGroup, TimerClass, Zero, NULL } };
|
|
|
|
TREE ReadFileTrees[] = {
|
|
|
|
{ Leaf | List, 1, T ReadFileLeaves, NULL },
|
|
{ Tree | List, 2, InProcessTrees, NULL },
|
|
{ Leaf | List, 2, T CompletionLeaves, NULL },
|
|
{ Tree | List, 3, UsingTrees, NULL } };
|
|
|
|
TREE ReadTimerTrees[] = {
|
|
|
|
{ Leaf | List, 1, T ReadTimerLeaves, NULL },
|
|
{ Tree | List, 2, InProcessTrees, NULL } };
|
|
|
|
TREE ReadTrees[] = {
|
|
|
|
{ Tree | Join, 4, ReadFileTrees, "file" },
|
|
{ Tree | Join, 2, ReadTimerTrees, "timer" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Repeat Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF RepeatTimesLeaves[] = {
|
|
|
|
{ RepeatRequest, RepeatGroup, FlowClass, RepeatOnCount, "times" } };
|
|
|
|
LEAF RepeatForLeaves[] = {
|
|
|
|
{ RepeatRequest, RepeatGroup, FlowClass, RepeatOnTimer, NULL } };
|
|
|
|
LEAF RepeatIndefinitelyLeaves[] = {
|
|
|
|
{ RepeatRequest, RepeatGroup, FlowClass, RepeatIndefinitely, NULL } };
|
|
|
|
TREE RepeatForTrees[] = {
|
|
|
|
{ Leaf | Text, 1, T RepeatForLeaves, NULL },
|
|
{ Leaf | List, 5, T TimeUnitLeaves, NULL } };
|
|
|
|
TREE RepeatTimesTrees[] = {
|
|
|
|
{ Leaf | List, 1, T RepeatTimesLeaves, NULL } };
|
|
|
|
TREE RepeatTrees[] = {
|
|
|
|
{ Tree | Text, 1, RepeatTimesTrees, NULL },
|
|
{ Tree | Join, 2, RepeatForTrees, "for" },
|
|
{ Leaf | List, 1, T RepeatIndefinitelyLeaves, "indefinitely" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Request Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF RequestLeaves[] = {
|
|
|
|
{ RequestSemaphoreRequest, WaitGroup, SemaphoreClass, Zero, "semaphore" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Set Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF SetCreateFlagLeaves[] = {
|
|
|
|
{ SetCreateFlagRequest, CreateGroup, AuxiliaryClass, Zero, "flag" } };
|
|
|
|
LEAF SetSemaphoreLeaves[] = {
|
|
|
|
{ SetSemaphoreRequest, BaseGroup, SemaphoreClass, Zero, NULL } };
|
|
|
|
LEAF SetSemaphoreWaitLeaves[] = {
|
|
|
|
{ SetSemaphoreRequest, WaitGroup, SemaphoreClass, Zero, "wait" } };
|
|
|
|
TREE SetSemaphoreTrees[] = {
|
|
|
|
{ Leaf | List, 1, T SetSemaphoreLeaves, NULL },
|
|
{ Leaf | List, 1, T SetSemaphoreWaitLeaves, "and" } };
|
|
|
|
TREE SetTrees[] = {
|
|
|
|
{ Leaf | List, 1, T SetCreateFlagLeaves, "create" },
|
|
{ Tree | Text, 2, SetSemaphoreTrees, "semaphore" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Sleep Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF SleepLeaves[] = {
|
|
|
|
{ SleepRequest, SleepGroup, TimerClass, Zero, NULL } };
|
|
|
|
TREE SleepTrees[] = {
|
|
|
|
{ Leaf | Text, 1, T SleepLeaves, NULL },
|
|
{ Leaf | List, 5, T TimeUnitLeaves, NULL } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Start & Lock Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF StartTimerLeaves[] = {
|
|
|
|
{ StartTimerRequest, TimerGroup, TimerClass, Zero, NULL } };
|
|
|
|
LEAF StartTimersLeaves[] = {
|
|
|
|
{ StartTimersRequest, TimersGroup, TimerClass, Zero, NULL } };
|
|
|
|
|
|
TREE StartTrees[] = {
|
|
|
|
{ Leaf | Text, 1, T StartTimerLeaves, "timer" },
|
|
{ Leaf | List, 1, T StartTimersLeaves, "timers" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Truncate Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF TruncateFileLeaves[] = {
|
|
|
|
{ TruncateFileRequest, OpenFileGroup, FileClass, Zero, NULL } };
|
|
|
|
TREE TruncateTrees[] = {
|
|
|
|
{ Leaf | List, 1, T TruncateFileLeaves, NULL },
|
|
{ Tree | Text, 1, FileCommonTrees, NULL } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Type Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF TypeLeaves[] = {
|
|
|
|
{ TypeCommentRequest, TypeGroup, AuxiliaryClass, Zero, "comment" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Wait Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF WaitForSemaphoreLeaves[] = {
|
|
|
|
{ WaitForSemaphoreRequest, WaitGroup, SemaphoreClass, Zero, NULL } };
|
|
|
|
TREE WaitForSemaphoreTrees[] = {
|
|
|
|
{ Tree | List, 2, InProcessTrees, NULL },
|
|
{ Tree | List, 3, UsingTrees, NULL },
|
|
{ Leaf | List, 1, T WaitForSemaphoreLeaves, NULL } };
|
|
|
|
TREE WaitForTrees[] = {
|
|
|
|
{ Tree | Join, 3, WaitForSemaphoreTrees, "semaphore" } };
|
|
|
|
TREE WaitTrees[] = {
|
|
|
|
{ Tree | Text, 1, WaitForTrees, "for" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Write Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF WriteFileLeaves[] = {
|
|
|
|
{ WriteFileRequest, WriteFileGroup, FileClass, Zero, NULL } };
|
|
|
|
LEAF WriteThroughLeaves[] = {
|
|
|
|
{ WriteThroughFlag, OtherModeGroup, ParameterClass, Zero, NULL } };
|
|
|
|
TREE WriteFileTrees[] = {
|
|
|
|
{ Tree | Text, 1, FileCommonTrees, NULL },
|
|
{ Leaf | List, 1, T WriteFileLeaves, NULL } };
|
|
|
|
TREE WriteThroughTrees[] = {
|
|
|
|
{ Leaf | List, 1, T WriteThroughLeaves, NULL },
|
|
{ Leaf | List, 2, T YesNoLeaves, "=" } };
|
|
|
|
TREE WriteSmallTrees[] = {
|
|
|
|
{ Tree | Join, 2, WriteThroughTrees, "through" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Left Bracket Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF ExecutionLeaves[] = {
|
|
|
|
{ ExecutionSectionRequest, ScanGroup, ScanClass, Zero, "section" } };
|
|
|
|
LEAF DefineFileLeaves[] = {
|
|
|
|
{ DefineFileRequest, DefineGroup, DefineClass, Zero, "as" } };
|
|
|
|
LEAF DefineOpenParametersLeaves[] = {
|
|
|
|
{ DefinePrototypeRequest, DefineGroup, DefineClass, Zero, "prototype" } };
|
|
|
|
LEAF DefineProcessLeaves[] = {
|
|
|
|
{ DefineProcessRequest, DefineGroup, DefineClass, Zero, NULL } };
|
|
|
|
LEAF PrototypeLeaves[] = {
|
|
|
|
{ PrototypeSectionRequest, ScanGroup, ScanClass, Zero, "section" } };
|
|
|
|
LEAF RightBracketedLeaves[] = {
|
|
|
|
{ Zero, Zero, Zero, Zero, "]" } };
|
|
|
|
LEAF DefineSemaphoreLeaves[] = {
|
|
|
|
{ DefineSemaphoreRequest, DefineGroup, DefineClass, Zero, NULL } };
|
|
|
|
LEAF DefineTimerLeaves[] = {
|
|
|
|
{ DefineTimerRequest, DefineGroup, DefineClass, Zero, NULL } };
|
|
|
|
TREE DefineFileTrees[] = {
|
|
|
|
{ Leaf | Text, 1, T DefineFileLeaves, NULL } };
|
|
|
|
TREE DefineOpenTrees[] = {
|
|
|
|
{ Leaf | Text, 1, T DefineOpenParametersLeaves, "parameters" } };
|
|
|
|
TREE DefineTrees[] = {
|
|
|
|
{ Tree | Text, 1, DefineFileTrees, "file" },
|
|
{ Tree | List, 1, DefineOpenTrees, "open" },
|
|
{ Leaf | Text, 1, T DefineProcessLeaves, "process" },
|
|
{ Leaf | Text, 1, T DefineSemaphoreLeaves, "semaphore" },
|
|
{ Leaf | Text, 1, T DefineTimerLeaves, "timer" } };
|
|
|
|
TREE LeftBracketedTrees[] = {
|
|
|
|
{ Tree | List, 5, DefineTrees, "Define" },
|
|
{ Leaf | List, 1, T ExecutionLeaves, "Execution" },
|
|
{ Leaf | List, 1, T PrototypeLeaves, "Prototype" } };
|
|
|
|
TREE LeftBracketTrees[] = {
|
|
|
|
{ Tree | List, 3, LeftBracketedTrees, NULL },
|
|
{ Leaf | List, 1, T RightBracketedLeaves, NULL } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Left && Right Brace Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF LeftBraceLeaves[] = {
|
|
|
|
{ LeftBraceRequest, BraceGroup, FlowClass, Zero, NULL } };
|
|
|
|
LEAF RightBraceLeaves[] = {
|
|
|
|
{ RightBraceRequest, BraceGroup, FlowClass, Zero, NULL } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* All Other Subtree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
LEAF BufferSpaceLeaves[] = {
|
|
|
|
{ BufferSpaceValue, QuadSizeGroup, ParameterClass, Zero, "=" } };
|
|
|
|
LEAF CountLeaves[] = {
|
|
|
|
{ CountChosen, QuadIndexGroup, ParameterClass, Zero, "=" } };
|
|
|
|
LEAF LockLeaves[] = {
|
|
|
|
{ LockSet, FileLocksGroup, ParameterClass, Zero, NULL } };
|
|
|
|
LEAF OffpointLeaves[] = {
|
|
|
|
{ OffPointIndex, TextTokenGroup, ParameterClass, OffPointBegin, "begin" },
|
|
{ OffPointIndex, TextTokenGroup, ParameterClass, OffPointCurrent, "current" },
|
|
{ OffPointIndex, TextTokenGroup, ParameterClass, OffPointEnd, "end" } };
|
|
|
|
LEAF OffsetLeaves[] = {
|
|
|
|
{ OffsetValue, SignedQuadGroup, ParameterClass, Zero, "=" } };
|
|
|
|
LEAF PatternLeaves[] = {
|
|
|
|
{ PatternChosen, ByteIndexGroup, ParameterClass, Zero, "=" } };
|
|
|
|
LEAF RecordSizeLeaves[] = {
|
|
|
|
{ RecordSizeValue, WordSizeGroup, ParameterClass, IncrementFlag, "+=" },
|
|
{ RecordSizeValue, WordSizeGroup, ParameterClass, DecrementFlag, "-=" },
|
|
{ RecordSizeValue, WordSizeGroup, ParameterClass, Zero, "=" } };
|
|
|
|
LEAF SchemeLeaves[] = {
|
|
|
|
{ SchemeChosen, ByteIndexGroup, ParameterClass, Zero, "=" } };
|
|
|
|
LEAF SemaphoreLeaves[] = {
|
|
|
|
{ SemaphoreChosen, ByteIndexGroup, ParameterClass, Zero, "=" } };
|
|
|
|
LEAF TimeoutLeaves[] = {
|
|
|
|
{ TimeoutValue, TimeGroup, ParameterClass, Zero, "=" } };
|
|
|
|
LEAF UnlockLeaves[] = {
|
|
|
|
{ UnlockSet, FileLocksGroup, ParameterClass, Zero, NULL } };
|
|
|
|
TREE BufferTrees[] = {
|
|
|
|
{ Leaf | Text, 1, T BufferSpaceLeaves, "space" } };
|
|
|
|
TREE OffpointTrees[] = {
|
|
|
|
{ Leaf | List, 3, T OffpointLeaves, "=" } };
|
|
|
|
TREE OffTrees[] = {
|
|
|
|
{ Tree | List, 1, OffpointTrees, "point" } };
|
|
|
|
TREE RecordTrees[] = {
|
|
|
|
{ Leaf | Text, 3, T RecordSizeLeaves, "size" } };
|
|
|
|
TREE TimeoutTrees[] = {
|
|
|
|
{ Leaf | Text, 1, T TimeoutLeaves, NULL },
|
|
{ Leaf | List, 5, T TimeUnitLeaves, NULL } };
|
|
|
|
TREE AllOtherTrees[] = {
|
|
|
|
{ Tree | List, 7, AllOtherModeTrees, NULL },
|
|
{ Tree | List, 1, BufferTrees, "buffer" },
|
|
{ Leaf | Text, 1, T CountLeaves, "count" },
|
|
{ Tree | List, 11, FileTrees, "file" },
|
|
{ Leaf | Text, 1, T LockLengthLeaves, "length" },
|
|
{ Leaf | List, 1, T LockLeaves, "lock:" },
|
|
{ Tree | List, 1, OffTrees, "off" },
|
|
{ Leaf | Text, 1, T OffsetLeaves, "offset" },
|
|
{ Leaf | Text, 1, T PatternLeaves, "pattern" },
|
|
{ Tree | List, 1, RecordTrees, "record" },
|
|
{ Leaf | Text, 1, T SchemeLeaves, "scheme" },
|
|
{ Leaf | Text, 1, T SemaphoreLeaves, "semaphore" },
|
|
{ Tree | List, 1, LockShareTrees, "share" },
|
|
{ Leaf | Text, 1, T LockStartLeaves, "start" },
|
|
{ Tree | Join, 2, TimeoutTrees, "timeout" },
|
|
{ Leaf | List, 1, T UnlockLeaves, "unlock:" },
|
|
{ Tree | List, 1, WriteSmallTrees, "write" } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* Main Control Tree Definitions */
|
|
/*---------------------------------------------------------------------------------*/
|
|
|
|
TREE AvailableSubtrees[] = {
|
|
|
|
{ Tree | List, 17, AllOtherTrees, NULL },
|
|
{ Tree | List, 2, AppendTrees, "Append" },
|
|
{ Tree | List, 2, BeginTrees, "Begin" },
|
|
{ Tree | List, 1, ChangeTrees, "Change" },
|
|
{ Tree | List, 2, ClearTrees, "Clear" },
|
|
{ Tree | List, 2, CloseTrees, "Close" },
|
|
{ Tree | List, 2, CollateTrees, "Collate" },
|
|
{ Tree | List, 2, ContinueTrees, "Continue" },
|
|
{ Tree | List, 2, CopyTrees, "Copy" },
|
|
{ Tree | List, 3, CreateTrees, "Create" },
|
|
{ Tree | List, 2, DeleteTrees, "Delete" },
|
|
{ Tree | List, 2, EndTrees, "End" },
|
|
{ Tree | List, 2, OnTrees, "On" },
|
|
{ Tree | List, 2, OpenTrees, "Open" },
|
|
{ Tree | List, 2, QueryTrees, "Query" },
|
|
{ Tree | Text, 2, ReadTrees, "Read" },
|
|
{ Tree | List, 3, RepeatTrees, "Repeat" },
|
|
{ Leaf | Text, 1, T RequestLeaves, "Request" },
|
|
{ Tree | List, 2, SetTrees, "Set" },
|
|
{ Tree | Join, 2, SleepTrees, "Sleep" },
|
|
{ Tree | List, 2, StartTrees, "Start" },
|
|
{ Tree | Join, 2, TruncateTrees, "Truncate" },
|
|
{ Leaf | List, 1, T TypeLeaves, "Type" },
|
|
{ Tree | List, 1, WaitTrees, "Wait" },
|
|
{ Tree | Join, 2, WriteFileTrees, "Write" },
|
|
{ Tree | Join, 2, LeftBracketTrees, "[" },
|
|
{ Leaf | List, 1, T LeftBraceLeaves, "{" },
|
|
{ Leaf | List, 1, T RightBraceLeaves, "}" } };
|
|
|
|
#define NumberOfSubtrees sizeof ( AvailableSubtrees ) / sizeof ( TREE )
|
|
|
|
TREE ControlTrees[] = {
|
|
|
|
{ Tree | List, NumberOfSubtrees, AvailableSubtrees, NULL } };
|
|
|
|
/*---------------------------------------------------------------------------------*/
|
|
/* The End */
|
|
/*---------------------------------------------------------------------------------*/
|