(*-------------------------------------------------------------------------*)
(*                                                                         *)
(*  Amiga Oberon Interface Module: Exec         Date: 16-Jun-90            *)
(*                                                                         *)
(*   © 1990 by Fridtjof Siebert                                            *)
(*                                                                         *)
(*-------------------------------------------------------------------------*)

MODULE Exec; (* $Implementation- *)

TYPE
  ADDRESS * = LONGINT;
  BPTR * = BPOINTER TO LONGINT;
  PROC * = PROCEDURE;

CONST
(* IntFlags *)
  tbeInt      * =  0;
  dskblk      * =  1;
  ifSoftint   * =  2;
  ports       * =  3;
  coper       * =  4;
  vertb       * =  5;
  blit        * =  6;
  aud0i       * =  7;
  aud1i       * =  8;
  aud2i       * =  9;
  aud3i       * = 10;
  rbfInt      * = 11;
  disksync    * = 12;
  exter       * = 13;
  inten       * = 14;
  intSet      * = 15;
  IntFlagsMax * = 16;

(* NodeType *)
  unknown     * =  0;
  task        * =  1;
  interrupt   * =  2;
  device      * =  3;
  msgPort     * =  4;
  message     * =  5;
  freeMsg     * =  6;
  replyMsg    * =  7;
  resource    * =  8;
  library     * =  9;
  memory      * = 10;
  softInt     * = 11;
  font        * = 12;
  process     * = 13;
  semaphore   * = 14;
  signalSem   * = 15;
  bootNode    * = 16;

TYPE
  NodePtr * = POINTER TO Node;
  Node * = STRUCT
    succ * : NodePtr;
    pred * : NodePtr;
    type * : SHORTINT; (* NodeType *)
    pri * : SHORTINT;
    name * : LONGINT;
  END;
  MinNodePtr * = POINTER TO MinNode;
  MinNode * = STRUCT
    succ * : MinNodePtr;
    pred * : MinNodePtr;
  END;
  List * = STRUCT
    head * : NodePtr;
    tail * : NodePtr;
    tailPred * : NodePtr;
    type * : SHORTINT; (* NodeType *)
    pad * : BYTE;
  END;
  ListPtr * = POINTER TO List;
  MinList * = STRUCT
    head * : MinNodePtr;
    tail * : MinNodePtr;
    tailPred * : MinNodePtr;
  END;
  MinListPtr * = POINTER TO MinList;
  Interrupt * = STRUCT
    node * : Node;
    data * : LONGINT;
    code * : PROC;
  END;
  InterruptPtr * = POINTER TO Interrupt;
  IntVector * = STRUCT
    data * : LONGINT;
    code * : PROC;
    node * : NodePtr;
  END;
  SoftIntList * = STRUCT
    list * : List;
    pad * : INTEGER;
  END;

CONST
(* MemReqs *)
  public    * =  0;
  chip      * =  1;
  fast      * =  2;
  memClear  * = 16;
  largest   * = 17;

TYPE
  MemChunkPtr * = POINTER TO MemChunk;
  MemChunk * = STRUCT
    next * : MemChunkPtr;
    bytes * : LONGINT;
  END;
  MemHeader * = STRUCT
    node * : Node;
    attributes * : SET; (* MemReqs *)
    first * : MemChunkPtr;
    lower * : LONGINT;
    upper * : LONGINT;
    free * : LONGINT;
  END;
  MemHeaderPtr * = POINTER TO MemHeader;
  MemEntry * = STRUCT
    addr * : LONGINT; (* or * : reqs * : LONGSET; (* MemReqs *) *)
    length * : LONGINT;
  END;
  MemList * = STRUCT
    node * : Node;
    numEntries * : INTEGER;
(*me * : ARRAY munEntries OF MemEntry;*)
  END;
  MemListPtr * = POINTER TO MemList;

CONST
(* MsgPortAction *)
  signal  * = 0;
  softint * = 1;
  ignore  * = 2;

