{
   Copyright (c) International Business Machines  Corp., 2000
   Copyright (c) 2003 Yuri Prokushev

   This module defines the interface to LVM.DLL, which is the
   engine that performs all of the disk partitioning/volume
   creation work.

   This program is free software;  you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY;  without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
   the GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program;  if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

}
Unit LVM;

{$PACKRECORDS C}

Interface

{$ifdef os2}
  {$define lvm1}
{$endif}

{$ifdef linux}
  {$define lvm2}
{$endif}

// The number of bytes in a sector on the disk.
const
  BYTES_PER_SECTOR=512;

//The maximum number of cylinders, heads, and sectors that a partition table entry can accomodate.
//Cylinders are numbered 0 - 1023, for a maximum of 1024 cylinders.
//eads are numbered 0 - 255, for a maximum of 256 heads.
//Sectors are numbered 1 - 63, for a maximum of 63 sectors per track.
const
  MAX_CYLINDERS= 1024;
  MAX_HEADS    = 256;
  MAX_SECTORS  = 63;

// The following define the values used to indicate that a partition table entry is for an EBR, not a partition.
const
  EBR_BOOT_INDICATOR = 0;
  EBR_FORMAT_INDICATOR = 5;

// The following define is used as the default Format_Indicator for new non-primary partitions.
const
  NEW_LOGICAL_DRIVE_FORMAT_INDICATOR = $6;

// The following define is used as the default Format_Indicator for a new non-active primary partitions.
const
  NEW_PRIMARY_PARTITION_FORMAT_INDICATOR = $16;

// The following define is used as the default Format_Indicator for a new active primary partition.
const
  NEW_ACTIVE_PRIMARY_PARTITION_FORMAT_INDICATOR = $06;

// The following define is used to hold the value of the Boot_Indicator for active partitions.
const
  ACTIVE_PARTITION = $80;

// Define the size of a Partition Name.  Partition Names are user defined names given to a partition.
const
  PARTITION_NAME_SIZE = 20;

// Define the size of a volume name.  Volume Names are user defined names given to a volume.
const
  VOLUME_NAME_SIZE = 20;

// Define the size of a disk name.  Disk Names are user defined names given to physical disk drives in the system.
const
  DISK_NAME_SIZE = 20;

// The name of the filesystem in use on a partition.  This name may be up to 12 ( + NULL terminator) characters long.
const
  FILESYSTEM_NAME_SIZE = 20;

// The comment field is reserved but is not currently used.  This is for future expansion and use.
const
  COMMENT_SIZE = 81;

// Define the minimum number of sectors to reserve on the disk for Boot Manager.
const
  BOOT_MANAGER_SIZE = 2048;

// An INTEGER number is a whole number, either + or -.
//The number appended to the INTEGER key word indicates the number of bits
//used to represent an INTEGER of that type.
type
  INTEGER16=SmallInt;
  INTEGER32=LongInt;
  INTEGER=LongInt;

// A CARDINAL number is a positive integer >= 0.
//The number appended to the CARDINAL key word indicates the number of bits
//used to represent a CARDINAL of that type.
type
  CARDINAL16=Word;
  CARDINAL32 = Cardinal;

(*
/* A REAL number is a floating point number. */
typedef float   REAL32;
typedef double  REAL64;
*)
  REAL32 = double;
  REAL64 = double;


// An ADDRESS variable is one which holds an address.  The address can contain
//anything, or even be invalid.  It is just an address which is presumed to
//hold some kind of data.
Type
  ADDRESS=Pointer;

Type
  pSTRING=PChar;

// 4 bytes
Type
  DoubleWord=Cardinal;

//* The following types are used in the declaration of disk structures.  Disk structures
//have a defined size and internal structure which must be matched exactly.              */

//* 8 bytes. */
type
  QuadWord=QWord;

// The following types are used internally by LVM.  */

// Define a Partition Sector Number.  A Partition Sector Number is relative to the start of a partition.
//The first sector in a partition is PSN 0.
type
  PSN=Cardinal;

// Define a Logical Sector Number.  A Logical Sector Number is relative to the start of a volume.
//The first sector in a volume is LSN 0.
type
  LSN=Cardinal;

// Define a Logical Block Address.  A Logical Block Address is relative to the start of a
//physical device - a disk drive.  The first sector on a disk drive is LBA 0.
type
  LBA=Cardinal;

// The following define sets the maximum number of LVM classes for which structures and storage will be reserved.
const
  MAXIMUM_LVM_CLASSES = 3;

// The following enum defines the various LVM classes to which a "feature" may belong.
// An LVM Plugin is used to implement a "feature", so "plugin" and "feature" are really synonyms.

type
  _LVM_Classes = (
    Partition_Class, // For "features" which must operate on a partition level - i.e. Bad Block Relocation.
    Aggregate_Class, // For "features" which combine partitions into a single logical entity - i.e. Drive Linking.
    Volume_Class     // For "features" which operate best on a volume level - i.e. encryption, mirroring etc.
       );
  LVM_Classes = _LVM_Classes;


// An LVM plugin may belong to one or more classes.  For each class to which it belongs, certain attributes must be defined.
//This structure tracks those attributes for a class.
type
  _LVM_Class_Attributes=record
    ClassMember: BOOLEAN;      // TRUE if a member of this class, FALSE otherwise.
    GlobalExclusive: BOOLEAN;  // TRUE if this plugin can not work with any other plugin - i.e. it
//must be the only "feature" on the volume, besides the built in feature of BBR.
    TopExclusive: BOOLEAN;     // TRUE if this plugin must be the topmost plugin in this class.
    BottomExclusive: BOOLEAN;  // TRUE if this plugin must be the bottommost plugin in this class.
    ClassExclusive: BOOLEAN;   // TRUE if this plugin will not work with any other plugin in this class.
    Weight_Factor: CARDINAL32;    // A value between 1 and 100 which is used to guide the LVM interfaces when attempting to
//establish a default ordering for plugins within this class.  A value of 1
//indicates that this plugin wants to be as close to the bottom of the plugins
//in this class as possible.  A value of 100 means that this plugin wants to
//be as close to being the topmost plugin in this class as possible.  This value
//is only used if none of the "exclusive" flags are set.
  end;
  LVM_Class_Attributes=_LVM_Class_Attributes;

// The following enum specifies the interface types that LVM supports, and hence any plugin must support.
  _LVM_Interface_Types= (
    PM_Interface,
    VIO_Interface,           // LVM.EXE is a VIO app. since it is used during install, and during recovery scenarios where PM/Java may not be available.
    Java_Interface          // The LVM GUI is written in Java.
  );
  LVM_Interface_Types=_LVM_Interface_Types;

const
  MAXIMUM_LVM_INTERFACE_TYPES = 3;


//* The following structures define what functions must be supported for each interface type.
type
  PADDRESS=^ADDRESS;
  PCARDINAL32=^CARDINAL32;

  _LVM_OS2_Native_Support=record
//void (* _System Create_and_Configure) ( CARDINAL32 ID, ADDRESS InputBuffer, CARDINAL32 InputBufferSize, ADDRESS * OutputBuffer, CARDINAL32 * OutputBufferSize, CARDINAL32 * Error_Code);
    Create_and_Configure: procedure(ID: CARDINAL32; InputBuffer: ADDRESS; InputBufferSize: CARDINAL32; OutputBuffer: PADDRESS; OutputBufferSize: PCARDINAL32; Error_Code: PCARDINAL32);
//void (* _System Display_Status) ( ADDRESS Volume_Handle, CARDINAL32 * Error_Code );
    Display_Status: procedure(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32 );
//void (* _System Control_Panel) (ADDRESS Volume_Handle, CARDINAL32 * Error_Code );
    Control_Panel: procedure(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32 );
//void (* _System Help_Panel) (CARDINAL32 Help_Index, CARDINAL32 * Error_Code);
    Help_Panel: procedure(Help_Index: CARDINAL32; Error_Code: PCARDINAL32);
  end;
  LVM_OS2_Native_Support=_LVM_OS2_Native_Support;


type
  _LVM_Interface_Support=record
    Interface_Supported: BOOLEAN;
  case longint of
      0 : ( Java_Interface_Class : ^char );
      1 : ( VIO_PM_Calls : LVM_OS2_Native_Support );
  end;
  LVM_Interface_Support=_LVM_Interface_Support;

//* The following define the default help indicies which must be supported by the Help_Panel function.  NOTE:  Index
//values from 0 to 100 are reserved by LVM.  The Plugin may, for its own use, use any values above 100.
const
  HELP_PLUGIN_DESCRIPTION   = 0;

// The following define the maximum length of the names which can be used to represent a feature in LVM.  The
//maximum name length for a feature is 30 characters plus the trailing NULL character.  For command line parsing,
//though, a shorter name is preferable!  Thus, the "short" name for a feature will be limited to 10 characters
//plus the trailing NULL character.  The "short" name will be used for command line purposes, while the regular
//name will be used by all other interfaces.
const
  MAX_FEATURE_NAME_LENGTH       = 31;
  MAX_FEATURE_SHORT_NAME_LENGTH = 11;
  MAX_OEM_INFO_LENGTH           =255;

// The following definitions are used to control and access the various "features" available through the LVM Engine, such as Drive Linking and BBR.
type
  _Feature_ID_Data=record
    Name: Array[0..MAX_FEATURE_NAME_LENGTH-1] of char;             // Feature Name, for use in menus and command line parsing.
    Short_Name: Array[0..MAX_FEATURE_SHORT_NAME_LENGTH-1] of char; // The name/code used to represent this feature during command line parsing.
    OEM_Info: Array[0..MAX_OEM_INFO_LENGTH-1] of char;             // Name and copyright info. of the manufacturer, i.e. IBM, Vinca, etc.
    ID: CARDINAL32;                                        // Numeric Feature ID.
    Major_Version_Number: CARDINAL32;                      // The version number of this feature.
    Minor_Version_Number: CARDINAL32;                      // The version number of this feature.
    LVM_Major_Version_Number: CARDINAL32;                  // The version of LVM that this feature was designed to work with.
    LVM_Minor_Version_Number: CARDINAL32;                  // The version of LVM that this feature was designed to work with.
    Preferred_Class: LVM_Classes;                           // The class from which this "feature" prefers to be chosen.  Encryption can be performed
//at the partition level or the volume level, and may therefore belong to both the
//Partition_Class and the Volume_Class.  However, it is preferrable for it to be used
//on the volume level instead of at the partition level.  Thus, its perferred class would
//be the Volume_Class, but it would still be a member of both the Volume_Class and the
//Partition_Class.
    ClassData: Array[0..MAXIMUM_LVM_CLASSES-1] of LVM_Class_Attributes;  // The attributes for each of the LVM classes that this "feature" is in.
    Interface_Support: Array[0..MAXIMUM_LVM_INTERFACE_TYPES-1] of LVM_Interface_Support;  // The functions and classes for each of the video modes that LVM can run it.
  end;
  Feature_ID_Data=_Feature_ID_Data;

// The following defines the TAG value used to identify an item of type Feature_ID_Data in a DLIST.
const
  FEATURE_ID_DATA_TAG = 354385972;

// The following are invariant for a disk drive.
Type
  Drive_Control_Record = record
    Drive_Number: CARDINAL32;                   // OS/2 Drive Number for this drive.
    Drive_Size: CARDINAL32;                     // The total number of sectors on the drive.
    Drive_Serial_Number: DoubleWord;            // The serial number assigned to this drive.  For info. purposes only.
    Drive_Handle: ADDRESS;                      // Handle used for operations on the disk that this record corresponds to.
    Cylinder_Count: CARDINAL32;                 // The number of cylinders on the drive.
    Heads_Per_Cylinder: CARDINAL32;             // The number of heads per cylinder for this drive.
    Sectors_Per_Track: CARDINAL32;              // The number of sectors per track for this drive.
    Drive_Is_PRM: BOOLEAN;                      // Set to TRUE if this drive is a PRM.
    Reserved: Array[0..3-1] of BYTE;              // Alignment.
  end;

// The following structure is returned by the Get_Drive_Control_Data function.
  Drive_Control_Array=record
    Drive_Control_Data: ^Drive_Control_Record;       // An array of drive control records.
    Count: CARDINAL32;                               // The number of entries in the array of drive control records.
  end;

// The following structure defines the information that can be changed for a specific disk drive.
  Drive_Information_Record=record
    Total_Available_Sectors: CARDINAL32;        // The number of sectors on the disk which are not currently assigned to a partition.
    Largest_Free_Block_Of_Sectors: CARDINAL32;  // The number of sectors in the largest contiguous block of available sectors.
    Corrupt_Partition_Table: BOOLEAN;           // If TRUE, then the partitioning information found on the drive is incorrect!
    Unusable: BOOLEAN;                          // If TRUE, the drive's MBR is not accessible and the drive can not be partitioned.
    IO_Error: BOOLEAN;                          // If TRUE, then the last I/O operation on this drive failed!
    Is_Big_Floppy: BOOLEAN;                     // If TRUE, then the drive is a PRM formatted as a big floppy (i.e. the old style removable media support).
    Drive_Name: Array[0..DISK_NAME_SIZE-1] of Char; // User assigned name for this disk drive.
  end;

  Partition_Information_Record=record
    Partition_Handle: ADDRESS;                      // The handle used to perform operations on this partition.
    Volume_Handle: ADDRESS;                         // If this partition is part of a volume, this will be the handle of
                                                    //the volume.  If this partition is NOT part of a volume, then this
                                                    //handle will be 0.
    Drive_Handle: ADDRESS;                          // The handle for the drive this partition resides on.
    Partition_Serial_Number: DoubleWord;            // The serial number assigned to this partition.
    Partition_Start: CARDINAL32;                    // The LBA of the first sector of the partition.
    True_Partition_Size: CARDINAL32;                // The total number of sectors comprising the partition.
    Usable_Partition_Size: CARDINAL32;              // The size of the partition as reported to the IFSM.  This is the
                                                    //size of the partition less any LVM overhead.
    Boot_Limit: CARDINAL32;                         // The maximum number of sectors from this block of free space that can be used to
                                                    //create a bootable partition if you allocate from the beginning of the block of
                                                    //free space.
    Spanned_Volume: BOOLEAN;                        // TRUE if this partition is part of a multi-partition volume.
    Primary_Partition: BOOLEAN;                     // True or False.  Any non-zero value here indicates that
                                                    //this partition is a primary partition.  Zero here indicates
                                                    //that this partition is a "logical drive" - i.e. it resides
                                                    //inside of an extended partition.
    Active_Flag: BYTE;                              // 80 = Partition is marked as being active.
                                                    // 0 = Partition is not active.
    OS_Flag: BYTE;                                  // This field is from the partition table.  It is known as the
                                                    //OS flag, the Partition Type Field, Filesystem Type, and
                                                    //various other names.

                                                    //Values of interest

                                                    //If this field is: (values are in hex)

                                                    //07 = The partition is a compatibility partition formatted for use
                                                    //with an installable filesystem, such as HPFS or JFS.
                                                    //00 = Unformatted partition
                                                    //01 = FAT12 filesystem is in use on this partition.
                                                    //04 = FAT16 filesystem is in use on this partition.
                                                    //0A = OS/2 Boot Manager Partition
                                                    //35 = LVM partition
                                                    //84 = OS/2 FAT16 partition which has been relabeled by Boot Manager to "Hide" it.
    Partition_Type: BYTE;                           // 0 = Free Space
                                                    //1 = LVM Partition (Part of an LVM Volume.)
                                                    //2 = Compatibility Partition
                                                    //All other values are reserved for future use.
    Partition_Status: BYTE;                         // 0 = Free Space
                                                    //1 = In Use - i.e. already assigned to a volume.
                                                    //2 = Available - i.e. not currently assigned to a volume.
    On_Boot_Manager_Menu: BOOLEAN;                  // Set to TRUE if this partition is not part of a Volume yet is on the Boot Manager Menu.
    Reserved: BYTE;                                 // Alignment.
    Volume_Drive_Letter: char;                      // The drive letter assigned to the volume that this partition is a part of.
    Drive_Name: Array[0..DISK_NAME_SIZE-1] of char;   // User assigned name for this disk drive.
    File_System_Name: Array[0..FILESYSTEM_NAME_SIZE-1] of char;// The name of the filesystem in use on this partition, if it is known.
    Partition_Name: Array[0..PARTITION_NAME_SIZE-1] of char;   // The user assigned name for this partition.
    Volume_Name: Array[0..VOLUME_NAME_SIZE-1] of char;         // If this partition is part of a volume, then this will be the
                                                             //name of the volume that this partition is a part of.  If this
                                                             //record represents free space, then the Volume_Name will be
                                                             //"FREE SPACE xx", where xx is a unique numeric ID generated by
                                                             //LVM.DLL.  Otherwise it will be an empty string.
  end;

// The following defines are for use with the Partition_Type field in the Partition_Information_Record.
const
  pt_FREE_SPACE_PARTITION = 0;
  pt_LVM_PARTITION        = 1;
  pt_COMPATIBILITY_PARTITION = 2;

// The following defines are for use with the Partition_Status field in the Partition_Information_Record.
const
  PARTITION_IS_IN_USE    = 1;
  PARTITION_IS_AVAILABLE = 2;
  PARTITION_IS_FREE_SPACE = 0;

// The following structure is returned by various functions in the LVM Engine.
type
  Partition_Information_Array=record
    Partition_Array: ^Partition_Information_Record; // An array of Partition_Information_Records.
    Count: CARDINAL32;           // The number of entries in the Partition_Array.
  end;

// The following items are invariant for a volume.
type
  Volume_Control_Record=record
    Volume_Serial_Number: DoubleWord;            // The serial number assigned to this volume.
    Volume_Handle: ADDRESS;                   // The handle used to perform operations on this volume.
    Compatibility_Volume: BOOLEAN;            // TRUE indicates that this volume is compatible with older versions of OS/2.
//FALSE indicates that this is an LVM specific volume and can not be used without OS2LVM.DMD.
    Device_Type: BYTE;                     // Indicates what type of device the Volume resides on:
//0 = Hard Drive under LVM Control
//1 = PRM under LVM Control
//2 = CD-ROM
//3 = Network drive
//4 = Unknown device NOT under LVM Control
    Reserved: Array[0..2-1] of BYTE;                     // Alignment.
  end;

// The following define the device types used in the Device_Type field of the Volume_Control_Record.
const
  LVM_HARD_DRIVE = 0;
  LVM_PRM        = 1;
  NON_LVM_CDROM  = 2;
  NETWORK_DRIVE  = 3;
  NON_LVM_DEVICE = 4;

// The following structure is returned by the Get_Volume_Control_Data function.
type
  Volume_Control_Array=record
    Volume_Control_Data: ^Volume_Control_Record;      // An array of volume control records.
    Count: CARDINAL32;                    // The number of entries in the array of volume control records.
  end;

// The following information about a volume can (and often does) vary.
type
  Volume_Information_Record=record
    Volume_Size: CARDINAL32;                           // The number of sectors comprising the volume.
    Partition_Count: CARDINAL32;                       // The number of partitions which comprise this volume.
    Drive_Letter_Conflict: CARDINAL32;                 // 0 indicates that the drive letter preference for this volume is unique.
//1 indicates that the drive letter preference for this volume
//is not unique, but this volume got its preferred drive letter anyway.
//2 indicates that the drive letter preference for this volume
//is not unique, and this volume did NOT get its preferred drive letter.
//4 indicates that this volume is currently "hidden" - i.e. it has
//no drive letter preference at the current time.
    Compatibility_Volume: BOOLEAN;                  // TRUE if this is for a compatibility volume, FALSE otherwise.
    Bootable: BOOLEAN;                              // Set to TRUE if this volume appears on the Boot Manager menu, or if it is
//a compatibility volume and its corresponding partition is the first active
//primary partition on the first drive.
    Drive_Letter_Preference: char;               // The drive letter that this volume desires to be.
    Current_Drive_Letter: char;                  // The drive letter currently used to access this volume.  May be different than
//Drive_Letter_Preference if there was a conflict ( i.e. Drive_Letter_Preference
//is already in use by another volume ).
    Initial_Drive_Letter: char;                  // The drive letter assigned to this volume by the operating system when LVM was started.
//This may be different from the Drive_Letter_Preference if there were conflicts, and
//may be different from the Current_Drive_Letter.  This will be 0x0 if the Volume did
//not exist when the LVM Engine was opened (i.e. it was created during this LVM session).
    New_Volume: BOOLEAN;                            // Set to FALSE if this volume existed before the LVM Engine was opened.  Set to
//TRUE if this volume was created after the LVM Engine was opened.
    Status: BYTE;                                // 0 = None.
//1 = Bootable
//2 = Startable
//3 = Installable.
    Reserved_1: BYTE;
    Volume_Name: Array[0..VOLUME_NAME_SIZE-1] of char;         // The user assigned name for this volume.
    File_System_Name: Array[0..FILESYSTEM_NAME_SIZE-1] of char;// The name of the filesystem in use on this partition, if it is known.
  end;

// The following structure is used to return the feature information for the installed features, or the features on a volume.
type
  Feature_Information_Array=record
    Count: CARDINAL32;
    Feature_Data: ^Feature_ID_Data;
  end;

// The following structure defines an item on the Boot Manager Menu.
type
  Boot_Manager_Menu_Item=record
    Handle: ADDRESS;            // A Volume or Partition handle.
    Volume: BOOLEAN;            // If TRUE, then Handle is the handle of a Volume.  Otherwise, Handle is the handle of a partition.
  end;

// The following structure is used to get a list of the items on the partition manager menu.
type
  Boot_Manager_Menu=record
    Menu_Items: ^Boot_Manager_Menu_Item;
    Count: CARDINAL32;
  end;

// The following structure is used to specify an LVM Feature when creating a volume.  Since LVM Features may be part of
//more than one LVM Class, the specific class to be used with the feature must also be specified.
type
  LVM_Feature_Specification_Record=record
    Feature_ID: CARDINAL32;      // The feature ID of the feature to use.
    Actual_Class: LVM_Classes;   // The LVM Class (supported by the specified feature) to use.
    Init_Data: ADDRESS;          // The address of a buffer containing initialization data for this feature.
                                 //NULL if there is no initialization data being provided for this feature.
  end;

// The following structure is used with the Get_Child_Handles function.
Type
  LVM_Handle_Array_Record=record
    Count: CARDINAL32;
    Handles: ^ADDRESS;
  end;

// The following preprocessor directives define the operations that can be performed on a partition, volume, or a block of free space.
// These definitions represent bits in a 32 bit value returned by the Get_Valid_Options function.
const
  CREATE_PRIMARY_PARTITION          = 1;
  CREATE_LOGICAL_DRIVE              = 2;
  DELETEPARTITION                   = 4;
  SET_ACTIVE_PRIMARY                = 8;
  SET_PARTITION_ACTIVE             = $10;
  SET_PARTITION_INACTIVE           = $20;
  SETSTARTABLE                    = $40;
  INSTALLBOOTMANAGER             = $80;
  REMOVEBOOTMANAGER              = $100;
  SET_BOOT_MANAGER_DEFAULTS        = $200;
  ADD_TO_BOOT_MANAGER_MENU         = $400;
  REMOVE_FROM_BOOT_MANAGER_MENU    = $800;
  DELETEVOLUME                    = $1000;
  HIDEVOLUME                      = $2000;
  EXPANDVOLUME                    = $4000;
  SET_VOLUME_INSTALLABLE           = $8000;
  ASSIGNDRIVELETTER              = $10000;
  CAN_BOOT_PRIMARY                 = $20000;      // If a primary is created from this block of free space, then it can be made bootable.
  CAN_BOOT_LOGICAL                 = $40000;      // If a logical drive is created from this block of free space, then OS/2 can boot from it by adding it to the boot manager menu.
  CAN_SET_NAME                     = $80000;
  SET_BOOT_MANAGER_STARTABLE       = $100000;

