home *** CD-ROM | disk | FTP | other *** search
/ AMIGA PD 1 / AMIGA-PD-1.iso / Programme_zum_Heft / Programmieren / Kurztests / PascalPCQ / Include / Libraries / DOSExtens.i < prev    next >
Text File  |  1990-08-28  |  9KB  |  283 lines
  1. {
  2.     DOSExtens.i for PCQ Pascal
  3.  
  4.     DOS structures not needed for the casual AmigaDOS user
  5. }
  6.  
  7. {$I "Include:Exec/Tasks.i"}
  8. {$I "Include:Exec/Ports.i"}
  9. {$I "Include:Exec/Libraries.i"}
  10. {$I "Include:Libraries/DOS.i"}
  11.  
  12.  
  13. Type
  14.  
  15. { All DOS processes have this structure }
  16. { Create and Device Proc returns pointer to the MsgPort in this structure }
  17. { dev_proc = Address(Integer(DeviceProc()) - SizeOf(Task)) }
  18.  
  19.     Process = record
  20.     pr_Task        : Task;
  21.     pr_MsgPort    : MsgPort;    { This is BPTR address from DOS functions  }
  22.     pr_Pad        : Short;    { Remaining variables on 4 byte boundaries }
  23.     pr_SegList    : BPTR;        { Array of seg lists used by this process  }
  24.     pr_StackSize    : Integer;    { Size of process stack in bytes        }
  25.     pr_GlobVec    : Address;    { Global vector for this process (BCPL)    }
  26.     pr_TaskNum    : Integer;    { CLI task number of zero if not a CLI        }
  27.     pr_StackBase    : BPTR;        { Ptr to high memory end of process stack  }
  28.     pr_Result2    : Integer;    { Value of secondary result from last call }
  29.     pr_CurrentDir    : BPTR;        { Lock associated with current directory   }
  30.     pr_CIS        : BPTR;        { Current CLI Input Stream            }
  31.     pr_COS        : BPTR;        { Current CLI Output Stream            }
  32.     pr_ConsoleTask    : Address;    { Console handler process for current window}
  33.     pr_FileSystemTask : Address;    { File handler process for current drive   }
  34.     pr_CLI        : BPTR;        { pointer to ConsoleLineInterpreter        }
  35.     pr_ReturnAddr    : Address;    { pointer to previous stack frame        }
  36.     pr_PktWait    : Address;    { Function to be called when awaiting msg  }
  37.     pr_WindowPtr    : Address;    { Window for error printing }
  38.     end;
  39.     ProcessPtr = ^Process;
  40.  
  41.  
  42. { The long word address (BPTR) of this structure is returned by
  43.  * Open() and other routines that return a file.  You need only worry
  44.  * about this struct to do async io's via PutMsg() instead of
  45.  * standard file system calls }
  46.  
  47.     FileHandleRec = record
  48.     fh_Link        : MessagePtr;    { EXEC message          }   
  49.     fh_Port        : MsgPortPtr;    { Reply port for the packet }
  50.     fh_Type        : MsgPortPtr;    { Port to do PutMsg() to  
  51.                       Address is negative if a plain file }
  52.     fh_Buf        : Integer;
  53.     fh_Pos        : Integer;
  54.     fh_End        : Integer;
  55.     fh_Func1    : Integer;
  56.     fh_Func2    : Integer;
  57.     fh_Func3    : Integer;
  58.     fh_Arg1        : Integer;
  59.     fh_Arg2        : Integer;
  60.     end;
  61.     FileHandlePtr = ^FileHandleRec;
  62.  
  63. { This is the extension to EXEC Messages used by DOS }
  64.  
  65.     DOSPacket = record
  66.     dp_Link    : MessagePtr;    { EXEC message          }
  67.     dp_Port    : MsgPortPtr;    { Reply port for the packet }
  68.                 { Must be filled in each send. }
  69.     dp_Type    : Integer;    { See ACTION_... below and 
  70.                 * 'R' means Read, 'W' means Write to the
  71.                 * file system }
  72.     dp_Res1    : Integer;    { For file system calls this is the result
  73.                 * that would have been returned by the
  74.                 * function, e.g. Write ('W') returns actual
  75.                 * length written }
  76.     dp_Res2    : Integer;    { For file system calls this is what would
  77.                 * have been returned by IoErr() }
  78.     dp_Arg1    : Integer;
  79.     dp_Arg2    : Integer;
  80.     dp_Arg3    : Integer;
  81.     dp_Arg4    : Integer;
  82.     dp_Arg5    : Integer;
  83.     dp_Arg6    : Integer;
  84.     dp_Arg7    : Integer;
  85.     end;
  86.     DOSPacketPtr = ^DOSPacket;
  87.  
  88.  
  89. { A Packet does not require the Message to be before it in memory, but
  90.  * for convenience it is useful to associate the two. 
  91.  * Also see the function init_std_pkt for initializing this structure }
  92.  
  93.  
  94.     StandardPacket = record
  95.     sp_Msg        : Message;
  96.     sp_Pkt        : DOSPacket;
  97.     end;
  98.     StandardPacketPtr = ^StandardPacket;
  99.  
  100.  
  101. Const
  102.  
  103. { Packet types }
  104.     ACTION_NIL            = 0;
  105.     ACTION_GET_BLOCK        = 2;    { OBSOLETE }
  106.     ACTION_SET_MAP        = 4;
  107.     ACTION_DIE            = 5;
  108.     ACTION_EVENT        = 6;
  109.     ACTION_CURRENT_VOLUME    = 7;
  110.     ACTION_LOCATE_OBJECT    = 8;
  111.     ACTION_RENAME_DISK        = 9;
  112.     ACTION_WRITE        = $57;    { 'W' }
  113.     ACTION_READ            = $52;    { 'R' }
  114.     ACTION_FREE_LOCK        = 15;
  115.     ACTION_DELETE_OBJECT    = 16;
  116.     ACTION_RENAME_OBJECT    = 17;
  117.     ACTION_MORE_CACHE        = 18;
  118.     ACTION_COPY_DIR        = 19;
  119.     ACTION_WAIT_CHAR        = 20;
  120.     ACTION_SET_PROTECT        = 21;
  121.     ACTION_CREATE_DIR        = 22;
  122.     ACTION_EXAMINE_OBJECT    = 23;
  123.     ACTION_EXAMINE_NEXT        = 24;
  124.     ACTION_DISK_INFO        = 25;
  125.     ACTION_INFO            = 26;
  126.     ACTION_FLUSH        = 27;
  127.     ACTION_SET_COMMENT        = 28;
  128.     ACTION_PARENT        = 29;
  129.     ACTION_TIMER        = 30;
  130.     ACTION_INHIBIT        = 31;
  131.     ACTION_DISK_TYPE        = 32;
  132.     ACTION_DISK_CHANGE        = 33;
  133.     ACTION_SET_DATE        = 34;
  134.  
  135.     ACTION_SCREEN_MODE        = 994;
  136.  
  137.     ACTION_READ_RETURN        = 1001;
  138.     ACTION_WRITE_RETURN        = 1002;
  139.     ACTION_SEEK            = 1008;
  140.     ACTION_FINDUPDATE        = 1004;
  141.     ACTION_FINDINPUT        = 1005;
  142.     ACTION_FINDOUTPUT        = 1006;
  143.     ACTION_END            = 1007;
  144.     ACTION_TRUNCATE        = 1022;    { fast file system only }
  145.     ACTION_WRITE_PROTECT    = 1023;    { fast file system only }
  146.  
  147. { DOS library node structure.
  148.  * This is the data at positive offsets from the library node.
  149.  * Negative offsets from the node is the jump table to DOS functions  
  150.  * node = (struct DosLibrary *) OpenLibrary( "dos.library" .. )         }
  151.  
  152. Type
  153.  
  154.     DOSLibrary = record
  155.     dl_lib        : Library;
  156.     dl_Root        : Address;      { Pointer to RootNode, described below }
  157.     dl_GV        : Address;      { Pointer to BCPL global vector          }
  158.     dl_A2        : Integer;      { Private register dump of DOS          }
  159.     dl_A5        : Integer;
  160.     dl_A6        : Integer;
  161.     end;
  162.     DOSLibraryPtr = ^DOSLibrary;
  163.  
  164.     RootNode = record
  165.     rn_TaskArray    : BPTR;        { [0] is max number of CLI's
  166.                       [1] is APTR to process id of CLI 1
  167.                       [n] is APTR to process id of CLI n }
  168.     rn_ConsoleSegment : BPTR;    { SegList for the CLI }
  169.     rn_Time        : DateStampRec;    { Current time }
  170.     rn_RestartSeg    : Integer;    { SegList for the disk validator process }
  171.     rn_Info        : BPTR;        { Pointer ot the Info structure }
  172.     rn_FileHandlerSegment : BPTR;    { segment for a file handler }
  173.     end;
  174.     RootNodePtr = ^RootNode;
  175.  
  176.     DOSInfo = record
  177.     di_McName    : BPTR;    { Network name of this machine; currently 0 }
  178.     di_DevInfo    : BPTR;    { Device List }
  179.     di_Devices    : BPTR;    { Currently zero }
  180.     di_Handlers    : BPTR;    { Currently zero }
  181.     di_NetHand    : Address;    { Network handler processid; currently zero }
  182.     end;
  183.     DOSInfoPtr = ^DOSInfo;
  184.  
  185. { DOS Processes started from the CLI via RUN or NEWCLI have this additional
  186.  * set to data associated with them }
  187.  
  188.     CommandLineInterface = record
  189.     cli_Result2    : Integer;    { Value of IoErr from last command }
  190.     cli_SetName    : BSTR;        { Name of current directory }
  191.     cli_CommandDir    : BPTR;        { Lock associated with command directory }
  192.     cli_ReturnCode    : Integer;    { Return code from last command }
  193.     cli_CommandName    : BSTR;        { Name of current command }
  194.     cli_FailLevel    : Integer;    { Fail level (set by FAILAT) }
  195.     cli_Prompt    : BSTR;        { Current prompt (set by PROMPT) }
  196.     cli_StandardInput : BPTR;    { Default (terminal) CLI input }
  197.     cli_CurrentInput : BPTR;    { Current CLI input }
  198.     cli_CommandFile    : BSTR;        { Name of EXECUTE command file }
  199.     cli_Interactive    : Integer;    { Boolean; True if prompts required }
  200.     cli_Background    : Integer;    { Boolean; True if CLI created by RUN }
  201.     cli_CurrentOutput : BPTR;    { Current CLI output }
  202.     cli_DefaultStack : Integer;    { Stack size to be obtained in long words }
  203.     cli_StandardOutput : BPTR;    { Default (terminal) CLI output }
  204.     cli_Module    : BPTR;        { SegList of currently loaded command }
  205.     end;
  206.     CommandLineInterfacePtr = ^CommandLineInterface;
  207.  
  208. { This structure can take on different values depending on whether it is
  209.  * a device, an assigned directory, or a volume.  Below is the structure
  210.  * reflecting volumes only.  Following that is the structure representing
  211.  * only devices.
  212.  }
  213.  
  214. { structure representing a volume }
  215.  
  216.     DeviceList = record
  217.     dl_Next        : BPTR;        { bptr to next device list }
  218.     dl_Type        : Integer;    { see DLT below }
  219.     dl_Task        : MsgPortPtr;    { ptr to handler task }
  220.     dl_Lock        : BPTR;        { not for volumes }
  221.     dl_VolumeDate    : DateStampRec;    { creation date }
  222.     dl_LockList    : BPTR;        { outstanding locks }
  223.     dl_DiskType    : Integer;    { 'DOS', etc }
  224.     dl_unused    : Integer;
  225.     dl_Name        : BSTR;        { bptr to bcpl name }
  226.     end;
  227.     DeviceListPtr = ^DeviceList;
  228.  
  229. { device structure (same as the DeviceNode structure in filehandler.h) }
  230.  
  231.     DevInfo = record
  232.     dvi_Next    : BPTR;
  233.     dvi_Type    : Integer;
  234.     dvi_Task    : Address;
  235.     dvi_Lock    : BPTR;
  236.     dvi_Handler    : BSTR;
  237.     dvi_StackSize    : Integer;
  238.     dvi_Priority    : Integer;
  239.     dvi_Startup    : Integer;
  240.     dvi_SegList    : BPTR;
  241.     dvi_GlobVec    : BSTR;
  242.     dvi_Name    : BSTR;
  243.     end;
  244.     DevInfoPtr = ^DevInfo;
  245.  
  246. { combined structure for devices, assigned directories, volumes }
  247.  
  248. Const
  249.  
  250. { definitions for dl_Type }
  251.  
  252.     DLT_DEVICE        = 0;
  253.     DLT_DIRECTORY    = 1;
  254.     DLT_VOLUME        = 2;
  255.  
  256. Type
  257.  
  258. { a lock structure, as returned by Lock() or DupLock() }
  259.  
  260.     FileLockRec = record
  261.     fl_Link        : BPTR;        { bcpl pointer to next lock }
  262.     fl_Key        : Integer;    { disk block number }
  263.     fl_Access    : Integer;    { exclusive or shared }
  264.     fl_Task        : MsgPortPtr;    { handler task's port }
  265.     fl_Volume    : BPTR;        { bptr to a DeviceList }
  266.     end;
  267.     FileLockPtr = ^FileLockRec;
  268.  
  269.  
  270. Function CreateProc(name : String; pri : Integer;
  271.             segment : BPTR; stackSize : Integer) : ProcessPtr;
  272.     External;
  273.  
  274. Function DeviceProc(name : String) : ProcessPtr;
  275.     External;
  276.  
  277. Function LoadSeg(name : String) : BPTR;
  278.     External;
  279.  
  280. Procedure UnLoadSeg(segment : BPTR);
  281.     External;
  282.  
  283.