TYPE
  TaskPtr * = POINTER TO Task;
  MsgPort * = STRUCT
    node * : Node;
    flags * : SHORTINT; (* MsgPortAction *)
    sigBit * : SHORTINT;
    sigTask * : TaskPtr;
    msgList * : List;
    END;
  MsgPortSoftInt * = STRUCT  (* use when MsgPort.flags * = softint *)
    node * : Node;
    flags * : SHORTINT; (* MsgPortAction *)
    pad0 * : BYTE;
    softInt * : InterruptPtr;
    msgList * : List;
  END;
  MsgPortPtr * = POINTER TO MsgPort;
  Message * = STRUCT
    node * : Node;
    replyPort * : MsgPortPtr;
    length * : INTEGER;
  END;
  MessagePtr * = POINTER TO Message;

CONST
(* TaskFlags *)
  procTime   * = 0;
  stackChk   * = 4;
  exception  * = 5;
  switch     * = 6;
  launch     * = 7;

(* TaskState *)
  inval   * = 0;
  added   * = 1;
  run     * = 2;
  ready   * = 3;
  wait    * = 4;
  except  * = 5;
  removed * = 6;

TYPE
  Task * = STRUCT
    node * : Node;
    flags * : SHORTSET; (* TaskFlags *)
    state * : SHORTSET; (* TaskState *)
    idNestCnt * : SHORTINT;
    tdNestCnt * : SHORTINT;
    sigAlloc * : LONGSET;
    sigWait * : LONGSET;
    sigRecvd * : LONGSET;
    sigExcept * : LONGSET;
    trapAlloc * : SET;
    trapAble * : SET;
    exceptData * : LONGINT;
    exceptCode * : PROC;
    trapData * : LONGINT;
    trapCode * : PROC;
    spReg * : LONGINT;
    spLower * : LONGINT;
    spUpper * : LONGINT;
    switch * : PROC;
    launch * : PROC;
    memEntry * : List;
    userData * : LONGINT;
  END;

CONST
(* Vordefinierte Signalnummern *)
  sigAbort * = 0;
  sigChild * = 1;
  sigBlit * = 4;
  sigSingle * = 4;
  sigDos * = 8;

  vectSize * = 6;
  reserved * = 4;
  base * = -vectSize;
  userDef * = base-reserved*vectSize;
  nonStd * = userDef;
  extFunc * = -24;
  expunge * = -18;
  close * = -12;
  open * = -6;

(* LibFlags *)
  summing * = 0;
  changed * = 1;
  sumUsed * = 2;
  delExp  * = 3;

TYPE
  Library * = STRUCT
    node * : Node;
    flags * : SHORTSET; (* LibFlags *);
    pad * : BYTE;
    negSize * : INTEGER;
    posSize * : INTEGER;
    version * : INTEGER;
    revision * : INTEGER;
    idString * : LONGINT;
    sum * : LONGINT;
    openCnt * : INTEGER;
  END;
  LibraryPtr * = POINTER TO Library;
  Device * = STRUCT
    library * : Library;
  END;
  DevicePtr * = POINTER TO Device;

CONST
(* UnitFlags *)
  active * = 0;
  inTask * = 1;

TYPE

  UnitPtr * = POINTER TO Unit;
  Unit * = STRUCT
    msgPort * : MsgPort;
    flags * : SHORTSET; (* UnitFlags *)
    pad * : BYTE;
    openCnt * : INTEGER;
  END;

CONST
    (* Standardbefehle für IORequest.command *)
  invalid * = 0;
  reset * = 1;
  read * = 2;
  write * = 3;
  update * = 4;
  clear * = 5;
  stop * = 6;
  start * = 7;
  flush * = 8;
  nonstd * = 9;
    (* Standard Fehlerwerte fuer IORequest.error *)
  openFail * = -1;
  aborted * = -2;
  noCmd * = -3;
  badLength * = -4;
    (* Offstes der Devicespezifischen Funktionen  *)
  abortIO * = -36;
  beginIO * = -30;

  quick * = 0;