// The following enumeration defines the allocation strategies used by the Create_Partition function.
type
  _Allocation_Algorithm =(
Automatic,               // Let LVM decide which block of free space to use to create the partition.
Best_Fit,                // Use the block of free space which is closest in size to the partition being created.
First_Fit,               // Use the first block of free space on the disk which is large enough to hold a partition of the specified size.
Last_Fit,                // Use the last block of free space on the disk which is large enough to hold a partition of the specified size.
From_Largest,            // Find the largest block of free space and allocate the partition from that block of free space.
From_Smallest,           // Find the smallest block of free space that can accommodate a partition of the size specified.
All                      // Turn the specified drive or block of free space into a single partition.
);
  Allocation_Algorithm=_Allocation_Algorithm;

// Error codes returned by the LVM Engine.
const
  LVM_ENGINE_NO_ERROR                          =  0;
  LVM_ENGINE_OUT_OF_MEMORY                     =  1;
  LVM_ENGINE_IO_ERROR                          =  2;
  LVM_ENGINE_BAD_HANDLE                        =  3;
  LVM_ENGINE_INTERNAL_ERROR                    =  4;
  LVM_ENGINE_ALREADY_OPEN                      =  5;
  LVM_ENGINE_NOT_OPEN                          =  6;
  LVM_ENGINE_NAME_TOO_BIG                      =  7;
  LVM_ENGINE_OPERATION_NOT_ALLOWED             =  8;
  LVM_ENGINE_DRIVE_OPEN_FAILURE                =  9;
  LVM_ENGINE_BAD_PARTITION                     = 10;
  LVM_ENGINE_CAN_NOT_MAKE_PRIMARY_PARTITION    = 11;
  LVM_ENGINE_TOO_MANY_PRIMARY_PARTITIONS       = 12;
  LVM_ENGINE_CAN_NOT_MAKE_LOGICAL_DRIVE        = 13;
  LVM_ENGINE_REQUESTED_SIZE_TOO_BIG            = 14;
  LVM_ENGINE_1024_CYLINDER_LIMIT               = 15;
  LVM_ENGINE_PARTITION_ALIGNMENT_ERROR         = 16;
  LVM_ENGINE_REQUESTED_SIZE_TOO_SMALL          = 17;
  LVM_ENGINE_NOT_ENOUGH_FREE_SPACE             = 18;
  LVM_ENGINE_BAD_ALLOCATION_ALGORITHM          = 19;
  LVM_ENGINE_DUPLICATE_NAME                    = 20;
  LVM_ENGINE_BAD_NAME                          = 21;
  LVM_ENGINE_BAD_DRIVE_LETTER_PREFERENCE       = 22;
  LVM_ENGINE_NO_DRIVES_FOUND                   = 23;
  LVM_ENGINE_WRONG_VOLUME_TYPE                 = 24;
  LVM_ENGINE_VOLUME_TOO_SMALL                  = 25;
  LVM_ENGINE_BOOT_MANAGER_ALREADY_INSTALLED    = 26;
  LVM_ENGINE_BOOT_MANAGER_NOT_FOUND            = 27;
  LVM_ENGINE_INVALID_PARAMETER                 = 28;
  LVM_ENGINE_BAD_FEATURE_SET                   = 29;
  LVM_ENGINE_TOO_MANY_PARTITIONS_SPECIFIED     = 30;
  LVM_ENGINE_LVM_PARTITIONS_NOT_BOOTABLE       = 31;
  LVM_ENGINE_PARTITION_ALREADY_IN_USE          = 32;
  LVM_ENGINE_SELECTED_PARTITION_NOT_BOOTABLE   = 33;
  LVM_ENGINE_VOLUME_NOT_FOUND                  = 34;
  LVM_ENGINE_DRIVE_NOT_FOUND                   = 35;
  LVM_ENGINE_PARTITION_NOT_FOUND               = 36;
  LVM_ENGINE_TOO_MANY_FEATURES_ACTIVE          = 37;
  LVM_ENGINE_PARTITION_TOO_SMALL               = 38;
  LVM_ENGINE_MAX_PARTITIONS_ALREADY_IN_USE     = 39;
  LVM_ENGINE_IO_REQUEST_OUT_OF_RANGE           = 40;
  LVM_ENGINE_SPECIFIED_PARTITION_NOT_STARTABLE = 41;
  LVM_ENGINE_SELECTED_VOLUME_NOT_STARTABLE     = 42;
  LVM_ENGINE_EXTENDFS_FAILED                   = 43;
  LVM_ENGINE_REBOOT_REQUIRED                   = 44;
  LVM_ENGINE_CAN_NOT_OPEN_LOG_FILE             = 45;
  LVM_ENGINE_CAN_NOT_WRITE_TO_LOG_FILE         = 46;
  LVM_ENGINE_REDISCOVER_FAILED                 = 47;
  LVM_ENGINE_INTERNAL_VERSION_FAILURE          = 48;
  LVM_ENGINE_PLUGIN_OPERATION_INCOMPLETE       = 49;
  LVM_ENGINE_BAD_FEATURE_ID                    = 50;
  LVM_ENGINE_NO_INIT_DATA                      = 51;
  LVM_ENGINE_NO_CONTEXT_DATA                   = 52;
  LVM_ENGINE_WRONG_CLASS_FOR_FEATURE           = 53;
  LVM_ENGINE_INCOMPATIBLE_FEATURES_SELECTED    = 54;
  LVM_ENGINE_NO_CHILDREN                       = 55;
  LVM_ENGINE_FEATURE_NOT_SUPPORTED_BY_INTERFACE= 56;
  LVM_ENGINE_NO_PARENT                         = 57;
  LVM_ENGINE_VOLUME_HAS_NOT_BEEN_COMMITTED_YET = 58;
  LVM_ENGINE_UNABLE_TO_REFERENCE_VOLUME        = 59;
  LVM_ENGINE_PARSING_ERROR                     = 60;
  LVM_ENGINE_INTERNAL_FEATURE_ERROR            = 61;
  LVM_ENGINE_VOLUME_NOT_CONVERTED              = 62;


// The following definitions are used for command line processing.  As the command line is processed,
//the command line is first broken up into tokens.  Each token has a "characterization", which indicates
//what the token is thought to be.

type
  Token_Characterizations=(
LVM_AcceptableCharsStr,
LVM_All,
LVM_BestFit,
LVM_BootDOS,
LVM_BootOS2,
LVM_Bootable,
LVM_CR,
LVM_CRI,
LVM_Compatibility,
LVM_Drive,
LVM_Existing,
LVM_Expand,
LVM_FS,
LVM_FirstFit,
LVM_Freespace,
LVM_FromEnd,
LVM_FromLargest,
LVM_FromSmallest,
LVM_FromStart,
LVM_LVM,
LVM_LastFit,
LVM_Logical,
LVM_New,
LVM_NoBoot,
LVM_NonBootable,
LVM_NotBootable,
LVM_Partition,
LVM_Primary,
LVM_RB,
LVM_Size,
LVM_Unusable,
LVM_Unused,
LVM_Volume,
LVM_Volumes,
LVM_Comma,
LVM_Number,
LVM_Colon,
LVM_Space,
LVM_Tab,
LVM_MultiSpace,
LVM_MultiTab,
LVM_String,
LVM_FileNameStr,
LVM_SemiColon,
LVM_Eof,
LVM_Separator,
LVM_Open_Paren,                    //* ( */
LVM_Close_Paren,                   //* ) */
LVM_Open_Bracket,                  //* [ */
LVM_Close_Bracket,                 //* ] */
LVM_Open_Brace,                    //* { */
LVM_Close_Brace,                   //* } */
LVM_EQ_Sign,                       //* = */
LVM_Bootmgr,
LVM_Create,
LVM_Delete,
LVM_DriveLetter,
LVM_File,
LVM_Hide,
LVM_Install,
LVM_NewMBR,
LVM_Query,
LVM_RediscoverPRM,
LVM_SetName,
LVM_SetStartable,
LVM_SI,
LVM_SlashSize,
LVM_StartLog
);

type
  _LVM_Token=record
    TokenText: PChar;  // The actual text of the token.
    TokenType: Token_Characterizations;  // What the token is thought to be.
    Position: CARDINAL32;   // The position of the first character of the token on the command line.
  end;
  LVM_Token=_LVM_Token;

const
  LVM_TOKEN_TAG = 28387473;

// Function Prototypes

//***************************************************************************
//
// Functions relating to the LVM Engine itself
//
//***************************************************************************

//****************************************************************************************************/
//*                                                                                                  */
//*   Function Name: Open_LVM_Engine                                                                 */
//*                                                                                                  */
//*   Descriptive Name: Opens the LVM Engine and readies it for use.                                 */
//*                                                                                                  */
//*   Input: BOOLEAN Ignore_CHS : If TRUE, then the LVM engine will not check the CHS values in the  */
//*                               MBR/EBR partition tables for validity.  This is useful if there    */
//*                               are drive geometry problems, such as the drive was partitioned and */
//*                               formatted with one geometry and then moved to a different machine  */
//*                               which uses a different geometry for the drive.  This would cause   */
//*                               the starting and ending CHS values in the partition tables to      */
//*                               be inconsistent with the size and partition offset entries in the  */
//*                               partition tables.  Setting Ignore_CHS to TRUE will disable the     */
//*                               LVM Engine's CHS consistency checks, thereby allowing the drive    */
//*                               to be partitioned.                                                 */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in which to store an error code   */
//*                                    should an error occur.                                        */
//*                                                                                                  */
//*   Output:  *Error_Code will be 0 if this function completes successfully.  If an error occurs,   */
//*            *Error_Code will contain a non-zero error code.                                       */
//*                                                                                                  */
//*   Error Handling: If this function aborts with an error, all memory allocated during the course  */
//*                   of this function will be released.  Disk read errors will be reported to the   */
//*                   user via pop-up error messages.  Disk read errors will only cause this         */
//*                   function to abort if none of the disk drives in the system could be            */
//*                   successfully read.                                                             */
//*                                                                                                  */
//*   Side Effects:  The LVM Engine will be initialized.  The partition tables for all OS2DASD       */
//*                  controlled disk drives will be read into memory.  Memory will be allocated for  */
//*                  the data structures used by the LVM Engine.                                     */
//*                                                                                                  */
//*   Notes:  This is provided for programs that used LVM Version 1.  This function assumes an       */
//*           LVM_Interface_Type of VIO_Interface.                                                   */
//*                                                                                                  */
//****************************************************************************************************/
procedure Open_LVM_Engine(Ignore_CHS: BOOLEAN; Error_Code: PCARDINAL32); external 'lvm' name 'Open_LVM_Engine';

//****************************************************************************************************/
//*                                                                                                  */
//*   Function Name: Open_LVM_Engine2                                                                */
//*                                                                                                  */
//*   Descriptive Name: Opens the LVM Engine and readies it for use.                                 */
//*                                                                                                  */
//*   Input: BOOLEAN Ignore_CHS : If TRUE, then the LVM engine will not check the CHS values in the  */
//*                               MBR/EBR partition tables for validity.  This is useful if there    */
//*                               are drive geometry problems, such as the drive was partitioned and */
//*                               formatted with one geometry and then moved to a different machine  */
//*                               which uses a different geometry for the drive.  This would cause   */
//*                               the starting and ending CHS values in the partition tables to      */
//*                               be inconsistent with the size and partition offset entries in the  */
//*                               partition tables.  Setting Ignore_CHS to TRUE will disable the     */
//*                               LVM Engine's CHS consistency checks, thereby allowing the drive    */
//*                               to be partitioned.                                                 */
//*          LVM_Interface_Types Interface_Type - Indicate the type of user interface being used:    */
//*                               PM_Interface, VIO_Interface, or Java_Interface.  This lets the     */
//*                               LVM Engine know which interface support routines to call in any    */
//*                               plugin modules which may be loaded.                                */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in which to store an error code   */
//*                                    should an error occur.                                        */
//*                                                                                                  */
//*   Output:  *Error_Code will be 0 if this function completes successfully.  If an error occurs,   */
//*            *Error_Code will contain a non-zero error code.                                       */
//*                                                                                                  */
//*   Error Handling: If this function aborts with an error, all memory allocated during the course  */
//*                   of this function will be released.  Disk read errors will be reported to the   */
//*                   user via pop-up error messages.  Disk read errors will only cause this         */
//*                   function to abort if none of the disk drives in the system could be            */
//*                   successfully read.                                                             */
//*                                                                                                  */
//*   Side Effects:  The LVM Engine will be initialized.  The partition tables for all OS2DASD       */
//*                  controlled disk drives will be read into memory.  Memory will be allocated for  */
//*                  the data structures used by the LVM Engine.                                     */
//*                                                                                                  */
//*   Notes:  New in LVM Version 2                                                                   */
//*                                                                                                  */
//****************************************************************************************************/
{$ifdef lvm2}
procedure Open_LVM_Engine2(Ignore_CHS: BOOLEAN; Interface_Type: LVM_Interface_Types; Error_Code: PCARDINAL32); external 'lvm' name 'Open_LVM_Engine2';
{$endif}
//*********************************************************************/
//*                                                                   */
//*   Function Name: Commit_Changes                                   */
//*                                                                   */
//*   Descriptive Name: Saves any changes made to the partitioning    */
//*                     information of the OS2DASD controlled disk    */
//*                     drives in the system.                         */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output:  The function return value will be TRUE if all of the   */
//*            partitioning/volume changes made were successfully     */
//*            written to disk.  Also, *Error_Code will be 0 if no    */
//*            errors occur.                                          */
//*                                                                   */
//*            If an error occurs, then the furnction return value    */
//*            will be FALSE and *Error_Code will contain a non-zero  */
//*            error code.                                            */
//*                                                                   */
//*   Error Handling:  If an error occurs, the function return value  */
//*                    will be false and *Error_Code will be > 0.     */
//*                                                                   */
//*                    Disk read and write errors will be indicated by*/
//*                    setting the IO_Error field of the              */
//*                    Drive_Information_Record to TRUE.  Thus, if    */
//*                    the function return value is FALSE, and        */
//*                    *Error_Code indicates an I/O error, the caller */
//*                    of this function should call the               */
//*                    Get_Drive_Status function on each drive to     */
//*                    determine which drives had I/O errors.         */
//*                                                                   */
//*                    If a read or write error occurs, then the      */
//*                    engine may not have been able to create a      */
//*                    partition or volume.  Thus, the caller         */
//*                    may want to refresh all partition and volume   */
//*                    data to see what the engine was and was not    */
//*                    able to create.                                */
//*                                                                   */
//*   Side Effects:  The partitioning information of the disk drives  */
//*                  in the system may be altered.                    */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Commit_Changes(Error_Code: PCARDINAL32): BOOLEAN; external 'lvm' name 'Commit_Changes';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_Java_Call_Back                               */
//*                                                                   */
//*   Descriptive Name: This function allows the calling Java program */
//*                     to set the call back address.  The call back  */
//*                     address is used when the LVM Engine or one of */
//*                     its plug-ins, needs to run a Java class to    */
//*                     gather information from the user.             */
//*                                                                   */
//*   Input: void ( * Execute_Java_Class) ... - The address of a       */
//*                                            function that the LVM  */
//*                                            engine may call when   */
//*                                            it needs a Java class  */
//*                                            to be executed.  This  */
//*                                            is only required if the*/
//*                                            user interface being   */
//*                                            used is written in Java*/
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output: If the function completes successfully, then *Error_Code*/
//*           will be set to LVM_ENGINE_NO_ERROR.  Otherwise,         */
//*           *Error_Code will be set to a non-zero error code.       */
//*                                                                   */
//*   Error Handling:  If an error occurs, the function will abort and*/
//*                    *Error_Code will be set to a non-zero error    */
//*                    code.                                          */
//*                                                                   */
//*   Side Effects:  The Java call back address is set to point to the*/
//*                  specified function.  Once the Java call back     */
//*                  address is set, LVM plug-ins which require the   */
//*                  Java call back will be enabled and can be used   */
//*                  during the creation of LVM Volumes.              */
//*                                                                   */
//*   Notes:  If a Java interface is in use (as specified on the      */
//*           Open_LVM_Engine call), then this function must be called*/
//*           in order to enable those LVM plug-ins which require     */
//*           initialization information during the creation of an    */
//*           LVM Volume.  If these plug-ins are not enabled, then    */
//*           they will not be reported by the Get_Available_Features */
//*           API, nor can they be used or accessed by any other LVM  */
//*           Engine APIs.  Thus, this function should be called      */
//*           immediately after the Open_LVM_Engine API is called.    */
//*                                                                   */
//*********************************************************************/
{$ifdef lvm2}
type
  TJavaExecProc=procedure(
    Class_Name: PChar;
    InputBuffer: ADDRESS;
    InputBufferSize: CARDINAL32;
    OutputBuffer: PADDRESS;
    OutputBufferSize,
    Error_Code: PCARDINAL32);

procedure Set_Java_Call_Back(
  Execute_Java_Class: TJAvaExecProc;
  Error_Code: PCARDINAL32); external 'lvm' name 'Set_Java_Call_Back';

{$endif}
//*********************************************************************/
//*                                                                   */
//*   Function Name: Close_LVM_Engine                                 */
//*                                                                   */
//*   Descriptive Name: Closes the LVM Engine and frees any memory    */
//*                     held by the LVM Engine.                       */
//*                                                                   */
//*   Input: None.                                                    */
//*                                                                   */
//*   Output:  None.                                                  */
//*                                                                   */
//*   Error Handling: N/A                                             */
//*                                                                   */
//*   Side Effects:  Any memory held by the LVM Engine is released.   */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Close_LVM_Engine; external 'lvm' name 'Close_LVM_Engine';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Available_Features                           */
//*                                                                   */
//*   Descriptive Name: Returns the feature ID information for each of*/
//*                     the features that the LVM Engine knows about. */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output: If successful, a Feature_Information_Array structure is */
//*           returned with a non-zero Count.  Also, *Error_Code will */
//*           be set to LVM_ENGINE_NO_ERROR.  If an error occurs,     */
//*           then the Count field in the structure will be 0 and     */
//*           ( *Error_Code) will contain a non-zero error code.       */
//*                                                                   */
//*   Error Handling: The only expected error is if this function is  */
//*                   called while the LVM Engine is not open.  This  */
//*                   should be the only error condition.             */
//*                                                                   */
//*   Side Effects:  Memory is allocated using the LVM Engine's memory*/
//*                  manager for the array of Feature_ID_Data items   */
//*                  being returned.                                  */
//*                                                                   */
//*   Notes:  This function seems to be presented since LVM Version 2 */
//*                                                                   */
//*********************************************************************/
{$ifdef LVM2}
function Get_Available_Features(Error_Code: PCARDINAL32): Feature_Information_Array; external 'lvm' name 'Get_Available_Features';
{$endif}
//*********************************************************************/
//*                                                                   */
//*   Function Name: Issue_Feature_Command                            */
//*                                                                   */
//*   Descriptive Name: Issues a feature specific command to either   */
//*                     the Ring 0 or Ring 3 portion of the feature.  */
//*                                                                   */
//*   Input: CARDINAL32 Feature_ID - The numeric ID assigned to the   */
//*                                  feature which is to receive the  */
//*                                  command being issued.            */
//*          ADDRESS Handle - The handle of the volume, partition, or */
//*                           aggregate to which the feature command  */
//*                           is to be directed.                      */
//*          BOOLEAN Ring0 - If TRUE, then the command will be sent   */
//*                          to the Ring 0 portion of the feature.    */
//*                          If FALSE, then the command will be sent  */
//*                          to the Ring 3 portion of the feature.    */
//*          ADDRESS InputBuffer - A buffer containing the command and*/
//*                                any necessary information for the  */
//*                                feature to process the command.    */
//*          CARDINAL32 InputSize - The number of bytes in the        */
//*                                 InputBuffer.                      */
//*          ADDRESS * OutputBuffer - The address of a variable used  */
//*                                   to hold the location of the     */
//*                                   output buffer created by the    */
//*                                   feature in response to the      */
//*                                   command in InputBuffer.         */
//*          CARDINAL32 * OutputSize - The address of a variable used */
//*                                    to hold the number of bytes in */
//*                                    *OutputBuffer.                 */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output: If successful, then *Error_Code will be set to          */
//*           LVM_ENGINE_NO_ERROR.  If unsuccessful, then *Error_Code */
//*           will be set to a non-zero error code.  *OutputBuffer and*/
//*           *OutputSize are set by the feature.  If the feature     */
//*           specified does not exist, then *OutputBuffer will be    */
//*           NULL and *Outputsize will be 0.  If the feature does    */
//*           exist, then the value of *OutputBuffer and *OutputSize  */
//*           depend upon the feature.                                */
//*                                                                   */
//*   Error Handling: If the specified feature does not exist, then   */
//*                   *Error_Code will contain a non-zero error code, */
//*                   *OutputBuffer will be NULL, and *OutputSize will*/
//*                   be set to 0.  All other error conditions are    */
//*                   feature dependent.                              */
//*                                                                   */
//*   Side Effects:  Side effects are feature dependent.              */
//*                                                                   */
//*   Notes:  New in LVM Version 2                                    */
//*                                                                   */
//*********************************************************************/
{$ifdef lvm2}
void _System Issue_Feature_Command( CARDINAL32 Feature_ID,
ADDRESS Handle,
BOOLEAN Ring0,
ADDRESS InputBuffer,
CARDINAL32 InputSize,
ADDRESS * OutputBuffer,
CARDINAL32 * OutputSize,
CARDINAL32 * Error_Code );
{$endif}
//*********************************************************************/
//*                                                                   */
//*   Function Name: Parse_Feature_Parameters                         */
//*                                                                   */
//*   Descriptive Name: This function allows access to the parsing    */
//*                     function of an LVM Plug-in Feature.  The      */
//*                     specified feature will be passed a list of    */
//*                     tokens to parse, and, if it parses the tokens */
//*                     successfully, will produce a buffer containing*/
//*                     initialization data that can be used with the */
//*                     Create_Volume API.  If it encounters an error,*/
//*                     the current item in the Tokens list will be   */
//*                     the offending item, and a pointer to an error */
//*                     message will be returned.                     */
//*                                                                   */
//*   Input: DLIST  Tokens - A DLIST of tokens to parse.  Parsing will*/
//*                          begin with the current entry in the list */
//*                          and proceed until there is an error or   */
//*                          until the specified feature has found a  */
//*                          complete command.  Each feature defines  */
//*                          what commands it will accept.            */
//*          LVM_Feature_Specification_Record * Feature_Data - A      */
//*                          pointer to a record which contains the   */
//*                          ID of the feature which is to parse the  */
//*                          DLIST of Tokens.  The other fields in    */
//*                          this record will be filled in by the     */
//*                          feature if it successfully parses the    */
//*                          tokens.                                  */
//*          char ** Error_Message - The address of a pointer to char.*/
//*                          This will be set to NULL if the feature  */
//*                          successfully parses the list of tokens,  */
//*                          or it will be set to point to an error   */
//*                          message if an error occurs.              */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32    */
//*                          variable into which an error code may    */
//*                          be placed.  The error code will be       */
//*                          LVM_ENGINE_NO_ERROR if this function     */
//*                          completes successfully, or a non-zero    */
//*                          error code if an error occurs.           */
//*                                                                   */
//*   Output: If there are no errors, the Actual_Class and Init_Data  */
//*           fields of *Feature_Data will be set, *Error_Message will*/
//*           be set to NULL, and Error_Code will be set to           */
//*           LVM_ENGINE_NO_ERROR.  The current item in the Tokens    */
//*           list will be the first token that was not parsed by the */
//*           feature (i.e. the first token after the command accepted*/
//*           by the plug-in).                                        */
//*                                                                   */
//*           If an error occurs, the values of Actual_Class and      */
//*           Init_Data in *Feature_Data are undefined.  *Error_Code  */
//*           will be set to LVM_ENGINE_PARSING_ERROR if the error is */
//*           parsing related, or some other non-zero value if the    */
//*           error is not parsing related.  If the error is parsing  */
//*           related, then *Error_Message will point to an error     */
//*           message which can be displayed for the user.  The       */
//*           current item in the Tokens list will be the token which */
//*           failed.                                                 */
//*                                                                   */
//*   Error Handling: If an parsing related error occurs, i.e. the    */
//*                   tokens in the Tokens list do not form a valid   */
//*                   command accepted by the specified feature, then */
//*                   the current item in the Tokens list will be the */
//*                   offending token, *Error_Message will be set to  */
//*                   point to an error message, and *Error_Code will */
//*                   be set to LVM_ENGINE_PARSING_ERROR.             */
//*                   If any other error occurs, the current item in  */
//*                   the Tokens list will be the token that was being*/
//*                   processed when the error occurs, and *Error_Code*/
//*                   will be set to a non-zero value.                */
//*                                                                   */
//*   Side Effects:  The current item in the Tokens list may change.  */
//*                                                                   */
//*   Notes:  Each feature defines which commands it will accept, and */
//*           therefore which commands it will successfully parse.    */
//*                                                                   */
//*********************************************************************/
{$ifdef lvm2}
void _System Parse_Feature_Parameters( DLIST                               Tokens,
LVM_Feature_Specification_Record  * Feature_Data,
char **                             Error_Message,
CARDINAL32 *                        Error_Code);
{$endif}
//*********************************************************************/
//*                                                                   */
//*   Function Name: Refresh_LVM_Engine                               */
//*                                                                   */
//*   Descriptive Name: This function causes the LVM Engine to look   */
//*                     for changes in the current system             */
//*                     configuration and update its internal tables  */
//*                     accordingly.                                  */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output:  None.                                                  */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be set to  */
//*                   a non-zero value.                               */
//*                                                                   */
//*   Side Effects: Volumes which represent non-LVM devices may have  */
//*                 their handles changed!                            */
//*                                                                   */
//*   Notes:  After calling this function, Get_Volume_Control_Data    */
//*           should be called to get the updated list of volumes.    */
//*           This is necessary as the handles of some volumes may    */
//*           have changed.                                           */
//*                                                                   */
//*********************************************************************/
procedure Refresh_LVM_Engine(Error_Code: PCARDINAL32); external 'lvm' name 'Refresh_LVM_Engine';

