compiles cube.pas example

.gitignore

@@ -1,4 +1,5 @@
 *.psx-exe
+!/psy-q-sdk/lib/*
 *.bak
 *.exe
 *.ppu

compiler/mips/cpuext.pas

@@ -0,0 +1,117 @@
+{
+    Copyright (c) 2024 by Kirill Kranz
+
+    This unit contains the CPU specific part of inserting a NOP on a Read After Write dependency
+
+    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., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ ****************************************************************************
+}
+unit cpuext;
+
+{$i fpcdefs.inc}
+
+interface
+uses
+    cutils,
+    globtype, symdef,
+    procinfo, cpuinfo, cpupara,
+    psub, aasmdata, cgutils, aasmtai; 
+
+
+    procedure resolveReadAfterWrite(list: TAsmList);
+
+
+implementation
+uses
+    systems, globals, verbose, sysutils, cclasses,
+    cpubase, cgbase, cgobj,
+    tgobj, paramgr, symconst, symcpu, aasmcpu;
+
+
+procedure resolveReadAfterWrite(list: TAsmList);
+label skip;
+var 
+    p, pp : tai;
+    l, x : TLinkedListItem;
+    firstReg : tregister;    
+
+begin
+
+	l:= list.first;
+    while assigned(l) do begin
+			
+		p:= tai(l);
+        if p.typ = ait_instruction then begin
+
+			if (taicpu(p).opcode = A_LB) or (taicpu(p).opcode = A_LBU) or
+               (taicpu(p).opcode = A_LH) or (taicpu(p).opcode = A_LHU) or
+               (taicpu(p).opcode = A_LW) or (taicpu(p).opcode = A_LWU) or
+               (taicpu(p).opcode = A_LWL) or (taicpu(p).opcode = A_LWR) or
+               (taicpu(p).opcode = A_MFC0) {MFC2} {LWC2} then begin
+
+                firstReg:= taicpu(p).oper[0]^.reg;
+
+				x:= l.next;
+				pp:= tai(x);
+				
+				while pp.typ <> ait_instruction do begin
+					x:= x.next;
+					pp:= tai(x);
+				end;
+
+				if pp.typ = ait_instruction then begin
+
+                   if (taicpu(p).opcode = A_LWL) and (taicpu(pp).opcode = A_LWR) then goto skip;
+                   if (taicpu(p).opcode = A_LWR) and (taicpu(pp).opcode = A_LWL) then goto skip;
+
+					if taicpu(pp).ops > 0 then begin
+
+                        if taicpu(pp).ops = 1 then
+                            if (taicpu(pp).oper[0]^.typ = top_reg) and (firstReg = taicpu(pp).oper[0]^.reg) then
+                                list.insertAfter(taicpu.op_none(A_NOP), l);
+
+						if taicpu(pp).ops = 2 then
+                            if ((taicpu(pp).oper[0]^.typ = top_reg) and (firstReg = taicpu(pp).oper[0]^.reg)) 
+                               or ((taicpu(pp).oper[1]^.typ = top_reg) and (firstReg = taicpu(pp).oper[1]^.reg))
+                               or ((taicpu(pp).oper[1]^.typ = top_ref) and (firstReg = taicpu(pp).oper[1]^.ref^.base))
+                               then
+								    list.insertAfter(taicpu.op_none(A_NOP), l);
+
+						if taicpu(pp).ops = 3 then
+                            if ((taicpu(pp).oper[0]^.typ = top_reg) and (firstReg = taicpu(pp).oper[0]^.reg)) or 
+                               ((taicpu(pp).oper[1]^.typ = top_reg) and (firstReg = taicpu(pp).oper[1]^.reg)) or
+							   ((taicpu(pp).oper[2]^.typ = top_reg) and (firstReg = taicpu(pp).oper[2]^.reg))
+                               then
+								    list.insertAfter(taicpu.op_none(A_NOP), l);
+
+
+					end;
+
+				end;
+
+			 end;
+
+        end;
+skip:
+     	l:= l.next;
+
+    end;
+
+end;
+
+
+begin
+end.

compiler/mips/cpupi.pas

@@ -29,7 +29,8 @@ interface
     cutils,
     globtype,symdef,
     procinfo,cpuinfo,cpupara,
-    psub,aasmdata,cgutils;
+    psub,aasmdata,cgutils,
+    cpuext;
 
   type
 
@@ -154,7 +155,11 @@ implementation
 
     procedure tcpuprocinfo.postprocess_code;
       begin
+        
         fixup_jmps(aktproccode);
+
+        if init_settings.cputype = cpu_mips1 then resolveReadAfterWrite(aktproccode);
+
       end;
 
 

compiler/mips/hlcgcpu.pas

@@ -64,6 +64,18 @@ implementation
       ref: treference;
       sym: tasmsymbol;
     begin
+
+
+    if (cs_create_pic in current_settings.moduleswitches) then begin
+
+{
+    !!!!!!!!!!!!!!!!1
+    
+    I'm not shure this code is correct
+      see line 86   ->    if NOT pic then do pic code
+
+
+}
       if weak then
         sym:=current_asmdata.WeakRefAsmSymbol(s,AT_FUNCTION)
       else
@@ -81,6 +93,14 @@ implementation
         end
       else
         cg.a_call_name(list,s,weak);
+
+
+    end else
+        cg.a_call_name(list,s,weak);
+
+
+
+
       { set the result location }
       result:=get_call_result_cgpara(pd,forceresdef);
     end;

compiler/systems/t_ps1.pas

@@ -25,38 +25,35 @@ unit t_ps1;
 {$i fpcdefs.inc}
 
 interface
+uses link;
 
-  uses
-    link;
-
-  type
-
-
+type
     TLinkerPS1=class(TExternalLinker)
     private
-      Function  WriteResponseFile(isdll:boolean) : Boolean;
+
+      procedure WriteScriptFile;
+      function CreatePSXEXE(name: string): boolean;
+
     public
-      constructor Create;override;
-      procedure SetDefaultInfo;override;
-      function  MakeExecutable:boolean;override;
+
+      constructor Create; override;
+
+      procedure SetDefaultInfo; override;
+      function  MakeExecutable: boolean; override;
       procedure InitSysInitUnitName; override;
+
     end;
 
 
 implementation
-
-  uses
-    SysUtils,
-    cutils,cfileutl,cclasses,
-    verbose,systems,globtype,globals,
-    fmodule,
-    aasmbase,
-    ogelf,owar,
-    i_ps1
-    ;
+uses
+    sysutils, classes,
+    cutils, cfileutl, cclasses,
+    globtype, globals, systems, verbose, comphook, cscript, fmodule,
+    i_ps1;
 
 
-Constructor TLinkerPS1.Create;
+constructor TLinkerPS1.Create;
 begin
   Inherited Create;
 end;
@@ -64,33 +61,330 @@ end;
 
 procedure TLinkerPS1.SetDefaultInfo;
 begin
-  with Info do
-   begin
-     ExeCmd[1]:= 'ld $OPT $RES';
-   end;
+  info.ExeCmd[1]:= 'ld $OPT $RES';
 end;
 
 
-Function TLinkerPS1.WriteResponseFile(isdll: boolean): Boolean;
+procedure TLinkerPS1.WriteScriptFile;
+Var
+    i : integer;
+    linkres  : TLinkRes;
+    s : TCmdStr;
+    megastr : ansistring;
+    newname : ansistring;
+    HPath    : TCmdStrListItem;
+
 begin
-  result:= True;
+
+    { Open link.res file }
+    LinkRes:= TLinkRes.Create(outputexedir + Info.ResName, true);
+
+
+    LinkRes.Add('MEMORY');
+    LinkRes.Add('{');
+    LinkRes.Add('ram (rwx) : ORIGIN = 0x80010000, LENGTH = 2M - 64K');
+    LinkRes.Add('}');
+    LinkRes.Add('ENTRY(main)');
+
+
+    HPath:= TCmdStrListItem(LibrarySearchPath.First);
+    while assigned(HPath) do begin
+      s:= HPath.Str;
+      
+      if s <> '' then LinkRes.Add('SEARCH_DIR("' + s + '")');
+      
+      HPath:= TCmdStrListItem(HPath.Next);
+    end;
+
+
+    LinkRes.Add('INPUT(' + ExtractFileName(ObjectFiles.GetFirst) + ')');  // have to be "si_prc.o"
+    while not ObjectFiles.Empty do begin
+        s:= ObjectFiles.GetFirst;
+        if s <> '' then LinkRes.Add('INPUT(' + ExtractFileName(s) + ')');        
+    end;
+
+    LinkRes.Add('INPUT(libcard.a libpress.a libgpu.a libgs.a libgte.a)');
+    LinkRes.Add('INPUT(libcd.a libetc.a libsn.a libsnd.a libspu.a)');
+    LinkRes.Add('INPUT(libmath.a libcomb.a libcard.a libtap.a libsio.a)');
+    LinkRes.Add('INPUT(libpad.a libc2.a libapi.a)');
+
+    LinkRes.Add('SECTIONS');
+    LinkRes.Add('{');
+    LinkRes.Add('   .text : ALIGN(8) {');
+    LinkRes.Add('         __exe_start__ = .;');
+    LinkRes.Add('');
+    LinkRes.Add('         __text_start__ = .;');
+    LinkRes.Add('           KEEP(*(.text.n_main));');
+    LinkRes.Add('           *(.text .text.*)');
+    LinkRes.Add('         __text_end__ = .;');
+    LinkRes.Add('');
+    LinkRes.Add('         __text_size__ = __text_start__ - __text_end__;');
+    LinkRes.Add('   } > ram');
+    LinkRes.Add('');
+    LinkRes.Add('   .rodata : ALIGN(8) {');
+    LinkRes.Add('');
+    LinkRes.Add('         __rdata_start__ = .;');
+    LinkRes.Add('           *(.rdata .rdata.* .rodata .rodata.*)');
+    LinkRes.Add('         __rdata_end__ = .;');
+    LinkRes.Add('');
+    LinkRes.Add('         __rdata_size__ = __rdata_end__ - __rdata_start__;');
+    LinkRes.Add('   } > ram');
+    LinkRes.Add('');
+    LinkRes.Add('   .ctors : ALIGN(8) {');
+    LinkRes.Add('');
+    LinkRes.Add('         __ctors_start__ = .;');
+    LinkRes.Add('           KEEP(*(.ctors))');
+    LinkRes.Add('           KEEP(*(SORT(.ctors.*)))');
+    LinkRes.Add('         __ctors_end__ = .;');
+    LinkRes.Add('');
+    LinkRes.Add('         __ctors_size__ = __ctors_end__ - __ctors_start__;');
+    LinkRes.Add('   } > ram');
+    LinkRes.Add('');
+    LinkRes.Add('   .dtors : ALIGN(8) {');
+    LinkRes.Add('');
+    LinkRes.Add('         __dtors_start__ = .;');
+    LinkRes.Add('           KEEP(*(.dtors))');
+    LinkRes.Add('           KEEP(*(SORT(.dtors.*)))');
+    LinkRes.Add('         __dtors_end__ = .;');
+    LinkRes.Add('');
+    LinkRes.Add('         __dtors_size__ = __dtors_end__ - __dtors_start__;');
+    LinkRes.Add('   } > ram');
+    LinkRes.Add('');
+    LinkRes.Add('   .data : ALIGN(8) {');
+    LinkRes.Add('');
+    LinkRes.Add('         __sdata_start__ = .;');
+    LinkRes.Add('           *(.sdata .sdata.*)');
+    LinkRes.Add('         __sdata_end__ = .;');
+    LinkRes.Add('');
+    LinkRes.Add('         __sdata_size__ = __sdata_end__ - __sdata_start__;');
+    LinkRes.Add('');
+    LinkRes.Add('         __data_start__ = .;');
+    LinkRes.Add('           *(.data .data.*)');
+    LinkRes.Add('           SORT(CONSTRUCTORS)');
+    LinkRes.Add('           . = ALIGN(2048);');
+    LinkRes.Add('         __data_end__ = .;');
+    LinkRes.Add('');
+    LinkRes.Add('         __exe_end__ = .;');
+    LinkRes.Add('         __data_size__ = __data_end__ - __data_start__;');
+    LinkRes.Add('   } > ram');
+    LinkRes.Add('');
+    LinkRes.Add('   __exe_size__ = __exe_end__ - __exe_start__;');
+    LinkRes.Add('');
+    LinkRes.Add('   .sbss : ALIGN(64) {');
+    LinkRes.Add('');
+    LinkRes.Add('         __sbss_start__ = .;');
+    LinkRes.Add('           *(.sbss .sbss.*)');
+    LinkRes.Add('         __sbss_end__ = .;');
+    LinkRes.Add('');
+    LinkRes.Add('         __sbss_size__ = __sbss_end__ - __sbss_start__;');
+    LinkRes.Add('   } > ram');
+    LinkRes.Add('');
+    LinkRes.Add('   .bss : ALIGN(64) {');
+    LinkRes.Add('');
+    LinkRes.Add('         __bss_start__ = .;');
+    LinkRes.Add('           *(.bss .bss.*)');
+    LinkRes.Add('           *(COMMON)');
+    LinkRes.Add('           . = ALIGN(64);');
+    LinkRes.Add('         __bss_end__ = .;');
+    LinkRes.Add('');
+    LinkRes.Add('         __bss_size__ = __bss_end__ - __bss_start__;');
+    LinkRes.Add('   } > ram');
+    LinkRes.Add('}');
+
+    linkres.writetodisk;
+    linkres.free;
+
 end;
 
 
-function TLinkerPS1.MakeExecutable: boolean;
+function FileCopy(source, target: string; startTargetOffset: dword): boolean;
+var
+    fin, fout : file;
+    NumRead : dWord;
+    Buf : Array[1..2048] of byte;
 begin
+
+  result:= false;
+
+  AssignFile(fin, source);
+  {$I-} reset(fin, 1); {$I+}
+  if ioResult <> 0 then exit;
+
+  AssignFile(fout, target);
+  if startTargetOffset = 0 then rewrite(fout, 1) else begin
+    {$I-} reset(fout, 1); {$I+}
+    if ioResult <> 0 then exit;
+    seek(fout, startTargetOffset);
+  end;
+
+  Repeat
+    BlockRead(fin,buf,Sizeof(buf),NumRead);
+    if NumRead = 0 then break;
+    BlockWrite(fout,Buf,NumRead);
+  Until false;
+
+  close(fin);
+  close(fout);
+
   result:= true;
+
+end;
+
+
+procedure write0till(var f: file; k: dWord);
+var 
+    b : byte;
+
+begin
+  
+  b:= 0;
+  repeat
+    BlockWrite(f, b, 1);
+  until filesize(f) >= k;
+
 end;
 
+
+function TLinkerPS1.CreatePSXEXE(name: string): boolean;
+const
+    header = 'PS-X EXE';
+
+var
+    f : file;
+    fsize : dword;
+    d : dword;
+
+begin
+
+  result:= false;
+  
+  AssignFile(f, name + '.bin');
+  {$I-} reset(f, 1); {$I+}
+  if ioResult <> 0 then exit;
+
+  if filesize(f) >= $200000 then begin
+    writeln('Binary size if bigger than 2 097 152 bytes');
+    exit;
+  end;
+  
+  close(f);
+
+  AssignFile(f, name + '.psx-exe');
+  {$I-} rewrite(f, 1); {$I+}
+  if ioResult <> 0 then exit;
+
+  BlockWrite(f, header, sizeof(header));
+  write0till(f, $10);
+
+  d:= $80010000;
+  BlockWrite(f, d, 4);
+  d:= $FFFFFFFF;
+  BlockWrite(f, d, 4);
+  d:= $80010000;
+  BlockWrite(f, d, 4);
+
+  write0till(f, $30);
+  write0till(f, $800);
+
+  fsize:= filesize(f);
+  close(f);
+
+  if not FileCopy(name + '.bin', name + '.psx-exe', fsize) then exit;
+
+  {$I-} reset(f, 1); {$I+}
+  if ioResult <> 0 then exit;
+  fsize:= filesize(f);
+  seek(f, fsize);
+
+  if (fsize mod $800) <> 0 then begin
+      fsize:= fsize + ($800 - (fsize mod $800));
+      write0till(f, fsize);
+  end;
+
+  seek(f, $1C);
+
+  d:= fsize - $800;
+  BlockWrite(f, d, 4);
+
+  close(f);
+
+  result:= true;
+
+end;
+
+
+
+function TLinkerPS1.MakeExecutable: boolean;
+var
+    binstr, cmdstr : TCmdStr;
+    success : boolean;
+begin
+
+    WriteScriptFile;
+
+    if cs_link_nolink in current_settings.globalswitches then begin
+      result:= true;
+      exit;
+    end;
+
+    { Call linker }
+    SplitBinCmd(Info.ExeCmd[1], binstr, cmdstr);
+
+    Replace(cmdstr, '$OPT', Info.ExtraOptions);
+    Replace(cmdstr, '$RES', '-T ' + (maybequoted(ScriptFixFileName(outputexedir + Info.ResName))));
+
+    if cs_link_smart in current_settings.globalswitches then cmdstr:= cmdstr + ' --gc-sections';
+
+    success:= DoExec(FindUtil(utilsprefix + BinStr), cmdstr + ' -o ' + current_module.exefilename + '.elf', true, false);
+    if not success then begin
+      result:= false;
+      exit;
+    end;
+
+    DeleteFile(outputexedir + Info.ResName);
+
+    
+    if not FileCopy(current_module.exefilename + '.elf', current_module.exefilename + '.bin', 0) then begin
+      writeln('Cant Write ' + current_module.exefilename + '.bin File!');
+      result:= false;
+      exit;
+    end;
+
+    DeleteFile(current_module.exefilename + '.elf');
+
+
+    success:= DoExec(FindUtil(utilsprefix + 'objcopy'), ' -O binary ' + current_module.exefilename +'.bin', true, false);
+    if not success then begin
+      writeln('OBJDUMP failed!');
+      result:= false;
+      exit;
+    end;
+
+   
+    success:= CreatePSXEXE(current_module.exefilename);
+    if not success then begin
+      writeln('Create PSX-EXE failed!');
+      result:= false;
+      exit;
+    end;
+
+    DeleteFile(current_module.exefilename + '.bin');
+
+    result:= true;
+end;
+
+
 procedure TLinkerPS1.InitSysInitUnitName;
 begin
-  sysinitunit:='si_prc';
+  sysinitunit:= 'si_prc';
 end;
 
 
 
 initialization
+
   RegisterLinker(ld_ps1, TLinkerPS1);
   RegisterTarget(system_mipsel_ps1_info);
+
 end.
 

cu

@@ -0,0 +1,7 @@
+#!/bin/bash
+./compiler/ppcrossmipsel ./rtl/ps1/system.pp -O- -Tps1 -Fi./rtl/mipsel -Fi./rtl/inc -Fi./rtl/ps1 -a -XP/usr/local/mipsel-unknown-elf/bin/mipsel-unknown-elf- -Cfnone
+./compiler/ppcrossmipsel ./rtl/inc/fpintres.pp -O- -Tps1 -Fu./rtl/ps1 -Fi./rtl/mipsel -Fi./rtl/inc -Fi./rtl/ps1 -a -XP/usr/local/mipsel-unknown-elf/bin/mipsel-unknown-elf- -Cfnone 
+./compiler/ppcrossmipsel ./rtl/ps1/si_prc.pp -O- -Tps1 -Fu./rtl/ps1 -Fi./rtl/mipsel -Fi./rtl/inc -Fi./rtl/ps1 -a -XP/usr/local/mipsel-unknown-elf/bin/mipsel-unknown-elf- -Cfnone 
+#./compiler/ppcrossmipsel ./rtl/ps1/objpas.pp -O- -Tps1 -Fu./rtl/ps1 -Fi./rtl/mipsel -Fi./rtl/inc -Fi./rtl/ps1 -a -XP/usr/local/mipsel-unknown-elf/bin/mipsel-unknown-elf- -Cfnone 
+#
+./compiler/ppcrossmipsel ./rtl/objpas/objpas.pp -O- -Tps1 -Fu./rtl/ps1 -Fi./rtl/mipsel -Fi./rtl/inc -Fi./rtl/ps1 -a -XP/usr/local/mipsel-unknown-elf/bin/mipsel-unknown-elf- -Cfnone 

f2

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+rm test.asm
+rm test.s
+rm test.o
+rm test.elf
+tm test.bin
+rm test.psx-exe
+rm *.res
+# -Cn
+./compiler/ppcrossmipsel test.pas -a -XX -Fu./rtl/ps1 -Fu./rtl/objpas -Tps1 -Cfnone -Fu./psy-q-sdk/bindings -Fl./psy-q-sdk/lib -XP/usr/local/mipsel-unknown-elf/bin/mipsel-unknown-elf-

psy-q-sdk/bindings/libabs.pas

@@ -0,0 +1,7 @@
+// $PSLibId: Run-time Library Release 4.6
+unit libabs;
+interface
+	function abs(num: longint): longint; stdcall; external;
+implementation
+begin
+end.

psy-q-sdk/bindings/libapi.pas

@@ -0,0 +1,115 @@
+//	File:libapi.h
+//	Copyright (C) 1997 by Sony Computer Entertainment Inc.
+//			All rights Reserved
+//
+// $PSLibId: Run-time Library Release 4.6$
+
+// don't change these macros and structures which is referred in controler code
+
+// Prototypes
+// prototypes added by suzu 96/03/01 and changed by hakama 96/06/06
+unit libapi;
+interface
+uses libstd;
+
+function SetRCnt(spec: dword; target: word; mode:longint): longint; stdcall; external;
+function GetRCnt(spec: dword): longint; stdcall; external;
+function ResetRCnt(spec: dword): longint; stdcall; external;
+function StartRCnt(spec: dword): longint; stdcall; external;
+function StopRCnt(spec: dword): longint; stdcall; external;
+
+function OpenEvent(desc: dword; spec: longint; mode: longint; func: pointer): longint; stdcall; external;
+function CloseEvent(event: dword): longint; stdcall; external;
+function WaitEvent(event: dword): longint; stdcall; external;
+function TestEvent(event: dword): longint; stdcall; external;
+function EnableEvent(event: dword): longint; stdcall; external;
+function DisableEvent(event: dword): longint; stdcall; external;
+procedure DeliverEvent(ev1, ev2: dword); stdcall; external;
+procedure UnDeliverEvent(ev1, ev2: dword); stdcall; external;
+
+function OpenTh(func: pointer; sp, gp: dword): longint; stdcall; external;
+function CloseTh(thread: dword): longint; stdcall; external;
+function ChangeTh(thread: dword): longint; stdcall; external;
+
+function open(devname: pchar; flag: longint): longint; stdcall; external;
+function close(fd: longint): longint; stdcall; external;
+function lseek(fd: longint; ofs: dword; flag: longint): longint; stdcall; external;
+function read(fd: longint; buf: pointer; n: dword): longint; stdcall; external;
+function write(fd: longint; buf: pointer; n: dword): longint; stdcall; external;
+function ioctl(fd: longint; com, arg: longint): longint; stdcall; external;
+function firstfile(name: pchar; dir: PDIRENTRY): PDIRENTRY; stdcall; external;
+function nextfile(dir: PDIRENTRY): PDIRENTRY; stdcall; external;
+function erase(name: pchar): longint; stdcall; external;
+
+
+function undelete(name: pchar): longint; stdcall; external;
+function format(name: pchar): longint; stdcall; external;
+function rename(src, dest: pchar): longint; stdcall; external;
+function cd(name: pchar): longint; stdcall; external;
+
+function LoadTest(name: pchar; _exec: PEXEC): longint; stdcall; external;
+function Load(name: pchar; _exec: PEXEC): longint; stdcall; external;
+//function Exec(_exec: PEXEC; , long, char **): longint; stdcall; external;
+function LoadExec(name: pchar; s_addr, s_size: dword): longint; stdcall; external;
+
+function InitPAD(bufA, bufB: pointer; lenA, lenB: dword): longint; stdcall; external;
+function StartPAD: longint; stdcall; external;
+procedure StopPAD; stdcall; external;
+procedure EnablePAD; stdcall; external;
+procedure DisablePAD; stdcall; external;
+
+procedure FlushCache; stdcall; external;
+procedure ReturnFromException; stdcall; external;
+function EnterCriticalSection: longint; stdcall; external;
+procedure ExitCriticalSection; stdcall; external;
+procedure Exception; stdcall; external;
+procedure SwEnterCriticalSection; stdcall; external;
+procedure SwExitCriticalSection; stdcall; external;
+
+function SetSp(new_sp: dword): dword; stdcall; external;
+function GetSp: dword; stdcall; external;
+function GetGp: dword; stdcall; external;
+function GetCr: dword; stdcall; external;
+function GetSr: dword; stdcall; external;
+function GetSysSp: dword; stdcall; external;
+
+function SetConf(ev, tcb, sp: dword): longint; stdcall; external;
+procedure GetConf(ev, tcb, sp: pdword); stdcall; external;
+
+function _get_errno: longint; stdcall; external;
+function _get_error(fd: longint): longint; stdcall; external;
+
+procedure SystemError(c: char; n: dword); stdcall; external;
+procedure SetMem(n: dword); stdcall; external;
+
+function Krom2RawAdd(sjiscode: word): longint; stdcall; external;
+function Krom2RawAdd2(sjiscode: word): longint; stdcall; external;
+
+procedure _96_init; stdcall; external;
+procedure _96_remove; stdcall; external;
+procedure _boot; stdcall; external;
+
+procedure ChangeClearPAD(val: longint); stdcall; external;
+
+// prototypes added by shino 96/05/22
+procedure InitCARD(val: longint); stdcall; external;
+function StartCARD: longint; stdcall; external;
+function StopCARD: longint; stdcall; external;
+procedure _bu_init; stdcall; external;
+function _card_info(chan: longint): longint; stdcall; external;
+function _card_clear(chan: longint): longint; stdcall; external;
+function _card_load(chan: longint): longint; stdcall; external;
+function _card_auto(val: longint): longint; stdcall; external;
+procedure _new_card; stdcall; external;
+function _card_status(drv: longint): longint; stdcall; external;
+function _card_wait(drv: longint): longint; stdcall; external;
+function _card_chan: dword; stdcall; external;
+function _card_write(chan, block: longint; buf: pointer): longint; stdcall; external;
+function _card_read(chan, block: longint; buf: pointer): longint; stdcall; external;
+function _card_format(chan: longint): longint; stdcall; external;	// added by iwano 98/03/24
+
+
+
+implementation
+begin
+end.

psy-q-sdk/bindings/libcd.pas

@@ -0,0 +1,337 @@
+{
+ *  (C) Copyright 1993/1994 Sony Computer Entertainment ,Tokyo,Japan.
+ *                      All Rights Reserved
+ *
+ *              libcd.h: CD-ROM sub system hendler
+ *
+ * CD-ROM Primitive Command list:
+ *
+ *	Symbol		type	Contents			
+ *	------------------------------------------------------
+ *	CdlNop		B	NOP		
+ *	CdlSetloc	B	Set position	
+ *	CdlPlay		B	CD-DA Play
+ *	CdlForward	B	Forward
+ *	CdlBackward	B	Backward
+ *	CdlReadN	B	Read with retry
+ *	CdlStanby	N	Standby
+ *	CdlStop		N	Stop
+ *	CdlPause	N	Pause
+ *	CdlMute		B	Mute on
+ *	CdlDemute	B	Mute off
+ *	CdlSetfilter	B	Set SubHeader filter
+ *	CdlSetmode	B	Set mode
+ *	CdlGetlocL	B	Get logical position
+ *	CdlGetlocP	B	Get phisycal position
+ *	CdlSeekL	N	Logical Seek
+ *	CdlSeekP	N	Phisical Seek
+ *	CdlReadS	B	Read without retry
+ *	------------------------------------------------------
+ *			B: Blocking, N: Non-Blocking operation
+ *		
+ *	
+ *	Symbol		arg		result
+ *	--------------------------------------------------------------
+ *	CdlNop		-		status
+ *	CdlSetloc	min,sec,sector	status
+ *	CdlPlay       	-		status
+ *	CdlForward	-		status
+ *	CdlBackward	-		status
+ *	CdlReadN	-		status
+ *	CdlStanby	-		status
+ *	CdlStop		-		status
+ *	CdlPause	-		status
+ *	CdlMute		-		status
+ *	CdlDemute	-		status
+ *	CdlSetfilter	file,chan	status
+ *	CdlSetmode	mode		status
+ *	CdlGetlocL	-		min,sec,sector,mode,file, chan
+ *	CdlGetlocP	-		track,index,min,sec,frame,
+ *							amin,asec,aframe
+ *	CdlSeekL	-		status
+ *	CdlSeekP	-		status
+ *	CdlReadS	-		status
+ *	--------------------------------------------------------------
+}
+
+unit libcd;
+interface
+uses libstd;
+
+const
+// CD-ROM Mode (used int CdlSetmode)
+	CdlModeStream  	= $100;    	// Normal Streaming
+	CdlModeStream2 	= $120;    	// SUB HEADER information includes
+	CdlModeSpeed	= $80;		// 0: normal speed	1: double speed
+	CdlModeRT 		= $40;		// 0: ADPCM off		1: ADPCM on
+	CdlModeSize1 	= $20;		// 0: 2048 byte		1: 2340byte
+	CdlModeSize0 	= $10;		// 0: -				1: 2328byte
+	CdlModeSF 		= $08;		// 0: Channel off	1: Channel on
+	CdlModeRept 	= $04;		// 0: Report off	1: Report on
+	CdlModeAP 		= $02;		// 0: AutoPause off	1: AutoPause on
+	CdlModeDA 		= $01;		// 0: CD-DA off		1: CD-DA on
+
+
+// Status Contents
+	CdlStatPlay		= $80;	// playing CD-DA
+	CdlStatSeek		= $40;	// seeking
+	CdlStatRead		= $20;	// reading data sectors
+	CdlStatShellOpen= $10;	// once shell open
+	CdlStatSeekError= $04;	// seek error detected
+	CdlStatStandby 	= $02;	// spindle motor rotating
+	CdlStatError 	= $01;	// command error detected
+
+// Macros for CdGetDiskType()
+	CdlStatNoDisk	= 0;
+	CdlOtherFormat	= 1;
+	CdlCdromFormat	= 2;
+
+// CD-ROM Primitive Commands
+	CdlNop			= $01;
+	CdlSetloc		= $02;
+	CdlPlay			= $03;
+	CdlForward		= $04;
+	CdlBackward		= $05;
+	CdlReadN		= $06;
+	CdlStandby		= $07;
+	CdlStop			= $08;
+	CdlPause		= $09;
+	CdlMute			= $0b;
+	CdlDemute		= $0c;
+	CdlSetfilter	= $0d;
+	CdlSetmode		= $0e;
+	CdlGetparam		= $0f;
+	CdlGetlocL		= $10;
+	CdlGetlocP		= $11;
+	CdlGetTN		= $13;
+	CdlGetTD		= $14;
+	CdlSeekL		= $15;
+	CdlSeekP		= $16;
+	CdlReadS		= $1B;
+
+// Interrupts
+	CdlNoIntr		= $00;	// No interrupt
+	CdlDataReady	= $01;	// Data Ready
+	CdlComplete		= $02;	// Command Complete
+	CdlAcknowledge	= $03;	// Acknowledge (reserved)
+	CdlDataEnd		= $04;	// End of Data Detected
+	CdlDiskError	= $05;	// Error Detected
+
+
+// Library Macros
+function btoi(b: longint): byte;	// BCD to u_char
+function itob(i: byte): longint;	// u_char to BCD
+
+procedure CdSeekL(p: dword);
+procedure CdSeekP(p: dword);
+procedure CdStandby;
+procedure CdPause;
+procedure CdStop;
+procedure CdMute;
+procedure CdDeMute;
+procedure CdForward;
+procedure CdBackward;
+
+
+// Position
+const
+	CdlMAXTOC 	= 100;
+
+// Callback
+type
+	CdlCB = procedure (b: byte; p: pchar);
+
+// Location
+type
+	CdlLOC = packed record
+		 		minute : byte;		// minute (BCD)
+				second : byte;		// second (BCD)
+				sector : byte;		// sector (BCD)
+				track : byte;		// track (void)
+			 end;
+	PCdlLOC = ^CdlLOC;
+
+// ADPCM Filter
+	CdlFILTER = packed record
+					_file : byte;		// file ID (always 1)
+					chan : byte;		// channel ID
+					pad : u_short;
+				end;
+
+// Attenuator
+	CdlATV = packed record
+				val0 : byte;		// volume for CD(L) -> SPU (L)
+				val1 : byte;		// volume for CD(L) -> SPU (R)
+				val2 : byte;		// volume for CD(R) -> SPU (L)
+				val3 : byte;		// volume for CD(R) -> SPU (R)
+			 end;
+	PCdlATV = ^CdlATV;
+
+// Low Level File System for CdSearchFile() 
+const
+	CdlMAXFILE 	=	64;		// max number of files in a directory
+	CdlMAXDIR 	= 	128;	// max number of total directories
+	CdlMAXLEVEL = 	8;		// max levels of directories
+
+type
+	CdlFILE = packed record
+				pos : CdlLOC;					// file location
+				size : u_long;					// file size
+				name : array [0..15] of char;	// file name (body) */
+			  end;
+	PCdlFILE = ^CdlFILE;
+
+// Streaming Structures
+type
+	StHEADER = packed record	// CD-ROM STR structure
+			    id : u_short;
+			    _type : u_short;
+			    secCount : u_short;
+			    nSectors : u_short;
+			    frameCount : u_long;
+			    frameSize : u_long;
+
+			    width : u_short;
+			    height : u_short;
+			    dummy1 : u_long;
+			    dummy2 : u_long;
+			    loc : CdlLOC;
+			   end;
+const
+	StFREE 		=	$0000;
+	StREWIND 	=   $0001;
+	StCOMPLETE 	=   $0002;
+	StBUSY 		=   $0003;
+	StLOCK 		=   $0004;
+
+	EDC 		= 	0;
+	SECTOR_SIZE = 	512;	// Sector Size (word)
+	HEADER_SIZE = 	8;		// Header Size (word)
+
+	StSTATUS        = $00;
+	StVER           = $00;
+	StTYPE          = $01;
+	StSECTOR_OFFSET = $02;
+	StSECTOR_SIZE   = $03;
+	StFRAME_NO      = $04;
+	StFRAME_SIZE    = $06;
+
+	StMOVIE_WIDTH   = $08;
+	StMOVIE_HEIGHT  = $09;
+
+
+// Prototypes for Streaming
+procedure StSetRing(ring_addr: Pdword; ring_size:Pdword); stdcall external;
+procedure StClearRing; stdcall external;
+procedure StUnSetRing; stdcall external;
+procedure StSetStream(mode: u_long; start_frame, end_frame: u_long; func1, func2: pointer); stdcall external;
+procedure StSetEmulate(addr: Pdword; mode: u_long; start_frame, end_frame: u_long; func1, func2: pointer); stdcall external;
+function StFreeRing(base: Pdword): u_long; stdcall external;
+function StGetNext(addr: pointer; header: pointer): u_long; stdcall external;
+function StGetNextS(addr: pointer; header: pointer): u_long; stdcall external;
+function StNextStatus(addr: pointer; header: pointer): u_short; stdcall external;
+procedure StRingStatus(free_sectors: Pshort; over_sectors: Pshort); stdcall external;
+procedure StSetMask(mask: u_long; start, _end: u_long); stdcall external;
+procedure StCdInterrupt; stdcall external;
+function StGetBackloc(loc: PCdlLOC): integer; stdcall external;
+function StSetChannel(channel: u_long): integer; stdcall external;
+
+// Prototypes
+procedure CdFlush; stdcall external;
+function CdSearchFile(fp: PCdlFILE; name: pchar): PCdlFILE; stdcall external;
+function CdIntToPos(i: integer; p: PCdlLOC): PCdlLOC; stdcall external;
+function CdComstr(com: byte): pchar; stdcall external;
+function CdIntstr(intr: byte): pchar; stdcall external;
+function CdControl(com: byte; param: Pbyte; result: Pbyte): integer; stdcall external;
+function CdControlB(com: byte; param: Pbyte; result: Pbyte): integer; stdcall external;
+function CdControlF(com: byte; param: Pbyte): integer; stdcall external;
+function CdGetSector(madr: pointer; size: integer): integer; stdcall external;
+function CdGetSector2(madr: pointer; size: integer): integer; stdcall external;
+function CdDataSync(mode: integer): integer; stdcall external;
+function CdGetToc(loc: PCdlLOC): integer; stdcall external;
+function CdPlay(mode: integer; track: Pinteger; offset: integer): integer; stdcall external;
+function CdMix(vol: PCdlATV): integer; stdcall external;
+function CdPosToInt(p: PCdlLOC): integer; stdcall external;
+function CdRead(sectors: integer; buf: pointer; mode: integer): integer; stdcall external;
+function CdRead2(mode: longint): integer; stdcall external;
+function CdReadFile(_file: pchar; addr: pointer; nbyte: integer): integer; stdcall external;
+function CdReadSync(mode: integer; res: pointer): integer; stdcall external;
+function CdReady(mode: integer; res: pointer): integer; stdcall external;
+function CdSetDebug(level: integer): integer; stdcall external;
+procedure CdSync(mode: integer; res: pointer); stdcall external;
+function CdDataCallback(func: pointer): pointer; stdcall external;
+function CdReadCallback(func: CdlCB): CdlCB; stdcall external;
+function CdReadyCallback(func: CdlCB): CdlCB; stdcall external;
+function CdSyncCallback(func: CdlCB): CdlCB; stdcall external;
+function CdInit: integer; stdcall external;
+function CdReset(mode: integer): integer; stdcall external;
+function CdStatus: integer; stdcall external;
+function CdLastCom: integer; stdcall external;
+function CdLastPos: PCdlLOC; stdcall external;
+function CdMode: integer; stdcall external;
+function CdDiskReady(mode: integer): integer; stdcall external;
+function CdGetDiskType: integer; stdcall external;
+// CdReadExec(char *file): EXEC;
+procedure CdReadBreak; stdcall external;
+
+implementation
+
+
+function btoi(b: longint): byte;
+begin
+	btoi:= b div 16 * 10 + b mod 16;
+end;
+
+function itob(i: byte): longint;
+begin
+	itob:= i div 10 * 16 + i mod 10;
+end;
+
+procedure CdSeekL(p: dword);
+begin
+	CdControl(CdlSeekL, @p, nil);
+end;
+
+
+procedure CdSeekP(p: dword);
+begin
+	CdControl(CdlSeekP, @p, nil);
+end;
+
+procedure CdStandby;
+begin
+	CdControl(CdlStandby, nil, nil);
+end;
+
+procedure CdPause;
+begin
+	CdControl(CdlPause, nil, nil);
+end;
+
+procedure CdStop;
+begin
+	CdControl(CdlStop, nil, nil);
+end;
+
+procedure CdMute;
+begin
+	CdControl(CdlMute, nil, nil);
+end;
+
+procedure CdDeMute;	
+begin
+	CdControl(CdlDemute, nil, nil);
+end;
+
+procedure CdForward;
+begin
+	CdControl(CdlForward, nil, nil);
+end;
+
+procedure CdBackward;
+begin
+	CdControl(CdlBackward, nil, nil);
+end;
+
+begin
+end.

psy-q-sdk/bindings/libcomb.pas

@@ -0,0 +1,161 @@
+unit libcomb; 
+interface
+const
+// Status bits
+	COMB_CTS		= $100;
+	COMB_DSR		= $80;
+	COMB_FE			= $20;
+	COMB_OE			= $10;
+	COMB_PERROR		= $8;
+	COMB_TXU		= $4;
+	COMB_RXRDY		= $2;
+	COMB_TXRDY		= $1;
+
+// Control bits
+	COMB_BIT_DTR	= $1;
+	COMB_BIT_RTS	= $2;
+
+// Macros
+function CombSioStatus: longint;					// Return serial controller status
+function CombControlStatus: longint;				// Return control line status
+function CombGetMode: longint;						// Return communication mode
+function CombGetBPS: longint;						// Return transfer rate
+function CombGetPacketSize: longint;				// Return current packet size
+function CombBytesToWrite: longint;					// Return # bytes remaining in write buffer
+function CombBytesToRead: longint;					// Return # bytes remaining to be read
+function CombBytesRemaining(a: longint): longint;	// Return # bytes remaining to read or write
+function CombAsyncRequest(a: longint): longint;		// Return async read/write request
+
+function CombSetControl(a: longint): longint;		// Set the control line status
+function CombSetMode(a: longint): longint;			// Sets communications mode
+function CombSetBPS(a: longint): longint;			// Sets the transfer rate
+function CombSetPacketSize(a: longint): longint;	// Sets the packet size
+
+function CombReset: longint;						// Reset serial controller
+function CombResetError: longint;					// Reset error bits
+function CombCancelWrite: longint;					// Cancel async write request
+function CombCancelRead: longint;					// Cancel async read request
+
+function CombSetRTS(a: longint): longint;						// Set RTS to 'a'
+function CombCTS: longint;							// Return status of CTS
+
+function CombWaitCallback(a: longint): longint;		// Install wait callback function
+
+function CombResetVBLANK: longint;					// Restart VBLANK signal
+
+
+procedure AddCOMB; stdcall external;
+procedure DelCOMB; stdcall external;
+procedure ChangeClearSIO(x: longint); stdcall external;
+function _comb_control(a, b, c: dword): longint; stdcall external;
+
+
+implementation
+
+function CombSioStatus: longint;
+begin
+	CombSioStatus:= _comb_control(0,0,0);
+end;
+
+function CombControlStatus: longint;
+begin
+	CombControlStatus:= _comb_control(0,1,0);
+end;
+
+function CombGetMode: longint;
+begin
+	CombGetMode:= _comb_control(0,2,0);
+end;
+
+function CombGetBPS: longint;
+begin
+	CombGetBPS:= _comb_control(0,3,0);
+end;
+
+function CombGetPacketSize: longint;
+begin
+	CombGetPacketSize:= _comb_control(0,4,0);
+end;
+
+function CombBytesToWrite: longint;
+begin
+	CombBytesToWrite:= _comb_control(0,5,0);
+end;
+
+function CombBytesToRead: longint;
+begin
+	CombBytesToRead:= _comb_control(0,5,1);
+end;
+
+function CombBytesRemaining(a: longint): longint;
+begin
+	CombBytesRemaining:= _comb_control(0,5,a);
+end;
+
+function CombAsyncRequest(a: longint): longint;
+begin
+	CombAsyncRequest:= _comb_control(0,6,a);
+end;
+
+function CombSetControl(a: longint): longint;
+begin
+	CombSetControl:= _comb_control(1,1,a);
+end;
+
+function CombSetMode(a: longint): longint;
+begin
+	CombSetMode:= _comb_control(1,2,a);
+end;
+
+function CombSetBPS(a: longint): longint;
+begin
+	CombSetBPS:= _comb_control(1,3,a);
+end;
+
+function CombSetPacketSize(a: longint): longint;
+begin
+	CombSetPacketSize:= _comb_control(1,4,a);
+end;
+
+function CombReset: longint;
+begin
+	CombReset:= _comb_control(2,0,0);
+end;
+
+function CombResetError: longint;
+begin
+	CombResetError:= _comb_control(2,1,0);
+end;
+
+function CombCancelWrite: longint;
+begin
+	CombCancelWrite:= _comb_control(2,2,0);
+end;
+
+function CombCancelRead: longint;
+begin
+	CombCancelRead:= _comb_control(2,3,0);
+end;
+
+function CombSetRTS(a: longint): longint;
+begin
+	CombSetRTS:= _comb_control(3,0,a);
+end;
+
+function CombCTS: longint;
+begin
+	CombCTS:= _comb_control(3,1,0);
+end;
+
+function CombWaitCallback(a: longint): longint;
+begin
+	CombWaitCallback:= _comb_control(4,0,a);
+end;
+
+function CombResetVBLANK: longint;
+begin
+	CombResetVBLANK:= _comb_control(5,0,0);
+end;
+
+begin
+end.

psy-q-sdk/bindings/libds.pas

@@ -0,0 +1,197 @@
+unit libds; 
+interface
+uses libstd;
+
+const
+	// CD-ROM Mode (used int CdlSetmode)
+	DslModeStream		= 	$100;// Normal Streaming 
+	DslModeStream2		= 	$120;// SUB HEADER information includes
+	DslModeSpeed		= 	$80;// 0: normal speed	1: double speed
+	DslModeRT			= 	$40;// 0: ADPCM off		1: ADPCM on
+	DslModeSize1		= 	$20;// 0: 2048 byte		1: 2340byte
+	DslModeSize0		= 	$10;// 0: -			1: 2328byte
+	DslModeSF			= 	$08;// 0: Channel off	1: Channel on
+	slModeRept			= 	$04;// 0: Report off	1: Report on
+	DslModeAP			= 	$02;// 0: AutoPause off	1: AutoPause on
+	DslModeDA			= 	$01;// 0: CD-DA off		1: CD-DA on
+
+	// Status contents
+	DslStatPlay			= 	$80;// playing CD-DA
+	DslStatSeek			= 	$40;// seeking
+	DslStatRead			= 	$20;// reading data sectors
+	DslStatShellOpen	=	$10;// once shell open
+	DslStatSeekError	=	$04;// seek error detected
+	DslStatStandby		=	$02;// spindle motor rotating
+	DslStatError		=	$01;// command error detected
+
+	// Macros for DsGetDiskType()
+	DslStatNoDisk		=	$01;
+	DslOtherFormat		=	$02;
+	DslCdromFormat		=	$04;
+
+	// CD-ROM Primitive Commands
+	DslNop				=	$01;// no operation
+	DslSetloc			=	$02;// set head position
+	DslPlay				=	$03;// play CD-DA
+	DslForward			=	$04;// forward DA play
+	DslBackward			=	$05;// backward DA play
+	DslReadN			=	$06;// read data with retry
+	DslStandby			=	$07;// start spindle motor
+	DslStop				=	$08;// stop spindle motor
+	DslPause			=	$09;// pause
+	DslMute				=	$0b;// mute on
+	DslDemute			=	$0c;// mute off
+	DslSetfilter		=	$0d;// set subheader filter
+	DslSetmode			=	$0e;// set mode 
+	DslGetparam			=	$0f;// get mode
+	DslGetlocL			=	$10;// get head position (data sector)
+	DslGetlocP			=	$11;// get head position (DA sector)
+	DslGetTN			=	$13;// get number of TOC
+	DslGetTD			=	$14;// get TOC data
+	DslSeekL			=	$15;// logical seek
+	DslSeekP			=	$16;// phisical seek
+	DslReadS			=	$1B;// read data without retry
+
+	// Interrupts
+	DslNoIntr			=	$00;// No interrupt
+	DslDataReady		=	$01;// Data Read
+	DslComplete			=	$02;// Command Complete
+	DslAcknowledge		=	$03;// Acknowledge (reserved)
+	DslDataEnd			=	$04;// End of Data Detected
+	DslDiskError		=	405;// Error Detected
+
+	DslNoResult			=	$06;
+	DslFinished			=	$07;
+
+function btoi(b: longint): byte;	// BCD to u_char
+function itob(i: byte): longint;	// u_char to BCD
+
+// Position
+const
+  	DslMAXTOC			=	100;
+
+
+// Callback
+//typedef void ( *DslRCB )( u_char, u_char*, u_long* );
+type
+	DslCB = procedure (b: byte; p: pchar);
+	DslRCB = procedure (b: byte; p: pchar; l: Plongint);
+
+
+// Location
+type 
+	DslLOC = packed record
+				minute : byte;		// minute (BCD)
+				second : byte;		// second (BCD)
+				sector : byte;		// sector (BCD)
+				track : byte;		// track (void)
+			 end;
+	PDslLOC = ^DslLOC;
+
+// ADPCM Filter
+	DslFILTER = packed record
+					_file : byte;		// file ID (always 1)
+					chan : byte;		// channel ID
+					pad : u_short;
+				end;
+
+// Attenuator
+	DslATV = packed record
+				val0 : byte;		// volume for CD(L) -> SPU (L)
+				val1 : byte;		// volume for CD(L) -> SPU (R)
+				val2 : byte;		// volume for CD(R) -> SPU (L)
+				val3 : byte;		// volume for CD(R) -> SPU (R)
+			 end;
+	PDslATV = ^DslATV;
+
+// Low Level File System for DsSearchFile() 
+const
+	DslMAXFILE		= 	64;		// max number of files in a directory
+	DslMAXDIR		=	128;	// max number of total directories
+	DslMAXLEVEL		=	8;		// max levels of directories
+
+type
+	DslFILE = packed record
+				pos : DslLOC;					// file location
+				size : dword;					// file size
+				name : array [0..15] of char;	// file name (body)
+			  end;
+	PDslFILE = ^DslFILE;
+
+// system status
+const
+	DslReady	=	1;
+	DslBusy		=	2;
+	DslNoCD		=	3;
+
+// maximum number of commands that can be added to the queue
+	DslMaxCOMMANDS	=	8;
+
+// maximum number of command execution results
+	DslMaxRESULTS	=	8;
+
+function DsInit: integer; stdcall external;
+function DsReset: integer; stdcall external;
+procedure DsClose; stdcall external;
+function DsCommand(com: byte; param: pchar; cbsync: DslCB; count: integer ): integer; stdcall external;
+function DsPacket(mode: byte; pos:PDslLOC; com: byte; func: DslCB; count: integer): integer; stdcall external;
+function DsSyncCallback(func: DslCB): DslCB; stdcall external;
+function DsReadyCallback(func: DslCB): DslCB; stdcall external;
+function DsSync(id: integer; res: pointer): integer; stdcall external;
+function DsReady(res: pointer): integer; stdcall external;
+procedure DsFlush; stdcall external;
+function DsSystemStatus: integer; stdcall external;
+function DsQueueLen: integer; stdcall external;
+function DsStatus: byte; stdcall external;
+function DsShellOpen: integer; stdcall external;
+
+function DsMix(vol: PDslATV): integer; stdcall external;
+function DsGetSector(madr: pointer; size: integer): integer; stdcall external;
+function DsGetSector2(madr: pointer; size: integer): integer; stdcall external;
+function DsGetToc(loc: PDslLOC): integer; stdcall external;
+procedure DsDataCallback(func: pointer); stdcall external;
+function DsDataSync(mode: integer): integer; stdcall external;
+function DsIntToPos(i: integer; p: PDslLOC): PDslLOC; stdcall external;
+function DsPosToInt(p: PDslLOC): integer; stdcall external;
+function DsSetDebug(level: integer ): integer; stdcall external;
+function DsLastPos(p: PDslLOC): PDslLOC; stdcall external;
+function DsLastCom: byte; stdcall external;
+
+function DsComstr(com: byte): pchar; stdcall external;
+function DsIntstr(intr: byte): pchar; stdcall external;
+
+function DsStartReadySystem(func: DslRCB; count: integer): integer; stdcall external;
+procedure DsEndReadySystem; stdcall external;
+function DsReadySystemMode(mode: integer): integer; stdcall external;
+
+function DsControlF(com: byte; param: pchar): integer; stdcall external;
+function DsControl(com: byte; param: pchar; res: pointer): integer; stdcall external;
+function DsControlB(com: byte; param: pchar; res: pointer): integer; stdcall external;
+
+function DsRead(pos: PDslLOC; sectors: integer; buf: Plongint; mode: integer): integer; stdcall external;
+function DsReadSync(res: pointer): integer; stdcall external;
+function DsReadCallback(func: DslCB): DslCB; stdcall external;
+procedure DsReadBreak; stdcall external;
+function DsRead2(pos: PDslLOC; mode: integer): integer; stdcall external;
+
+function DsSearchFile(fp: PDslFILE; name: pchar ): PDslFILE; stdcall external;
+function DsReadFile(_file: pchar; addr: Plongint; nbyte: integer): integer; stdcall external;
+//struct EXEC* DsReadExec( char* file ); stdcall external;
+function DsPlay(mode: integer; tracks: Pinteger; offset: integer): integer; stdcall external;
+
+procedure DsGetDiskType; stdcall external;
+
+implementation
+
+function btoi(b: longint): byte;
+begin
+	btoi:= b div 16 * 10 + b mod 16;
+end;
+
+function itob(i: byte): longint;
+begin
+	itob:= i div 10 * 16 + i mod 10;
+end;
+
+begin
+end.

psy-q-sdk/bindings/libetc.pas

@@ -0,0 +1,82 @@
+//  (C) Copyright 1993/1994 Sony Corporation,Tokyo,Japan. All Rights Reserved
+// 			libetc.h: Pad Interface
+unit libetc;
+interface 
+
+var
+ 	PadIdentifier: integer; external;
+// PAD I/O (SIO Pad)
+const
+	PADLup     = 1 shl 12;
+	PADLdown   = 1 shl 14;
+	PADLleft   = 1 shl 15;
+	PADLright  = 1 shl 13;
+	PADRup     = 1 shl  4;
+	PADRdown   = 1 shl  6;
+	PADRleft   = 1 shl  7;
+	PADRright  = 1 shl  5;
+	PADi       = 1 shl  9;
+	PADj       = 1 shl 10;
+	PADk       = 1 shl  8;
+	PADl       = 1 shl  3;
+	PADm       = 1 shl  1;
+	PADn       = 1 shl  2;
+	PADo       = 1 shl  0;
+	PADh       = 1 shl 11;
+	PADL1      = PADn;
+	PADL2      = PADo;
+	PADR1      = PADl;
+	PADR2      = PADm;
+	PADstart   = PADh;
+	PADselect  = PADk;
+			    
+	MOUSEleft  = 1 shl 3;
+	MOUSEright = 1 shl 2;
+
+// PAD utility macro: _PAD(x,y)
+//   x: controller ID (0 or 1)
+//   y: PAD assign macro
+//
+// Example: _PAD(0,PADstart) ... PADstart of controller 1
+//          _PAD(1,PADLup)   ... PADLup of controller 2
+function _PAD(x, y: longint): longint;
+
+// scratch pad address 0x1f800000 - 0x1f800400 */
+function getScratchAddr(offset: dword): dword;
+
+
+// Video Mode:	NTSC/PAL
+const
+	MODE_NTSC = 0;
+	MODE_PAL  = 1;
+
+function CheckCallback: integer; stdcall; external;
+procedure PadInit(mode: integer); stdcall; external;
+function ResetCallback: integer; stdcall; external;
+function RestartCallback: integer; stdcall; external;
+function StopCallback: integer; stdcall; external;
+function VSync(mode: integer): integer; stdcall; external;
+function VSyncCallback(f: pointer): integer; stdcall; external;
+function GetVideoMode: longint; stdcall; external;
+function SetVideoMode(mode: longint): longint; stdcall; external;
+function PadRead(id: integer): dword; stdcall; external;
+procedure PadStop; stdcall; external;
+
+
+implementation
+
+
+function _PAD(x, y: longint): longint;
+begin
+	_PAD:= y shl x shl 4;
+end;
+
+
+function getScratchAddr(offset: dword): dword;
+begin
+	getScratchAddr:= $1f800000+(offset*4);
+end;
+
+
+begin
+end.

psy-q-sdk/bindings/libgpu.pas

@@ -0,0 +1,1742 @@
+//  (C) Copyright 1993-1995 Sony Corporation,Tokyo,Japan. All Rights Reserved
+// 		libgpu.h: Graphic Primitive Structures Database
+{
+ *
+ * Primitive list:
+ *
+ *      Name     |Size*1|Shade  |Vertex |Texture| Function
+ *      ---------+------+-------+-------+-------+------------------------
+ *      POLY_F3  | 5	|Flat   |   3   |OFF    | Flat Triangle
+ *      POLY_FT3 | 8	|Flat   |   3   |ON     | Flat Textured Triangle
+ *      POLY_G3  | 7	|Gouraud|   3   |OFF    | Gouraud Triangle
+ *      POLY_GT3 |10	|Gouraud|   3   |ON     | Gouraud Textured Triangle
+ *      POLY_F4  | 6	|Flat   |   4   |OFF    | Flat Quadrangle
+ *      POLY_FT4 |10	|Flat   |   4   |ON     | Flat Textured Quadrangle
+ *      POLY_G4  | 9	|Gouraud|   4   |OFF    | Gouraud Quadrangle
+ *      POLY_GT4 |13	|Gouraud|   4   |ON     | Gouraud Textured Quadrangle
+ *      ---------+------+-------+-------+-------+------------------------
+ *      LINE_F2  | 4	|Flat   |   2   | -     | unconnected Flat Line 
+ *      LINE_G2  | 5	|Gouraud|   2   | -     | unconnected Gouraud Line 
+ *      LINE_F3  | 6	|Flat	|   3	| -     | 3-connected Flat Line
+ *      LINE_G3  | 8	|Gouraud|   3	| -     | 3-connected Gouraud Line
+ *      LINE_F4  | 7	|Flat	|   4	| -    	| 4-connected Flat Line
+ *      LINE_G4  |10	|Gouraud|   4	| -    	| 4-connected Gouraud Line
+ *      ---------+------+-------+-------+-------+------------------------
+ *      SPRT	 | 5	|Flat	|   1   |ON     | free size Sprite
+ *      SPRT_16	 | 4	|Flat	|   1   |ON     | 16x16 Sprite
+ *      SPRT_8	 | 4	|Flat	|   1   |ON     | 8x8 Sprite
+ *      ---------+------+-------+-------+-------+------------------------
+ *      TILE	 | 4	|Flat	|   1   |OFF    | free size Sprite
+ *      TILE_16	 | 3	|Flat	|   1   |OFF    | 16x16 Sprite
+ *      TILE_8	 | 3	|Flat	|   1   |OFF    | 8x8 Sprite
+ *      TILE_1	 | 3	|Flat	|   1   |OFF    | 1x1 Sprite
+ *      ---------+------+-------+-------+-------+------------------------
+ *      DR_TWIN	 | 3	|   -	|   -   | -     | Texture Window
+ *      DR_AREA	 | 3	|   -	|   -   | -     | Drawing Area
+ *      DR_OFFSET| 3	|   -	|   -   | -     | Drawing Offset
+ *      DR_MODE  | 3	|   -	|   -   | -     | Drawing Mode
+ *      DR_ENV   |16	|   -	|   -	| -     | Drawing Environment
+ *      DR_MOVE  | 6	|   -	|   -	| -     | MoveImage
+ *      DR_LOAD  |17	|   -	|   -	| -     | LoadImage
+ *      DR_TPAGE | 2    |   -   |   -   | -     | Drawing TPage
+ *      DR_STP   | 3    |   -   |   -   | -     | Drawing STP
+ *
+ *	*1: in long-word
+ *
+ * Texture Attributes:
+ *	abr: ambient rate
+ *		abr	0	1	2	3
+ *		-------------------------------------
+ *		Front	0.5	1.0	0.5	-1.0
+ *		Back	0.5	1.0	1.0	 1.0
+ *
+ *	tp: texture mode
+ *		 tp	0	1	2	
+ *		 -----------------------------
+ *		 depth	4bit	8bit	16bit
+ *		 color	CLUT	CLUT	DIRECT
+}
+unit libgpu; 
+interface
+uses libgte;
+
+function GPU_printf(fmt: pchar): longint; varargs; stdcall; external; // printf() object
+
+// Time-out Cycle
+const
+	WAIT_TIME	=	$800000;
+
+//	General
+procedure limitRange(var x: integer; l, h: integer); inline;
+
+
+
+
+// Rectangle:
+type
+	RECT = packed record
+			x, y : smallint;	// offset point on VRAM
+			w, h : smallint;	// width and height
+	       end;
+	PRECT = ^RECT;
+
+	RECT32 = packed record
+			x, y : longint;		// offset point on VRAM
+			w, h : longint;		// width and height
+		 end;
+
+
+// Environment 
+
+	DR_ENV = packed record			// Packed Drawing Environment
+			tag : dword;
+			code : array [0..14] of dword;
+		 end;
+	PDR_ENV = ^DR_ENV;
+
+	       
+	DRAWENV = packed record
+				clip : RECT;						// clip area
+				ofs : array [0..1] of smallint;		// drawing offset
+				tw : RECT;							// texture window
+				tpage : word;						// texture page
+				dtd : byte;							// dither flag (0:off, 1:on)
+				dfe : byte;							// flag to draw on display area (0:off 1:on)
+				isbg : byte;						// enable to auto-clear
+				r0, g0, b0 : byte;					// initital background color
+				_dr_env : DR_ENV;					// reserved
+			  end;
+	PDRAWENV = ^DRAWENV;
+	       
+	DISPENV = packed record
+				disp : RECT;						// display area
+				screen : RECT;						// display start point
+				isinter : byte;						// interlace 0: off 1: on
+				isrgb24 : byte;						// RGB24 bit mode
+				pad0, pad1 : byte;					// reserved
+			  end;
+	PDISPENV = ^DISPENV;
+
+// Polygon Primitive Definitions
+	P_TAG = bitpacked record
+        		addr: 0..16777215; 						// 24-bit address (24 bits can represent numbers from 0 to 16777215)
+        		len: 0..255;       						// 8-bit length (8 bits can represent numbers from 0 to 255)
+        		r0, g0, b0, code: Byte;
+          	end;
+	
+	P_CODE = packed record
+				r0, g0, b0, code : byte;
+			 end;
+	
+	POLY_F3 = packed record							// Flat Triangle
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0,	y0 : smallint;
+			x1,	y1 : smallint;
+			x2,	y2 : smallint;
+		  end;
+	PPOLY_F3 = ^POLY_F3;
+
+	POLY_F4 = packed record 						// Flat Quadrangle
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0,	y0 : smallint;
+			x1,	y1 : smallint;
+			x2,	y2 : smallint;
+			x3,	y3 : smallint;
+		  end;
+	PPOLY_F4 = ^POLY_F4;
+
+
+
+	POLY_FT3 = packed record	  					// Flat Textured Triangle
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0,	y0 : smallint;
+			u0, v0 : byte;
+			clut : word;
+			x1,	y1 : smallint;
+			u1, v1 : byte;
+			tpage : word;
+			x2,	y2 : smallint;
+			u2, v2 : byte;
+			pad1 : word;
+		   end;
+	PPOLY_FT3 = ^POLY_FT3;
+
+	POLY_FT4 = packed record						// Flat Textured Quadrangle
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			u0, v0 : byte;	
+			clut : word;
+			x1,	y1 : smallint;
+			u1, v1 : byte;
+			tpage : word;
+			x2,	y2 : smallint;
+			u2, v2 : byte;
+			pad1 : word;
+			x3,	y3 : smallint;
+			u3, v3 : byte;
+			pad2 : word;
+		   end;
+	PPOLY_FT4 = ^POLY_FT4;
+
+	POLY_G3 = packed record							// Gouraud Triangle
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0,	y0 : smallint;
+			r1, g1, b1, pad1 : byte;
+			x1,	y1 : smallint;
+			r2, g2, b2, pad2 : byte;
+			x2,	y2 : smallint;
+		  end;
+	PPOLY_G3 = ^POLY_G3;
+
+	POLY_G4 = packed record							// Gouraud Quadrangle
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0,	y0 : smallint;
+			r1, g1, b1, pad1 : byte;
+			x1,	y1 : smallint;
+			r2, g2, b2, pad2 : byte;
+			x2,	y2 : smallint;
+			r3, g3, b3, pad3 : byte;
+			x3,	y3 : smallint;
+		  end;
+	PPOLY_G4 = ^POLY_G4;
+
+	POLY_GT3 = packed record						// Gouraud Textured Triangle
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			u0, v0 : byte;
+			clut : word;
+			r1, g1, b1, p1 : byte;
+			x1,	y1 : smallint;
+			u1, v1 : byte;	
+			tpage : word;
+			r2, g2, b2, p2 : byte;
+			x2,	y2 : smallint;
+			u2, v2 : byte;	
+			pad2 : word;
+		  end;
+	PPOLY_GT3 = ^POLY_GT3;
+
+	POLY_GT4 = packed record 						// Gouraud Textured Quadrangle
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			u0, v0 : byte;
+			clut : word;
+			r1, g1, b1, p1 : byte;
+			x1, y1 : smallint;
+			u1, v1 : byte;	
+			tpage : word;
+			r2, g2, b2, p2 : byte;
+			x2, y2 : smallint;
+			u2, v2 : byte;	
+			pad2 : word;
+			r3, g3, b3, p3 : byte;
+			x3, y3 : smallint;
+			u3, v3 : byte;	
+			pad3 : word;
+		 end;
+	PPOLY_GT4 = ^POLY_GT4;
+
+
+// Line Primitive Definitions
+	LINE_F2 = packed record							// Unconnected Flat Line
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			x1, y1 : smallint;
+		  end;
+	PLINE_F2 = ^LINE_F2;
+
+	LINE_G2 = packed record							// Unconnected Gouraud Line
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			r1, g1, b1, p1 : byte;
+			x1, y1 : smallint;
+		  end;
+	PLINE_G2 = ^LINE_G2;
+
+	LINE_F3 = packed record							// 2 connected Flat Line
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			x1, y1 : smallint;
+			x2, y2 : smallint;
+			pad : dword;
+		  end;
+	PLINE_F3 = ^LINE_F3;
+
+
+	LINE_G3 = packed record							// 2 connected Gouraud Line
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			r1, g1, b1, p1 : byte;
+			x1, y1 : smallint;
+			r2, g2, b2, p2 : byte;
+			x2, y2 : smallint;
+			pad : dword;
+		  end;
+	PLINE_G3 = ^LINE_G3;
+
+	LINE_F4 = packed record							// 3 connected Flat Line Quadrangle
+				tag : dword;
+				r0, g0, b0, code : byte;
+				x0, y0 : smallint;
+				x1, y1 : smallint;
+				x2, y2 : smallint;
+				x3, y3 : smallint;
+				pad : dword;
+		  end;
+	PLINE_F4 = ^LINE_F4;
+
+	LINE_G4 = packed record							// 3 connected Gouraud Line
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			r1, g1, b1, p1 : byte;
+			x1, y1 : smallint;
+			r2, g2, b2, p2 : byte;
+			x2, y2 : smallint;
+			r3, g3, b3, p3 : byte;
+			x3, y3 : smallint;
+			pad : dword;
+		  end;
+	PLINE_G4 = ^LINE_G4;
+
+
+// Sprite Primitive Definitions
+	SPRT = packed record							// free size Sprite
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			u0, v0 : byte;	
+			clut : word;
+			w, h : smallint;
+	      end;
+	PSPRT = ^SPRT;
+
+	SPRT_16 = packed record						// 16x16 Sprite
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			u0, v0 : byte;
+			clut : word;
+		  end;
+	PSPRT_16 = ^SPRT_16;
+
+	       
+ 	SPRT_8 = packed record							// 8x8 Sprite
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0,	y0 : smallint;
+			u0, v0 : byte;	
+			clut : word;
+		  end;
+	PSPRT_8 = ^SPRT_8;
+	       
+// Tile Primitive Definitions
+	TILE = packed record							// free size Tile
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+			w, h : smallint;
+	       end;
+	PTILE = ^TILE;
+
+	TILE_16 = packed record							// 16x16 Tile
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+		  end;
+	PTILE_16 = ^TILE_16;
+
+
+
+	TILE_8 = packed record							// 8x8 Tile
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+		 end;
+	PTILE_8 = ^TILE_8;
+
+
+	TILE_1 = packed record							// 1x1 Tile
+			tag : dword;
+			r0, g0, b0, code : byte;
+			x0, y0 : smallint;
+		 end;
+	PTILE_1 = TILE_1;
+
+//  Special Primitive Definitions
+	DR_MODE = packed record							// Drawing Mode
+			tag : dword;
+			code : array [0..1] of dword;
+		  end;
+	PDR_MODE = ^DR_MODE;
+
+	DR_TWIN = packed record							// Texture Window
+			tag : dword;
+			code : array [0..1] of dword;
+		  end;
+	PDR_TWIN =^DR_TWIN;
+
+	DR_AREA = packed record							// Drawing Area
+			tag : dword;
+			code : array [0..1] of dword;
+		  end;
+	PDR_AREA = ^DR_AREA;
+
+	       
+	DR_OFFSET = packed record						// Drawing Offset
+			tag : dword;
+			code : array [0..1] of dword;
+	 	    end;
+	PDR_OFFSET = ^DR_OFFSET;
+
+	       
+ 	DR_MOVE = packed record							// MoveImage
+			tag : dword;
+			code : array [0..4] of dword;
+		  end;
+	PDR_MOVE = ^DR_MOVE;
+
+
+	DR_LOAD	= packed record							// LoadImage
+			tag : dword;
+			code : array [0..2] of dword;
+			p : array [0..12] of dword;
+		  end;
+	PDR_LOAD = ^DR_LOAD;
+
+	DR_TPAGE = packed record						// Drawing TPage
+			tag : dword;
+			code : array [0..0] of dword;
+		   end;
+	PDR_TPAGE = DR_TPAGE;
+
+	DR_STP = packed record                          // Drawing STP
+        		tag : dword;
+       			code : array [0..1] of dword;
+        	 end;
+        PDR_STP = DR_STP;
+
+
+//	Font Stream Parameters
+const 
+	FNT_MAX_ID = 8;									// max number of stream ID
+	FNT_MAX_SPRT = 1024;							// max number of sprites in all streams
+
+
+//	Multi-purpose Sony-TMD primitive
+type
+	TMD_PRIM = packed record
+				id : dword;	
+				r0, g0, b0, p0 : byte;				// Color of vertex 0
+				r1, g1, b1, p1 : byte;				// Color of vertex 1
+				r2, g2, b2, p2 : byte;				// Color of vertex 2
+				r3, g3, b3, p3 : byte;				// Color of vertex 3
+				tpage, clut : word;					// texture page ID, clut ID
+				u0, v0, u1, v1 : byte;				// texture corner point
+				u2, v2, u3, v3 : byte;
+				
+				// independent vertex model
+				x0, x1, x2, x3 : SVECTOR;			// 3D corner point
+				n0, n1, n2, n3 : SVECTOR;			// 3D corner normal vector
+				
+				// Common vertex model
+				v_ofs : PSVECTOR;					// offset to vertex database
+				n_ofs : PSVECTOR;					// offset to normal database
+				
+				vert0, vert1 : word; 				// index of vertex
+				vert2, vert3 : word;		
+				norm0, norm1 : word; 				// index of normal
+				norm2, norm3 : word;
+		   end;
+	PTMD_PRIM = ^TMD_PRIM;
+	
+
+
+// Multi-purpose TIM image
+	TIM_IMAGE = packed record
+			mode : dword;					// pixel mode
+			crect : PRECT;					// CLUT rectangle on frame buffer
+			caddr : pdword;					// CLUT address on main memory
+			prect : PRECT;					// texture image rectangle on frame buffer
+			paddr : pdword;					// texture image address on main memory
+		    end;
+	PTIM_IMAGE = ^TIM_IMAGE;
+
+function FntPrint(Args: pchar): longint; varargs; stdcall; external;
+function KanjiFntPrint(Args: pchar): longint; varargs; stdcall; external;
+function FntPrint: longint; stdcall; external;
+function KanjiFntPrint: longint; stdcall; external;
+	
+function GetDispEnv(env: PDISPENV): PDISPENV; stdcall; external;
+function PutDispEnv(env: PDISPENV): PDISPENV; stdcall; external;
+function SetDefDispEnv(env: PDISPENV; x, y, w, h: longint): PDISPENV; stdcall; external;
+function GetDrawEnv(env: PDRAWENV): PDRAWENV; stdcall; external;
+function PutDrawEnv(env: PDRAWENV): PDRAWENV; stdcall; external;
+function SetDefDrawEnv(env: PDRAWENV; x, y, w, h: longint): PDRAWENV; stdcall; external;
+function ReadTIM(timimg: PTIM_IMAGE): PTIM_IMAGE; stdcall; external;
+function ReadTMD(tmdprim: PTMD_PRIM): PTMD_PRIM; stdcall; external;
+function CheckPrim(s: pchar; p: pdword): longint; stdcall; external;
+function ClearImage(rect: PRECT; r, g, b: byte): longint; stdcall; external;
+function ClearImage2(rect: PRECT; r, g, b: byte): longint; stdcall; external;
+function DrawSync(mode: longint): longint; stdcall; external;
+function FntOpen(x, y, w, h: longint; isbg, n: longint): longint; stdcall; external;
+function GetGraphDebug: longint; stdcall; external;
+function GetTimSize(sjis: pbyte): longint; stdcall; external;
+function IsEndPrim(p: pointer): longint; stdcall; external;
+function KanjiFntOpen(x, y, w, h: longint; dx, dy, cx, cy: longint; isbg, n: longint): longint; stdcall; external;
+procedure KanjiFntClose; stdcall; external;
+function Krom2Tim(sjis: pbyte; taddr:pdword; dx, dy, cdx, cdy: longint; fg, bg: dword): longint; stdcall; external;
+function LoadImage(rect: PRECT; p: pointer): longint; stdcall; external;
+function MargePrim(p0, p1: pointer): longint; stdcall; external;
+function MoveImage(rect: PRECT; x, y: longint): longint; stdcall; external;
+function OpenTIM(addr: pointer): longint; stdcall; external;
+function OpenTMD(tmd: pdword; obj_no: longint): longint; stdcall; external;
+function ResetGraph(mode: longint): longint; stdcall; external;
+function SetGraphDebug(level: longint): longint; stdcall; external;
+function StoreImage(rect: PRECT; p: pointer): longint; stdcall; external;
+function ClearOTag(ot: pointer; n: longint): pdword; stdcall; external;
+function ClearOTagR(ot: pointer; n: longint): pdword; stdcall; external;
+function FntFlush(id: longint): pdword; stdcall; external;
+function KanjiFntFlush(id: longint): pdword; stdcall; external;
+function DrawSyncCallback(func: pointer): longint; stdcall; external;
+function GetClut(x, y: longint): word; stdcall; external;
+function GetTPage(tp, abr: longint; x, y: longint): word; stdcall; external;
+function LoadClut(clut: pointer; x, y: longint): word; stdcall; external;
+function LoadClut2(clut: pointer; x, y: longint): word; stdcall; external;
+function LoadTPage(pix: pointer; tp, abr: longint; x, y, w, h: longint): word; stdcall; external;
+function NextPrim(p: pointer): pointer; stdcall; external;
+procedure AddPrim(ot: pointer; p: pointer); stdcall; external;
+procedure AddPrims(ot: pointer; p0, p1: pointer); stdcall; external;
+procedure CatPrim(p0, p1: pointer); stdcall; external;
+procedure DrawOTag(p: pointer); stdcall; external;
+procedure DrawOTagIO(p: pointer); stdcall; external;
+procedure DrawOTagEnv(p: pointer; env: PDRAWENV); stdcall; external;
+procedure DrawPrim(p: pointer); stdcall; external;
+procedure DumpClut(clut: word); stdcall; external;
+procedure DumpDispEnv(env: PDISPENV); stdcall; external;
+procedure DumpDrawEnv(env: PDRAWENV); stdcall; external;
+procedure DumpOTag(p: pointer); stdcall; external;
+procedure DumpTPage(tpage: word); stdcall; external;
+procedure FntLoad(tx, ty: longint); stdcall; external;
+procedure SetDispMask(mask: longint); stdcall; external;
+procedure SetDrawArea(p: PDR_AREA; r: PRECT); stdcall; external;
+procedure SetDrawEnv(dr_env: PDR_ENV; env: PDRAWENV); stdcall; external;
+procedure SetDrawLoad(p: PDR_LOAD; rect: PRECT); stdcall; external;
+procedure SetDrawMode(p: PDR_MODE; dfe, dtd: longint; tpage: longint; tw: PRECT); stdcall; external;
+procedure SetDrawTPage(p: PDR_TPAGE; dfe, dtd: longint; tpage: longint); stdcall; external;
+procedure SetDrawMove(p: PDR_MOVE; r: PRECT; x, y: longint); stdcall; external;
+procedure SetDrawOffset(p: PDR_OFFSET; ofs: pword); stdcall; external;
+procedure SetDrawStp(p: PDR_STP; pbw: longint); stdcall; external;
+procedure SetDumpFnt(id: longint); stdcall; external;
+procedure SetLineF2(p: PLINE_F2); stdcall; external;
+procedure SetLineF3(p: PLINE_F3); stdcall; external;
+procedure SetLineF4(p: PLINE_F4); stdcall; external;
+procedure SetLineG2(p: PLINE_G2); stdcall; external;
+procedure SetLineG3(p: PLINE_G3); stdcall; external;
+procedure SetLineG4(p: PLINE_G4); stdcall; external;
+procedure SetPolyF3(p: PPOLY_F3); stdcall; external;
+procedure SetPolyF4(p: PPOLY_F4); stdcall; external;
+procedure SetPolyFT3(p: PPOLY_FT3); stdcall; external;
+procedure SetPolyFT4(p: PPOLY_FT4); stdcall; external;
+procedure SetPolyG3(p: PPOLY_G3); stdcall; external;
+procedure SetPolyG4(p: PPOLY_G4); stdcall; external;
+procedure SetPolyGT3(p: PPOLY_GT3); stdcall; external;
+procedure SetPolyGT4(p: PPOLY_GT4); stdcall; external;
+procedure SetSemiTrans(p: pointer; abe: longint); stdcall; external;
+procedure SetShadeTex(p: pointer; tge: longint); stdcall; external;
+procedure SetSprt(p: PSPRT); stdcall; external;
+procedure SetSprt16(p: PSPRT_16); stdcall; external;
+procedure SetSprt8(p: PSPRT_8); stdcall; external;
+procedure SetTexWindow(p: PDR_TWIN; tw: PRECT); stdcall; external;
+procedure SetTile(p: PTILE); stdcall; external;
+procedure SetTile1(p: PTILE_1); stdcall; external;
+procedure SetTile16(p: PTILE_16); stdcall; external;
+procedure SetTile8(p: PTILE_8); stdcall; external;
+procedure TermPrim(p: pointer); stdcall; external;
+function BreakDraw: pdword; stdcall; external;
+procedure ContinueDraw(insaddr: pdword; contaddr: pdword); stdcall; external;
+function IsIdleGPU(max_count: longint): longint; stdcall; external;
+function GetODE: longint; stdcall; external;
+function LoadImage2(_rect: PRECT; p: pointer): longint; stdcall; external;
+function StoreImage2(_rect: PRECT; p: pointer): longint; stdcall; external;
+function MoveImage2(_rect: PRECT; x, y: longint): longint; stdcall; external;
+function DrawOTag2(p: pointer): longint; stdcall; external;
+procedure GetDrawMode(p: PDR_MODE); stdcall; external;
+procedure GetTexWindow(p: PDR_TWIN); stdcall; external;
+procedure GetDrawArea(p: PDR_AREA); stdcall; external;
+procedure GetDrawOffset(p: PDR_OFFSET); stdcall; external;
+procedure GetDrawEnv2(p: PDR_ENV); stdcall; external;
+
+
+
+
+
+//	Set/Add Vector/Rectangle Attributes
+procedure setVector(var v: VECTOR; const x, y, z: longint);
+procedure setVector(var v: SVECTOR; const x, y, z: smallint);
+procedure setVector(var v: DVECTOR; const x, y, z: smallint);
+
+{
+#define applyVector(v, _x, _y, _z, op) \
+	(v)->vx op _x, (v)->vy op _y, (v)->vz op _z	
+}
+
+procedure copyVector(var v0: VECTOR; const v1: VECTOR);
+procedure copyVector(var v0: SVECTOR; const v1: SVECTOR);
+procedure copyVector(var v0: DVECTOR; const v1: DVECTOR);
+
+procedure addVector(var v0: VECTOR; const v1: VECTOR);
+procedure addVector(var v0: SVECTOR; const v1: SVECTOR);
+procedure addVector(var v0: DVECTOR; const v1: DVECTOR);
+
+
+procedure dumpVector(str: pchar; const v: VECTOR);
+procedure dumpVector(str: pchar; const v: SVECTOR);
+procedure dumpVector(str: pchar; const v: DVECTOR);
+
+procedure dumpMatrix(const x: MATRIX);
+
+procedure setRECT(var r: RECT; const x, y, w, h: longint);
+
+(*
+ *	Set Primitive Attributes
+ */
+#define setTPage(p,tp,abr,x,y) \
+	((p)->tpage = getTPage(tp,abr,x,y))
+
+#define setClut(p,x,y) \
+	((p)->clut = getClut(x,y))
+*)					   
+
+// Set Primitive Colors
+procedure setRGB0(var p: POLY_F3; const r, g, b: byte);
+procedure setRGB0(var p: POLY_F4; const r, g, b: byte);
+procedure setRGB0(var p: POLY_FT3; const r, g, b: byte);
+procedure setRGB0(var p: POLY_FT4; const r, g, b: byte);
+procedure setRGB0(var p: POLY_G3; const r, g, b: byte);
+procedure setRGB0(var p: POLY_G4; const r, g, b: byte);
+procedure setRGB0(var p: POLY_GT3; const r, g, b: byte);
+procedure setRGB0(var p: POLY_GT4; const r, g, b: byte);
+procedure setRGB0(var c: DRAWENV; r, g, b: byte);
+
+procedure setRGB1(var p: POLY_G3; const r, g, b: byte);
+procedure setRGB1(var p: POLY_G4; const r, g, b: byte);
+procedure setRGB1(var p: POLY_GT3; const r, g, b: byte);
+procedure setRGB1(var p: POLY_GT4; const r, g, b: byte);
+
+procedure setRGB2(var p: POLY_G3; const r, g, b: byte);
+procedure setRGB2(var p: POLY_G4; const r, g, b: byte);
+procedure setRGB2(var p: POLY_GT3; const r, g, b: byte);
+procedure setRGB2(var p: POLY_GT4; const r, g, b: byte);
+
+procedure setRGB3(var p: POLY_G4; const r, g, b: byte);
+procedure setRGB3(var p: POLY_GT4; const r, g, b: byte);
+
+
+// Set Primitive Screen Points
+procedure setXY0(var p: POLY_F3; const x, y: smallint);
+procedure setXY0(var p: POLY_F4; const x, y: smallint);
+procedure setXY0(var p: POLY_FT3; const x, y: smallint);
+procedure setXY0(var p: POLY_FT4; const x, y: smallint);
+procedure setXY0(var p: POLY_G3; const x, y: smallint);
+procedure setXY0(var p: POLY_G4; const x, y: smallint);
+procedure setXY0(var p: POLY_GT3; const x, y: smallint);
+procedure setXY0(var p: POLY_GT4; const x, y: smallint);
+
+
+
+(*
+#define setXY2(p,_x0,_y0,_x1,_y1)					\
+	(p)->x0 = (_x0), (p)->y0 = (_y0),				\
+	(p)->x1 = (_x1), (p)->y1 = (_y1)
+
+#define setXY3(p,_x0,_y0,_x1,_y1,_x2,_y2)				\
+	(p)->x0 = (_x0), (p)->y0 = (_y0),				\
+	(p)->x1 = (_x1), (p)->y1 = (_y1),				\
+	(p)->x2 = (_x2), (p)->y2 = (_y2)
+
+#define setXY4(p,_x0,_y0,_x1,_y1,_x2,_y2,_x3,_y3) 			\
+	(p)->x0 = (_x0), (p)->y0 = (_y0),				\
+	(p)->x1 = (_x1), (p)->y1 = (_y1),				\
+	(p)->x2 = (_x2), (p)->y2 = (_y2),				\
+	(p)->x3 = (_x3), (p)->y3 = (_y3)
+
+#define setXYWH(p,_x0,_y0,_w,_h)					\
+	(p)->x0 = (_x0),      (p)->y0 = (_y0),				\
+	(p)->x1 = (_x0)+(_w), (p)->y1 = (_y0),				\
+	(p)->x2 = (_x0),      (p)->y2 = (_y0)+(_h),			\
+	(p)->x3 = (_x0)+(_w), (p)->y3 = (_y0)+(_h)
+
+/*
+ * Set Primitive Width/Height
+ */
+#define setWH(p,_w,_h)	(p)->w = _w, (p)->h = _h
+
+/*
+ * Set Primitive Texture Points
+ */
+#define setUV0(p,_u0,_v0)						\
+	(p)->u0 = (_u0), (p)->v0 = (_v0)				\
+	
+#define setUV3(p,_u0,_v0,_u1,_v1,_u2,_v2)				\
+	(p)->u0 = (_u0), (p)->v0 = (_v0),				\
+	(p)->u1 = (_u1), (p)->v1 = (_v1),				\
+	(p)->u2 = (_u2), (p)->v2 = (_v2)
+	
+#define setUV4(p,_u0,_v0,_u1,_v1,_u2,_v2,_u3,_v3) 			\
+	(p)->u0 = (_u0), (p)->v0 = (_v0),				\
+	(p)->u1 = (_u1), (p)->v1 = (_v1),				\
+	(p)->u2 = (_u2), (p)->v2 = (_v2),				\
+	(p)->u3 = (_u3), (p)->v3 = (_v3)
+
+#define setUVWH(p,_u0,_v0,_w,_h)					\
+	(p)->u0 = (_u0),      (p)->v0 = (_v0),				\
+	(p)->u1 = (_u0)+(_w), (p)->v1 = (_v0),				\
+	(p)->u2 = (_u0),      (p)->v2 = (_v0)+(_h),			\
+	(p)->u3 = (_u0)+(_w), (p)->v3 = (_v0)+(_h)
+*)
+	
+
+// Dump Primivie Parameters
+procedure dumpRECT(r: RECT);
+
+(*
+procedure dumpWH(p)	GPU_printf("(%d,%d)\n", (p)->w,  (p)->h ) 
+#define dumpXY0(p)	GPU_printf("(%d,%d)\n", (p)->x0, (p)->y0) 
+#define dumpUV0(p)	GPU_printf("(%d,%d)\n", (p)->u0, (p)->v0) 
+
+#define dumpXY2(p)							\
+	GPU_printf("(%d,%d)-(%d,%d)\n",					\
+	(p)->x0, (p)->y0, (p)->x1, (p)->y1)
+
+#define dumpXY3(p)							\
+	GPU_printf("(%d,%d)-(%d,%d)-(%d,%d)\n",				\
+	(p)->x0, (p)->y0, (p)->x1, (p)->y1,				\
+	(p)->x2, (p)->y2)
+
+#define dumpUV3(p)							\
+	GPU_printf("(%d,%d)-(%d,%d)-(%d,%d)\n",				\
+	(p)->u0, (p)->v0, (p)->u1, (p)->v1,				\
+	(p)->u2, (p)->v2)
+
+#define dumpXY4(p)							\
+	GPU_printf("(%d,%d)-(%d,%d)-(%d,%d)-(%d,%d)\n",			\
+	(p)->x0, (p)->y0, (p)->x1, (p)->y1,				\
+	(p)->x2, (p)->y2, (p)->x3, (p)->y3)
+
+#define dumpUV4(p)							\
+	GPU_printf("(%d,%d)-(%d,%d)-(%d,%d)-(%d,%d)\n",			\
+	(p)->u0, (p)->v0, (p)->u1, (p)->v1,				\
+	(p)->u2, (p)->v2, (p)->u3, (p)->v3)			
+
+#define dumpRGB0(p)							\
+	GPU_printf("(%3d,%3d,%3d)\n", (p)->r0, (p)->g0, (p)->b0) 	
+		   
+#define dumpRGB1(p)							\
+	GPU_printf("(%3d,%3d,%3d)\n", (p)->r1, (p)->g1, (p)->b1)	
+		   
+#define dumpRGB2(p)							\
+	GPU_printf("(%3d,%3d,%3d)\n", (p)->r2, (p)->g2, (p)->b2) 
+		   
+#define dumpRGB3(p)							\
+	GPU_printf("(%3d,%3d,%3d)\n", (p)->r3, (p)->g3, (p)->b3) 	
+*)
+
+
+// Primitive Handling Macros
+procedure setlen(var p: P_TAG; const len: byte);
+procedure setlen(var p: POLY_F3; const len: byte);
+procedure setlen(var p: POLY_FT3; const len: byte);
+procedure setlen(var p: POLY_G3; const len: byte);
+procedure setlen(var p: POLY_GT3; const len: byte);
+procedure setlen(var p: POLY_F4; const len: byte);
+procedure setlen(var p: POLY_FT4; const len: byte);
+procedure setlen(var p: POLY_G4; const len: byte);
+procedure setlen(var p: POLY_GT4; const len: byte);
+procedure setlen(var p: SPRT_8; const len: byte);
+procedure setlen(var p: SPRT_16; const len: byte);
+procedure setlen(var p: SPRT; const len: byte);
+procedure setlen(var p: TILE_1; const len: byte);
+procedure setlen(var p: TILE_8; const len: byte);
+procedure setlen(var p: TILE_16; const len: byte);
+procedure setlen(var p: TILE; const len: byte);
+procedure setlen(var p: LINE_F2; const len: byte);
+procedure setlen(var p: LINE_G2; const len: byte);
+procedure setlen(var p: LINE_F3; const len: byte);
+procedure setlen(var p: LINE_G3; const len: byte);
+procedure setlen(var p: LINE_F4; const len: byte);
+procedure setlen(var p: LINE_G4; const len: byte);
+
+
+procedure setaddr(var p: P_TAG; const addr: dword);
+
+
+
+procedure setcode(var p: P_TAG; const code: byte);
+procedure setcode(var p: POLY_F3; const code: byte);
+procedure setcode(var p: POLY_FT3; const code: byte);
+procedure setcode(var p: POLY_G3; const code: byte);
+procedure setcode(var p: POLY_GT3; const code: byte);
+procedure setcode(var p: POLY_F4; const code: byte);
+procedure setcode(var p: POLY_FT4; const code: byte);
+procedure setcode(var p: POLY_G4; const code: byte);
+procedure setcode(var p: POLY_GT4; const code: byte);
+procedure setcode(var p: SPRT_8; const code: byte);
+procedure setcode(var p: SPRT_16; const code: byte);
+procedure setcode(var p: SPRT; const code: byte);
+procedure setcode(var p: TILE_1; const code: byte);
+procedure setcode(var p: TILE_8; const code: byte);
+procedure setcode(var p: TILE_16; const code: byte);
+procedure setcode(var p: TILE; const code: byte);
+procedure setcode(var p: LINE_F2; const code: byte);
+procedure setcode(var p: LINE_G2; const code: byte);
+procedure setcode(var p: LINE_F3; const code: byte);
+procedure setcode(var p: LINE_G3; const code: byte);
+procedure setcode(var p: LINE_F4; const code: byte);
+procedure setcode(var p: LINE_G4; const code: byte);
+
+
+function getlen(p: P_TAG): byte;
+function getcode(p: P_TAG): byte;
+function getaddr(p: P_TAG): dword;
+
+
+{
+#define nextPrim(p)  		(void *)((((P_TAG *)(p))->addr)|0x80000000)
+#define isendprim(p) 		((((P_TAG *)(p))->addr)==0xffffff)
+
+#define addPrim(ot, p)		setaddr(p, getaddr(ot)), setaddr(ot, p)
+#define addPrims(ot, p0, p1)	setaddr(p1, getaddr(ot)),setaddr(ot, p0)
+
+#define catPrim(p0, p1)		setaddr(p0, p1)
+#define termPrim(p)		setaddr(p, 0xffffffff)
+
+#define setSemiTrans(p, abe) \
+	((abe)?setcode(p, getcode(p)|0x02):setcode(p, getcode(p)&~0x02))
+
+#define setShadeTex(p, tge) \
+	((tge)?setcode(p, getcode(p)|0x01):setcode(p, getcode(p)&~0x01))
+
+#define getTPage(tp, abr, x, y) 					\
+	 ((((tp)&0x3)<<7)|(((abr)&0x3)<<5)|(((y)&0x100)>>4)|(((x)&0x3ff)>>6)| \
+	 (((y)&0x200)<<2))
+
+#define getClut(x, y) \
+	(((y)<<6)|(((x)>>4)&0x3f))
+
+#define dumpTPage(tpage)						\
+	GPU_printf("tpage: (%d,%d,%d,%d)\n",				\
+			   ((tpage)>>7)&0x003,((tpage)>>5)&0x003,	\
+			   ((tpage)<<6)&0x7c0,				\
+			   (((tpage)<<4)&0x100)+(((tpage)>>2)&0x200))
+
+#define dumpClut(clut) \
+	GPU_printf("clut: (%d,%d)\n", (clut&0x3f)<<4, (clut>>6))
+
+#define _get_mode(dfe, dtd, tpage)	\
+		((0xe1000000)|((dtd)?0x0200:0)| \
+		((dfe)?0x0400:0)|((tpage)&0x9ff))
+
+#define setDrawTPage(p, dfe, dtd, tpage)	\
+	setlen(p, 1),	\
+	((u_long *)(p))[1] = _get_mode(dfe, dtd, tpage)
+
+#define _get_tw(tw)	\
+		(tw ? ((0xe2000000)|((((tw)->y&0xff)>>3)<<15)| \
+		((((tw)->x&0xff)>>3)<<10)|(((~((tw)->h-1)&0xff)>>3)<<5)| \
+		(((~((tw)->w-1)&0xff)>>3))) : 0)
+
+#define setTexWindow(p, tw)			\
+	setlen(p, 2),				\
+	((u_long *)(p))[1] = _get_tw(tw),	\
+	((u_long *)(p))[2] = 0
+
+#define _get_len(rect)	\
+		(((rect)->w*(rect)->h+1)/2+4)
+
+#define setDrawLoad(pt, rect)					\
+	(_get_len(rect) <= 16) ? (				\
+		(setlen(pt, _get_len(rect))),			\
+		((pt)->code[0] = 0xa0000000),			\
+		((pt)->code[1] = *((u_long *)&(rect)->x)),	\
+		((pt)->code[2] = *((u_long *)&(rect)->w)),	\
+		((pt)->p[_get_len(rect)-4] = 0x01000000)	\
+	) : ( \
+		(setlen(pt,0)) \
+	)
+
+#define setDrawStp(p, pbw) 				\
+        setlen(p, 2),					\
+        ((u_long *)p)[1] = 0xe6000000|(pbw?0x01:0),	\
+        ((u_long *)p)[2] = 0
+
+#define setDrawMode(p, dfe, dtd, tpage, tw) 		\
+        setlen(p, 2),					\
+        ((u_long *)p)[1] = _get_mode(dfe, dtd, tpage),	\
+        ((u_long *)p)[2] = _get_tw((RECT *)tw)
+
+	}
+//	Primitive 	Lentgh		Code			
+//--------------------------------------------------------------------
+//								
+
+procedure setPolyF3(var p: POLY_F3);
+procedure setPolyFT3(var p: POLY_FT3);
+procedure setPolyG3(var p: POLY_G3);
+procedure setPolyGT3(var p: POLY_GT3);
+procedure setPolyF4(var p: POLY_F4);
+procedure setPolyFT4(var p: POLY_FT4);
+procedure setPolyG4(var p: POLY_G4);
+procedure setPolyGT4(var p: POLY_GT4);
+procedure setSprt8(var p: SPRT_8);
+procedure setSprt16(var p: SPRT_16);
+procedure setSprt(var p: SPRT);
+//procedure setTile1(var p: TILE_1);
+procedure setTile8(var p: TILE_8);
+procedure setTile16(var p: TILE_16);
+procedure setTile(var p: TILE);
+procedure setLineF2(var p: LINE_F2);
+procedure setLineG2(var p: LINE_G2);
+procedure setLineF3(var p: LINE_F3);
+procedure setLineG3(var p: LINE_G3);
+procedure setLineF4(var p: LINE_F4);
+procedure setLineG4(var p: LINE_G4);
+
+
+implementation
+
+
+procedure limitRange(var x: integer; l, h: integer); inline;
+begin
+  if x < l then x := l else if x > h then x := h;
+end;
+
+
+procedure setVector(var v: VECTOR; const x, y, z: longint);
+begin
+	v.vx:= x;
+	v.vy:= y;
+	v.vz:= z;
+end;
+
+procedure setVector(var v: SVECTOR; const x, y, z: smallint);
+begin
+	v.vx:= x;
+	v.vy:= y;
+	v.vz:= z;
+end;
+
+procedure setVector(var v: DVECTOR; const x, y, z: smallint);
+begin
+	v.vx:= x;
+	v.vy:= y;
+end;
+
+
+procedure copyVector(var v0: VECTOR; const v1: VECTOR);
+begin
+	v0:= v1;
+end;
+
+procedure copyVector(var v0: SVECTOR; const v1: SVECTOR);
+begin
+	v0:= v1;
+end;
+
+procedure copyVector(var v0: DVECTOR; const v1: DVECTOR);
+begin
+	v0:= v1;
+end;
+
+
+procedure addVector(var v0: VECTOR; const v1: VECTOR);
+begin
+	v0.vx:= v0.vx + v1.vx;
+	v0.vy:= v0.vy + v1.vy;
+	v0.vz:= v0.vz + v1.vz;
+end;
+
+procedure addVector(var v0: SVECTOR; const v1: SVECTOR);
+begin
+	v0.vx:= v0.vx + v1.vx;
+	v0.vy:= v0.vy + v1.vy;
+	v0.vz:= v0.vz + v1.vz;
+end;
+
+procedure addVector(var v0: DVECTOR; const v1: DVECTOR);
+begin
+	v0.vx:= v0.vx + v1.vx;
+	v0.vy:= v0.vy + v1.vy;
+end;
+
+
+procedure setRECT(var r: RECT; const x, y, w, h: longint);
+begin
+	r.x:= x;
+	r.y:= y;
+	r.w:= w;
+	r.h:= h;
+end;
+
+
+procedure dumpMatrix(const x: MATRIX);
+begin
+	GPU_printf('\t%5d,%5d,%5d\n', x.m[0,0], x.m[0,1], x.m[0,2]);
+	GPU_printf('\t%5d,%5d,%5d\n', x.m[1,0], x.m[1,1], x.m[1,2]);
+	GPU_printf('\t%5d,%5d,%5d\n', x.m[2,0], x.m[2,1], x.m[2,2]);
+end;
+
+
+procedure dumpVector(str: pchar; const v: VECTOR);
+begin
+	GPU_printf('%s=(%d,%d,%d)\n', str, v.vx, v.vy, v.vz)
+end;
+
+procedure dumpVector(str: pchar; const v: SVECTOR);
+begin
+	GPU_printf('%s=(%d,%d,%d)\n', str, v.vx, v.vy, v.vz)
+end;
+
+procedure dumpVector(str: pchar; const v: DVECTOR);
+begin
+	GPU_printf('%s=(%d,%d)\n', str, v.vx, v.vy)
+end;
+
+
+
+procedure setRGB0(var p: POLY_F3; const r, g, b: byte);
+begin
+	p.r0:= r;
+	p.g0:= g;
+	p.b0:= b;
+end;
+
+procedure setRGB0(var p: POLY_F4; const r, g, b: byte);
+begin
+	p.r0:= r;
+	p.g0:= g;
+	p.b0:= b;
+end;
+
+
+procedure setRGB0(var p: POLY_FT3; const r, g, b: byte);
+begin
+	p.r0:= r;
+	p.g0:= g;
+	p.b0:= b;
+end;
+
+
+procedure setRGB0(var p: POLY_FT4; const r, g, b: byte);
+begin
+	p.r0:= r;
+	p.g0:= g;
+	p.b0:= b;
+end;
+
+
+procedure setRGB0(var p: POLY_G3; const r, g, b: byte);
+begin
+	p.r0:= r;
+	p.g0:= g;
+	p.b0:= b;
+end;
+
+
+procedure setRGB0(var p: POLY_G4; const r, g, b: byte);
+begin
+	p.r0:= r;
+	p.g0:= g;
+	p.b0:= b;
+end;
+
+
+procedure setRGB0(var p: POLY_GT3; const r, g, b: byte);
+begin
+	p.r0:= r;
+	p.g0:= g;
+	p.b0:= b;
+end;
+
+
+procedure setRGB0(var p: POLY_GT4; const r, g, b: byte);
+begin
+	p.r0:= r;
+	p.g0:= g;
+	p.b0:= b;
+end;
+
+procedure setRGB0(var c: DRAWENV; r, g, b: byte);
+begin
+	c.r0:=r;
+	c.g0:=g;
+	c.b0:=b;
+end;
+
+
+
+
+procedure setRGB1(var p: POLY_G3; const r, g, b: byte);
+begin
+	p.r1:= r;
+	p.g1:= g;
+	p.b1:= b;
+end;
+
+
+procedure setRGB1(var p: POLY_G4; const r, g, b: byte);
+begin
+	p.r1:= r;
+	p.g1:= g;
+	p.b1:= b;
+end;
+
+
+procedure setRGB1(var p: POLY_GT3; const r, g, b: byte);
+begin
+	p.r1:= r;
+	p.g1:= g;
+	p.b1:= b;
+end;
+
+
+procedure setRGB1(var p: POLY_GT4; const r, g, b: byte);
+begin
+	p.r1:= r;
+	p.g1:= g;
+	p.b1:= b;
+end;
+
+
+procedure setRGB2(var p: POLY_G3; const r, g, b: byte);
+begin
+	p.r2:= r;
+	p.g2:= g;
+	p.b2:= b;
+end;
+
+
+procedure setRGB2(var p: POLY_G4; const r, g, b: byte);
+begin
+	p.r2:= r;
+	p.g2:= g;
+	p.b2:= b;
+end;
+
+
+procedure setRGB2(var p: POLY_GT3; const r, g, b: byte);
+begin
+	p.r2:= r;
+	p.g2:= g;
+	p.b2:= b;
+end;
+
+
+procedure setRGB2(var p: POLY_GT4; const r, g, b: byte);
+begin
+	p.r2:= r;
+	p.g2:= g;
+	p.b2:= b;
+end;
+
+
+procedure setRGB3(var p: POLY_G4; const r, g, b: byte);
+begin
+	p.r3:= r;
+	p.g3:= g;
+	p.b3:= b;
+end;
+
+
+procedure setRGB3(var p: POLY_GT4; const r, g, b: byte);
+begin
+	p.r3:= r;
+	p.g3:= g;
+	p.b3:= b;
+end;
+
+
+procedure setXY0(var p: POLY_F3; const x, y: smallint);
+begin
+	p.x0:= x;
+	p.y0:= y;
+end;
+
+procedure setXY0(var p: POLY_F4; const x, y: smallint);
+begin
+	p.x0:= x;
+	p.y0:= y;
+end;
+
+procedure setXY0(var p: POLY_FT3; const x, y: smallint);
+begin
+	p.x0:= x;
+	p.y0:= y;
+end;
+
+procedure setXY0(var p: POLY_FT4; const x, y: smallint);
+begin
+	p.x0:= x;
+	p.y0:= y;
+end;
+
+procedure setXY0(var p: POLY_G3; const x, y: smallint);
+begin
+	p.x0:= x;
+	p.y0:= y;
+end;
+
+procedure setXY0(var p: POLY_G4; const x, y: smallint);
+begin
+	p.x0:= x;
+	p.y0:= y;
+end;
+
+procedure setXY0(var p: POLY_GT3; const x, y: smallint);
+begin
+	p.x0:= x;
+	p.y0:= y;
+end;
+
+procedure setXY0(var p: POLY_GT4; const x, y: smallint);
+begin
+	p.x0:= x;
+	p.y0:= y;
+end;
+
+
+
+
+
+
+
+
+
+
+
+
+
+procedure dumpRECT(r: RECT);
+begin
+	GPU_printf('(%d,%d)-(%d,%d)\n', r.x, r.y, r.w, r.h);
+end;
+
+
+
+
+
+procedure setlen(var p: P_TAG; const len: byte);
+begin
+ 	p.len:= len;
+end;
+
+procedure setlen(var p: POLY_F3; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: POLY_FT3; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: POLY_G3; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: POLY_GT3; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: POLY_F4; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: POLY_FT4; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: POLY_G4; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: POLY_GT4; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: SPRT_8; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: SPRT_16; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: SPRT; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: TILE_1; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: TILE_8; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: TILE_16; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: TILE; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: LINE_F2; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: LINE_G2; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: LINE_F3; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: LINE_G3; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: LINE_F4; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+procedure setlen(var p: LINE_G4; const len: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.len:= len;
+end;
+
+
+
+
+
+
+
+procedure setaddr(var p: P_TAG; const addr: dword);
+begin
+	p.addr:= addr;
+end;
+
+procedure setcode(var p: P_TAG; const code: byte);
+begin
+	p.code:= code;
+end;
+
+
+procedure setcode(var p: POLY_F3; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: POLY_FT3; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: POLY_G3; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: POLY_GT3; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: POLY_F4; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: POLY_FT4; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: POLY_G4; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: POLY_GT4; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: SPRT_8; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: SPRT_16; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: SPRT; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: TILE_1; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: TILE_8; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: TILE_16; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: TILE; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: LINE_F2; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: LINE_G2; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: LINE_F3; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: LINE_G3; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: LINE_F4; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+procedure setcode(var p: LINE_G4; const code: byte);
+var x : ^P_TAG;
+begin
+	x:= @p;
+ 	x^.code:= code;
+end;
+
+
+function getlen(p: P_TAG): byte;
+begin
+	getlen:= p.len;
+end;
+
+function getcode(p: P_TAG): byte;
+begin
+   	getcode:= p.code;
+end;
+
+function getaddr(p: P_TAG): dword;
+begin
+	getaddr:= p.addr;
+end;
+
+
+
+
+
+//	Primitive 	Lentgh		Code			
+//--------------------------------------------------------------------
+//								
+
+//#define setPolyF3(p)	setlen(p, 4),  setcode(p, 0x20)
+procedure setPolyF3(var p: POLY_F3);
+begin
+	setlen(p, 4);
+	setcode(p, $20);
+end;
+
+//#define setPolyFT3(p)	setlen(p, 7),  setcode(p, 0x24)
+procedure setPolyFT3(var p: POLY_FT3);
+begin
+	setlen(p, 7);
+	setcode(p, $24);
+end;
+
+//#define setPolyG3(p)	setlen(p, 6),  setcode(p, 0x30)
+procedure setPolyG3(var p: POLY_G3);
+begin
+	setlen(p, 6);
+	setcode(p, $30);
+end;
+
+//#define setPolyGT3(p)	setlen(p, 9),  setcode(p, 0x34)
+procedure setPolyGT3(var p: POLY_GT3);
+begin
+	setlen(p, 9);
+	setcode(p, $34);
+end;
+
+
+//#define setPolyF4(p)	setlen(p, 5),  setcode(p, 0x28)
+procedure setPolyF4(var p: POLY_F4);
+begin
+	setlen(p, 5);
+	setcode(p, $28);
+end;
+
+//#define setPolyFT4(p)	setlen(p, 9),  setcode(p, 0x2c)
+procedure setPolyFT4(var p: POLY_FT4);
+begin
+	setlen(p, 9);
+	setcode(p, $2c);
+end;
+
+
+//#define setPolyG4(p)	setlen(p, 8),  setcode(p, 0x38)
+procedure setPolyG4(var p: POLY_G4);
+begin
+	setlen(p, 8);
+	setcode(p, $38);
+end;
+
+//#define setPolyGT4(p)	setlen(p, 12), setcode(p, 0x3c)
+procedure setPolyGT4(var p: POLY_GT4);
+begin
+	setlen(p, 12);
+	setcode(p, $3c);
+end;
+
+
+//#define setSprt8(p)	setlen(p, 3),  setcode(p, 0x74)
+procedure setSprt8(var p: SPRT_8);
+begin
+	setlen(p, 3);
+	setcode(p, $74);
+end;
+
+//#define setSprt16(p)	setlen(p, 3),  setcode(p, 0x7c)
+procedure setSprt16(var p: SPRT_16);
+begin
+	setlen(p, 3);
+	setcode(p, $7c);
+
+end;
+
+//#define setSprt(p)	setlen(p, 4),  setcode(p, 0x64)
+procedure setSprt(var p: SPRT);
+begin
+	setlen(p, 4);
+	setcode(p, $64);
+end;
+
+//#define setTile1(p)	setlen(p, 2),  setcode(p, 0x68)
+{
+procedure setTile1(var p: TILE_1);
+begin
+	setlen(p, 2);
+	setcode(p, $68);
+end;
+}
+//#define setTile8(p)	setlen(p, 2),  setcode(p, 0x70)
+procedure setTile8(var p: TILE_8);
+begin
+	setlen(p, 2);
+	setcode(p, $70);
+end;
+
+//#define setTile16(p)	setlen(p, 2),  setcode(p, 0x78)
+procedure setTile16(var p: TILE_16);
+begin
+	setlen(p, 2);
+	setcode(p, $78);
+end;
+
+//#define setTile(p)	setlen(p, 3),  setcode(p, 0x60)
+procedure setTile(var p: TILE);
+begin
+	setlen(p, 3);
+	setcode(p, $60);
+end;
+
+//#define setLineF2(p)	setlen(p, 3),  setcode(p, 0x40)
+procedure setLineF2(var p: LINE_F2);
+begin
+	setlen(p, 3);
+	setcode(p, $40);
+end;
+
+//#define setLineG2(p)	setlen(p, 4),  setcode(p, 0x50)
+procedure setLineG2(var p: LINE_G2);
+begin
+	setlen(p, 4);
+	setcode(p, $50);
+end;
+
+//#define setLineF3(p)	setlen(p, 5),  setcode(p, 0x48),(p)->pad = 0x55555555
+procedure setLineF3(var p: LINE_F3);
+begin
+	setlen(p, 5);  
+	setcode(p, $48);
+	p.pad:= $55555555;
+end;
+
+//#define setLineG3(p)	setlen(p, 7),  setcode(p, 0x58),(p)->pad = 0x55555555, \
+//			(p)->p2 = 0
+procedure setLineG3(var p: LINE_G3);
+begin
+	setlen(p, 7);
+	setcode(p, $58);
+	p.pad:= $55555555;
+	p.p2:= 0;
+end;
+
+//#define setLineF4(p)	setlen(p, 6),  setcode(p, 0x4c),(p)->pad = 0x55555555
+procedure setLineF4(var p: LINE_F4);
+begin
+	setlen(p, 6);
+	setcode(p, $4c);
+	p.pad:= $55555555;
+end;
+
+//#define setLineG4(p)	setlen(p, 9),  setcode(p, 0x5c),(p)->pad = 0x55555555, \
+//			(p)->p2 = 0, (p)->p3 = 0
+procedure setLineG4(var p: LINE_G4);
+begin
+	setlen(p, 9);
+	setcode(p, $5c);
+	p.pad:= $55555555;
+	p.p2:= 0;
+	p.p3:= 0;
+end;
+
+
+end.

psy-q-sdk/bindings/libgs.pas

@@ -0,0 +1,1466 @@
+// libgs.h: Graphic Library Header 
+unit libgs;
+interface
+
+type
+		PACKET = byte;						// packet peripheral pointer
+
+const
+		PSBANK 			= $80000000;
+		ZRESOLUTION     = $3fff;			// --- Zsort resolution ---
+
+		WORLD 			= 0;
+
+// function SCREEN ((GsCOORDINATE2 *)0x0001)
+
+type
+
+		GsCOORD2PARAM = packed record
+							scale : VECTOR;
+							rotate : SVECTOR;
+							trans : VECTOR;
+		end;
+		GsCOORD2PARAM = ^GsCOORD2PARAM;
+
+		PGsCOORDINATE2 = ^GsCOORDINATE2;
+		GsCOORDINATE2 = packed record
+							flg : dword;
+							coord : MATRIX;
+							workm : MATRIX;
+							param : PGsCOORD2PARAM;
+							super : PGsCOORDINATE2;
+							_sub : PGsCOORDINATE2;
+		end;
+
+		
+		GsVIEW2 = packed record
+							view : MATRIX;
+							super : GsCOORDINATE2;
+		end;
+
+		GsRVIEW2 = packed record
+							vpx, vpy, vpz : longint;
+							vrx, vry, vrz : longint;
+							rz : longint;
+							super : PGsCOORDINATE2;
+		end;
+       
+		GsF_LIGHT = packed record
+							vx, vy, vz : longint;
+							r, g, b : byte;
+		end;
+       
+
+
+		GsOT_TAG = packed record
+							p:0..16777215
+							num:0..255;
+		end;
+
+
+		PGsOT_TAG = ^GsOT_TAG;
+		GsOT = packed record
+							len : dword;
+							org : PGsOT_TAG;
+							offset : dword;
+							point : dword;
+							tag : PGsOT_TAG;
+		end;
+
+		GsDOBJ2 = packed record
+							attr : dword;					// pers,trans,rotate,disp
+							coord2 : PGsCOORDINATE2;		// local dmatrix
+							tmd : pdword;
+							id : dword;
+		end;
+
+		GsDOBJ3 = packed record
+							attr : dword;					// pers,trans,rotate,disp
+							coord2 : PGsCOORDINATE2;		// local dmatrix
+							pmd : pdword;					// pmd top address
+							base : pdword;					// object base address
+							sv : pdword;					// shared vertex base
+							id : dword;
+		end;
+
+		GsDOBJ4 = packed record
+							attr : dword; 					// pers,trans,rotate,disp
+							coord2 : PGsCOORDINATE2;		// local dmatrix
+							tmd : pdword;
+							id : dword;
+		end;
+
+		GsDOBJ5 = packed record
+							attr : dword;
+							coord2 : PGsCOORDINATE2;
+							tmd : pdword;
+							packet : pdword;
+							id : dword;
+		end;
+
+
+		GsSPRITE = packed record
+							attr : dword;
+							x, y : smallint;
+							w, h : word;
+							tpage : word;
+							u, v : byte;
+							cx, cy : smallint;
+							r, g, b : byte;
+							mx, my : smallint;
+							scalex, scaley : smallint;
+							rotate : longint;
+		end;
+
+
+		GsCELL = packed record
+							u, v : byte;
+							cba : word;
+							flag : word;
+							tpage : word;
+		end;
+		PGsCell = ^GsCELL;
+
+		GsMAP = packed record
+							cellw, cellh : byte;
+							ncellw, ncellh : word;
+							base : PGsCELL;
+							index : pword;
+		end;
+		PGsMAP = ^GsMAP;
+
+
+		GsBG = packed record
+							attr : dword;
+							x, y : smallint;
+							w, h : smallint;
+							scrollx, scrolly : smallint;
+							r, g, b : byte;
+							map : PGsMAP;
+							mx, my : smallint;
+							scalex, scaley : smallint;
+							rotate : longint;
+		end;
+
+
+		GsLINE = packed record
+							attr : dword;
+							x0, y0 : smallint;
+							x1, y1 : smallint;
+							r, g, b : byte;
+		end;
+
+		GsGLINE = packed record
+							attr : dword;
+							x0, y0 : smallint;
+							x1, y1 : smallint;
+							r0, g0, b0 : byte;
+							r1, g1, b1 : byte;
+		end;
+
+		GsBOXF = packed record
+							attr : dword;
+							x, y : smallint;
+							w, h : word;
+							r, g, b : byte;
+       	end;
+
+       	GsFOGPARAM = packed record
+							dqa : smallint;
+							dqb : longint;
+							rfc, gfc, bfc : byte;
+       	end;
+
+
+       	GsIMAGE = packed record
+							pmode : dword;
+							px, py : smallint;
+							pw, ph : word;
+							pixel : pointer;
+							cx, cy : smallint;
+							cw, ch : word;
+							clut : pointer;
+		end;
+
+
+		_GsPOSITION = packed record
+							offx, offy : smallint;
+		end;
+
+
+		GsOBJTABLE2 = packed record
+							top : PGsDOBJ2;
+							nobj : longint;
+							maxobj : longint;
+		end;
+
+(*
+typedef struct {
+	PACKET
+	* (*f3[2][3]) ();
+	PACKET
+	* (*nf3[2]) ();
+	PACKET
+	* (*g3[2][3]) ();
+	PACKET
+	* (*ng3[2]) ();
+	PACKET
+	* (*tf3[2][3]) ();
+	PACKET
+	* (*ntf3[2]) ();
+	PACKET
+	* (*tg3[2][3]) ();
+	PACKET
+	* (*ntg3[2]) ();
+	PACKET
+	* (*f4[2][3]) ();
+	PACKET
+	* (*nf4[2]) ();
+	PACKET
+	* (*g4[2][3]) ();
+	PACKET
+	* (*ng4[2]) ();
+	PACKET
+	* (*tf4[2][3]) ();
+	PACKET
+	* (*ntf4[2]) ();
+	PACKET
+	* (*tg4[2][3]) ();
+	PACKET
+	* (*ntg4[2]) ();
+	PACKET
+	* (*f3g[3])();
+	PACKET
+	* (*g3g[3])();
+	PACKET
+	* (*f4g[3])();
+	PACKET
+	* (*g4g[3])();
+}       _GsFCALL;
+*)
+
+
+const
+		GsDivMODE_NDIV  = 0;
+		GsDivMODE_DIV   = 1;
+		GsLMODE_NORMAL 	= 0;
+		GsLMODE_FOG    	= 1;
+		GsLMODE_LOFF   	= 2;
+
+// libgs macro 
+		GsOFSGTE 		= 0;
+		GsOFSGPU 		= 4;
+		GsINTER  		= 1;
+		GsNONINTER 		= 0;
+		GsRESET0 		= 0;
+		GsRESET3 		= 3 shl 4;
+
+// object attribute set macro 
+		GsLDIM0 		= 0;
+		GsLDIM1 		= 1;
+		GsLDIM2 		= 2;
+		GsLDIM3 		= 3;
+		GsLDIM4 		= 4;
+		GsLDIM5 		= 5;
+		GsLDIM6 		= 6;
+		GsLDIM7 		= 7;
+		GsFOG   		= 1 shl 3;
+		GsMATE  		= 1 shl 4;
+		GsLLMOD 		= 1 shl 5;
+		GsLOFF  		= 1 shl 6;
+		GsZIGNR 		= 1 shl 7;
+		GsNBACKC 		= 1 shl 8;
+		GsDIV1   		= 1 shl 9;
+		GsDIV2   		= 2 shl 9;
+		GsDIV3   		= 3 shl 9;
+		GsDIV4	 		= 4 shl 9;
+		GsDIV5	 		= 5 shl 9;
+		GsAZERO  		= 0 shl 28;
+		GsAONE   		= 1 shl 28;
+		GsATWO   		= 2 shl 28;
+		GsATHREE 		= 3 shl 28;
+		GsALON   		= 1 shl 30;
+		GsDOFF   		= 1 shl 31;
+
+
+// BG/sprite attribute set macro 
+
+		GsPERS   		= 1 shl 26;
+		GsROTOFF 		= 1 shl 27;
+{
+#define GsIncFrame()  (PSDCNT++, PSDCNT= PSDCNT?PSDCNT:1, \
+                      (PSDIDX= (PSDIDX==0?1:0)))
+
+#define GsUpdateCoord()  (PSDCNT++, PSDCNT= PSDCNT?PSDCNT:1)
+
+#define GsSetAzwh(z,w,h)    GsADIVZ = (z),GsADIVW = (w),GsADIVH = (h);
+}
+
+		GsTMDFlagGRD	= $04;
+
+// FLIP macro for GsSort[Fast]SpriteB
+		GsHFLIP			= $01;
+		GsVFLIP			= $02;
+
+
+// TMD structure 
+// GTE PACKET to-GPU command '<packet-name>.code'
+		GPU_COM_F3    	= $20;
+		GPU_COM_TF3   	= $24;
+		GPU_COM_G3    	= $30;
+		GPU_COM_TG3   	= $34;
+
+		GPU_COM_F4    	= $28;
+		GPU_COM_TF4   	= $2c;
+		GPU_COM_G4    	= $38;
+		GPU_COM_TG4   	= $3c;
+
+		GPU_COM_NF3   	= $21;
+		GPU_COM_NTF3  	= $25;
+		GPU_COM_NG3   	= $31;
+		GPU_COM_NTG3  	= $35;
+
+		GPU_COM_NF4   	= $29;
+		GPU_COM_NTF4  	= $2d;
+		GPU_COM_NG4   	= $39;
+		GPU_COM_NTG4  	= $3d;
+
+
+// TMD structure
+		TMD_P_F3 = packed record
+						out, _in, dummy, cd : byte;
+						r0, g0, b0, code : byte;
+						n0, v0 : word;
+						v1, v2 : word;
+		end;
+
+		TMD_P_G3 = packed record
+						out, _in, dummy, cd : byte;
+						r0, g0, b0, code : byte;
+						n0, v0 : word;
+						n1, v1 : word;
+						n2, v2 : word;
+		end;
+
+
+		TMD_P_F3G = packed record
+						out, _in, dummy, cd : byte;
+						r0, g0, b0, code : byte;
+						r1, g1, b1, dummy1 : byte;
+						r2, g2, b2, dummy2 : byte;
+						n0, v0 : word;
+						v1, v2 : word;
+		end;
+
+
+		TMD_P_G3G = packed record
+						out, _in, dummy, cd : byte;
+						r0, g0, b0, code : byte;
+						r1, g1, b1, dummy1 : byte;
+						r2, g2, b2, dummy2 : byte;
+						n0, v0 : word;
+						n1, v1 : word;
+						n2, v2 : word;
+		end;
+
+		TMD_P_NF3 = packed record
+						out, _in, dummy, cd : byte;
+						r0, g0, b0, code : byte;
+						v0, v1 : word;
+						v2, p : word;
+		end;
+
+
+		TMD_P_NG3 = packed record
+						out, _in, dummy, cd : byte;
+						r0, g0, b0, code : byte;
+						r1, g1, b1, p1 : byte;
+						r2, g2, b2, p2 : byte;
+						v0, v1 : word;
+						v2, p : word;
+		end;
+
+		TMD_P_F4 = packed record
+						out, _in, dummy, cd : byte;
+						r0, g0, b0, code : byte;
+						n0, v0 : word;
+						v1, v2 : word;
+						v3, p : word;
+		end;
+
+		TMD_P_G4 = packed record
+						out, _in, dummy, cd : byte;
+						r0, g0, b0, code : byte;
+						n0, v0 : word;
+						u1, v1 : word;
+						n2, v2 : word;
+						n3, v3 : word;
+		end;
+
+typedef struct {
+	u_char	out, in, dummy, cd;
+	u_char	r0, g0, b0, code;
+	u_char	r1, g1, b1, dummy1;
+	u_char	r2, g2, b2, dummy2;
+	u_char	r3, g3, b3, dummy3;
+	u_short n0, v0;
+	u_short v1, v2;
+	u_short v3, dummy4;
+}       TMD_P_F4G;
+
+typedef struct {
+	u_char	out, in, dummy, cd;
+	u_char	r0, g0, b0, code;
+	u_char	r1, g1, b1, dummy1;
+	u_char	r2, g2, b2, dummy2;
+	u_char	r3, g3, b3, dummy3;
+	u_short n0, v0;
+	u_short n1, v1;
+	u_short n2, v2;
+	u_short n3, v3;
+}       TMD_P_G4G;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  r0, g0, b0, code;
+	u_short v0, v1;
+	u_short v2, v3;
+}       TMD_P_NF4;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  r0, g0, b0, code;
+	u_char  r1, g1, b1, p1;
+	u_char  r2, g2, b2, p2;
+	u_char  r3, g3, b3, p3;
+	u_short v0, v1;
+	u_short v2, v3;
+}       TMD_P_NG4;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  tu0, tv0;
+	u_short clut;
+	u_char  tu1, tv1;
+	u_short tpage;
+	u_char  tu2, tv2;
+	u_short p;
+	u_short n0, v0;
+	u_short v1, v2;
+}       TMD_P_TF3;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  tu0, tv0;
+	u_short clut;
+	u_char  tu1, tv1;
+	u_short tpage;
+	u_char  tu2, tv2;
+	u_short p;
+	u_short n0, v0;
+	u_short n1, v1;
+	u_short n2, v2;
+}       TMD_P_TG3;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  tu0, tv0;
+	u_short clut;
+	u_char  tu1, tv1;
+	u_short tpage;
+	u_char  tu2, tv2;
+	u_short p0;
+	u_char  r0, g0, b0, p1;
+	u_short v0, v1;
+	u_short v2, p2;
+}       TMD_P_TNF3;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  tu0, tv0;
+	u_short clut;
+	u_char  tu1, tv1;
+	u_short tpage;
+	u_char  tu2, tv2;
+	u_short p0;
+	u_char  r0, g0, b0, p1;
+	u_char  r1, g1, b1, p2;
+	u_char  r2, g2, b2, p3;
+	u_short v0, v1;
+	u_short v2, p4;
+}       TMD_P_TNG3;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  tu0, tv0;
+	u_short clut;
+	u_char  tu1, tv1;
+	u_short tpage;
+	u_char  tu2, tv2;
+	u_short p0;
+	u_char  tu3, tv3;
+	u_short p1;
+	u_short n0, v0;
+	u_short v1, v2;
+	u_short v3, p2;
+}       TMD_P_TF4;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  tu0, tv0;
+	u_short clut;
+	u_char  tu1, tv1;
+	u_short tpage;
+	u_char  tu2, tv2;
+	u_short p0;
+	u_char  tu3, tv3;
+	u_short p1;
+	u_short n0, v0;
+	u_short n1, v1;
+	u_short n2, v2;
+	u_short n3, v3;
+}       TMD_P_TG4;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  tu0, tv0;
+	u_short clut;
+	u_char  tu1, tv1;
+	u_short tpage;
+	u_char  tu2, tv2;
+	u_short p0;
+	u_char  tu3, tv3;
+	u_short p1;
+	u_char  r0, g0, b0, p2;
+	u_short v0, v1;
+	u_short v2, v3;
+}       TMD_P_TNF4;
+
+typedef struct {
+	u_char  out, in, dummy, cd;
+	u_char  tu0, tv0;
+	u_short clut;
+	u_char  tu1, tv1;
+	u_short tpage;
+	u_char  tu2, tv2;
+	u_short p0;
+	u_char  tu3, tv3;
+	u_short p1;
+	u_char  r0, g0, b0, p2;
+	u_char  r1, g1, b1, p3;
+	u_char  r2, g2, b2, p4;
+	u_char  r3, g3, b3, p5;
+	u_short v0, v1;
+	u_short v2, v3;
+}       TMD_P_TNG4;
+
+struct TMD_STRUCT {
+	u_long *vertop;         /* vertex top address of TMD format */
+	u_long  vern;           /* the number of vertex of TMD format */
+	u_long *nortop;         /* normal top address of TMD format */
+	u_long  norn;           /* the number of normal of TMD format */
+	u_long *primtop;        /* primitive top address of TMD format */
+	u_long  primn;          /* the number of primitives of TMD format */
+	u_long  scale;          /* the scale factor of TMD format */
+};
+
+/*
+ * active sub divide structure 
+ *
+ */
+
+#define minmax4(x1,x2,x3,x4,x5,x6) x1>x2?(x6=x1,x5=x2):(x5=x1,x6=x2),\
+                                   x3>x6?x6=x3:x3<x5?x5=x3:0,\
+                                   x4>x6?x6=x4:x4<x5?x5=x4:0
+
+#define minmax3(x1,x2,x3,x4,x5)    x1>x2?(x5=x1,x4=x2):(x4=x1,x5=x2),\
+                                   x3>x5?x5=x3:x3<x4?x4=x3:0
+
+
+typedef struct {
+	short   vx, vy, vz;
+	u_char  tu, tv;
+}       VERT;
+
+typedef struct {
+	short   vx, vy, vz;
+	u_char  tu, tv;
+	CVECTOR col;
+}       VERTC;
+
+
+typedef struct {
+	u_long  limit;		/* divide limit */
+	long    hwd, vwd;	/* dummy */
+	int     shift;		/* OT shift */
+	u_long *org;		/* OT org */
+	u_long *pk;		/* packet base */
+	long    otz;		/* gte otz */
+	long    adivz;		/* active divide codition z */
+	short   adivw, adivh;	/* active divide condition w,h */
+	long    flg0;		/* gte flag */
+	long    flg;		/* gte flag */
+	short   minx, miny, maxx, maxy;	/* polygon min-max */
+	short   hwd0, vwd0;	/* resolution of screen */
+	u_long *tag;		/* work temprly for addPrim */
+	POLY_FT4 si;		/* work packet */
+}       GsADIV_FT4;
+
+typedef struct {
+	VERT    vt[4];
+}       GsADIV_P_FT4;
+
+
+
+typedef struct {
+	u_long  limit;		/* divide limit */
+	long    hwd, vwd;	/* dummy */
+	int     shift;		/* OT shift */
+	u_long *org;		/* OT org */
+	u_long *pk;		/* packet base */
+	long    otz;		/* gte otz */
+	long    adivz;		/* active divide codition z */
+	short   adivw, adivh;	/* active divide condition w,h */
+	long    flg0;		/* gte flag */
+	long    flg;		/* gte flag */
+	short   minx, miny, maxx, maxy;	/* polygon min-max */
+	short   hwd0, vwd0;	/* resolution of screen */
+	u_long *tag;		/* work temprly for addPrim */
+	POLY_GT4 si;		/* work packet */
+}       GsADIV_GT4;
+
+typedef struct {
+	VERTC   vt[4];
+}       GsADIV_P_GT4;
+
+
+typedef struct {
+	u_long  limit;		/* divide limit */
+	long    hwd, vwd;	/* dummy */
+	int     shift;		/* OT shift */
+	u_long *org;		/* OT org */
+	u_long *pk;		/* packet base */
+	long    otz;		/* gte otz */
+	long    adivz;		/* active divide codition z */
+	short   adivw, adivh;	/* active divide condition w,h */
+	long    flg0;		/* gte flag */
+	long    flg;		/* gte flag */
+	short   minx, miny, maxx, maxy;	/* polygon min-max */
+	short   hwd0, vwd0;	/* resolution of screen */
+	u_long *tag;		/* work temprly for addPrim */
+	POLY_G4 si;		/* work packet */
+}       GsADIV_G4;
+
+typedef struct {
+	VERTC   vt[4];
+}       GsADIV_P_G4;
+
+typedef struct {
+	u_long  limit;		/* divide limit */
+	long    hwd, vwd;	/* dummy */
+	int     shift;		/* OT shift */
+	u_long *org;		/* OT org */
+	u_long *pk;		/* packet base */
+	long    otz;		/* gte otz */
+	long    adivz;		/* active divide codition z */
+	short   adivw, adivh;	/* active divide condition w,h */
+	long    flg0;		/* gte flag */
+	long    flg;		/* gte flag */
+	short   minx, miny, maxx, maxy;	/* polygon min-max */
+	short   hwd0, vwd0;	/* resolution of screen */
+	u_long *tag;		/* work temprly for addPrim */
+	POLY_F4 si;		/* work packet */
+}       GsADIV_F4;
+
+typedef struct {
+	VERT    vt[4];
+}       GsADIV_P_F4;
+
+
+typedef struct {
+	u_long  limit;		/* divide limit */
+	long    hwd, vwd;	/* dummy */
+	int     shift;		/* OT shift */
+	u_long *org;		/* OT org */
+	u_long *pk;		/* packet base */
+	long    otz;		/* gte otz */
+	long    adivz;		/* active divide codition z */
+	short   adivw, adivh;	/* active divide condition w,h */
+	long    flg;		/* gte flag */
+	short   minx, miny, maxx, maxy;	/* polygon min-max */
+	short   hwd0, vwd0;	/* resolution of screen */
+	u_long *tag;		/* work temprly for addPrim */
+	POLY_FT3 si;		/* work packet */
+}       GsADIV_FT3;
+
+typedef struct {
+	VERT    vt[3];
+}       GsADIV_P_FT3;
+
+typedef struct {
+	u_long  limit;		/* divide limit */
+	long    hwd, vwd;	/* dummy */
+	int     shift;		/* OT shift */
+	u_long *org;		/* OT org */
+	u_long *pk;		/* packet base */
+	long    otz;		/* gte otz */
+	long    adivz;		/* active divide codition z */
+	short   adivw, adivh;	/* active divide condition w,h */
+	long    flg;		/* gte flag */
+	short   minx, miny, maxx, maxy;	/* polygon min-max */
+	short   hwd0, vwd0;	/* resolution of screen */
+	u_long *tag;		/* work temprly for addPrim */
+	POLY_GT3 si;		/* work packet */
+}       GsADIV_GT3;
+
+typedef struct {
+	VERTC   vt[3];
+}       GsADIV_P_GT3;
+
+typedef struct {
+	u_long  limit;		/* divide limit */
+	long    hwd, vwd;	/* dummy */
+	int     shift;		/* OT shift */
+	u_long *org;		/* OT org */
+	u_long *pk;		/* packet base */
+	long    otz;		/* gte otz */
+	long    adivz;		/* active divide codition z */
+	short   adivw, adivh;	/* active divide condition w,h */
+	long    flg;		/* gte flag */
+	short   minx, miny, maxx, maxy;	/* polygon min-max */
+	short   hwd0, vwd0;	/* resolution of screen */
+	u_long *tag;		/* work temprly for addPrim */
+	POLY_G3 si;		/* work packet */
+}       GsADIV_G3;
+
+typedef struct {
+	VERTC   vt[3];
+}       GsADIV_P_G3;
+
+typedef struct {
+	u_long  limit;		/* divide limit */
+	long    hwd, vwd;	/* dummy */
+	int     shift;		/* OT shift */
+	u_long *org;		/* OT org */
+	u_long *pk;		/* packet base */
+	long    otz;		/* gte otz */
+	long    adivz;		/* active divide codition z */
+	short   adivw, adivh;	/* active divide condition w,h */
+	long    flg;		/* gte flag */
+	short   minx, miny, maxx, maxy;	/* polygon min-max */
+	short   hwd0, vwd0;	/* resolution of screen */
+	u_long *tag;		/* work temprly for addPrim */
+	POLY_F3 si;		/* work packet */
+}       GsADIV_F3;
+
+typedef struct {
+	VERT    vt[3];
+}       GsADIV_P_F3;
+
+/*
+ * PROTOTYPE DIFINITIONS 
+ */
+#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
+extern  "C" {
+#endif
+
+	void    GsInitGraph(unsigned short x, unsigned short y, unsigned short intmode,
+		              unsigned short dith, unsigned short varmmode);
+	void    GsInit3D(void);
+	void    GsMapModelingData(unsigned long *p);
+
+	void    GsSetProjection(long h);
+	int     GsSetFlatLight(int id, GsF_LIGHT * lt);
+	void    GsSetLightMode(int mode);
+	void    GsSetFogParam(GsFOGPARAM * fogparm);
+	void    GsSetAmbient(long r, long g, long b);
+	void    GsDrawOt(GsOT * ot);
+	void    GsSetWorkBase(PACKET * outpacketp);
+
+	void    GsSortObject3(GsDOBJ3 * objp, GsOT * ot, int shift);
+	void    GsSortObject4(GsDOBJ2 * objp, GsOT * ot, int shift, u_long * scratch);
+	void    GsSortObject5(GsDOBJ5 * objp, GsOT * ot, int shift, u_long * scratch);
+	void    GsSortObject5J(GsDOBJ5 * objp, GsOT * ot, int shift, u_long * scratch);
+
+	void    GsSortSprite(GsSPRITE * sp, GsOT * ot, unsigned short pri);
+	void    GsSortSpriteB(GsSPRITE * sp, GsOT * ot, unsigned short pri,
+				unsigned short flip);
+	void    GsSortFastSprite(GsSPRITE * sp, GsOT * ot, unsigned short pri);
+	void    GsSortFastSpriteB(GsSPRITE * sp, GsOT * ot, unsigned short pri,
+				unsigned short flip);
+	void    GsSortFlipSprite(GsSPRITE * sp, GsOT * ot, unsigned short pri);
+	void    GsSortBg(GsBG * bg, GsOT * ot, unsigned short pri);
+	void    GsSortFastBg(GsBG * bg, GsOT * ot, unsigned short pri);
+	void    GsInitFixBg16(GsBG * bg, u_long * work);
+	void    GsSortFixBg16(GsBG * bg, u_long * work, GsOT * otp, unsigned short pri);
+	void    GsInitFixBg32(GsBG * bg, u_long * work);
+	void    GsSortFixBg32(GsBG * bg, u_long * work, GsOT * otp, unsigned short pri);
+	void    GsSortLine(GsLINE * lp, GsOT * ot, unsigned short pri);
+	void    GsSortGLine(GsGLINE * lp, GsOT * ot, unsigned short pri);
+	void    GsSortBoxFill(GsBOXF * bp, GsOT * ot, unsigned short pri);
+	void    GsSortPoly(void *pp, GsOT * ot, unsigned short pri);
+
+	void    GsClearOt(unsigned short offset, unsigned short point, GsOT * otp);
+	GsOT   *GsSortOt(GsOT * ot_src, GsOT * ot_dest);
+	GsOT   *GsCutOt(GsOT * ot_src, GsOT * ot_dest);
+	void    GsDefDispBuff(unsigned short x0, unsigned short y0, unsigned short x1, unsigned short y1);
+	void    GsSortClear(unsigned char, unsigned char, unsigned char, GsOT *);
+	void    GsGetTimInfo(unsigned long *im, GsIMAGE * tim);
+	void    GsSwapDispBuff(void);
+	int     GsGetActiveBuff(void);
+	void    GsSetDrawBuffClip(void);
+	void    GsSetDrawBuffOffset(void);
+	void    GsSetClip(RECT * clip);
+	DRAWENV *GsSetClip2(RECT * clip);
+	void    GsSetOffset(long x, long y);
+	void    GsSetOrign(long x, long y);
+
+	void    GsInitCoordinate2(GsCOORDINATE2 * super, GsCOORDINATE2 * base);
+	void    GsMulCoord0(MATRIX * m1, MATRIX * m2, MATRIX * m3);
+	void    GsMulCoord2(MATRIX * m1, MATRIX * m2);
+	void    GsMulCoord3(MATRIX * m1, MATRIX * m2);
+	void    GsGetLw(GsCOORDINATE2 * m, MATRIX * out);
+	void    GsGetLs(GsCOORDINATE2 * m, MATRIX * out);
+	void    GsGetLws(GsCOORDINATE2 * m, MATRIX * outw, MATRIX * outs);
+
+	u_long  GsLinkObject3(unsigned long pmd_base, GsDOBJ3 * objp);
+	void    GsLinkObject4(unsigned long tmd_base, GsDOBJ2 * objp, int n);
+	void    GsLinkObject5(unsigned long tmd_base, GsDOBJ5 * objp, int n);
+
+	void    GsSetLightMatrix(MATRIX * mp);
+	void    GsSetLightMatrix2(MATRIX * mp);
+	int     GsSetRefView2(GsRVIEW2 * pv);
+	int     GsSetRefView2L(GsRVIEW2 * pv);
+	int     GsSetView2(GsVIEW2 * pv);
+	void    GsSetLsMatrix(MATRIX * mp);
+	void    GsSetClip2D(RECT * rectp);
+	void    GsInitVcount();
+	long    GsGetVcount();
+	void    GsClearVcount();
+	void	GsDefDispBuff2(u_short x0, u_short y0, u_short x1, u_short y1);
+	void	GsDrawOtIO(GsOT *ot);
+	PACKET *GsGetWorkBase();
+	void	GsInitGraph2( u_short x, u_short y, u_short intmode, u_short dith, u_short vrammode);
+	void	GsSortObject4J(GsDOBJ2 *objp, GsOT *otp, int shift, u_long *scratch);
+	void    GsClearDispArea(unsigned char r, unsigned char g, unsigned char b);
+
+	u_long *GsPresetObject(GsDOBJ5 * objp, u_long * base_addr);
+	void    GsScaleScreen(SVECTOR * scale);
+
+	PACKET *GsA4divF3L(TMD_P_F3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			           int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divF3LFG(TMD_P_F3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divF3NL(TMD_P_F3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divNF3(TMD_P_NF3 * op, VERT * vp, PACKET * pk, int n,
+			           int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divF4L(TMD_P_F4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			           int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divF4LFG(TMD_P_F4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divF4NL(TMD_P_F4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divNF4(TMD_P_NF4 * op, VERT * vp, PACKET * pk, int n,
+			           int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divG3L(TMD_P_G3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			           int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divG3LFG(TMD_P_G3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divG3NL(TMD_P_G3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divNG3(TMD_P_NG3 * op, VERT * vp, PACKET * pk, int n,
+			           int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divG4L(TMD_P_G4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			           int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divG4LFG(TMD_P_G4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divG4NL(TMD_P_G4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divNG4(TMD_P_NG4 * op, VERT * vp, PACKET * pk, int n,
+			           int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTF3L(TMD_P_TF3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTF3LFG(TMD_P_TF3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTF3NL(TMD_P_TF3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTNF3(TMD_P_TNF3 * op, VERT * vp, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTF4L(TMD_P_TF4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTF4LFG(TMD_P_TF4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTF4NL(TMD_P_TF4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTNF4(TMD_P_TNF4 * op, VERT * vp, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTF4LM(TMD_P_TF4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTF4LFGM(TMD_P_TF4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTF4NLM(TMD_P_TF4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTNF4M(TMD_P_TNF4 * op, VERT * vp, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTG3L(TMD_P_TG3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTG3LFG(TMD_P_TG3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTG3NL(TMD_P_TG3 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTNG3(TMD_P_TNG3 * op, VERT * vp, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTG4L(TMD_P_TG4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTG4LFG(TMD_P_TG4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTG4NL(TMD_P_TG4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTNG4(TMD_P_TNG4 * op, VERT * vp, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTG4LM(TMD_P_TG4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTG4LFGM(TMD_P_TG4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTG4NLM(TMD_P_TG4 * op, VERT * vp, VERT * np, PACKET * pk, int n,
+			             int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsA4divTNG4M(TMD_P_TNG4 * op, VERT * vp, PACKET * pk, int n,
+			            int shift, GsOT * ot, u_long * scratch);
+	PACKET *GsTMDfastF3GL(TMD_P_F3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastF3GLFG(TMD_P_F3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastF3GNL(TMD_P_F3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG3GL(TMD_P_G3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG3GLFG(TMD_P_G3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG3GNL(TMD_P_G3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsPrstF3GL(TMD_P_F3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsPrstF3GLFG(TMD_P_F3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsPrstF3GNL(TMD_P_F3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsPrstG3GL(TMD_P_G3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsPrstG3GLFG(TMD_P_G3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsPrstG3GNL(TMD_P_G3G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG3M(TMD_P_G3 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG3MFG(TMD_P_G3 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastTG3M(TMD_P_TG3 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastTG3MFG(TMD_P_TG3 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastF4GL(TMD_P_F4G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastF4GLFG(TMD_P_F4G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastF4GNL(TMD_P_F4G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG4GL(TMD_P_G4G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG4GLFG(TMD_P_G4G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG4GNL(TMD_P_G4G *op, VERT *vp, VERT *np, PACKET *pk,
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG4M(TMD_P_G4 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastG4MFG(TMD_P_G4 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastTG4M(TMD_P_TG4 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastTG4MFG(TMD_P_TG4 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastF3M(TMD_P_F3 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastF3MFG(TMD_P_F3 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastTF3M(TMD_P_TF3 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastTF3MFG(TMD_P_TF3 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastF4M(TMD_P_F4 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastF4MFG(TMD_P_F4 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastTF4M(TMD_P_TF4 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+	PACKET *GsTMDfastTF4MFG(TMD_P_TF4 *op, VERT *vp, VERT *np, PACKET *pk, 
+						int n, int shift, GsOT *ot, u_long *scratch);
+
+#if defined(_LANGUAGE_C_PLUS_PLUS)||defined(__cplusplus)||defined(c_plusplus)
+}
+#endif
+
+
+
+/* EXTERN */
+extern RECT CLIP2;		/* clipping area */
+extern short PSDBASEX[2], PSDBASEY[2];	/* double buffer base */
+extern short PSDIDX;		/* double buffer index */
+extern u_long PSDCNT;		/* frame counter for using matrix cache */
+extern _GsPOSITION POSITION;	/* 2d offset */
+extern DRAWENV GsDRAWENV;	/* DRAWENV of Gs */
+extern DISPENV GsDISPENV;	/* DISPENV of Gs */
+extern MATRIX GsWSMATRIX;	/* Current World-Screen Matrix of Gs */
+extern MATRIX GsWSMATRIX_ORG;	/* Original World-Screen Matrix of Gs */
+extern long HWD0, VWD0;		/* rezolution of Holyzontal and Vertical */
+extern MATRIX GsLIGHTWSMATRIX;	/* World-Screen Light Matrix of Gs */
+extern MATRIX GsIDMATRIX;	/* Unit Matrix */
+extern MATRIX GsIDMATRIX2;	/* Unit Matrix including Aspect retio */
+extern PACKET *GsOUT_PACKET_P;	/* Work Base pointer */
+extern long GsADIVZ;		/* Active sub divide condition (z) */
+extern short GsADIVW, GsADIVH;	/* Active sub divide condition (w,h) */
+extern int GsLIGHT_MODE;	/* lighting mode global */
+extern u_long GsMATE_C, GsLMODE, GsLIGNR, GsLIOFF, GsZOVER, GsBACKC, GsNDIV;
+extern u_long GsTRATE, GsTON, GsDISPON;
+
+
+#if 0
+extern _GsFCALL GsFCALL5;	/* GsSortObject5J Func Table */
+/* hook only functions to use */
+jt_init5()
+{				/* GsSortObject5J Hook Func */
+	PACKET *GsPrstF3NL(), *GsPrstF3LFG(), *GsPrstF3L(), *GsPrstNF3();
+	PACKET *GsTMDdivF3NL(), *GsTMDdivF3LFG(), *GsTMDdivF3L(), *GsTMDdivNF3();
+	PACKET *GsPrstG3NL(), *GsPrstG3LFG(), *GsPrstG3L(), *GsPrstNG3();
+	PACKET *GsTMDdivG3NL(), *GsTMDdivG3LFG(), *GsTMDdivG3L(), *GsTMDdivNG3();
+	PACKET *GsPrstTF3NL(), *GsPrstTF3LFG(), *GsPrstTF3L(), *GsPrstTNF3();
+	PACKET *GsTMDdivTF3NL(), *GsTMDdivTF3LFG(), *GsTMDdivTF3L(),*GsTMDdivTNF3();
+	PACKET *GsPrstTG3NL(), *GsPrstTG3LFG(), *GsPrstTG3L(), *GsPrstTNG3();
+	PACKET *GsTMDdivTG3NL(), *GsTMDdivTG3LFG(), *GsTMDdivTG3L(),*GsTMDdivTNG3();
+	PACKET *GsPrstF4NL(), *GsPrstF4LFG(), *GsPrstF4L(), *GsPrstNF4();
+	PACKET *GsTMDdivF4NL(), *GsTMDdivF4LFG(), *GsTMDdivF4L(), *GsTMDdivNF4();
+	PACKET *GsPrstG4NL(), *GsPrstG4LFG(), *GsPrstG4L(), *GsPrstNG4();
+	PACKET *GsTMDdivG4NL(), *GsTMDdivG4LFG(), *GsTMDdivG4L(), *GsTMDdivNG4();
+	PACKET *GsPrstTF4NL(), *GsPrstTF4LFG(), *GsPrstTF4L(), *GsPrstTNF4();
+	PACKET *GsTMDdivTF4NL(), *GsTMDdivTF4LFG(), *GsTMDdivTF4L(),*GsTMDdivTNF4();
+	PACKET *GsPrstTG4NL(), *GsPrstTG4LFG(), *GsPrstTG4L(), *GsPrstTNG4();
+	PACKET *GsTMDdivTG4NL(), *GsTMDdivTG4LFG(), *GsTMDdivTG4L(),*GsTMDdivTNG4();
+	PACKET *GsPrstF3GNL(), *GsPrstF3GLFG(), *GsPrstF3GL();
+	PACKET *GsPrstG3GNL(), *GsPrstG3GLFG(), *GsPrstG3GL();
+
+	/* flat triangle */
+	GsFCALL5.f3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsPrstF3L;
+	GsFCALL5.f3[GsDivMODE_NDIV][GsLMODE_FOG] = GsPrstF3LFG;
+	GsFCALL5.f3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsPrstF3NL;
+	GsFCALL5.f3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivF3L;
+	GsFCALL5.f3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivF3LFG;
+	GsFCALL5.f3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivF3NL;
+	GsFCALL5.nf3[GsDivMODE_NDIV] = GsPrstNF3;
+	GsFCALL5.nf3[GsDivMODE_DIV] = GsTMDdivNF3;
+	/* gour triangle */
+	GsFCALL5.g3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsPrstG3L;
+	GsFCALL5.g3[GsDivMODE_NDIV][GsLMODE_FOG] = GsPrstG3LFG;
+	GsFCALL5.g3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsPrstG3NL;
+	GsFCALL5.g3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivG3L;
+	GsFCALL5.g3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivG3LFG;
+	GsFCALL5.g3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivG3NL;
+	GsFCALL5.ng3[GsDivMODE_NDIV] = GsPrstNG3;
+	GsFCALL5.ng3[GsDivMODE_DIV] = GsTMDdivNG3;
+	/* texture flat triangle */
+	GsFCALL5.tf3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsPrstTF3L;
+	GsFCALL5.tf3[GsDivMODE_NDIV][GsLMODE_FOG] = GsPrstTF3LFG;
+	GsFCALL5.tf3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsPrstTF3NL;
+	GsFCALL5.tf3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTF3L;
+	GsFCALL5.tf3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTF3LFG;
+	GsFCALL5.tf3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTF3NL;
+	GsFCALL5.ntf3[GsDivMODE_NDIV] = GsPrstTNF3;
+	GsFCALL5.ntf3[GsDivMODE_DIV] = GsTMDdivTNF3;
+	/* texture gour triangle */
+	GsFCALL5.tg3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsPrstTG3L;
+	GsFCALL5.tg3[GsDivMODE_NDIV][GsLMODE_FOG] = GsPrstTG3LFG;
+	GsFCALL5.tg3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsPrstTG3NL;
+	GsFCALL5.tg3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTG3L;
+	GsFCALL5.tg3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTG3LFG;
+	GsFCALL5.tg3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTG3NL;
+	GsFCALL5.ntg3[GsDivMODE_NDIV] = GsPrstTNG3;
+	GsFCALL5.ntg3[GsDivMODE_DIV] = GsTMDdivTNG3;
+	/* flat quad */
+	GsFCALL5.f4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsPrstF4L;
+	GsFCALL5.f4[GsDivMODE_NDIV][GsLMODE_FOG] = GsPrstF4LFG;
+	GsFCALL5.f4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsPrstF4NL;
+	GsFCALL5.f4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivF4L;
+	GsFCALL5.f4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivF4LFG;
+	GsFCALL5.f4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivF4NL;
+	GsFCALL5.nf4[GsDivMODE_NDIV] = GsPrstNF4;
+	GsFCALL5.nf4[GsDivMODE_DIV] = GsTMDdivNF4;
+	/* gour quad */
+	GsFCALL5.g4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsPrstG4L;
+	GsFCALL5.g4[GsDivMODE_NDIV][GsLMODE_FOG] = GsPrstG4LFG;
+	GsFCALL5.g4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsPrstG4NL;
+	GsFCALL5.g4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivG4L;
+	GsFCALL5.g4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivG4LFG;
+	GsFCALL5.g4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivG4NL;
+	GsFCALL5.ng4[GsDivMODE_NDIV] = GsPrstNG4;
+	GsFCALL5.ng4[GsDivMODE_DIV] = GsTMDdivNG4;
+	/* texture flat quad */
+	GsFCALL5.tf4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsPrstTF4L;
+	GsFCALL5.tf4[GsDivMODE_NDIV][GsLMODE_FOG] = GsPrstTF4LFG;
+	GsFCALL5.tf4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsPrstTF4NL;
+	GsFCALL5.tf4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTF4L;
+	GsFCALL5.tf4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTF4LFG;
+	GsFCALL5.tf4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTF4NL;
+	GsFCALL5.ntf4[GsDivMODE_NDIV] = GsPrstTNF4;
+	GsFCALL5.ntf4[GsDivMODE_DIV] = GsTMDdivTNF4;
+	/* texture gour quad */
+	GsFCALL5.tg4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsPrstTG4L;
+	GsFCALL5.tg4[GsDivMODE_NDIV][GsLMODE_FOG] = GsPrstTG4LFG;
+	GsFCALL5.tg4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsPrstTG4NL;
+	GsFCALL5.tg4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTG4L;
+	GsFCALL5.tg4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTG4LFG;
+	GsFCALL5.tg4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTG4NL;
+	GsFCALL5.ntg4[GsDivMODE_NDIV] = GsPrstTNG4;
+	GsFCALL5.ntg4[GsDivMODE_DIV] = GsTMDdivTNG4;
+	/* gradation triangle */
+	GsFCALL5.f3g[GsLMODE_NORMAL] = GsPrstF3GL;
+	GsFCALL5.f3g[GsLMODE_FOG] = GsPrstF3GLFG;
+	GsFCALL5.f3g[GsLMODE_LOFF] = GsPrstF3GNL;
+	GsFCALL5.g3g[GsLMODE_NORMAL] = GsPrstG3GL;
+	GsFCALL5.g3g[GsLMODE_FOG] = GsPrstG3GLFG;
+	GsFCALL5.g3g[GsLMODE_LOFF] = GsPrstG3GNL;
+}
+#endif
+
+#if 0
+extern _GsFCALL GsFCALL4;	/* GsSortObject4J Func Table */
+/* hook only functions to use*/
+jt_init4()
+{				/* GsSortObject4J Hook Func */
+	PACKET *GsTMDfastF3NL(), *GsTMDfastF3LFG(), *GsTMDfastF3L(),*GsTMDfastNF3();
+	PACKET *GsTMDdivF3NL(), *GsTMDdivF3LFG(), *GsTMDdivF3L(), *GsTMDdivNF3();
+	PACKET *GsTMDfastG3NL(), *GsTMDfastG3LFG(), *GsTMDfastG3L(),*GsTMDfastNG3();
+	PACKET *GsTMDdivG3NL(), *GsTMDdivG3LFG(), *GsTMDdivG3L(), *GsTMDdivNG3();
+	PACKET *GsTMDfastTF3NL(), *GsTMDfastTF3LFG(), *GsTMDfastTF3L(), *GsTMDfastTNF3();
+	PACKET *GsTMDdivTF3NL(), *GsTMDdivTF3LFG(), *GsTMDdivTF3L(), *GsTMDdivTNF3();
+	PACKET *GsTMDfastTG3NL(), *GsTMDfastTG3LFG(), *GsTMDfastTG3L(), *GsTMDfastTNG3();
+	PACKET *GsTMDdivTG3NL(), *GsTMDdivTG3LFG(), *GsTMDdivTG3L(), *GsTMDdivTNG3();
+	PACKET *GsTMDfastF4NL(), *GsTMDfastF4LFG(), *GsTMDfastF4L(), *GsTMDfastNF4();
+	PACKET *GsTMDdivF4NL(), *GsTMDdivF4LFG(), *GsTMDdivF4L(), *GsTMDdivNF4();
+	PACKET *GsTMDfastG4NL(), *GsTMDfastG4LFG(), *GsTMDfastG4L(), *GsTMDfastNG4();
+	PACKET *GsTMDdivG4NL(), *GsTMDdivG4LFG(), *GsTMDdivG4L(), *GsTMDdivNG4();
+	PACKET *GsTMDfastTF4NL(), *GsTMDfastTF4LFG(), *GsTMDfastTF4L(), *GsTMDfastTNF4();
+	PACKET *GsTMDdivTF4NL(), *GsTMDdivTF4LFG(), *GsTMDdivTF4L(), *GsTMDdivTNF4();
+	PACKET *GsTMDfastTG4NL(), *GsTMDfastTG4LFG(), *GsTMDfastTG4L(), *GsTMDfastTNG4();
+	PACKET *GsTMDdivTG4NL(), *GsTMDdivTG4LFG(), *GsTMDdivTG4L(), *GsTMDdivTNG4();
+
+	/* flat triangle */
+	GsFCALL4.f3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastF3L;
+	GsFCALL4.f3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastF3LFG;
+	GsFCALL4.f3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastF3NL;
+	GsFCALL4.f3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivF3L;
+	GsFCALL4.f3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivF3LFG;
+	GsFCALL4.f3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivF3NL;
+	GsFCALL4.nf3[GsDivMODE_NDIV] = GsTMDfastNF3;
+	GsFCALL4.nf3[GsDivMODE_DIV] = GsTMDdivNF3;
+	/* gour triangle */
+	GsFCALL4.g3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastG3L;
+	GsFCALL4.g3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastG3LFG;
+	GsFCALL4.g3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastG3NL;
+	GsFCALL4.g3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivG3L;
+	GsFCALL4.g3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivG3LFG;
+	GsFCALL4.g3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivG3NL;
+	GsFCALL4.ng3[GsDivMODE_NDIV] = GsTMDfastNG3;
+	GsFCALL4.ng3[GsDivMODE_DIV] = GsTMDdivNG3;
+	/* texture flat triangle */
+	GsFCALL4.tf3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTF3L;
+	GsFCALL4.tf3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTF3LFG;
+	GsFCALL4.tf3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTF3NL;
+	GsFCALL4.tf3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTF3L;
+	GsFCALL4.tf3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTF3LFG;
+	GsFCALL4.tf3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTF3NL;
+	GsFCALL4.ntf3[GsDivMODE_NDIV] = GsTMDfastTNF3;
+	GsFCALL4.ntf3[GsDivMODE_DIV] = GsTMDdivTNF3;
+	/* texture gour triangle */
+	GsFCALL4.tg3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTG3L;
+	GsFCALL4.tg3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTG3LFG;
+	GsFCALL4.tg3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTG3NL;
+	GsFCALL4.tg3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTG3L;
+	GsFCALL4.tg3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTG3LFG;
+	GsFCALL4.tg3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTG3NL;
+	GsFCALL4.ntg3[GsDivMODE_NDIV] = GsTMDfastTNG3;
+	GsFCALL4.ntg3[GsDivMODE_DIV] = GsTMDdivTNG3;
+	/* flat quad */
+	GsFCALL4.f4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastF4L;
+	GsFCALL4.f4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastF4LFG;
+	GsFCALL4.f4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastF4NL;
+	GsFCALL4.f4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivF4L;
+	GsFCALL4.f4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivF4LFG;
+	GsFCALL4.f4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivF4NL;
+	GsFCALL4.nf4[GsDivMODE_NDIV] = GsTMDfastNF4;
+	GsFCALL4.nf4[GsDivMODE_DIV] = GsTMDdivNF4;
+	/* gour quad */
+	GsFCALL4.g4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastG4L;
+	GsFCALL4.g4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastG4LFG;
+	GsFCALL4.g4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastG4NL;
+	GsFCALL4.g4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivG4L;
+	GsFCALL4.g4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivG4LFG;
+	GsFCALL4.g4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivG4NL;
+	GsFCALL4.ng4[GsDivMODE_NDIV] = GsTMDfastNG4;
+	GsFCALL4.ng4[GsDivMODE_DIV] = GsTMDdivNG4;
+	/* texture flat quad */
+	GsFCALL4.tf4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTF4L;
+	GsFCALL4.tf4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTF4LFG;
+	GsFCALL4.tf4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTF4NL;
+	GsFCALL4.tf4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTF4L;
+	GsFCALL4.tf4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTF4LFG;
+	GsFCALL4.tf4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTF4NL;
+	GsFCALL4.ntf4[GsDivMODE_NDIV] = GsTMDfastTNF4;
+	GsFCALL4.ntf4[GsDivMODE_DIV] = GsTMDdivTNF4;
+	/* texture gour quad */
+	GsFCALL4.tg4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTG4L;
+	GsFCALL4.tg4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTG4LFG;
+	GsFCALL4.tg4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTG4NL;
+	GsFCALL4.tg4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTG4L;
+	GsFCALL4.tg4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTG4LFG;
+	GsFCALL4.tg4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTG4NL;
+	GsFCALL4.ntg4[GsDivMODE_NDIV] = GsTMDfastTNG4;
+	GsFCALL4.ntg4[GsDivMODE_DIV] = GsTMDdivTNG4;
+	/* gradation  triangle */
+	GsFCALL4.f3g[GsLMODE_NORMAL] = GsTMDfastF3GL;
+	GsFCALL4.f3g[GsLMODE_FOG] = GsTMDfastF3GLFG;
+	GsFCALL4.f3g[GsLMODE_LOFF] = GsTMDfastF3GNL;
+	GsFCALL4.g3g[GsLMODE_NORMAL] = GsTMDfastG3GL;
+	GsFCALL4.g3g[GsLMODE_FOG] = GsTMDfastG3GLFG;
+	GsFCALL4.g3g[GsLMODE_LOFF] = GsTMDfastG3GNL;
+	/* gradation  quad */
+	GsFCALL4.f4g[GsLMODE_NORMAL] = GsTMDfastF4GL;
+	GsFCALL4.f4g[GsLMODE_FOG] = GsTMDfastF4GLFG;
+	GsFCALL4.f4g[GsLMODE_LOFF] = GsTMDfastF4GNL;
+	GsFCALL4.g4g[GsLMODE_NORMAL] = GsTMDfastG4GL;
+	GsFCALL4.g4g[GsLMODE_FOG] = GsTMDfastG4GLFG;
+	GsFCALL4.g4g[GsLMODE_LOFF] = GsTMDfastG4GNL;
+}
+#endif
+
+#if 0
+extern _GsFCALL GsFCALL4;	/* GsSortObject4J Func Table */
+jt_init4()
+{				/* Gs SortObject4J Active sub divide Func */
+	PACKET *GsTMDfastF3NL(), *GsTMDfastF3LFG(), *GsTMDfastF3L(), *GsTMDfastNF3();
+	PACKET *GsA4divF3NL(), *GsA4divF3LFG(), *GsA4divF3L(), *GsA4divNF3();
+	PACKET *GsTMDfastG3NL(), *GsTMDfastG3LFG(), *GsTMDfastG3L(), *GsTMDfastNG3();
+	PACKET *GsA4divG3NL(), *GsA4divG3LFG(), *GsA4divG3L(), *GsA4divNG3();
+	PACKET *GsTMDfastTF3NL(), *GsTMDfastTF3LFG(), *GsTMDfastTF3L(), *GsTMDfastTNF3();
+	PACKET *GsA4divTF3NL(), *GsA4divTF3LFG(), *GsA4divTF3L(), *GsA4divTNF3();
+	PACKET *GsTMDfastTG3NL(), *GsTMDfastTG3LFG(), *GsTMDfastTG3L(), *GsTMDfastTNG3();
+	PACKET *GsA4divTG3NL(), *GsA4divTG3LFG(), *GsA4divTG3L(), *GsA4divTNG3();
+	PACKET *GsTMDfastF4NL(), *GsTMDfastF4LFG(), *GsTMDfastF4L(), *GsTMDfastNF4();
+	PACKET *GsA4divF4NL(), *GsA4divF4LFG(), *GsA4divF4L(), *GsA4divNF4();
+	PACKET *GsTMDfastG4NL(), *GsTMDfastG4LFG(), *GsTMDfastG4L(), *GsTMDfastNG4();
+	PACKET *GsA4divG4NL(), *GsA4divG4LFG(), *GsA4divG4L(), *GsA4divNG4();
+	PACKET *GsTMDfastTF4NL(), *GsTMDfastTF4LFG(), *GsTMDfastTF4L(), *GsTMDfastTNF4();
+	PACKET *GsA4divTF4NL(), *GsA4divTF4LFG(), *GsA4divTF4L(), *GsA4divTNF4();
+	PACKET *GsTMDfastTG4NL(), *GsTMDfastTG4LFG(), *GsTMDfastTG4L(), *GsTMDfastTNG4();
+	PACKET *GsA4divTG4NL(), *GsA4divTG4LFG(), *GsA4divTG4L(), *GsA4divTNG4();
+	PACKET *GsA4divTF4L();
+
+	/* flat triangle */
+	GsFCALL4.f3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastF3L;
+	GsFCALL4.f3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastF3LFG;
+	GsFCALL4.f3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastF3NL;
+	GsFCALL4.f3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsA4divF3L;
+	GsFCALL4.f3[GsDivMODE_DIV][GsLMODE_FOG] = GsA4divF3LFG;
+	GsFCALL4.f3[GsDivMODE_DIV][GsLMODE_LOFF] = GsA4divF3NL;
+	GsFCALL4.nf3[GsDivMODE_NDIV] = GsTMDfastNF3;
+	GsFCALL4.nf3[GsDivMODE_DIV] = GsA4divNF3;
+	/* gour triangle */
+	GsFCALL4.g3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastG3L;
+	GsFCALL4.g3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastG3LFG;
+	GsFCALL4.g3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastG3NL;
+	GsFCALL4.g3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsA4divG3L;
+	GsFCALL4.g3[GsDivMODE_DIV][GsLMODE_FOG] = GsA4divG3LFG;
+	GsFCALL4.g3[GsDivMODE_DIV][GsLMODE_LOFF] = GsA4divG3NL;
+	GsFCALL4.ng3[GsDivMODE_NDIV] = GsTMDfastNG3;
+	GsFCALL4.ng3[GsDivMODE_DIV] = GsA4divNG3;
+	/* texture flat triangle */
+	GsFCALL4.tf3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTF3L;
+	GsFCALL4.tf3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTF3LFG;
+	GsFCALL4.tf3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTF3NL;
+	GsFCALL4.tf3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsA4divTF3L;
+	GsFCALL4.tf3[GsDivMODE_DIV][GsLMODE_FOG] = GsA4divTF3LFG;
+	GsFCALL4.tf3[GsDivMODE_DIV][GsLMODE_LOFF] = GsA4divTF3NL;
+	GsFCALL4.ntf3[GsDivMODE_NDIV] = GsTMDfastTNF3;
+	GsFCALL4.ntf3[GsDivMODE_DIV] = GsA4divTNF3;
+	/* texture gour triangle */
+	GsFCALL4.tg3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTG3L;
+	GsFCALL4.tg3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTG3LFG;
+	GsFCALL4.tg3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTG3NL;
+	GsFCALL4.tg3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsA4divTG3L;
+	GsFCALL4.tg3[GsDivMODE_DIV][GsLMODE_FOG] = GsA4divTG3LFG;
+	GsFCALL4.tg3[GsDivMODE_DIV][GsLMODE_LOFF] = GsA4divTG3NL;
+	GsFCALL4.ntg3[GsDivMODE_NDIV] = GsTMDfastTNG3;
+	GsFCALL4.ntg3[GsDivMODE_DIV] = GsA4divTNG3;
+	/* flat quad */
+	GsFCALL4.f4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastF4L;
+	GsFCALL4.f4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastF4LFG;
+	GsFCALL4.f4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastF4NL;
+	GsFCALL4.f4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsA4divF4L;
+	GsFCALL4.f4[GsDivMODE_DIV][GsLMODE_FOG] = GsA4divF4LFG;
+	GsFCALL4.f4[GsDivMODE_DIV][GsLMODE_LOFF] = GsA4divF4NL;
+	GsFCALL4.nf4[GsDivMODE_NDIV] = GsTMDfastNF4;
+	GsFCALL4.nf4[GsDivMODE_DIV] = GsA4divNF4;
+	/* gour quad */
+	GsFCALL4.g4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastG4L;
+	GsFCALL4.g4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastG4LFG;
+	GsFCALL4.g4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastG4NL;
+	GsFCALL4.g4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsA4divG4L;
+	GsFCALL4.g4[GsDivMODE_DIV][GsLMODE_FOG] = GsA4divG4LFG;
+	GsFCALL4.g4[GsDivMODE_DIV][GsLMODE_LOFF] = GsA4divG4NL;
+	GsFCALL4.ng4[GsDivMODE_NDIV] = GsTMDfastNG4;
+	GsFCALL4.ng4[GsDivMODE_DIV] = GsA4divNG4;
+	/* texture flat quad */
+	GsFCALL4.tf4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTF4L;
+	GsFCALL4.tf4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTF4LFG;
+	GsFCALL4.tf4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTF4NL;
+	GsFCALL4.tf4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsA4divTF4L;
+	GsFCALL4.tf4[GsDivMODE_DIV][GsLMODE_FOG] = GsA4divTF4LFG;
+	GsFCALL4.tf4[GsDivMODE_DIV][GsLMODE_LOFF] = GsA4divTF4NL;
+	GsFCALL4.ntf4[GsDivMODE_NDIV] = GsTMDfastTNF4;
+	GsFCALL4.ntf4[GsDivMODE_DIV] = GsA4divTNF4;
+	/* texture gour quad */
+	GsFCALL4.tg4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTG4L;
+	GsFCALL4.tg4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTG4LFG;
+	GsFCALL4.tg4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTG4NL;
+	GsFCALL4.tg4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsA4divTG4L;
+	GsFCALL4.tg4[GsDivMODE_DIV][GsLMODE_FOG] = GsA4divTG4LFG;
+	GsFCALL4.tg4[GsDivMODE_DIV][GsLMODE_LOFF] = GsA4divTG4NL;
+	GsFCALL4.ntg4[GsDivMODE_NDIV] = GsTMDfastTNG4;
+	GsFCALL4.ntg4[GsDivMODE_DIV] = GsA4divTNG4;
+	/* gradation triangle */
+	GsFCALL4.f3g[GsLMODE_NORMAL] = GsTMDfastF3GL;
+	GsFCALL4.f3g[GsLMODE_FOG] = GsTMDfastF3GLFG;
+	GsFCALL4.f3g[GsLMODE_LOFF] = GsTMDfastF3GNL;
+	GsFCALL4.g3g[GsLMODE_NORMAL] = GsTMDfastG3GL;
+	GsFCALL4.g3g[GsLMODE_FOG] = GsTMDfastG3GLFG;
+	GsFCALL4.g3g[GsLMODE_LOFF] = GsTMDfastG3GNL;
+	/* gradation  quad */
+	GsFCALL4.f4g[GsLMODE_NORMAL] = GsTMDfastF4GL;
+	GsFCALL4.f4g[GsLMODE_FOG] = GsTMDfastF4GLFG;
+	GsFCALL4.f4g[GsLMODE_LOFF] = GsTMDfastF4GNL;
+	GsFCALL4.g4g[GsLMODE_NORMAL] = GsTMDfastG4GL;
+	GsFCALL4.g4g[GsLMODE_FOG] = GsTMDfastG4GLFG;
+	GsFCALL4.g4g[GsLMODE_LOFF] = GsTMDfastG4GNL;
+}
+#endif
+
+#if 0
+extern _GsFCALL GsFCALL4;	/* GsSortObject4J Func Table */
+/* hook only functions to use */
+jt_init4()
+{				/* GsSortObject4J Hook Func (for material attenuation)*/
+	PACKET *GsTMDfastF3NL(), *GsTMDfastF3MFG(), *GsTMDfastF3M(),*GsTMDfastNF3();
+	PACKET *GsTMDdivF3NL(), *GsTMDdivF3LFG(), *GsTMDdivF3L(), *GsTMDdivNF3();
+	PACKET *GsTMDfastG3NL(), *GsTMDfastG3MFG(), *GsTMDfastG3M(),*GsTMDfastNG3();
+	PACKET *GsTMDdivG3NL(), *GsTMDdivG3LFG(), *GsTMDdivG3L(), *GsTMDdivNG3();
+	PACKET *GsTMDfastTF3NL(), *GsTMDfastTF3MFG(), *GsTMDfastTF3M(), *GsTMDfastTNF3();
+	PACKET *GsTMDdivTF3NL(), *GsTMDdivTF3LFG(), *GsTMDdivTF3L(), *GsTMDdivTNF3();
+	PACKET *GsTMDfastTG3NL(), *GsTMDfastTG3MFG(), *GsTMDfastTG3M(), *GsTMDfastTNG3();
+	PACKET *GsTMDdivTG3NL(), *GsTMDdivTG3LFG(), *GsTMDdivTG3L(), *GsTMDdivTNG3();
+	PACKET *GsTMDfastF4NL(), *GsTMDfastF4MFG(), *GsTMDfastF4M(), *GsTMDfastNF4();
+	PACKET *GsTMDdivF4NL(), *GsTMDdivF4LFG(), *GsTMDdivF4L(), *GsTMDdivNF4();
+	PACKET *GsTMDfastG4NL(), *GsTMDfastG4MFG(), *GsTMDfastG4M(), *GsTMDfastNG4();
+	PACKET *GsTMDdivG4NL(), *GsTMDdivG4LFG(), *GsTMDdivG4L(), *GsTMDdivNG4();
+	PACKET *GsTMDfastTF4NL(), *GsTMDfastTF4MFG(), *GsTMDfastTF4M(), *GsTMDfastTNF4();
+	PACKET *GsTMDdivTF4NL(), *GsTMDdivTF4LFG(), *GsTMDdivTF4L(), *GsTMDdivTNF4();
+	PACKET *GsTMDfastTG4NL(), *GsTMDfastTG4MFG(), *GsTMDfastTG4M(), *GsTMDfastTNG4();
+	PACKET *GsTMDdivTG4NL(), *GsTMDdivTG4LFG(), *GsTMDdivTG4L(), *GsTMDdivTNG4();
+
+	/* flat triangle */
+	GsFCALL4.f3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastF3M;
+	GsFCALL4.f3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastF3MFG;
+	GsFCALL4.f3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastF3NL;
+	GsFCALL4.f3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivF3L;
+	GsFCALL4.f3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivF3LFG;
+	GsFCALL4.f3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivF3NL;
+	GsFCALL4.nf3[GsDivMODE_NDIV] = GsTMDfastNF3;
+	GsFCALL4.nf3[GsDivMODE_DIV] = GsTMDdivNF3;
+	/* gour triangle */
+	GsFCALL4.g3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastG3M;
+	GsFCALL4.g3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastG3MFG;
+	GsFCALL4.g3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastG3NL;
+	GsFCALL4.g3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivG3L;
+	GsFCALL4.g3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivG3LFG;
+	GsFCALL4.g3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivG3NL;
+	GsFCALL4.ng3[GsDivMODE_NDIV] = GsTMDfastNG3;
+	GsFCALL4.ng3[GsDivMODE_DIV] = GsTMDdivNG3;
+	/* texture flat triangle */
+	GsFCALL4.tf3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTF3M;
+	GsFCALL4.tf3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTF3MFG;
+	GsFCALL4.tf3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTF3NL;
+	GsFCALL4.tf3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTF3L;
+	GsFCALL4.tf3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTF3LFG;
+	GsFCALL4.tf3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTF3NL;
+	GsFCALL4.ntf3[GsDivMODE_NDIV] = GsTMDfastTNF3;
+	GsFCALL4.ntf3[GsDivMODE_DIV] = GsTMDdivTNF3;
+	/* texture gour triangle */
+	GsFCALL4.tg3[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTG3M;
+	GsFCALL4.tg3[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTG3MFG;
+	GsFCALL4.tg3[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTG3NL;
+	GsFCALL4.tg3[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTG3L;
+	GsFCALL4.tg3[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTG3LFG;
+	GsFCALL4.tg3[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTG3NL;
+	GsFCALL4.ntg3[GsDivMODE_NDIV] = GsTMDfastTNG3;
+	GsFCALL4.ntg3[GsDivMODE_DIV] = GsTMDdivTNG3;
+	/* flat quad */
+	GsFCALL4.f4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastF4M;
+	GsFCALL4.f4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastF4MFG;
+	GsFCALL4.f4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastF4NL;
+	GsFCALL4.f4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivF4L;
+	GsFCALL4.f4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivF4LFG;
+	GsFCALL4.f4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivF4NL;
+	GsFCALL4.nf4[GsDivMODE_NDIV] = GsTMDfastNF4;
+	GsFCALL4.nf4[GsDivMODE_DIV] = GsTMDdivNF4;
+	/* gour quad */
+	GsFCALL4.g4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastG4M;
+	GsFCALL4.g4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastG4MFG;
+	GsFCALL4.g4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastG4NL;
+	GsFCALL4.g4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivG4L;
+	GsFCALL4.g4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivG4LFG;
+	GsFCALL4.g4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivG4NL;
+	GsFCALL4.ng4[GsDivMODE_NDIV] = GsTMDfastNG4;
+	GsFCALL4.ng4[GsDivMODE_DIV] = GsTMDdivNG4;
+	/* texture flat quad */
+	GsFCALL4.tf4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTF4M;
+	GsFCALL4.tf4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTF4MFG;
+	GsFCALL4.tf4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTF4NL;
+	GsFCALL4.tf4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTF4L;
+	GsFCALL4.tf4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTF4LFG;
+	GsFCALL4.tf4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTF4NL;
+	GsFCALL4.ntf4[GsDivMODE_NDIV] = GsTMDfastTNF4;
+	GsFCALL4.ntf4[GsDivMODE_DIV] = GsTMDdivTNF4;
+	/* texture gour quad */
+	GsFCALL4.tg4[GsDivMODE_NDIV][GsLMODE_NORMAL] = GsTMDfastTG4M;
+	GsFCALL4.tg4[GsDivMODE_NDIV][GsLMODE_FOG] = GsTMDfastTG4MFG;
+	GsFCALL4.tg4[GsDivMODE_NDIV][GsLMODE_LOFF] = GsTMDfastTG4NL;
+	GsFCALL4.tg4[GsDivMODE_DIV][GsLMODE_NORMAL] = GsTMDdivTG4L;
+	GsFCALL4.tg4[GsDivMODE_DIV][GsLMODE_FOG] = GsTMDdivTG4LFG;
+	GsFCALL4.tg4[GsDivMODE_DIV][GsLMODE_LOFF] = GsTMDdivTG4NL;
+	GsFCALL4.ntg4[GsDivMODE_NDIV] = GsTMDfastTNG4;
+	GsFCALL4.ntg4[GsDivMODE_DIV] = GsTMDdivTNG4;
+	/* gradation  triangle */
+	GsFCALL4.f3g[GsLMODE_NORMAL] = GsTMDfastF3GL;
+	GsFCALL4.f3g[GsLMODE_FOG] = GsTMDfastF3GLFG;
+	GsFCALL4.f3g[GsLMODE_LOFF] = GsTMDfastF3GNL;
+	GsFCALL4.g3g[GsLMODE_NORMAL] = GsTMDfastG3GL;
+	GsFCALL4.g3g[GsLMODE_FOG] = GsTMDfastG3GLFG;
+	GsFCALL4.g3g[GsLMODE_LOFF] = GsTMDfastG3GNL;
+	/* gradation  quad */
+	GsFCALL4.f4g[GsLMODE_NORMAL] = GsTMDfastF4GL;
+	GsFCALL4.f4g[GsLMODE_FOG] = GsTMDfastF4GLFG;
+	GsFCALL4.f4g[GsLMODE_LOFF] = GsTMDfastF4GNL;
+	GsFCALL4.g4g[GsLMODE_NORMAL] = GsTMDfastG4GL;
+	GsFCALL4.g4g[GsLMODE_FOG] = GsTMDfastG4GLFG;
+	GsFCALL4.g4g[GsLMODE_LOFF] = GsTMDfastG4GNL;
+}
+#endif
+
+#endif				/* _LIBGS_H_ */

psy-q-sdk/bindings/libgte.pas

@@ -0,0 +1,394 @@
+{$MODE OBJFPC}
+unit libgte; 
+interface
+
+
+// Geometry Structures:
+const
+		ONE	= 4096;	// GTE regards 4096 as 1.0
+		TMPVTXNUM = 16;	// Clip Function Header
+		OUTVTXNUM = 10;
+
+
+type
+	MATRIX = packed record
+				m : array [0..2, 0..2] of smallint;		// 3x3 rotation matrix
+        		t : array [0..2] of longint;		// transfer vector
+        	 end;
+    PMATRIX = ^MATRIX;
+
+    VECTOR = packed record							// long word type 3D vector
+				vx, vy : longint;
+				vz, pad : longint;
+			 end;
+	PVECTOR = ^VECTOR;
+	
+	SVECTOR = packed record							// short word type 3D vector
+				vx, vy : smallint;
+				vz, pad : smallint;
+			  end;
+	PSVECTOR = ^SVECTOR;
+	       
+	CVECTOR = packed record							// color type vector
+			  	r, g, b, cd : byte;
+			  end;
+	PCVECTOR = ^CVECTOR;
+	       
+	DVECTOR = packed record							// 2D short vector
+				vx, vy : smallint;
+			  end;
+	PDVECTOR = ^DVECTOR;
+
+	EVECTOR = packed record
+				v : SVECTOR;						// Object(Local) 3D Vertex
+				sxyz : VECTOR;						// Screen 3D Vertex
+				sxy : DVECTOR;						// Screen 2D Vertex
+				rgb : CVECTOR;						// Vertex Color Data
+				txuv, pad : smallint;				// Texture Mapping Data
+				chx, chy : longint;					// Clip Window Data
+		     end;
+	PEVECTOR = ^EVECTOR;
+	PPEVECTOR = ^PEVECTOR;
+
+	RVECTOR = packed record							// division vertex data vector
+				v : SVECTOR;
+				uv : array [0..1] of byte;
+	 			pad : word;
+				c : CVECTOR;
+				sxy : DVECTOR;
+				sz : dword;							// clip z-data
+			  end;
+	PRVECTOR = ^RVECTOR;
+
+	CRVECTOR3 = packed record						// recursive vector for triangles
+					r01, r12, r20 : RVECTOR;
+					r0, r1, r2 : PRVECTOR;
+					rtn : pdword;
+				end;
+
+	DIVPOLYGON3 = packed record						// division buffer for triangles
+					ndiv : dword;					// number of divisions
+					pih, piv : dword;				// clipping area
+					clut, tpage : word;
+					rgbc : CVECTOR;
+					ot : pdword;
+					r0, r1, r2 : RVECTOR;
+					cr : array [0..4] of CRVECTOR3;
+				  end;
+
+	CRVECTOR4 = packed record						// recursive vector for four-sided polygons
+					r01, r02, r31, r32, rc : RVECTOR;
+					r0, r1, r2, r3 : PRVECTOR;
+					rtn : pdword;
+				end;
+
+	DIVPOLYGON4 = packed record						// division buffer for four-sided polygons
+					ndiv : dword;					// number of divisions
+					pih, piv : dword;				// clipping area
+					clut, tpage : word;
+					rgbc : CVECTOR;
+					ot : pdword;
+					r0, r1, r2, r3 : RVECTOR;
+					cr : array [0..4] of CRVECTOR4;
+				 end;
+
+	SPOL = packed record
+        		xy : array [0..2] of smallint;
+        		uv : array [0..1] of smallint;
+        		rgb : array [0..2] of smallint;
+           end;
+    PSPOL = ^SPOL;
+
+                                        
+    POL4 = packed record							// polygon: 41 bytes/1 polygon
+        	sxy : array [0..3, 0..1] of smallint;   //0..7
+        	sz : array [0..3, 0..1] of smallint;    // 8..15sz[][1] is dummy
+        	uv  : array [0..3, 0..1] of smallint;   // 16..23
+        	rgb : array [0..3, 0..2] of smallint;   // 23..34
+        	code : smallint;                   		// 35...  F4:5, TF4:6, G4:7, TG4:8
+           end;
+    PPOL4 = ^POL4;
+
+    POL3 = packed record
+        	sxy : array [0..2, 0..1] of smallint;
+        	sz : array [0..2, 0..1] of smallint;   	// sz[][1] is dummy
+        	uv : array [0..2, 0..1] of smallint;
+        	rgb : array [0..2, 0..2] of smallint;
+        	code : smallint;                   		// F3:1, TF3:2, G3:3, TG3:4
+    	  end;
+    PPOL3 = ^POL3;
+
+   	TMESH = packed record
+	   			v : PSVECTOR;                     	// shared vertices
+        		n : PSVECTOR;                     	// shared normals
+        		u : PSVECTOR;                     	// shared texture addresses
+        		c : PCVECTOR;                     	// shared colors
+        		len : dword;                    	// mesh length(=#vertex)
+        	end;
+
+
+    QMESH = packed record
+        		v : PSVECTOR;                     	// shared vertices
+        		n : PSVECTOR;                     	// shared normals
+        		u : PSVECTOR;                     	// shared texture addresses
+        		c : PCVECTOR;                     	// shared colors
+        		lenv : dword;                   	// mesh length_V(=#vertex_V)
+        		lenh : dword;                   	// mesh length_H(=#vertex_H)
+    		end;
+
+
+
+procedure InitGeom; stdcall; external;
+
+procedure EigenMatrix(m, t: PMATRIX); stdcall; external;
+function IsIdMatrix(m: PMATRIX): longint; stdcall; external;
+function MulMatrix0(m0, m1, m2: PMATRIX): PMATRIX; stdcall; external;
+function MulRotMatrix0(m0, m1: PMATRIX): PMATRIX; stdcall; external;
+function MulMatrix(m0, m1: PMATRIX): PMATRIX; stdcall; external;
+function MulMatrix2(m0, m1: PMATRIX): PMATRIX; stdcall; external;
+function MulRotMatrix(m0: PMATRIX): PMATRIX; stdcall; external;
+function SetMulMatrix(m0, m1: PMATRIX): PMATRIX; stdcall; external;
+function SetMulRotMatrix(m0: PMATRIX): PMATRIX; stdcall; external;
+
+function ApplyMatrix(m: PMATRIX; v0: PSVECTOR; v1: PVECTOR): PVECTOR; stdcall; external;
+function ApplyRotMatrix(v0: PSVECTOR; v1: PVECTOR): PVECTOR; stdcall; external;
+function ApplyRotMatrixLV(v0, v1: PVECTOR): PVECTOR; stdcall; external;
+function ApplyMatrixLV(m: PMATRIX; v0, v1: PVECTOR): PVECTOR; stdcall; external;
+
+function ApplyMatrixSV(m: PMATRIX; v0, v1: PSVECTOR): PSVECTOR; stdcall; external;
+
+function ApplyTransposeMatrixLV(m: PMATRIX; v0, v1: PVECTOR): PVECTOR; stdcall; external;
+
+function RotMatrix(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixXZY(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixYXZ(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixYZX(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixZXY(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixZYX(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrix_gte(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixYXZ_gte(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixZYX_gte(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixX(r: longint; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixY(r: longint; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixZ(r: longint; m: PMATRIX): PMATRIX; stdcall; external;
+function RotMatrixC(r: PSVECTOR; m: PMATRIX): PMATRIX; stdcall; external;
+function TransMatrix(m: PMATRIX; v: PVECTOR): PMATRIX; stdcall; external;
+function ScaleMatrix(m: PMATRIX; v: PVECTOR): PMATRIX; stdcall; external;
+function ScaleMatrixL(m: PMATRIX; v: PVECTOR): PMATRIX; stdcall; external;
+function TransposeMatrix(m0, m1: PMATRIX): PMATRIX; stdcall; external;
+function CompMatrix(m0, m1, m2: PMATRIX): PMATRIX; stdcall; external;
+function CompMatrixLV(m0, m1, m2: PMATRIX): PMATRIX; stdcall; external;
+
+procedure MatrixNormal(m, n: PMATRIX); stdcall; external;
+procedure MatrixNormal_0(m, n: PMATRIX); stdcall; external;
+procedure MatrixNormal_1(m, n: PMATRIX); stdcall; external;
+procedure MatrixNormal_2(m, n: PMATRIX); stdcall; external;
+
+procedure SetRotMatrix(m: PMATRIX); stdcall; external;
+procedure SetLightMatrix(m: PMATRIX); stdcall; external;
+procedure SetColorMatrix(m: PMATRIX); stdcall; external;
+procedure SetTransMatrix(m: PMATRIX); stdcall; external;
+procedure PushMatrix; stdcall; external;
+procedure PopMatrix; stdcall; external;
+procedure ReadRotMatrix(m: PMATRIX); stdcall; external;
+procedure ReadLightMatrix(m: PMATRIX); stdcall; external;
+procedure ReadColorMatrix(m: PMATRIX); stdcall; external;
+procedure SetRGBcd(v: PCVECTOR); stdcall; external;
+procedure SetBackColor(rbk, gbk, bbk: longint); stdcall; external;
+procedure SetFarColor(rfc, gfc, bfc: longint); stdcall; external;
+procedure SetGeomOffset(ofx, ofy: longint); stdcall; external;
+procedure SetGeomScreen(h: longint); stdcall; external;
+procedure ReadSZfifo3(sz0, sz1, sz2: plongint); stdcall; external;
+procedure ReadSZfifo4(szx, sz0, sz1, sz2: plongint); stdcall; external;
+procedure ReadSXSYfifo(sxy0, sxy1, sxy2: plongint); stdcall; external;
+procedure ReadRGBfifo(v0, v1, v2: PCVECTOR); stdcall; external;
+procedure ReadGeomOffset(ofx, ofy: plongint); stdcall; external;
+function ReadGeomScreen: longint; stdcall; external;
+
+procedure TransRot_32(v0, v1: PVECTOR; flag: plongint); stdcall; external;
+function TransRotPers(v0: PSVECTOR; sxy: plongint; p: plongint; flag: plongint): longint; stdcall; external;
+function TransRotPers3(v0, v1, v2: PSVECTOR; sxy0, sxy1, sxy2: plongint; p: plongint; flag: plongint): longint; stdcall; external;
+
+//procedure pers_map(abuf: longint; vertex: pointer; int tex[4][2], u_short *dtext); stdcall; external;
+procedure PhongLine(istart_x, iend_x: longint; p, q: longint; pixx: pointer; fs, ft, i4, det: longint); stdcall; external;
+
+function RotTransPers(v0: PSVECTOR; sxy, p, flag: plongint): longint; stdcall; external;
+function RotTransPers3(v0, v1, v2: PSVECTOR; sxy0, sxy1, sxy2: plongint; p: plongint; flag: plongint): longint; stdcall; external;
+procedure RotTrans(v0: PSVECTOR; v1: PVECTOR; flag: plongint); stdcall; external;
+procedure RotTransSV(v0, v1: PSVECTOR; flag: plongint); stdcall; external;
+procedure LocalLight(v0: PSVECTOR; v1: PVECTOR); stdcall; external;
+procedure LightColor(v0, v1: PVECTOR); stdcall; external;
+procedure DpqColorLight(v0: PVECTOR; v1: PCVECTOR; p: longint; v2: PCVECTOR); stdcall; external;
+procedure DpqColor(v0: PCVECTOR; p: longint; v1: PCVECTOR); stdcall; external;
+procedure DpqColor3(v0, v1, v2: PCVECTOR; p: longint; v3, v4, v5: PCVECTOR); stdcall; external;
+procedure Intpl(v0:PVECTOR; p: longint; v1: PCVECTOR); stdcall; external;
+function Square12(v0, v1: PVECTOR):PVECTOR; stdcall; external;
+function Square0(v0, v1: PVECTOR):PVECTOR; stdcall; external;
+function SquareSL12(v0: PSVECTOR; v1: PVECTOR): PVECTOR; stdcall; external;
+function SquareSL0(v0: PSVECTOR; v1: PVECTOR): PVECTOR; stdcall; external;
+function SquareSS12(v0, v1: PSVECTOR): PSVECTOR; stdcall; external;
+function SquareSS0(v0, v1: PSVECTOR): PSVECTOR; stdcall; external;
+procedure NormalColor(v0: PSVECTOR; v1: PCVECTOR); stdcall; external;
+procedure NormalColor3(v0, v1, v2: PSVECTOR; v3, v4, v5:PCVECTOR); stdcall; external;
+procedure NormalColorDpq(v0: PSVECTOR; v1: PCVECTOR; p: longint; v2: PCVECTOR); stdcall; external;
+procedure NormalColorDpq3(v0, v1, v2: PSVECTOR; v3: PCVECTOR; p: longint; v4, v5, v6: PCVECTOR); stdcall; external;
+procedure NormalColorCol(v0: PSVECTOR; v1, v2: PCVECTOR); stdcall; external;
+procedure NormalColorCol3(v0, v1, v2: PSVECTOR; v3, v4, v5, v6: PCVECTOR); stdcall; external;
+procedure ColorDpq(v0: PVECTOR; v1: PCVECTOR; p: longint; v2: PCVECTOR); stdcall; external;
+procedure ColorCol(v0: PVECTOR; v1, v2: PCVECTOR); stdcall; external;
+function NormalClip(sxy0, sxy1, sxy2: longint): longint; stdcall; external;
+function AverageZ3(sz0, sz1, sz2: longint): longint; stdcall; external;
+function AverageZ4(sz0, sz1, sz2, sz3: longint): longint; stdcall; external;
+procedure OuterProduct12(v0, v1, v2: PVECTOR); stdcall; external;
+procedure OuterProduct0(v0, v1, v2: PVECTOR); stdcall; external;
+function Lzc(data: longint): longint; stdcall; external;
+
+function RotTransPers4(v0, v1, v2, v3: PSVECTOR; sxy0, sxy1, sxy2, sxy3: plongint; p, flag: plongint): longint; stdcall; external;
+procedure RotTransPersN(v0: PSVECTOR; v1: PDVECTOR; sz: pword; p, flag: pword; n: longint); stdcall; external;
+procedure RotTransPers3N(v0: PSVECTOR; v1: PDVECTOR; sz: pword; flag: pword; n: longint); stdcall; external;
+procedure RotMeshH(Yheight: pword; Vo: PDVECTOR; sz: pword; flag: pword; Xoffset, Zoffset: smallint; m, n: smallint; base: PDVECTOR); stdcall; external;
+function RotAverage3(v0, v1, v2: PSVECTOR; sxy0, sxy1, sxy2: plongint; p, flag: plongint): longint; stdcall; external;
+function RotAverage4(v0, v1, v2, v3: PSVECTOR; sxy0, sxy1, sxy2, sxy3: plongint; p, flag: plongint): longint; stdcall; external;
+function RotNclip3(v0, v1, v2: PSVECTOR; sxy0, sxy1, sxy2: plongint; p, otz, flag: plongint): longint; stdcall; external;
+function RotNclip4(v0, v1, v2, v3: PSVECTOR; sxy0, sxy1, sxy2, sxy3: plongint; p, otz, flag: plongint): longint; stdcall; external;
+function RotAverageNclip3(v0, v1, v2: PSVECTOR; sxy0, sxy1, sxy2: plongint; p, otz, flag: plongint): longint; stdcall; external;
+function RotAverageNclip4(v0, v1, v2, v3: PSVECTOR; sxy0, sxy1, sxy2, sxy3: plongint; p, otz, flag: plongint): longint; stdcall; external;
+function RotColorDpq(v0, v1: PSVECTOR; v2: PCVECTOR; sxy: plongint; v3: PCVECTOR; flag: plongint): longint; stdcall; external;
+function RotColorDpq3(v0, v1, v2, v3, v4, v5: PSVECTOR; v6: PCVECTOR; sxy0, sxy1, sxy2: plongint; v7, v8, v9: PCVECTOR; flag: plongint): longint; stdcall; external;
+function RotAverageNclipColorDpq3(v0, v1, v2, v3, v4, v5: PSVECTOR; v6: PCVECTOR; sxy0, sxy1, sxy2: plongint; v7, v8, v9: PCVECTOR; otz, flag: plongint): longint; stdcall; external;
+function RotAverageNclipColorCol3(v0, v1, v2, v3, v4, v5: PSVECTOR; v6: PCVECTOR; sxy0, sxy1, sxy2: plongint; v7, v8, v9: PCVECTOR; otz, flag: plongint): longint; stdcall; external;
+function RotColorMatDpq(v0, v1: PSVECTOR; v2: PCVECTOR; sxy: plongint; v3: PCVECTOR; matc, flag: longint): longint; stdcall; external;
+procedure ColorMatDpq(v0: PSVECTOR; v1: PCVECTOR; p: longint; v2: PCVECTOR; matc: longint); stdcall; external;
+procedure ColorMatCol(v0: PSVECTOR; v1, v2: PCVECTOR; matc: longint); stdcall; external;
+procedure LoadAverage12(v0, v1: PVECTOR; p0, p1: longint; v2: PVECTOR); stdcall; external;
+procedure LoadAverageShort12(v0, v1: PSVECTOR; p0, p1: longint; v2: PSVECTOR); stdcall; external;
+procedure LoadAverage0(v0, v1: PVECTOR; p0, p1: longint; v2: PVECTOR); stdcall; external;
+procedure LoadAverageShort0(v0, v1: PSVECTOR; p0, p1: longint; v2: PSVECTOR); stdcall; external;
+procedure LoadAverageByte(v0, v1: pbyte; p0, p1: longint; v2: pbyte); stdcall; external;
+procedure LoadAverageCol(v0, v1: pbyte; p0, p1: longint; v2: pbyte); stdcall; external;
+function VectorNormal(v0, v1: PVECTOR): longint; stdcall; external;
+function VectorNormalS(v0: PVECTOR; v1: PSVECTOR): longint; stdcall; external;
+function VectorNormalSS(v0, v1: PSVECTOR): longint; stdcall; external;
+function SquareRoot0(a: longint): longint; stdcall; external;
+function SquareRoot12(a: longint): longint; stdcall; external;
+procedure InvSquareRoot(a: longint; b, c: plongint); stdcall; external;
+procedure gteMIMefunc(otp, dfp: PSVECTOR; n, p: plongint); stdcall; external;
+procedure SetFogFar(a, h: longint); stdcall; external;
+procedure SetFogNear(a, h: longint); stdcall; external;
+procedure SetFogNearFar(a, b, h: plongint); stdcall; external;
+procedure SubPol4(p: PPOL4; sp: PSPOL; ndiv: longint); stdcall; external;
+procedure SubPol3(p: PPOL3; sp: PSPOL; ndiv: longint); stdcall; external;
+
+function rcos(a: longint): longint; stdcall; external;
+function rsin(a: longint): longint; stdcall; external;
+function ccos(a: longint): longint; stdcall; external;
+function csin(a: longint): longint; stdcall; external;
+function cln(a: longint): longint; stdcall; external;
+function csqrt(a: longint): longint; stdcall; external;
+function catan(a: longint): longint; stdcall; external;
+
+function ratan2(y, x: longint): longint; stdcall; external;
+
+
+procedure RotPMD_F3(pa: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_G3(pa: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_FT3(pa: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_GT3(pa: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_F4(pa: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_G4(pa: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_FT4(pa: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_GT4(pa: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+
+procedure RotPMD_SV_F3(pa, va: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_SV_G3(pa, va: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_SV_FT3(pa, va: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_SV_GT3(pa, va: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_SV_F4(pa, va: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_SV_G4(pa, va: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_SV_FT4(pa, va: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+procedure RotPMD_SV_GT4(pa, va: plongint; ot: pdword; otlen, id, backc: longint); stdcall; external;
+
+
+procedure InitClip(evbfad: PEVECTOR; hw, vw, h, _near, _far: longint); stdcall; external;
+function Clip3F(v0, v1, v2: PSVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip3FP(v0, v1, v2: PSVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip4F(v0, v1, v2, v3: PSVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip4FP(v0, v1, v2, v3: PSVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip3FT(v0, v1, v2: PSVECTOR; uv0, uv1, uv2: psmallint; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip3FTP(v0, v1, v2: PSVECTOR; uv0, uv1, uv2: psmallint; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip4FT(v0, v1, v2, v3: PSVECTOR; uv0, uv1, uv2, uv3: psmallint; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip4FTP(v0, v1, v2, v3: PSVECTOR; uv0, uv1, uv2, uv3: psmallint; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip3G(v0, v1, v2: PSVECTOR; rgb0, rgb1, rgb2: PCVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip3GP(v0, v1, v2: PSVECTOR; rgb0, rgb1, rgb2: PCVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip4G(v0, v1, v2, v3: PSVECTOR; rgb0, rgb1, rgb2, rgb3: PCVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip4GP(v0, v1, v2, v3: PSVECTOR; rgb0, rgb1, rgb2, rgb3: PCVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip3GT(v0, v1, v2: PSVECTOR; uv0, uv1, uv2: psmallint; rgb0, rgb1, rgb2: PCVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip3GTP(v0, v1, v2: PSVECTOR; uv0, uv1, uv2: psmallint; rgb0, rgb1, rgb2: PCVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip4GT(v0, v1, v2, v3: PSVECTOR; uv0, uv1, uv2, uv3: psmallint; rgb0, rgb1, rgb2, rgb3: PCVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+function Clip4GTP(v0, v1, v2, v3: PSVECTOR; uv0, uv1, uv2, uv3: psmallint; rgb0, rgb1, rgb2, rgb3: PCVECTOR; evmx: PPEVECTOR): longint; stdcall; external;
+
+procedure RotTransPers_nom(v0: PSVECTOR); stdcall; external;
+procedure RotTransPers3_nom(v0, v1, v2: PSVECTOR); stdcall; external;
+procedure RotTransPers4_nom(v0, v1, v2, v3: PSVECTOR); stdcall; external;
+procedure RotTrans_nom(v0: PSVECTOR); stdcall; external;
+procedure RotAverage3_nom(v0, v1, v2: PSVECTOR); stdcall; external;
+procedure RotNclip3_nom(v0, v1, v2: PSVECTOR); stdcall; external;
+procedure RotAverageNclip3_nom(v0, v1, v2: PSVECTOR); stdcall; external;
+procedure RotAverageNclipColorDpq3_nom(v0, v1, v2, v3, v4, v5: PSVECTOR; v6: PCVECTOR); stdcall; external;
+procedure RotAverageNclipColorCol3_nom(v0, v1, v2, v3, v4, v5: PSVECTOR; v6: PCVECTOR); stdcall; external;
+procedure RotColorDpq_nom(v0, v1: PSVECTOR; v2: PCVECTOR); stdcall; external;
+function RotColorDpq3_nom(v0, v1, v2, v3, v4, v5: PSVECTOR; v6: PCVECTOR): longint; stdcall; external;
+procedure NormalColor_nom(v0: PSVECTOR); stdcall; external;
+procedure NormalColor3_nom(v0, v1, v2: PSVECTOR); stdcall; external;
+procedure NormalColorDpq_nom(v0: PSVECTOR; v1: PCVECTOR; p: longint); stdcall; external;
+procedure NormalColorDpq3_nom(v0, v1, v2: PSVECTOR; v3: PCVECTOR; p: longint); stdcall; external;
+procedure NormalColorCol_nom(v0: PSVECTOR; v1: PCVECTOR); stdcall; external;
+procedure NormalColorCol3_nom(v0, v1, v2: PSVECTOR; v3: PCVECTOR); stdcall; external;
+
+
+procedure RotSMD_F3(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;	
+procedure RotSMD_G3(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;	
+procedure RotSMD_FT3(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint);	 stdcall; external;	
+procedure RotSMD_GT3(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_F4(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_G4(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_FT4(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_GT4(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+
+procedure RotSMD_SV_F3(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint);	 stdcall; external;	
+procedure RotSMD_SV_G3(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_SV_FT3(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_SV_GT3(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_SV_F4(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_SV_G4(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_SV_FT4(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotSMD_SV_GT4(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+
+
+
+procedure RotRMD_F3(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;	
+procedure RotRMD_G3(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;	
+procedure RotRMD_FT3(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_GT3(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_F4(pa: plongint;  ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_G4(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_FT4(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_GT4(pa: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+
+procedure RotRMD_SV_F3(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_SV_G3(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_SV_FT3(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_SV_GT3(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_SV_F4(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_SV_G4(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_SV_FT4(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+procedure RotRMD_SV_GT4(pa: plongint; va: plongint; ot: pdword; otlen, id, sclip, hclip, vclip, nclipmode: longint); stdcall; external;		
+
+function p2otz(p, projection: longint): longint; stdcall; external;
+function otz2p(otz, projection: longint): longint; stdcall; external;
+
+
+
+implementation
+begin
+end.

psy-q-sdk/bindings/libsnd.pas

@@ -0,0 +1,465 @@
+//
+// 	Copyright (C) 1994 by Sony Computer Entertainment Inc.
+//				          All Rights Reserved.
+//
+//	Sony Computer Entertainment Inc. Development Department
+//
+// Run-time Library Release 4.6$
+{$MODE OBJFPC}
+unit libsnd;
+interface
+
+//include <sys/types.h>
+
+const
+	SSPLAY_INFINITY  = 0;
+	SS_NOTICK	 = $1000;
+	SS_NOTICK0	 = 0;
+	SS_TICK60	 = 1;
+	SS_TICK240	 = 2;
+	SS_TICK120	 = 3;
+	SS_TICK50	 = 4;
+	SS_TICKVSYNC	 = 5;
+	SS_TICKMODE_MAX  = 6;
+	SSPLAY_PAUSE     = 0;
+	SSPLAY_PLAY      = 1;
+	SS_SOFF          = 0;     
+	SS_SON           = 1;     
+	SS_MIX           = 0;   
+	SS_REV           = 1;   
+	SS_SERIAL_A      = 0;
+	SS_SERIAL_B      = 1;    
+	SS_MUTE_OFF      = 0;    
+	SS_MUTE_ON       = 1;    
+
+	SS_IMEDIATE 	    = 0;
+	SS_IMMEDIATE        = 0;
+	SS_WAIT_COMPLETED   = 1;
+
+	SS_REV_TYPE_OFF        = 0;
+	SS_REV_TYPE_ROOM       = 1;
+	SS_REV_TYPE_STUDIO_A   = 2;
+	SS_REV_TYPE_STUDIO_B   = 3;
+	SS_REV_TYPE_STUDIO_C   = 4;
+	SS_REV_TYPE_HALL       = 5;
+	SS_REV_TYPE_SPACE      = 6;
+	SS_REV_TYPE_ECHO       = 7;
+	SS_REV_TYPE_DELAY      = 8;
+	SS_REV_TYPE_PIPE       = 9;
+	SSSKIP_TICK    	       = 0;
+	SSSKIP_NOTE4   	       = 1; 
+	SSSKIP_NOTE8   	       = 2; 
+	SSSKIP_BAR     	       = 3;
+
+	SS_SEQ_TABSIZ          = 176;
+
+	SND_VOLL  	       = 1;
+	SND_VOLR  	       = 2;
+	SND_ADSR1 	       = 4;
+	SND_ADSR2 	       = 8;
+	SND_ADDR  	       = 16;
+	SND_PITCH 	       = 32;
+
+	NULL 		       = 0;
+
+
+// Vag & Vab Structure 
+type
+	VabHdr = packed record			// VAB Bank Headdings
+		form : longint;          	// always 'VABp'
+		ver : longint;           	// VAB file version number
+		id : longint;            	// VAB id
+		fsize : dword;         		// VAB file size
+		reserved0 : word;     		// system reserved
+		ps : word;            		// # of the programs in this bank
+		ts : word;            		// # of the tones in this bank
+		vs : word;            		// # of the vags in this bank
+		mvol : byte;          		// master volume for this bank
+		pan : byte;           		// master panning for this bank
+		attr1 : byte;         		// bank attributes1
+		attr2 : byte;         		// bank attributes2
+		reserved1 : dword;     		// system reserved
+	end;					// 32 byte
+	PVabHdr = ^VabHdr;
+
+	ProgAtr = packed record        		// Program Headdings
+		tones : byte;          		// # of tones
+		mvol : byte;           		// program volume
+		prior : byte;          		// program priority
+		mode : byte;           		// program mode
+		mpan : byte;           		// program pan
+		reserved0 : byte;      		// system reserved
+		attr : smallint;           	// program attribute
+		reserved1 : dword;      	// system reserved
+		reserved2 : dword;      	// system reserved
+	end;					// 16 byte
+	PProgAtr = ^ProgAtr;
+
+	VagAtr = packed record          	// VAG Tone Headdings
+		prior : byte;         		// tone priority
+		mode : byte;          		// play mode
+		vol : byte;           		// tone volume
+		pan : byte;           		// tone panning
+		center : byte;        		// center note
+		shift : byte;         		// center note fine tune
+		min : byte;           		// minimam note limit
+		max : byte;           		// maximam note limit
+		vibW : byte;          		// vibrate depth
+		vibT : byte;          		// vibrate duration
+		porW : byte;          		// portamento depth
+		porT : byte;          		// portamento duration
+		pbmin : byte;         		// under pitch bend max
+		pbmax : byte;         		// upper pitch bend max
+		reserved1 : byte;     		// system reserved
+		reserved2 : byte;     		// system reserved
+		adsr1 : word;         		// adsr1
+		adsr2 : word;         		// adsr2
+		prog : smallint;          	// parent program
+		vag : smallint;           	// vag reference
+		reserved : array [0..3] of smallint;   // system reserved
+	end; 					// 32 byte
+	PVagAtr = ^VagAtr;
+
+// Volume Structure
+	SndVolume = packed record
+        	left : word;
+        	right : word;
+        end;
+        PSndVolume = ^SndVolume;
+
+	SndVolume2 = packed record
+		left : smallint;
+		right : smallint;
+	end;
+
+	SndRegisterAttr = packed record
+		volume : SndVolume2;
+		pitch : smallint;
+		mask : smallint;
+		addr : smallint;
+		adsr1 : smallint;
+		adsr2 : smallint;
+	end;
+	PSndRegisterAttr = ^SndRegisterAttr;
+
+	SndVoiceStats = packed record
+		vagId : smallint;
+		vabId : smallint;
+		pitch : word;
+		note : smallint;
+		tone : smallint;
+		prog_num : smallint;
+		prog_actual : smallint;
+		vol : smallint;
+		pan : smallint;
+	end;
+	PSndVoiceStats = ^SndVoiceStats;
+
+// CallBack
+ SsMarkCallbackProc = procedure(ac_no, tr_no: smallint; data: smallint);
+
+
+function SsVabOpenHead(addr: pointer; vab_id: smallint): smallint; stdcall; external;
+function SsVabOpenHeadSticky(addr: pointer; vab_id: smallint; sbaddr: dword): smallint; stdcall; external;
+function SsVabTransBody(addr: pointer; vab_id: smallint): smallint; stdcall; external;
+function SsVabTransBodyPartly(addr: pointer; bufsize: dword; vab_id: smallint): smallint; stdcall; external;
+function SsVabTransfer(vh_add, vb_addr: pointer; vab_id: smallint; i_flag: smallint): smallint; stdcall; external;
+function SsVabTransCompleted(immediateFlag: smallint): smallint; stdcall; external;
+procedure SsVabClose(vab_id: smallint); stdcall; external;
+
+procedure SsInit; stdcall; external;
+procedure SsInitHot; stdcall; external;
+procedure SsSetTableSize(table: pointer; s_max, t_max: smallint); stdcall; external;
+procedure SsSetTickMode(tick_mode: longint); stdcall; external;
+function SsSetTickCallback(cb: pointer): longint; stdcall; external;
+procedure SsStart; stdcall; external;
+procedure SsStart2; stdcall; external;
+procedure SsEnd; stdcall; external;
+procedure SsQuit; stdcall; external;
+
+procedure SsSeqCalledTbyT; stdcall; external;
+
+function SsSeqOpen(addr: pointer; vab_id: smallint): smallint; stdcall; external;
+procedure SsSeqPlay(seq_access_num: smallint; play_mode: byte; l_count: smallint); stdcall; external;
+procedure SsSeqPlayPtoP(access_num: smallint; seq_num: smallint; start_point, end_point: pointer; play_mode: byte; l_count: smallint); stdcall; external;
+procedure SsSeqPause(seq_access_num: smallint); stdcall; external;
+procedure SsSeqReplay(seq_access_num: smallint); stdcall; external;
+function SsSeqSkip(access_num, seq_num: smallint; _unit: byte; count: smallint): longint; stdcall; external;
+procedure SsSeqStop(seq_access_num: smallint); stdcall; external;
+procedure SsSeqSetVol(seq_access_num: smallint; voll, volr: smallint); stdcall; external;
+procedure SsSeqSetNext(seq_access_num1, seq_access_num2: smallint); stdcall; external;
+procedure SsSeqSetCrescendo(seq_access_num: smallint; vol: smallint; v_time: longint); stdcall; external; 
+procedure SsSeqSetDecrescendo(seq_access_num: smallint; vol: smallint; v_time: longint); stdcall; external;
+procedure SsSeqSetAccelerando(seq_access_num: smallint; tempo: longint; v_time: longint); stdcall; external;
+procedure SsSeqSetRitardando(seq_access_num: smallint; tempo: longint; v_time: longint); stdcall; external;
+procedure SsSeqClose(seq_access_num: smallint); stdcall; external;
+
+function SsSepOpen(addr: pointer; vab_id: smallint; seq_num: smallint): smallint; stdcall; external;
+procedure SsSepPlay(sep_access_num: smallint; seq_num: smallint; play_mode: byte; l_count: smallint); stdcall; external;
+procedure SsSepPause(sep_access_num, seq_num: smallint); stdcall; external;
+procedure SsSepReplay(sep_access_num, seq_num: smallint); stdcall; external;
+procedure SsSepStop(sep_access_num, seq_num: smallint); stdcall; external;
+procedure SsSepSetVol(sep_access_num, seq_num: smallint; voll, volr: smallint); stdcall; external;
+procedure SsSepSetCrescendo(sep_access_num, seq_num: smallint; vol: smallint; v_time: longint); stdcall; external;
+procedure SsSepSetDecrescendo(sep_access_num, seq_num: smallint; vol: smallint; v_time: longint); stdcall; external;
+procedure SsSepSetAccelerando(sep_access_num, seq_num: smallint; tempo: longint; v_time: longint); stdcall; external;
+procedure SsSepSetRitardando(sep_access_num, seq_num: smallint; tempo: longint; v_time: longint); stdcall; external;
+procedure SsSepClose(sep_access_num: smallint); stdcall; external;
+
+function SsVoKeyOn(vab_pro, pitch: longint; volL,volR: byte): longint; stdcall; external;
+function SsVoKeyOff(vab_pro, pitch: longint): longint; stdcall; external;
+
+procedure SsSetMVol(voll, volr: smallint); stdcall; external;
+procedure SsGetMVol(m_vol: PSndVolume); stdcall; external;
+procedure SsSetRVol(voll, volr: smallint); stdcall; external;
+procedure SsGetRVol(r_vol: PSndVolume); stdcall; external;
+procedure SsSetMute(mode: byte); stdcall; external;
+function SsGetMute: byte; stdcall; external;
+procedure SsSetSerialAttr(s_num, attr, mode: byte); stdcall; external;
+function SsGetSerialAttr(s_num, attr: byte): byte; stdcall; external;
+procedure SsSetSerialVol(s_num:  byte; voll, volr: smallint); stdcall; external;
+procedure SsGetSerialVol(s_num: byte; s_vol: PSndVolume); stdcall; external;
+procedure SsSetNck(n_clock: smallint); stdcall; external;
+function SsGetNck: smallint; stdcall; external;
+procedure SsSetNoiseOn(voll, volr: smallint); stdcall; external;  
+procedure SsSetNoiseOff; stdcall; external;
+procedure SsSetMono; stdcall; external;
+procedure SsSetStereo; stdcall; external;      
+procedure SsSetTempo(access_num, seq_num: smallint; tempo: smallint); stdcall; external;
+procedure SsSetLoop(access_num, seq_num: smallint; I_count: smallint); stdcall; external;
+function SsIsEos(access_num, seq_num: smallint): smallint; stdcall; external;
+procedure SsPlayBack(access_num, seq_num: smallint; I_count: smallint); stdcall; external;
+procedure SsSetMarkCallback(access_num, seq_num: smallint; proc: SsMarkCallbackProc); stdcall; external;
+function SsSetReservedVoice(voices: byte): byte; stdcall; external;
+
+function SsUtKeyOn(vabId, prog, tone, note, fine, voll, volr: smallint): smallint; stdcall; external;
+function SsUtKeyOff(voice, vabId, prog, tone, note: smallint): smallint; stdcall; external;
+function SsUtKeyOnV(voice, vabId, prog, tone, fine, voll, volr: smallint): smallint; stdcall; external;
+function SsUtKeyOffV(voice: smallint): smallint; stdcall; external;
+function SsUtPitchBend(voice, vabId, prog, note, pbend: smallint): smallint; stdcall; external;
+function SsUtChangePitch(voice, vabId, prog, old_note, old_fine, new_note, new_fine: smallint): smallint; stdcall; external;
+function SsUtChangeADSR(vc, vabId, prog, old_note: smallint;  adsr1, adsr2: word): smallint; stdcall; external;
+function SsUtSetVabHdr(vabId, vabhdrptr: PVabHdr): smallint; stdcall; external;
+function SsUtGetVabHdr(vabId, vabhdrptr: PVabHdr): smallint; stdcall; external;
+function SsUtSetProgAtr(vabId, progNum: smallint; progatrptr: PProgAtr): smallint; stdcall; external;
+function SsUtGetProgAtr(vabId, progNum: smallint; progatrptr: PProgAtr): smallint; stdcall; external;
+function SsUtSetVagAtr(vabId, progNum, toneNum: smallint; vagatrptr: PVagAtr): smallint; stdcall; external;
+function SsUtGetVagAtr(vabId, progNum, toneNum: smallint; vagatrptr: PVagAtr): smallint; stdcall; external;
+function SsUtSetDetVVol(vc: smallint; detvoll, detvolr: smallint): smallint; stdcall; external;
+function SsUtGetDetVVol(vc: smallint; detvoll, detvolr: psmallint): smallint; stdcall; external;
+function SsUtSetVVol(vc: smallint; detvoll, detvolr: smallint): smallint; stdcall; external;
+function SsUtGetVVol(vc: smallint; detvoll, detvolr: psmallint): smallint; stdcall; external;
+function SsUtAutoVol(vc: smallint; start_vol, end_vol, delta_time: smallint): smallint; stdcall; external;
+function SsUtAutoPan(vc: smallint; start_pan, end_pan, delta_time: smallint): smallint; stdcall; external;
+procedure SsUtReverbOn; stdcall; external;
+procedure SsUtReverbOff; stdcall; external;
+function SsUtSetReverbType(_type: smallint): smallint; stdcall; external;
+function SsUtGetReverbType: smallint; stdcall; external;
+procedure SsUtSetReverbDepth(ldepth, rdepth: smallint); stdcall; external;
+procedure SsUtSetReverbFeedback(feedback: smallint); stdcall; external;
+procedure SsUtSetReverbDelay(delay: smallint); stdcall; external;
+procedure SsUtAllKeyOff(mode: smallint); stdcall; external;
+procedure SsSetAutoKeyOffMode(mode: smallint); stdcall; external;
+procedure SsUtFlush; stdcall; external;
+function SsVabFakeHead(addr: pointer; vabid: smallint; sbaddr: dword): smallint; stdcall; external;
+function SsVabFakeBody(vabid: smallint): smallint; stdcall; external;
+function SsUtGetVBaddrInSB(vabid: smallint): dword; stdcall; external;
+function SsUtGetVagAddr(vabId, vagId: smallint): longint; stdcall; external;
+function SsUtGetVagAddrFromTone(vabId, progId, toneId: smallint): dword; stdcall; external;
+procedure SsSetNext(ac_no1, tr_no1, ac_no2, tr_no2: smallint); stdcall; external;
+procedure SsSeqGetVol(access_num, seq_num: smallint; voll, volr: psmallint); stdcall; external;
+procedure SsChannelMute(acn, trn: smallint; channels: longint); stdcall; external;
+function SsSeqOpenJ(addr: pointer; vab_id: smallint): smallint; stdcall; external;
+function SsSepOpenJ(addr: pointer; vab_id, seq_num: smallint): smallint; stdcall; external;
+function SsGetCurrentPoint(acn, trn: smallint): pointer; stdcall; external;
+function SsSetCurrentPoint(acn, trn: smallint; point: pointer): longint; stdcall; external;
+function SsGetChannelMute(sep_num, seq_num: smallint): longint; stdcall; external;
+procedure SsSetVoiceMask(s_voice: dword); stdcall; external;
+function SsGetVoiceMask: dword; stdcall; external;
+procedure SsQueueRegisters(voice: longint; SRA: PSndRegisterAttr); stdcall; external;
+procedure SsQueueKeyOn(voices: longint); stdcall; external;
+procedure SsQueueReverb(voices, reverb: longint); stdcall; external;
+function SsGetActualProgFromProg(vabId, ProgNum: smallint): smallint; stdcall; external;
+procedure SsSetVoiceSettings(voice: longint; Snd_v_attr: PSndVoiceStats); stdcall; external;
+function SsPitchFromNote(note, fine: smallint; center, shift: byte): word; stdcall; external;
+function SsVoiceCheck(voice, vabId: longint; note: smallint): smallint; stdcall; external;
+function SsBlockVoiceAllocation: byte; stdcall; external;
+function SsUnBlockVoiceAllocation: byte; stdcall; external;
+function SsAllocateVoices(voices, priority: byte): longint; stdcall; external;
+
+
+// for function table
+const
+	CC_NUMBER     	= 0;
+	CC_BANKCHANGE 	= 1;
+	CC_DATAENTRY  	= 2;
+	CC_MAINVOL    	= 3;
+	CC_PANPOT     	= 4;
+	CC_EXPRESSION 	= 5;
+	CC_DAMPER     	= 6;
+	CC_NRPN1      	= 7;
+	CC_NRPN2      	= 8;
+	CC_RPN1       	= 9;
+	CC_RPN2       	= 10;
+	CC_EXTERNAL   	= 11;
+	CC_RESETALL   	= 12;
+
+	DE_PRIORITY	= 0;	 
+	DE_MODE  	= 1;
+	DE_LIMITL	= 2;
+	DE_LIMITH	= 3;
+	DE_ADSR_AR_L	= 4; 
+	DE_ADSR_AR_E	= 5;
+	DE_ADSR_DR  	= 6;
+	DE_ADSR_SL  	= 7; 
+	DE_ADSR_SR_L  	= 8;
+	DE_ADSR_SR_E 	= 9;
+	DE_ADSR_RR_L	= 10; 
+	DE_ADSR_RR_E	= 11;
+	DE_ADSR_SR  	= 12;
+	DE_VIB_TIME 	= 13; 
+	DE_PORTA_DEPTH	= 14;
+	DE_REV_TYPE  	= 15;
+	DE_REV_DEPTH 	= 16;
+	DE_ECHO_FB  	= 17;
+	DE_ECHO_DELAY	= 18;
+	DE_DELAY  	= 19;
+{
+type
+	_SsFCALL = packed record
+		void (*noteon) ();
+		void (*programchange) ();
+		void (*pitchbend) ();
+		void (*metaevent) ();
+		void (*control[13]) ();
+		void (*ccentry[20]) ();
+	end;
+
+procedure _SsNoteOn (short, short, unsigned char, unsigned char);
+procedure _SsSetProgramChange(short, short, unsigned char); 
+procedure _SsGetMetaEvent(short, short, unsigned char); 
+procedure _SsSetPitchBend(short, short);
+procedure _SsSetControlChange(short, short, unsigned char); 
+procedure _SsContBankChange(short, short); 
+procedure _SsContDataEntry(short, short, unsigned char);
+procedure _SsContMainVol(short, short, unsigned char);  
+procedure _SsContPanpot(short, short, unsigned char);
+procedure _SsContExpression(short, short, unsigned char); 
+procedure _SsContDamper(short, short, unsigned char); 
+procedure _SsContExternal(short, short, unsigned char); 
+procedure _SsContNrpn1(short, short, unsigned char); 
+procedure _SsContNrpn2(short, short, unsigned char); 
+procedure _SsContRpn1(short, short, unsigned char); 
+procedure _SsContRpn2(short, short, unsigned char); 
+procedure _SsContResetAll(short, short);
+
+procedure _SsSetNrpnVabAttr0(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr1(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr2(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr3(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr4(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr5(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr6(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr7(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr8(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr9(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr10(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr11(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr12(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr13(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr14(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr15(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr16(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr17(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr18(short, short, short, VagAtr, short, unsigned char);
+procedure _SsSetNrpnVabAttr19(short, short, short, VagAtr, short, unsigned char);
+
+procedure dmy_nothing1(short, short, unsigned char, unsigned char);
+procedure dmy_SsNoteOn (short, short, unsigned char, unsigned char);
+procedure dmy_SsSetProgramChange(short, short, unsigned char); 
+procedure dmy_SsGetMetaEvent(short, short, unsigned char); 
+procedure dmy_SsSetPitchBend(short, short);
+procedure dmy_SsSetControlChange(short, short, unsigned char); 
+procedure dmy_SsContBankChange(short, short); 
+procedure dmy_SsContDataEntry(short, short, unsigned char);
+procedure dmy_SsContMainVol(short, short, unsigned char);  
+procedure dmy_SsContPanpot(short, short, unsigned char);
+procedure dmy_SsContExpression(short, short, unsigned char); 
+procedure dmy_SsContDamper(short, short, unsigned char); 
+procedure dmy_SsContExternal(short, short, unsigned char); 
+procedure dmy_SsContNrpn1(short, short, unsigned char); 
+procedure dmy_SsContNrpn2(short, short, unsigned char); 
+procedure dmy_SsContRpn1(short, short, unsigned char); 
+procedure dmy_SsContRpn2(short, short, unsigned char); 
+procedure dmy_SsContResetAll(short, short);
+procedure dmy_SsSetNrpnVabAttr0(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr1(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr2(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr3(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr4(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr5(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr6(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr7(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr8(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr9(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr10(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr11(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr12(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr13(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr14(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr15(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr16(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr17(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr18(short, short, short, VagAtr, short, unsigned char);
+procedure dmy_SsSetNrpnVabAttr19(short, short, short, VagAtr, short, unsigned char);
+
+_SsFCALL SsFCALL;
+
+
+
+procedure jt_SsInit;
+begin
+//	SsFCALL.noteon                   = (void (*)())_SsNoteOn;
+//	SsFCALL.programchange            = (void (*)())_SsSetProgramChange;
+//	SsFCALL.metaevent                = (void (*)())_SsGetMetaEvent;
+//	SsFCALL.pitchbend                = (void (*)())_SsSetPitchBend; 
+//        SsFCALL.control [CC_NUMBER]      = (void (*)())_SsSetControlChange;
+//	SsFCALL.control [CC_BANKCHANGE]  = (void (*)())_SsContBankChange;
+//	SsFCALL.control [CC_MAINVOL]     = (void (*)())_SsContMainVol;
+//	SsFCALL.control [CC_PANPOT]      = (void (*)())_SsContPanpot;
+//	SsFCALL.control [CC_EXPRESSION]  = (void (*)())_SsContExpression;
+//	SsFCALL.control [CC_DAMPER]      = (void (*)())_SsContDamper;
+//	SsFCALL.control [CC_NRPN1]       = (void (*)())_SsContNrpn1;
+//	SsFCALL.control [CC_NRPN2]       = (void (*)())_SsContNrpn2;
+//	SsFCALL.control [CC_RPN1]        = (void (*)())_SsContRpn1;
+//	SsFCALL.control [CC_RPN2]        = (void (*)())_SsContRpn2;
+//	SsFCALL.control [CC_EXTERNAL]    = (void (*)())_SsContExternal;
+//	SsFCALL.control [CC_RESETALL]    = (void (*)())_SsContResetAll;
+//	SsFCALL.control [CC_DATAENTRY]   = (void (*)())_SsContDataEntry;
+//	SsFCALL.ccentry [DE_PRIORITY]	 = (void (*)())_SsSetNrpnVabAttr0;   
+//	SsFCALL.ccentry [DE_MODE]        = (void (*)())_SsSetNrpnVabAttr1; 
+//	SsFCALL.ccentry [DE_LIMITL]      = (void (*)())_SsSetNrpnVabAttr2; 
+//	SsFCALL.ccentry [DE_LIMITH]      = (void (*)())_SsSetNrpnVabAttr3; 
+//	SsFCALL.ccentry [DE_ADSR_AR_L]   = (void (*)())_SsSetNrpnVabAttr4; 
+//	SsFCALL.ccentry [DE_ADSR_AR_E]   = (void (*)())_SsSetNrpnVabAttr5; 
+//	SsFCALL.ccentry [DE_ADSR_DR]     = (void (*)())_SsSetNrpnVabAttr6; 
+//	SsFCALL.ccentry [DE_ADSR_SL]     = (void (*)())_SsSetNrpnVabAttr7; 
+//	SsFCALL.ccentry [DE_ADSR_SR_L]   = (void (*)())_SsSetNrpnVabAttr8; 
+//	SsFCALL.ccentry [DE_ADSR_SR_E]   = (void (*)())_SsSetNrpnVabAttr9; 
+//	SsFCALL.ccentry [DE_ADSR_RR_L]   = (void (*)())_SsSetNrpnVabAttr10; 
+//	SsFCALL.ccentry [DE_ADSR_RR_E]   = (void (*)())_SsSetNrpnVabAttr11; 
+//	SsFCALL.ccentry [DE_ADSR_SR]     = (void (*)())_SsSetNrpnVabAttr12; 
+//	SsFCALL.ccentry [DE_VIB_TIME]    = (void (*)())_SsSetNrpnVabAttr13; 
+//	SsFCALL.ccentry [DE_PORTA_DEPTH] = (void (*)())_SsSetNrpnVabAttr14; 
+//	SsFCALL.ccentry [DE_REV_TYPE]    = (void (*)())_SsSetNrpnVabAttr15; 
+//	SsFCALL.ccentry [DE_REV_DEPTH]   = (void (*)())_SsSetNrpnVabAttr16; 
+//	SsFCALL.ccentry [DE_ECHO_FB]     = (void (*)())_SsSetNrpnVabAttr17; 
+//	SsFCALL.ccentry [DE_ECHO_DELAY]  = (void (*)())_SsSetNrpnVabAttr18; 
+//	SsFCALL.ccentry [DE_DELAY]       = (void (*)())_SsSetNrpnVabAttr19; 
+end;
+}
+
+
+implementation
+begin
+end.

psy-q-sdk/bindings/libspu.pas

@@ -0,0 +1,529 @@
+// Copyright (c) 1993, 1994, 1995, 1996 Sony Computer Entertainment Inc.
+// All Rights Reserved.
+//
+// This file is part of ``PlayStation(R)'' Programmer Tool /
+// Runtime Library.
+//
+// R & D Division, Sony Computer Entertainment Inc.
+//
+// $Id: libspu.h,v 1.80 1997/06/24 11:14:04 kaol Exp $
+//
+// $PSLibId: Run-time Library Release 4.6$
+{$MODE OBJFPC}
+unit libspu;
+interface
+
+const
+//  CONSTANT 
+    SPU_SUCCESS         = 0;
+    SPU_INVALID_ARGS    = -3;
+    SPU_DIAG	        = -2;
+    SPU_CHECK	        = -1;
+    SPU_OFF		        = 0;
+    SPU_ON		        = 1;
+    SPU_CLEAR	        = 2;
+    SPU_RESET	        = 3;
+    SPU_DONT_CARE	    = 4;
+    SPU_ALL		        = 0;
+    SPU_CDONLY	        = 5;
+    SPU_VOICEONLY	    = 6;
+    SPU_CONT	        = 7;
+    SPU_BIT		        = 8;
+    SPU_NULL	        = 0;
+
+// Macros below will be obsoleted.
+    SpuDiag		        = SPU_DIAG;
+    SpuCheck	        = SPU_CHECK;
+    SpuOff		        = SPU_OFF;
+    SpuOn		        = SPU_ON;
+    SpuClear	        = SPU_CLEAR;
+    SpuReset	        = SPU_RESET;
+    SpuDontCare	        = SPU_DONT_CARE;
+    SpuALL		        = SPU_ALL;
+    SpuCDOnly	        = SPU_CDONLY;
+    SpuVoiceOnly	    = SPU_VOICEONLY;
+    SpuCont		        = SPU_CONT;
+    SpuNull		        = SPU_NULL;
+
+    SPU_OFF_ENV_ON	    = 2;
+    SPU_ON_ENV_OFF	    = 3;
+
+// Macros below will be obsoleted.
+    SpuOffEnvOn	        = SPU_OFF_ENV_ON;
+    SpuOnEnvOff	        = SPU_ON_ENV_OFF;
+
+    SPU_ERROR	        = -1;
+// Macros below will be obsoleted.
+    SpuError	        = SPU_ERROR;
+
+    SPU_TRANSFER_BY_DMA = 0;
+    SPU_TRANSFER_BY_IO  = 1;
+// Macros below will be obsoleted.
+    SpuTransferByDMA    = SPU_TRANSFER_BY_DMA;
+    SpuTransferByIO     = SPU_TRANSFER_BY_IO;
+    SpuTransByDMA       = SpuTransferByDMA;
+    SpuTransByIO        = SpuTransferByIO;
+
+    SPU_TRANSFER_WAIT   = 1;
+    SPU_TRANSFER_PEEK   = 0;
+    SPU_TRANSFER_GLANCE = SPU_TRANSFER_PEEK;
+
+
+// Voice designate
+    SPU_00CH            = 1 shl 0;
+    SPU_01CH            = 1 shl 1;
+    SPU_02CH            = 1 shl 2;
+    SPU_03CH            = 1 shl 3;
+    SPU_04CH            = 1 shl 4;
+    SPU_05CH            = 1 shl 5;
+    SPU_06CH            = 1 shl 6;
+    SPU_07CH            = 1 shl 7;
+    SPU_08CH            = 1 shl 8;
+    SPU_09CH            = 1 shl 9;
+    SPU_10CH            = 1 shl 10;
+    SPU_11CH            = 1 shl 11;
+    SPU_12CH            = 1 shl 12;
+    SPU_13CH            = 1 shl 13;
+    SPU_14CH            = 1 shl 14;
+    SPU_15CH            = 1 shl 15;
+    SPU_16CH            = 1 shl 16;
+    SPU_17CH            = 1 shl 17;
+    SPU_18CH            = 1 shl 18;
+    SPU_19CH            = 1 shl 19;
+
+    SPU_20CH            = 1 shl 20;
+    SPU_21CH            = 1 shl 21;
+    SPU_22CH            = 1 shl 22;
+    SPU_23CH            = 1 shl 23;
+
+    SPU_0CH             = SPU_00CH;
+    SPU_1CH             = SPU_01CH;
+    SPU_2CH             = SPU_02CH;
+    SPU_3CH             = SPU_03CH;
+    SPU_4CH             = SPU_04CH;
+    SPU_5CH             = SPU_05CH;
+    SPU_6CH             = SPU_06CH;
+    SPU_7CH             = SPU_07CH;
+    SPU_8CH             = SPU_08CH;
+    SPU_9CH             = SPU_09CH;
+
+    SPU_ALLCH           = SPU_00CH or SPU_01CH or SPU_02CH or SPU_03CH or SPU_04CH or SPU_05CH or SPU_06CH or SPU_07CH or SPU_08CH or SPU_09CH or SPU_10CH or SPU_11CH or SPU_12CH or SPU_13CH or SPU_14CH or SPU_15CH or SPU_16CH or SPU_17CH or SPU_18CH or SPU_19CH or SPU_20CH or SPU_21CH or SPU_22CH or SPU_23CH;
+
+
+function SPU_KEYCH(x: longint): longint;
+function SPU_VOICECH(x: longint): longint;
+
+
+// for Voice setting
+const
+    SPU_VOICE_VOLL		 = 1 shl  0;                //  volume (left)
+    SPU_VOICE_VOLR		 = 1 shl  1;                // volume (right)
+    SPU_VOICE_VOLMODEL	 = 1 shl  2;                // volume mode (left)
+    SPU_VOICE_VOLMODER	 = 1 shl  3;                // volume mode (right) 
+    SPU_VOICE_PITCH		 = 1 shl  4;                // tone (pitch setting)
+    SPU_VOICE_NOTE		 = 1 shl  5;                // tone (note setting) 
+    SPU_VOICE_SAMPLE_NOTE= 1 shl  6;                // waveform data sample note
+    SPU_VOICE_WDSA		 = 1 shl  7;                // waveform data start address
+    SPU_VOICE_ADSR_AMODE = 1 shl  8;                // ADSR Attack rate mode 
+    SPU_VOICE_ADSR_SMODE = 1 shl  9;                // ADSR Sustain rate mode
+    SPU_VOICE_ADSR_RMODE = 1 shl 10;                // ADSR Release rate mode
+    SPU_VOICE_ADSR_AR	 = 1 shl 11;                // ADSR Attack rate      
+    SPU_VOICE_ADSR_DR	 = 1 shl 12;                // ADSR Decay rate       
+    SPU_VOICE_ADSR_SR    = 1 shl 13;                // ADSR Sustain rate     
+    SPU_VOICE_ADSR_RR	 = 1 shl 14;                // ADSR Release rate     
+    SPU_VOICE_ADSR_SL	 = 1 shl 15;                // ADSR Sustain level    
+    SPU_VOICE_LSAX		 = 1 shl 16;                // start address for loop
+    SPU_VOICE_ADSR_ADSR1 = 1 shl 17;                // ADSR adsr1 for `VagAtr'
+    SPU_VOICE_ADSR_ADSR2 = 1 shl 18;                // ADSR adsr2 for `VagAtr'
+
+    SPU_VOICE_DIRECT	 = 0;
+    SPU_VOICE_LINEARIncN = 1;
+    SPU_VOICE_LINEARIncR = 2;
+    SPU_VOICE_LINEARDecN = 3;
+    SPU_VOICE_LINEARDecR = 4;
+    SPU_VOICE_EXPIncN	 = 5;
+    SPU_VOICE_EXPIncR	 = 6;
+    SPU_VOICE_EXPDec	 = 7;
+    SPU_VOICE_EXPDecN	 = SPU_VOICE_EXPDec;
+    SPU_VOICE_EXPDecR	 = SPU_VOICE_EXPDec;
+
+    SPU_DECODED_FIRSTHALF=	0;
+    SPU_DECODED_SECONDHALF=	1;
+    SPU_DECODE_FIRSTHALF =	SPU_DECODED_FIRSTHALF;
+    SPU_DECODE_SECONDHALF= 	SPU_DECODED_SECONDHALF;
+
+
+    SPU_COMMON_MVOLL	 =	1 shl  0;               // master volume (left)
+    SPU_COMMON_MVOLR	 =	1 shl  1;               // master volume (right)
+    SPU_COMMON_MVOLMODEL =	1 shl  2;               // master volume mode (left)
+    SPU_COMMON_MVOLMODER =	1 shl  3;               // master volume mode (right)
+    SPU_COMMON_RVOLL	 =	1 shl  4;               // reverb volume (left)
+    SPU_COMMON_RVOLR	 =	1 shl  5;               // reverb volume (right)
+    SPU_COMMON_CDVOLL	 = 	1 shl  6;               // CD input volume (left)
+    SPU_COMMON_CDVOLR	 =	1 shl  7;               // CD input volume (right)
+    SPU_COMMON_CDREV	 =	1 shl  8;               // CD input reverb on/off
+    SPU_COMMON_CDMIX	 =	1 shl  9;               // CD input on/off
+    SPU_COMMON_EXTVOLL	 =	1 shl 10;               // external digital input volume (left)
+    SPU_COMMON_EXTVOLR	 =	1 shl 11;               // external digital input volume (right)
+    SPU_COMMON_EXTREV	 =	1 shl 12;               // external digital input reverb on/off
+    SPU_COMMON_EXTMIX	 =	1 shl 13;               // external digital input on/off
+
+// for Reverb setting
+    SPU_REV_MODE		 = 1 shl 0;                 // mode setting
+    SPU_REV_DEPTHL		 = 1 shl 1;                 // reverb depth (left)
+    SPU_REV_DEPTHR		 = 1 shl 2;                 // reverb depth (right)
+    SPU_REV_DELAYTIME	 = 1 shl 3;                 // Delay Time  (ECHO, DELAY only)
+    SPU_REV_FEEDBACK	 = 1 shl 4;                 // Feedback    (ECHO only)
+
+    SPU_REV_MODE_CHECK	 = -1;
+    SPU_REV_MODE_OFF	 = 0;
+    SPU_REV_MODE_ROOM	 = 1;
+    SPU_REV_MODE_STUDIO_A= 2;
+    SPU_REV_MODE_STUDIO_B= 3;
+    SPU_REV_MODE_STUDIO_C= 4;
+    SPU_REV_MODE_HALL	 = 5;
+    SPU_REV_MODE_SPACE	 = 6;
+    SPU_REV_MODE_ECHO	 = 7;
+    SPU_REV_MODE_DELAY	 = 8;
+    SPU_REV_MODE_PIPE	 = 9;
+    SPU_REV_MODE_MAX	 = 10;
+
+    SPU_REV_MODE_CLEAR_WA= $100;
+
+
+//	Event flushing
+    SPU_EVENT_KEY        = 1 shl 0;
+    SPU_EVENT_PITCHLFO   = 1 shl 1;
+    SPU_EVENT_NOISE      = 1 shl 2;
+    SPU_EVENT_REVERB     = 1 shl 3;
+
+    SPU_EVENT_ALL        = 0;
+
+type
+    SpuVolume = packed record
+        left : smallint;
+        right : smallint;
+    end;
+    
+    SpuVoiceAttr = packed record
+        voice : dword;		                        // set voice:
+                                                    //  SpuSetVoiceAttr: each voice is a bit array
+                                                    //  SpuGetVoiceAttr: voice is a bit value
+        mask : dword;		                        // settings attribute bit (invalid with Get)
+        volume : SpuVolume;		                    // volume                         
+        volmode : SpuVolume;	                    // volume mode                    
+        volumex : SpuVolume;	                    // current volume (invalid with Set)
+        pitch : word;		                        // tone (pitch setting)
+        note : word;		                        // tone (note setting)
+        sample_note : word;	                        // tone (note setting)
+        envx : smallint;		                    // current envelope value (invalid with Set)
+        addr : dword;		                        // waveform data start address
+        loop_addr : dword;	                        // loop start address
+        a_mode : longint;		                    // Attack rate mode	
+        s_mode : longint;		                    // Sustain rate mode
+        r_mode : longint;		                    // Release rate mode
+        ar : word;		                            // Attack rate		
+        dr : word;		                            // Decay rate		
+        sr : word;		                            // Sustain rate		
+        rr : word;		                            // Release rate		
+        sl : word;		                            // Sustain level	
+        adsr1 : word;		                        // adsr1 for `VagAtr'
+        adsr2 : word;		                        // adsr2 for `VagAtr'
+    end;
+    PSpuVoiceAttr = ^SpuVoiceAttr;
+
+    SpuLVoiceAttr = packed record
+        voiceNum : smallint;		                // voice number
+        pad : smallint;			                    // padding
+    	attr : SpuVoiceAttr;		                // voice attribute
+    end;
+    PSpuLVoiceAttr = ^SpuLVoiceAttr;
+
+    SpuReverbAttr = packed record
+        mask : dword;	                            // settings mask
+        mode : longint;	                            // reverb mode
+        depth : SpuVolume;	                        // reverb depth
+        delay : longint;	                        // Delay Time  (ECHO, DELAY only)
+        feedback : longint;                         // Feedback    (ECHO only)
+    end;
+    PSpuReverbAttr = ^SpuReverbAttr;
+
+const
+    SPU_DECODEDDATA_SIZE = $200;
+    SPU_DECODEDATA_SIZE  = SPU_DECODEDDATA_SIZE;
+
+type
+    SpuDecodedData = packed record
+        cd_left  : array [0..SPU_DECODEDDATA_SIZE - 1] of smallint;
+        cd_right : array [0..SPU_DECODEDDATA_SIZE - 1] of smallint;
+        voice1   : array [0..SPU_DECODEDDATA_SIZE - 1] of smallint;
+        voice3   : array [0..SPU_DECODEDDATA_SIZE - 1] of smallint;
+    end;
+    SpuDecodeData = SpuDecodedData;
+    PSpuDecodedData = ^SpuDecodedData;
+    
+    SpuExtAttr = packed record
+        volume : SpuVolume;		                    // volume
+        reverb : longint;		                    // reverb on/off
+        mix : longint;		                        // mixing on/off
+    end;
+
+    SpuCommonAttr = packed record
+        mask : dword;	                            // settings mask
+        mvol : SpuVolume;	                        // master volume
+        mvolmode : SpuVolume;                       // master volume mode
+        mvolx : SpuVolume;	                        // current master volume
+        cd : SpuExtAttr;	                        // CD input attributes
+        ext : SpuExtAttr;	                        // external digital input attributes
+    end;
+    PSpuCommonAttr = ^SpuCommonAttr;
+
+    SpuIRQCallbackProc = procedure;
+    SpuTransferCallbackProc = procedure;
+
+// for SPU Malloc (used in SpuInitMalloc())
+const
+    SPU_MALLOC_RECSIZ   = 8;
+
+// User specifiable global environment
+type
+    SpuEnv = packed record
+        mask : dword;
+        queueing : dword;
+    end;
+    PSpuEnv = ^SpuEnv;
+
+const
+    SPU_ENV_EVENT_QUEUEING	= 01 shl 0;
+
+
+procedure SpuInit; stdcall; external;
+procedure SpuInitHot; stdcall; external;
+procedure SpuStart; stdcall; external;
+procedure SpuQuit; stdcall; external;
+function SpuSetMute(on_off: longint): longint; stdcall; external;
+function SpuGetMute: longint; stdcall; external;
+procedure SpuSetEnv(env: PSpuEnv); stdcall; external;
+
+function SpuSetNoiseClock(n_clock: longint): longint; stdcall; external;
+function SpuGetNoiseClock: longint; stdcall; external;
+function SpuSetNoiseVoice(on_off: longint; voice_bit: dword): dword; stdcall; external;
+function SpuGetNoiseVoice: dword; stdcall; external;
+
+function SpuSetReverb(on_off: longint): longint; stdcall; external;
+function SpuGetReverb: longint; stdcall; external;
+function SpuSetReverbModeParam(attr: PSpuReverbAttr): longint; stdcall; external;
+procedure SpuGetReverbModeParam(attr: PSpuReverbAttr); stdcall; external;
+function SpuSetReverbDepth(attr: PSpuReverbAttr): longint; stdcall; external;
+function SpuReserveReverbWorkArea(on_off: longint): longint; stdcall; external;
+function SpuIsReverbWorkAreaReserved(on_off: longint): longint; stdcall; external;
+function SpuSetReverbVoice(on_off: longint; voice_bit: dword): dword; stdcall; external;
+function SpuGetReverbVoice: dword; stdcall; external;
+function SpuClearReverbWorkArea(mode: longint): longint; stdcall; external;
+
+function SpuWrite(addr: pointer; size: dword): dword; stdcall; external;
+function SpuWrite0(size: dword): dword; stdcall; external;
+function SpuRead(addr: pointer; size: dword): dword; stdcall; external;
+function SpuSetTransferMode(mode: longint): longint; stdcall; external;
+function SpuSetTransMode(mode: longint):longint; // NO EXTERNAL
+function SpuGetTransferMode: longint; stdcall; external;
+function SpuGetTransMode: longint; // NO EXTERNAL
+function SpuSetTransferStartAddr(addr: dword): dword; stdcall; external;
+function SpuSetTransStartAddr(addr: dword): dword; // NO EXTERNAL
+function SpuGetTransferStartAddr: dword; stdcall; external;
+function SpuGetTransStartAddr: dword; // NO EXTERNAL
+function SpuWritePartly(addr: pointer; size: dword): dword; stdcall; external;
+
+function SpuIsTransferCompleted(flag: longint): longint; stdcall; external;
+function SpuSetTransferCallback(func: SpuTransferCallbackProc): SpuTransferCallbackProc; stdcall; external;
+function SpuReadDecodedData(d_data: PSpuDecodedData; flag: longint): longint; stdcall; external;
+function SpuReadDecodeData(d_data: PSpuDecodedData; flag: longint): longint; // NO EXTERNAL
+
+function SpuSetIRQ(on_off: longint): longint; stdcall; external;
+function SpuGetIRQ: longint; stdcall; external;
+function SpuSetIRQAddr(addr: dword): dword; stdcall; external;
+function SpuGetIRQAddr: dword; stdcall; external;
+function SpuSetIRQCallback(func: SpuIRQCallbackProc): SpuIRQCallbackProc; stdcall; external;
+
+procedure SpuSetVoiceAttr(arg: PSpuVoiceAttr); stdcall; external;
+procedure SpuGetVoiceAttr(arg: PSpuVoiceAttr); stdcall; external;
+procedure SpuSetKey(on_off: longint; voice_bit: dword); stdcall; external;
+procedure SpuSetKeyOnWithAttr(attr: PSpuVoiceAttr); stdcall; external;
+function SpuGetKeyStatus(voice_bit: dword): longint; stdcall; external;
+procedure SpuGetAllKeysStatus(status: pointer); stdcall; external;
+function SpuFlush(ev: dword): dword; stdcall; external;
+
+function SpuSetPitchLFOVoice(on_off: longint; voice_bit: dword): dword; stdcall; external;
+function SpuGetPitchLFOVoice: dword; stdcall; external;
+
+procedure SpuSetCommonAttr(attr: PSpuCommonAttr); stdcall; external;
+procedure SpuGetCommonAttr(attr: PSpuCommonAttr); stdcall; external;
+
+function SpuInitMalloc(num: longint; top: pointer): longint; stdcall; external;
+function SpuMalloc(size: longint): longint; stdcall; external;
+function SpuMallocWithStartAddr(addr: dword; size: longint): longint; stdcall; external;
+procedure SpuFree(addr: dword); stdcall; external;
+
+function SpuRGetAllKeysStatus(min_, max_: longint; status: pointer): longint; stdcall; external;
+function SpuRSetVoiceAttr(min_, max_: longint; arg: PSpuVoiceAttr): longint; stdcall; external;
+
+procedure SpuNSetVoiceAttr(vNum: longint; arg: PSpuVoiceAttr); stdcall; external;
+procedure SpuNGetVoiceAttr(vNum: longint; arg: PSpuVoiceAttr); stdcall; external;
+
+procedure SpuLSetVoiceAttr(num: longint; argList: PSpuLVoiceAttr); stdcall; external;
+
+procedure SpuSetVoiceVolume(vNum: longint; volL, volR: smallint); stdcall; external;
+procedure SpuSetVoiceVolumeAttr(vNum: longint; volL, volR: smallint; volModeL, volModeR: smallint); stdcall; external;
+procedure SpuSetVoicePitch(vNum: longint; pitch: word); stdcall; external;
+procedure SpuSetVoiceNote(vNum: longint; note: word); stdcall; external;
+procedure SpuSetVoiceSampleNote(vNum: longint; sampleNote: word); stdcall; external;
+procedure SpuSetVoiceStartAddr(vNum: longint; startAddr: dword); stdcall; external;
+procedure SpuSetVoiceLoopStartAddr(vNum: longint; lsa: dword); stdcall; external;
+procedure SpuSetVoiceAR(vNum: longint; AR: word); stdcall; external;
+procedure SpuSetVoiceDR(vNum: longint; DR: word); stdcall; external;
+procedure SpuSetVoiceSR(vNum: longint; SR: word); stdcall; external;
+procedure SpuSetVoiceRR(vNum: longint; RR: word); stdcall; external;
+procedure SpuSetVoiceSL(vNum: longint; SL: word); stdcall; external;
+procedure SpuSetVoiceARAttr(vNum: longint; AR: word; ARmode: longint); stdcall; external;
+procedure SpuSetVoiceSRAttr(vNum: longint; SR: word; SRmode: longint); stdcall; external;
+procedure SpuSetVoiceRRAttr(vNum: longint; RR: word; RRmode: longint); stdcall; external;
+procedure SpuSetVoiceADSR(vNum: longint; AR, DR, SR, RR, SL: word); stdcall; external;
+procedure SpuSetVoiceADSRAttr(vNum: longint; AR, DR, SR, RR, SL: word; ARmode, SRmode, RRmode: longint); stdcall; external;
+
+procedure SpuGetVoiceVolume(vNum: longint; volL, volR: psmallint); stdcall; external;
+procedure SpuGetVoiceVolumeAttr(vNum: longint; volL, volR, volModeL, volModeR: psmallint); stdcall; external;
+procedure SpuGetVoiceVolumeX(vNum: longint; volXL, volXR: psmallint); stdcall; external;
+procedure SpuGetVoicePitch(vNum: longint; pitch: pword); stdcall; external;
+procedure SpuGetVoiceNote(vNum: longint; note:pword); stdcall; external;
+procedure SpuGetVoiceSampleNote(vNum: longint; sampleNote: pword); stdcall; external;
+procedure SpuGetVoiceEnvelope(vNum: longint; envx: psmallint); stdcall; external;
+procedure SpuGetVoiceStartAddr(vNum: longint; startAddr: pword); stdcall; external;
+procedure SpuGetVoiceLoopStartAddr(vNum: longint; loopStartAddr: pword); stdcall; external;
+procedure SpuGetVoiceAR(vNum: longint; AR: pword); stdcall; external;
+procedure SpuGetVoiceDR(vNum: longint; DR: pword); stdcall; external;
+procedure SpuGetVoiceSR(vNum: longint; SR: pword); stdcall; external;
+procedure SpuGetVoiceRR(vNum: longint; RR: pword); stdcall; external;
+procedure SpuGetVoiceSL(vNum: longint; SL: pword); stdcall; external;
+procedure SpuGetVoiceARAttr(vNum: longint; AR: pword; ARmode: plongint); stdcall; external;
+procedure SpuGetVoiceSRAttr(vNum: longint; SR: pword; SRmode: plongint); stdcall; external;
+procedure SpuGetVoiceRRAttr(vNum: longint; RR: pword; RRmode: plongint); stdcall; external;
+procedure SpuGetVoiceADSR(vNum: longint; AR, DR, SR, RR, SL: pword); stdcall; external;
+procedure SpuGetVoiceADSRAttr(vNum: longint; AR, DR, SR, RR, SL: pword; ARmode, SRmode, RRmode: plongint); stdcall; external;
+procedure SpuGetVoiceEnvelopeAttr(vNum: longint; keyStat: plongint; envx: psmallint); stdcall; external;
+
+procedure SpuSetCommonMasterVolume(mvol_left, mvol_right: smallint); stdcall; external;
+procedure SpuSetCommonMasterVolumeAttr(mvol_left, mvol_right, mvolmode_left, mvolmode_right: smallint); stdcall; external;
+procedure SpuSetCommonCDMix(cd_mix: longint); stdcall; external;
+procedure SpuSetCommonCDVolume(cd_left, cd_right: smallint); stdcall; external;
+procedure SpuSetCommonCDReverb(cd_reverb: longint); stdcall; external;
+
+procedure SpuGetCommonMasterVolume(mvol_left, mvol_right: psmallint); stdcall; external;
+procedure SpuGetCommonMasterVolumeX(mvolx_left, mvolx_right: psmallint); stdcall; external;
+procedure SpuGetCommonMasterVolumeAttr(mvol_left, mvol_right, mvolmode_left, mvolmode_right: psmallint); stdcall; external;
+procedure SpuGetCommonCDMix(cd_mix: plongint); stdcall; external;
+procedure SpuGetCommonCDVolume(cd_left, cd_right: psmallint); stdcall; external;
+procedure SpuGetCommonCDReverb(cd_reverb: plongint); stdcall; external;
+
+function SpuSetReverbModeType(mode: longint): longint; stdcall; external;
+procedure SpuSetReverbModeDepth(depth_left, depth_right: smallint); stdcall; external;
+procedure SpuSetReverbModeDelayTime(del: longint); stdcall; external;
+procedure SpuSetReverbModeFeedback(feedback: longint); stdcall; external;
+procedure SpuGetReverbModeType(mode: plongint); stdcall; external;
+procedure SpuGetReverbModeDepth(depth_left, depth_right: psmallint); stdcall; external;
+procedure SpuGetReverbModeDelayTime(del: plongint); stdcall; external;
+procedure SpuGetReverbModeFeedback(feedback: plongint); stdcall; external;
+procedure SpuSetESA(revAddr: longint); stdcall; external;
+
+
+const
+    SPU_ST_NOT_AVAILABLE    = 0;
+    SPU_ST_ACCEPT           = 1;
+
+    SPU_ST_ERROR            = -1;
+    SPU_ST_INVALID_ARGUMENT = -2;
+    SPU_ST_WRONG_STATUS     = -3;
+
+    SPU_ST_STOP             = 2;
+    SPU_ST_IDLE             = 3;
+    SPU_ST_PREPARE          = 4;
+    SPU_ST_START            = 5;
+    SPU_ST_PLAY             = 6;
+    SPU_ST_TRANSFER         = 7;
+    SPU_ST_FINAL            = 8;
+
+
+// VAG's header size
+const
+    SPU_ST_VAG_HEADER_SIZE  = $30;
+
+type
+    SpuStVoiceAttr = packed record
+        status : byte;		                        // stream status
+        pad1 : byte;		                        // padding
+        pad2 : byte;			                    // padding
+        pad3 : byte;			                    // padding
+        last_size : longint;		                // the size of last transferring (last_size <= (size / 2))
+        buf_addr : dword;	                        // The start address of stream buffer
+        data_addr : dword;	                        // The start address of SPU streaming data in main memory
+    end;
+
+    SpuStEnv = packed record
+        size : longint;			                    // The size of stream buffer
+        low_priority : longint;		                // transfer priority
+        voice : array [0..23] of SpuStVoiceAttr;
+    end;
+    PSpuStEnv = ^SpuStEnv;
+
+type
+    SpuStCallbackProc = function(d: dword; l: longint): pointer;
+
+function SpuStInit(x: longint): PSpuStEnv; stdcall; external;
+function SpuStQuit: longint; stdcall; external;
+function SpuStGetStatus: longint; stdcall; external;
+function SpuStGetVoiceStatus: dword; stdcall; external;
+function SpuStTransfer(flag: longint; voice_bit: dword): longint; stdcall; external;
+function SpuStSetPreparationFinishedCallback(func: SpuStCallbackProc): SpuStCallbackProc; stdcall; external;
+function SpuStSetTransferFinishedCallback(func: SpuStCallbackProc): SpuStCallbackProc; stdcall; external;
+function SpuStSetStreamFinishedCallback(func: SpuStCallbackProc): SpuStCallbackProc; stdcall; external;
+
+
+implementation
+
+function SPU_KEYCH(x: longint): longint;
+begin
+    result:= 1 shl x;
+end;
+
+function SPU_VOICECH(x: longint): longint;
+begin
+    result:= SPU_KEYCH(x);
+end;
+
+function SpuSetTransMode(mode: longint): longint;
+begin
+    result:= SpuSetTransferMode(mode);
+end;
+
+function SpuGetTransMode: longint;
+begin
+    result:= SpuGetTransferMode;
+end;
+
+function SpuSetTransStartAddr(addr: dword): dword;
+begin
+    result:= SpuSetTransferStartAddr(addr);
+end;
+
+function SpuGetTransStartAddr: dword;
+begin
+    result:= SpuGetTransferStartAddr;
+end;
+
+
+function SpuReadDecodeData(d_data: PSpuDecodedData; flag: longint): longint;
+begin
+     result:= SpuReadDecodedData(d_data, flag);
+end;
+
+begin
+end.

psy-q-sdk/bindings/libstd.pas

@@ -0,0 +1,733 @@
+unit libstd;
+interface
+
+type
+	Pdword = ^dword;
+	Pshort = ^smallint;
+	Pbyte = ^byte;
+	Pinteger = ^integer;
+
+
+
+
+// stddef.h
+type
+	size_t = dword;
+	wchar_t = dword;
+    u_char = byte;
+	u_short = smallint;
+	u_int = longint;
+	u_long = longint;
+
+const
+	WEOF = $ffffffff;
+	NULL = 0;
+
+
+
+
+// errno.h
+const
+	EPERM 	= 1;		// Not owner
+	ENOENT 	= 2;		// No such file or directory
+	ESRCH 	= 3;		// No such process
+	EINTR 	= 4;		// Interrupted system call
+	EIO 	= 5;		// I/O error
+	ENXIO 	= 6;		// No such device or address
+	E2BIG 	= 7;		// Arg list too long
+	ENOEXEC = 8;		// Exec format error
+	EBADF 	= 9;		// Bad file number
+	ECHILD 	= 10;		// No children
+	EAGAIN 	= 11;		// No more processes
+	ENOMEM 	= 12;		// Not enough core
+	EACCES 	= 13;		// Permission denied
+	EFAULT 	= 14;		// Bad address
+	ENOTBLK = 15;		// Block device required
+	EBUSY 	= 16;		// Mount device busy
+	EEXIST 	= 17;		// File exists
+	EXDEV 	= 18;		// Cross-device link
+	ENODEV 	= 19;		// No such device
+	ENOTDIR = 20;		// Not a directory
+	EISDIR 	= 21;		// Is a directory
+	EINVAL 	= 22;		// Invalid argument
+	ENFILE	= 23;		// File table overflow
+	EMFILE 	= 24;		// Too many open files
+	ENOTTY 	= 25;		// Not a typewriter
+	ETXTBSY = 26;		// Text file busy
+	EFBIG 	= 27;		// File too large
+	ENOSPC 	= 28;		// No space left on device
+	ESPIPE 	= 29;		// Illegal seek
+	EROFS 	= 30;		// Read-only file system
+	EFORMAT = 31;		// Bad file format
+	EPIPE 	= 32;		// Broken pipe
+
+	// math software
+	EDOM 	= 33;		// Argument too large
+	ERANGE 	= 34;		// Result too large
+
+	// non-blocking and interrupt i/o
+	EWOULDBLOCK = 35;	// Operation would block
+	EINPROGRESS	= 36;	// Operation now in progress
+	EALREADY 	= 37;	// Operation already in progress
+
+var
+	errno : longint; external;
+
+
+
+
+
+// types.h
+type
+	ushort = smallint;	// sys III compat */
+	uint = dword;		// sys V compat */
+	ulong = dword;		// sys V compat */
+
+	_quad = packed record
+		 		val : array [0..1] of longint;
+		 	end;
+	quad = _quad;
+
+	daddr_t = longint;
+	caddr_t = pchar;
+	qaddr_t = ^longint;	// should be typedef quad * qaddr_t; */
+	ino_t = dword;
+	swblk_t = longint;
+
+	time_t = longint;
+	dev_t = smallint;
+	off_t = longint;
+	uid_t = u_short;
+	gid_t = u_short;
+
+const
+	NBBY = 8;		// number of bits in a byte */
+
+type
+	_physadr = 	packed record
+				 	r : array [0..0] of longint;
+				end;
+	physadr = ^_physadr;
+
+	label_t	= 	packed record
+					val : array [0..11] of longint;
+				end;
+
+
+
+const
+	DescMask 	= $ff000000;
+	DescTH 		= DescMask;
+	DescHW   	= $f0000000;
+	DescEV   	= $f1000000;
+	DescRC   	= $f2000000;
+	DescUEV   	= $f3000000;		// User event
+	DescSW   	= $f4000000;		// BIOS
+
+	HwVBLANK	= DescHW or $01;	// VBLANK
+	HwGPU		= DescHW or $02;	// GPU
+	HwCdRom		= DescHW or $03;	// CDROM Decorder
+	HwDMAC		= DescHW or $04;	// DMA controller
+	HwRTC0		= DescHW or $05;	// RTC0
+	HwRTC1		= DescHW or $06;	// RTC1
+	HwRTC2		= DescHW or $07;	// RTC2
+	HwCNTL		= DescHW or $08;	// Controller
+	HwSPU		= DescHW or $09;	// SPU
+	HwPIO		= DescHW or $0a;	// PIO
+	HwSIO		= DescHW or $0b;	// SIO
+
+	HwCPU		= DescHW or $10;	// Exception
+	HwCARD		= DescHW or $11;	// memory card
+	HwCARD_0	= DescHW or $12;	// memory card
+	HwCARD_1	= DescHW or $13;	// memory card
+	SwCARD		= DescSW or $01;	// memory card
+	SwMATH      = DescSW or $02;	// libmath
+
+	RCntCNT0    = DescRC or $00;  	// display pixel
+	RCntCNT1  	= DescRC or $01;  	// horizontal sync
+	RCntCNT2  	= DescRC or $02;  	// one-eighth of system clock
+	RCntCNT3  	= DescRC or $03;  	// vertical sync target value fixed to 1
+
+	RCntMdINTR	= $1000;
+	RCntMdNOINTR= $2000;
+	RCntMdSC	= $0001;
+	RCntMdSP	= $0000;
+	RCntMdFR	= $0000;
+	RCntMdGATE	= $0010;
+
+	EvSpCZ		= $0001;			// counter becomes zero
+	EvSpINT		= $0002;			// interrupted
+	EvSpIOE		= $0004;			// end of i/o
+	EvSpCLOSE	= $0008;			// file was closed
+	EvSpACK		= $0010;			// command acknowledged
+	EvSpCOMP	= $0020;			// command completed
+	EvSpDR		= $0040;			// data ready
+	EvSpDE		= $0080;			// data end
+	EvSpTIMOUT  = $0100;      	    // time out
+	EvSpUNKNOWN = $0200;       		// unknown command
+	EvSpIOER	= $0400;			// end of read buffer
+	EvSpIOEW	= $0800;			// end of write buffer
+	EvSpTRAP    = $1000;    	    // general interrupt
+	EvSpNEW		= $2000;			// new device
+	EvSpSYSCALL	= $4000;			// system call instruction
+	EvSpERROR	= $8000;			// error happned
+	EvSpPERROR	= $8001;			// previous write error happned
+	EvSpEDOM    = $0301;			// domain error in libmath
+	EvSpERANGE  = $0302;			// range error in libmath
+
+	EvMdINTR	= $1000;
+	EvMdNOINTR	= $2000;
+
+	EvStUNUSED  = $0000;
+	EvStWAIT    = $1000;
+	EvStACTIVE  = $2000;
+	EvStALREADY = $4000;
+
+	TcbMdRT		= $1000;			// reserved by system
+	TcbMdPRI	= $2000;			// reserved by system
+
+	TcbStUNUSED	= $1000;
+	TcbStACTIVE	= $4000;
+
+	NREGS		= 40;
+
+type
+
+	EXEC = packed record
+			 pc0 : dword; 									// Execution start address
+			 gp0 : dword; 									// gp register initial value
+			 t_addr : dword; 								// Starting address of initialized text section
+			 t_size : dword; 								// Size of text section
+			 d_addr : dword; 								// Starting address of initialized data section
+			 d_size : dword; 								// Size of initialized data section
+			 b_addr : dword; 								// Uninitialized data section start address
+			 b_size : dword; 								// Uninitialized data section size
+			 s_addr : dword; 								// Stack start address (specified by the user)
+			 s_size : dword; 								// Stack size (specified by the user)
+			 sp : dword; 									// Register shunt variable
+			 fp : dword; 									// Register shunt variable
+			 gp : dword; 									// Register shunt variable
+			 ret : dword; 									// Register shunt variable
+			 base : dword; 									// Register shunt variable
+	end;
+	PEXEC = ^EXEC;
+
+
+	ToT = packed record
+				head : pdword;
+				size : longint;
+	end;
+
+	TCB = packed record
+				status : longint;
+				mode : longint;
+				reg : array [0..NREGS - 1] of dword;		// never change the offset of this
+				system : array [0..5] of longint;			// reserved by system
+	end;
+	PTCB = ^TCB;
+
+	TCBH = packed record
+				entry : PTCB;								// NULL
+				flag : longint;
+	end;
+
+	EvCB = packed record
+				desc : dword;
+				status : longint;
+				spec : longint;
+				mode : longint;
+				FHandler : pointer;
+				system : array [0..1] of longint;			// reserved by system
+	end;
+
+	XF_HDR = packed record
+				key : array [0..7] of char;
+				text : dword;
+				data : dword;
+				_exec : EXEC;
+				title : array [0..59] of char;				// "PlayStation(tm) Executable A1"
+	end;
+
+
+var
+	SysToT : array [0..31] of ToT; external;
+
+	SysClearRCnt : array [0..0] of longint; external;
+
+
+type
+	PDIRENTRY = ^DIRENTRY;
+	DIRENTRY = packed record
+					name : array [0..29] of char; 			// Filename
+					attr : longint; 						// Attributes (dependent on file system)
+					size : longint; 						// File size (in bytes)
+					next : PDIRENTRY; 						// Pointer to next file entry (for user)
+					system : array [0..7] of char; 			// Reserved by system
+	end;
+	
+	
+
+
+
+
+//
+// Basic system types and major/minor device constructing/busting macros.
+function major(x: longint): dword; // major part of a device
+function minor(x: longint): longint; // minor part of a device
+function makedev(x, y: longint): longint; // make a device number
+
+
+
+
+
+// memory.h
+function memcpy(dest: pointer; src: pointer; count: dword): pointer; stdcall external;
+function memmove(dest: pointer; const src: pointer; count: dword): pointer; stdcall external;
+function memcmp(const lhs: pointer; const rhs: pointer; count: dword): longint; stdcall external;
+function memchr(const ptr: pointer; val: char; num: dword): pointer; stdcall external;
+function memset(const dest: pointer; ch: byte; count: dword): pointer; stdcall external;
+function bcopy(const src: pointer; dest: pointer; len: dword): pointer; stdcall external;
+function bzero(s: pointer; n: dword): pointer; stdcall external;
+function bcmp(const s1: pointer; const s2: pointer; n: dword): longint; stdcall external;
+
+
+
+
+// malloc.h
+procedure InitHeap(p: pdword; l: dword); stdcall external;
+procedure free(p: pointer); stdcall external;
+function malloc(l: size_t): pointer; stdcall external;
+function calloc(nitems: size_t; l: size_t): pointer; stdcall external;
+function realloc(p: pointer; l: size_t): pointer; stdcall external;
+procedure InitHeap2(p: pdword; l: dword); stdcall external;
+procedure free2(p: pointer); stdcall external;
+function malloc2(l: size_t): pointer; stdcall external;
+function calloc2(l1: size_t; l2: size_t): pointer; stdcall external;
+function realloc2(p: pointer; l: size_t): pointer; stdcall external;
+procedure InitHeap3(p: pdword; l: dword); stdcall external;
+procedure free3(p: pointer); stdcall external;
+function malloc3(l: size_t): pointer; stdcall external;
+function calloc3(l1: size_t; l2: size_t): pointer; stdcall external;
+function realloc3(p: pointer; l: size_t): pointer; stdcall external;
+
+
+
+
+// strings.h
+const
+	LMAX = 256;
+
+function strcat(dest: pchar; const src: pchar): pchar; stdcall external;
+function strncat(dest: pchar; const src: pchar; num: size_t): pchar; stdcall; external;
+function strcmp(str1: pchar; str2: pchar): longint; stdcall; external;
+function strncmp(const str1: pchar; const str2: pchar; num: size_t): longint; stdcall; external;
+function strcpy(dest: pchar; src: pchar): pchar; stdcall; external;
+function strncpy(dest: pchar; const src: pchar; num: size_t): pchar; stdcall; external;
+function strlen(s: pchar): longint; stdcall; external;
+function index(const s: pchar; pos: byte): pchar; stdcall; external;
+function rindex(const s: pchar; pos: byte): pchar; stdcall; external;
+
+function strchr(const src: pchar; ch: char): pchar; stdcall; external;
+function strrchr(const src: pchar; ch: char): pchar; stdcall; external;
+function strpbrk(const str1: pchar; const str2: pchar): pchar; stdcall; external;
+function strspn(const str1: pchar; const str2: pchar): longint; stdcall; external;
+function strcspn(const str1: pchar; const str2: pchar): longint; stdcall; external;
+function strtok(str1: pchar; const str2: pchar): pchar; stdcall; external;
+function strstr(const str1: pchar; const str2: pchar): pchar; stdcall; external;
+
+function strdup(p: pchar): pchar;
+
+
+
+
+// rand.h
+const 
+	RAND_MAX = 32767;
+
+function rand: longint; stdcall; external;
+procedure srand(x: longint); stdcall; external;
+
+
+
+
+// stdlib.h
+type
+	Tcmp = function (const a: pointer; const b: pointer): longint;
+	Pcmp = ^Tcmp;
+
+function bsearch(const key: pointer; const ptr: pointer; count: size_t; size: size_t; comp: Pcmp ) : pointer; stdcall; external;
+procedure exit; stdcall; external;
+
+
+
+
+// stdio.h
+const
+	BUFSIZ = 1024;
+	EOF = -1;
+	SEEK_SET = 0;
+	SEEK_CUR = 1;
+	SEEK_END = 2;
+
+function printf(const fmt: pchar): longint; varargs; stdcall; external;
+function sprintf(buffer: pchar; const fmt: pchar): longint; varargs; stdcall; external;
+
+function getc(s: longint): char; stdcall; external;
+function getchar: char; stdcall; external;
+function gets(s: pchar): pchar; stdcall; external;
+procedure putc(ch: char; s: longint); stdcall; external;
+procedure putchar(ch: char); stdcall; external;
+procedure puts(const s: pchar); stdcall; external;
+
+
+
+
+// abs.h
+function abs(x: longint): longint; stdcall; external;
+
+
+
+
+// convert.h
+function atoi(const str: pchar): longint; stdcall; external;
+function atol(const str: pchar): longint; stdcall; external;
+function strtol(const str: pchar; endptr: pointer; base: longint): longint; stdcall; external;
+function strtoul(const str: pchar; endptr: pointer; base: longint): dword; stdcall; external;
+function labs(x: longint): longint; stdcall; external;
+
+
+
+
+//limits.h
+const
+	CHAR_BIT = 8;
+	SCHAR_MIN = -128;
+	SCHAR_MAX = 127;
+	UCHAR_MAX =	255;
+	CHAR_MIN = SCHAR_MIN;
+	CHAR_MAX = SCHAR_MAX;
+	SHRT_MIN = -32768;
+	SHRT_MAX = 32767;
+	USHRT_MAX = 65535;
+	INT_MIN = -2147483648;
+	INT_MAX = 2147483647;
+	UINT_MAX = 4294967295;
+	LONG_MIN = -2147483648;
+	LONG_MAX = 2147483647;
+	ULONG_MAX =	4294967295;
+
+	USI_MAX	= 4294967295;	// max decimal value of an "unsigned"
+	WORD_BIT = 32;		// # of bits in a "word" or "int"
+
+	MB_LEN_MAX = 4;
+
+
+
+
+// qsort.h
+procedure qsort(base: pointer; num: size_t; size: size_t; compar: pointer); stdcall; external;
+
+
+
+
+
+// ctype.h
+const
+	_U = $01;	// upper case letter
+	_L = $02;	// lower case letter
+	_N = $04;	// digit
+	_S = $08;	// space, tab, newline, vertical tab, formfeed, or carriage return
+	_P = $10;	// punctuation character
+	_C = $20;	// control character or delete
+	_X = $40;   // hexadecimal digit [0-9a-fA-F]
+	_B = $80;	// blank (space)
+
+//extern	char	_ctype_[];
+
+function toupper(ch: char): char; stdcall; external;
+function tolower(ch: char): char; stdcall; external;
+
+function isalpha(ch: char): boolean;
+function isupper(ch: char): boolean;
+function islower(ch: char): boolean;
+function isdigit(ch: char): boolean;
+function isxdigit(ch: char): boolean;
+function isspace(ch: char): boolean;
+function ispunct(ch: char): boolean;
+function isalnum(ch: char): boolean;
+function isprint(ch: char): boolean;
+function isgraph(ch: char): boolean;
+function iscntrl(ch: char): boolean;
+function isascii(ch: char): boolean;
+function toascii(ch: char): char;
+//function _toupper(ch: char)	((unsigned char)(c)-'a'+'A')
+//function _tolower(ch: char)	((unsigned char)(c)-'A'+'a')
+
+
+
+
+
+// ioctl.h
+function FIOCNBLOCK: longint;
+function FIOCSCAN: longint;    // scan for input
+// tty and sio
+function TIOCRAW: longint; 	   // disable xon/xoff control
+function TIOCFLUSH: longint;   // flush input buffer
+function TIOCREOPEN: longint;  // reopen
+function TIOCBAUD: longint;    // set baud rate
+function TIOCEXIT: longint;    // console interrup
+function TIOCDTR: longint;     // control DTR line
+function TIOCRTS: longint;     // control RTS line
+function TIOCLEN: longint;     // stop<<16 | char
+					           // stop 0:none 1:1 2:1.5 3:2bit
+					           // char 0:5 1:6 2:7 3:8bit
+function TIOCPARITY: longint;  // parity 0:none 1:e 3:o
+function TIOSTATUS: longint;   // return status
+function TIOERRRST: longint;   // error reset
+function TIOEXIST: longint;    // exist test with DTR/CTS
+function TIORLEN: longint;     // receive buffer length
+// disk
+function DIOFORMAT: longint;   // format
+
+
+
+
+// fcntl.h
+const
+	FREAD	=	$0001;		// readable
+	FWRITE	=	$0002;		// writable
+	FNBLOCK	=	$0004;		// non-blocking reads
+	FRLOCK	=	$0010;		// read locked (non-shared)
+	FWLOCK	=	$0020;		// write locked (non-shared)
+	FAPPEND	=	$0100;		// append on each write
+	FCREAT	=	$0200;		// create if nonexistant
+	FTRUNC	=	$0400;		// truncate to zero length
+	FSCAN	=	$1000;		// scan type
+	FRCOM	=	$2000;		// remote command entry
+	FNBUF	=	$4000;		// no ring buf. and console interrupt
+	FASYNC	=	$8000;		// asyncronous i/o
+
+
+
+
+// file.h
+const
+	// Flag for open()
+	O_RDONLY  = FREAD;
+	O_WRONLY  = FWRITE;
+	O_RDWR    = FREAD or FWRITE;
+	O_CREAT   = FCREAT;  // open with file create
+	O_NOBUF   = FNBUF;	// no device buffer and console interrupt
+	O_NBLOCK  = FNBLOCK;	// non blocking mode
+	O_NOWAIT  = FASYNC;	// asyncronous i/o
+
+
+
+
+
+
+implementation
+
+
+function strdup(p: pchar): pchar;	
+begin
+ 	strdup:= malloc(strlen(p) + 1);
+ 	strcpy(strdup, p);
+end;
+
+
+function isalpha(ch: char): boolean;
+begin
+	isalpha:= boolean(byte(ch) and (_U or _L));
+end;
+
+
+function isupper(ch: char): boolean;
+begin
+	isupper:= boolean(byte(ch) and _U);
+end;
+
+
+function islower(ch: char): boolean;
+begin
+	islower:= boolean(byte(ch) and _L);
+end;
+
+
+function isdigit(ch: char): boolean;
+begin
+	isdigit:= boolean(byte(ch) and _N);
+end;
+
+
+function isxdigit(ch: char): boolean;
+begin
+	isxdigit:= boolean(byte(ch) and (_X or _N));
+end;
+
+
+function isspace(ch: char): boolean;
+begin
+	isspace:= boolean(byte(ch) and _S);
+end;
+
+
+function ispunct(ch: char): boolean;
+begin
+	ispunct:= boolean(byte(ch) and _P);
+end;
+
+
+function isalnum(ch: char): boolean;
+begin
+	isalnum:= boolean(byte(ch) and (_U or _L or _N));
+end;
+
+
+function isprint(ch: char): boolean;
+begin
+	isprint:= boolean(byte(ch) and (_P or _U or _L or _N or _B));
+end;
+
+
+function isgraph(ch: char): boolean;
+begin
+	isgraph:= boolean(byte(ch) and (_P or _U or _L or _N));
+end;
+
+
+function iscntrl(ch: char): boolean;
+begin
+	iscntrl:= boolean(byte(ch) and _C);
+end;
+
+
+function isascii(ch: char): boolean;
+begin
+	isascii:= boolean(byte(ch) <= $7f);
+end;
+
+
+function toascii(ch: char): char;
+begin
+	toascii:= char(byte(ch) and $7f);
+end;
+
+
+function major(x: longint): dword;
+begin
+	major:= dword((x shr 8) and 0377);
+end;
+
+
+function minor(x: longint): longint;
+begin
+	minor:=	x and 0377;
+end;
+
+
+function makedev(x, y: longint): longint;
+begin
+	makedev:= ((x shl 8) or y);
+end;
+
+
+function FIOCNBLOCK: longint;
+begin
+	FIOCNBLOCK:= (dword('f') shl 8) or 1;
+end;
+
+
+function FIOCSCAN: longint;
+begin
+	FIOCSCAN:= (dword('f') shl 8) or 2;
+end;
+
+
+function TIOCRAW: longint;
+begin
+	TIOCRAW:= (dword('t') shl 8) or 1;
+end;
+
+
+function TIOCFLUSH: longint;
+begin
+	TIOCFLUSH:= (dword('t') shl 8) or 2;
+end;
+
+
+function TIOCREOPEN: longint;
+begin
+	TIOCREOPEN:= (dword('t') shl 8) or 3;
+end;
+
+
+function TIOCBAUD: longint;
+begin
+	TIOCBAUD:= (dword('t') shl 8) or 4;
+end;
+
+
+function TIOCEXIT: longint;
+begin
+	TIOCEXIT:= (dword('t') shl 8) or 5;
+end;
+
+
+function TIOCDTR: longint;
+begin
+	TIOCDTR:= (dword('t') shl 8) or 6;
+end;
+
+
+function TIOCRTS: longint;
+begin
+	TIOCRTS:= (dword('t') shl 8) or 7;
+end;
+
+
+function TIOCLEN: longint;
+begin
+	TIOCLEN:= (dword('t') shl 8) or 8;
+end;
+
+
+function TIOCPARITY: longint;
+begin
+	TIOCPARITY:= (dword('t') shl 8) or 9;
+end;
+
+
+function TIOSTATUS: longint;
+begin
+	TIOSTATUS:= (dword('t') shl 8) or 10;
+end;
+
+
+function TIOERRRST: longint;
+begin
+	TIOERRRST:= (dword('t') shl 8) or 11;
+end;
+
+
+function TIOEXIST: longint;
+begin
+	TIOEXIST:= (dword('t') shl 8) or 12;
+end;
+
+
+function TIORLEN: longint;
+begin
+	TIORLEN:= (dword('t') shl 8) or 13;
+end;
+
+
+function DIOFORMAT: longint;
+begin
+	DIOFORMAT:= (dword('d') shl 8) or 1;
+end;
+
+
+
+begin
+end.

psy-q-sdk/bindings/libstrings.pas

@@ -0,0 +1,38 @@
+// string functions pseudo definition header 
+// $PSLibId: Run-time Library Release 4.6$
+{$MODE OBJFPC}
+unit libstrings;
+interface
+const 
+	LMAX = 256;
+
+function strcat(destination:pchar; const source: pchar): pchar; stdcall; external;
+function strncat(destination:pchar; const source, num: longint): pchar; stdcall; external;
+function strcmp(str1, str2: pchar): longint; stdcall; external;
+function strncmp(str1, str2: pchar; num: longint): longint; stdcall; external;
+function strcpy(destination, source: pchar): pchar; stdcall; external;
+function strncpy(destination, source: pchar; num: longint): pchar; stdcall; external;
+function strlen(p: pchar): longint; stdcall; external;
+function index(const p: pchar; num: longint): pchar; stdcall; external;
+function rindex(const p: pchar; num: longint): pchar; stdcall; external;
+
+function strchr(const str: pchar; character: longint): pchar; stdcall; external;
+function strrchr(const str: pchar; character: longint): pchar; stdcall; external;
+function strpbrk(const str1, str2: pchar): pchar; stdcall; external;
+function strspn(const str1, str2: pchar): longint; stdcall; external;
+function strcspn(const str1, str2: pchar): longint; stdcall; external;
+function strtok(str1, str2: pchar): pchar; stdcall; external;
+function strstr(const str1, str2: pchar): pchar; stdcall; external;
+
+function strdup(p: pchar): pchar;
+
+implementation
+uses libstd;
+
+function strdup(p: pchar): pchar;
+begin
+	result:= strcpy(malloc(strlen(p) + 1), p); 
+end;
+
+begin
+end.

psy-q-sdk/bindings/r3000.pas

@@ -0,0 +1,296 @@
+//
+// $PSLibId: Run-time Library Release 4.6$
+//
+{$MODE OBJFPC}
+unit r3000;
+interface
+const
+
+// Segment base addresses and sizes
+	K0BASE = $80000000;
+	K0SIZE = $20000000;
+	K1BASE = $A0000000;
+	K1SIZE = $20000000;
+	K2BASE = $C0000000;
+	K2SIZE = $20000000;
+
+// Exception vectors
+	UT_VEC = K0BASE;							// utlbmiss vector
+	E_VEC  = K0BASE + $80;						// exception vector
+	R_VEC  = K1BASE + $1fc00000;				// reset vector
+
+// Address conversion macros
+function K0_TO_K1(x: dword): dword;				// kseg0 to kseg1
+function K1_TO_K0(x: dword): dword;				// kseg1 to kseg0
+function K0_TO_PHYS(x: dword): dword;			// kseg0 to physical
+function K1_TO_PHYS(x: dword): dword;			// kseg1 to physical
+function PHYS_TO_K0(x: dword): dword;			// physical to kseg0
+function PHYS_TO_K1(x: dword): dword;			// physical to kseg1
+
+// Address predicates
+function IS_KSEG0(x: dword): boolean;
+function IS_KSEG1(x: dword): boolean;
+// function IS_KSEG2(x: dword): boolean;
+// function IS_KPTESEG(x: dword): boolean;
+function IS_KUSEG(x: dword): boolean;
+
+
+const
+// Cache size constants
+	MINCACHE =	4 * 1024;
+	MAXCACHE =	64 * 1024;
+
+
+// Status register
+	SR_CUMASK =	$f0000000;					// coproc usable bits
+
+	SR_CU3    =	$80000000;					// Coprocessor 3 usable
+	SR_CU2    =	$40000000;					// Coprocessor 2 usable
+	SR_CU1	  =	$20000000;					// Coprocessor 1 usable
+	SR_CU0	  =	$10000000;					// Coprocessor 0 usable
+
+	SR_BEV	  =	$00400000;					// use boot exception vectors
+
+// Cache control bits
+	SR_TS	  =	$00200000;					// TLB shutdown
+	SR_PE	  =	$00100000;					// cache parity error
+	SR_CM	  =	$00080000;					// cache miss
+	SR_PZ	  =	$00040000;					// cache parity zero
+	SR_SWC	  =	$00020000;					// swap cache
+	SR_ISC	  =	$00010000;					// Isolate data cache
+
+ 	SR_MM_MODE = $00010000;					// lwl/swl/etc become scache/etc
+ {
+ define: 
+ lcache		lwl
+ scache		swl
+ flush		lwr $0,
+ inval		swr $0,
+}
+
+
+// Interrupt enable bits
+// (NOTE: bits set to 1 enable the corresponding level interrupt)
+	SR_IMASK	= $0000ff00;			// Interrupt mask
+	SR_IMASK8	= $00000000;			// mask level 8
+	SR_IMASK7	= $00008000;			// mask level 7
+	SR_IMASK6	= $0000c000;			// mask level 6
+	SR_IMASK5	= $0000e000;			// mask level 5
+	SR_IMASK4	= $0000f000;			// mask level 4
+	SR_IMASK3	= $0000f800;			// mask level 3
+	SR_IMASK2	= $0000fc00;			// mask level 2
+	SR_IMASK1	= $0000fe00;			// mask level 1
+	SR_IMASK0	= $0000ff00;			// mask level 0
+
+	SR_IBIT8	= $00008000;			// bit level 8
+	SR_IBIT7	= $00004000;			// bit level 7
+	SR_IBIT6	= $00002000;			// bit level 6
+	SR_IBIT5	= $00001000;			// bit level 5
+	SR_IBIT4	= $00000800;			// bit level 4
+	SR_IBIT3	= $00000400;			// bit level 3
+	SR_IBIT2	= $00000200;			// bit level 2
+	SR_IBIT1	= $00000100;			// bit level 1
+
+	SR_KUO		= $00000020;			// old kernel/user, 0 => k, 1 => u
+	SR_IEO		= $00000010;			// old interrupt enable, 1 => enable
+	SR_KUP		= $00000008;			// prev kernel/user, 0 => k, 1 => u
+	SR_IEP		= $00000004;			// prev interrupt enable, 1 => enable
+	SR_KUC		= $00000002;			// cur kernel/user, 0 => k, 1 => u
+	SR_IEC		= $00000001;			// cur interrupt enable, 1 => enable
+
+	SR_IMASKSHIFT	= 8;
+
+	SR_FMT		= '\20\40BD\26TS\25PE\24CM\23PZ\22SwC\21IsC\20IM7\17IM6\16IM5\15IM4\14IM3\13IM2\12IM1\11IM0\6KUo\5IEo\4KUp\3IEp\2KUc\1IEc';
+
+// Cause Register
+
+	CAUSE_BD		= $80000000;		// Branch delay slot */
+	CAUSE_CEMASK	= $30000000;		// coprocessor error */
+	CAUSE_CESHIFT	= 28;
+
+/// Interrupt pending bits
+	CAUSE_IP8	= $00008000;			// External level 8 pending
+	CAUSE_IP7	= $00004000;			// External level 7 pending
+	CAUSE_IP6	= $00002000;			// External level 6 pending
+	CAUSE_IP5	= $00001000;			// External level 5 pending
+	CAUSE_IP4	= $00000800;			// External level 4 pending
+	CAUSE_IP3	= $00000400;			// External level 3 pending
+	CAUSE_SW2	= $00000200;			// Software level 2 pending
+	CAUSE_SW1	= $00000100;			// Software level 1 pending
+
+	CAUSE_IPMASK	= $0000FF00;		// Pending interrupt mask
+	CAUSE_IPSHIFT	= 8;
+
+	CAUSE_EXCMASK	= $0000003C;		// Cause code bits
+	CAUSE_EXCSHIFT	= 2;
+
+	CAUSE_FMT		= '\20\40BD\36CE1\35CE0\20IP8\17IP7\16IP6\15IP5\14IP4\13IP3\12SW2\11SW1\1INT';
+
+
+// Cause register exception codes
+function EXC_CODE(x: dword): dword;
+
+const
+// Hardware exception codes
+	EXC_INT		= 0 shl 2;			// interrupt
+	EXC_MOD		= 1 shl 2;			// TLB mod
+	EXC_RMISS	= 2 shl 2;			// Read TLB Miss
+	EXC_WMISS	= 3 shl 2;			// Write TLB Miss
+	EXC_RADE	= 4 shl 2;			// Read Address Error
+	EXC_WADE	= 5 shl 2;			// Write Address Error
+	EXC_IBE		= 6 shl 2;			// Instruction Bus Error
+	EXC_DBE		= 7 shl 2;			// Data Bus Error
+	EXC_SYSCALL	= 8 shl 2;			// SYSCALL
+	EXC_BREAK	= 9 shl 2;			// BREAKpoint
+	EXC_II		= 10 shl 2;			// Illegal Instruction
+	EXC_CPU		= 11 shl 2;			// CoProcessor Unusable
+	EXC_OV		= 12 shl 2;			// OVerflow
+
+// software exception codes
+	SEXC_SEGV	= 16 shl 2;			// Software detected seg viol
+	SEXC_RESCHED= 17 shl 2;			// resched request
+	SEXC_PAGEIN	= 18 shl 2;			// page-in request
+	SEXC_CPU	= 19 shl 2;			// coprocessor unusable
+
+
+// Coprocessor 0 registers
+{$DEFINE C0_INX	$0} 				// tlb index
+{$DEFINE C0_RAND $1}				// tlb random
+{$DEFINE C0_TLBLO $2}				// tlb entry low
+{$DEFINE C0_CTXT $4}				// tlb context
+
+{$DEFINE C0_PIDMASK	$6}				// Mips2
+
+{$DEFINE C0_BADVADDR $8}			// bad virtual address
+
+{$DEFINE C0_TLBHI $10}				// tlb entry hi
+{$DEFINE C0_PID	$10}				// Mips2
+
+{$DEFINE C0_SR $12}					// status register
+{$DEFINE C0_CAUSE $13}				// exception cause
+{$DEFINE C0_EPC $14}				// exception pc
+{$DEFINE C0_PRID $15}				// revision identifier
+{$DEFINE C0_ERREG $16}				// Mips2
+
+// Coprocessor 0 operations
+	C0_READI  	= $1;		// read ITLB entry addressed by C0_INDEX
+	C0_WRITEI 	= $2;		// write ITLB entry addressed by C0_INDEX
+	C0_WRITER 	= $6;		// write ITLB entry addressed by C0_RAND
+	C0_PROBE  	= $8;		// probe for ITLB entry addressed by TLBHI
+	C0_RFE	  	= $10;		// restore for exception
+
+// Flags for the nofault handler. 0 means no fault is expected.
+	NF_BADADDR	= 1;			// badaddr, wbadaddr
+	NF_COPYIO	= 2;			// copyin, copyout
+	NF_ADDUPC	= 3;			// addupc
+	NF_FSUMEM	= 4;			// fubyte, subyte, fuword, suword
+	NF_USERACC	= 5;			// useracc
+	NF_SOFTFP	= 6;			// softfp
+	NF_REVID	= 7;			// revision ids
+	NF_NENTRIES	= 8;
+
+// TLB size constants
+ 	TLBWIREDBASE    = 0;               					// WAG for now
+ 	NWIREDENTRIES   = 8;               					// WAG for now
+ 	TLBRANDOMBASE   = NWIREDENTRIES;
+ 	NTLBENTRIES     = 64;
+ 	NRANDOMENTRIES  = (NTLBENTRIES - NWIREDENTRIES);
+ 	              		
+
+ 	TLBRAND_RANDMASK   = $00003f00;
+	TLBRAND_RANDSHIFT  = 8;
+
+
+// Chip interrupt vector
+	NC0VECS		 = 8;
+
+
+
+// extern int (*c0vec_tbl[])();
+var
+	c0vec_tbl : array of function: longint; external;
+
+
+const
+ 	BRK_KERNEL 		 = $f1;
+ 	EXCEPT_NORM      = 1;
+ 	EXCEPT_UTLB      = 2;
+ 	EXCEPT_BRKPT   	 = 3;
+ 	EXCEPT_DB    	 = 4;
+ 	EXCEPT_GDB    	 = 4;
+	EXCEPT_INT    	 = 9;
+	EXCEPT_ELSE    	 = $ff;
+
+
+
+implementation
+
+// Address conversion macros
+function K0_TO_K1(x: dword): dword;	
+begin
+	result:= x or $A0000000;
+end;
+
+function K1_TO_K0(x: dword): dword;
+begin
+	result:= x and $9FFFFFFF;
+end;
+
+function K0_TO_PHYS(x: dword): dword;
+begin
+	result:= x and $1FFFFFFF;
+end;
+
+function K1_TO_PHYS(x: dword): dword;
+begin
+	result:= x and $1FFFFFFF;
+end;
+
+function PHYS_TO_K0(x: dword): dword;
+begin
+	result:= x or $80000000;
+end;
+
+function PHYS_TO_K1(x: dword): dword;
+begin
+	result:= x or $A0000000;
+end;
+
+// Address predicates
+function IS_KSEG0(x: dword): boolean;
+begin	
+	result:= ((x >= K0BASE) and (x < K1BASE));
+end;
+
+function IS_KSEG1(x: dword): boolean;
+begin
+	result:= ((x >= K1BASE) and (x < K2BASE));
+end;
+
+
+{
+function IS_KSEG2(x: dword): boolean;
+begin
+	result:= ((x >= K2BASE) and (x < KPTEBASE));
+end;
+
+function IS_KPTESEG(x: dword): boolean;
+begin
+	result:= (x >= KPTEBASE);
+end;
+}
+
+
+
+function IS_KUSEG(x: dword): boolean;
+begin
+	result:= (x < K0BASE);
+end;
+
+function EXC_CODE(x: dword): dword;
+begin
+	result:= x shl 2;
+end;
+
+begin
+end.

rtl/mips/mips.inc

@@ -16,6 +16,7 @@
 {****************************************************************************
                            MIPS specific stuff
 ****************************************************************************}
+{$IFNDEF FPUNONE}
 function get_fsr : dword;assembler;nostackframe;[public, alias: 'FPC_GETFSR'];
   asm
     cfc1 $2,$31
@@ -71,6 +72,9 @@ const
 
   fpu_all_bits = fpu_enable_mask or fpu_flags_mask or fpu_cause_mask or fpu_rounding_mask;
 
+{$ENDIF}
+
+
 {$if defined(FPUMIPS2) or defined(FPUMIPS3)}
 {$define FPC_SYSTEM_HAS_SYSINITFPU}
 procedure SysInitFPU;
@@ -485,6 +489,13 @@ begin
   InterLockedIncrement(l);
 end;
 
+{$IFDEF CPUMIPS1}
+function InterLockedDecrement (var Target: longint) : longint;
+begin
+    Target:= Target - 1;
+    Result:=Target;
+end;
+{$ELSE}
 function InterLockedDecrement (var Target: longint) : longint; assembler; nostackframe;
 asm
   sync
@@ -497,8 +508,15 @@ asm
   nop
   sync
 end;
+{$ENDIF}
 
-
+{$IFDEF CPUMIPS1}
+function InterLockedIncrement (var Target: longint) : longint;
+begin
+    Target:= Target + 1;
+    Result:=Target;
+end;
+{$ELSE}
 function InterLockedIncrement (var Target: longint) : longint; assembler; nostackframe;
 asm
   sync
@@ -511,8 +529,15 @@ asm
   nop
   sync
 end;
+{$ENDIF}
 
-
+{$IFDEF CPUMIPS1}
+function InterLockedExchange (var Target: longint;Source : longint) : longint;
+begin
+    Result:=Target;
+    Target:=Source;
+end;
+{$ELSE}
 function InterLockedExchange (var Target: longint;Source : longint) : longint; assembler; nostackframe;
 asm
   sync
@@ -524,7 +549,15 @@ asm
   nop
   sync
 end;
+{$ENDIF}
 
+{$IFDEF CPUMIPS1}
+function InterLockedExchangeAdd (var Target: longint;Source : longint) : longint;
+begin
+    Result:=Target;
+    Target:= Target + Source;
+end;
+{$ELSE}
 function InterLockedExchangeAdd (var Target: longint;Source : longint) : longint; assembler; nostackframe;
 asm
   sync
@@ -536,8 +569,16 @@ asm
   nop
   sync
 end;
+{$ENDIF}
 
-
+{$IFDEF CPUMIPS1}
+function InterlockedCompareExchange(var Target: longint; NewValue: longint; Comperand: longint): longint;
+begin
+    Result:= Target;
+    if Target = Comperand then
+      Target:= NewValue;
+end;
+{$ELSE}
 function InterlockedCompareExchange(var Target: longint; NewValue: longint; Comperand: longint): longint; assembler; nostackframe;
 asm
   sync
@@ -552,7 +593,7 @@ asm
   sync
 .L2:
 end;
-
+{$ENDIF}
 
 {$ifndef FPC_SYSTEM_HAS_SAR_QWORD}
 {$ifdef ENDIAN_BIG}

rtl/ps1/Makefile

@@ -0,0 +1,2756 @@
+#
+# Don't edit, this file is generated by FPCMake Version 2.0.0
+#
+default: all
+MAKEFILETARGETS=i386-linux i386-go32v2 i386-win32 i386-os2 i386-freebsd i386-beos i386-haiku i386-netbsd i386-solaris i386-netware i386-openbsd i386-wdosx i386-darwin i386-emx i386-watcom i386-netwlibc i386-wince i386-embedded i386-symbian i386-nativent i386-iphonesim i386-android i386-aros m68k-linux m68k-netbsd m68k-amiga m68k-atari m68k-palmos m68k-macosclassic m68k-embedded m68k-sinclairql m68k-human68k powerpc-linux powerpc-netbsd powerpc-amiga powerpc-macosclassic powerpc-darwin powerpc-morphos powerpc-embedded powerpc-wii powerpc-aix sparc-linux sparc-netbsd sparc-solaris sparc-embedded x86_64-linux x86_64-freebsd x86_64-haiku x86_64-netbsd x86_64-solaris x86_64-openbsd x86_64-darwin x86_64-win64 x86_64-embedded x86_64-iphonesim x86_64-android x86_64-aros x86_64-dragonfly arm-linux arm-netbsd arm-palmos arm-wince arm-gba arm-nds arm-embedded arm-symbian arm-android arm-aros arm-freertos arm-ios powerpc64-linux powerpc64-darwin powerpc64-embedded powerpc64-aix avr-embedded armeb-linux armeb-embedded mips-linux mipsel-linux mipsel-embedded mipsel-android mipsel-ps1 mips64-linux mips64el-linux jvm-java jvm-android i8086-embedded i8086-msdos i8086-win16 aarch64-linux aarch64-freebsd aarch64-darwin aarch64-win64 aarch64-embedded aarch64-iphonesim aarch64-android aarch64-ios wasm32-embedded wasm32-wasi sparc64-linux riscv32-linux riscv32-embedded riscv32-freertos riscv64-linux riscv64-embedded xtensa-linux xtensa-embedded xtensa-freertos z80-embedded z80-zxspectrum z80-msxdos z80-amstradcpc loongarch64-linux
+BSDs = freebsd netbsd openbsd darwin dragonfly
+UNIXs = linux $(BSDs) solaris qnx haiku aix
+LIMIT83fs = go32v2 os2 emx watcom msdos win16 atari human68k
+OSNeedsComspecToRunBatch = go32v2 watcom
+FORCE:
+.PHONY: FORCE
+lc = $(subst A,a,$(subst B,b,$(subst C,c,$(subst D,d,$(subst E,e,$(subst F,f,$(subst G,g,$(subst H,h,$(subst I,i,$(subst J,j,$(subst K,k,$(subst L,l,$(subst M,m,$(subst N,n,$(subst O,o,$(subst P,p,$(subst Q,q,$(subst R,r,$(subst S,s,$(subst T,t,$(subst U,u,$(subst V,v,$(subst W,w,$(subst X,x,$(subst Y,y,$(subst Z,z,$1))))))))))))))))))))))))))
+override PATH:=$(patsubst %/,%,$(subst \,/,$(PATH)))
+ifneq ($(findstring darwin,$(OSTYPE)),)
+inUnix=1 #darwin
+SEARCHPATH:=$(filter-out .,$(subst :, ,$(PATH)))
+else
+ifeq ($(findstring ;,$(PATH)),)
+inUnix=1
+SEARCHPATH:=$(filter-out .,$(subst :, ,$(PATH)))
+else
+SEARCHPATH:=$(subst ;, ,$(PATH))
+endif
+endif
+SEARCHPATH+=$(patsubst %/,%,$(subst \,/,$(dir $(MAKE))))
+PWD:=$(strip $(wildcard $(addsuffix /pwd.exe,$(SEARCHPATH))))
+ifeq ($(PWD),)
+PWD:=$(strip $(wildcard $(addsuffix /pwd,$(SEARCHPATH))))
+ifeq ($(PWD),)
+$(error You need the GNU utils package to use this Makefile)
+else
+PWD:=$(firstword $(PWD))
+SRCEXEEXT=
+endif
+else
+PWD:=$(firstword $(PWD))
+SRCEXEEXT=.exe
+endif
+ifndef inUnix
+ifeq ($(OS),Windows_NT)
+inWinNT=1
+else
+ifdef OS2_SHELL
+inOS2=1
+endif
+endif
+else
+ifneq ($(findstring cygdrive,$(PATH)),)
+inCygWin=1
+endif
+endif
+ifdef inUnix
+SRCBATCHEXT=.sh
+else
+ifdef inOS2
+SRCBATCHEXT=.cmd
+else
+SRCBATCHEXT=.bat
+endif
+endif
+ifdef COMSPEC
+ifneq ($(filter $(OS_SOURCE),$(OSNeedsComspecToRunBatch)),)
+ifndef RUNBATCH
+RUNBATCH=$(COMSPEC) /C
+endif
+endif
+endif
+ifdef inUnix
+PATHSEP=/
+else
+PATHSEP:=$(subst /,\,/)
+ifdef inCygWin
+PATHSEP=/
+endif
+endif
+ifdef PWD
+BASEDIR:=$(subst \,/,$(shell $(PWD)))
+ifdef inCygWin
+ifneq ($(findstring /cygdrive/,$(BASEDIR)),)
+BASENODIR:=$(patsubst /cygdrive%,%,$(BASEDIR))
+BASEDRIVE:=$(firstword $(subst /, ,$(BASENODIR)))
+BASEDIR:=$(subst /cygdrive/$(BASEDRIVE)/,$(BASEDRIVE):/,$(BASEDIR))
+endif
+endif
+else
+BASEDIR=.
+endif
+ifdef inOS2
+ifndef ECHO
+ECHO:=$(strip $(wildcard $(addsuffix /gecho$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO:=$(strip $(wildcard $(addsuffix /echo$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO=echo
+else
+ECHO:=$(firstword $(ECHO))
+endif
+else
+ECHO:=$(firstword $(ECHO))
+endif
+endif
+export ECHO
+endif
+override OS_TARGET_DEFAULT=ps1
+override CPU_TARGET_DEFAULT=mipsel
+ifndef FPC
+ifdef PP
+FPC=$(PP)
+endif
+endif
+ifndef FPC
+FPCPROG:=$(strip $(wildcard $(addsuffix /fpc$(SRCEXEEXT),$(SEARCHPATH))))
+ifneq ($(FPCPROG),)
+FPCPROG:=$(firstword $(FPCPROG))
+ifneq ($(CPU_TARGET),)
+FPC:=$(shell $(FPCPROG) -P$(CPU_TARGET) -PB)
+else
+FPC:=$(shell $(FPCPROG) -PB)
+endif
+ifneq ($(findstring Error,$(FPC)),)
+override FPC=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH)))))
+else
+ifeq ($(strip $(wildcard $(FPC))),)
+FPC:=$(firstword $(FPCPROG))
+endif
+endif
+else
+override FPC=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH)))))
+endif
+endif
+override FPC:=$(subst $(SRCEXEEXT),,$(FPC))
+override FPC:=$(subst \,/,$(FPC))$(SRCEXEEXT)
+FOUNDFPC:=$(strip $(wildcard $(FPC)))
+ifeq ($(FOUNDFPC),)
+FOUNDFPC=$(strip $(wildcard $(addsuffix /$(FPC),$(SEARCHPATH))))
+ifeq ($(FOUNDFPC),)
+$(error Compiler $(FPC) not found)
+endif
+endif
+ifndef FPC_COMPILERINFO
+FPC_COMPILERINFO:=$(shell $(FPC) -iVSPTPSOTO)
+endif
+ifndef FPC_VERSION
+FPC_VERSION:=$(word 1,$(FPC_COMPILERINFO))
+endif
+export FPC FPC_VERSION FPC_COMPILERINFO
+unexport CHECKDEPEND ALLDEPENDENCIES
+ifndef CPU_TARGET
+ifdef CPU_TARGET_DEFAULT
+CPU_TARGET=$(CPU_TARGET_DEFAULT)
+endif
+endif
+ifndef OS_TARGET
+ifdef OS_TARGET_DEFAULT
+OS_TARGET=$(OS_TARGET_DEFAULT)
+endif
+endif
+ifndef CPU_SOURCE
+CPU_SOURCE:=$(word 2,$(FPC_COMPILERINFO))
+endif
+ifndef CPU_TARGET
+CPU_TARGET:=$(word 3,$(FPC_COMPILERINFO))
+endif
+ifndef OS_SOURCE
+OS_SOURCE:=$(word 4,$(FPC_COMPILERINFO))
+endif
+ifndef OS_TARGET
+OS_TARGET:=$(word 5,$(FPC_COMPILERINFO))
+endif
+CPU_OS_TARGET=$(CPU_TARGET)-$(OS_TARGET)
+ifdef SUB_TARGET
+L_SUB_TARGET=$(call lc,$(SUB_TARGET))
+FULL_TARGET:=$(CPU_TARGET)-$(OS_TARGET)-$(L_SUB_TARGET)
+else
+FULL_TARGET:=$(CPU_TARGET)-$(OS_TARGET)
+endif
+CPU_OS_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE)
+ifdef SUB_SOURCE
+L_SUB_SOURCE=$(call lc,$(SUB_SOURCE))
+FULL_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE)-$(L_SUB_SOURCE)
+else
+FULL_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE)
+endif
+ifeq ($(CPU_TARGET),armeb)
+ARCH=arm
+override FPCOPT+=-Cb
+else
+ifeq ($(CPU_TARGET),armel)
+ARCH=arm
+override FPCOPT+=-CaEABI
+else
+ARCH=$(CPU_TARGET)
+endif
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-embedded)
+endif
+ifdef SUB_TARGET 
+FPCOPT+=-t$(SUB_TARGET)
+FPMAKE_OPT+=--subtarget=$(SUB_TARGET)
+endif
+ifeq ($(CPU_OS_TARGET),arm-embedded)
+ifeq ($(SUBARCH),)
+$(error When compiling for arm-embedded, a sub-architecture (e.g. SUBARCH=armv4t or SUBARCH=armv7m) must be defined)
+endif
+override FPCOPT+=-Cp$(SUBARCH)
+endif
+ifeq ($(CPU_OS_TARGET),avr-embedded)
+ifeq ($(SUBARCH),)
+$(error When compiling for avr-embedded, a sub-architecture (e.g. SUBARCH=avr25 or SUBARCH=avr35) must be defined)
+endif
+override FPCOPT+=-Cp$(SUBARCH)
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-embedded)
+ifeq ($(SUBARCH),)
+$(error When compiling for mipsel-embedded, a sub-architecture (e.g. SUBARCH=pic32mx) must be defined)
+endif
+override FPCOPT+=-Cp$(SUBARCH)
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-embedded)
+ifeq ($(SUBARCH),)
+$(error When compiling for xtensa-embedded, a sub-architecture (e.g. SUBARCH=lx106 or SUBARCH=lx6) must be defined)
+endif
+override FPCOPT+=-Cp$(SUBARCH)
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-freertos)
+ifeq ($(SUBARCH),)
+$(error When compiling for xtensa-freertos, a sub-architecture (e.g. SUBARCH=lx106 or SUBARCH=lx6) must be defined)
+endif
+override FPCOPT+=-Cp$(SUBARCH)
+endif
+ifeq ($(CPU_OS_TARGET),arm-freertos)
+ifeq ($(SUBARCH),)
+$(error When compiling for arm-freertos, a sub-architecture (e.g. SUBARCH=armv6m or SUBARCH=armv7em) must be defined)
+endif
+override FPCOPT+=-Cp$(SUBARCH)
+endif
+ifneq ($(filter $(OS_SOURCE),$(LIMIT83fs)),)
+TARGETSUFFIX=$(OS_TARGET)
+SOURCESUFFIX=$(OS_SOURCE)
+else
+ifneq ($(filter $(OS_TARGET),$(LIMIT83fs)),)
+TARGETSUFFIX=$(OS_TARGET)
+else
+TARGETSUFFIX=$(FULL_TARGET)
+endif
+SOURCESUFFIX=$(FULL_SOURCE)
+endif
+ifneq ($(CPU_OS_TARGET),$(CPU_OS_SOURCE))
+CROSSCOMPILE=1
+endif
+ifeq ($(findstring makefile,$(MAKECMDGOALS)),)
+ifeq ($(filter $(CPU_OS_TARGET),$(MAKEFILETARGETS)),)
+$(error The Makefile doesn't support target $(FULL_TARGET), please run fpcmake first)
+endif
+endif
+ifneq ($(filter $(OS_TARGET),$(BSDs)),)
+BSDhier=1
+endif
+ifeq ($(OS_TARGET),linux)
+linuxHier=1
+endif
+ifndef CROSSCOMPILE
+BUILDFULLNATIVE=1
+export BUILDFULLNATIVE
+endif
+ifdef BUILDFULLNATIVE
+BUILDNATIVE=1
+export BUILDNATIVE
+endif
+export OS_TARGET OS_SOURCE ARCH CPU_TARGET CPU_SOURCE SUB_TARGET SUB_SOURCE FULL_TARGET FULL_SOURCE TARGETSUFFIX SOURCESUFFIX CROSSCOMPILE CPU_OS_TARGET CPU_OS_SOURCE
+ifdef FPCDIR
+override FPCDIR:=$(subst \,/,$(FPCDIR))
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),)
+override FPCDIR=wrong
+endif
+else
+override FPCDIR=wrong
+endif
+ifdef DEFAULT_FPCDIR
+ifeq ($(FPCDIR),wrong)
+override FPCDIR:=$(subst \,/,$(DEFAULT_FPCDIR))
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),)
+override FPCDIR=wrong
+endif
+endif
+endif
+ifeq ($(FPCDIR),wrong)
+ifdef inUnix
+override FPCDIR=/usr/local/lib/fpc/$(FPC_VERSION)
+ifeq ($(wildcard $(FPCDIR)/units),)
+override FPCDIR=/usr/lib/fpc/$(FPC_VERSION)
+endif
+else
+override FPCDIR:=$(subst /$(FPC),,$(firstword $(strip $(wildcard $(addsuffix /$(FPC),$(SEARCHPATH))))))
+override FPCDIR:=$(FPCDIR)/..
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),)
+override FPCDIR:=$(FPCDIR)/..
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),)
+override FPCDIR:=$(BASEDIR)
+ifeq ($(wildcard $(addprefix $(FPCDIR)/,rtl)),)
+override FPCDIR=c:/pp
+endif
+endif
+endif
+endif
+endif
+ifndef CROSSBINDIR
+CROSSBINDIR:=$(wildcard $(FPCDIR)/bin/$(TARGETSUFFIX))
+endif
+ifneq ($(filter $(OS_TARGET),darwin iphonesim ios),)
+ifneq ($(filter $(OS_SOURCE),darwin ios),)
+DARWIN2DARWIN=1
+endif
+endif
+ifndef BINUTILSPREFIX
+ifndef CROSSBINDIR
+ifdef CROSSCOMPILE
+ifneq ($(OS_TARGET),msdos)
+ifndef DARWIN2DARWIN
+ifneq ($(CPU_TARGET),jvm)
+BINUTILSPREFIX=$(CPU_TARGET)-$(OS_TARGET)-
+ifeq ($(OS_TARGET),android)
+ifeq ($(CPU_TARGET),arm)
+BINUTILSPREFIX=arm-linux-androideabi-
+else
+ifeq ($(CPU_TARGET),i386)
+BINUTILSPREFIX=i686-linux-android-
+else
+BINUTILSPREFIX=$(CPU_TARGET)-linux-android-
+endif
+endif
+endif
+endif
+endif
+else
+BINUTILSPREFIX=$(OS_TARGET)-
+endif
+endif
+endif
+endif
+UNITSDIR:=$(wildcard $(FPCDIR)/units/$(TARGETSUFFIX))
+ifeq ($(UNITSDIR),)
+UNITSDIR:=$(wildcard $(FPCDIR)/units/$(OS_TARGET))
+endif
+PACKAGESDIR:=$(wildcard $(FPCDIR) $(FPCDIR)/packages)
+ifndef FPCFPMAKE
+ifdef CROSSCOMPILE
+ifeq ($(strip $(wildcard $(addsuffix /compiler/ppc$(SRCEXEEXT),$(FPCDIR)))),)
+FPCPROG:=$(strip $(wildcard $(addsuffix /fpc$(SRCEXEEXT),$(SEARCHPATH))))
+ifneq ($(FPCPROG),)
+FPCPROG:=$(firstword $(FPCPROG))
+FPCFPMAKE:=$(shell $(FPCPROG) -PB)
+ifeq ($(strip $(wildcard $(FPCFPMAKE))),)
+FPCFPMAKE:=$(firstword $(FPCPROG))
+endif
+else
+override FPCFPMAKE=$(firstword $(strip $(wildcard $(addsuffix /ppc386$(SRCEXEEXT),$(SEARCHPATH)))))
+endif
+else
+FPCFPMAKE=$(strip $(wildcard $(addsuffix /compiler/ppc$(SRCEXEEXT),$(FPCDIR))))
+FPMAKE_SKIP_CONFIG=-n
+export FPCFPMAKE
+export FPMAKE_SKIP_CONFIG
+endif
+else
+FPMAKE_SKIP_CONFIG=-n
+FPCFPMAKE=$(FPC)
+endif
+endif
+override PACKAGE_NAME=rtl
+PACKAGEDIR_MAIN:=$(firstword $(subst /Makefile.fpc,,$(strip $(wildcard $(addsuffix /rtl/Makefile.fpc,$(PACKAGESDIR))))))
+RTL=..
+INC=../inc
+COMMON=$(RTL)/common
+PROCINC=../$(CPU_TARGET)
+UNITPREFIX=rtl
+OBJPASDIR=$(RTL)/objpas
+ifdef EXCEPTIONS_IN_SYSTEM
+override FPCOPT+=-dEXCEPTIONS_IN_SYSTEM
+endif
+ifdef NO_EXCEPTIONS_IN_SYSTEM
+override FPCOPT+=-dNO_EXCEPTIONS_IN_SYSTEM
+endif
+ifeq ($(CPU_OS_TARGET),i386-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-go32v2)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-win32)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-os2)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-freebsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-beos)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-haiku)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-netbsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-solaris)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-netware)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-openbsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-wdosx)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-darwin)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-emx)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-watcom)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-netwlibc)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-wince)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-symbian)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-nativent)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-iphonesim)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-android)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i386-aros)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),m68k-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),m68k-netbsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),m68k-amiga)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),m68k-atari)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),m68k-palmos)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),m68k-macosclassic)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),m68k-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),m68k-sinclairql)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),m68k-human68k)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-netbsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-amiga)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-macosclassic)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-darwin)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-morphos)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-wii)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-aix)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),sparc-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),sparc-netbsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),sparc-solaris)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),sparc-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-freebsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-haiku)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-netbsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-solaris)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-openbsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-darwin)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-win64)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-iphonesim)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-android)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-aros)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-dragonfly)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-netbsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-palmos)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-wince)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-gba)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-nds)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-symbian)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-android)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-aros)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-freertos)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),arm-ios)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-darwin)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-aix)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),avr-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),armeb-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),armeb-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),mips-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-android)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-ps1)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),mips64-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),mips64el-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),jvm-java)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),jvm-android)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i8086-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i8086-msdos)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),i8086-win16)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-freebsd)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-darwin)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-win64)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-iphonesim)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-android)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-ios)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),wasm32-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),wasm32-wasi)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),sparc64-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),riscv32-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),riscv32-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),riscv32-freertos)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),riscv64-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),riscv64-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-freertos)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),z80-embedded)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),z80-zxspectrum)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),z80-msxdos)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),z80-amstradcpc)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+ifeq ($(CPU_OS_TARGET),loongarch64-linux)
+override TARGET_UNITS+=$(SYSTEMUNIT) strt
+endif
+override INSTALL_FPCPACKAGE=y
+ifeq ($(CPU_OS_TARGET),i386-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-go32v2)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-win32)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-os2)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-freebsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-beos)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-haiku)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-netbsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-solaris)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-netware)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-openbsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-wdosx)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-darwin)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-emx)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-watcom)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-netwlibc)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-wince)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-symbian)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-nativent)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-iphonesim)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-android)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-aros)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-netbsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-amiga)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-atari)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-palmos)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-macosclassic)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-sinclairql)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-human68k)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-netbsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-amiga)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-macosclassic)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-darwin)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-morphos)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-wii)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-aix)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),sparc-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),sparc-netbsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),sparc-solaris)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),sparc-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-freebsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-haiku)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-netbsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-solaris)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-openbsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-darwin)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-win64)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-iphonesim)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-android)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-aros)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-dragonfly)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-netbsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-palmos)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-wince)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-gba)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-nds)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-symbian)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-android)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-aros)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-freertos)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),arm-ios)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-darwin)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-aix)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),avr-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),armeb-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),armeb-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),mips-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-android)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-ps1)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),mips64-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),mips64el-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),jvm-java)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),jvm-android)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i8086-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i8086-msdos)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i8086-win16)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-freebsd)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-darwin)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-win64)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-iphonesim)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-android)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-ios)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),wasm32-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),wasm32-wasi)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),sparc64-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),riscv32-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),riscv32-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),riscv32-freertos)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),riscv64-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),riscv64-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-freertos)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),z80-embedded)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),z80-zxspectrum)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),z80-msxdos)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),z80-amstradcpc)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),loongarch64-linux)
+override COMPILER_INCLUDEDIR+=$(INC) $(PROCINC)
+endif
+ifeq ($(CPU_OS_TARGET),i386-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-go32v2)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-win32)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-os2)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-freebsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-beos)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-haiku)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-netbsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-solaris)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-netware)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-openbsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-wdosx)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-darwin)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-emx)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-watcom)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-netwlibc)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-wince)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-symbian)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-nativent)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-iphonesim)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-android)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i386-aros)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-netbsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-amiga)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-atari)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-palmos)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-macosclassic)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-sinclairql)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),m68k-human68k)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-netbsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-amiga)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-macosclassic)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-darwin)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-morphos)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-wii)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc-aix)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),sparc-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),sparc-netbsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),sparc-solaris)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),sparc-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-freebsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-haiku)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-netbsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-solaris)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-openbsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-darwin)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-win64)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-iphonesim)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-android)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-aros)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),x86_64-dragonfly)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-netbsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-palmos)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-wince)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-gba)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-nds)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-symbian)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-android)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-aros)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-freertos)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),arm-ios)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-darwin)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),powerpc64-aix)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),avr-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),armeb-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),armeb-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),mips-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-android)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),mipsel-ps1)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),mips64-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),mips64el-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),jvm-java)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),jvm-android)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i8086-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i8086-msdos)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),i8086-win16)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-freebsd)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-darwin)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-win64)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-iphonesim)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-android)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),aarch64-ios)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),wasm32-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),wasm32-wasi)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),sparc64-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),riscv32-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),riscv32-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),riscv32-freertos)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),riscv64-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),riscv64-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),xtensa-freertos)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),z80-embedded)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),z80-zxspectrum)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),z80-msxdos)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),z80-amstradcpc)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifeq ($(CPU_OS_TARGET),loongarch64-linux)
+override COMPILER_SOURCEDIR+=$(INC) $(PROCINC) $(COMMON)
+endif
+ifdef REQUIRE_UNITSDIR
+override UNITSDIR+=$(REQUIRE_UNITSDIR)
+endif
+ifdef REQUIRE_PACKAGESDIR
+override PACKAGESDIR+=$(REQUIRE_PACKAGESDIR)
+endif
+ifdef ZIPINSTALL
+ifneq ($(filter $(OS_TARGET),$(UNIXs)),)
+UNIXHier=1
+endif
+else
+ifneq ($(filter $(OS_SOURCE),$(UNIXs)),)
+UNIXHier=1
+endif
+endif
+ifndef INSTALL_PREFIX
+ifdef PREFIX
+INSTALL_PREFIX=$(PREFIX)
+endif
+endif
+ifndef INSTALL_PREFIX
+ifdef UNIXHier
+INSTALL_PREFIX=/usr/local
+else
+ifdef INSTALL_FPCPACKAGE
+INSTALL_BASEDIR:=/pp
+else
+INSTALL_BASEDIR:=/$(PACKAGE_NAME)
+endif
+endif
+endif
+export INSTALL_PREFIX
+ifdef INSTALL_FPCSUBDIR
+export INSTALL_FPCSUBDIR
+endif
+ifndef DIST_DESTDIR
+DIST_DESTDIR:=$(BASEDIR)
+endif
+export DIST_DESTDIR
+ifndef COMPILER_UNITTARGETDIR
+ifdef PACKAGEDIR_MAIN
+COMPILER_UNITTARGETDIR=$(PACKAGEDIR_MAIN)/units/$(TARGETSUFFIX)
+else
+COMPILER_UNITTARGETDIR=units/$(TARGETSUFFIX)
+endif
+endif
+ifndef COMPILER_TARGETDIR
+COMPILER_TARGETDIR=.
+endif
+ifndef INSTALL_BASEDIR
+ifdef UNIXHier
+ifdef INSTALL_FPCPACKAGE
+INSTALL_BASEDIR:=$(INSTALL_PREFIX)/lib/fpc/$(FPC_VERSION)
+else
+INSTALL_BASEDIR:=$(INSTALL_PREFIX)/lib/$(PACKAGE_NAME)
+endif
+else
+INSTALL_BASEDIR:=$(INSTALL_PREFIX)
+endif
+endif
+ifndef INSTALL_BINDIR
+ifdef UNIXHier
+INSTALL_BINDIR:=$(INSTALL_PREFIX)/bin
+else
+INSTALL_BINDIR:=$(INSTALL_BASEDIR)/bin
+ifdef INSTALL_FPCPACKAGE
+ifdef CROSSCOMPILE
+ifdef CROSSINSTALL
+INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(SOURCESUFFIX)
+else
+INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(TARGETSUFFIX)
+endif
+else
+INSTALL_BINDIR:=$(INSTALL_BINDIR)/$(TARGETSUFFIX)
+endif
+endif
+endif
+endif
+ifndef INSTALL_UNITDIR
+INSTALL_UNITDIR:=$(INSTALL_BASEDIR)/units/$(TARGETSUFFIX)
+ifdef INSTALL_FPCPACKAGE
+ifdef PACKAGE_NAME
+INSTALL_UNITDIR:=$(INSTALL_UNITDIR)/$(PACKAGE_NAME)
+endif
+endif
+endif
+ifndef INSTALL_LIBDIR
+ifdef UNIXHier
+INSTALL_LIBDIR:=$(INSTALL_PREFIX)/lib
+else
+INSTALL_LIBDIR:=$(INSTALL_UNITDIR)
+endif
+endif
+ifndef INSTALL_SOURCEDIR
+ifdef UNIXHier
+ifdef BSDhier
+SRCPREFIXDIR=share/src
+else
+ifdef linuxHier
+SRCPREFIXDIR=share/src
+else
+SRCPREFIXDIR=src
+endif
+endif
+ifdef INSTALL_FPCPACKAGE
+ifdef INSTALL_FPCSUBDIR
+INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/fpc-$(FPC_VERSION)/$(INSTALL_FPCSUBDIR)/$(PACKAGE_NAME)
+else
+INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/fpc-$(FPC_VERSION)/$(PACKAGE_NAME)
+endif
+else
+INSTALL_SOURCEDIR:=$(INSTALL_PREFIX)/$(SRCPREFIXDIR)/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+endif
+else
+ifdef INSTALL_FPCPACKAGE
+ifdef INSTALL_FPCSUBDIR
+INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source/$(INSTALL_FPCSUBDIR)/$(PACKAGE_NAME)
+else
+INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source/$(PACKAGE_NAME)
+endif
+else
+INSTALL_SOURCEDIR:=$(INSTALL_BASEDIR)/source
+endif
+endif
+endif
+ifndef INSTALL_DOCDIR
+ifdef UNIXHier
+ifdef BSDhier
+DOCPREFIXDIR=share/doc
+else
+ifdef linuxHier
+DOCPREFIXDIR=share/doc
+else
+DOCPREFIXDIR=doc
+endif
+endif
+ifdef INSTALL_FPCPACKAGE
+INSTALL_DOCDIR:=$(INSTALL_PREFIX)/$(DOCPREFIXDIR)/fpc-$(FPC_VERSION)/$(PACKAGE_NAME)
+else
+INSTALL_DOCDIR:=$(INSTALL_PREFIX)/$(DOCPREFIXDIR)/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+endif
+else
+ifdef INSTALL_FPCPACKAGE
+INSTALL_DOCDIR:=$(INSTALL_BASEDIR)/doc/$(PACKAGE_NAME)
+else
+INSTALL_DOCDIR:=$(INSTALL_BASEDIR)/doc
+endif
+endif
+endif
+ifndef INSTALL_EXAMPLEDIR
+ifdef UNIXHier
+ifdef INSTALL_FPCPACKAGE
+ifdef BSDhier
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/share/examples/fpc-$(FPC_VERSION)/$(PACKAGE_NAME)
+else
+ifdef linuxHier
+INSTALL_EXAMPLEDIR:=$(INSTALL_DOCDIR)/examples
+else
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/doc/fpc-$(FPC_VERSION)/examples/$(PACKAGE_NAME)
+endif
+endif
+else
+ifdef BSDhier
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/share/examples/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+else
+ifdef linuxHier
+INSTALL_EXAMPLEDIR:=$(INSTALL_DOCDIR)/examples/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+else
+INSTALL_EXAMPLEDIR:=$(INSTALL_PREFIX)/doc/$(PACKAGE_NAME)-$(PACKAGE_VERSION)
+endif
+endif
+endif
+else
+ifdef INSTALL_FPCPACKAGE
+INSTALL_EXAMPLEDIR:=$(INSTALL_BASEDIR)/examples/$(PACKAGE_NAME)
+else
+INSTALL_EXAMPLEDIR:=$(INSTALL_BASEDIR)/examples
+endif
+endif
+endif
+ifndef INSTALL_DATADIR
+INSTALL_DATADIR=$(INSTALL_BASEDIR)
+endif
+ifndef INSTALL_SHAREDDIR
+INSTALL_SHAREDDIR=$(INSTALL_PREFIX)/lib
+endif
+ifdef CROSSCOMPILE
+ifndef CROSSBINDIR
+CROSSBINDIR:=$(wildcard $(CROSSTARGETDIR)/bin/$(SOURCESUFFIX))
+ifeq ($(CROSSBINDIR),)
+CROSSBINDIR:=$(wildcard $(INSTALL_BASEDIR)/cross/$(TARGETSUFFIX)/bin/$(FULL_SOURCE))
+endif
+endif
+else
+CROSSBINDIR=
+endif
+ifeq ($(OS_SOURCE),linux)
+ifndef GCCLIBDIR
+ifeq ($(CPU_TARGET),i386)
+ifneq ($(filter x86_64,$(shell uname -a)),)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -m32 -print-libgcc-file-name`)
+else
+CROSSGCCOPT=-m32
+endif
+endif
+endif
+ifeq ($(CPU_TARGET),powerpc)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -m32 -print-libgcc-file-name`)
+else
+CROSSGCCOPT=-m32
+endif
+endif
+ifeq ($(CPU_TARGET),powerpc64)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -m64 -print-libgcc-file-name`)
+else
+CROSSGCCOPT=-m64
+endif
+endif
+ifeq ($(CPU_TARGET),sparc)
+ifneq ($(filter sparc64,$(shell uname -a)),)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -m32 -print-libgcc-file-name`)
+else
+CROSSGCCOPT=-m32
+endif
+endif
+endif
+ifneq ($(filter $(CPU_TARGET),mips64 mipsel64),)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -mabi=64 -print-libgcc-file-name`)
+else
+CROSSGCCOPT=-mabi=64
+endif
+endif
+ifneq ($(filter $(CPU_TARGET),mips mipsel),)
+ifeq ($(BINUTILSPREFIX),)
+GCCLIBDIR:=$(shell dirname `gcc -mabi=32 -print-libgcc-file-name`)
+else
+CROSSGCCOPT=-mabi=32
+endif
+endif
+ifeq ($(BINUTILSPREFIX),)
+ifeq ($(GCCLIBDIR),)
+GCCLIBDIR:=$(shell dirname `gcc -print-libgcc-file-name`)
+endif
+else
+ifeq ($(CROSSGCCOPT),)
+CROSSGCCOPT=-g
+endif
+endif
+endif
+ifdef FPCFPMAKE
+FPCFPMAKE_CPU_TARGET=$(shell $(FPCFPMAKE) -iTP)
+ifeq ($(CPU_TARGET),$(FPCFPMAKE_CPU_TARGET))
+FPCMAKEGCCLIBDIR:=$(GCCLIBDIR)
+else
+ifneq ($(filter $(FPCFPMAKE_CPU_TARGET),aarch64 powerpc64 riscv64 sparc64 x86_64 loongarch64),)
+FPCMAKE_CROSSGCCOPT=-m64
+else
+ifneq ($(filter $(FPCFPMAKE_CPU_TARGET),mips64 mips64el),)
+FPCMAKE_CROSSGCCOPT=-mabi=64
+else
+ifneq ($(filter $(FPCFPMAKE_CPU_TARGET),mips mipsel),)
+FPCMAKE_CROSSGCCOPT=-mabi=32
+else
+ifeq ($(FPCFPMAKE_CPU_TARGET),riscv64)
+FPCMAKE_CROSSGCCOPT=-mabi=lp64
+else
+ifeq ($(FPCFPMAKE_CPU_TARGET),riscv32)
+FPCMAKE_CROSSGCCOPT=-mabi=ilp32
+else
+ifeq ($(FPCFPMAKE_CPU_TARGET),loongarch64)
+FPCMAKE_CROSSGCCOPT=-mabi=lp64d
+else
+FPCMAKE_CROSSGCCOPT=-m32
+endif
+endif
+endif
+endif
+endif
+endif
+FPCMAKEGCCLIBDIR:=$(shell dirname `gcc $(FPCMAKE_CROSSGCCOPT) -print-libgcc-file-name`)
+endif
+endif
+ifndef FPCMAKEGCCLIBDIR
+FPCMAKEGCCLIBDIR:=$(shell dirname `gcc -print-libgcc-file-name`)
+endif
+ifndef GCCLIBDIR
+CROSSGCC=$(strip $(wildcard $(addsuffix /$(BINUTILSPREFIX)gcc$(SRCEXEEXT),$(SEARCHPATH))))
+ifneq ($(CROSSGCC),)
+GCCLIBDIR:=$(shell dirname `$(CROSSGCC) $(CROSSGCCOPT) -print-libgcc-file-name`)
+endif
+endif
+endif
+ifdef inUnix
+ifeq ($(OS_SOURCE),netbsd)
+OTHERLIBDIR:=/usr/pkg/lib
+endif
+export GCCLIBDIR FPCMAKEGCCLIBDIR OTHERLIBDIR
+endif
+BATCHEXT=.bat
+LOADEREXT=.as
+EXEEXT=.exe
+PPLEXT=.ppl
+PPUEXT=.ppu
+OEXT=.o
+LTOEXT=.bc
+ASMEXT=.s
+SMARTEXT=.sl
+STATICLIBEXT=.a
+SHAREDLIBEXT=.so
+SHAREDLIBPREFIX=libfp
+STATICLIBPREFIX=libp
+IMPORTLIBPREFIX=libimp
+RSTEXT=.rst
+EXEDBGEXT=.dbg
+ifeq ($(OS_TARGET),go32v1)
+STATICLIBPREFIX=
+SHORTSUFFIX=v1
+endif
+ifeq ($(OS_TARGET),go32v2)
+STATICLIBPREFIX=
+SHORTSUFFIX=dos
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),watcom)
+STATICLIBPREFIX=
+OEXT=.obj
+ASMEXT=.asm
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=wat
+IMPORTLIBPREFIX=
+endif
+ifneq ($(CPU_TARGET),jvm)
+ifeq ($(OS_TARGET),android)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=lnx
+endif
+endif
+ifeq ($(OS_TARGET),linux)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=lnx
+endif
+ifeq ($(OS_TARGET),dragonfly)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=df
+endif
+ifeq ($(OS_TARGET),freebsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=fbs
+endif
+ifeq ($(OS_TARGET),netbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=nbs
+endif
+ifeq ($(OS_TARGET),openbsd)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=obs
+endif
+ifeq ($(OS_TARGET),win32)
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=w32
+endif
+ifeq ($(OS_TARGET),os2)
+BATCHEXT=.cmd
+AOUTEXT=.out
+STATICLIBPREFIX=
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=os2
+ECHO=echo
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),emx)
+BATCHEXT=.cmd
+AOUTEXT=.out
+STATICLIBPREFIX=
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=emx
+ECHO=echo
+IMPORTLIBPREFIX=
+endif
+ifeq ($(OS_TARGET),amiga)
+EXEEXT=
+SHAREDLIBEXT=.library
+SHORTSUFFIX=amg
+endif
+ifeq ($(OS_TARGET),aros)
+EXEEXT=
+SHAREDLIBEXT=.library
+SHORTSUFFIX=aros
+endif
+ifeq ($(OS_TARGET),morphos)
+EXEEXT=
+SHAREDLIBEXT=.library
+SHORTSUFFIX=mos
+endif
+ifeq ($(OS_TARGET),atari)
+EXEEXT=.ttp
+SHORTSUFFIX=ata
+endif
+ifeq ($(OS_TARGET),beos)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=be
+endif
+ifeq ($(OS_TARGET),haiku)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=hai
+endif
+ifeq ($(OS_TARGET),solaris)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=sun
+endif
+ifeq ($(OS_TARGET),qnx)
+BATCHEXT=.sh
+EXEEXT=
+SHORTSUFFIX=qnx
+endif
+ifeq ($(OS_TARGET),netware)
+EXEEXT=.nlm
+STATICLIBPREFIX=
+SHORTSUFFIX=nw
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),netwlibc)
+EXEEXT=.nlm
+STATICLIBPREFIX=
+SHORTSUFFIX=nwl
+IMPORTLIBPREFIX=imp
+endif
+ifeq ($(OS_TARGET),macosclassic)
+BATCHEXT=
+EXEEXT=
+DEBUGSYMEXT=.xcoff
+SHORTSUFFIX=mac
+IMPORTLIBPREFIX=imp
+endif
+ifneq ($(filter $(OS_TARGET),darwin iphonesim ios),)
+BATCHEXT=.sh
+EXEEXT=
+HASSHAREDLIB=1
+SHORTSUFFIX=dwn
+EXEDBGEXT=.dSYM
+endif
+ifeq ($(OS_TARGET),gba)
+EXEEXT=.gba
+SHAREDLIBEXT=.so
+SHORTSUFFIX=gba
+endif
+ifeq ($(OS_TARGET),symbian)
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=symbian
+endif
+ifeq ($(OS_TARGET),NativeNT)
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=nativent
+endif
+ifeq ($(OS_TARGET),wii)
+EXEEXT=.dol
+SHAREDLIBEXT=.so
+SHORTSUFFIX=wii
+endif
+ifeq ($(OS_TARGET),aix)
+BATCHEXT=.sh
+EXEEXT=
+SHAREDLIBEXT=.a
+SHORTSUFFIX=aix
+endif
+ifeq ($(OS_TARGET),java)
+OEXT=.class
+ASMEXT=.j
+SHAREDLIBEXT=.jar
+SHORTSUFFIX=java
+endif
+ifeq ($(CPU_TARGET),jvm)
+ifeq ($(OS_TARGET),android)
+OEXT=.class
+ASMEXT=.j
+SHAREDLIBEXT=.jar
+SHORTSUFFIX=android
+endif
+endif
+ifeq ($(OS_TARGET),msdos)
+STATICLIBPREFIX=
+STATICLIBEXT=.a
+SHORTSUFFIX=d16
+endif
+ifeq ($(OS_TARGET),msxdos)
+STATICLIBPREFIX=
+STATICLIBEXT=.a
+SHORTSUFFIX=msd
+endif
+ifeq ($(OS_TARGET),embedded)
+ifeq ($(CPU_TARGET),i8086)
+STATICLIBPREFIX=
+STATICLIBEXT=.a
+else
+EXEEXT=.bin
+endif
+ifeq ($(CPU_TARGET),z80)
+OEXT=.rel
+endif
+SHORTSUFFIX=emb
+endif
+ifeq ($(OS_TARGET),win16)
+STATICLIBPREFIX=
+STATICLIBEXT=.a
+SHAREDLIBEXT=.dll
+SHORTSUFFIX=w16
+endif
+ifeq ($(OS_TARGET),zxspectrum)
+OEXT=.rel
+endif
+ifeq ($(OS_TARGET),wasi)
+EXEEXT=.wasm
+endif
+ifneq ($(filter $(OS_SOURCE),$(LIMIT83fs)),)
+FPCMADE=fpcmade.$(SHORTSUFFIX)
+ZIPSUFFIX=$(SHORTSUFFIX)
+ZIPCROSSPREFIX=
+ZIPSOURCESUFFIX=src
+ZIPEXAMPLESUFFIX=exm
+else
+FPCMADE=fpcmade.$(TARGETSUFFIX)
+ZIPSOURCESUFFIX=.source
+ZIPEXAMPLESUFFIX=.examples
+ifdef CROSSCOMPILE
+ZIPSUFFIX=.$(SOURCESUFFIX)
+ZIPCROSSPREFIX=$(TARGETSUFFIX)-
+else
+ZIPSUFFIX=.$(TARGETSUFFIX)
+ZIPCROSSPREFIX=
+endif
+endif
+ifndef ECHO
+ECHO:=$(strip $(wildcard $(addsuffix /gecho$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO:=$(strip $(wildcard $(addsuffix /echo$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ECHO),)
+ECHO= __missing_command_ECHO
+else
+ECHO:=$(firstword $(ECHO))
+endif
+else
+ECHO:=$(firstword $(ECHO))
+endif
+endif
+export ECHO
+ifndef DATE
+DATE:=$(strip $(wildcard $(addsuffix /gdate$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(DATE),)
+DATE:=$(strip $(wildcard $(addsuffix /date$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(DATE),)
+DATE= __missing_command_DATE
+else
+DATE:=$(firstword $(DATE))
+endif
+else
+DATE:=$(firstword $(DATE))
+endif
+endif
+export DATE
+ifndef GINSTALL
+GINSTALL:=$(strip $(wildcard $(addsuffix /ginstall$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(GINSTALL),)
+GINSTALL:=$(strip $(wildcard $(addsuffix /install$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(GINSTALL),)
+GINSTALL= __missing_command_GINSTALL
+else
+GINSTALL:=$(firstword $(GINSTALL))
+endif
+else
+GINSTALL:=$(firstword $(GINSTALL))
+endif
+endif
+export GINSTALL
+ifndef CPPROG
+CPPROG:=$(strip $(wildcard $(addsuffix /cp$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(CPPROG),)
+CPPROG= __missing_command_CPPROG
+else
+CPPROG:=$(firstword $(CPPROG))
+endif
+endif
+export CPPROG
+ifndef RMPROG
+RMPROG:=$(strip $(wildcard $(addsuffix /rm$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(RMPROG),)
+RMPROG= __missing_command_RMPROG
+else
+RMPROG:=$(firstword $(RMPROG))
+endif
+endif
+export RMPROG
+ifndef MVPROG
+MVPROG:=$(strip $(wildcard $(addsuffix /mv$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(MVPROG),)
+MVPROG= __missing_command_MVPROG
+else
+MVPROG:=$(firstword $(MVPROG))
+endif
+endif
+export MVPROG
+ifndef MKDIRPROG
+MKDIRPROG:=$(strip $(wildcard $(addsuffix /gmkdir$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(MKDIRPROG),)
+MKDIRPROG:=$(strip $(wildcard $(addsuffix /mkdir$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(MKDIRPROG),)
+MKDIRPROG= __missing_command_MKDIRPROG
+else
+MKDIRPROG:=$(firstword $(MKDIRPROG))
+endif
+else
+MKDIRPROG:=$(firstword $(MKDIRPROG))
+endif
+endif
+export MKDIRPROG
+ifndef ECHOREDIR
+ifndef inUnix
+ECHOREDIR=echo
+else
+ECHOREDIR=$(ECHO)
+endif
+endif
+ifndef COPY
+COPY:=$(CPPROG) -fp
+endif
+ifndef COPYTREE
+COPYTREE:=$(CPPROG) -Rfp
+endif
+ifndef MKDIRTREE
+MKDIRTREE:=$(MKDIRPROG) -p
+endif
+ifndef MOVE
+MOVE:=$(MVPROG) -f
+endif
+ifndef DEL
+DEL:=$(RMPROG) -f
+endif
+ifndef DELTREE
+DELTREE:=$(RMPROG) -rf
+endif
+ifndef INSTALL
+ifdef inUnix
+INSTALL:=$(GINSTALL) -c -m 644
+else
+INSTALL:=$(COPY)
+endif
+endif
+ifndef INSTALLEXE
+ifdef inUnix
+INSTALLEXE:=$(GINSTALL) -c -m 755
+else
+INSTALLEXE:=$(COPY)
+endif
+endif
+ifndef MKDIR
+MKDIR:=$(GINSTALL) -m 755 -d
+endif
+export ECHOREDIR COPY COPYTREE MOVE DEL DELTREE INSTALL INSTALLEXE MKDIR
+ifndef PPUMOVE
+PPUMOVE:=$(strip $(wildcard $(addsuffix /ppumove$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(PPUMOVE),)
+PPUMOVE= __missing_command_PPUMOVE
+else
+PPUMOVE:=$(firstword $(PPUMOVE))
+endif
+endif
+export PPUMOVE
+ifndef FPCMAKE
+FPCMAKE:=$(strip $(wildcard $(addsuffix /fpcmake$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(FPCMAKE),)
+FPCMAKE= __missing_command_FPCMAKE
+else
+FPCMAKE:=$(firstword $(FPCMAKE))
+endif
+endif
+export FPCMAKE
+ifndef ZIPPROG
+ZIPPROG:=$(strip $(wildcard $(addsuffix /zip$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(ZIPPROG),)
+ZIPPROG= __missing_command_ZIPPROG
+else
+ZIPPROG:=$(firstword $(ZIPPROG))
+endif
+endif
+export ZIPPROG
+ifndef TARPROG
+TARPROG:=$(strip $(wildcard $(addsuffix /gtar$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(TARPROG),)
+TARPROG:=$(strip $(wildcard $(addsuffix /tar$(SRCEXEEXT),$(SEARCHPATH))))
+ifeq ($(TARPROG),)
+TARPROG= __missing_command_TARPROG
+else
+TARPROG:=$(firstword $(TARPROG))
+endif
+else
+TARPROG:=$(firstword $(TARPROG))
+endif
+endif
+export TARPROG
+ASNAME=$(BINUTILSPREFIX)as
+LDNAME=$(BINUTILSPREFIX)ld
+ARNAME=$(BINUTILSPREFIX)ar
+RCNAME=$(BINUTILSPREFIX)rc
+NASMNAME=$(BINUTILSPREFIX)nasm
+ifndef ASPROG
+ifdef CROSSBINDIR
+ASPROG=$(CROSSBINDIR)/$(ASNAME)$(SRCEXEEXT)
+else
+ASPROG=$(ASNAME)
+endif
+endif
+ifndef LDPROG
+ifdef CROSSBINDIR
+LDPROG=$(CROSSBINDIR)/$(LDNAME)$(SRCEXEEXT)
+else
+LDPROG=$(LDNAME)
+endif
+endif
+ifndef RCPROG
+ifdef CROSSBINDIR
+RCPROG=$(CROSSBINDIR)/$(RCNAME)$(SRCEXEEXT)
+else
+RCPROG=$(RCNAME)
+endif
+endif
+ifndef ARPROG
+ifdef CROSSBINDIR
+ARPROG=$(CROSSBINDIR)/$(ARNAME)$(SRCEXEEXT)
+else
+ARPROG=$(ARNAME)
+endif
+endif
+ifndef NASMPROG
+ifdef CROSSBINDIR
+NASMPROG=$(CROSSBINDIR)/$(NASMNAME)$(SRCEXEEXT)
+else
+NASMPROG=$(NASMNAME)
+endif
+endif
+AS=$(ASPROG)
+LD=$(LDPROG)
+RC=$(RCPROG)
+AR=$(ARPROG)
+NASM=$(NASMPROG)
+ifdef inUnix
+PPAS=./ppas$(SRCBATCHEXT)
+else
+PPAS=ppas$(SRCBATCHEXT)
+endif
+ifdef inUnix
+LDCONFIG=ldconfig
+else
+LDCONFIG=
+endif
+ifdef DATE
+DATESTR:=$(shell $(DATE) +%Y%m%d)
+else
+DATESTR=
+endif
+ZIPOPT=-9
+ZIPEXT=.zip
+ifeq ($(USETAR),bz2)
+TAROPT=vj
+TAREXT=.tar.bz2
+else
+TAROPT=vz
+TAREXT=.tar.gz
+endif
+ifndef NOCPUDEF
+override FPCOPTDEF=$(ARCH)
+endif
+ifneq ($(OS_TARGET),$(OS_SOURCE))
+override FPCOPT+=-T$(OS_TARGET)
+endif
+ifneq ($(CPU_TARGET),$(CPU_SOURCE))
+override FPCOPT+=-P$(ARCH)
+endif
+ifeq ($(OS_SOURCE),openbsd)
+override FPCOPT+=-FD$(NEW_BINUTILS_PATH)
+override FPCMAKEOPT+=-FD$(NEW_BINUTILS_PATH)
+override FPMAKE_BUILD_OPT+=-FD$(NEW_BINUTILS_PATH)
+endif
+ifndef CROSSBOOTSTRAP
+ifneq ($(BINUTILSPREFIX),)
+override FPCOPT+=-XP$(BINUTILSPREFIX)
+ifneq ($(RLINKPATH),)
+override FPCOPT+=-Xr$(RLINKPATH)
+endif
+endif
+endif
+ifndef CROSSCOMPILE
+ifneq ($(BINUTILSPREFIX),)
+override FPCMAKEOPT+=-XP$(BINUTILSPREFIX)
+override FPMAKE_BUILD_OPT+=-XP$(BINUTILSPREFIX)
+endif
+endif
+ifdef UNITDIR
+override FPCOPT+=$(addprefix -Fu,$(UNITDIR))
+endif
+ifdef LIBDIR
+override FPCOPT+=$(addprefix -Fl,$(LIBDIR))
+endif
+ifdef OBJDIR
+override FPCOPT+=$(addprefix -Fo,$(OBJDIR))
+endif
+ifdef INCDIR
+override FPCOPT+=$(addprefix -Fi,$(INCDIR))
+endif
+ifdef LINKSMART
+override FPCOPT+=-XX
+endif
+ifdef CREATESMART
+override FPCOPT+=-CX
+endif
+ifdef DEBUG
+override FPCOPT+=-gl
+override FPCOPTDEF+=DEBUG
+endif
+ifdef RELEASE
+FPCCPUOPT:=-O2
+override FPCOPT+=-Ur -Xs $(FPCCPUOPT) -n
+override FPCOPTDEF+=RELEASE
+endif
+ifdef STRIP
+override FPCOPT+=-Xs
+endif
+ifdef OPTIMIZE
+override FPCOPT+=-O2
+endif
+ifdef VERBOSE
+override FPCOPT+=-vwni
+endif
+ifdef COMPILER_OPTIONS
+override FPCOPT+=$(COMPILER_OPTIONS)
+endif
+ifdef COMPILER_UNITDIR
+override FPCOPT+=$(addprefix -Fu,$(COMPILER_UNITDIR))
+endif
+ifdef COMPILER_LIBRARYDIR
+override FPCOPT+=$(addprefix -Fl,$(COMPILER_LIBRARYDIR))
+endif
+ifdef COMPILER_OBJECTDIR
+override FPCOPT+=$(addprefix -Fo,$(COMPILER_OBJECTDIR))
+endif
+ifdef COMPILER_INCLUDEDIR
+override FPCOPT+=$(addprefix -Fi,$(COMPILER_INCLUDEDIR))
+endif
+ifdef CROSSBINDIR
+override FPCOPT+=-FD$(CROSSBINDIR)
+endif
+ifdef COMPILER_TARGETDIR
+override FPCOPT+=-FE$(COMPILER_TARGETDIR)
+ifeq ($(COMPILER_TARGETDIR),.)
+override TARGETDIRPREFIX=
+else
+override TARGETDIRPREFIX=$(COMPILER_TARGETDIR)/
+endif
+endif
+ifdef COMPILER_UNITTARGETDIR
+override FPCOPT+=-FU$(COMPILER_UNITTARGETDIR)
+ifeq ($(COMPILER_UNITTARGETDIR),.)
+override UNITTARGETDIRPREFIX=
+else
+override UNITTARGETDIRPREFIX=$(COMPILER_UNITTARGETDIR)/
+endif
+else
+ifdef COMPILER_TARGETDIR
+override COMPILER_UNITTARGETDIR=$(COMPILER_TARGETDIR)
+override UNITTARGETDIRPREFIX=$(TARGETDIRPREFIX)
+endif
+endif
+ifdef SYSROOTPATH
+override FPCOPT+=-XR$(SYSROOTPATH)
+else
+ifeq ($(OS_TARGET),$(OS_SOURCE))
+ifeq ($(OS_TARGET),darwin)
+ifeq ($(CPU_TARGET),aarch64)
+ifneq ($(wildcard /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk),)
+override FPCOPT+=-XR/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
+endif
+endif
+endif
+endif
+endif
+ifdef CREATESHARED
+override FPCOPT+=-Cg
+endif
+ifneq ($(filter $(OS_TARGET),dragonfly freebsd openbsd netbsd linux solaris),)
+ifneq ($(filter $(CPU_TARGET),x86_64 mips mipsel mips64 mips64el riscv64 powerpc64),)
+override FPCOPT+=-Cg
+endif
+endif
+ifneq ($(filter $(CPU_TARGET),z80),)
+override FPCOPT+=-CX -XX
+endif
+ifdef LINKSHARED
+endif
+ifdef GCCLIBDIR
+override FPCOPT+=-Fl$(GCCLIBDIR)
+ifdef FPCMAKEGCCLIBDIR
+override FPCMAKEOPT+=-Fl$(FPCMAKEGCCLIBDIR)
+else
+override FPCMAKEOPT+=-Fl$(GCCLIBDIR)
+endif
+endif
+ifdef OTHERLIBDIR
+override FPCOPT+=$(addprefix -Fl,$(OTHERLIBDIR))
+endif
+ifdef OPT
+override FPCOPT+=$(OPT)
+endif
+ifdef FPMAKEBUILDOPT
+override FPMAKE_BUILD_OPT+=$(FPMAKEBUILDOPT)
+endif
+ifdef FPCOPTDEF
+override FPCOPT+=$(addprefix -d,$(FPCOPTDEF))
+endif
+ifdef CFGFILE
+override FPCOPT+=@$(CFGFILE)
+endif
+ifdef USEENV
+override FPCEXTCMD:=$(FPCOPT)
+override FPCOPT:=!FPCEXTCMD
+export FPCEXTCMD
+endif
+override AFULL_TARGET=$(CPU_TARGET)-$(OS_TARGET)
+override AFULL_SOURCE=$(CPU_SOURCE)-$(OS_SOURCE)
+ifneq ($(AFULL_TARGET),$(AFULL_SOURCE))
+override ACROSSCOMPILE=1
+endif
+ifdef ACROSSCOMPILE
+override FPCOPT+=$(CROSSOPT)
+endif
+override COMPILER:=$(strip $(FPC) $(FPCOPT))
+ifneq (,$(filter -sh,$(COMPILER)))
+UseEXECPPAS=1
+endif
+ifneq (,$(filter -s,$(COMPILER)))
+ifeq ($(FULL_SOURCE),$(FULL_TARGET))
+UseEXECPPAS=1
+endif
+endif
+ifneq ($(UseEXECPPAS),1)
+EXECPPAS=
+else
+ifdef RUNBATCH
+EXECPPAS:=@$(RUNBATCH) $(PPAS)
+else
+EXECPPAS:=@$(PPAS)
+endif
+endif
+.PHONY: fpc_units
+ifneq ($(TARGET_UNITS)$(TARGET_IMPLICITUNITS),)
+override ALLTARGET+=fpc_units
+override UNITPPUFILES=$(addsuffix $(PPUEXT),$(TARGET_UNITS))
+override IMPLICITUNITPPUFILES=$(addsuffix $(PPUEXT),$(TARGET_IMPLICITUNITS))
+override INSTALLPPUFILES+=$(UNITPPUFILES) $(IMPLICITUNITPPUFILES)
+override CLEANPPUFILES+=$(UNITPPUFILES) $(IMPLICITUNITPPUFILES)
+endif
+fpc_units: $(COMPILER_UNITTARGETDIR) $(UNITPPUFILES)
+ifdef TARGET_RSTS
+override RSTFILES=$(addsuffix $(RSTEXT),$(TARGET_RSTS))
+override CLEANRSTFILES+=$(RSTFILES)
+endif
+.PHONY: fpc_all fpc_smart fpc_debug fpc_release fpc_shared
+$(FPCMADE): $(ALLDEPENDENCIES) $(ALLTARGET)
+	@$(ECHOREDIR) Compiled > $(FPCMADE)
+fpc_all: $(FPCMADE)
+fpc_smart:
+	$(MAKE) all LINKSMART=1 CREATESMART=1
+fpc_debug:
+	$(MAKE) all DEBUG=1
+fpc_release:
+	$(MAKE) all RELEASE=1
+.SUFFIXES: $(EXEEXT) $(PPUEXT) $(OEXT) $(LTOEXT) .pas .lpr .dpr .pp .rc .res
+$(COMPILER_UNITTARGETDIR):
+	$(MKDIRTREE) $(COMPILER_UNITTARGETDIR)
+$(COMPILER_TARGETDIR):
+	$(MKDIRTREE) $(COMPILER_TARGETDIR)
+%$(PPUEXT): %.pp
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(PPUEXT): %.pas
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.pp
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.pas
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.lpr
+	$(COMPILER) $<
+	$(EXECPPAS)
+%$(EXEEXT): %.dpr
+	$(COMPILER) $<
+	$(EXECPPAS)
+%.res: %.rc
+	windres -i $< -o $@
+vpath %.pp $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.pas $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.lpr $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.dpr $(COMPILER_SOURCEDIR) $(COMPILER_INCLUDEDIR)
+vpath %.inc $(COMPILER_INCLUDEDIR)
+vpath %$(OEXT) $(COMPILER_UNITTARGETDIR)
+vpath %$(LTOEXT) $(COMPILER_UNITTARGETDIR)
+vpath %$(PPUEXT) $(COMPILER_UNITTARGETDIR)
+.PHONY: fpc_shared
+override INSTALLTARGET+=fpc_shared_install
+ifndef SHARED_LIBVERSION
+SHARED_LIBVERSION=$(FPC_VERSION)
+endif
+ifndef SHARED_LIBNAME
+SHARED_LIBNAME=$(PACKAGE_NAME)
+endif
+ifndef SHARED_FULLNAME
+SHARED_FULLNAME=$(SHAREDLIBPREFIX)$(SHARED_LIBNAME)-$(SHARED_LIBVERSION)$(SHAREDLIBEXT)
+endif
+ifndef SHARED_LIBUNITS
+SHARED_LIBUNITS:=$(TARGET_UNITS) $(TARGET_IMPLICITUNITS)
+override SHARED_LIBUNITS:=$(filter-out $(INSTALL_BUILDUNIT),$(SHARED_LIBUNITS))
+endif
+fpc_shared:
+ifdef HASSHAREDLIB
+	$(MAKE) all CREATESHARED=1 LINKSHARED=1 CREATESMART=1
+ifneq ($(SHARED_BUILD),n)
+	$(PPUMOVE) -q $(SHARED_LIBUNITS) -i$(COMPILER_UNITTARGETDIR) -o$(SHARED_FULLNAME) -d$(COMPILER_UNITTARGETDIR) -P$(BINUTILSPREFIX)
+endif
+else
+	@$(ECHO) Shared Libraries not supported
+endif
+fpc_shared_install:
+ifneq ($(SHARED_BUILD),n)
+ifneq ($(SHARED_LIBUNITS),)
+ifneq ($(wildcard $(COMPILER_UNITTARGETDIR)/$(SHARED_FULLNAME)),)
+	$(INSTALL) $(COMPILER_UNITTARGETDIR)/$(SHARED_FULLNAME) $(INSTALL_SHAREDDIR)
+endif
+endif
+endif
+.PHONY: fpc_install fpc_sourceinstall fpc_exampleinstall
+ifdef INSTALL_UNITS
+override INSTALLPPUFILES+=$(addsuffix $(PPUEXT),$(INSTALL_UNITS))
+endif
+ifdef INSTALL_BUILDUNIT
+override INSTALLPPUFILES:=$(filter-out $(INSTALL_BUILDUNIT)$(PPUEXT),$(INSTALLPPUFILES))
+endif
+ifdef INSTALLPPUFILES
+ifneq ($(IMPORTLIBPREFIX)-$(STATICLIBEXT),$(STATICLIBPREFIX)-$(STATICLIBEXT))
+override INSTALLPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(INSTALLPPUFILES)) $(subst $(PPUEXT),$(LTOEXT),$(INSTALLPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES))) $(addprefix $(IMPORTLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES)))
+else
+override INSTALLPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(INSTALLPPUFILES)) $(subst $(PPUEXT),$(LTOEXT),$(INSTALLPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(INSTALLPPUFILES)))
+endif
+ifneq ($(UNITTARGETDIRPREFIX),)
+override INSTALLPPUFILENAMES:=$(notdir $(INSTALLPPUFILES))
+override INSTALLPPULINKFILENAMES:=$(notdir $(INSTALLPPULINKFILES))
+override INSTALLPPUFILES=$(addprefix $(UNITTARGETDIRPREFIX),$(INSTALLPPUFILENAMES))
+override INSTALLPPULINKFILES=$(wildcard $(addprefix $(UNITTARGETDIRPREFIX),$(INSTALLPPULINKFILENAMES)))
+endif
+override INSTALL_CREATEPACKAGEFPC=1
+endif
+ifdef INSTALLEXEFILES
+ifneq ($(TARGETDIRPREFIX),)
+override INSTALLEXEFILES:=$(addprefix $(TARGETDIRPREFIX),$(notdir $(INSTALLEXEFILES)))
+endif
+endif
+fpc_install: all $(INSTALLTARGET)
+ifdef INSTALLEXEFILES
+	$(MKDIR) $(INSTALL_BINDIR)
+	$(INSTALLEXE) $(INSTALLEXEFILES) $(INSTALL_BINDIR)
+endif
+ifdef INSTALL_CREATEPACKAGEFPC
+ifdef FPCMAKE
+ifdef PACKAGE_VERSION
+ifneq ($(wildcard Makefile.fpc),)
+	$(FPCMAKE) -p -T$(CPU_TARGET)-$(OS_TARGET) Makefile.fpc
+	$(MKDIR) $(INSTALL_UNITDIR)
+	$(INSTALL) Package.fpc $(INSTALL_UNITDIR)
+endif
+endif
+endif
+endif
+ifdef INSTALLPPUFILES
+	$(MKDIR) $(INSTALL_UNITDIR)
+	$(INSTALL) $(INSTALLPPUFILES) $(INSTALL_UNITDIR)
+ifneq ($(INSTALLPPULINKFILES),)
+	$(INSTALL) $(INSTALLPPULINKFILES) $(INSTALL_UNITDIR)
+endif
+ifneq ($(wildcard $(LIB_FULLNAME)),)
+	$(MKDIR) $(INSTALL_LIBDIR)
+	$(INSTALL) $(LIB_FULLNAME) $(INSTALL_LIBDIR)
+ifdef inUnix
+	ln -sf $(LIB_FULLNAME) $(INSTALL_LIBDIR)/$(LIB_NAME)
+endif
+endif
+endif
+ifdef INSTALL_FILES
+	$(MKDIR) $(INSTALL_DATADIR)
+	$(INSTALL) $(INSTALL_FILES) $(INSTALL_DATADIR)
+endif
+fpc_sourceinstall: distclean
+	$(MKDIR) $(INSTALL_SOURCEDIR)
+	$(COPYTREE) $(BASEDIR)/* $(INSTALL_SOURCEDIR)
+fpc_exampleinstall: $(EXAMPLEINSTALLTARGET) $(addsuffix _distclean,$(TARGET_EXAMPLEDIRS))
+ifdef HASEXAMPLES
+	$(MKDIR) $(INSTALL_EXAMPLEDIR)
+endif
+ifdef EXAMPLESOURCEFILES
+	$(COPY) $(EXAMPLESOURCEFILES) $(INSTALL_EXAMPLEDIR)
+endif
+ifdef TARGET_EXAMPLEDIRS
+	$(COPYTREE) $(addsuffix /*,$(TARGET_EXAMPLEDIRS)) $(INSTALL_EXAMPLEDIR)
+endif
+.PHONY: fpc_clean fpc_cleanall fpc_distclean
+ifdef EXEFILES
+override CLEANEXEFILES:=$(addprefix $(TARGETDIRPREFIX),$(CLEANEXEFILES))
+override CLEANEXEDBGFILES:=$(addprefix $(TARGETDIRPREFIX),$(CLEANEXEDBGFILES))
+endif
+ifdef CLEAN_PROGRAMS
+override CLEANEXEFILES+=$(addprefix $(TARGETDIRPREFIX),$(addsuffix $(EXEEXT), $(CLEAN_PROGRAMS)))
+override CLEANEXEDBGFILES+=$(addprefix $(TARGETDIRPREFIX),$(addsuffix $(EXEDBGEXT), $(CLEAN_PROGRAMS)))
+endif
+ifdef CLEAN_UNITS
+override CLEANPPUFILES+=$(addsuffix $(PPUEXT),$(CLEAN_UNITS))
+endif
+ifdef CLEANPPUFILES
+override CLEANPPULINKFILES:=$(subst $(PPUEXT),$(OEXT),$(CLEANPPUFILES)) $(subst $(PPUEXT),$(LTOEXT),$(CLEANPPUFILES)) $(addprefix $(STATICLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(CLEANPPUFILES))) $(addprefix $(IMPORTLIBPREFIX),$(subst $(PPUEXT),$(STATICLIBEXT),$(CLEANPPUFILES)))
+ifdef DEBUGSYMEXT
+override CLEANPPULINKFILES+=$(subst $(PPUEXT),$(DEBUGSYMEXT),$(CLEANPPUFILES))
+endif
+override CLEANPPUFILENAMES:=$(CLEANPPUFILES)
+override CLEANPPUFILES=$(addprefix $(UNITTARGETDIRPREFIX),$(CLEANPPUFILENAMES))
+override CLEANPPULINKFILENAMES:=$(CLEANPPULINKFILES)
+override CLEANPPULINKFILES=$(wildcard $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANPPULINKFILENAMES)))
+endif
+fpc_clean: $(CLEANTARGET)
+ifdef CLEANEXEFILES
+	-$(DEL) $(CLEANEXEFILES)
+endif
+ifdef CLEANEXEDBGFILES
+	-$(DELTREE) $(CLEANEXEDBGFILES)
+endif
+ifdef CLEANPPUFILES
+	-$(DEL) $(CLEANPPUFILES)
+endif
+ifneq ($(CLEANPPULINKFILES),)
+	-$(DEL) $(CLEANPPULINKFILES)
+endif
+ifdef CLEANRSTFILES
+	-$(DEL) $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANRSTFILES))
+endif
+ifdef CLEAN_FILES
+	-$(DEL) $(CLEAN_FILES)
+endif
+ifdef LIB_NAME
+	-$(DEL) $(LIB_NAME) $(LIB_FULLNAME)
+endif
+	-$(DEL) $(FPCMADE) *$(FULL_TARGET).fpm Package.fpc *$(ASMEXT)
+	-$(DEL) $(FPCEXTFILE) $(REDIRFILE) script*.res link*.res *_script.res *_link.res
+	-$(DEL) $(PPAS) *_ppas$(BATCHEXT) ppas$(BATCHEXT) ppaslink$(BATCHEXT)
+fpc_cleanall: $(CLEANTARGET)
+ifdef CLEANEXEFILES
+	-$(DEL) $(CLEANEXEFILES)
+endif
+ifdef COMPILER_UNITTARGETDIR
+ifdef CLEANPPUFILES
+	-$(DEL) $(CLEANPPUFILES)
+endif
+ifneq ($(CLEANPPULINKFILES),)
+	-$(DEL) $(CLEANPPULINKFILES)
+endif
+ifdef CLEANRSTFILES
+	-$(DEL) $(addprefix $(UNITTARGETDIRPREFIX),$(CLEANRSTFILES))
+endif
+endif
+ifdef CLEAN_FILES
+	-$(DEL) $(CLEAN_FILES)
+endif
+	-$(DELTREE) units
+	-$(DELTREE) bin
+	-$(DEL) *$(OEXT) *$(LTOEXT) *$(PPUEXT) *$(RSTEXT) *$(ASMEXT) *$(STATICLIBEXT) *$(SHAREDLIBEXT) *$(PPLEXT)
+ifneq ($(PPUEXT),.ppu)
+	-$(DEL) *.o *.ppu *.a
+endif
+	-$(DELTREE) *$(SMARTEXT)
+	-$(DEL) fpcmade.* Package.fpc *.fpm
+	-$(DEL) $(FPCEXTFILE) $(REDIRFILE) script*.res link*.res *_script.res *_link.res
+	-$(DEL) $(PPAS) *_ppas$(BATCHEXT) ppas$(BATCHEXT) ppaslink$(BATCHEXT)
+ifdef AOUTEXT
+	-$(DEL) *$(AOUTEXT)
+endif
+ifdef DEBUGSYMEXT
+	-$(DEL) *$(DEBUGSYMEXT)
+endif
+ifdef LOCALFPMAKEBIN
+	-$(DEL) $(LOCALFPMAKEBIN)
+	-$(DEL) $(FPMAKEBINOBJ)
+endif
+fpc_distclean: cleanall
+.PHONY: fpc_baseinfo
+override INFORULES+=fpc_baseinfo
+fpc_baseinfo:
+	@$(ECHO)
+	@$(ECHO)  == Package info ==
+	@$(ECHO)  Package Name..... $(PACKAGE_NAME)
+	@$(ECHO)  Package Version.. $(PACKAGE_VERSION)
+	@$(ECHO)
+	@$(ECHO)  == Configuration info ==
+	@$(ECHO)
+	@$(ECHO)  FPC.......... $(FPC)
+	@$(ECHO)  FPC Version.. $(FPC_VERSION)
+	@$(ECHO)  Source CPU... $(CPU_SOURCE)
+	@$(ECHO)  Target CPU... $(CPU_TARGET)
+	@$(ECHO)  Source OS.... $(OS_SOURCE)
+	@$(ECHO)  Target OS.... $(OS_TARGET)
+	@$(ECHO)  Full Source.. $(FULL_SOURCE)
+	@$(ECHO)  Full Target.. $(FULL_TARGET)
+	@$(ECHO)  SourceSuffix. $(SOURCESUFFIX)
+	@$(ECHO)  TargetSuffix. $(TARGETSUFFIX)
+	@$(ECHO)  FPC fpmake... $(FPCFPMAKE)
+	@$(ECHO)
+	@$(ECHO)  == Directory info ==
+	@$(ECHO)
+	@$(ECHO)  Required pkgs... $(REQUIRE_PACKAGES)
+	@$(ECHO)
+	@$(ECHO)  Basedir......... $(BASEDIR)
+	@$(ECHO)  FPCDir.......... $(FPCDIR)
+	@$(ECHO)  CrossBinDir..... $(CROSSBINDIR)
+	@$(ECHO)  UnitsDir........ $(UNITSDIR)
+	@$(ECHO)  PackagesDir..... $(PACKAGESDIR)
+	@$(ECHO)
+	@$(ECHO)  GCC library..... $(GCCLIBDIR)
+	@$(ECHO)  Other library... $(OTHERLIBDIR)
+	@$(ECHO)
+	@$(ECHO)  == Tools info ==
+	@$(ECHO)
+	@$(ECHO)  As........ $(AS)
+	@$(ECHO)  Ld........ $(LD)
+	@$(ECHO)  Ar........ $(AR)
+	@$(ECHO)  Rc........ $(RC)
+	@$(ECHO)
+	@$(ECHO)  Mv........ $(MVPROG)
+	@$(ECHO)  Cp........ $(CPPROG)
+	@$(ECHO)  Rm........ $(RMPROG)
+	@$(ECHO)  GInstall.. $(GINSTALL)
+	@$(ECHO)  Echo...... $(ECHO)
+	@$(ECHO)  Shell..... $(SHELL)
+	@$(ECHO)  Date...... $(DATE)
+	@$(ECHO)  FPCMake... $(FPCMAKE)
+	@$(ECHO)  PPUMove... $(PPUMOVE)
+	@$(ECHO)  Zip....... $(ZIPPROG)
+	@$(ECHO)
+	@$(ECHO)  == Object info ==
+	@$(ECHO)
+	@$(ECHO)  Target Loaders........ $(TARGET_LOADERS)
+	@$(ECHO)  Target Units.......... $(TARGET_UNITS)
+	@$(ECHO)  Target Implicit Units. $(TARGET_IMPLICITUNITS)
+	@$(ECHO)  Target Programs....... $(TARGET_PROGRAMS)
+	@$(ECHO)  Target Dirs........... $(TARGET_DIRS)
+	@$(ECHO)  Target Examples....... $(TARGET_EXAMPLES)
+	@$(ECHO)  Target ExampleDirs.... $(TARGET_EXAMPLEDIRS)
+	@$(ECHO)
+	@$(ECHO)  Clean Units......... $(CLEAN_UNITS)
+	@$(ECHO)  Clean Files......... $(CLEAN_FILES)
+	@$(ECHO)
+	@$(ECHO)  Install Units....... $(INSTALL_UNITS)
+	@$(ECHO)  Install Files....... $(INSTALL_FILES)
+	@$(ECHO)
+	@$(ECHO)  == Install info ==
+	@$(ECHO)
+	@$(ECHO)  DateStr.............. $(DATESTR)
+	@$(ECHO)  ZipName.............. $(ZIPNAME)
+	@$(ECHO)  ZipPrefix............ $(ZIPPREFIX)
+	@$(ECHO)  ZipCrossPrefix....... $(ZIPCROSSPREFIX)
+	@$(ECHO)  ZipSuffix............ $(ZIPSUFFIX)
+	@$(ECHO)  FullZipName.......... $(FULLZIPNAME)
+	@$(ECHO)  Install FPC Package.. $(INSTALL_FPCPACKAGE)
+	@$(ECHO)
+	@$(ECHO)  Install base dir..... $(INSTALL_BASEDIR)
+	@$(ECHO)  Install binary dir... $(INSTALL_BINDIR)
+	@$(ECHO)  Install library dir.. $(INSTALL_LIBDIR)
+	@$(ECHO)  Install units dir.... $(INSTALL_UNITDIR)
+	@$(ECHO)  Install source dir... $(INSTALL_SOURCEDIR)
+	@$(ECHO)  Install doc dir...... $(INSTALL_DOCDIR)
+	@$(ECHO)  Install example dir.. $(INSTALL_EXAMPLEDIR)
+	@$(ECHO)  Install data dir..... $(INSTALL_DATADIR)
+	@$(ECHO)
+	@$(ECHO)  Dist destination dir. $(DIST_DESTDIR)
+	@$(ECHO)  Dist zip name........ $(DIST_ZIPNAME)
+	@$(ECHO)
+.PHONY: fpc_info
+fpc_info: $(INFORULES)
+.PHONY: fpc_makefile fpc_makefiles fpc_makefile_sub1 fpc_makefile_sub2 \
+	fpc_makefile_dirs
+fpc_makefile:
+	$(FPCMAKE) -w -T$(OS_TARGET) Makefile.fpc
+fpc_makefile_sub1:
+ifdef TARGET_DIRS
+	$(FPCMAKE) -w -T$(OS_TARGET) $(addsuffix /Makefile.fpc,$(TARGET_DIRS))
+endif
+ifdef TARGET_EXAMPLEDIRS
+	$(FPCMAKE) -w -T$(OS_TARGET) $(addsuffix /Makefile.fpc,$(TARGET_EXAMPLEDIRS))
+endif
+fpc_makefile_sub2: $(addsuffix _makefile_dirs,$(TARGET_DIRS) $(TARGET_EXAMPLEDIRS))
+fpc_makefile_dirs: fpc_makefile_sub1 fpc_makefile_sub2
+fpc_makefiles: fpc_makefile fpc_makefile_dirs
+all: fpc_all
+debug: fpc_debug
+smart: fpc_smart
+release: fpc_release
+units: fpc_units
+examples:
+shared: fpc_shared
+install: fpc_install
+sourceinstall: fpc_sourceinstall
+exampleinstall: fpc_exampleinstall
+distinstall:
+zipinstall:
+zipsourceinstall:
+zipexampleinstall:
+zipdistinstall:
+clean: fpc_clean
+distclean: fpc_distclean
+cleanall: fpc_cleanall
+info: fpc_info
+makefiles: fpc_makefiles
+.PHONY: all debug smart release units examples shared install sourceinstall exampleinstall distinstall zipinstall zipsourceinstall zipexampleinstall zipdistinstall clean distclean cleanall info makefiles
+ifneq ($(wildcard fpcmake.loc),)
+include fpcmake.loc
+endif
+include $(INC)/makefile.inc
+SYSINCDEPS=$(addprefix $(INC)/,$(SYSINCNAMES))
+include $(PROCINC)/makefile.cpu
+SYSCPUDEPS=$(addprefix $(PROCINC)/,$(CPUINCNAMES))
+SYSDEPS=$(SYSINCDEPS) $(SYSCPUDEPS)
+strt$(PPUEXT) : $(SYSTEMUNIT)$(PPUEXT)
+	$(COMPILER) strt.pp

rtl/ps1/Makefile.fpc

@@ -0,0 +1,56 @@
+#
+#   Makefile.fpc for MIPSEL PlayStation 1
+#
+[package]
+main=rtl
+[target]
+loaders=
+units=$(SYSTEMUNIT) strt
+
+[require]
+nortl=y
+[install]
+fpcpackage=y
+[default]
+target=ps1
+cpu=mipsel
+[compiler]
+includedir=$(INC) $(PROCINC)
+sourcedir=$(INC) $(PROCINC) $(COMMON)
+[prerules]
+RTL=..
+INC=../inc
+COMMON=$(RTL)/common
+PROCINC=../$(CPU_TARGET)
+UNITPREFIX=rtl
+
+# Paths
+OBJPASDIR=$(RTL)/objpas
+# Insert exception handler in system unit
+ifdef EXCEPTIONS_IN_SYSTEM
+override FPCOPT+=-dEXCEPTIONS_IN_SYSTEM
+endif
+# Insert exception handler in system unit
+ifdef NO_EXCEPTIONS_IN_SYSTEM
+override FPCOPT+=-dNO_EXCEPTIONS_IN_SYSTEM
+endif
+[rules]
+# Get the system independent include file names.
+# This will set the following variables :
+# SYSINCNAMES
+include $(INC)/makefile.inc
+SYSINCDEPS=$(addprefix $(INC)/,$(SYSINCNAMES))
+# Get the processor dependent include file names.
+# This will set the following variables :
+# CPUINCNAMES
+include $(PROCINC)/makefile.cpu
+SYSCPUDEPS=$(addprefix $(PROCINC)/,$(CPUINCNAMES))
+# Put system unit dependencies together.
+SYSDEPS=$(SYSINCDEPS) $(SYSCPUDEPS)
+
+#
+# Loaders
+#
+
+strt$(PPUEXT) : $(SYSTEMUNIT)$(PPUEXT)
+        $(COMPILER) strt.pp

rtl/ps1/rtl.cfg

@@ -0,0 +1,24 @@
+ -Sf-
+ -SfHEAP
+ -SfINITFINAL
+ -SfCLASSES
+ -SfEXCEPTIONS
+ -SfEXITCODE
+ -SfANSISTRINGS
+ -SfWIDESTRINGS
+ -SfTEXTIO
+# -SfCONSOLEIO
+ -SfFILEIO
+ -SfRANDOM
+ -SfVARIANTS
+ -SfOBJECTS
+ -SfDYNARRAYS
+ -SfTHREADING
+ -SfCOMMANDARGS
+ -SfPROCESSES
+ -SfSTACKCHECK
+ -SfDYNLIBS
+ -SfEXITCODE
+ -SfSOFTFPU
+ -SfRTTI
+ -SfRESOURCES

rtl/ps1/rtldefs.inc

@@ -0,0 +1 @@
+ 

rtl/ps1/si_prc.pp

@@ -6,7 +6,6 @@ implementation
 
 procedure PascalMain; external name 'PASCALMAIN';
 
-
 { this function must be the first in this unit which contains code }
 function _FPC_proc_start: longint; cdecl; public name '_start';
 begin

rtl/ps1/sysdir.inc

@@ -0,0 +1,35 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 1999-2000 by Florian Klaempfl and Pavel Ozerski
+    member of the Free Pascal development team.
+
+    FPC Pascal system unit for the Win32 API.
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    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.
+
+ **********************************************************************}
+
+{*****************************************************************************
+                           Directory Handling
+*****************************************************************************}
+
+Procedure do_MkDir(const s: rawbytestring);inline;
+begin
+end;
+
+Procedure do_RmDir(const s: rawbytestring);inline;
+begin
+end;
+
+Procedure do_ChDir(const s: rawbytestring);inline;
+begin
+end;
+
+procedure do_GetDir (DriveNr: byte; var Dir: RawByteString);inline;
+begin
+end;

rtl/ps1/sysfile.inc

@@ -0,0 +1,91 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2001 by Free Pascal development team
+
+    Low leve file functions
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    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.
+
+ **********************************************************************}
+
+
+
+{****************************************************************************
+                        Low level File Routines
+ ****************************************************************************}
+
+procedure do_close(handle : thandle);inline;
+begin
+end;
+
+
+procedure do_erase(p : PAnsiChar; pchangeable: boolean);inline;
+begin
+end;
+
+
+procedure do_rename(p1,p2 : PAnsiChar; p1changeable, p2changeable: boolean);inline;
+begin
+end;
+
+
+function do_write(h:thandle;addr:pointer;len : longint) : longint;
+begin
+  do_write:=len;
+end;
+
+
+function do_read(h:thandle;addr:pointer;len : longint) : longint;
+begin
+  do_read:=0;
+end;
+
+
+function do_filepos(handle : thandle) : longint;inline;
+begin
+end;
+
+
+procedure do_seek(handle:thandle;pos : longint);inline;
+begin
+end;
+
+
+
+function do_seekend(handle:thandle):longint;inline;
+begin
+end;
+
+
+function do_filesize(handle : thandle) : longint;inline;
+begin
+
+end;
+
+
+{ truncate at a given position }
+procedure do_truncate (handle:thandle;pos:longint);inline;
+begin
+end;
+
+procedure do_open(var f;p:PAnsiChar;flags:longint; pchangeable: boolean);inline;
+{
+  filerec and textrec have both handle and mode as the first items so
+  they could use the same routine for opening/creating.
+  when (flags and $100)   the file will be append
+  when (flags and $1000)  the file will be truncate/rewritten
+  when (flags and $10000) there is no check for close (needed for textfiles)
+}
+begin
+end;
+
+
+function do_isdevice(handle:THandle):boolean;inline;
+begin
+  do_isdevice:=true;
+end;

rtl/ps1/sysheap.inc

@@ -0,0 +1,28 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2005 by Free Pascal development team
+
+    Low level memory functions
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    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.
+
+ **********************************************************************}
+
+{*****************************************************************************
+                              Heap Management
+*****************************************************************************}
+
+function SysOSAlloc (size: ptruint): pointer;
+begin
+  SysOSAlloc:=_malloc(size);
+end;
+
+procedure SysOSFree(p: pointer; size: ptruint);
+begin
+  _free(p);
+end;

rtl/ps1/objpas.pp → rtl/ps1/sysos.inc

@@ -1,8 +1,10 @@
 {
     This file is part of the Free Pascal run time library.
-    Copyright (c) 1999-2000 by the Free Pascal development team
+    Copyright (c) 2013 by Free Pascal development team
 
-    This unit makes Free Pascal as much as possible Delphi compatible
+    This file implements all the base types and limits required
+    for a minimal POSIX compliant subset required to port the compiler
+    to a new OS.
 
     See the file COPYING.FPC, included in this distribution,
     for details about the copyright.
@@ -12,18 +14,3 @@
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
  **********************************************************************}
-{$Mode ObjFpc}
-{$I-,S-}
-unit objpas;
-
-  interface
-
-    { first, in object pascal, the integer type must be redefined }
-    const
-       MaxInt  = MaxLongint;
-    type
-       Integer  = longint;
-
-  implementation
-
-end.

rtl/ps1/sysosh.inc

@@ -0,0 +1,27 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2013 by Free Pascal development team
+
+    This file implements all the base types and limits required
+    for a minimal POSIX compliant subset required to port the compiler
+    to a new OS.
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    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.
+
+ **********************************************************************}
+
+{Platform specific information}
+type
+  THandle = dword;
+  TThreadID = THandle;
+  TOSTimestamp = LongInt;
+
+  PRTLCriticalSection = ^TRTLCriticalSection;
+  TRTLCriticalSection = record
+    Locked: boolean
+  end;

rtl/ps1/system.pp

@@ -1,78 +1,88 @@
 unit system;
 interface
 
-const
-  MaxLongint  = $7fffffff;
-  
-type
-  TTypeKind = (tkUnknown, tkInteger, tkChar, tkEnumeration, tkFloat, tkSet,
-    tkMethod, tkSString, tkLString, tkAString, tkWString, tkVariant, tkArray,
-    tkRecord, tkInterface, tkClass, tkObject, tkWChar, tkBool, tkInt64, tkQWord,
-    tkDynArray, tkInterfaceRaw, tkProcVar, tkUString, tkUChar, tkHelper, tkFile,
-    tkClassRef, tkPointer);
-
-{$I typedefs.inc}
-
-{$I ../mips/setjumph.inc}
-
-type
-PExceptAddr = ^TExceptAddr;
-  TExceptAddr = record 
-    buf: Pjmp_buf;
-    next: PExceptAddr;
-    {$IFDEF CPU16}
-    frametype: SmallInt;
-    {$ELSE CPU16}
-    frametype: LongInt;
-    {$ENDIF CPU16}
-  end;
-
-  PGuid = ^TGuid;
-  TGuid = packed record
-    case Integer of
-    1:
-     (Data1: DWord;
-      Data2: word;
-      Data3: word;
-      Data4: array [0 .. 7] of byte;
-    );
-    2:
-     (D1: DWord;
-      D2: word;
-      D3: word;
-      D4: array [0 .. 7] of byte;
-    );
-    3:
-    ( { uuid fields according to RFC4122 }
-      time_low: DWord; // The low field of the timestamp
-      time_mid: word; // The middle field of the timestamp
-      time_hi_and_version: word;
-      // The high field of the timestamp multiplexed with the version number
-      clock_seq_hi_and_reserved: byte;
-      // The high field of the clock sequence multiplexed with the variant
-      clock_seq_low: byte; // The low field of the clock sequence
-      node: array [0 .. 5] of byte; // The spatially unique node identifier
-    );
-  end;
+{$define FPC_IS_SYSTEM}
+{$DEFINE FPCRTL_FILESYSTEM_SINGLE_BYTE_API}
+{$define FPC_HAS_FEATURE_DYNLIBS}
+{$define FPC_HAS_FEATURE_INITFINAL}
+{$define FPC_HAS_FEATURE_ANSISTRINGS}
+{define USE_NOTHREADMANAGER}
+{$define FPC_HAS_FEATURE_THREADING}
+
+{$I systemh.inc}
 
 var
-  ExitCode: hresult = 0; export name 'operatingsystem_result';
+  argc:longint=0;
+  argv:PPAnsiChar;
+  envp:PPAnsiChar;
+
+implementation
 
-procedure fpc_initializeunits; compilerproc;
+procedure _InitHeap(p: pdword; l: dword); external name 'InitHeap';
+procedure _free(p: pointer); external name 'free';
+function _malloc(l: dword): pointer; external name 'malloc';
 
-procedure fpc_do_exit; compilerproc;
 
-implementation
+const
+    maxExitCode = 255;
+    AllowDirectorySeparators : set of AnsiChar = ['\','/'];
+    DirectorySeparator = '/';
+  { Default filehandles }
+    UnusedHandle    = $ffff;{ instead of -1, as it is a word value}
+    StdInputHandle  = 0;
+    StdOutputHandle = 1;
+    StdErrorHandle  = 2;
+    CtrlZMarksEOF: boolean = true; (* #26 is considered as end of file *)
+    DefaultTextLineBreakStyle : TTextLineBreakStyle = tlbsCR;
+    LineEnding = #10;
+    PathSeparator = '/';
+    MaxPathLen = 255;
+    LFNSupport = true;
+    FileNameCaseSensitive = true;
+    sLineBreak = #13;
 
-{$I ../mips/setjump.inc}
+{I ../mips/setjump.inc}
+{$I system.inc}
 
 
-procedure fpc_initializeunits;
+procedure Randomize;
+begin
+  randseed:= 1234;
+end;
+
+function GetProcessID: LongWord;
+begin
+  result:= 0;
+end;
+
+function ParamCount: LongInt;
 begin
+  ParamCount:= 0;
 end;
 
-procedure fpc_do_exit;
+function ParamStr(l: LongInt): ShortString;
 begin
+  result:='';
 end;
 
+procedure SysInitStdIO;
+begin
+end;
+
+function CheckInitialStkLen(stklen : SizeUInt) : SizeUInt;
+begin
+  result:= stklen;
+end;
+
+procedure system_exit;
+begin
+  repeat
+  until false;
+end;
+
+
+begin
+  InOutRes:= 0;
+  _InitHeap(pdword($800F8000), $00100000);
+  InitSystemThreads;
 end.

rtl/ps1/tthread.inc

@@ -0,0 +1,80 @@
+{
+    This file is part of the Free Component Library (FCL)
+    Copyright (c) 1999-2000 by the Free Pascal development team
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    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.
+
+ **********************************************************************}
+{****************************************************************************}
+{*                             TThread                                      *}
+{****************************************************************************}
+xxxx
+
+procedure TThread.CallOnTerminate;
+
+begin
+end;
+
+
+function TThread.GetPriority: TThreadPriority;
+
+begin
+  GetPriority:=tpNormal;
+end;
+
+
+procedure TThread.SetPriority(Value: TThreadPriority);
+
+begin
+end;
+
+
+procedure TThread.SetSuspended(Value: Boolean);
+
+begin
+end;
+
+
+procedure TThread.DoTerminate;
+
+begin
+end;
+
+
+procedure TThread.SysCreate(CreateSuspended: Boolean; const StackSize: SizeUInt);
+
+begin
+ {IsMultiThread := TRUE; }
+end;
+
+
+procedure TThread.SysDestroy;
+
+begin
+end;
+
+
+procedure TThread.Resume;
+
+begin
+end;
+
+
+procedure TThread.Suspend;
+
+begin
+end;
+
+
+function TThread.WaitFor: Integer;
+
+begin
+  WaitFor:=0;
+end;
+
+

rtl/ps1/typedefs.inc

@@ -1,190 +0,0 @@
-Type
-  { The compiler has all integer types defined internally. Here
-    we define only aliases }
-  DWord    = LongWord;
-  Cardinal = LongWord;
-  Integer  = SmallInt;
-  UInt64   = QWord;
-
-  SizeInt = Longint;
-  SizeUInt = DWord;
-  PtrInt = Longint;
-  PtrUInt = DWord;
-  ValSInt = Longint;
-  ValUInt = Cardinal;
-  CodePointer = Pointer;
-  CodePtrInt = PtrInt;
-  CodePtrUInt = PtrUInt;
-  TExitCode = Longint;
-
-  { NativeInt and NativeUInt are Delphi compatibility types. Even though Delphi
-    has IntPtr and UIntPtr, the Delphi documentation for NativeInt states that
-    'The size of NativeInt is equivalent to the size of the pointer on the
-    current platform'. Because of the misleading names, these types shouldn't be
-    used in the FPC RTL. Note that on i8086 their size changes between 16-bit
-    and 32-bit according to the memory model, so they're not really a 'native
-    int' type there at all. }
-  NativeInt  = Type PtrInt;
-  NativeUInt = Type PtrUInt;
-
-  Int8    = ShortInt;
-  Int16   = SmallInt;
-  Int32   = Longint;
-  IntPtr  = PtrInt;
-  UInt8   = Byte;
-  UInt16  = Word;
-  UInt32  = Cardinal;
-  UIntPtr = PtrUInt;
-
-{ Zero - terminated strings }
-
-{$IF DECLARED(AnsiChar)}
-// Compiler defines AnsiChar and WideChar, not AnsiChar
-{$IFDEF UNICODERTL}
-  Char = WideChar;
-{$ElSE}
-  Char = AnsiChar;
-{$ENDIF}
-
-{$ELSE}
-  // Compiler defines Char, we make AnsiChar an alias
-  AnsiChar = char;
-{$ENDIF}
-
-  PChar               = ^Char;
-  PPChar              = ^PChar;
-  PPPChar             = ^PPChar;
-
-  TAnsiChar           = AnsiChar;
-  PAnsiChar           = ^AnsiChar;
-  PPAnsiChar          = ^PAnsiChar;
-  PPPAnsiChar         = ^PPAnsiChar;
-
-  UTF8Char = AnsiChar;
-  PUTF8Char = PAnsiChar;
-
-  UCS4Char            = 0..$10ffff;
-  PUCS4Char           = ^UCS4Char;
-{$ifdef CPU16}
-  TUCS4CharArray      = array[0..32767 div sizeof(UCS4Char)-1] of UCS4Char;
-{$else CPU16}
-  TUCS4CharArray      = array[0..$effffff] of UCS4Char;
-{$endif CPU16}
-  PUCS4CharArray      = ^TUCS4CharArray;
-{$ifdef FPC_HAS_FEATURE_DYNARRAYS}
-  UCS4String          = array of UCS4Char;
-{$endif}
-
-
-Comp = type Int64;
-
-
-PCurrency           = ^Currency;
-
-  UTF8String          = type ansistring;
-  PUTF8String         = ^UTF8String;
-
-  RawByteString       = ansistring;
-
-  HRESULT             = type Longint;
-  TError               = type Longint;
-
-  PSmallInt           = ^Smallint;
-  PShortInt           = ^Shortint;
-  PInteger            = ^Integer;
-  PByte               = ^Byte;
-  PWord               = ^word;
-  PDWord              = ^DWord;
-  PLongWord           = ^LongWord;
-  PLongint            = ^Longint;
-  PCardinal           = ^Cardinal;
-  PQWord              = ^QWord;
-  PInt64              = ^Int64;
-  PUInt64             = ^UInt64;
-  PPtrInt             = ^PtrInt;
-  PPtrUInt            = ^PtrUInt;
-  PSizeInt            = ^SizeInt;
-  PSizeUInt           = ^SizeUInt;
-
-  PPByte              = ^PByte;
-  PPLongint           = ^PLongint;
-
-  PPointer            = ^Pointer;
-  PPPointer           = ^PPointer;
-
-  PCodePointer        = ^CodePointer;
-  PPCodePointer       = ^PCodePointer;
-
-  PBoolean            = ^Boolean;
-
-{$IFNDEF VER3_0}
-  PBoolean8           = ^Boolean8;
-{$ENDIF VER3_0}
-  PBoolean16          = ^Boolean16;
-  PBoolean32          = ^Boolean32;
-  PBoolean64          = ^Boolean64;
-
-  PByteBool           = ^ByteBool;
-  PWordBool           = ^WordBool;
-  PLongBool           = ^LongBool;
-  PQWordBool          = ^QWordBool;
-
-  PNativeInt 	      = ^NativeInt;
-  PNativeUInt	      = ^NativeUint;
-  PInt8   	      = PShortInt;
-  PInt16  	      = PSmallint;
-  PInt32  	      = PLongint;
-  PIntPtr 	      = PPtrInt;
-  PUInt8  	      = PByte;
-  PUInt16 	      = PWord;
-  PUInt32 	      = PDWord;
-  PUintPtr	      = PPtrUInt;
-
-  PShortString        = ^ShortString;
-  PAnsiString         = ^AnsiString;
-  PRawByteString      = ^RawByteString;
-
-{$ifndef FPUNONE}
-  PDate               = ^TDateTime;
-  PDateTime           = ^TDateTime;
-{$endif}
-  PError              = ^TError;
-
-{$ifdef FPC_HAS_FEATURE_VARIANTS}
-  PVariant            = ^Variant;
-  POleVariant         = ^OleVariant;
-{$endif FPC_HAS_FEATURE_VARIANTS}
-
-  PWideChar           = ^WideChar;
-  PPWideChar          = ^PWideChar;
-  PPPWideChar         = ^PPWideChar;
-  WChar               = Widechar;
-  UCS2Char            = WideChar;
-  PUCS2Char           = PWideChar;
-  PWideString         = ^WideString;
-
-  UnicodeChar         = WideChar;
-  PUnicodeChar        = ^UnicodeChar;
-  PUnicodeString      = ^UnicodeString;
-
-  PMarshaledString    = ^PWideChar;
-  PMarshaledAString   = ^PAnsiChar;
-
-  MarshaledString     = PWideChar;
-  MarshaledAString    = PAnsiChar;
-
-  TSystemCodePage     = Word;
-
-  TFileTextRecChar    = {$if defined(FPC_ANSI_TEXTFILEREC) or not(defined(FPC_HAS_FEATURE_WIDESTRINGS))}AnsiChar{$else}UnicodeChar{$endif};
-  PFileTextRecChar    = ^TFileTextRecChar;
-
-  TTextLineBreakStyle = (tlbsLF,tlbsCRLF,tlbsCR);
-
-{ opaque data type and related opaque pointer }
-  TOpaqueData = record end;
-  POpaqueData = ^TOpaqueData;
-  OpaquePointer = type POpaqueData;
-
-{ procedure type }
-  TProcedure  = Procedure;
- 

run

@@ -0,0 +1,3 @@
+#!/bin/bash
+pcsx-redux -exe "/run/media/key-real/E3AF-F107/code/source/test.psx-exe" -run
+#pcsx-redux -exe "/home/key-real/vip-code/source/test.psx-exe" -run

test.pas

@@ -0,0 +1,223 @@
+{$MODE OBJFPC}
+uses libstd, libcd, libcomb, libds, libetc, libgpu, libgte;
+
+
+procedure GsInitGraph(x, y, intmode, dith, varmmode: word); stdcall; external;
+
+const
+	MODE_NTSC = 0;
+	MODE_PAL = 1;
+
+
+
+const 
+	OTSIZE = 4096;
+
+	vertices : array [0..7] of SVECTOR = (
+	  (vx: -128; vy: -128; vz: -128; pad: 0 ),
+	  (vx:  128; vy: -128; vz: -128; pad: 0 ),
+	  (vx:  128; vy: -128; vz:  128; pad: 0 ),
+	  (vx: -128; vy: -128; vz:  128; pad: 0 ),
+	  (vx: -128; vy:  128; vz: -128; pad: 0 ),
+	  (vx:  128; vy:  128; vz: -128; pad: 0 ),
+	  (vx:  128; vy:  128; vz:  128; pad: 0 ),
+	  (vx: -128; vy:  128; vz:  128; pad: 0 ));
+
+	faces : array [0..35] of smallint = (
+	  0, 3, 2, // top
+	  0, 2, 1, // top
+	  4, 0, 1, // front
+	  4, 1, 5, // front
+	  7, 4, 5, // bottom
+	  7, 5, 6, // bottom
+	  5, 1, 2, // right
+	  5, 2, 6, // right
+	  2, 3, 7, // back
+	  2, 7, 6, // back
+	  0, 4, 7, // left
+	  0, 7, 3  // left 
+	  );
+
+type
+
+	DoubleBuff = packed record
+  		draw : DRAWENV;
+  		disp : DISPENV;
+ 	end;
+
+var
+	screen : array [0..1] of DoubleBuff;           // Struct to hold the display & draw buffers
+	currbuff : byte;            // Holds the current buffer number (0 or 1)
+
+	ot : array[0..1, 0..OTSIZE] of dword;
+
+	i : longint;
+	ii : longint;
+	otz : longint;
+	counter : dword;
+
+	poly : array [0..11] of POLY_G3;
+
+
+procedure setRGB0(var c: DRAWENV; r, g, b: byte);
+begin
+	c.r0:=r;
+	c.g0:=g;
+	c.b0:=b;
+end;
+
+
+procedure ScreenInit(width, height: dword);
+begin
+		
+  	ResetGraph(0);
+	InitGeom();
+
+	SetGraphDebug(0);
+
+	
+	SetVideoMode(MODE_PAL);
+	GsInitGraph(width, height, 0, 0, 0);
+	
+
+	SetDefDispEnv(@screen[0].disp, 0, 0, width, height);
+	SetDefDispEnv(@screen[1].disp, 0, height, width, height);
+
+	SetDefDrawEnv(@screen[0].draw, 0, height, width, height);
+	SetDefDrawEnv(@screen[1].draw, 0, 0, width, height);
+
+	screen[0].disp.screen.x:= 0;
+	screen[0].disp.screen.y:= 0;
+	screen[1].disp.screen.x:= 0;
+	screen[1].disp.screen.y:= 0;
+
+	screen[0].disp.screen.h:= 256;
+	screen[0].disp.screen.w:= 0;
+	screen[1].disp.screen.h:= 256;
+	screen[1].disp.screen.w:= 0;
+
+
+	screen[0].draw.isbg:= 1;
+	screen[1].draw.isbg:= 1;
+
+	// Set the background clear color
+	setRGB0(screen[0].draw, 0, 0, 0);
+	setRGB0(screen[1].draw, 0, 0, 0);
+
+	
+	// Initialize and setup the GTE geometry offsets
+	SetGeomOffset(width div 2, height div 2);
+	SetGeomScreen(100);
+	
+	SetDispMask(1);
+
+	// Set the current initial buffer
+	currbuff:= 0;
+	PutDispEnv(@screen[currbuff].disp);
+	PutDrawEnv(@screen[currbuff].draw);
+
+end;
+
+
+procedure DisplayFrame;
+begin
+	
+	// Set the current display & draw buffers
+	PutDispEnv(@screen[currbuff].disp);
+	PutDrawEnv(@screen[currbuff].draw);
+
+	DrawOTag(@ot[currbuff, OTSIZE - 1]);
+
+	FntFlush(-1);
+
+	if currbuff = 0 then currbuff:=1 else currbuff:=0;
+
+	// Sync and wait for vertical blank
+	DrawSync(0);
+	VSync(0);
+
+end;
+
+
+var
+	rotation : SVECTOR;
+    translation : VECTOR;
+    transform : MATRIX;
+
+    p : pointer;
+    flg : pointer;
+    nclip : longint;
+
+    ch: pchar;
+    d: dword;
+
+
+begin
+
+
+	ScreenInit(320, 256);
+
+
+	FntLoad(960, 256);
+	SetDumpFnt(FntOpen(0, 100, 200, 200, 0, 512));
+
+	rotation.vx:= 0;
+	rotation.vy:= 0;
+	rotation.vz:= 0;
+
+	translation.vx:= 0;
+	translation.vy:= 0;
+	translation.vz:= 500;
+
+	counter:= 1;
+
+//	srand(1234);
+//randomize;
+
+
+	repeat
+
+		ClearOTagR(@ot[currbuff], OTSIZE);
+		
+
+
+		rotation.vx +=  6;
+	  	rotation.vy +=  8;
+	  	rotation.vz += 12;
+
+	    RotMatrix(@rotation, @transform);
+	    TransMatrix(@transform, @translation);
+			
+		SetRotMatrix(@transform);
+    	SetTransMatrix(@transform);
+
+	    for i:= 0 to 11 do begin
+			setPolyG3(@poly[i]);
+
+			  poly[i].r0:= 255; poly[i].g0:=0;   poly[i].b0:= 0;
+			  poly[i].r1:= 0;   poly[i].g1:=255; poly[i].b1:= 0;
+			  poly[i].r2:= 0;   poly[i].g2:=0;   poly[i].b2:= 255;
+	{
+			  otz:= 0;
+			  otz:= otz + RotTransPers(@vertices[faces[i * 3 + 0]], @poly[i].x0, @p, @flg);
+			  otz:= otz + RotTransPers(@vertices[faces[i * 3 + 1]], @poly[i].x1, @p, @flg);
+			  otz:= otz + RotTransPers(@vertices[faces[i * 3 + 2]], @poly[i].x2, @p, @flg);
+			  otz:= otz div 3;
+	}
+				nclip:= RotAverageNclip3(@vertices[faces[i * 3 + 0]], @vertices[faces[i * 3 + 1]], @vertices[faces[i * 3 + 2]], @poly[i].x0, @poly[i].x1, @poly[i].x2, @p, @otz, @flg);
+				if nclip <= 0 then continue;
+
+				if (otz > 0) and (otz < OTSIZE) then addPrim(@ot[currbuff, otz], @poly[i]);
+		end;
+
+
+		counter:= counter + 1;
+
+		FntPrint('Hello from FPC %d', counter);
+		
+
+		DisplayFrame;
+		
+	until false;
+
+end.