TYPE
  IORequest * = STRUCT
    message * : Message;
    device * : DevicePtr;
    unit * : UnitPtr;
    command * : INTEGER;
    flags * : SHORTSET;
    error * : SHORTINT;
  END;
  IORequestPtr * = POINTER TO IORequest;
  IOStdReq * = STRUCT
    message * : Message;
    device * : DevicePtr;
    unit * : UnitPtr;
    command * : INTEGER;
    flags * : SHORTSET;
    error * : SHORTINT;
    actual * : LONGINT;
    length * : LONGINT;
    data * : LONGINT;
    offset * : LONGINT;
  END;
  IOStdReqPtr * = POINTER TO IOStdReq;
  Semaphore * = STRUCT
    msgPort * : MsgPort;
    bids * : INTEGER;
  END;
  SemaphorePtr * = POINTER TO Semaphore;
  SemaphoreRequest * = STRUCT
    link * : MinNode;
    waiter * : TaskPtr;
  END;
  SignalSemaphore * = STRUCT
    link * : Node;
    nestCount * : INTEGER;
    waitQueue * : MinList;
    multipleLink * : SemaphoreRequest;
    owner * : TaskPtr;
    queueCount * : INTEGER;
  END;
  SignalSemaphorePtr * = POINTER TO SignalSemaphore;

CONST
(* ResidentFlags *)
  coldstart * = 0;
  autoinit  * = 7;

TYPE
  ResidentPtr * = POINTER TO Resident;
  Resident * = STRUCT
    matchWord * : INTEGER;
    matchTag * : ResidentPtr;
    endSkip * : LONGINT;
    flags * : SHORTSET; (* ResidentFlags *)
    version * : BYTE;
    type * : SHORTINT; (* NodeType *)
    pri * : SHORTINT;
    name * : LONGINT;
    idString * : LONGINT;
    init * : LONGINT;
  END;

CONST
(* add to Alertnumber for Deadend-Alerts: *)
  deadEnd * = MIN(LONGINT);

CONST
  matchword * = 04AFCH;

(* AttnFlags *)
    m68010 * = 0;
    m68020 * = 1;
    m68881 * = 4;

TYPE
  ExecBase * = STRUCT
    libNode * : Library;
    softVer * : INTEGER;
    lowMemChkSum * : INTEGER;
    chkBase * : LONGINT;
    coldCapture * : LONGINT;
    coolCapture * : LONGINT;
    warmCapture * : LONGINT;
    sysStkUpper * : LONGINT;
    sysStkLower * : LONGINT;
    maxLocMem * : LONGINT;
    debugEntry * : LONGINT;
    debugData * : LONGINT;
    alertData * : LONGINT;
    maxExtMem * : LONGINT;
    chkSum * : INTEGER;
    intVects * : ARRAY IntFlagsMax OF IntVector;
    thisTask * : TaskPtr;
    idleCount * : LONGINT;
    dispCount * : LONGINT;
    quantum * : INTEGER;
    elapsed * : INTEGER;
    sysFlags * : INTEGER;
    idNestCnt * : SHORTINT;
    tdNestCnt * : SHORTINT;
    attnFlags * : SET; (* AttnFlags *);
    attnResched * : INTEGER;
    resModules * : LONGINT;
    taskTrapCode * : PROC;
    taskExceptCode * : PROC;
    taskExitCode * : PROC;
    taskSigAlloc * : LONGSET;
    taskTrapAlloc * : SET;
    memList * : List;
    resourceList * : List;
    deviceList * : List;
    intrList * : List;
    libList * : List;
    portList * : List;
    taskReady * : List;
    taskWait * : List;
    softInts * : ARRAY 5 OF SoftIntList;
    lastAlert * : ARRAY 4 OF LONGINT;
    vBlankFrequency * : BYTE;
    powerSupplyFrequency * : BYTE;
    semaphoreList * : List;
    kickMemPtr * : LONGINT;
    kickTagPtr * : LONGINT;
    kickCheckSum * : LONGINT;
    execBaseReserved * : ARRAY 10 OF BYTE;
    execBaseNewReserved * : ARRAY 20 OF BYTE;
  END;
  ExecBasePtr * = POINTER TO ExecBase;