//****************************************************************************
//
// Functions relating to Drives
//
//***************************************************************************

//*********************************************************************/
//*                                                                   */
//*   Function Name:  Get_Drive_Control_Data                          */
//*                                                                   */
//*   Descriptive Name:  This function returns an array of            */
//*                      Drive_Control_Records.  These records provide*/
//*                      important information about the drives in the*/
//*                      system and provide the handles required to   */
//*                      access them.                                 */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output:  A Drive_Control_Array structure is returned.  If no    */
//*            errors occur, Drive_Control_Data will be non-NULL,     */
//*            Count will be greater than zero, and *Error_Code will  */
//*            be 0.                                                  */
//*                                                                   */
//*   Error Handling:  If an error occurs, the Drive_Control_Array    */
//*                    returned by this function will have NULL for   */
//*                    Drive_Control_Data, and 0 for Count.           */
//*                    *Error_Code will be greater than 0.            */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  The caller becomes responsible for the memory allocated */
//*           for the array of Drive_Control_Records pointed to by    */
//*           Drive_Control_Data pointer in the Drive_Control_Array   */
//*           structure returned by this function.  The caller should */
//*           free this memory when they are done using it.           */
//*                                                                   */
//*********************************************************************/
function Get_Drive_Control_Data(Error_Code: PCARDINAL32): Drive_Control_Array; external 'lvm' name 'Get_Drive_Control_Data';

//*********************************************************************/
//*                                                                   */
//*   Function Name:  Get_Drive_Status                                */
//*                                                                   */
//*   Descriptive Name:  Returns the Drive_Information_Record for the */
//*                      drive specified by Drive_Handle.             */
//*                                                                   */
//*   Input: ADDRESS Drive_Handle - The handle of the drive to use.   */
//*                             Drive handles are obtained through the*/
//*                             Get_Drive_Control_Data function.      */
//*         CARDINAL32 * Error_Code - The address of a CARDINAL32 in  */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output: This function returns the Drive_Information_Record for  */
//*           the drive associated with the specified Drive_Handle.   */
//*           If no errors occur, *Error_Code will be set to 0.  If an*/
//*           error does occur, then *Error_Code will be non-zero.    */
//*                                                                   */
//*   Error Handling:  If an error occurs, then *Error_Code will be   */
//*                    non-zero.                                      */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Get_Drive_Status(Drive_Handle: ADDRESS; Error_Code: PCARDINAL32): Drive_Information_Record; external 'lvm' name 'Get_Drive_Status';

//****************************************************************************
//
// Functions relating to Partitions
//
//***************************************************************************

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Partitions                                   */
//*                                                                   */
//*   Descriptive Name: Returns an array of partitions associated     */
//*                     with the object specified by Handle.          */
//*                                                                   */
//*   Input:ADDRESS Handle - This is the handle of a drive or volume. */
//*                      Drive handles are obtained through the       */
//*                      Get_Drive_Control_Data function.  Volume     */
//*                      handles are obtained through the             */
//*                      Get_Volume_Control_Data function.            */
//*         CARDINAL32 * Error_Code - The address of a CARDINAL32 in  */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output: This function returns a structure.  The structure has   */
//*           two components: an array of partition information       */
//*           records and the number of entries in the array.  If     */
//*           Handle is the handle of a disk drive, then the returned */
//*           array will contain a partition information record for   */
//*           each partition and block of free space on that drive.   */
//*           If Handle is the handle of a volume, then the returned  */
//*           array will contain a partition information record for   */
//*           each partition which is part of the specified volume.   */
//*           If no errors occur, then *Error_Code will be 0.  If an  */
//*           error does occur, then *Error_Code will be non-zero.    */
//*                                                                   */
//*   Error Handling: Any memory allocated for the return value will  */
//*                   be freed.  The Partition_Information_Array      */
//*                   returned by this function will contain a NULL   */
//*                   pointer for Partition_Array, and have a Count of*/
//*                   0.  *Error_Code will be non-zero.               */
//*                                                                   */
//*                   If Handle is non-NULL and is invalid, a trap    */
//*                   is likely.                                      */
//*                                                                   */
//*   Side Effects:  Memory will be allocated to hold the array       */
//*                  returned by this function.                       */
//*                                                                   */
//*   Notes:  The caller becomes responsible for the memory allocated */
//*           for the array of Partition_Information_Records pointed  */
//*           to by Partition_Array pointer in the                    */
//*           Partition_Information_Array structure returned by this  */
//*           function.  The caller should free this memory when they */
//*           are done using it.                                      */
//*                                                                   */
//*********************************************************************/
function Get_Partitions(Handle: ADDRESS; Error_Code: PCARDINAL32): Partition_Information_Array; external 'lvm' name 'Get_Partitions';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Partition_Handle                             */
//*                                                                   */
//*   Descriptive Name: Returns the handle of the partition whose     */
//*                     serial number matches the one provided.       */
//*                                                                   */
//*   Input: CARDINAL32 Serial_Number - This is the serial number to  */
//*                                     look for.  If a partition with*/
//*                                     a matching serial number is   */
//*                                     found, its handle will be     */
//*                                     returned.                     */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: If a partition with a matching serial number is found,  */
//*              then the function return value will be the handle    */
//*              of the partition found.  If no matching partition is */
//*              found, then the function return value will be NULL.  */
//*                                                                   */
//*   Error Handling:  If no errors occur, *Error_Code will be        */
//*                    LVM_ENGINE_NO_ERROR.  If an error occurs, then */
//*                    *Error_Code will be a non-zero error code.     */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Get_Partition_Handle(Serial_Number: CARDINAL32; Error_Code: PCARDINAL32): ADDRESS; external 'lvm' name 'Get_Partition_Handle';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Partition_Information                        */
//*                                                                   */
//*   Descriptive Name: Returns the Partition_Information_Record for  */
//*                     the partition specified by Partition_Handle.  */
//*                                                                   */
//*   Input: ADDRESS Partition_Handle - The handle associated with the*/
//*                                     partition for which the       */
//*                                     Partition_Information_Record  */
//*                                     is desired.                   */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: A Partition_Information_Record is returned.  If there   */
//*           is no error, then *Error_Code will be 0.  If an error   */
//*           occurs, *Error_Code will be non-zero.                   */
//*                                                                   */
//*   Error Handling:  If the Partition_Handle is not a valid handle, */
//*                    a trap could result.  If it is a handle for    */
//*                    something other than a partition, an error code*/
//*                    will be returned in *Error_Code.               */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Get_Partition_Information(Partition_Handle: ADDRESS; Error_Code: PCARDINAL32): Partition_Information_Record; external 'lvm' name 'Get_Partition_Information';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Create_Partition                                 */
//*                                                                   */
//*   Descriptive Name: Creates a partition on a disk drive.          */
//*                                                                   */
//*   Input: ADDRESS         Handle - The handle of a disk drive or   */
//*                                   a block of free space.          */
//*          CARDINAL32      Size - The size, in sectors, of the      */
//*                                 partition to create.              */
//*          char            Name[] - The name to give to the newly   */
//*                                   created partition.              */
//*          Allocation_Algorithm algorithm - If Handle is a drive,   */
//*                                           then the engine will    */
//*                                           find a block of free    */
//*                                           space to use to create  */
//*                                           the partition.  This    */
//*                                           tells the engine which  */
//*                                           memory management       */
//*                                           algorithm to use.       */
//*          BOOLEAN         Bootable - If TRUE, then the engine will */
//*                                     only create the partition if  */
//*                                     it can be booted from.  If    */
//*                                     Primary_Partition is FALSE,   */
//*                                     then it is assumed that OS/2  */
//*                                     is the operating system that  */
//*                                     will be booted.               */
//*          BOOLEAN         Primary_Partition - If TRUE, then the    */
//*                                              engine will create   */
//*                                              a primary partition. */
//*                                              If FALSE, then the   */
//*                                              engine will create a */
//*                                              logical drive.       */
//*          BOOLEAN         Allocate_From_Start - If TRUE, then the  */
//*                                                engine will        */
//*                                                allocate the new   */
//*                                                partition from the */
//*                                                beginning of the   */
//*                                                selected block of  */
//*                                                free space.  If    */
//*                                                FALSE, then the    */
//*                                                partition will be  */
//*                                                allocated from the */
//*                                                end of the selected*/
//*                                                block of free      */
//*                                                space.             */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: The function return value will be the handle of the     */
//*           partition created.  If the partition could not be       */
//*           created, then NULL will be returned.                    */
//*           *Error_Code will be 0 if the partition was created.     */
//*           *Error_Code will be > 0 if the partition could not be   */
//*           created.                                                */
//*                                                                   */
//*   Error Handling:  If the partition can not be created, then any  */
//*                    memory allocated by this function will be      */
//*                    freed and the partitioning of the disk in      */
//*                    question will be unchanged.                    */
//*                                                                   */
//*                    If Handle is not a valid handle, then a trap   */
//*                    may result.                                    */
//*                                                                   */
//*                    If Handle represents a partition or volume,    */
//*                    then the function will abort and set           */
//*                    *Error_Code to a non-zero value.               */
//*                                                                   */
//*   Side Effects:  A partition may be created on a disk drive.      */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
type
  TPartitionName=Array[0..PARTITION_NAME_SIZE-1] of char;

function Create_Partition(Handle: ADDRESS;
Size: CARDINAL32;
Name: TPartitionName;
algorithm: Allocation_Algorithm;
Bootable: BOOLEAN;
Primary_Partition: BOOLEAN;
Allocate_From_Start: BOOLEAN;
Error_Code: PCARDINAL32
): ADDRESS; external 'lvm' name 'Create_Partition';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Delete_Partition                                 */
//*                                                                   */
//*   Descriptive Name: Deletes the partition specified by            */
//*                     Partition_Handle.                             */
//*                                                                   */
//*   Input: ADDRESS Partition_Handle - The handle associated with the*/
//*                                     partition to be deleted.      */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the partition was deleted      */
//*           successfully.  *Error_Code will be > 0 if the partition */
//*           could not be deleted.                                   */
//*                                                                   */
//*   Error Handling: If the partition can not be deleted, then       */
//*                   *Error_Code will be > 0.                        */
//*                                                                   */
//*                   If Partition_Handle is not a valid handle, a    */
//*                   trap may result.                                */
//*                                                                   */
//*                   If Partition_Handle is a volume or drive handle,*/
//*                   then this function will abort and set           */
//*                   *Error_Code to a non-zero value.                */
//*                                                                   */
//*   Side Effects: A partition on a disk drive may be deleted.       */
//*                                                                   */
//*   Notes:  A partition can not be deleted if it is part of a       */
//*           volume!                                                 */
//*                                                                   */
//*********************************************************************/
procedure Delete_Partition(Partition_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Delete_Partition';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_Active_Flag                                  */
//*                                                                   */
//*   Descriptive Name: Sets the Active Flag field for a partition.   */
//*                                                                   */
//*   Input: ADDRESS Partition_Handle - The handle of the partition   */
//*                                     whose Active Flag is to be set*/
//*          BYTE Active_Flag - The new value for the Active Flag.    */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the Active Flag was            */
//*           successfully set, otherwise *Error_Code will contain a  */
//*           non-zero error code indicating what went wrong.         */
//*                                                                   */
//*   Error Handling: If the Active Flag can not be set, this function*/
//*                   will abort without changing any disk structures.*/
//*                                                                   */
//*                   If Partition_Handle is not a valid handle, a    */
//*                   trap may result.                                */
//*                                                                   */
//*                   If Partition_Handle is a volume or drive handle,*/
//*                   then this function will abort and set           */
//*                   *Error_Code to a non-zero value.                */
//*                                                                   */
//*                                                                   */
//*   Side Effects:  The Active Flag for a partition may be modified. */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_Active_Flag(Partition_Handle: ADDRESS;
Active_Flag: BYTE;
Error_Code: PCARDINAL32
); external 'lvm' name 'Set_Active_Flag';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_OS_Flag                                      */
//*                                                                   */
//*   Descriptive Name: Sets the OS Flag field for a partition.  This */
//*                     field is typically used to indicate the       */
//*                     filesystem used on the partition, which       */
//*                     generally gives an indication of which OS is  */
//*                     using that partition.                         */
//*                                                                   */
//*   Input: ADDRESS Partition_Handle - The handle of the partition   */
//*                                     whose Active Flag is to be set*/
//*          BYTE OS_Flag - The new value for the OS Flag.            */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the OS Flag was successfully   */
//*           set, otherwise *Error_Code will contain a non-zero error*/
//*           code indicating what went wrong.                        */
//*                                                                   */
//*   Error Handling: If the OS Flag can not be set, this function    */
//*                   will abort without changing any disk structures.*/
//*                                                                   */
//*                   If Partition_Handle is not a valid handle, a    */
//*                   trap may result.                                */
//*                                                                   */
//*                   If Partition_Handle is a volume or drive handle,*/
//*                   then this function will abort and set           */
//*                   *Error_Code to a non-zero value.                */
//*                                                                   */
//*                                                                   */
//*   Side Effects:  The OS Flag for a partition may be modified.     */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_OS_Flag(Partition_Handle: ADDRESS;
OS_Flag: BYTE;
Error_Code: PCARDINAL32
); external 'lvm' name 'Set_OS_Flag';

//****************************************************************************
//
// Functions relating to Volumes
//
//***************************************************************************

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Volume_Control_Data                          */
//*                                                                   */
//*   Descriptive Name: This function returns a structure containing  */
//*                     an array of Volume_Control_Records.  These    */
//*                     records contain information about volumes     */
//*                     which is invariant - i.e. will not change for */
//*                     as long as the volume exists.  One of the     */
//*                     items in the Volume_Control_Record is the     */
//*                     handle for the volume.  This handle must be   */
//*                     used on all accesses to the volume.           */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: A Volume_Control_Array structure is returned.           */
//*                                                                   */
//*           If there are no errors, then the Volume_Control_Data    */
//*           pointer in the Volume_Control_Array will be non-NULL,   */
//*           the Count field of the Volume_Control_Array will be     */
//*           >= 0, and *Error_Code will be 0.                        */
//*                                                                   */
//*           If an error does occur, then the Volume_Control_Data    */
//*           pointer in the the Volume_Control_Array will be NULL,   */
//*           the Count field of the Volume_Control_Array will be 0,  */
//*           and *Error_Code will be > 0.                            */
//*                                                                   */
//*   Error Handling: If an error occurs, then any memory allocated by*/
//*                   this function will be freed.                    */
//*                                                                   */
//*   Side Effects:  Memory for the returned array is allocated.      */
//*                                                                   */
//*   Notes:  The caller becomes responsible for the memory allocated */
//*           for the array of Volume_Control_Records pointed to by   */
//*           Volume_Control_Data pointer in the Volume_Control_Array */
//*           structure returned by this function.  The caller should */
//*           free this memory when they are done using it.           */
//*                                                                   */
//*********************************************************************/
function Get_Volume_Control_Data(Error_Code: PCARDINAL32): Volume_Control_Array; external 'lvm' name 'Get_Volume_Control_Data';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Volume_Information                           */
//*                                                                   */
//*   Descriptive Name:  This function returns the                    */
//*                      Volume_Information_Record for the volume     */
//*                      associated with Volume_Handle.               */
//*                                                                   */
//*   Input: ADDRESS Volume_Handle - The handle of the volume about   */
//*                                  which information is desired.    */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: This function returns a Volume_Information_Record.      */
//*                                                                   */
//*           If this function is successful, then *Error_Code will be*/
//*              0.                                                   */
//*                                                                   */
//*           If this function fails, then *Error_Code will be > 0.   */
//*                                                                   */
//*   Error Handling:  If Volume_Handle is not a valid handle, a trap */
//*                    will be likely.  If Volume_Handle is a drive or*/
//*                    partition handle, *Error_Code will be > 0.     */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Get_Volume_Information(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32): Volume_Information_Record; external 'lvm' name 'Get_Volume_Information';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Create_Volume                                    */
//*                                                                   */
//*   Descriptive Name:  This function creates a volume from a list of*/
//*                      partitions.  The partitions are specified by */
//*                      their corresponding handles.                 */
//*                                                                   */
//*   Input: char         Name[] - The name to assign to the newly    */
//*                                created volume.                    */
//*          BOOLEAN      Create_LVM_Volume - If TRUE, then an LVM    */
//*                                           volume is created,      */
//*                                           otherwise a             */
//*                                           compatibility volume is */
//*                                           created.                */
//*          BOOLEAN      Bootable - If TRUE, the volume will not be  */
//*                                  created unless OS/2 can be booted*/
//*                                  from it.                         */
//*          char         Drive_Letter_Preference - This is the drive */
//*                                                 letter to use for */
//*                                                 accessing the     */
//*                                                 newly created     */
//*                                                 volume.           */
//*          CARDINAL32   FeaturesToUse - This is currently reserved  */
//*                                       for future use and should   */
//*                                       always be set to 0.         */
//*          CARDINAL32   Partition_Count - The number of partitions  */
//*                                         to link together to form  */
//*                                         the volume being created. */
//*          ADDRESS      Partition_Handles[] - An array of partition */
//*                                             handles with one entry*/
//*                                             for each partition    */
//*                                             that is to become part*/
//*                                             of the volume being   */
//*                                             created.              */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the volume was created.        */
//*           *Error_Code will be > 0 if the volume could not be      */
//*              created.                                             */
//*                                                                   */
//*   Error Handling: If any of the handles in the partition handles  */
//*                   array is not valid, then a trap is likely.  If  */
//*                   Partition_Count is greater than the number of   */
//*                   entries in the partition handles array, then a  */
//*                   trap is likely.  If any of the handles in the   */
//*                   partition array are not partition handles, then */
//*                   *Error_Code will be > 0.  If the volume can NOT */
//*                   be created, then *Error_Code will be > 0 and any*/
//*                   memory allocated by this function will be freed.*/
//*                   If the volume can NOT be created, then the      */
//*                   existing partition/volume structure of the disk */
//*                   will be unchanged.                              */
//*                                                                   */
//*   Side Effects:  A volume may be created.                         */
//*                                                                   */
//*   Notes:  This function provides limited compatibility for        */
//*           programs written to use the LVM Version 1 interface.    */
//*           Specifically, this function will only allow the         */
//*           creation of compatibility volumes.  Any attempt to      */
//*           create an LVM volume will result in an error code being */
//*           returned.                                               */
//*                                                                   */
//*********************************************************************/
type
  TVolumeName=Array[0..VOLUME_NAME_SIZE-1] of char;

procedure Create_Volume(Name: TVolumeName;
Create_LVM_Volume: BOOLEAN;
Bootable: BOOLEAN;
Drive_Letter_Preference: char;
FeaturesToUse: CARDINAL32;
Partition_Count: CARDINAL32;
Partition_Handles: Array of ADDRESS;
Error_Code: PCARDINAL32
); external 'lvm' name 'Create_Volume';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Create_Volume2                                   */
//*                                                                   */
//*   Descriptive Name:  This function creates a volume from a list of*/
//*                      partitions.  The partitions are specified by */
//*                      their corresponding handles.                 */
//*                                                                   */
//*   Input: char         Name[] - The name to assign to the newly    */
//*                                created volume.                    */
//*          BOOLEAN      Create_LVM_Volume - If TRUE, then an LVM    */
//*                                           volume is created,      */
//*                                           otherwise a             */
//*                                           compatibility volume is */
//*                                           created.                */
//*          BOOLEAN      Bootable - If TRUE, the volume will not be  */
//*                                  created unless OS/2 can be booted*/
//*                                  from it.                         */
//*          char         Drive_Letter_Preference - This is the drive */
//*                                                 letter to use for */
//*                                                 accessing the     */
//*                                                 newly created     */
//*                                                 volume.           */
//*          CARDINAL32   Feature_Count - The number of features to   */
//*                                       install on the volume being */
//*                                       created.  This field is     */
//*                                       ignored if Create_LVM_Volume*/
//*                                       is FALSE.                   */
//*          LVM_Feature_Specification_Record FeaturesToUse[] - An    */
//*                                         array of feature IDs and  */
//*                                         their associated LVM      */
//*                                         classes used to designate */
//*                                         which features to install */
//*                                         on the volume being       */
//*                                         created and the order in  */
//*                                         which to install them.    */
//*                                         This field is ignored if  */
//*                                         Create_LVM_Volume is      */
//*                                         FALSE.                    */
//*          CARDINAL32   Partition_Count - The number of partitions  */
//*                                         to link together to form  */
//*                                         the volume being created. */
//*          ADDRESS      Partition_Handles[] - An array of partition */
//*                                             handles with one entry*/
//*                                             for each partition    */
//*                                             that is to become part*/
//*                                             of the volume being   */
//*                                             created.              */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the volume was created.        */
//*           *Error_Code will be > 0 if the volume could not be      */
//*              created.                                             */
//*                                                                   */
//*   Error Handling: If any of the handles in the partition handles  */
//*                   array is not valid, then a trap is likely.  If  */
//*                   Partition_Count is greater than the number of   */
//*                   entries in the partition handles array, then a  */
//*                   trap is likely.  If any of the handles in the   */
//*                   partition array are not partition handles, then */
//*                   *Error_Code will be > 0.  If the volume can NOT */
//*                   be created, then *Error_Code will be > 0 and any*/
//*                   memory allocated by this function will be freed.*/
//*                   If the volume can NOT be created, then the      */
//*                   existing partition/volume structure of the disk */
//*                   will be unchanged.                              */
//*                                                                   */
//*   Side Effects:  A volume may be created.                         */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
{$ifdef lvm2}
void _System Create_Volume2( char                               Name[VOLUME_NAME_SIZE],
BOOLEAN                            Create_LVM_Volume,
BOOLEAN                            Bootable,
char                               Drive_Letter_Preference,
CARDINAL32                         Feature_Count,
LVM_Feature_Specification_Record   FeaturesToUse[],
CARDINAL32                         Partition_Count,
ADDRESS                            Partition_Handles[],
CARDINAL32 *                       Error_Code
);
{$endif}

