/packages/amunits/src/otherlibs/identify.pas

https://github.com/slibre/freepascal · Pascal · 726 lines · 473 code · 107 blank · 146 comment · 6 complexity · 6e50367514cf27aeb9ec4e534e9bd382 MD5 · raw file 

    

  1. {
    2. 

  2.     This file is part of the Free Pascal run time library.
    3. 

  3. 

  4.     A file in Amiga system run time library.
    5. 

  5.     Copyright (c) 2001-2003 by Nils Sjoholm
    6. 

  6.     member of the Amiga RTL development team.
    7. 

  7. 

  8.     See the file COPYING.FPC, included in this distribution,
    9. 

  9.     for details about the copyright.
    10. 

  10. 

  11.     This program is distributed in the hope that it will be useful,
    12. 

  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    14. 

  14. 

  15.  **********************************************************************}
    16. 

  16. 

  17. {
    18. 

  18.     History:
    19. 

  19. 

  20.     First version of this unit.
    21. 

  21.     13 Mar 2001.
    22. 

  22. 

  23.     Updated to use fpc 1.0.7
    24. 

  24.     Added array of const and some
    25. 

  25.     overlay functions.
    26. 

  26.     08 Jan 2003
    27. 

  27. 

  28.     Added the defines use_amiga_smartlink and
    29. 

  29.     use_auto_openlib.
    30. 

  30.     12 Jan 2003.
    31. 

  31. 

  32.     Changed cardinal > longword.
    33. 

  33.     Changed startcode for unit.
    34. 

  34.     11 Feb 2003.
    35. 

  35. 

  36.     nils.sjoholm@mailbox.swipnet.se
    37. 

  37. }
    38. 

  38. 

  39. {$mode objfpc}
    40. 

  40. 

  41. {$I useamigasmartlink.inc}
    42. 

  42. {$ifdef use_amiga_smartlink}
    43. 

  43.     {$smartlink on}
    44. 

  44. {$endif use_amiga_smartlink}
    45. 

  45. 

  46. UNIT IDENTIFY;
    47. 

  47. 

  48. INTERFACE
    49. 

  49. USES Exec, utility;
    50. 

  50. 

  51. {
    52. 

  52. ** $VER: identify.h 13.0 (11.09.2001)
    53. 

  53. **
    54. 

  54. ** identify.library definitions
    55. 

  55. **
    56. 

  56. ** (C) Copyright 1996-2000 Richard Koerber
    57. 

  57. ** All Rights Reserved.
    58. 

  58. }
    59. 

  59. 

  60. CONST  _IDTAGS      = $CD450000;
    61. 

  61. 

  62. { --------------------------------------------------------------------------}
    63. 

  63. { Generic library informations }
    64. 

  64. 

  65. CONST  IDENTIFYVERSION = 13;
    66. 

  66.        IDENTIFYNAME    : PChar = 'identify.library';
    67. 

  67. 

  68. TYPE   pIdentifyBase = ^tIdentifyBase;
    69. 

  69.        TIdentifyBase  = Record
    70. 

  70.           ifyb_LibNode  :tLibrary;
    71. 

  71.        End;
    72. 

  72. 

  73. CONST  IDENTIFYBUFLEN = 50;  { default buffer length }
    74. 

  74. 

  75. { --------------------------------------------------------------------------}
    76. 

  76. { Expansion() tags }
    77. 

  77. 

  78.        IDTAG_ConfigDev   = _IDTAGS+$00; { "p_ConfigDev" ConfigDev }
    79. 

  79.                                         { structure to be evaluated }
    80. 

  80.        IDTAG_ManufID     = _IDTAGS+$01; { UWORD manufacturer ID if no }
    81. 

  81.                                         { ConfigDev is available }
    82. 

  82.        IDTAG_ProdID      = _IDTAGS+$02; { UBYTE product ID if no }
    83. 

  83.                                         { ConfigDev is available }
    84. 

  84.        IDTAG_StrLength   = _IDTAGS+$03; { UWORD of maximum buffer length, }
    85. 

  85.                                         { including termination. Default }
    86. 

  86.                                         { is 50. }
    87. 

  87.        IDTAG_ManufStr    = _IDTAGS+$04; { STRPTR of manufacturer name }
    88. 

  88.                                         { puffer, or NULL }
    89. 

  89.        IDTAG_ProdStr     = _IDTAGS+$05; { STRPTR of product name }
    90. 

  90.                                         { puffer, or NULL }
    91. 

  91.        IDTAG_ClassStr    = _IDTAGS+$06; { STRPTR of product class }
    92. 

  92.                                         { puffer, or NULL }
    93. 

  93.        IDTAG_DeadStr     = _IDTAGS+$07; { STRPTR deadend or recoverable alert? }
    94. 

  94.        IDTAG_SubsysStr   = _IDTAGS+$08; { STRPTR alert subsystem }
    95. 

  95.        IDTAG_GeneralStr  = _IDTAGS+$09; { STRPTR alert general cause }
    96. 

  96.        IDTAG_SpecStr     = _IDTAGS+$0A; { STRPTR alert specific cause }
    97. 

  97.        IDTAG_FuncNameStr = _IDTAGS+$0B; { STRPTR function name }
    98. 

  98.        IDTAG_Expansion   = _IDTAGS+$0C; { "pp_ConfigDev" ConfigDev for a }
    99. 

  99.                                         { complete expansion check. Init }
    100. 

  100.                                         { the variable with NULL and pass }
    101. 

  101.                                         { a pointer to it using this tag. }
    102. 

  102.        IDTAG_Secondary   = _IDTAGS+$0D; { BOOL warn for secondary expansion }
    103. 

  103.                                         { boards (defaults to FALSE) }
    104. 

  104.        IDTAG_ClassID     = _IDTAGS+$0E; { ULONG * class ID of the provided }
    105. 

  105.                                         { expansion board (see below) [V8] }
    106. 

  106.        IDTAG_Localize    = _IDTAGS+$0F; { BOOL return localized strings }
    107. 

  107.                                         { (defaults to TRUE) [V8] }
    108. 

  108.        IDTAG_NULL4NA     = _IDTAGS+$10; { BOOL return NULL for not available, }
    109. 

  109.                                         { else return a string (defaults to }
    110. 

  110.                                         { FALSE) [V8] }
    111. 

  111. 

  112. { --------------------------------------------------------------------------}
    113. 

  113. { Hardware description types }
    114. 

  114. 

  115.        IDHW_SYSTEM      = 0;   { System (Amiga,DraCo,...)            [V2] }
    116. 

  116.        IDHW_CPU         = 1;   { CPU (68000,68010,...,68060) }
    117. 

  117.        IDHW_FPU         = 2;   { FPU (---,68881,68882,68040,68060) }
    118. 

  118.        IDHW_MMU         = 3;   { MMU (---,68852,68030,68040,68060) }
    119. 

  119.        IDHW_OSVER       = 4;   { OS Version (Vx.x) }
    120. 

  120.        IDHW_EXECVER     = 5;   { Exec Version (Vx.x) }
    121. 

  121.        IDHW_WBVER       = 6;   { Workbench Version (---,Vx.x) }
    122. 

  122.        IDHW_ROMSIZE     = 7;   { OS ROM Size (xKB, xMB) }
    123. 

  123.        IDHW_CHIPSET     = 8;   { Chipset (OCS,ECS,AGA,DraCo) }
    124. 

  124.        IDHW_GFXSYS      = 9;   { Graphic OS (AmigaOS, CyberGraphX, ...) }
    125. 

  125.        IDHW_CHIPRAM     = 10;  { Chip RAM (xKB, xMB, xGB) }
    126. 

  126.        IDHW_FASTRAM     = 11;  { Fast RAM (xKB, xMB, xGB) }
    127. 

  127.        IDHW_RAM         = 12;  { Total RAM (xKB, xMB, xGB) }
    128. 

  128.        IDHW_SETPATCHVER = 13;  { SetPatch Version (---,Vx.x)         [V4] }
    129. 

  129.        IDHW_AUDIOSYS    = 14;  { Audio OS (AmigaOS, AHI, ...)        [V5] }
    130. 

  130.        IDHW_OSNR        = 15;  { AmigaOS (2.04, 3.1, ...) }
    131. 

  131.        IDHW_VMMCHIPRAM  = 16;  { VMM Chip RAM ( *KB, *MB, *GB) }
    132. 

  132.        IDHW_VMMFASTRAM  = 17;  { VMM Fast RAM ( *KB, *MB, *GB) }
    133. 

  133.        IDHW_VMMRAM      = 18;  { VMM Total RAM ( *KB, *MB, *GB) }
    134. 

  134.        IDHW_PLNCHIPRAM  = 19;  { Plain Chip RAM ( *KB, *MB, *GB) }
    135. 

  135.        IDHW_PLNFASTRAM  = 20;  { Plain Fast RAM ( *KB, *MB, *GB) }
    136. 

  136.        IDHW_PLNRAM      = 21;  { Plain Total RAM (*KB, *MB, *GB) }
    137. 

  137.        IDHW_VBR         = 22;  { Vector Base Register                [V6] }
    138. 

  138.        IDHW_LASTALERT   = 23;  { Last Alert code }
    139. 

  139.        IDHW_VBLANKFREQ  = 24;  { VBlank Frequency }
    140. 

  140.        IDHW_POWERFREQ   = 25;  { Power Frequency }
    141. 

  141.        IDHW_ECLOCK      = 26;  { EClock }
    142. 

  142.        IDHW_SLOWRAM     = 27;  { Plain Slow RAM ( *KB, *MB, *GB) }
    143. 

  143.        IDHW_GARY        = 28;  { Gary (---,Normal,...) }
    144. 

  144.        IDHW_RAMSEY      = 29;  { RAMSEY (---,D,F) }
    145. 

  145.        IDHW_BATTCLOCK   = 30;  { Battery Backed Up Clock (---,Found) }
    146. 

  146.        IDHW_CHUNKYPLANAR = 31; { Chunky To Planar Hardware (---,Found) [V7] }
    147. 

  147.        IDHW_POWERPC     = 32;  { PowerPC present? (---,Found) }
    148. 

  148.        IDHW_PPCCLOCK    = 33;  { PowerPC clock (unit MHz) }
    149. 

  149.        IDHW_CPUREV      = 34;  { CPU revision                          [V8] }
    150. 

  150.        IDHW_CPUCLOCK    = 35;  { CPU clock (unit MHz) }
    151. 

  151.        IDHW_FPUCLOCK    = 36;  { FPU clock (unit MHz) }
    152. 

  152.        IDHW_RAMACCESS   = 37;  { Main board RAM access time (unit ns) }
    153. 

  153.        IDHW_RAMWIDTH    = 38;  { Main board RAM width (bit) }
    154. 

  154.        IDHW_RAMCAS      = 39;  { Main board RAM CAS mode }
    155. 

  155.        IDHW_RAMBANDWIDTH = 40; { Main board RAM bandwidth }
    156. 

  156.        IDHW_TCPIP       = 41;  { TCP/IP stack                          [V9] }
    157. 

  157.        IDHW_PPCOS       = 42;  { PowerPC OS }
    158. 

  158.        IDHW_AGNUS       = 43;  { Agnus chip revision }
    159. 

  159.        IDHW_AGNUSMODE   = 44;  { Agnus chip mode }
    160. 

  160.        IDHW_DENISE      = 45;  { Denise chip version                   [V10] }
    161. 

  161.        IDHW_DENISEREV   = 46;  { Denise chip revision }
    162. 

  162.        IDHW_BOINGBAG    = 47;  { BoingBag number                       [V12] }
    163. 

  163.        IDHW_NUMBEROF    = 48;  { Number of types, PRIVATE! }
    164. 

  164. 

  165. { --------------------------------------------------------------------------}
    166. 

  166. { IDHW_SYSTEM numerical result codes }
    167. 

  167. 

  168.        IDSYS_AMIGA1000  = 0;    { Amiga 1000 }
    169. 

  169.        IDSYS_AMIGAOCS   = 1;    { OCS Amiga 500/2000 }
    170. 

  170.        IDSYS_AMIGAECS   = 2;    { ECS Amiga 500/2000 }
    171. 

  171.        IDSYS_AMIGA500   = 3;    { Amiga 500 }
    172. 

  172.        IDSYS_AMIGA2000  = 4;    { Amiga 2000 }
    173. 

  173.        IDSYS_AMIGA3000  = 5;    { Amiga 3000 }
    174. 

  174.        IDSYS_CDTV       = 6;    { CDTV }
    175. 

  175.        IDSYS_AMIGA600   = 7;    { Amiga 600 }
    176. 

  176.        IDSYS_CD32       = 8;    { CD32 }
    177. 

  177.        IDSYS_AMIGA1200  = 9;    { Amiga 1200 }
    178. 

  178.        IDSYS_AMIGA4000  = 10;   { Amiga 4000 }
    179. 

  179.        IDSYS_DRACO      = 11;   { DraCo }
    180. 

  180.        IDSYS_UAE        = 12;   { Ubiquitous Amiga Emulator }
    181. 

  181.        IDSYS_AMIGA4000T = 13;   { Amiga 4000 Tower }
    182. 

  182. 

  183. { --------------------------------------------------------------------------}
    184. 

  184. { IDHW_CPU numerical result codes }
    185. 

  185. 

  186.        IDCPU_68000     = 0;     { 68000 }
    187. 

  187.        IDCPU_68010     = 1;     { 68010 }
    188. 

  188.        IDCPU_68020     = 2;     { 68020 }
    189. 

  189.        IDCPU_68030     = 3;     { 68030 }
    190. 

  190.        IDCPU_68EC030   = 4;     { 68EC030 (without MMU) }
    191. 

  191.        IDCPU_68040     = 5;     { 68040 }
    192. 

  192.        IDCPU_68LC040   = 6;     { 68LC040 (without FPU) }
    193. 

  193.        IDCPU_68060     = 7;     { 68060 }
    194. 

  194.        IDCPU_68LC060   = 8;     { 68LC060 (without FPU) }
    195. 

  195. 

  196. { --------------------------------------------------------------------------}
    197. 

  197. { IDHW_FPU numerical result codes }
    198. 

  198. 

  199.        IDFPU_NONE      = 0;     { no FPU }
    200. 

  200.        IDFPU_68881     = 1;     { 68881 }
    201. 

  201.        IDFPU_68882     = 2;     { 68882 }
    202. 

  202.        IDFPU_68040     = 3;     { 68040 }
    203. 

  203.        IDFPU_68060     = 4;     { 68060 }
    204. 

  204. 

  205. { --------------------------------------------------------------------------}
    206. 

  206. { IDHW_MMU numerical result codes }
    207. 

  207. 

  208.        IDMMU_NONE      = 0;     { no MMU }
    209. 

  209.        IDMMU_68851     = 1;     { 68851 }
    210. 

  210.        IDMMU_68030     = 2;     { 68030 }
    211. 

  211.        IDMMU_68040     = 3;     { 68040 }
    212. 

  212.        IDMMU_68060     = 4;     { 68060 }
    213. 

  213. 

  214. { --------------------------------------------------------------------------}
    215. 

  215. { IDHW_OSNR numerical result codes }
    216. 

  216. 

  217.        IDOS_UNKNOWN    = 0;     { <V36 or >V40 }
    218. 

  218.        IDOS_2_0        = 1;     { OS2.0  (V36) }
    219. 

  219.        IDOS_2_04       = 2;     { OS2.04 (V37) }
    220. 

  220.        IDOS_2_1        = 3;     { OS2.1  (V38) }
    221. 

  221.        IDOS_3_0        = 4;     { OS3.0  (V39) }
    222. 

  222.        IDOS_3_1        = 5;     { OS3.1  (V40) }
    223. 

  223.        IDOS_3_5        = 6;     { OS3.5  (V44) }
    224. 

  224.        IDOS_3_9        = 7;     { OS3.9  (V45) }
    225. 

  225. 

  226. { --------------------------------------------------------------------------}
    227. 

  227. { IDHW_CHIPSET numerical result codes }
    228. 

  228. 

  229.        IDCS_OCS        = 0;     { OCS }
    230. 

  230.        IDCS_ECS        = 1;     { ECS }
    231. 

  231.        IDCS_AGA        = 2;     { AGA }
    232. 

  232.        IDCS_ALTAIS     = 3;     { DraCo Altais }
    233. 

  233.        IDCS_NECS       = 4;     { Nearly ECS (no HR-Agnus or HR-Denise) }
    234. 

  234. 

  235. { --------------------------------------------------------------------------}
    236. 

  236. { IDHW_GFXSYS numerical result codes }
    237. 

  237. 

  238.        IDGOS_AMIGAOS   = 0;     { Plain AmigaOS }
    239. 

  239.        IDGOS_EGS       = 1;     { EGS }
    240. 

  240.        IDGOS_RETINA    = 2;     { Retina }
    241. 

  241.        IDGOS_GRAFFITI  = 3;     { Graffiti }
    242. 

  242.        IDGOS_TIGA      = 4;     { TIGA }
    243. 

  243.        IDGOS_PROBENCH  = 5;     { Merlin ProBench }
    244. 

  244.        IDGOS_PICASSO   = 6;     { Picasso }
    245. 

  245.        IDGOS_CGX       = 7;     { CyberGraphX }
    246. 

  246.        IDGOS_CGX3      = 8;     { CyberGraphX 3D }
    247. 

  247.        IDGOS_PICASSO96 = 9;     { Picasso96 }
    248. 

  248.        IDGOS_CGX4      = 10;    { CyberGraphX V4 }
    249. 

  249. 

  250. { --------------------------------------------------------------------------}
    251. 

  251. { IDHW_AUDIOSYS numerical result codes }
    252. 

  252. 

  253.        IDAOS_AMIGAOS   = 0;     { Plain AmigaOS }
    254. 

  254.        IDAOS_MAESTIX   = 1;     { MaestroPro driver }
    255. 

  255.        IDAOS_TOCCATA   = 2;     { Toccata driver }
    256. 

  256.        IDAOS_PRELUDE   = 3;     { Prelude driver }
    257. 

  257.        IDAOS_AHI       = 4;     { AHI }
    258. 

  258.        IDAOS_MACROAUDIO = 5;    { MacroAudio }
    259. 

  259. 

  260. { --------------------------------------------------------------------------}
    261. 

  261. { IDHW_GARY numerical result codes }
    262. 

  262. 

  263.        IDGRY_NONE      = 0;     { No Gary available }
    264. 

  264.        IDGRY_NORMAL    = 1;     { Normal Gary }
    265. 

  265.        IDGRY_ENHANCED  = 2;     { Enhanced Gary }
    266. 

  266. 

  267. { --------------------------------------------------------------------------}
    268. 

  268. { IDHW_RAMSEY numerical result codes }
    269. 

  269. 

  270.        IDRSY_NONE      = 0;     { No RamSey available }
    271. 

  271.        IDRSY_REVD      = 1;     { RamSey Revision D }
    272. 

  272.        IDRSY_REVF      = 2;     { RamSey Revision F }
    273. 

  273. 

  274. { --------------------------------------------------------------------------}
    275. 

  275. { IDHW_POWERPC numerical result codes }
    276. 

  276. 

  277.        IDPPC_NONE      = 0;     {  No PowerPC implemented }
    278. 

  278.        IDPPC_OTHER     = 1;     {  Another PowerPC }
    279. 

  279.        IDPPC_602       = 2;     {  602 }
    280. 

  280.        IDPPC_603       = 3;     {  603 }
    281. 

  281.        IDPPC_603E      = 4;     {  603e }
    282. 

  282.        IDPPC_603P      = 5;     {  603p }
    283. 

  283.        IDPPC_604       = 6;     {  604 }
    284. 

  284.        IDPPC_604E      = 7;     {  604e }
    285. 

  285.        IDPPC_620       = 8;     {  620 }
    286. 

  286. 

  287. { --------------------------------------------------------------------------}
    288. 

  288. { IDHW_RAMCAS numerical result codes }
    289. 

  289. 

  290.        IDCAS_NONE      = 0;     {  Not available }
    291. 

  291.        IDCAS_NORMAL    = 1;     {  Normal access }
    292. 

  292.        IDCAS_DOUBLE    = 2;     {  Double access }
    293. 

  293. 

  294. { --------------------------------------------------------------------------}
    295. 

  295. { IDHW_TCPIP numerical result codes }
    296. 

  296. 

  297.        IDTCP_NONE      = 0;     {  Not available }
    298. 

  298.        IDTCP_AMITCP    = 1;     {  AmiTCP }
    299. 

  299.        IDTCP_MIAMI     = 2;     {  Miami }
    300. 

  300.        IDTCP_TERMITE   = 3;     {  TermiteTCP }
    301. 

  301.        IDTCP_GENESIS   = 4;     {  GENESiS }
    302. 

  302.        IDTCP_MIAMIDX   = 5;     {  MiamiDx }
    303. 

  303. 

  304. { --------------------------------------------------------------------------}
    305. 

  305. { IDHW_PPCOS numerical result codes }
    306. 

  306. 

  307.        IDPOS_NONE      = 0;     {  None }
    308. 

  308.        IDPOS_POWERUP   = 1;     {  PowerUP (Phase 5) }
    309. 

  309.        IDPOS_WARPOS    = 2;     {  WarpOS (Haage&Partner) }
    310. 

  310. 

  311. { --------------------------------------------------------------------------}
    312. 

  312. { IDHW_AGNUS numerical result codes }
    313. 

  313. 

  314.        IDAG_NONE       = 0;     {  None }
    315. 

  315.        IDAG_UNKNOWN    = 1;     {  Unknown Agnus }
    316. 

  316.        IDAG_8361       = 2;     {  Agnus 8361 }
    317. 

  317.        IDAG_8367       = 3;     {  Agnus 8367 }
    318. 

  318.        IDAG_8370       = 4;     {  Agnus 8370 }
    319. 

  319.        IDAG_8371       = 5;     {  Agnus 8371 }
    320. 

  320.        IDAG_8372_R4    = 6;     {  Agnus 8372 Rev. 1-4 }
    321. 

  321.        IDAG_8372_R5    = 7;     {  Agnus 8372 Rev. 5 }
    322. 

  322.        IDAG_8374_R2    = 8;     {  Alice 8374 Rev. 1-2 }
    323. 

  323.        IDAG_8374_R3    = 9;     {  Alice 8374 Rev. 3-4 }
    324. 

  324. 

  325. { --------------------------------------------------------------------------}
    326. 

  326. { IDHW_DENISE numerical result codes }
    327. 

  327. 

  328.        IDDN_NONE       = 0;     {  None }
    329. 

  329.        IDDN_UNKNOWN    = 1;     {  Unknown Denise (new model?! :-) }
    330. 

  330.        IDDN_8362       = 2;     {  Denise 8362 }
    331. 

  331.        IDDN_8373       = 3;     {  Denise 8373 }
    332. 

  332.        IDDN_8364       = 4;     {  Lisa 8364 }
    333. 

  333. 

  334. { --------------------------------------------------------------------------}
    335. 

  335. { IDHW_AGNUSMODE numerical result codes }
    336. 

  336. 

  337.        IDAM_NONE       = 0;     {  None }
    338. 

  338.        IDAM_NTSC       = 1;     {  NTSC Agnus }
    339. 

  339.        IDAM_PAL        = 2;     {  PAL Agnus }
    340. 

  340. 

  341. { --------------------------------------------------------------------------}
    342. 

  342. { IDTAG_ClassID numerical result codes }
    343. 

  343. 

  344.        IDCID_UNKNOWN     = 0;   {  unknown functionality }
    345. 

  345.        IDCID_MISC        = 1;   {  miscellaneous expansion }
    346. 

  346.        IDCID_TURBO       = 2;   {  accelerator }
    347. 

  347.        IDCID_TURBORAM    = 3;   {  accelerator RAM }
    348. 

  348.        IDCID_TURBOHD     = 4;   {  accelerator + some HD controller }
    349. 

  349.        IDCID_TURBOIDE    = 5;   {  accelerator + AT-IDE controller }
    350. 

  350.        IDCID_TURBOSCSIHD = 6;   {  accelerator + SCSI host adapter }
    351. 

  351.        IDCID_NET         = 7;   {  some network }
    352. 

  352.        IDCID_ARCNET      = 8;   {  ArcNet }
    353. 

  353.        IDCID_ETHERNET    = 9;   {  Ethernet }
    354. 

  354.        IDCID_AUDIO       = 10;  {  audio }
    355. 

  355.        IDCID_VIDEO       = 11;  {  video (video digitizer etc) }
    356. 

  356.        IDCID_MULTIMEDIA  = 12;  {  multimedia (audio, video, etc) }
    357. 

  357.        IDCID_DSP         = 13;  {  multi purpose DSP }
    358. 

  358.        IDCID_BUSBRIDGE   = 14;  {  ISA bus bridge }
    359. 

  359.        IDCID_BRIDGE      = 15;  {  PC bridge }
    360. 

  360.        IDCID_EMULATOR    = 16;  {  some Emulator hardware }
    361. 

  361.        IDCID_MACEMU      = 17;  {  Macintosh emulator hardware }
    362. 

  362.        IDCID_ATARIEMU    = 18;  {  Atari emulator hardware }
    363. 

  363.        IDCID_GFX         = 19;  {  graphics (register) }
    364. 

  364.        IDCID_GFXRAM      = 20;  {  graphics (video RAM) }
    365. 

  365.        IDCID_HD          = 21;  {  some HD controller }
    366. 

  366.        IDCID_HDRAM       = 22;  {  some HD controller + RAM }
    367. 

  367.        IDCID_IDEHD       = 23;  {  IDE controller }
    368. 

  368.        IDCID_IDEHDRAM    = 24;  {  IDE controller + RAM }
    369. 

  369.        IDCID_SCSIHD      = 25;  {  SCSI host adapter }
    370. 

  370.        IDCID_RAMSCSIHD   = 26;  {  SCSI host adapter + RAM }
    371. 

  371.        IDCID_CDROM       = 27;  {  CD-ROM interface }
    372. 

  372.        IDCID_MODEM       = 28;  {  internal modem }
    373. 

  373.        IDCID_ISDN        = 29;  {  internal ISDN terminal adapter }
    374. 

  374.        IDCID_MULTIIO     = 30;  {  multi I/O (serial + parallel) }
    375. 

  375.        IDCID_SERIAL      = 31;  {  multi serial (no parallel) }
    376. 

  376.        IDCID_PARALLEL    = 32;  {  multi parallel (no serial) }
    377. 

  377.        IDCID_SCANIF      = 33;  {  scanner interface }
    378. 

  378.        IDCID_TABLET      = 34;  {  drawing tablet interface }
    379. 

  379.        IDCID_RAM         = 35;  {  plain RAM expansion }
    380. 

  380.        IDCID_FLASHROM    = 36;  {  Flash ROM }
    381. 

  381.        IDCID_SCSIIDE     = 37;  {  combined SCSI/IDE controller }
    382. 

  382.        IDCID_RAMFPU      = 38;  {  RAM expansion + FPU }
    383. 

  383.        IDCID_GUESS       = 39;  {  name was unknown but guessed }
    384. 

  384.        IDCID_KICKSTART   = 40;  {  KickStart }
    385. 

  385.        IDCID_RAM32       = 41;  {  32bit RAM expansion }
    386. 

  386.        IDCID_TURBOANDRAM = 42;  {  accelerator + RAM expansion }
    387. 

  387.        IDCID_ACCESS      = 43;  {  access control }
    388. 

  388.        IDCID_INTERFACE   = 44;  {  some interface }
    389. 

  389.        IDCID_MFMHD       = 45;  {  MFM HD controller }
    390. 

  390.        IDCID_FLOPPY      = 46;  {  floppy disk controller }
    391. 

  391.         { Be prepared to get other numbers as well. In this case you }
    392. 

  392.         { should assume IDCID_MISC. }
    393. 

  393. 

  394. { --------------------------------------------------------------------------}
    395. 

  395. { Error codes }
    396. 

  396. 

  397. { Positive error codes are DOS errors! }
    398. 

  398.        IDERR_OKAY = 0;       { No error }
    399. 

  399.        IDERR_NOLENGTH = -1;  { Buffer length is 0 ?? }
    400. 

  400.        IDERR_BADID = -2;     { Missing or bad board ID }
    401. 

  401.        IDERR_NOMEM = -3;     { Not enough memory }
    402. 

  402.        IDERR_NOFD = -4;      { No fitting FD file found }
    403. 

  403.        IDERR_OFFSET = -5;    { Function offset not found }
    404. 

  404.        IDERR_DONE = -6;      { Done with traversing (not an error) }
    405. 

  405.        IDERR_SECONDARY = -7; { Secondary expansion board (not an error) }
    406. 

  406. 

  407. { --------------------------------------------------------------------------}
    408. 

  408. { That's all... }
    409. 

    410. 

  410. 

  411. 

  412. 

  413. VAR IdentifyBase : pLibrary;
    414. 

  414. 

  415. FUNCTION IdExpansion(TagList : pTagItem) : LONGINT;
    416. 

  416. FUNCTION IdHardware(Type_ : Ulong; TagList : pTagItem) : pCHAR;
    417. 

  417. FUNCTION IdAlert(ID : Ulong; TagList : pTagItem) : LONGINT;
    418. 

  418. FUNCTION IdFunction(LibName : pCHAR; Offset : LONGINT; TagList : pTagItem) : LONGINT;
    419. 

  419. FUNCTION IdHardwareNum(Type_ : Ulong; TagList : pTagItem) : Ulong;
    420. 

  420. PROCEDURE IdHardwareUpdate;
    421. 

  421. FUNCTION IdFormatString(String_ : pCHAR; Buffer : pCHAR; Length : Ulong; Tags : pTagItem) : Ulong;
    422. 

  422. FUNCTION IdEstimateFormatSize(String_ : pCHAR; Tags : pTagItem) : Ulong;
    423. 

  423. 

  424. {
    425. 

  425.      This is functions and procedures with array of const.
    426. 

  426.      For use with fpc 1.0 and above.
    427. 

  427. }
    428. 

  428. 

  429. FUNCTION IdExpansionTags(const TagList : Array Of Const) : LONGINT;
    430. 

  430. FUNCTION IdHardwareTags(Type_ : longword; const TagList : Array Of Const) : pCHAR;
    431. 

  431. FUNCTION IdAlertTags(ID : longword; const TagList : Array Of Const) : LONGINT;
    432. 

  432. FUNCTION IdFunctionTags(LibName : pCHAR; Offset : LONGINT; const TagList : Array Of Const) : LONGINT;
    433. 

  433. FUNCTION IdHardwareNumTags(Type_ : longword; const TagList : Array Of Const) : longword;
    434. 

  434. FUNCTION IdFormatStringTags(String_ : pCHAR; Buffer : pCHAR; Length : longword; const Tags : Array Of Const) : longword;
    435. 

  435. FUNCTION IdEstimateFormatSizeTags(String_ : pCHAR; const Tags : Array Of Const) : longword;
    436. 

  436. 

  437. {
    438. 

  438.      Overlay functions
    439. 

  439. }
    440. 

  440. 

  441. FUNCTION IdFunction(LibName : string; Offset : LONGINT; TagList : pTagItem) : LONGINT;
    442. 

  442. FUNCTION IdFormatString(String_ : string; Buffer : pCHAR; Length : Ulong; Tags : pTagItem) : Ulong;
    443. 

  443. FUNCTION IdEstimateFormatSize(String_ : string; Tags : pTagItem) : Ulong;
    444. 

  444. FUNCTION IdFunctionTags(LibName : string; Offset : LONGINT; const TagList : Array Of Const) : LONGINT;
    445. 

  445. FUNCTION IdFormatStringTags(String_ : string; Buffer : pCHAR; Length : longword; const Tags : Array Of Const) : longword;
    446. 

  446. FUNCTION IdEstimateFormatSizeTags(String_ : string; const Tags : Array Of Const) : longword;
    447. 

  447. 

  448. {You can remove this include and use a define instead}
    449. 

  449. {$I useautoopenlib.inc}
    450. 

  450. {$ifdef use_init_openlib}
    451. 

  451. procedure InitIDENTIFYLibrary;
    452. 

  452. {$endif use_init_openlib}
    453. 

  453. 

  454. {This is a variable that knows how the unit is compiled}
    455. 

  455. var
    456. 

  456.     IDENTIFYIsCompiledHow : longint;
    457. 

  457. 

  458. IMPLEMENTATION
    459. 

  459. 

  460. uses
    461. 

  461. {$ifndef dont_use_openlib}
    462. 

  462. msgbox,
    463. 

  463. {$endif dont_use_openlib}
    464. 

  464. tagsarray,pastoc;
    465. 

  465. 

  466. FUNCTION IdExpansion(TagList : pTagItem) : LONGINT;
    467. 

  467. BEGIN
    468. 

  468.   ASM
    469. 

  469.         MOVE.L  A6,-(A7)
    470. 

  470.         MOVEA.L TagList,A0
    471. 

  471.         MOVEA.L IdentifyBase,A6
    472. 

  472.         JSR     -030(A6)
    473. 

  473.         MOVEA.L (A7)+,A6
    474. 

  474.         MOVE.L  D0,@RESULT
    475. 

  475.   END;
    476. 

  476. END;
    477. 

  477. 

  478. FUNCTION IdHardware(Type_ : Ulong; TagList : pTagItem) : pCHAR;
    479. 

  479. BEGIN
    480. 

  480.   ASM
    481. 

  481.         MOVE.L  A6,-(A7)
    482. 

  482.         MOVE.L  Type_,D0
    483. 

  483.         MOVEA.L TagList,A0
    484. 

  484.         MOVEA.L IdentifyBase,A6
    485. 

  485.         JSR     -036(A6)
    486. 

  486.         MOVEA.L (A7)+,A6
    487. 

  487.         MOVE.L  D0,@RESULT
    488. 

  488.   END;
    489. 

  489. END;
    490. 

  490. 

  491. FUNCTION IdAlert(ID : Ulong; TagList : pTagItem) : LONGINT;
    492. 

  492. BEGIN
    493. 

  493.   ASM
    494. 

  494.         MOVE.L  A6,-(A7)
    495. 

  495.         MOVE.L  ID,D0
    496. 

  496.         MOVEA.L TagList,A0
    497. 

  497.         MOVEA.L IdentifyBase,A6
    498. 

  498.         JSR     -042(A6)
    499. 

  499.         MOVEA.L (A7)+,A6
    500. 

  500.         MOVE.L  D0,@RESULT
    501. 

  501.   END;
    502. 

  502. END;
    503. 

  503. 

  504. FUNCTION IdFunction(LibName : pCHAR; Offset : LONGINT; TagList : pTagItem) : LONGINT;
    505. 

  505. BEGIN
    506. 

  506.   ASM
    507. 

  507.         MOVE.L  A6,-(A7)
    508. 

  508.         MOVEA.L LibName,A0
    509. 

  509.         MOVE.L  Offset,D0
    510. 

  510.         MOVEA.L TagList,A1
    511. 

  511.         MOVEA.L IdentifyBase,A6
    512. 

  512.         JSR     -048(A6)
    513. 

  513.         MOVEA.L (A7)+,A6
    514. 

  514.         MOVE.L  D0,@RESULT
    515. 

  515.   END;
    516. 

  516. END;
    517. 

  517. 

  518. FUNCTION IdHardwareNum(Type_ : Ulong; TagList : pTagItem) : Ulong;
    519. 

  519. BEGIN
    520. 

  520.   ASM
    521. 

  521.         MOVE.L  A6,-(A7)
    522. 

  522.         MOVE.L  Type_,D0
    523. 

  523.         MOVEA.L TagList,A0
    524. 

  524.         MOVEA.L IdentifyBase,A6
    525. 

  525.         JSR     -054(A6)
    526. 

  526.         MOVEA.L (A7)+,A6
    527. 

  527.         MOVE.L  D0,@RESULT
    528. 

  528.   END;
    529. 

  529. END;
    530. 

  530. 

  531. PROCEDURE IdHardwareUpdate;
    532. 

  532. BEGIN
    533. 

  533.   ASM
    534. 

  534.         MOVE.L  A6,-(A7)
    535. 

  535.         MOVEA.L IdentifyBase,A6
    536. 

  536.         JSR     -060(A6)
    537. 

  537.         MOVEA.L (A7)+,A6
    538. 

  538.   END;
    539. 

  539. END;
    540. 

  540. 

  541. FUNCTION IdFormatString(String_ : pCHAR; Buffer : pCHAR; Length : Ulong; Tags : pTagItem) : Ulong;
    542. 

  542. BEGIN
    543. 

  543.   ASM
    544. 

  544.         MOVE.L  A6,-(A7)
    545. 

  545.         MOVEA.L String_,A0
    546. 

  546.         MOVEA.L Buffer,A1
    547. 

  547.         MOVE.L  Length,D0
    548. 

  548.         MOVEA.L Tags,A2
    549. 

  549.         MOVEA.L IdentifyBase,A6
    550. 

  550.         JSR     -066(A6)
    551. 

  551.         MOVEA.L (A7)+,A6
    552. 

  552.         MOVE.L  D0,@RESULT
    553. 

  553.   END;
    554. 

  554. END;
    555. 

  555. 

  556. FUNCTION IdEstimateFormatSize(String_ : pCHAR; Tags : pTagItem) : Ulong;
    557. 

  557. BEGIN
    558. 

  558.   ASM
    559. 

  559.         MOVE.L  A6,-(A7)
    560. 

  560.         MOVEA.L String_,A0
    561. 

  561.         MOVEA.L Tags,A1
    562. 

  562.         MOVEA.L IdentifyBase,A6
    563. 

  563.         JSR     -072(A6)
    564. 

  564.         MOVEA.L (A7)+,A6
    565. 

  565.         MOVE.L  D0,@RESULT
    566. 

  566.   END;
    567. 

  567. END;
    568. 

  568. 

  569. {
    570. 

  570.  Functions and procedures with array of const go here
    571. 

  571. }
    572. 

  572. FUNCTION IdExpansionTags(const TagList : Array Of Const) : LONGINT;
    573. 

  573. begin
    574. 

  574.     IdExpansionTags := IdExpansion(readintags(TagList));
    575. 

  575. end;
    576. 

  576. 

  577. FUNCTION IdHardwareTags(Type_ : longword; const TagList : Array Of Const) : pCHAR;
    578. 

  578. begin
    579. 

  579.     IdHardwareTags := IdHardware(Type_ , readintags(TagList));
    580. 

  580. end;
    581. 

  581. 

  582. FUNCTION IdAlertTags(ID : longword; const TagList : Array Of Const) : LONGINT;
    583. 

  583. begin
    584. 

  584.     IdAlertTags := IdAlert(ID , readintags(TagList));
    585. 

  585. end;
    586. 

  586. 

  587. FUNCTION IdFunctionTags(LibName : pCHAR; Offset : LONGINT; const TagList : Array Of Const) : LONGINT;
    588. 

  588. begin
    589. 

  589.     IdFunctionTags := IdFunction(LibName , Offset , readintags(TagList));
    590. 

  590. end;
    591. 

  591. 

  592. FUNCTION IdHardwareNumTags(Type_ : longword; const TagList : Array Of Const) : longword;
    593. 

  593. begin
    594. 

  594.     IdHardwareNumTags := IdHardwareNum(Type_ , readintags(TagList));
    595. 

  595. end;
    596. 

  596. 

  597. FUNCTION IdFormatStringTags(String_ : pCHAR; Buffer : pCHAR; Length : longword; const Tags : Array Of Const) : longword;
    598. 

  598. begin
    599. 

  599.     IdFormatStringTags := IdFormatString(String_ , Buffer , Length , readintags(Tags));
    600. 

  600. end;
    601. 

  601. 

  602. FUNCTION IdEstimateFormatSizeTags(String_ : pCHAR; const Tags : Array Of Const) : longword;
    603. 

  603. begin
    604. 

  604.     IdEstimateFormatSizeTags := IdEstimateFormatSize(String_ , readintags(Tags));
    605. 

  605. end;
    606. 

  606. 

  607. {
    608. 

  608.      Overlay functions
    609. 

  609. }
    610. 

  610. 

  611. FUNCTION IdFunction(LibName : string; Offset : LONGINT; TagList : pTagItem) : LONGINT;
    612. 

  612. begin
    613. 

  613.     IdFunction := IdFunction(pas2c(LibName),Offset,TagList);
    614. 

  614. end;
    615. 

  615. 

  616. FUNCTION IdFormatString(String_ : string; Buffer : pCHAR; Length : Ulong; Tags : pTagItem) : Ulong;
    617. 

  617. begin
    618. 

  618.     IdFormatString := IdFormatString(pas2c(String_),Buffer,Length,Tags);
    619. 

  619. end;
    620. 

  620. 

  621. FUNCTION IdEstimateFormatSize(String_ : string; Tags : pTagItem) : Ulong;
    622. 

  622. begin
    623. 

  623.     IdEstimateFormatSize := IdEstimateFormatSize(pas2c(String_),Tags);
    624. 

  624. end;
    625. 

  625. 

  626. FUNCTION IdFunctionTags(LibName : string; Offset : LONGINT; const TagList : Array Of Const) : LONGINT;
    627. 

  627. begin
    628. 

  628.     IdFunctionTags := IdFunction(pas2c(LibName),Offset,readintags(TagList));
    629. 

  629. end;
    630. 

  630. 

  631. FUNCTION IdFormatStringTags(String_ : string; Buffer : pCHAR; Length : longword; const Tags : Array Of Const) : longword;
    632. 

  632. begin
    633. 

  633.     IdFormatStringTags := IdFormatString(pas2c(String_),Buffer,Length,readintags(Tags));
    634. 

  634. end;
    635. 

  635. 

  636. FUNCTION IdEstimateFormatSizeTags(String_ : string; const Tags : Array Of Const) : longword;
    637. 

  637. begin
    638. 

  638.     IdEstimateFormatSizeTags := IdEstimateFormatSize(pas2c(String_),readintags(Tags));
    639. 

  639. end;
    640. 

  640. 

  641. const
    642. 

  642.     { Change VERSION and LIBVERSION to proper values }
    643. 

  643. 

  644.     VERSION : string[2] = '0';
    645. 

  645.     LIBVERSION : longword = 0;
    646. 

  646. 

  647. {$ifdef use_init_openlib}
    648. 

  648.   {$Info Compiling initopening of identify.library}
    649. 

  649.   {$Info don't forget to use InitIDENTIFYLibrary in the beginning of your program}
    650. 

    651. 

  651. var
    652. 

  652.     identify_exit : Pointer;
    653. 

  653. 

  654. procedure CloseidentifyLibrary;
    655. 

  655. begin
    656. 

  656.     ExitProc := identify_exit;
    657. 

  657.     if IdentifyBase <> nil then begin
    658. 

  658.         CloseLibrary(IdentifyBase);
    659. 

  659.         IdentifyBase := nil;
    660. 

  660.     end;
    661. 

  661. end;
    662. 

  662. 

  663. procedure InitIDENTIFYLibrary;
    664. 

  664. begin
    665. 

  665.     IdentifyBase := nil;
    666. 

  666.     IdentifyBase := OpenLibrary(IDENTIFYNAME,LIBVERSION);
    667. 

  667.     if IdentifyBase <> nil then begin
    668. 

  668.         identify_exit := ExitProc;
    669. 

  669.         ExitProc := @CloseidentifyLibrary;
    670. 

  670.     end else begin
    671. 

  671.         MessageBox('FPC Pascal Error',
    672. 

  672.         'Can''t open identify.library version ' + VERSION + #10 +
    673. 

  673.         'Deallocating resources and closing down',
    674. 

  674.         'Oops');
    675. 

  675.         halt(20);
    676. 

  676.     end;
    677. 

  677. end;
    678. 

  678. 

  679. begin
    680. 

  680.     IDENTIFYIsCompiledHow := 2;
    681. 

  681. {$endif use_init_openlib}
    682. 

  682. 

  683. {$ifdef use_auto_openlib}
    684. 

  684.   {$Info Compiling autoopening of identify.library}
    685. 

  685. 

  686. var
    687. 

  687.     identify_exit : Pointer;
    688. 

  688. 

  689. procedure CloseidentifyLibrary;
    690. 

  690. begin
    691. 

  691.     ExitProc := identify_exit;
    692. 

  692.     if IdentifyBase <> nil then begin
    693. 

  693.         CloseLibrary(IdentifyBase);
    694. 

  694.         IdentifyBase := nil;
    695. 

  695.     end;
    696. 

  696. end;
    697. 

  697. 

  698. begin
    699. 

  699.     IdentifyBase := nil;
    700. 

  700.     IdentifyBase := OpenLibrary(IDENTIFYNAME,LIBVERSION);
    701. 

  701.     if IdentifyBase <> nil then begin
    702. 

  702.         identify_exit := ExitProc;
    703. 

  703.         ExitProc := @CloseidentifyLibrary;
    704. 

  704.         IDENTIFYIsCompiledHow := 1;
    705. 

  705.     end else begin
    706. 

  706.         MessageBox('FPC Pascal Error',
    707. 

  707.         'Can''t open identify.library version ' + VERSION + #10 +
    708. 

  708.         'Deallocating resources and closing down',
    709. 

  709.         'Oops');
    710. 

  710.         halt(20);
    711. 

  711.     end;
    712. 

  712. 

  713. {$endif use_auto_openlib}
    714. 

  714. 

  715. {$ifdef dont_use_openlib}
    716. 

  716. begin
    717. 

  717.     IDENTIFYIsCompiledHow := 3;
    718. 

  718.    {$Warning No autoopening of identify.library compiled}
    719. 

  719.    {$Warning Make sure you open identify.library yourself}
    720. 

  720. {$endif dont_use_openlib}
    721. 

  721. 

  722. 

  723. END. (* UNIT IDENTIFY *)
    724.