VAR
  exec* [4] : ExecBasePtr;

PROCEDURE AbortIO* {exec,-480}(iORequest{9}: ADDRESS);
PROCEDURE AddDevice* {exec,-432}(device{9}: DevicePtr);
PROCEDURE AddHead* {exec,-240}(list{8}: ListPtr;
                               node{9}: ADDRESS);
PROCEDURE AddIntServer* {exec,-168}(intNum{0}: LONGINT;
                                    interrupt{9}: InterruptPtr);
PROCEDURE AddLibrary* {exec,-396}(library{9}: LibraryPtr);
PROCEDURE AddMemList* {exec,-618}(size{0}: LONGINT;
                                  attributes{1}: LONGSET; (* MemReqs *)
                                  pri{2}: LONGINT;
                                  exec{8}: LONGINT;
                                  name{9}: ARRAY OF CHAR): LONGINT;
PROCEDURE AddPort* {exec,-354}(port{9}: MsgPortPtr);
PROCEDURE AddResource* {exec,-486}(resource{9}: ADDRESS);
PROCEDURE AddSemaphore* {exec,-600}(
                  signalSemaphore{9}: SignalSemaphorePtr);
PROCEDURE AddTail* {exec,-246}(list{8}: ListPtr;
                               node{9}: ADDRESS);
PROCEDURE AddTask* {exec,-282}(task{9}: TaskPtr;
                               initialPC{10}: PROC;
                               finalPC{11}: ADDRESS);
PROCEDURE Alert* {exec,-108}(alertNum{7}: LONGINT;
                             parameters{13}: LONGINT);
PROCEDURE AllocAbs* {exec,-204}(byteSize{0}: LONGINT;
                                location{9}: LONGINT): ADDRESS;
PROCEDURE Allocate* {exec,-186}(freeList{8}: MemHeaderPtr;
                                byteSize{0}: LONGINT): ADDRESS;
PROCEDURE AllocEntry* {exec,-222}(
                  memList1{8}: MemListPtr): ADDRESS;
PROCEDURE AllocMem* {exec,-198}(byteSize{0}: LONGINT;
                                requirements{1}: LONGSET (* MemReqs *)): ADDRESS;
PROCEDURE AllocSignal* {exec,-330}(
                  signalNum1{0}: LONGINT): SHORTINT;
PROCEDURE AllocTrap* {exec,-342}(trapNum1{0}: LONGINT): SHORTINT;
PROCEDURE AttemptSemaphore* {exec,-576}(
                  signalSemaphore{8}: SignalSemaphorePtr ): BOOLEAN;
PROCEDURE AvailMem* {exec,-216}(
                  requirements{1}: LONGSET (* MemReqs *)): LONGINT;
PROCEDURE Cause* {exec,-180}(interrupt{9}: InterruptPtr);
PROCEDURE CheckIO* {exec,-468}(ioRequest{9}: ADDRESS): BOOLEAN;
PROCEDURE CloseDevice* {exec,-450}(ioRequest{9}: ADDRESS);
PROCEDURE CloseLibrary* {exec,-414}(library{9}: LibraryPtr);
PROCEDURE CopyMem* {exec,-624}(source{8}: ARRAY OF BYTE;
                               dest{9}: ARRAY OF BYTE;
                               size{0}: LONGINT);
PROCEDURE CopyMemQuick* {exec,-630}(source{8}: ARRAY OF BYTE;
                                    dest{9}: ARRAY OF BYTE;
                                    size{0}: LONGINT);
PROCEDURE Deallocate* {exec,-192}(freeList{8}: MemHeaderPtr;
                                  memoryBlock{9}: ADDRESS;
                                  byteSize{0}: LONGINT);