//*********************************************************************/
//*                                                                   */
//*   Function Name: Delete_Volume                                    */
//*                                                                   */
//*   Descriptive Name: Deletes the volume specified by Volume_Handle.*/
//*                                                                   */
//*   Input: ADDRESS Volume_Handle - The handle of the volume to      */
//*                                  delete.  All partitions which are*/
//*                                  part of the specified volume will*/
//*                                  be deleted also.                 */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the volume and its partitions  */
//*           are successfully deleted.  Otherwise, *Error_Code will  */
//*           be > 0.                                                 */
//*                                                                   */
//*   Error Handling: *Error_Code will be > 0 if an error occurs.  If */
//*                   the volume or any of its partitions can not be  */
//*                   deleted, then any changes made by this function */
//*                   will be undone.                                 */
//*                                                                   */
//*                   If Volume_Handle is not a valid handle, a trap  */
//*                   may result.                                     */
//*                                                                   */
//*                   If Volume_Handle is a partition or drive handle,*/
//*                   then this function will abort and set           */
//*                   *Error_Code to a non-zero value.                */
//*                                                                   */
//*   Side Effects:  A volume and its partitions may be deleted.      */
//*                  System memory may be freed as the internal       */
//*                  structures used to track the deleted volume      */
//*                  are no longer required.                          */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Delete_Volume(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Delete_Volume';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Hide_Volume                                      */
//*                                                                   */
//*   Descriptive Name: Hide volume "hides" a volume from OS/2 by     */
//*                     removing its drive letter assignment.  Without*/
//*                     a drive letter assignment, OS/2 can not access*/
//*                     (or "see") the volume.                        */
//*                                                                   */
//*   Input: ADDRESS Volume_Handle - The handle of the volume to hide.*/
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the volume was successfully    */
//*           hidden.  If the volume could not be hidden, then        */
//*           *Error_Code will be > 0.                                */
//*                                                                   */
//*   Error Handling: *Error_Code will be > 0 if the volume can not be*/
//*                   hidden.  If the volume can not be hidden, then  */
//*                   nothing will be altered.                        */
//*                                                                   */
//*                   If Volume_Handle is not a valid handle, a trap  */
//*                   may result.                                     */
//*                                                                   */
//*                   If Volume_Handle is a partition or drive handle,*/
//*                   then this function will abort and set           */
//*                   *Error_Code to a non-zero value.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Hide_Volume(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Hide_Volume';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Expand_Volume                                    */
//*                                                                   */
//*   Descriptive Name: This function expands an existing volume by   */
//*                     linking additional partitions to it.          */
//*                                                                   */
//*   Input: ADDRESS Volume_Handle - The handle of the volume to be   */
//*                                  expanded.                        */
//*          CARDINAL32 Partition_Count - The number of partitions or */
//*                                       volumes to be added to the  */
//*                                       volume being expanded.      */
//*          ADDRESS Partition_Handles[] - An array of handles.  Each */
//*                                        handle in the array is the */
//*                                        handle of a partition      */
//*                                        which is to be added to    */
//*                                        the volume being expanded. */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the volume is successfully     */
//*           expanded.  If the volume can not be expanded,           */
//*           *Error_Code will be > 0.                                */
//*                                                                   */
//*   Error Handling: If the volume can not be expanded, the state of */
//*                   the volume is unchanged and any memory allocated*/
//*                   by this function is freed.                      */
//*                                                                   */
//*                   If Volume_Handle is not a valid handle, a trap  */
//*                   may result.                                     */
//*                                                                   */
//*                   If Volume_Handle is a partition or drive handle,*/
//*                   then this function will abort and set           */
//*                   *Error_Code to a non-zero value.                */
//*                                                                   */
//*                   If any of the partition handles in the          */
//*                   Partition_handles array are not valid handles,  */
//*                   then a trap may result.                         */
//*                                                                   */
//*                   If any of the partition handles in the          */
//*                   Partition_Handles array are actually drive      */
//*                   handles, then this function will abort and      */
//*                   set *Error_Code to a non-zero value.            */
//*                                                                   */
//*                   If Partition_Count is greater than the number of*/
//*                   entries in the Partition_Handles array, a trap  */
//*                   may result.                                     */
//*                                                                   */
//*   Side Effects:  A volume may be expanded.  If the volume is      */
//*                  expanded using another volume, the partitions    */
//*                  on the second volume will be linked to those of  */
//*                  the first volume and all data on the second      */
//*                  volume will be lost.                             */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Expand_Volume(Volume_Handle: ADDRESS;
Partition_Count: CARDINAL32;
Partition_Handles: Array of ADDRESS;
Error_Code: PCARDINAL32
); external 'lvm' name 'Expand_Volume';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Assign_Drive_Letter                              */
//*                                                                   */
//*   Descriptive Name: Assigns a drive letter to a volume.           */
//*                                                                   */
//*   Input: ADDRESS Volume_Handle - The handle of the volume which   */
//*                                  is to have its assigned drive    */
//*                                  letter changed.                  */
//*          char  New_Drive_Preference - The new drive letter to     */
//*                                       assign to the volume.       */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the drive letter was assigned  */
//*           successfully; otherwise *Error_Code will be > 0.        */
//*                                                                   */
//*   Error Handling: If the drive letter assignment can not be made, */
//*                   the volume will not be altered.                 */
//*                                                                   */
//*                   If Volume_Handle is not a valid handle, a trap  */
//*                   may result.                                     */
//*                                                                   */
//*                   If Volume_Handle is a partition or drive handle,*/
//*                   then this function will abort and set           */
//*                   *Error_Code to a non-zero value.                */
//*                                                                   */
//*   Side Effects:  A volume may have its drive letter assignment    */
//*                  changed.                                         */
//*                                                                   */
//*   Notes:  If the drive letter being assigned is already in use by */
//*           volume which does not lie on removable media, then the  */
//*           drive assignment will NOT be made.                      */
//*                                                                   */
//*********************************************************************/
procedure Assign_Drive_Letter(Volume_Handle: ADDRESS;
New_Drive_Preference: char;
Error_Code: PCARDINAL32
); external 'lvm' name 'Assign_Drive_Letter';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_Installable                                  */
//*                                                                   */
//*   Descriptive Name: Marks a volume as being the volume to install */
//*                     OS/2 on.                                      */
//*                                                                   */
//*   Input: ADDRESS Volume_Handle - The handle of the volume to which*/
//*                                  OS/2 should be installed.        */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: If the volume is successfully marked as installable,    */
//*           *Error_Code will be 0; otherwise *Error_Code will       */
//*           be > 0.                                                 */
//*                                                                   */
//*   Error Handling: If Volume_Handle is not a valid handle, a trap  */
//*                   may result.                                     */
//*                                                                   */
//*                   If Volume_Handle is a partition or drive handle,*/
//*                   then this function will abort and set           */
//*                   *Error_Code to a non-zero value.                */
//*                                                                   */
//*   Side Effects:  The specified volume may be marked as            */
//*                  installable.                                     */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_Installable(Volume_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Set_Installable';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Installable_Volume                           */
//*                                                                   */
//*   Descriptive Name: Marks a volume as being the volume to install */
//*                     OS/2 on.                                      */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: If a volume is mared installable, its information will  */
//*           be returned and *Error_Code will be LVM_ENGINE_NO_ERROR.*/
//*           If there is no volume marked installable, then          */
//*           *Error_Code will be > 0.                                */
//*                                                                   */
//*   Error Handling: An error code is returned if there is an error. */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Get_Installable_Volume(Error_Code: PCARDINAL32): Volume_Information_Record; external 'lvm' name 'Get_Installable_Volume';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Convert_Volumes_To_V1                            */
//*                                                                   */
//*   Descriptive Name: This function attempts to convert all LVM     */
//*                     volumes in the system into a format that can  */
//*                     be used by LVM Version 1, which was shipped   */
//*                     with Warp Server for e-business.  This        */
//*                     function returns a bitmap of the drive letters*/
//*                     corresponding to Volumes that can not be      */
//*                     converted.                                    */
//*                                                                   */
//*   Input: BOOLEAN * Hidden_Volume_Conversion_Failure - The address */
//*                                 of a BOOLEAN variable in which    */
//*                                 to store a flag indicating if     */
//*                                 there were hidden volumes that    */
//*                                 could not be converted.  If       */
//*                                 *Hidden_Volume_Conversion_Failure */
//*                                 is TRUE, then there were hidden   */
//*                                 volumes that could not be         */
//*                                 converted.  If FALSE, then there  */
//*                                 were no hidden volumes, or the    */
//*                                 hidden volumes that existed were  */
//*                                 converted successfully.           */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: This function returns a bitmap of the drive letters     */
//*           corresponding to volumes that could not be converted to */
//*           LVM Version 1 format.  If this function is successful   */
//*           and all volumes were converted, then *Error_Code will be*/
//*           set to LVM_ENGINE_NO_ERROR and the bitmap returned will */
//*           have no bits set.  If this function failes, *Error_Code */
//*           will contain a non-zero error code and the bitmap       */
//*           returned by this function may be non-zero.              */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be > 0.    */
//*                                                                   */
//*   Side Effects:  All LVM volumes that can be converted to LVM     */
//*                  Version 1 format will be.                        */
//*                                                                   */
//*   Notes:  Bit 0 in the bitmap returned by this function represents*/
//*           drive letter 'A'.                                       */
//*                                                                   */
//*********************************************************************/
{$ifdef lvm2}
CARDINAL32 _System Convert_Volumes_To_V1 ( BOOLEAN *    Hidden_Volume_Conversion_Failure,
CARDINAL32 * Error_Code ) ;
{$endif}

//***************************************************************************
//
// Functions relating to Partitions, Drives, and Volumes.
//
//***************************************************************************

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_Name                                         */
//*                                                                   */
//*   Descriptive Name: Sets the name of a volume, drive, or partition*/
//*                                                                   */
//*   Input: ADDRESS Handle - The handle of the drive, partition, or  */
//*                           volume which is to have its name set.   */
//*          char New_Name[] - The new name for the drive/partition/  */
//*                            volume.                                */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the name is set as specified.  */
//*           If the name can not be set, *Error_Code will be > 0.    */
//*                                                                   */
//*   Error Handling: If the name can not be set, then drive/volume/  */
//*                   partition is not modified.                      */
//*                                                                   */
//*                   If Handle is not a valid handle, a trap may     */
//*                   result.                                         */
//*                                                                   */
//*   Side Effects:  A drive/volume/partition may have its name set.  */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_Name(Handle: ADDRESS;
New_Name: Array of char;
Error_Code: PCARDINAL32
); external 'lvm' name 'Set_Name';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_Startable                                    */
//*                                                                   */
//*   Descriptive Name: Sets the specified volume or partition        */
//*                     startable.  If a volume is specified, it must */
//*                     be a compatibility volume whose partition is  */
//*                     a primary partition on the first drive.  If a */
//*                     partition is specified, it must be a primary  */
//*                     partition on the first drive in the system.   */
//*                                                                   */
//*   Input: ADDRESS Handle - The handle of the partition or volume   */
//*                           which is to be set startable.           */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the specified volume or        */
//*           partition was set startable.                            */
//*           If the name can not be set, *Error_Code will be > 0.    */
//*                                                                   */
//*   Error Handling: If the volume or partition could not be set     */
//*                   startable, then nothing in the system is        */
//*                   changed.                                        */
//*                                                                   */
//*                   If Handle is not a valid handle, a trap may     */
//*                   result.                                         */
//*                                                                   */
//*   Side Effects:  Any other partition or volume which is marked    */
//*                  startable will have its startable flag cleared.  */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_Startable(Handle: ADDRESS;
Error_Code: PCARDINAL32
); external 'lvm' name 'Set_Startable';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Valid_Options                                */
//*                                                                   */
//*   Descriptive Name: Returns a bitmap where each bit in the bitmap */
//*                     corresponds to a possible operation that the  */
//*                     LVM Engine can perform.  Those bits which are */
//*                     1 represent operations which can be performed */
//*                     on the item specified by Handle.  Those bits  */
//*                     which are 0 are not allowed on the item       */
//*                     specified by Handle.                          */
//*                                                                   */
//*   Input: ADDRESS Handle - This is any valid drive, volume, or     */
//*                           partition handle.                       */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output:  A bitmap indicating which operations are valid on the  */
//*            item specified by Handle.                              */
//*                                                                   */
//*            If no errors occur, *Error_Code will be 0, otherwise   */
//*            *Error_Code will be > 0.                               */
//*                                                                   */
//*   Error Handling:  If Handle is not valid, a trap will be likely. */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  The values of the various bits in the bitmap returned   */
//*           by this function are defined near the beginning of this */
//*           file, immediately after all of the structure            */
//*           definitions.                                            */
//*                                                                   */
//*********************************************************************/
function Get_Valid_Options(Handle: ADDRESS; Error_Code: PCARDINAL32): CARDINAL32; external 'lvm' name 'Get_Valid_Options';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Child_Handles                                */
//*                                                                   */
//*   Descriptive Name: Given the handle of a volume or aggregate,    */
//*                     this function will return the handles of the  */
//*                     children of the volume or aggregate.  This    */
//*                     allows the entire tree representation of a    */
//*                     volume to be traversed, a level at a time.    */
//*                                                                   */
//*   Input: ADDRESS Handle - The handle of the volume or aggregate   */
//*                           whose children are required.            */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output:  If successful, an LVM_Handle_Array_Record is returned  */
//*            with a non-zero Count.  Also, *Error_Code will be set  */
//*            to LVM_ENGINE_NO_ERROR.  If an error occurs, then      */
//*            the Count field will be 0 and *Error_Code will contain */
//*            a non-zero error code.                                 */
//*                                                                   */
//*   Error Handling: If Handle is not a valid handle, then a trap is */
//*                   likely.  If Handle is the handle of partition,  */
//*                   then *Error_Code will be set to                 */
//*                   LVM_ENGINE_NO_CHILDREN.  If Handle is not a     */
//*                   volume or aggregate handle, then *Error_Code    */
//*                   will be set to LVM_ENGINE_BAD_HANDLE.           */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
{$ifdef lvm2}
LVM_Handle_Array_Record  _System Get_Child_Handles( ADDRESS Handle, CARDINAL32 * Error_Code);
{$endif}
//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Parent_Handle                                */
//*                                                                   */
//*   Descriptive Name: Given the handle of a partition or aggregate, */
//*                     this function will return the handle of the   */
//*                     parent of the partition or aggregate.         */
//*                                                                   */
//*   Input: ADDRESS Handle - The handle of the partition or aggregate*/
//*                           whose parent is required.               */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output:  If successful, the handle of the parent is returned    */
//*            as the function result and *Error_Code will be set to  */
//*            LVM_ENGINE_NO_ERROR.                                   */
//*            If an error occurs, then NULL will be the function     */
//*            result and *Error_Code will contain a non-zero error   */
//*            code.                                                  */
//*                                                                   */
//*   Error Handling: If Handle is not a valid handle, then a trap is */
//*                   likely.  If Handle is the handle of volume,     */
//*                   then *Error_Code will be set to                 */
//*                   LVM_ENGINE_NO_PARENT.  If Handle is not the     */
//*                   handle of a volume, partition, or aggregate     */
//*                   then *Error_Code will be set to                 */
//*                   LVM_ENGINE_BAD_HANDLE.                          */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
{$ifdef lvm2}
ADDRESS _System Get_Parent_Handle( ADDRESS Handle, CARDINAL32 * Error_Code);
{$endif}
//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Features                                     */
//*                                                                   */
//*   Descriptive Name: Returns the feature ID information for each of*/
//*                     the features that are installed on the        */
//*                     item specified by Handle.                     */
//*                                                                   */
//*   Input: ADDRESS Handle - The handle of the object to use.        */
//*                                                                   */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                   in which to store an error code */
//*                                   should an error occur.          */
//*                                                                   */
//*   Output: If successful, a Feature_Information_Array structure is */
//*           returned with a non-zero Count.  Also, *Error_Code will */
//*           be set to LVM_ENGINE_NO_ERROR.  If an error occurs,     */
//*           then the Count field in the structure will be 0 and     */
//*           ( *Error_Code) will contain a non-zero error code.       */
//*                                                                   */
//*   Error Handling:  If Handle is not a valid handle, a trap        */
//*                    will be likely.                                */
//*                                                                   */
//*   Side Effects:  Memory is allocated using the LVM Engine's memory*/
//*                  manager for the array of Feature_ID_Data items   */
//*                  being returned.                                  */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
{$ifdef lvm2}
Feature_Information_Array _System Get_Features( ADDRESS Handle, CARDINAL32 * Error_Code );
{$endif}
//***************************************************************************
//
// Functions relating to Boot Manager
//
//***************************************************************************

//*********************************************************************/
//*                                                                   */
//*   Function Name: Boot_Manager_Is_Installed                        */
//*                                                                   */
//*   Descriptive Name: Indicates whether or not Boot Manager is      */
//*                     installed on the first or second hard drives  */
//*                     in the system.                                */
//*                                                                   */
//*   Input: BOOLEAN * Active - *Active is set to TRUE if LVM found an*/
//*                             active copy of Boot Manager on the    */
//*                             system.  If LVM could not find an     */
//*                             active copy of Boot Manager on the    */
//*                             system, but did find an inactive copy */
//*                             of Boot Manager, then *Active will be */
//*                             set to FALSE.                         */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: TRUE is returned if Boot Manager is found.  If this     */
//*           copy of Boot Manager is Active, then *Active will be set*/
//*           to TRUE.  If the copy of Boot Manager is not currently  */
//*           active, then *Active will be set to FALSE.              */
//*                                                                   */
//*           FALSE is returned if Boot Manager is not found or if an */
//*           error occurs.  In this case, *Active is undefined.      */
//*                                                                   */
//*           *Error_Code will be 0 if no errors occur; otherwise it  */
//*           will be > 0.                                            */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be > 0.    */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
type
  PBOOLEAN=^BOOLEAN;

function Boot_Manager_Is_Installed(Active: PBOOLEAN; Error_Code: PCARDINAL32): BOOLEAN; external 'lvm' name 'Boot_Manager_Is_Installed';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Boot_Manager_Handle                          */
//*                                                                   */
//*   Descriptive Name: Returns the handle of the partition containing*/
//*                     Boot Manager.                                 */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: If Boot Manager is NOT installed, NULL is returned.     */
//*           If Boot Manager is installed, whether it is active or   */
//*           not, the handle of the partition it resides in is       */
//*           returned.                                               */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be > 0.    */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:                                                          */
//*                                                                   */
//*********************************************************************/
function Get_Boot_Manager_Handle(Error_Code: PCARDINAL32): ADDRESS; external 'lvm' name 'Get_Boot_Manager_Handle';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Add_To_Boot_Manager                              */
//*                                                                   */
//*   Descriptive Name: Adds the volume/partition to the Boot Manager */
//*                     menu.                                         */
//*                                                                   */
//*   Input: ADDRESS Handle - The handle of a partition or volume that*/
//*                           is to be added to the Boot Manager menu.*/
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the partition or volume was    */
//*           successfully added to the Boot Manager menu; otherwise  */
//*           *Error_Code will be > 0.                                */
//*                                                                   */
//*   Error Handling: If the partition/volume can not be added to the */
//*                   Boot Manager menu, no action is taken and       */
//*                   *Error_Code will contain a non-zero error code. */
//*                                                                   */
//*                   If Handle is not a valid handle, a trap may     */
//*                   result.                                         */
//*                                                                   */
//*                   If Handle represents a drive, then this function*/
//*                   will abort and set *Error_Code to a non-zero    */
//*                   value.                                          */
//*                                                                   */
//*   Side Effects:  The Boot Manager menu may be altered.            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Add_To_Boot_Manager(Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Add_To_Boot_Manager';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Remove_From_Boot_Manager                         */
//*                                                                   */
//*   Descriptive Name: Removes the specified partition or volume     */
//*                     from the Boot Manager menu.                   */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the partition or volume was    */
//*           successfully removed to the Boot Manager menu;          */
//*           otherwise *Error_Code will be > 0.                      */
//*                                                                   */
//*   Error Handling: If Handle is not a valid handle, a trap may     */
//*                   result.                                         */
//*                                                                   */
//*                   If Handle represents a drive, or if Handle      */
//*                   represents a volume or partition which is NOT on*/
//*                   the boot manager menu, then this function       */
//*                   will abort and set *Error_Code to a non-zero    */
//*                   value.                                          */
//*                                                                   */
//*   Side Effects:  The Boot Manager menu may be altered.            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Remove_From_Boot_Manager(Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'Remove_From_Boot_Manager';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Boot_Manager_Menu                            */
//*                                                                   */
//*   Descriptive Name: Returns an array containing the handles of the*/
//*                     partitions and volumes appearing on the       */
//*                     Boot Manager menu.                            */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: The function returns a Boot_Manager_Menu structure.     */
//*           This structure contains two items: a pointer to an array*/
//*           of Boot_Manager_Menu_Items and a count of how many items*/
//*           are in the array.  Each Boot_Manager_Menu_Item contains */
//*           a handle and a BOOLEAN variable to indicate whether the */
//*           handle is for a partition or a volume.                  */
//*                                                                   */
//*           If this function is successful, then *Error_Code will   */
//*           be 0.                                                   */
//*                                                                   */
//*           If an error occurs, the Count field in the              */
//*           Boot_Manager_Menu will be 0 and the corresponding       */
//*           pointer will be NULL.  *Error_Code will be > 0.         */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be > 0.    */
//*                   any memory allocated by this function will be   */
//*                   freed.                                          */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Get_Boot_Manager_Menu(Error_Code: PCARDINAL32): Boot_Manager_Menu; external 'lvm' name 'Get_Boot_Manager_Menu';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Install_Boot_Manager                             */
//*                                                                   */
//*   Descriptive Name: This function installs Boot Manager.  It can  */
//*                     be used to replace an existing Boot Manager   */
//*                     as well.                                      */
//*                                                                   */
//*   Input: CARDINAL32  Drive_Number - The number of the drive to    */
//*                                     install Boot Manager on.  Must*/
//*                                     be 1 or 2.                    */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: If this function is successful, then *Error_Code will be*/
//*           0; otherwise it will be > 0.                            */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be set to a*/
//*                   non-zero value.  Depending upon the error, it   */
//*                   is possible that the Boot Manager partition can */
//*                   be left in an unusuable state (such as for a    */
//*                   write error).                                   */
//*                                                                   */
//*   Side Effects: Boot Manager may be installed on drive 1 or 2.    */
//*                 The MBR for drive 1 may be altered.               */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
// Only drives 0 and 1 are acceptable.
procedure Install_Boot_Manager(Drive_Number: CARDINAL32; Error_Code: PCARDINAL32); external 'lvm' name 'Install_Boot_Manager';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Remove_Boot_Manager                              */
//*                                                                   */
//*   Descriptive Name: Removes Boot Manager from the system.         */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if Boot Manager was successfully  */
//*           removed from the system; otherwise *Error_Code will     */
//*           be 0.                                                   */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be > 0.    */
//*                                                                   */
//*   Side Effects:  Boot Manager will be removed from the system.    */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Remove_Boot_Manager(Error_Code: PCARDINAL32); external 'lvm' name 'Remove_Boot_Manager';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_Boot_Manager_Options                         */
//*                                                                   */
//*   Descriptive Name: Sets the Boot Managers Options.  The options  */
//*                     that can be set are: whether or not the time- */
//*                     out timer is active, how long the timer-out   */
//*                     is, the partition to boot by default, and     */
//*                     whether or not Boot Manager should display its*/
//*                     menu using default mode or advanced mode.     */
//*                                                                   */
//*   Input: ADDRESS Handle - The handle of the partition or volume   */
//*                           to boot if the time-out timer is active */
//*                           and the time-out value is reached.      */
//*          BOOLEAN Timer_Active - If TRUE, then the time-out timer  */
//*                                 is active.                        */
//*          CARDINAL32 Time_Out_Value - If the time-out timer is     */
//*                                      active, this is the time-out */
//*                                      value, in seconds.           */
//*          BOOLEAN Advanced_Mode - If TRUE, then Boot Manager will  */
//*                                  operate in advanced mode.  If    */
//*                                  FALSE, then normal mode will be  */
//*                                  in effect.                       */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if no errors occur.  If an error  */
//*           does occur, then *Error_Code will be > 0.               */
//*                                                                   */
//*   Error Handling: If an error occurs, no changes will be made to  */
//*                   Boot Manager and *Error_Code will be set a      */
//*                   non-zero error code.                            */
//*                                                                   */
//*   Side Effects:  Boot Manager may be modified.                    */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_Boot_Manager_Options(Handle: ADDRESS;
Timer_Active: BOOLEAN;
Time_Out_Value: CARDINAL32;
Advanced_Mode: BOOLEAN;
Error_Code: PCARDINAL32
); external 'lvm' name 'Set_Boot_Manager_Options';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Boot_Manager_Options                         */
//*                                                                   */
//*   Descriptive Name: This function returns the current Boot Manager*/
//*                     settings for the various Boot Manager options.*/
//*                                                                   */
//*   Input: ADDRESS * Handle - The handle for the default boot volume*/
//*                             or partition.                         */
//*          BOOLEAN * Handle_Is_Volume - If TRUE, then Handle        */
//*                                       represents a volume.  If    */
//*                                       FALSE, then Handle          */
//*                                       represents a partition.     */
//*          BOOLEAN * Timer_Active - If TRUE, then the time-out timer*/
//*                                   is active.  If FALSE, then the  */
//*                                   time-out timer is not active.   */
//*          CARDINAL32 * Time_Out_Value - If the time-out timer is   */
//*                                        active, then this is the   */
//*                                        number of seconds that Boot*/
//*                                        Manager will wait for user */
//*                                        input before booting the   */
//*                                        default volume/partition.  */
//*          BOOLEAN * Advanced_Mode - If TRUE, the Boot Manager is   */
//*                                    operating in advanced mode.  If*/
//*                                    FALSE, then Boot Manager is    */
//*                                    operating in normal mode.      */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Handle, *Handle_Is_Volume, *Timer_Active,              */
//*           *Time_out_value, *Advanced_Mode, and *Error_Code are all*/
//*           set by this function.  If there are no errors, then     */
//*           *Error_Code will be set to 0.  If any errors occur, then*/
//*           *Error_Code will be > 0.                                */
//*                                                                   */
//*   Error Handling: If any of the parameters are invalid, then a    */
//*                   trap is likely.  If Boot Manager is not         */
//*                   installed, then *Error_Code will be > 0.        */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Get_Boot_Manager_Options(Handle: PADDRESS;
Handle_Is_Volume: PBOOLEAN;
Timer_Active: PBOOLEAN;
Time_Out_Value: PCARDINAL32;
Advanced_Mode: PBOOLEAN;
Error_Code: PCARDINAL32
); external 'lvm' name 'Get_Boot_Manager_Options';

//****************************************************************************
//
// Other Functions
//
//***************************************************************************

//*********************************************************************/
//*                                                                   */
//*   Function Name:  Allocate_Engine_Memory                          */
//*                                                                   */
//*   Descriptive Name:  Allocates a block of memory using LVM.DLL's  */
//*                      memory management functions.                 */
//*                                                                   */
//*   Input: CARDINAL32 Size - The number of bytes of memory to       */
//*                            allocate.                              */
//*                                                                   */
//*   Output: The address of the block of memory which was allocated, */
//*           or NULL if the requested amount of memory could not be  */
//*           allocated.                                              */
//*                                                                   */
//*   Error Handling: None.                                           */
//*                                                                   */
//*   Side Effects:  The specified number of bytes is allocated from  */
//*                  the memory manager imbedded in LVM.DLL.  Memory  */
//*                  allocated by this function must be freed using   */
//*                  Free_Engine_Memory function.  The use of any     */
//*                  memory manager to free the memory could result in*/
//*                  Bad Things Happening!                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
{$ifdef lvm2}
ADDRESS _System Allocate_Engine_Memory( CARDINAL32 Size );
{$endif}
//*********************************************************************/
//*                                                                   */
//*   Function Name:  Free_Engine_Memory                              */
//*                                                                   */
//*   Descriptive Name: Frees a memory object created by LVM.DLL and  */
//*                     returned to a user of LVM.DLL.                */
//*                                                                   */
//*   Input: ADDRESS Object : The address of the memory object to     */
//*                           free.  This could be the                */
//*                           Drive_Control_Data field of a           */
//*                           Drive_Control_Record, the               */
//*                           Partition_Array field of a              */
//*                           Partition_Information_Array structure,  */
//*                           or any other dynamically allocated      */
//*                           memory object created by LVM.DLL and    */
//*                           returned by a function in LVM.DLL.      */
//*                                                                   */
//*   Output: None.                                                   */
//*                                                                   */
//*   Error Handling: None.                                           */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  A trap or exception could occur if a bad address is     */
//*           passed into this function.                              */
//*                                                                   */
//*********************************************************************/
procedure Free_Engine_Memory(Object_: ADDRESS); external 'lvm' name 'Free_Engine_Memory';

//*********************************************************************/
//*                                                                   */
//*   Function Name: New_MBR                                          */
//*                                                                   */
//*   Descriptive Name: This function lays down a new MBR on the      */
//*                     specified drive.                              */
//*                                                                   */
//*   Input: ADDRESS Drive_Handle - The handle of the drive on which  */
//*                                 the new MBR is to be placed.      */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if the new MBR was successfully   */
//*           placed on the specified drive.  If the operation failed */
//*           for any reason, then *Error_Code will contain a non-zero*/
//*           error code.                                             */
//*                                                                   */
//*   Error Handling: If an error occurs, then the existing MBR is not*/
//*                   altered and *Error_Code will be > 0.            */
//*                                                                   */
//*   Side Effects:  A new MBR may be placed on the specified drive.  */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure New_MBR(Drive_Handle: ADDRESS; Error_Code: PCARDINAL32); external 'lvm' name 'New_MBR';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Available_Drive_Letters                      */
//*                                                                   */
//*   Descriptive Name: This function returns a bitmap indicating     */
//*                     which drive letters are available for use.    */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: This function returns a bitmap of the available drive   */
//*           letters.  If this function is successful, then          */
//*           *Error_Code will be set to 0.  Otherwise, *Error_Code   */
//*           will be > 0 and the bitmap returned will have all bits  */
//*           set to 0.                                               */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be > 0.    */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  A drive letter is available if it is not associated     */
//*           with a volume located on a disk drive controlled        */
//*           by OS2DASD.                                             */
//*                                                                   */
//*********************************************************************/
function Get_Available_Drive_Letters(Error_Code: PCARDINAL32): CARDINAL32; external 'lcm' name 'Get_Available_Drive_Letters';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Reserved_Drive_Letters                       */
//*                                                                   */
//*   Descriptive Name: This function returns a bitmap indicating     */
//*                     which drive letters are reserved for use by   */
//*                     devices NOT under the control of LVM.         */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: This function returns a bitmap of the drive letters     */
//*           which are being used by devices which are NOT controlled*/
//*           by LVM.  While a Volume CAN be assigned a drive letter  */
//*           from this list, a reboot will almost always be required */
//*           in order for the assignment to take place.              */
//*           If this function is successful, then *Error_Code will be*/
//*           set to 0.  Otherwise, *Error_Code will be > 0 and the   */
//*           bitmap returned will have all bits set to 0.            */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be > 0.    */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  Devices which are assigned drive letters but which are  */
//*           NOT under LVM control include:  CD-ROM, Network drives, */
//*           parallel port attached devices, and any DASD devices    */
//*           not controlled by OS2DASD.                              */
//*                                                                   */
//*********************************************************************/
function Get_Reserved_Drive_Letters(Error_Code: CARDINAL32): CARDINAL32; external 'lvm' name 'Get_Reserved_Drive_Letters';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Reboot_Required                                  */
//*                                                                   */
//*   Descriptive Name: This function indicates whether or not any    */
//*                     changes were made to the partitioning of the  */
//*                     disks in the system which would require a     */
//*                     reboot to make functional.                    */
//*                                                                   */
//*   Input: None.                                                    */
//*                                                                   */
//*   Output: The function return value will be TRUE if the system    */
//*           must be rebooted as a result of disk partitioning       */
//*           changes.                                                */
//*                                                                   */
//*   Error Handling: None required.                                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Reboot_Required: BOOLEAN; external 'lvm' name 'Reboot_Required';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Changes_Pending                                  */
//*                                                                   */
//*   Descriptive Name: This function indicates whether or not any    */
//*                     changes were made to the partitioning of the  */
//*                     disks in the system which have not yet been   */
//*                     comitted to disk.                             */
//*                                                                   */
//*   Input: None.                                                    */
//*                                                                   */
//*   Output: The function return value will be TRUE if there are     */
//*           uncomitted changes to the partitioning of one or more of*/
//*           the drives in the system.                               */
//*                                                                   */
//*   Error Handling: None required.                                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Changes_Pending: BOOLEAN; external 'lvm' name 'Changes_Pending';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_Reboot_Flag                                  */
//*                                                                   */
//*   Descriptive Name: This function sets the Reboot Flag.  The      */
//*                     Reboot Flag is a special flag on the boot     */
//*                     disk used by the install program to keep      */
//*                     track of whether or not the system was just   */
//*                     rebooted.  It is used by the various phases   */
//*                     of install.                                   */
//*                                                                   */
//*   Input: BOOLEAN Reboot - The new value for the Reboot Flag.  If  */
//*                           TRUE, then the reboot flag will be set. */
//*                           If FALSE, then the reboot flag will be  */
//*                           cleared.                                */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be set to 0 if there are no errors.    */
//*           *Error_Code will be > 0 if an error occurs.             */
//*                                                                   */
//*   Error Handling: If an error occurs, then the value of the Reboot*/
//*                   Flag will be unchanged.                         */
//*                                                                   */
//*   Side Effects:  The value of the Reboot Flag may be changed.     */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_Reboot_Flag(Reboot: BOOLEAN; Error_Code: PCARDINAL32); external 'lvm' name 'Set_Reboot_Flag';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Reboot_Flag                                  */
//*                                                                   */
//*   Descriptive Name: This function returns the value of the Reboot */
//*                     Flag.  The Reboot Flag is a special flag on   */
//*                     the boot disk used by the install program to  */
//*                     keep track of whether or not the system was   */
//*                     just rebooted.  It is used by the various     */
//*                     phases of install.                            */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: The function return value will be TRUE if no errors     */
//*           occur and the Reboot Flag is set.  *Error_Code will be  */
//*           0 under these conditions.  If an error occurs, the      */
//*           function return value will be FALSE and *Error_Code     */
//*           will be > 0.                                            */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be > 0.    */
//*                   The value of the reboot flag will be unchanged. */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Get_Reboot_Flag(Error_Code: PCARDINAL32): BOOLEAN; external 'lvm' name 'Get_Reboot_Flag';

//*********************************************************************/
//*                                                                   */
//*                                                                   */
//*   Function Name: Set_Install_Flags                                */
//*                                                                   */
//*   Descriptive Name: This function sets the value of the Install   */
//*                     Flags.  The Install Flags reside in a 32 bit  */
//*                     field in the LVM dataspace.  These flags are  */
//*                     not used by LVM, thereby leaving Install free */
//*                     to use them for whatever it wants.            */
//*                                                                   */
//*   Input: CARDINAL32 Install_Flags - The new value for the Install */
//*                                     Flags.                        */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32    */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be set to 0 if there are no errors.    */
//*           *Error_Code will be > 0 if an error occurs.             */
//*                                                                   */
//*   Error Handling: If an error occurs, then the value of the       */
//*                   Install Flags will be unchanged.                */
//*                                                                   */
//*   Side Effects:  The value of the Install Flags may be changed.   */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_Install_Flags(Install_Flags: CARDINAL32; Error_Code: PCARDINAL32); external 'lvm' name 'Set_Install_Flags';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_Install_Flags                                */
//*                                                                   */
//*   Descriptive Name: This function returns the value of the Install*/
//*                     Flags.  The Install Flags reside in a 32 bit  */
//*                     field in the LVM dataspace.  These flags are  */
//*                     not used by LVM, thereby leaving Install free */
//*                     to use them for whatever it wants.            */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: The function returns the current value of the Install   */
//*           Flags stored in the LVM Dataspace.                      */
//*           *Error_Code will be LVM_ENGINE_NO_ERROR if the function */
//*           is successful.  If an error occurs, the function will   */
//*           return 0 and *Error_Code will be > 0.                   */
//*                                                                   */
//*   Error Handling: If an error occurs, *Error_Code will be > 0.    */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
function Get_Install_Flags(Error_Code: PCARDINAL32): CARDINAL32; external 'lvm' name 'Get_Install_Flags';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_Min_Install_Size                             */
//*                                                                   */
//*   Descriptive Name: This function tells the LVM Engine how big a  */
//*                     partition/volume must be in order for it to   */
//*                     marked installable.  If this function is not  */
//*                     used to set the minimum size for an           */
//*                     installable partition/volume, the LVM Engine  */
//*                     will use a default value of 300 MB.           */
//*                                                                   */
//*   Input: CARDINAL32 Min_Sectors - The minimum size, in sectors,   */
//*                                   that a partition must be in     */
//*                                   order for it to be marked as    */
//*                                   installable.                    */
//*                                                                   */
//*   Output: None.                                                   */
//*                                                                   */
//*   Error Handling: None required.                                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_Min_Install_Size(Min_Sectors: CARDINAL32); external 'lvm' name 'Set_Min_Install_Size';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Set_Free_Space_Threshold                         */
//*                                                                   */
//*   Descriptive Name: This function tells the LVM Engine not to     */
//*                     report blocks of free space which are less    */
//*                     than the size specified.  The engine defaults */
//*                     to not reporting blocks of free space which   */
//*                     are smaller than 2048 sectors (1 MB).         */
//*                                                                   */
//*   Input: CARDINAL32 Min_Sectors - The minimum size, in sectors,   */
//*                                   that a block of free space must */
//*                                   be in order for the LVM engine  */
//*                                   to report it.                   */
//*                                                                   */
//*   Output: None.                                                   */
//*                                                                   */
//*   Error Handling: None required.                                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Set_Free_Space_Threshold(Min_Sectors: CARDINAL32); external 'lvm' name 'Set_Free_Space_Threshold';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Read_Sectors                                     */
//*                                                                   */
//*   Descriptive Name: This function reads one or more sectors from  */
//*                     the specified drive and places the data read  */
//*                     in Buffer.                                    */
//*                                                                   */
//*   Input: CARDINAL32 Drive_Number : The number of the hard drive to*/
//*                                    read from.  The drives in the  */
//*                                    system are numbered from 1 to  */
//*                                    n, where n is the total number */
//*                                    of hard drives in the system.  */
//*          LBA Starting_Sector : The first sector to read from.     */
//*          CARDINAL32 Sectors_To_Read : The number of sectors to    */
//*                                       read into memory.           */
//*          ADDRESS Buffer : The location to put the data read into. */
//*          CARDINAL32 * Error : The address of a variable to hold   */
//*                               the error return code.              */
//*                                                                   */
//*   Output: If Successful, then the data read will be placed in     */
//*              memory starting at Buffer, and *Error will be        */
//*              LVM_ENGINE_NO_ERROR.                                 */
//*           If Unsuccessful, then *Error will be > 0 and the        */
//*              contents of memory starting at Buffer is undefined.  */
//*                                                                   */
//*   Error Handling: *Error will be > 0 if an error occurs.          */
//*                                                                   */
//*   Side Effects: Data may be read into memory starting at Buffer.  */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Read_Sectors(Drive_Number: CARDINAL32;
Starting_Sector: LBA;
Sectors_To_Read: CARDINAL32;
Buffer: ADDRESS;
Error: PCARDINAL32); external 'lvm' name 'Read_Sectors';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Write_Sectors                                    */
//*                                                                   */
//*   Descriptive Name: This function writes data from memory to one  */
//*                     or more sectors on the specified drive.       */
//*                                                                   */
//*   Input: CARDINAL32 Drive_Number : The number of the hard drive to*/
//*                                    write to.  The drives in the   */
//*                                    system are numbered from 1 to  */
//*                                    n, where n is the total number */
//*                                    of hard drives in the system.  */
//*          LBA Starting_Sector : The first sector to write to.      */
//*          CARDINAL32 Sectors_To_Read : The number of sectors to    */
//*                                       be written.                 */
//*          ADDRESS Buffer : The location of the data to be written  */
//*                           to disk.                                */
//*          CARDINAL32 * Error : The address of a variable to hold   */
//*                               the error return code.              */
//*                                                                   */
//*   Output: If Successful, then the data at Buffer will be placed   */
//*              on the disk starting at the sector specified, and    */
//*              *Error will be LVM_ENGINE_NO_ERROR.                  */
//*           If Unsuccessful, then *Error will be > 0 and the        */
//*              contents of the disk starting at sector              */
//*              Starting_Sector is undefined.                        */
//*                                                                   */
//*   Error Handling: *Error will be > 0 if an error occurs.          */
//*                                                                   */
//*   Side Effects: Data may be written to disk.                      */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Write_Sectors(Drive_Number: CARDINAL32;
Starting_Sector: LBA;
Sectors_To_Write: CARDINAL32;
Buffer: ADDRESS;
Error: PCARDINAL32); external 'lvm' name 'Write_Sectors';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Rediscover_PRMs                                  */
//*                                                                   */
//*   Descriptive Name: Causes OS2LVM and OS2DASD to check PRMs for   */
//*                     new or changed media.                         */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: If the Rediscover PRM operation was successful, then    */
//*           *Error_Code will be LVM_ENGINE_NO_ERROR.  If there      */
//*           was an error, then *Error_Code will be > 0.             */
//*                                                                   */
//*   Error Handling: None.                                           */
//*                                                                   */
//*   Side Effects:  New volumes may be discovered and assigned drive */
//*                  letters by OS2LVM and OS2DASD.                   */
//*                                                                   */
//*   Notes: The LVM Engine must be CLOSED when this function is      */
//*          called as this function is disabled while it is open!    */
//*                                                                   */
//*********************************************************************/
procedure Rediscover_PRMs(Error_Code: PCARDINAL32); external 'lvm' name 'Rediscover_PRMs';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Get_LVM_View                                     */
//*                                                                   */
//*   Descriptive Name:  This function gets the OS2LVM data for the   */
//*                      specified drive letter.  The intent is to    */
//*                      allow the determination of what drive letter */
//*                      a volume really has given the possibilities  */
//*                      of conflict or a drive preference of '*'.    */
//*                                                                   */
//*   Input:  char  IFSM_Drive_Letter : The drive letter for which the*/
//*                                     OS2LVM data is requested.     */
//*           CARDINAL32 * Drive_Number : The address of a variable   */
//*                                       to hold the OS/2 drive      */
//*                                       number of the drive         */
//*                                       containing the first        */
//*                                       partition of the volume     */
//*                                       currently assigned to the   */
//*                                       requested drive letter.     */
//*           CARDINAL32 * Partition_LBA : The address of a variable  */
//*                                        to hold the LBA of the     */
//*                                        first partition of the     */
//*                                        volume currently assigned  */
//*                                        to the requested drive     */
//*                                        letter.                    */
//*           char * LVM_Drive_Letter : The address of a variable to  */
//*                                     hold the drive letter that    */
//*                                     OS2LVM thinks the volume      */
//*                                     assigned to the requested     */
//*                                     drive letter should have.     */
//*           BYTE * UnitID : The address of a variable to hold the   */
//*                           OS2LVM unit ID for the volume associated*/
//*                           with the requested drive letter.        */
//*                                                                   */
//*   Output:  The function return value will be TRUE if the function */
//*            completed successfully.                                */
//*                                                                   */
//*   Error Handling: If this function fails, the specified drive     */
//*                   letter is either not in use, or is in use by a  */
//*                   device not controlled by OS2LVM.                */
//*                                                                   */
//*   Side Effects: None.                                             */
//*                                                                   */
//*   Notes: This function can be used with the LVM Engine open or    */
//*          closed.                                                  */
//*                                                                   */
//*********************************************************************/
function Get_LVM_View(IFSM_Drive_Letter: char;
Drive_Number: PCARDINAL32;
Partition_LBA: PCARDINAL32;
LVM_Drive_Letter: Pchar;
UnitID: PBYTE): BOOLEAN; external 'lvm' name 'Get_LVM_View';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Start_Logging                                    */
//*                                                                   */
//*   Descriptive Name: Enables the LVM Engine logging.  Once enabled,*/
//*                     the LVM Engine logging function will log all  */
//*                     LVM Engine activity to the specified log file.*/
//*                     The data is logged in a binary format for     */
//*                     compactness and speed.                        */
//*                                                                   */
//*   Input: char * Filename - The filename of the file to use as the */
//*                            log file.                              */
//*          CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: If the logging file was successfully created, then      */
//*           *Error_Code will be 0.  If the log file could not be    */
//*           created, then *Error_Code will be > 0.                  */
//*                                                                   */
//*   Error Handling: If the log file can not be created, then        */
//*                   *Error_Code will be > 0.                        */
//*                                                                   */
//*   Side Effects:  A file may be created/opened for logging of      */
//*                  LVM Engine actions.                              */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Start_Logging(Filename: Pchar; Error_Code: PCARDINAL32); external 'lvm' name 'Start_Logging';

//*********************************************************************/
//*                                                                   */
//*   Function Name: Stop_Logging                                     */
//*                                                                   */
//*   Descriptive Name: This function ends LVM Engine logging and     */
//*                     closes the log file.                          */
//*                                                                   */
//*   Input: CARDINAL32 * Error_Code - The address of a CARDINAL32 in */
//*                                    in which to store an error code*/
//*                                    should an error occur.         */
//*                                                                   */
//*   Output: *Error_Code will be 0 if this function completes        */
//*           successfully; otherwise it will be > 0.                 */
//*                                                                   */
//*   Error Handling: If the log file is not currently opened, or if  */
//*                   the close operation fails on the log file, then */
//*                   *Error_Code will be > 0.                        */
//*                                                                   */
//*   Side Effects:  The log file may be closed.                      */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
procedure Stop_Logging(Error_Code: PCARDINAL32); external 'lvm' name 'Stop_Logging';


{$ifdef lists}
(*
* Description:  This module implements a simple, generic, doubly linked list.
*               Data objects of any type can be placed into a linked list
*               created by this module.  Futhermore, data objects of different
*               types may be placed into the same linked list.
*
* Notes:  This linked list implementation makes use of the concept of the
*         current item.  In any non-empty list, one item in the list will
*         be designated as the current item.  When any of the following
*         functions are called, they will operate upon the current item
*         only: GetItem, ReplaceItem, DeleteItem, GetTag, NextItem,
*         PreviousItem, GetObject, ExtractItem, and ExtractObject.  The
*         user of this module may set the current item through the use of
*         the GoToStartOfList, GoToEndOfList, NextItem, PreviousItem,
*         and GoToSpecifiedItem functions.
*
*         Since a linked list created by this module may contain items
*         of different types, the user will need a way to identify items
*         of different types which may be in the same list.  To allow users
*         to do this, the concept of an item tag is used.  When an item is
*         added to the list, the user must enter an item tag.  The item
*         tag is merely some identifier that the user wishes to associate
*         with the item being placed into the list.  When used as intended,
*         each type of data item will have a unique tag associated with it.
*         This way, all data items of the same type will have the same tag
*         while data items of different types will have different tags.
*         Thus, by using the GetTag function, the user can get the item
*         tag for the current item without having to get the item from the
*         list.  This allows the user to differentiate between items of
*         different types which reside in the same list.
*
*         This module is single threaded.  If used in a multi-threaded
*         environment, the user must implement appropriate access controls.
*
*         When an item is inserted or appended to a list, this module
*         allocates memory on the heap to hold the item and then copies
*         the item to the memory that it allocated.  This allows local
*         variables to be safely inserted or appended to a list.  However,
*         it should be noted that under certain circumstances a copy of the
*         entire data item will NOT be made.  Specifically, if the data item
*         is a structure or array containing pointers, then the data pointed
*         to by the pointers will NOT be copied even though the structure or
*         array is!  This results from the fact that, when an item is being
*         inserted or appended to a list, the user provides just an address
*         and size.  This module assumes that the item to inserted or append
*         lies in a contiguous block of memory at the address provided by the
*         user.  This module has no way of knowing the structure of the data
*         at the specified address, and therefore can not know about any
*         embedded pointers which may lie within that block of memory.
*
*         This module now employs the concept of a handle.  A handle is a
*         reference to a specific item in a list which allows that item to
*         be made the current item in the list quickly.  Example:  If you
*         use the GetHandle function to get a handle for the current item
*         (lets call the item B1), then, regardless of where you are in the
*         list (or any reodering of the items in the list), you can make item
*         B1 the current item by passing its handle to the GoToSpecifiedItem
*         function.  Alternatively, you could operate directly on B1 using
*         the other handle based functions, such as GetItem_By_Handle, for
*         example.  GetItem_By_Handle gets the item associated with the
*         specified handle without changing which item in the list is the
*         current item in the list.
*
*         The functions of this module refer to user data as either items or
*         objects.  The difference between the two is simple, yet subtle.  It
*         deals with who is responsible for the memory used to hold the data.
*         In the case of an item, this module is responsible for the memory
*         used to hold the user data.  In the case of an object, the user
*         is responsible for the memory used to hold the data.
*
*         What this means is that, for functions adding ITEMS to a list,
*         this module will be responsible for allocating memory to hold
*         the user data and then copying the user data into the memory
*         that was allocated.  For functions which return items, this
*         module will COPY the user data from the LIST into a buffer
*         specified by the user.  For functions which add objects to a
*         list, the user provides a pointer to a block of memory holding
*         user data.  This block of memory was allocated by the user, and
*         becomes the "property" of this module once it has been added to
*         a LIST.  For functions which return objects, a pointer to the
*         memory where the data is stored is returned.  As long as an item/object
*         is in a LIST, this module will be responsible for the memory that
*         is used to store the data associated with that item.  This means that
*         users of this module should not call free on an object returned by this
*         module as long as that object is still within a list.
*
*
*)