PROCEDURE Debug* {exec,-114}();
PROCEDURE Disable* {exec,-120}();
PROCEDURE Dispatch* {exec,- 60}();
PROCEDURE DoIO* {exec,-456}(ioRequest{9}: ADDRESS);
PROCEDURE Enable* {exec,-126}();
PROCEDURE Enqueue* {exec,-270}(list{8}: ListPtr;
                               node{9}: ADDRESS);
PROCEDURE Exception* {exec,- 66}();
PROCEDURE ExitIntr* {exec,- 36}();
PROCEDURE FindName* {exec,-276}(start{8}: ADDRESS;
                                name{9}: ARRAY OF CHAR): LONGINT;
PROCEDURE FindPort* {exec,-390}(name{9}: ARRAY OF CHAR): MsgPortPtr;
PROCEDURE FindResident* {exec,- 96}(name{9}: ARRAY OF CHAR): ResidentPtr;
PROCEDURE FindSemaphore* {exec,-594}(
                  name{9}: ARRAY OF CHAR): SignalSemaphorePtr;
PROCEDURE FindTask* {exec,-294}(name{9}: ARRAY OF CHAR): TaskPtr;
PROCEDURE Forbid* {exec,-132}();
PROCEDURE FreeEntry* {exec,-228}(memList{8}: MemListPtr);
PROCEDURE FreeMem* {exec,-210}(memoryBlock{9}: ADDRESS;
                               byteSize{0}: LONGINT);
PROCEDURE FreeSignal* {exec,-336}(signalNum{0}: LONGINT);
PROCEDURE FreeTrap* {exec,-348}(trapNum{0}: LONGINT);
PROCEDURE GetCC* {exec,-528}(): SET;
PROCEDURE GetMsg* {exec,-372}(port{8}: MsgPortPtr): LONGINT;
PROCEDURE InitCode* {exec,- 72}(startClass{0}: SHORTSET; (* ResidentFlags *)
                                version{1}: LONGINT);
PROCEDURE InitResident* {exec,-102}(resident{9}: ResidentPtr;
                                    segList{1}: BPTR);
PROCEDURE InitSemaphore* {exec,-558}(
                     signalSemaphore{8}: SignalSemaphorePtr);
PROCEDURE InitStruct* {exec,- 78}(initTable{9}: ADDRESS;
                                  memory{10}: ADDRESS;
                                  size{0}: LONGINT);
PROCEDURE Insert* {exec,-234}(list{8}: ListPtr;
                              node{9}: ADDRESS;
                              listNode{10}: ADDRESS);
PROCEDURE MakeFunctions* {exec,- 90}(target{8}: ADDRESS;
                                     functArray{9}: ADDRESS;
                                     functDispBase{10}: ADDRESS);
PROCEDURE MakeLibrary* {exec,- 84}(vectors{8}: ADDRESS;
                                   structure{9}: ADDRESS;
                                   init{10}: ADDRESS;
                                   dataSize{0}: LONGINT;
                                   segList{1}: BPTR): LibraryPtr;
PROCEDURE ObtainSemaphore* {exec,-564}(
                     signalSemaphore{8}: SignalSemaphorePtr);
PROCEDURE ObtainSemaphoreList* {exec,-582}(list{8}: ListPtr);
PROCEDURE OldOpenLibrary* {exec,-408}(
                     libName{9}: ARRAY OF CHAR): LibraryPtr;
PROCEDURE OpenDevice* {exec,-444}(devName{8}: ARRAY OF CHAR;
                     unitNumber{0}: LONGINT;
                     ioRequest{9}: ADDRESS;
                     flags{1}: LONGSET): LONGINT;
PROCEDURE OpenLibrary* {exec,-552}(libName{9}: ARRAY OF CHAR;
                                   version{0}: LONGINT): LibraryPtr;
PROCEDURE OpenResource* {exec,-498}(resName{9}: ARRAY OF CHAR): LONGINT;
PROCEDURE Permit* {exec,-138}();
PROCEDURE Procure* {exec,-540}(semaphore{8}: SemaphorePtr;
                               bidMessage{9}: MessagePtr): LONGINT;
PROCEDURE PutMsg* {exec,-366}(port{8}: MsgPortPtr;
                              message{9}: ADDRESS);