typedef unsigned long TAG;

typedef ADDRESS DLIST;

//*--------------------------------------------------
//* Type definitions
//--------------------------------------------------*/

typedef enum _Insertion_Modes {
InsertAtStart,
InsertBefore,
InsertAfter,
AppendToList
} Insertion_Modes;

//************************************************
//*           Functions Available                *
//************************************************/

//*
//* The parameter *Error is set by every function in this module.  It
//* will be set to 0 to indicate success, and will be > 0 if an
//* error occurs.  The following table lists the possible error codes:
//*     0 : No error.
//*     1 : Out of memory
//*     2 : Memory has been corrupted!
//*     3 : Bad List Record!
//*     4 : List Record not initialized yet!
//*     5 : List is empty!
//*     6 : Item size mismatch!
//*     7 : Bad item pointer!
//*     8 : Item has zero size!
//*     9 : Item tag mismatch!
//*    10 : Already at end of list!
//*    11 : Already at start of list!
//*    12 : Bad Handle!
//*    13 : Invalid Insertion Mode!
//*/
const
  DLIST_SUCCESS                   = 0;
  DLIST_OUT_OF_MEMORY             = 1;
  DLIST_CORRUPTED                 = 2;
  DLIST_BAD                       = 3;
  DLIST_NOT_INITIALIZED           = 4;
  DLIST_EMPTY                     = 5;
  DLIST_ITEM_SIZE_WRONG           = 6;
  DLIST_BAD_ITEM_POINTER          = 7;
  DLIST_ITEM_SIZE_ZERO            = 8;
  DLIST_ITEM_TAG_WRONG            = 9;
  DLIST_END_OF_LIST               =10;
  DLIST_ALREADY_AT_START          =11;
  DLIST_BAD_HANDLE                =12;
  DLIST_INVALID_INSERTION_MODE    =13;

///* The following code is special.  It is for use with the PruneList and ForEachItem functions.  Basically, these functions
//can be thought of as "searching" a list.  They present each item in the list to a user supplied function which can then
//operate on the items.  If the user supplied function returns a non-zero error code, ForEachItem and PruneList abort and
//return an error to the caller.  This may be undesirable.  If the user supplied function used with PruneList and ForEachItem
//returns the code below, PruneList/ForEachItem will abort and return DLIST_SUCCESS.  This allows PruneList and ForEachItem
//to be used to search a list and terminate the search when the desired item is found without having to traverse the
//remaining items in the list.                                                                                                  */
#define DLIST_SEARCH_COMPLETE  0xFF

#ifdef USE_POOLMAN

//*********************************************************************/
//*                                                                   */
//*   Function Name:  CreateList                                      */
//*                                                                   */
//*   Descriptive Name: This function allocates and initializes the   */
//*                     data structures associated with a list and    */
//*                     then returns a pointer to these structures.   */
//*                                                                   */
//*   Input: CARDINAL32 InitialPoolSize - Each List gets a pool of    */
//*                                     link nodes.  When items are   */
//*                                     added to the List, a link node*/
//*                                     is removed from the pool.     */
//*                                     When an item is removed from  */
//*                                     the List, the link node used  */
//*                                     for that item is returned to  */
//*                                     the pool.  InitialPoolSize is */
//*                                     the number of link nodes to   */
//*                                     place in the pool when the    */
//*                                     pool is created.              */
//*          CARDINAL32 MaximumPoolSize - When the pool runs out of   */
//*                                     link nodes, new nodes are     */
//*                                     allocated by the pool.  When  */
//*                                     these links start being       */
//*                                     returned to the pool, the pool*/
//*                                     will grow.  This parameter    */
//*                                     puts a limit on how big the   */
//*                                     pool may grow to.  Once the   */
//*                                     pool reaches this size, any   */
//*                                     link nodes being returned to  */
//*                                     the pool will be deallocated. */
//*          CARDINAL32 PoolIncrement - When the pool runs out of link*/
//*                                   nodes and more are required,    */
//*                                   the pool will allocate one or   */
//*                                   more link nodes.  This tells the*/
//*                                   pool how many link nodes to     */
//*                                   allocate at one time.           */
//*                                                                   */
//*   Output: If Success : The function return value will be non-NULL */
//*                                                                   */
//*           If Failure : The function return value will be NULL.    */
//*                                                                   */
//*   Error Handling:  The function will only fail if it can not      */
//*                    allocate enough memory to create the new list  */
//*                    and its associated pool of link nodes.         */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
DLIST _System CreateList(CARDINAL32 InitialPoolSize,
CARDINAL32 MaximumPoolSize,
CARDINAL32 PoolIncrement);

#else

//*********************************************************************/
//*                                                                   */
//*   Function Name:  CreateList                                      */
//*                                                                   */
//*   Descriptive Name: This function allocates and initializes the   */
//*                     data structures associated with a list and    */
//*                     then returns a pointer to these structures.   */
//*                                                                   */
//*   Input: None.                                                    */
//*                                                                   */
//*   Output: If Success : The function return value will be non-NULL */
//*                                                                   */
//*           If Failure : The function return value will be NULL.    */
//*                                                                   */
//*   Error Handling:  The function will only fail if it can not      */
//*                    allocate enough memory to create the new list. */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  None.                                                   */
//*                                                                   */
//*********************************************************************/
DLIST _System CreateList( void );

#endif

//*********************************************************************/
//*                                                                   */
//*   Function Name: InsertItem                                       */
//*                                                                   */
//*   Descriptive Name:  This function inserts an item into a DLIST.  */
//*                      The item can be placed either before or      */
//*                      after the current item in the DLIST.         */
//*                                                                   */
//*   Input:  DLIST          ListToAddTo : The list to which the      */
//*                                        data item is to be         */
//*                                        added.                     */
//*           CARDINAL32    ItemSize : The size of the data item, in  */
//*                                    bytes.                         */
//*           ADDRESS       ItemLocation : The address of the data    */
//*                                        to append to the list      */
//*           TAG           ItemTag : The item tag to associate with  */
//*                                   item being appended to the list */
//*           ADDRESS TargetHandle : The item in ListToAddTo which    */
//*                                   is used to determine where      */
//*                                   the item being transferred will */
//*                                   be placed.  If this is NULL,    */
//*                                   then the current item in        */
//*                                   ListToAddTo will be used.       */
//*           Insertion_Modes InsertMode : This indicates where,      */
//*                                   relative to the item in         */
//*                                   ListToAddTo specified by        */
//*                                   Target_Handle, the item being   */
//*                                   inserted can be placed.         */
//*           BOOLEAN MakeCurrent : If TRUE, the item being inserted  */
//*                                 into ListToAddTo becomes the      */
//*                                 current item in ListToAddTo.      */
//*           CARDINAL32 *  Error : The address of a variable to hold */
//*                                 the error return code.            */
//*                                                                   */
//*   Output:  If the operation is successful, then *Error will be    */
//*            set to 0 and the function return value will be the     */
//*            handle for the item that was appended to the list.     */
//*            If the operation fails, then *Error will contain an    */
//*            error code and the function return value will be NULL. */
//*                                                                   */
//*   Error Handling: This function will fail under the following     */
//*                   conditions:                                     */
//*                       ListToAddTo does not point to a valid       */
//*                           list                                    */
//*                       ItemSize is 0                               */
//*                       ItemLocation is NULL                        */
//*                       The memory required to hold a copy of the   */
//*                           item can not be allocated.              */
//*                       The memory required to create a LINK NODE   */
//*                           can not be allocated.                   */
//*                       TargetHandle is invalid or is for an item   */
//*                           in another list.                        */
//*                   If this routine fails, an error code is returned*/
//*                   and any memory allocated by this function is    */
//*                   freed.                                          */
//*                                                                   */
//*   Side Effects: None.                                             */
//*                                                                   */
//*   Notes:  The item to add is copied to the heap to                */
//*           avoid possible conflicts with the usage of              */
//*           local variables in functions which process              */
//*           DLISTs.  However, a pointer to a local variable         */
//*           should not be appended to the DLIST.                    */
//*                                                                   */
//*           It is assumed that TargetHandle is valid, or is at least*/
//*           the address of an accessible block of storage.  If      */
//*           TargetHandle is invalid, or is not the address of an    */
//*           accessible block of storage, then a trap or exception   */
//*           may occur.                                              */
//*                                                                   */
//*           It is assumed that Error contains a valid address. It   */
//*           is also assumed that if ItemLocation is not NULL, then  */
//*           it is a valid address that can be dereferenced.  If     */
//*           these assumptions are violated, an exception or trap    */
//*           may occur.                                              */
//*                                                                   */
//*                                                                   */
//*********************************************************************/
ADDRESS _System InsertItem ( DLIST           ListToAddTo,
CARDINAL32      ItemSize,
ADDRESS         ItemLocation,
TAG             ItemTag,
ADDRESS         TargetHandle,
Insertion_Modes Insert_Mode,
BOOLEAN         MakeCurrent,
CARDINAL32 *    Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name: InsertObject                                     */
//*                                                                   */
//*   Descriptive Name:  This function inserts an object into a DLIST.*/
//*                      The object can be inserted before or after   */
//*                      the current item in the list.                */
//*                                                                   */
//*   Input:  DLIST          ListToAddTo : The list to which the      */
//*                                          data object is to be     */
//*                                          inserted.                */
//*           CARDINAL32    ItemSize : The size of the data item, in  */
//*                                    bytes.                         */
//*           ADDRESS       ItemLocation : The address of the data    */
//*                                        to append to the list      */
//*           TAG           ItemTag : The item tag to associate with  */
//*                                   the item being appended to the  */
//*                                   list                            */
//*           ADDRESS TargetHandle : The item in ListToAddTo which    */
//*                                   is used to determine where      */
//*                                   the item being transferred will */
//*                                   be placed.  If this is NULL,    */
//*                                   then the current item in        */
//*                                   ListToAddTo will be used.       */
//*           Insertion_Modes InsertMode : This indicates where,      */
//*                                   relative to the item in         */
//*                                   ListToAddTo specified by        */
//*                                   Target_Handle, the item being   */
//*                                   inserted can be placed.         */
//*           BOOLEAN MakeCurrent : If TRUE, the item being inserted  */
//*                                 into ListToAddTo becomes the      */
//*                                 current item in ListToAddTo.      */
//*           CARDINAL32 *  Error : The address of a variable to hold */
//*                                 the error return code.            */
//*                                                                   */
//*   Output:  If the operation is successful, then *Error will be    */
//*            set to 0 and the function return value will be the     */
//*            handle for the item that was appended to the list.     */
//*            If the operation fails, then *Error will contain an    */
//*            error code and the function return value will be NULL. */
//*                                                                   */
//*   Error Handling: This function will fail under the following     */
//*                   conditions:                                     */
//*                       ListToAddTo does not point to a valid       */
//*                           list                                    */
//*                       ItemSize is 0                               */
//*                       ItemLocation is NULL                        */
//*                       The memory required for a LINK NODE can not */
//*                           be allocated.                           */
//*                       TargetHandle is invalid or is for an item   */
//*                           in another list.                        */
//*                   If this routine fails, an error code is returned*/
//*                   and any memory allocated by this function is    */
//*                   freed.                                          */
//*                                                                   */
//*   Side Effects: None.                                             */
//*                                                                   */
//*   Notes:  The item to insert is NOT copied to the heap.  Instead, */
//*           the location of the item is stored in the list.  This   */
//*           is the major difference between InsertObject and        */
//*           InsertItem.  InsertItem allocates memory on the heap,   */
//*           copies the item to the memory it allocated, and stores  */
//*           the address of the memory it allocated in the list.     */
//*           InsertObject stores the address provided by the user.   */
//*                                                                   */
//*           It is assumed that TargetHandle is valid, or is at least*/
//*           the address of an accessible block of storage.  If      */
//*           TargetHandle is invalid, or is not the address of an    */
//*           accessible block of storage, then a trap or exception   */
//*           may occur.                                              */
//*                                                                   */
//*           It is assumed that Error contains a valid address. It   */
//*           is also assumed that if ItemLocation is not NULL, then  */
//*           it is a valid address that can be dereferenced.  If     */
//*           these assumptions are violated, an exception or trap    */
//*           may occur.                                              */
//*                                                                   */
//*                                                                   */
//*********************************************************************/
ADDRESS _System InsertObject ( DLIST           ListToAddTo,
CARDINAL32      ItemSize,
ADDRESS         ItemLocation,
TAG             ItemTag,
ADDRESS         TargetHandle,
Insertion_Modes Insert_Mode,
BOOLEAN         MakeCurrent,
CARDINAL32 *    Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  DeleteItem                                      */
//*                                                                   */
//*   Descriptive Name:  This function removes the specified item from*/
//*                      the list and optionally frees the memory     */
//*                      associated with it.                          */
//*                                                                   */
//*   Input:  DLIST       ListToDeleteFrom : The list whose current   */
//*                                         item is to be deleted.    */
//*           BOOLEAN    FreeMemory : If TRUE, then the memory        */
//*                                   associated with the current     */
//*                                   item will be freed.  If FALSE   */
//*                                   then the current item will be   */
//*                                   removed from the list but its   */
//*                                   memory will not be freed.       */
//*           ADDRESS Handle : The handle of the item to get.  This   */
//*                            handle must be of an item which resides*/
//*                            in ListToDeleteFrom, or NULL.  If      */
//*                            NULL is used, then the current item    */
//*                            in ListToDeleteFrom will be deleted.   */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                 the error return code.            */
//*                                                                   */
//*   Output:  If the operation is successful, then *Error will be    */
//*            set to 0.  If the operation fails, then *Error will    */
//*            contain an error code.                                 */
//*                                                                   */
//*   Error Handling: This function will fail if ListToDeleteFrom is  */
//*                   not a valid list, or if ListToDeleteFrom is     */
//*                   empty, or if Handle is invalid.                 */
//*                   If this routine fails, an error code is returned*/
//*                   in *Error.                                      */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  Items in a list can be accessed in two ways:  A copy of */
//*           the item can be obtained using GetItem and its related  */
//*           calls, or a pointer to the item can be obtained using   */
//*           GetObject and its related calls.  If you have a copy of */
//*           the data and wish to remove the item from the list, set */
//*           FreeMemory to TRUE.  This will remove the item from the */
//*           list and deallocate the memory used to hold it.  If you */
//*           have a pointer to the item in the list (from one of the */
//*           GetObject style functions) and wish to remove the item  */
//*           from the list, set FreeMemory to FALSE.  This removes   */
//*           the item from the list without freeing its memory, so   */
//*           that the pointer obtained with the GetObject style      */
//*           functions is still useable.                             */
//*                                                                   */
//*           It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*           It is assumed that Handle is valid, or is at least the  */
//*           address of an accessible block of storage.  If Handle   */
//*           is invalid, or is not the address of an accessible block*/
//*           of storage, then a trap or exception may occur.         */
//*           NOTE: For this function, NULL is considered a valid     */
//*                 handle which refers to the current item in        */
//*                 ListToDeleteFrom.                                 */
//*                                                                   */
//*           This function does not alter which item is the current  */
//*           item in the list, unless the handle specified belongs   */
//*           to the current item in the list, in which case the      */
//*           item following the current item becomes the current     */
//*           item in the list.  If there is no item following the    */
//*           current item in the list, then the item preceeding the  */
//*           current item will become the current item in the list.  */
//*                                                                   */
//*********************************************************************/
void _System DeleteItem (DLIST        ListToDeleteFrom,
BOOLEAN      FreeMemory,
ADDRESS      Handle,
CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  DeleteAllItems                                  */
//*                                                                   */
//*   Descriptive Name:  This function deletes all of the items in the*/
//*                      specified list and optionally frees the      */
//*                      memory associated with each item deleted.    */
//*                                                                   */
//*   Input:  DLIST       ListToDeleteFrom : The list whose items     */
//*                                          are to be deleted.       */
//*           BOOLEAN    FreeMemory : If TRUE, then the memory        */
//*                                   associated with each item in the*/
//*                                   list will be freed.  If FALSE   */
//*                                   then the each item will be      */
//*                                   removed from the list but its   */
//*                                   memory will not be freed.       */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                 the error return code.            */
//*                                                                   */
//*   Output:  If the operation is successful, then *Error will be    */
//*            set to 0.  If the operation fails, then *Error will    */
//*            contain an error code.                                 */
//*                                                                   */
//*   Error Handling: This function will fail if ListToDeleteFrom is  */
//*                   not a valid list, or if ListToDeleteFrom is     */
//*                   empty.                                          */
//*                   If this routine fails, an error code is returned*/
//*                   in *Error.                                      */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  Items in a list can be accessed in two ways:  A copy of */
//*           the item can be obtained using GetItem and its related  */
//*           calls, or a pointer to the item can be obtained using   */
//*           GetObject and its related calls.  If you have a copy of */
//*           the data and wish to remove the item from the list, set */
//*           FreeMemory to TRUE.  This will remove the item from the */
//*           list and deallocate the memory used to hold it.  If you */
//*           have a pointer to the item in the list (from one of the */
//*           GetObject style functions) and wish to remove the item  */
//*           from the list, set FreeMemory to FALSE.  This removes   */
//*           the item from the list without freeing its memory, so   */
//*           that the pointer obtained with the GetObject style      */
//*           functions is still useable.                             */
//*                                                                   */
//*           It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
void _System DeleteAllItems (DLIST        ListToDeleteFrom,
BOOLEAN      FreeMemory,
CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  GetItem                                         */
//*                                                                   */
//*   Descriptive Name:  This function copies the specified item in   */
//*                      the list to a buffer provided by the caller. */
//*                                                                   */
//*   Input:  DLIST   ListToGetItemFrom : The list whose current item */
//*                                      is to be copied and returned */
//*                                      to the caller.               */
//*           CARDINAL32 ItemSize : What the caller thinks the size of*/
//*                               the current item is.                */
//*           ADDRESS     ItemLocation : This is the location of the  */
//*                                      buffer into which the current*/
//*                                      item is to be copied.        */
//*           TAG     ItemTag : What the caller thinks the item tag   */
//*                             of the current item is.               */
//*           ADDRESS Handle : The handle of the item to get.  This   */
//*                            handle must be of an item which resides*/
//*                            in ListToGetItemFrom, or NULL.  If     */
//*                            NULL, then the current item in the list*/
//*                            will be used.                          */
//*           BOOLEAN MakeCurrent : If TRUE, the item to get will     */
//*                                 become the current item in the    */
//*                                 list.                             */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                              the error return code.               */
//*                                                                   */
//*   Output:  If Successful :                                        */
//*                 *Error will be set to 0.                          */
//*                 The buffer at ItemLocation will contain a copy of */
//*                    the current item from ListToGetItemFrom.       */
//*            If Failure :                                           */
//*                 *Error will contain an error code.                */
//*                                                                   */
//*                                                                   */
//*   Error Handling: This function will fail under any of the        */
//*                   following conditions:                           */
//*                         ListToGetItemFrom is not a valid list     */
//*                         ItemSize does not match the size of the   */
//*                             current item in the list              */
//*                         ItemLocation is NULL                      */
//*                         ItemTag does not match the item tag       */
//*                             of the current item in the list       */
//*                         Handle is invalid, or is for an item      */
//*                             which is not in ListToGetItemFrom     */
//*                   If any of these conditions occur, *Error will   */
//*                   contain a non-zero error code.                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. It   */
//*           is also assumed that if ItemLocation is not NULL, then  */
//*           it is a valid address that can be dereferenced.  If     */
//*           these assumptions are violated, an exception or trap    */
//*           may occur.                                              */
//*                                                                   */
//*           It is assumed that Handle is valid, or is at least the  */
//*           address of an accessible block of storage.  If Handle   */
//*           is invalid, or is not the address of an accessible block*/
//*           of storage, then a trap or exception may occur.         */
//*           NOTE: For this function, NULL is considered a valid     */
//*                 handle corresponding to the current item in the   */
//*                 list.                                             */
//*                                                                   */
//*           This function does not alter which item is the current  */
//*           item in the list.                                       */
//*                                                                   */
//*********************************************************************/
void _System GetItem( DLIST          ListToGetItemFrom,
CARDINAL32     ItemSize,
ADDRESS        ItemLocation,
TAG            ItemTag,
ADDRESS        Handle,
BOOLEAN        MakeCurrent,
CARDINAL32 *   Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  GetNextItem                                     */
//*                                                                   */
//*   Descriptive Name:  This function advances the current item      */
//*                      pointer and then copies the current item in  */
//*                      the list to a buffer provided by the caller. */
//*                                                                   */
//*   Input:  DLIST   ListToGetItemFrom : The list whose current item */
//*                                      is to be copied and returned */
//*                                      to the caller.               */
//*           CARDINAL32 ItemSize : What the caller thinks the size of*/
//*                                 the current item is.              */
//*           ADDRESS     ItemLocation : This is the location of the  */
//*                                      buffer into which the current*/
//*                                      item is to be copied.        */
//*           TAG     ItemTag : What the caller thinks the item tag   */
//*                             of the current item is.               */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code.             */
//*                                                                   */
//*   Output:  If Successful :                                        */
//*                 *Error will be set to 0.                          */
//*                 The buffer at ItemLocation will contain a copy of */
//*                    the current item from ListToGetItemFrom.       */
//*            If Failure :                                           */
//*                 *Error will contain an error code.                */
//*                 The current item pointer will NOT be advanced.    */
//*                     The current item in the list will be the same */
//*                     as before the call to this function.          */
//*                                                                   */
//*   Error Handling: This function will fail under any of the        */
//*                   following conditions:                           */
//*                         ListToGetItemFrom is not a valid list     */
//*                         ItemSize does not match the size of the   */
//*                             current item in the list              */
//*                         ItemLocation is NULL                      */
//*                         ItemTag does not match the item tag       */
//*                             of the current item in the list       */
//*                         The current item in the list before this  */
//*                             function is called is the last item   */
//*                             item in the list.                     */
//*                   If any of these conditions occur, *Error will   */
//*                   contain a non-zero error code.                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. It   */
//*           is also assumed that if ItemLocation is not NULL, then  */
//*           it is a valid address that can be dereferenced.  If     */
//*           these assumptions are violated, an exception or trap    */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
void _System GetNextItem( DLIST          ListToGetItemFrom,
CARDINAL32     ItemSize,
ADDRESS        ItemLocation,
TAG            ItemTag,
CARDINAL32 *   Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  GetPreviousItem                                 */
//*                                                                   */
//*   Descriptive Name:  This function makes the previous item in the */
//*                      list the current item in the list and then   */
//*                      copies that item to a buffer provided by the */
//*                      user.                                        */
//*                                                                   */
//*   Input:  DLIST   ListToGetItemFrom : The list whose current item */
//*                                      is to be copied and returned */
//*                                      to the caller.               */
//*           CARDINAL32 ItemSize : What the caller thinks the size of*/
//*                                 the current item is.              */
//*           ADDRESS    ItemLocation : This is the location of the   */
//*                                      buffer into which the current*/
//*                                      item is to be copied.        */
//*           TAG     ItemTag : What the caller thinks the item tag   */
//*                             of the current item is.               */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code.             */
//*                                                                   */
//*   Output:  If Successful :                                        */
//*                 *Error will be set to 0.                          */
//*                 The buffer at ItemLocation will contain a copy of */
//*                    the current item from ListToGetItemFrom.       */
//*            If Failure :                                           */
//*                 *Error will contain an error code.                */
//*                 The current item pointer will NOT be advanced.    */
//*                     The current item in the list will be the same */
//*                     as before the call to this function.          */
//*                                                                   */
//*   Error Handling: This function will fail under any of the        */
//*                   following conditions:                           */
//*                         ListToGetItemFrom is not a valid list     */
//*                         ItemSize does not match the size of the   */
//*                             current item in the list              */
//*                         ItemLocation is NULL                      */
//*                         ItemTag does not match the item tag       */
//*                             of the current item in the list       */
//*                         The current item in the list before this  */
//*                             function is called is the last item   */
//*                             item in the list.                     */
//*                   If any of these conditions occur, *Error will   */
//*                   contain a non-zero error code.                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. It   */
//*           is also assumed that if ItemLocation is not NULL, then  */
//*           it is a valid address that can be dereferenced.  If     */
//*           these assumptions are violated, an exception or trap    */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
void _System GetPreviousItem( DLIST          ListToGetItemFrom,
CARDINAL32     ItemSize,
ADDRESS        ItemLocation,
TAG            ItemTag,
CARDINAL32 *   Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  GetObject                                       */
//*                                                                   */
//*   Descriptive Name:  This function returns the address of the data*/
//*                      associated with the specified item in the    */
//*                      list.                                        */
//*                                                                   */
//*   Input:  DLIST   ListToGetItemFrom : The list whose current item */
//*                                      is to have its address       */
//*                                      returned to the caller.      */
//*           CARDINAL32 ItemSize : What the caller thinks the size of*/
//*                               the current item is.                */
//*           TAG     ItemTag : What the caller thinks the item tag   */
//*                             of the current item is.               */
//*           ADDRESS Handle : The handle of the item to get.  This   */
//*                            handle must be of an item which resides*/
//*                            in ListToGetItemFrom, or NULL.  If     */
//*                            NULL, then the current item in the list*/
//*           BOOLEAN MakeCurrent : If TRUE, the item to get will     */
//*                                 become the current item in the    */
//*                                 list.                             */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code.             */
//*                                                                   */
//*   Output:  If Successful :                                        */
//*                 *Error will be set to 0.                          */
//*                 The function return value will be the address of  */
//*                 the data associated with the current item in the  */
//*                 list.                                             */
//*            If Failure :                                           */
//*                 *Error will contain an error code.                */
//*                 The function return value will be NULL.           */
//*                                                                   */
//*   Error Handling: This function will fail under any of the        */
//*                   following conditions:                           */
//*                         ListToGetItemFrom is not a valid list     */
//*                         ItemSize does not match the size of the   */
//*                             current item in the list              */
//*                         ItemTag does not match the item tag       */
//*                             of the current item in the list       */
//*                         Handle is invalid, or is for an item      */
//*                             which is not in ListToGetItemFrom     */
//*                   If any of these conditions occur, *Error will   */
//*                   contain a non-zero error code.                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  The user should not free the memory associated with     */
//*           the address returned by this function as the object is  */
//*           still in the list.                                      */
//*                                                                   */
//*           It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap may   */
//*           occur.                                                  */
//*                                                                   */
//*           It is assumed that Handle is valid, or is at least the  */
//*           address of an accessible block of storage.  If Handle   */
//*           is invalid, or is not the address of an accessible block*/
//*           of storage, then a trap or exception may occur.         */
//*           NOTE: For this function, NULL is considered a valid     */
//*                 handle designating the current item in the list.  */
//*                                                                   */
//*           This function does not alter which item is the current  */
//*           item in the list.                                       */
//*                                                                   */
//*********************************************************************/
ADDRESS _System GetObject( DLIST          ListToGetItemFrom,
CARDINAL32     ItemSize,
TAG            ItemTag,
ADDRESS        Handle,
BOOLEAN        MakeCurrent,
CARDINAL32 *   Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  GetNextObject                                   */
//*                                                                   */
//*   Descriptive Name:  This function advances the current item      */
//*                      pointer and then returns the address of the  */
//*                      data associated with the current item in the */
//*                      list.                                        */
//*                                                                   */
//*   Input:  DLIST   ListToGetItemFrom : The list whose current item */
//*                                      is to be copied and returned */
//*                                      to the caller.               */
//*           CARDINAL32 ItemSize : What the caller thinks the size of*/
//*                                 the current item is.              */
//*           TAG     ItemTag : What the caller thinks the item tag   */
//*                             of the current item is.               */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code.             */
//*                                                                   */
//*   Output:  If Successful :                                        */
//*                 *Error will be set to 0.                          */
//*                 The function return value will be the address of  */
//*                 the data associated with the current item in the  */
//*                 list.                                             */
//*            If Failure :                                           */
//*                 *Error will contain an error code.                */
//*                 The function return value will be NULL.           */
//*                 The current item pointer will NOT be advanced.    */
//*                     The current item in the list will be the same */
//*                     as before the call to this function.          */
//*                                                                   */
//*   Error Handling: This function will fail under any of the        */
//*                   following conditions:                           */
//*                         ListToGetItemFrom is not a valid list     */
//*                         ItemSize does not match the size of the   */
//*                             current item in the list              */
//*                         ItemTag does not match the item tag       */
//*                             of the current item in the list       */
//*                         The current item in the list before this  */
//*                             function is called is the last item   */
//*                             item in the list.                     */
//*                   If any of these conditions occur, *Error will   */
//*                   contain a non-zero error code.                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  The user should not free the memory associated with     */
//*           the address returned by this function as the object is  */
//*           still in the list.                                      */
//*                                                                   */
//*           It is assumed that Error contains a valid address. If   */
//*           this assumption are violated, an exception or trap may  */
//*           occur.                                                  */
//*                                                                   */
//*********************************************************************/
ADDRESS _System GetNextObject( DLIST          ListToGetItemFrom,
CARDINAL32     ItemSize,
TAG            ItemTag,
CARDINAL32 *   Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  GetPreviousObject                               */
//*                                                                   */
//*   Descriptive Name:  This function makes the previous item in the */
//*                      list the current item and then returns the   */
//*                      address of the data associated with the      */
//*                      current item in the list.                    */
//*                                                                   */
//*   Input:  DLIST   ListToGetItemFrom : The list whose current item */
//*                                      is to be copied and returned */
//*                                      to the caller.               */
//*           CARDINAL32 ItemSize : What the caller thinks the size of*/
//*                                 the current item is.              */
//*           TAG     ItemTag : What the caller thinks the item tag   */
//*                             of the current item is.               */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code.             */
//*                                                                   */
//*   Output:  If Successful :                                        */
//*                 *Error will be set to 0.                          */
//*                 The function return value will be the address of  */
//*                 the data associated with the current item in the  */
//*                 list.                                             */
//*            If Failure :                                           */
//*                 *Error will contain an error code.                */
//*                 The function return value will be NULL.           */
//*                 The current item pointer will NOT be advanced.    */
//*                     The current item in the list will be the same */
//*                     as before the call to this function.          */
//*                                                                   */
//*   Error Handling: This function will fail under any of the        */
//*                   following conditions:                           */
//*                         ListToGetItemFrom is not a valid list     */
//*                         ItemSize does not match the size of the   */
//*                             current item in the list              */
//*                         ItemTag does not match the item tag       */
//*                             of the current item in the list       */
//*                         The current item in the list before this  */
//*                             function is called is the last item   */
//*                             item in the list.                     */
//*                   If any of these conditions occur, *Error will   */
//*                   contain a non-zero error code.                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  The user should not free the memory associated with     */
//*           the address returned by this function as the object is  */
//*           still in the list.                                      */
//*                                                                   */
//*           It is assumed that Error contains a valid address. If   */
//*           this assumption are violated, an exception or trap may  */
//*           occur.                                                  */
//*                                                                   */
//*********************************************************************/
ADDRESS _System GetPreviousObject( DLIST          ListToGetItemFrom,
CARDINAL32     ItemSize,
TAG            ItemTag,
CARDINAL32 *   Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  ExtractItem                                     */
//*                                                                   */
//*   Descriptive Name:  This function copies the specified item in   */
//*                      the list to a buffer provided by the caller  */
//*                      and removes the item from the list.          */
//*                                                                   */
//*   Input:  DLIST   ListToGetItemFrom : The list whose current item */
//*                                      is to be copied and returned */
//*                                      to the caller.               */
//*           CARDINAL32 ItemSize : What the caller thinks the size of*/
//*                                 the current item is.              */
//*           ADDRESS     ItemLocation : This is the location of the  */
//*                                      buffer into which the current*/
//*                                      item is to be copied.        */
//*           TAG     ItemTag : What the caller thinks the item tag   */
//*                             of the current item is.               */
//*           ADDRESS Handle : The handle of the item to get.  This   */
//*                            handle must be of an item which resides*/
//*                            in ListToGetItemFrom, or NULL.  If     */
//*                            NULL, then the current item in the list*/
//*                            will be used.                          */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code.             */
//*                                                                   */
//*   Output:  If Successful :                                        */
//*                 *Error will be set to 0.                          */
//*                 The buffer at ItemLocation will contain a copy of */
//*                    the current item from ListToGetItemFrom.       */
//*                 The item will have been removed from the list and */
//*                    its memory deallocated.                        */
//*            If Failure :                                           */
//*                 *Error will contain an error code.                */
//*                                                                   */
//*   Error Handling: This function will fail under any of the        */
//*                   following conditions:                           */
//*                         ListToGetItemFrom is not a valid list     */
//*                         ItemSize does not match the size of the   */
//*                             current item in the list              */
//*                         ItemLocation is NULL                      */
//*                         ItemTag does not match the item tag       */
//*                             of the current item in the list       */
//*                         Handle is invalid, or is for an item      */
//*                             which is not in ListToGetItemFrom     */
//*                   If any of these conditions occur, *Error will   */
//*                   contain a non-zero error code.                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. It   */
//*           is also assumed that if ItemLocation is not NULL, then  */
//*           it is a valid address that can be dereferenced.  If     */
//*           these assumptions are violated, an exception or trap    */
//*           may occur.                                              */
//*                                                                   */
//*           It is assumed that Handle is valid, or is at least the  */
//*           address of an accessible block of storage.  If Handle   */
//*           is invalid, or is not the address of an accessible block*/
//*           of storage, then a trap or exception may occur.         */
//*           NOTE: For this function, NULL is considered a valid     */
//*                 handle which refers to the current item in the    */
//*                 list.                                             */
//*                                                                   */
//*           This function does not alter which item is the current  */
//*           item in the list, unless the handle specified belongs   */
//*           to the current item in the list, in which case the      */
//*           item following the current item becomes the current     */
//*           item in the list.  If there is no item following the    */
//*           current item in the list, then the item preceeding the  */
//*           current item will become the current item in the list.  */
//*                                                                   */
//*********************************************************************/
void _System ExtractItem( DLIST          ListToGetItemFrom,
CARDINAL32     ItemSize,
ADDRESS        ItemLocation,
TAG            ItemTag,
ADDRESS        Handle,
CARDINAL32 *   Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  ExtractObject                                   */
//*                                                                   */
//*   Descriptive Name:  This function returns the address of the data*/
//*                      associated with the specified item in the    */
//*                      list and then removes that item from the list*/
//*                                                                   */
//*   Input:  DLIST   ListToGetItemFrom : The list whose current item */
//*                                      is to be copied and returned */
//*                                      to the caller.               */
//*           CARDINAL32 ItemSize : What the caller thinks the size of*/
//*                                 the current item is.              */
//*           TAG     ItemTag : What the caller thinks the item tag   */
//*                             of the current item is.               */
//*           ADDRESS Handle : The handle of the item to get.  This   */
//*                            handle must be of an item which resides*/
//*                            in ListToGetItemFrom, or NULL.  If     */
//*                            NULL, then the current item in the     */
//*                            list will be used.                     */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code.             */
//*                                                                   */
//*   Output:  If Successful :                                        */
//*                 *Error will be set to 0.                          */
//*                 The function return value will be the address of  */
//*                 the data associated with the current item in the  */
//*                 list.                                             */
//*                 The current item is removed from the list.        */
//*            If Failure :                                           */
//*                 *Error will contain an error code.                */
//*                 The function return value will be NULL.           */
//*                                                                   */
//*   Error Handling: This function will fail under any of the        */
//*                   following conditions:                           */
//*                         ListToGetItemFrom is not a valid list     */
//*                         ItemSize does not match the size of the   */
//*                             current item in the list              */
//*                         ItemTag does not match the item tag       */
//*                             of the current item in the list       */
//*                         Handle is invalid, or is for an item      */
//*                             which is not in ListToGetItemFrom     */
//*                   If any of these conditions occur, *Error will   */
//*                   contain a non-zero error code.                  */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  The user is responsible for the memory associated with  */
//*           the address returned by this function since this        */
//*           function removes that object from the list.  This means */
//*           that, when the user is through with the object, they    */
//*           should free it.                                         */
//*                                                                   */
//*           It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap may   */
//*           occur.                                                  */
//*                                                                   */
//*           It is assumed that Handle is valid, or is at least the  */
//*           address of an accessible block of storage.  If Handle   */
//*           is invalid, or is not the address of an accessible block*/
//*           of storage, then a trap or exception may occur.         */
//*           NOTE: For this function, NULL is considered a valid     */
//*                 handle which refers to the current item in the    */
//*                 list.                                             */
//*                                                                   */
//*           This function does not alter which item is the current  */
//*           item in the list, unless the handle specified belongs   */
//*           to the current item in the list, in which case the      */
//*           item following the current item becomes the current     */
//*           item in the list.  If there is no item following the    */
//*           current item in the list, then the item preceeding the  */
//*           current item will become the current item in the list.  */
//*                                                                   */
//*********************************************************************/
ADDRESS _System ExtractObject( DLIST          ListToGetItemFrom,
CARDINAL32     ItemSize,
TAG            ItemTag,
ADDRESS        Handle,
CARDINAL32 *   Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  ReplaceItem                                     */
//*                                                                   */
//*   Descriptive Name:  This function replaces the specified item in */
//*                      the list with the one provided as its        */
//*                      argument.                                    */
//*                                                                   */
//*   Input: DLIST   ListToReplaceItemIn : The list whose current item*/
//*                                       is to be replaced           */
//*          CARDINAL32 ItemSize : The size, in bytes, of the         */
//*                              replacement item                     */
//*          ADDRESS     ItemLocation : The address of the replacement*/
//*                                     item                          */
//*          TAG     ItemTag : The item tag that the user wishes to   */
//*                            associate with the replacement item    */
//*          ADDRESS Handle : The handle of the item to get.  This    */
//*                           handle must be of an item which resides */
//*                           in ListToGetItemFrom, or NULL.  If NULL */
//*                           then the current item in the list will  */
//*                           used.                                   */
//*          BOOLEAN MakeCurrent : If TRUE, the item to get will      */
//*                                become the current item in the     */
//*                                list.                              */
//*          CARDINAL32 * Error : The address of a variable to hold   */
//*                               the error return code               */
//*                                                                   */
//*   Output:  If Successful then *Error will be set to 0.            */
//*            If Unsuccessful, then *Error will be set to a non-zero */
//*              error code.                                          */
//*                                                                   */
//*   Error Handling:  This function will fail under the following    */
//*                    conditions:                                    */
//*                         ListToReplaceItemIn is empty              */
//*                         ItemSize is 0                             */
//*                         ItemLocation is NULL                      */
//*                         The memory required can not be allocated. */
//*                         Handle is invalid, or is for an item      */
//*                             which is not in ListToGetItemFrom     */
//*                    If any of these conditions occurs, *Error      */
//*                    will contain a non-zero error code.            */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. It   */
//*           is also assumed that if ItemLocation is not NULL, then  */
//*           it is a valid address that can be dereferenced.  If     */
//*           these assumptions are violated, an exception or trap    */
//*           may occur.                                              */
//*                                                                   */
//*           It is assumed that Handle is valid, or is at least the  */
//*           address of an accessible block of storage.  If Handle   */
//*           is invalid, or is not the address of an accessible block*/
//*           of storage, then a trap or exception may occur.         */
//*           NOTE: For this function, NULL is a valid handle which   */
//*                 refers to the current item in the list.           */
//*                                                                   */
//*           This function does not alter which item is the current  */
//*           item in the list.                                       */
//*                                                                   */
//*********************************************************************/
void _System ReplaceItem( DLIST         ListToReplaceItemIn,
CARDINAL32    ItemSize,
ADDRESS       ItemLocation,
TAG           ItemTag,
ADDRESS       Handle,
BOOLEAN       MakeCurrent,
CARDINAL32 *  Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name: ReplaceObject                                    */
//*                                                                   */
//*   Descriptive Name:  This function replaces the specified object  */
//*                      in the list with the one provided as its     */
//*                      argument.                                    */
//*                                                                   */
//*   Input: DLIST   ListToReplaceItemIn : The list whose current     */
//*                                       object is to be replaced    */
//*          CARDINAL32 ItemSize : The size, in bytes, of the         */
//*                              replacement object                   */
//*          ADDRESS     ItemLocation : The address of the replacement*/
//*                                     item                          */
//*          TAG     ItemTag : The item tag that the user wishes to   */
//*                            associate with the replacement item    */
//*          ADDRESS Handle : The handle of the item to get.  This    */
//*                           handle must be of an item which resides */
//*                           in ListToGetItemFrom, or NULL.  If NULL */
//*                           then the current item in the list will  */
//*                           be used.                                */
//*          BOOLEAN MakeCurrent : If TRUE, the item to get will      */
//*                                become the current item in the     */
//*                                list.                              */
//*          CARDINAL32 * Error : The address of a variable to hold   */
//*                               the error return code               */
//*                                                                   */
//*   Output:  If Successful then *Error will be set to 0 and the     */
//*              return value of the function will be the address     */
//*              of the object that was replaced.                     */
//*            If Unsuccessful, then *Error will be set to a non-zero */
//*              error code and the function return value will be     */
//*              NULL.                                                */
//*                                                                   */
//*   Error Handling:  This function will fail under the following    */
//*                    conditions:                                    */
//*                         ListToReplaceItemIn is empty              */
//*                         ItemSize is 0                             */
//*                         ItemLocation is NULL                      */
//*                         The memory required can not be allocated. */
//*                         Handle is invalid, or is for an item      */
//*                             which is not in ListToGetItemFrom     */
//*                    If any of these conditions occurs, *Error      */
//*                    will contain a non-zero error code.            */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  The user is responsible for the memory associated with  */
//*           the object returned by this function as that object is  */
//*           removed from the list.  This means that, when the user  */
//*           is through with the object returned by this function,   */
//*           they should free it.                                    */
//*                                                                   */
//*           It is assumed that Error contains a valid address. It   */
//*           is also assumed that if ItemLocation is not NULL, then  */
//*           it is a valid address that can be dereferenced.  If     */
//*           these assumptions are violated, an exception or trap    */
//*           may occur.                                              */
//*                                                                   */
//*           It is assumed that Handle is valid, or is at least the  */
//*           address of an accessible block of storage.  If Handle   */
//*           is invalid, or is not the address of an accessible block*/
//*           of storage, then a trap or exception may occur.         */
//*           NOTE: For this function, NULL is a valid handle for the */
//*                 current item in the list.                         */
//*                                                                   */
//*           This function does not alter which item is the current  */
//*           item in the list.                                       */
//*                                                                   */
//*********************************************************************/
ADDRESS _System ReplaceObject( DLIST         ListToReplaceItemIn,
CARDINAL32 *  ItemSize,             /* On input - size of new object.  On return = size of old object. */
ADDRESS       ItemLocation,
TAG        *  ItemTag,              /* On input - TAG of new object.  On return = TAG of old object. */
ADDRESS       Handle,
BOOLEAN       MakeCurrent,
CARDINAL32 *  Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  GetTag                                          */
//*                                                                   */
//*   Descriptive Name:  This function returns the item tag associated*/
//*                      with the current item in the list.           */
//*                                                                   */
//*   Input:  DLIST   ListToGetTagFrom : The list from which the item */
//*                                     tag of the current item is to */
//*                                     be returned                   */
//*           ADDRESS Handle : The handle of the item whose TAG and   */
//*                            size we are to get.  This handle must  */
//*                            be of an item which resides in         */
//*                            in ListToGetTagFrom, or NULL.  If NULL */
//*                            then the current item in the list will */
//*                            be used.                               */
//*           CARDINAL32 * ItemSize : The size, in bytes, of the      */
//*                                   current item in the list.       */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, the function returns the item tag & size*/
//*               associated with the current item in ListToGetTagFrom*/
//*               and *Error is set to 0.                             */
//*            If unsuccessful, the function returns 0 and *Error is  */
//*               set to a non-zero error code.                       */
//*                                                                   */
//*   Error Handling: This function will fail if ListToGetTagFrom is  */
//*                   not a valid list or is an empty list.  In either*/
//*                   of these cases, *Error is set to a non-zero     */
//*                   error code.                                     */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*                                                                   */
//*********************************************************************/
TAG _System GetTag( DLIST  ListToGetTagFrom,
ADDRESS Handle,
CARDINAL32 * ItemSize,
CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  GetHandle                                       */
//*                                                                   */
//*   Descriptive Name:  This function returns a handle for the       */
//*                      current item in the list.  This handle is    */
//*                      then associated with that item regardless of */
//*                      its position in the list.  This handle can be*/
//*                      used to make its associated item the current */
//*                      item in the list.                            */
//*                                                                   */
//*   Input:  DLIST   ListToGetHandleFrom : The list from which a     */
//*                                        handle is needed.          */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, the function returns a handle for the   */
//*               the current item in ListToGetHandleFrom, and *Error */
//*               is set to 0.                                        */
//*            If unsuccessful, the function returns 0 and *Error is  */
//*               set to a non-zero error code.                       */
//*                                                                   */
//*   Error Handling: This function will fail if ListToGetHandleFrom  */
//*                   is not a valid list or is an empty list.  In    */
//*                   either of these cases, *Error is set to a       */
//*                   non-zero error code.                            */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*           The handle returned is a pointer to an internal         */
//*           structure within the list.  If the item associated      */
//*           with this handle is removed from the list, the handle   */
//*           will be invalid and should not be used as the internal  */
//*           structure it points to will nolonger exist!             */
//*                                                                   */
//*********************************************************************/
ADDRESS _System GetHandle ( DLIST ListToGetHandleFrom, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  GetListSize                                     */
//*                                                                   */
//*   Descriptive Name:  This function returns the number of items in */
//*                      a list.                                      */
//*                                                                   */
//*   Input:  DLIST   ListToGetSizeOf : The list whose size we wish to*/
//*                                    know                           */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, the function returns the a count of the */
//*               number of items in the list, and *Error is set to 0.*/
//*            If unsuccessful, the function returns 0 and *Error is  */
//*               set to a non-zero error code.                       */
//*                                                                   */
//*   Error Handling: This function will fail if ListToGetSizeOf is   */
//*                   not a valid list.  If this happens, then *Error */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
CARDINAL32 _System GetListSize( DLIST ListToGetSizeOf, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  ListEmpty                                       */
//*                                                                   */
//*   Descriptive Name:  This function returns TRUE if the            */
//*                      specified list is empty, otherwise it returns*/
//*                      FALSE.                                       */
//*                                                                   */
//*   Input:  DLIST       ListToCheck : The list to check to see if it*/
//*                                    is empty                       */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, the function returns TRUE if the        */
//*               number of items in the list is 0, otherwise it      */
//*               returns FALSE.  Also, *Error is set to 0.           */
//*            If unsuccessful, the function returns TRUE and         */
//*               *Error is set to a non-zero error code.             */
//*                                                                   */
//*   Error Handling: This function will fail if ListToCheck is not   */
//*                   a valid list.  If this happens, then *Error     */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
BOOLEAN _System ListEmpty( DLIST ListToCheck, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  AtEndOfList                                     */
//*                                                                   */
//*   Descriptive Name:  This function returns TRUE if the            */
//*                      current item in the list is the last item    */
//*                      in the list.  Returns FALSE otherwise.       */
//*                                                                   */
//*   Input:  DLIST       ListToCheck : The list to check.            */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, the function returns TRUE if the        */
//*               current item in the list is the last item in the    */
//*               list.  If it is not the last item in the list,      */
//*               FALSE is returned.  *Error_Code is set to           */
//*               DLIST_SUCCESS.                                      */
//*            If unsuccessful, the function returns FALSE and        */
//*               *Error is set to a non-zero error code.             */
//*                                                                   */
//*   Error Handling: This function will fail if ListToCheck is not   */
//*                   a valid list.  If this happens, then *Error     */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
BOOLEAN _System AtEndOfList( DLIST ListToCheck, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  AtStartOfList                                   */
//*                                                                   */
//*   Descriptive Name:  This function returns TRUE if the            */
//*                      current item in the list is the first item   */
//*                      in the list.  Returns FALSE otherwise.       */
//*                                                                   */
//*   Input:  DLIST       ListToCheck : The list to check.            */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, the function returns TRUE if the        */
//*               current item in the list is the first item in the   */
//*               list.  If it is not the first item in the list,     */
//*               FALSE is returned.  *Error_Code is set to           */
//*               DLIST_SUCCESS.                                      */
//*            If unsuccessful, the function returns FALSE and        */
//*               *Error is set to a non-zero error code.             */
//*                                                                   */
//*   Error Handling: This function will fail if ListToCheck is not   */
//*                   a valid list.  If this happens, then *Error     */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
BOOLEAN _System AtStartOfList( DLIST ListToCheck, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  DestroyList                                     */
//*                                                                   */
//*   Descriptive Name:  This function releases the memory associated */
//*                      with the internal data structures of a DLIST.*/
//*                      Once a DLIST has been eliminated by this     */
//*                      function, it must be reinitialized before it */
//*                      can be used again.                           */
//*                                                                   */
//*   Input:  DLIST       ListToDestroy : The list to be eliminated   */
//*                                      from memory.                 */
//*           BOOLEAN FreeItemMemory : If TRUE, all items in the list */
//*                                    will be freed.  If FALSE, all  */
//*                                    items in the list are not      */
//*                                    freed, only the list structures*/
//*                                    associated with them are.      */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, *Error will be set to 0.                */
//*            If unsuccessful, *Error will be set to a non-zero error*/
//*               code.                                               */
//*                                                                   */
//*   Error Handling: This function will fail if ListToDestroy is not */
//*                   a valid list.  If this happens, then *Error     */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*           If FreeItemMemory is TRUE, then this function will try  */
//*           to delete any items which may be in the list.  However, */
//*           since this function has no way of knowing the internal  */
//*           structure of an item, items which contain embedded      */
//*           pointers will not be entirely freed.  This can lead to  */
//*           memory leaks.  The programmer should ensure that any    */
//*           list passed to this function when the FreeItemMemory    */
//*           parameter is TRUE is empty or does not contain any      */
//*           items with embedded pointers.                           */
//*                                                                   */
//*********************************************************************/
void _System DestroyList( DLIST *  ListToDestroy, BOOLEAN FreeItemMemory, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  NextItem                                        */
//*                                                                   */
//*   Descriptive Name:  This function makes the next item in the list*/
//*                      the current item in the list (i.e. it        */
//*                      advances the current item pointer).          */
//*                                                                   */
//*   Input:  DLIST       ListToAdvance : The list whose current item */
//*                                      pointer is to be advanced    */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, *Error will be set to 0.                */
//*            If unsuccessful, *Error will be set to a non-zero error*/
//*               code.                                               */
//*                                                                   */
//*   Error Handling: This function will fail under the following     */
//*                   conditions:                                     */
//*                        ListToAdvance is not a valid list          */
//*                        ListToAdvance is empty                     */
//*                        The current item is the last item in the   */
//*                           list                                    */
//*                   If any of these conditions occurs, then *Error  */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
void _System NextItem( DLIST  ListToAdvance, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  PreviousItem                                    */
//*                                                                   */
//*   Descriptive Name:  This function makes the previous item in the */
//*                      list the current item in the list.           */
//*                                                                   */
//*   Input:  DLIST       ListToChange : The list whose current item  */
//*                                      pointer is to be changed     */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, *Error will be set to 0.                */
//*            If unsuccessful, *Error will be set to a non-zero error*/
//*               code.                                               */
//*                                                                   */
//*   Error Handling: This function will fail under the following     */
//*                   conditions:                                     */
//*                        ListToChange is not a valid list           */
//*                        ListToChange is empty                      */
//*                        The current item is the first item in the  */
//*                           list                                    */
//*                   If any of these conditions occurs, then *Error  */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
void _System PreviousItem( DLIST  ListToChange, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name: GoToStartOfList                                  */
//*                                                                   */
//*   Descriptive Name:  This function makes the first item in the    */
//*                      list the current item in the list.           */
//*                                                                   */
//*   Input:  DLIST       ListToReset : The list whose current item   */
//*                                    is to be set to the first item */
//*                                    in the list                    */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, *Error will be set to 0.                */
//*            If unsuccessful, *Error will be set to a non-zero error*/
//*               code.                                               */
//*                                                                   */
//*   Error Handling: This function will fail if ListToReset is not   */
//*                   a valid list.  If this occurs, then *Error      */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
void _System GoToStartOfList( DLIST ListToReset, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name: GoToEndOfList                                    */
//*                                                                   */
//*   Descriptive Name:  This function makes the last item in the     */
//*                      list the current item in the list.           */
//*                                                                   */
//*   Input:  DLIST       ListToSet : The list whose current item     */
//*                                    is to be set to the last item  */
//*                                    in the list                    */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, *Error will be set to 0.                */
//*            If unsuccessful, *Error will be set to a non-zero error*/
//*               code.                                               */
//*                                                                   */
//*   Error Handling: This function will fail if ListToSet is not     */
//*                   a valid list.  If this occurs, then *Error      */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
void _System GoToEndOfList( DLIST ListToSet, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name: GoToSpecifiedItem                                */
//*                                                                   */
//*   Descriptive Name:  This function makes the item associated with */
//*                      Handle the current item in the list.         */
//*                                                                   */
//*   Input:  DLIST  ListToReposition:  The list whose current item   */
//*                                    is to be set to the item       */
//*                                    associated with Handle.        */
//*           ADDRESS Handle : A handle obtained by using the         */
//*                            GetHandle function.  This handle       */
//*                            identifies a unique item in the list.  */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return code              */
//*                                                                   */
//*   Output:  If successful, *Error will be set to 0.                */
//*            If unsuccessful, *Error will be set to a non-zero error*/
//*               code.                                               */
//*                                                                   */
//*   Error Handling: This function will fail if ListToReposition is  */
//*                   not a valid list.  If this occurs, then *Error  */
//*                   is set to a non-zero error code.                */
//*                                                                   */
//*   Side Effects:  None.                                            */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*                                                                   */
//*           It is assumed that Handle is a valid handle and that    */
//*           the item associated with Handle is still in the list.   */
//*           If these conditions are not met, an exception or trap   */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
void _System GoToSpecifiedItem( DLIST ListToReposition, ADDRESS Handle, CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  SortList                                        */
//*                                                                   */
//*   Descriptive Name:  This function sorts the contents of a list.  */
//*                      The sorting algorithm used is a stable sort  */
//*                      whose performance is not dependent upon the  */
//*                      initial order of the items in the list.      */
//*                                                                   */
//*   Input: DLIST ListToSort : The DLIST that is to be sorted.       */
//*                                                                   */
//*          INTEGER32 ( *Compare) ( ... )                             */
//*                                                                   */
//*              This is a pointer to a function that can compare any */
//*              two items in the list.  It should return -1 if       */
//*              Object1 is less than Object2, 0 if Object1 is equal  */
//*              to Object2, and 1 if Object1 is greater than Object2.*/
//*              This function will be called during the sort whenever*/
//*              the sorting algorithm needs to compare two objects.  */
//*                                                                   */
//*              The Compare function takes the following parameters: */
//*                                                                   */
//*              ADDRESS Object1 : The address of the data for the    */
//*                                first object to be compared.       */
//*              TAG Object1Tag : The user assigned TAG value for the */
//*                               first object to be compared.        */
//*              ADDRESS Object2 : The address of the data for the    */
//*                                second object to be compared.      */
//*              TAG Object2Tag : The user assigned TAG value for the */
//*                               second object to be compared.       */
//*              CARDINAL32 * Error : The address of a variable to    */
//*                                   hold the error return value.    */
//*                                                                   */
//*              If this function ever sets *Error to a non-zero value*/
//*              the sort will terminate and the error code will be   */
//*              returned to the caller of the SortList function.     */
//*                                                                   */
//*          CARDINAL32 * Error : The address of a variable to hold   */
//*                               the error return value.             */
//*                                                                   */
//*   Output:  If successful, this function will set *Error to        */
//*               DLIST_SUCCESS and ListToSort will have been sorted. */
//*            If unsuccessful, *Error will contain an error code.    */
//*               The order of the items in ListToSort is undefined   */
//*               and may have changed.                               */
//*                                                                   */
//*   Error Handling: This function will terminate if *Compare sets   */
//*                   *Error to a non-zero value, or if ListToSort    */
//*                   is invalid.  If this function does terminate in */
//*                   the middle of a sort, the order of the items in */
//*                   ListToSort may be different than it was before  */
//*                   the function was called.                        */
//*                                                                   */
//*   Side Effects: None.                                             */
//*                                                                   */
//*   Notes:  It is assumed that Error contains a valid address. If   */
//*           this assumption is violated, an exception or trap       */
//*           may occur.                                              */
//*                                                                   */
//*********************************************************************/
void _System SortList(DLIST        ListToSort,
INTEGER32    ( * _System Compare) (ADDRESS Object1, TAG Object1Tag, ADDRESS Object2, TAG Object2Tag,CARDINAL32 * Error),
CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  ForEachItem                                     */
//*                                                                   */
//*   Descriptive Name:  This function passes a pointer to each item  */
//*                      in a list to a user provided function for    */
//*                      processing by the user provided function.    */
//*                                                                   */
//*   Input:  DLIST ListToProcess : The DLIST whose items are to be   */
//*                                processed by the user provided     */
//*                                function.                          */
//*                                                                   */
//*           void ( * ProcessItem) (...)                               */
//*                                                                   */
//*               This is a pointer to the user provided function.    */
//*               This user provided function takes the following     */
//*                  parameters:                                      */
//*                                                                   */
//*                  ADDRESS Object : A pointer to an item in         */
//*                                   ListToProcess.                  */
//*                  TAG Object1Tag : The user assigned TAG value for */
//*                                   the item pointed to by Object.  */
//*                  ADDRESS Parameter : The address of a block of    */
//*                                      memory containing any        */
//*                                      parameters that the user     */
//*                                      wishes to have passed to this*/
//*                                      function.                    */
//*                  CARDINAL32 * Error : The address of a variable to*/
//*                                       hold the error return value.*/
//*                                                                   */
//*           ADDRESS Parameters : This field is passed through to    */
//*                                *ProcessItem.  This function does  */
//*                                not even look at the contents of   */
//*                                this field.  This field is here to */
//*                                provide the user a way to pass     */
//*                                additional data to *ProcessItem    */
//*                                that *ProcessItem may need to      */
//*                                function correctly.                */
//*                                                                   */
//*           BOOLEAN Forward : If TRUE, then the list is traversed   */
//*                             from the start of the list to the end */
//*                             of the list.  If FALSE, then the list */
//*                             is traversed from the end of the list */
//*                             to the beginning.                     */
//*                                                                   */
//*           CARDINAL32 * Error : The address of a variable to hold  */
//*                                the error return value.            */
//*                                                                   */
//*   Output:  If successful, this function will set *Error to        */
//*               DLIST_SUCCESS.                                      */
//*            If unsuccessful, then this function will set *Error to */
//*               a non-zero error code.                              */
//*                                                                   */
//*   Error Handling: This function aborts immediately when an error  */
//*                   is detected, and any remaining items in the list*/
//*                   will not be processed.                          */
//*                                                                   */
//*   Side Effects: None.                                             */
//*                                                                   */
//*   Notes: This function allows the user to access all of the items */
//*          in a list and perform an operation on them.  The         */
//*          operation performed must not free any items in the list, */
//*          or perform any list operations on the list being         */
//*          processed.                                               */
//*                                                                   */
//*          As an example of when this would be useful, consider a   */
//*          a list of graphic objects (rectangles, triangles, circles*/
//*          etc.)  which comprise a drawing.  To draw the picture    */
//*          that these graphic objects represent, one could build a  */
//*          loop which gets and draws each item.  Another way to     */
//*          do this would be to build a drawing function which can   */
//*          draw any of the graphic objects, and then use that       */
//*          function as the ProcessItem function in a call to        */
//*          ForEachItem.                                             */
//*                                                                   */
//*          If the ProcessItem function sets *Error to something     */
//*          other than DLIST_SUCCESS, then ForEachItem will terminate*/
//*          and return an error to whoever called it.  The single    */
//*          exception to this is if ProcessItem sets *Error to       */
//*          DLIST_SEARCH_COMPLETE, in which case ForEachItem         */
//*          terminates and sets *Error to DLIST_SUCCESS.  This is    */
//*          useful for using ForEachItem to search a list and then  */
//*          terminating the search once the desired item is found.   */
//*                                                                   */
//*          A word about the Parameters parameter.  This parameter   */
//*          is passed through to *ProcessItem and is never looked at */
//*          by this function.  This means that the user can put any  */
//*          value they desire into Parameters as long as it is the   */
//*          same size (in bytes) as Parameters.  The intended use of */
//*          Parameters is to allow the user to pass information to   */
//*          *ProcessItem that *ProcessItem may need.  Either way,    */
//*          how Parameters is used is literally up to the user.      */
//*                                                                   */
//*********************************************************************/
void _System ForEachItem(DLIST        ListToProcess,
void         ( * _System ProcessItem) (ADDRESS Object, TAG ObjectTag, CARDINAL32 ObjectSize, ADDRESS ObjectHandle, ADDRESS Parameters, CARDINAL32 * Error),
ADDRESS      Parameters,
BOOLEAN      Forward,
CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  PruneList                                       */
//*                                                                   */
//*   Descriptive Name:  This function allows the caller to examine   */
//*                      each item in a list and optionally delete    */
//*                      it from the list.                            */
//*                                                                   */
//*   Input:  DLIST ListToProcess : The DLIST to be pruned.           */
//*                                                                   */
//*           BOOLEAN ( * KillItem) (...)                               */
//*                                                                   */
//*               This is a pointer to a user provided function.      */
//*               This user provided function takes the following     */
//*                  parameters:                                      */
//*                                                                   */
//*                  ADDRESS Object : A pointer to an item in         */
//*                                   ListToProcess.                  */
//*                  TAG Object1Tag : The user assigned TAG value for */
//*                                   the item pointed to by Object.  */
//*                  ADDRESS Parameter : The address of a block of    */
//*                                      memory containing any        */
//*                                      parameters that the user     */
//*                                      wishes to have passed to this*/
//*                                      function.                    */
//*                  BOOLEAN * FreeMemory : The address of a BOOLEAN  */
//*                                         variable which this       */
//*                                         function will set to      */
//*                                         either TRUE or FALSE.     */
//*                                         If the function return    */
//*                                         value is TRUE, then the   */
//*                                         value in *FreeMemory will */
//*                                         be examined.  If it is    */
//*                                         TRUE, then PruneList will */
//*                                         free the memory associated*/
//*                                         with the item being       */
//*                                         deleted.  If *FreeMemory  */
//*                                         is FALSE, then the item   */
//*                                         being removed from the    */
//*                                         DLIST will not be freed,  */
//*                                         and it is up to the user  */
//*                                         to ensure that this memory*/
//*                                         is handled properly.      */
//*                  CARDINAL32 * Error : The address of a variable to*/
//*                                       hold the error return value.*/
//*                                                                   */
//*           ADDRESS Parameters : This field is passed through to    */
//*                                *ProcessItem.  This function does  */
//*                                not even look at the contents of   */
//*                                this field.  This field is here to */
//*                                provide the user a way to pass     */
//*                                additional data to *ProcessItem    */
//*                                that *ProcessItem may need to      */
//*                                function correctly.                */
//*                                                                   */
//*          CARDINAL32 * Error : The address of a variable to hold   */
//*                               the error return value.             */
//*                                                                   */
//*   Output:  If successful, this function will set *Error to        */
//*               DLIST_SUCCESS.                                      */
//*            If unsuccessful, then this function will set *Error to */
//*               a non-zero error code.                              */
//*                                                                   */
//*   Error Handling: This function aborts immediately when an error  */
//*                   is detected, and any remaining items in the list*/
//*                   will not be processed.                          */
//*                                                                   */
//*   Side Effects: None.                                             */
//*                                                                   */
//*   Notes: This function allows the user to access all of the items */
//*          in a list, perform an operation on them, and then        */
//*          optionally delete ("remove") them from the DLIST.  The   */
//*          operation performed must not free any items in the list, */
//*          or perform any list operations on the list being         */
//*          processed.                                               */
//*                                                                   */
//*          If the KillItem function sets *Error to something other  */
//*          than DLIST_SUCCESS, then PruneList will terminate and    */
//*          return an error to whoever called it.  The single        */
//*          exception to this is if KillItem sets *Error to          */
//*          DLIST_SEARCH_COMPLETE, in which case KillItem            */
//*          terminates and sets *Error to DLIST_SUCCESS.  This is    */
//*          useful for using KillItem to search a list and then     */
//*          terminating the search once the desired item is found.   */
//*                                                                   */
//*          A word about the Parameters parameter.  This parameter   */
//*          is passed through to *ProcessItem and is never looked at */
//*          by this function.  This means that the user can put any  */
//*          value they desire into Parameters as long as it is the   */
//*          same size (in bytes) as Parameters.  The intended use of */
//*          Parameters is to allow the user to pass information to   */
//*          *ProcessItem that *ProcessItem may need.  Either way,    */
//*          how Parameters is used is literally up to the user.      */
//*                                                                   */
//*********************************************************************/
void _System PruneList(DLIST        ListToProcess,
BOOLEAN      ( * _System KillItem) (ADDRESS Object, TAG ObjectTag, CARDINAL32 ObjectSize, ADDRESS ObjectHandle, ADDRESS Parameters, BOOLEAN * FreeMemory, CARDINAL32 * Error),
ADDRESS      Parameters,
CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  AppendList                                      */
//*                                                                   */
//*   Descriptive Name: Removes the items in SourceList and appends   */
//*                     them to TargetList.                           */
//*                                                                   */
//*   Input:  DLIST TargetList : The DLIST which is to have the items */
//*                             from SourceList appended to it.       */
//*           DLIST SourceList : The DLIST whose items are to be      */
//*                              removed and appended to TargetList.  */
//*          CARDINAL32 * Error : The address of a variable to hold   */
//*                               the error return value.             */
//*                                                                   */
//*   Output: If successful, *Error will be set to DLIST_SUCCESS,     */
//*              SourceList will be empty, and TargetList will contain*/
//*              all of its original items and all of the items that  */
//*              were in SourceList.                                  */
//*           If unsuccessful, *Error will be set to a non-zero value */
//*              and SourceList and TargetList will be unmodified.    */
//*                                                                   */
//*   Error Handling:  This function will abort immediately upon      */
//*                    detection of an error.  All errors that can be */
//*                    detected are detected before the contents of   */
//*                    SourceList are appended to TargetList, so if an*/
//*                    error is detected and the function aborts,     */
//*                    SourceList and TargetList are unaltered.       */
//*                                                                   */
//*   Side Effects: None.                                             */
//*                                                                   */
//*   Notes: None.                                                    */
//*                                                                   */
//*********************************************************************/
void _System AppendList(DLIST        TargetList,
DLIST        SourceList,
CARDINAL32 * Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  TransferItem                                    */
//*                                                                   */
//*   Descriptive Name: Removes an item in SourceList and places in   */
//*                     TargetList.                                   */
//*                                                                   */
//*   Input:  DLIST SourceList : The DLIST containing the item which  */
//*                              is to be transferred.                */
//*           ADDRESS SourceHandle : The handle of the item in        */
//*                                   SourceList which is to be       */
//*                                   transferred to another DLIST.   */
//*                                   If this is NULL, then the       */
//*                                   current item in SourceList will */
//*                                   be used.                        */
//*           DLIST TargetList : The DLIST which is to receive the    */
//*                              item being transferred.              */
//*           ADDRESS TargetHandle : The item in TargetList which     */
//*                                   is used to determine where      */
//*                                   the item being transferred will */
//*                                   be placed.  If this is NULL,    */
//*                                   then the current item in        */
//*                                   TargetList will be used.        */
//*           Insertion_Modes TransferMode : This indicates where,    */
//*                                   relative to the item in         */
//*                                   TargetList specified by         */
//*                                   Target_Handle, the item being   */
//*                                   transferred can be placed.      */
//*          BOOLEAN MakeCurrent : If TRUE, the item transferred to   */
//*                                 TargetList becomes the current    */
//*                                 item in TargetList.               */
//*          CARDINAL32 * Error : The address of a variable to hold   */
//*                               the error return value.             */
//*                                                                   */
//*   Output: If successful, *Error will be set to DLIST_SUCCESS,     */
//*              SourceList will be empty, and TargetList will contain*/
//*              all of its original items and all of the items that  */
//*              were in SourceList.                                  */
//*           If unsuccessful, *Error will be set to a non-zero value */
//*              and SourceList and TargetList will be unmodified.    */
//*                                                                   */
//*   Error Handling:  This function will abort immediately upon      */
//*                    detection of an error.  All errors that can be */
//*                    detected are detected before the contents of   */
//*                    SourceList are appended to TargetList, so if an*/
//*                    error is detected and the function aborts,     */
//*                    SourceList and TargetList are unaltered.       */
//*                                                                   */
//*   Side Effects: None.                                             */
//*                                                                   */
//*   Notes: None.                                                    */
//*                                                                   */
//*********************************************************************/
void _System TransferItem(DLIST             SourceList,
ADDRESS           SourceHandle,
DLIST             TargetList,
ADDRESS           TargetHandle,
Insertion_Modes   TransferMode,
BOOLEAN           MakeCurrent,
CARDINAL32 *      Error);

//*********************************************************************/
//*                                                                   */
//*   Function Name:  CheckListIntegrity                              */
//*                                                                   */
//*   Descriptive Name: Checks the integrity of a DLIST.  All link    */
//*                     nodes in the list are checked, as are all     */
//*                     fields in the list control block.             */
//*                                                                   */
//*   Input:  DLIST ListToCheck - The list whose integrity is to be   */
//*                               checked.                            */
//*                                                                   */
//*   Output: The function return value will be TRUE if all of the    */
//*           elements in the DLIST are correct.  If this function    */
//*           returns FALSE, then the DLIST being checked has been    */
//*           corrupted!                                              */
//*                                                                   */
//*   Error Handling: If this function encounters an error in a DLIST,*/
//*                   it will return FALSE.                           */
//*                                                                   */
//*   Side Effects: None.                                             */
//*                                                                   */
//*   Notes: None.                                                    */
//*                                                                   */
//*********************************************************************/
BOOLEAN _System CheckListIntegrity(DLIST ListToCheck);

{$endif}

Implementation

End.