PROCEDURE RawDoFmt* {exec,-522}(formatString{8}: ARRAY OF CHAR;
                                dataStream{9}: ADDRESS;
                                putChProc{10}: PROC;
                                putChData{11}: ADDRESS);
PROCEDURE RawIOInit* {exec,-504}();
PROCEDURE RawMayGetChar* {exec,-510}(): CHAR;
PROCEDURE RawPutChar* {exec,-516}(ch{0}: CHAR);
PROCEDURE ReleaseSemaphore* {exec,-570}(
                     signalSemaphore{8}: SignalSemaphorePtr);
PROCEDURE ReleaseSemaphoreList* {exec,-588}(list{8}: ListPtr);
PROCEDURE RemDevice* {exec,-438}(device{9}: DevicePtr);
PROCEDURE RemHead* {exec,-258}(list{8}: ListPtr): ADDRESS;
PROCEDURE RemIntServer* {exec,-174}(intNum{0}: LONGINT;
                                    interrupt{9}: InterruptPtr);
PROCEDURE RemLibrary* {exec,-402}(library{9}: LibraryPtr);
PROCEDURE Remove* {exec,-252}(node{9}: ADDRESS);
PROCEDURE RemPort* {exec,-360}(port{9}: MsgPortPtr);
PROCEDURE RemResource* {exec,-492}(resource{9}: ADDRESS);
PROCEDURE RemSemaphore* {exec,-606}(
                     signalSemaphore{9}: SignalSemaphorePtr);
PROCEDURE RemTail* {exec,-264}(list{8}: ListPtr): ADDRESS;
PROCEDURE RemTask* {exec,-288}(task{9}: TaskPtr);
PROCEDURE ReplyMsg* {exec,-378}(message{9}: ADDRESS);
PROCEDURE Reschedule* {exec,- 48}();
PROCEDURE Schedule* {exec,- 42}();
PROCEDURE SendIO* {exec,-462}(ioRequest{9}: ADDRESS);
PROCEDURE SetExcept* {exec,-312}(newSignals{0}: LONGSET;
                                 signalMask{1}: LONGSET): LONGSET;
PROCEDURE SetFunction* {exec,-420}(library{9}: LibraryPtr;
                                   funcOffset{8}: INTEGER;
                                   funcEntry{0}: ADDRESS): ADDRESS;
PROCEDURE SetIntVector* {exec,-162}(
                     intNumber{0}: LONGINT;
                     interrupt{9}: InterruptPtr): InterruptPtr;
PROCEDURE SetSignal* {exec,-306}(newSignals{0}: LONGSET;
                                 signalMask{1}: LONGSET): LONGSET;
PROCEDURE SetSR* {exec,-144}(newSR{0}: SET;
                             mask{1}: SET): SET;
PROCEDURE SetTaskPri* {exec,-300}(task{9}: TaskPtr;
                                  priority{0}: SHORTINT): SHORTINT;
PROCEDURE Signal* {exec,-324}(task{9}: TaskPtr;
                              signals{0}: LONGSET);
PROCEDURE SumKickData* {exec,-612}();
PROCEDURE SumLibrary* {exec,-426}(library{9}: LibraryPtr);
PROCEDURE SuperState* {exec,-150}(): LONGINT;
PROCEDURE Supervisor* {exec,- 30}();
PROCEDURE Switch* {exec,- 54}();
PROCEDURE TypeOfMem* {exec,-534}(address{9}: ADDRESS): LONGSET (* MemReqs *);
PROCEDURE UserState* {exec,-156}(sysStack{0}: LONGINT);
PROCEDURE Vacate* {exec,-546}(semaphore{8}: SemaphorePtr);
PROCEDURE Wait* {exec,-318}(signalSet{0}: LONGSET): LONGSET;
PROCEDURE WaitIO* {exec,-474}(ioRequest{9}: ADDRESS);
PROCEDURE WaitPort* {exec,-384}(port{8}: MsgPortPtr);

END Exec.