home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 1995 December / SOFM_Dec1995.bin / pc / os2 / vpascal / source / tv / tv4vp.pat < prev    next >
Text File  |  1995-10-31  |  167KB  |  4,772 lines
  1. Comparing BP7\OBJECTS.PAS and VP\OBJECTS.PAS 
  2. 10a11,12
  3. > { NOTE: TEmsStream is not implemented.                  }
  4. > 
  5. 13c15
  6. < {$O+,F+,X+,I-,S-}
  7. > {$X+,I-,S-,B-,Cdecl-}
  8. 16a19,20
  9. > uses Use32;
  10. > 
  11. 38c42
  12. <   MaxCollectionSize = 65520 div SizeOf(Pointer);
  13. >   MaxCollectionSize = 512*1024*1024 div SizeOf(Pointer);
  14. 47c51
  15. <   vmtHeaderSize = 8;
  16. >   vmtHeaderSize = 12;
  17. 58c62
  18. <     Lo, Hi: Word;
  19. >     Lo, Hi: SmallWord;
  20. 62c66
  21. <     Ofs, Seg: Word;
  22. >     Ofs: Longint;
  23. 77c81
  24. <   TByteArray = array[0..32767] of Byte;
  25. >   TByteArray = array[0..512*1024*1024] of Byte;
  26. 80c84,87
  27. <   TWordArray = array[0..16383] of Word;
  28. >   TWordArray = array[0..512*1024*1024 div 2] of SmallWord;
  29. > 
  30. >   PLongArray = ^TLongArray;
  31. >   TLongArray = array[0..512*1024*1024 div 4] of Longint;
  32. 81a89,91
  33. >   PPtrArray = ^TPtrArray;
  34. >   TPtrArray = array[0..512*1024*1024 div 4] of Pointer;
  35. > 
  36. 99c109
  37. <     Next: Word;
  38. >     Next: PStreamRec;
  39. 129,133c139
  40. < {$IFDEF Windows}
  41. >   FNameStr = String;
  42. 158c164
  43. <     constructor Init(FileName: FNameStr; Mode, Size: Word);
  44. >     constructor Init(const FileName: FNameStr; Mode, Size: Word);
  45. 169,186d174
  46. < { TEmsStream }
  47. 191,193c179,181
  48. <     SegCount: Integer;
  49. >     BlockCount: Integer;
  50. >     BlockList: PPtrArray;
  51. >     CurBlock: Integer;
  52. 283,284d270
  53. < {$IFNDEF Windows}
  54. 378,379d363
  55. < {$ENDIF}
  56. 385,392d368
  57. < { Longint routines }
  58. 404a381,384
  59. > { Analog to DOS int 21h I/O functions }
  60. > 
  61. > procedure DosFn;
  62. > 
  63. 411,415d390
  64. < { EMS stream state variables }
  65. 439,440d413
  66. < {$IFNDEF Windows }
  67. 455,456d427
  68. < {$ENDIF}
  69. 459,471c430
  70. < {$IFDEF Windows}
  71. > uses Memory, Strings, Os2Base;
  72. 487d445
  73. < {$IFNDEF Windows}
  74. 489d446
  75. < {$ENDIF}
  76. 506c463
  77. <   StreamTypes: Word = 0;
  78. >   StreamTypes: PStreamRec = nil;
  79. 513,531c470,478
  80. < procedure RegisterType(var S: TStreamRec); assembler;
  81. > procedure RegisterType(var S: TStreamRec);
  82. > var
  83. >   P: PStreamRec;
  84. > begin
  85. >   P := StreamTypes;
  86. >   while (P <> nil) and (P^.ObjType <> S.ObjType) do P := P^.Next;
  87. >   if (P <> nil) or (S.ObjType = 0) then RegisterError;
  88. >   S.Next := StreamTypes;
  89. >   StreamTypes := @S;
  90. 543,559c490,502
  91. < { In    AX    = Error info                              }
  92. > { In    eax   = Error info                              }
  93. > {       dl    = Error code                              }
  94. > {       ecx   = Stream object pointer                   }
  95. > { Uses  eax,edx                                         }
  96. > 
  97. > procedure DoStreamError; assembler; {$USES ecx} {$FRAME-}
  98. > asm
  99. >                 movsx   edx,dl
  100. >                 push    edx             { [1]:Integer = Code    }
  101. >                 push    eax             { [2]:Integer = Info    }
  102. >                 push    ecx             { [3]:Pointer = Self    }
  103. >                 mov     eax,[ecx]
  104. >                 Call    DWord Ptr [eax].TStream_Error
  105. 598c541
  106. < function TStream.Get: PObject; assembler;
  107. > function TStream.Get: PObject; assembler; {$USES None} {$FRAME+}
  108. 600,635c543,573
  109. <         PUSH    AX
  110. >                 push    eax
  111. >                 mov     eax,esp
  112. >                 push    eax                     { [1]:Pointer = Buf   }
  113. >                 push    4                       { [2]:DWord   = Count }
  114. >                 mov     eax,Self
  115. >                 push    eax                     { [3]:Pointer = Self  }
  116. >                 mov     eax,[eax]
  117. >                 Call    DWord Ptr [eax].TStream_Read
  118. >                 pop     eax
  119. >                 test    eax,eax                 { Return nil }
  120. >                 jz      @@4
  121. >                 mov     edx,StreamTypes
  122. >                 jmp     @@2
  123. >               @@1:
  124. >                 cmp     eax,[edx].TStreamRec.ObjType
  125. >                 je      @@3
  126. >                 mov     edx,[edx].TStreamRec.Next
  127. >               @@2:
  128. >                 test    edx,edx
  129. >                 jnz     @@1
  130. >                 mov     ecx,Self
  131. >                 mov     dl,stGetError
  132. >                 Call    DoStreamError
  133. >                 xor     eax,eax                 { Return nil }
  134. >                 jmp     @@4
  135. >               @@3:
  136. >                 push    Self                    { [1]:Pointer = TStream }
  137. >                 push    [edx].TStreamRec.VmtLink{ [2]:DWord   = VMT     }
  138. >                 push    0                       { [3]:Pointer = Self = nil: allocate in dynamic memory }
  139. >                 Call    [edx].TStreamRec.Load
  140. >               @@4:                              { Return Self or nil }
  141. 648c586
  142. < procedure TStream.Put(P: PObject); assembler;
  143. > procedure TStream.Put(P: PObject); assembler; {$USES None} {$FRAME+}
  144. 650,688c588,622
  145. <         LES     DI,P
  146. >                 mov     ecx,P
  147. >                 jecxz   @@4
  148. >                 mov     eax,[ecx]               { VMT pointer }
  149. >                 mov     edx,StreamTypes
  150. >                 jmp     @@2
  151. >               @@1:
  152. >                 cmp     eax,[edx].TStreamRec.VmtLink
  153. >                 je      @@3
  154. >                 mov     edx,[edx].TStreamRec.Next
  155. >               @@2:
  156. >                 test    edx,edx
  157. >                 jne     @@1
  158. >                 mov     ecx,Self
  159. >                 mov     dl,stPutError
  160. >                 Call    DoStreamError
  161. >                 jmp     @@5
  162. >               @@3:
  163. >                 mov     ecx,[edx].TStreamRec.ObjType
  164. >               @@4:
  165. >                 push    edx
  166. >                 push    ecx                     { Write object type  }
  167. >                 mov     eax,esp
  168. >                 push    eax                     { [1]:Pointer = Buf  }
  169. >                 push    4                       { [2]:DWord   = Size }
  170. >                 mov     eax,Self                { [3]:Pointer = Self }
  171. >                 push    eax
  172. >                 mov     eax,[eax]
  173. >                 Call    DWord Ptr [eax].TStream_Write
  174. >                 pop     ecx
  175. >                 pop     edx
  176. >                 jecxz   @@5
  177. >                 push    Self                    { [1]:Pointer = TStream }
  178. >                 push    P                       { [2]:Pointer = Self    }
  179. >                 Call    [edx].TStreamRec.Store
  180. >               @@5:
  181. 764a699,700
  182. > {$USES ebx,esi,edi} {$FRAME+}
  183. > 
  184. 769,972c705,877
  185. <         XOR     AX,AX
  186. >                 push    0                       { [1]:DWord = VMT       }
  187. >                 push    Self                    { [2]:Pointer = Self    }
  188. >                 Call    TStream.Init            { Inherited Init;       }
  189. >                 mov     esi,FileName
  190. >                 lea     edi,NameBuf
  191. >                 mov     edx,edi                 { edx = @FName (ASCIIZ) }
  192. >                 xor     eax,eax
  193. >                 cld
  194. >                 lodsb
  195. >                 cmp     al,79
  196. >                 jb      @@1
  197. >                 mov     al,79
  198. >               @@1:
  199. >                 xchg    ecx,eax
  200. >                 rep     movsb                   { File name             }
  201. >                 xchg    eax,ecx
  202. >                 stosb                           { Null terminator       }
  203. >                 xor     ecx,ecx                 { ecx = File attribute  }
  204. >                 mov     eax,Mode                { ah=DosFn,al=Open mode }
  205. >                 Call    DosFn
  206. >                 jnc     @@2                     { eax = File Handle     }
  207. >                 mov     ecx,Self
  208. >                 mov     dl,stInitError
  209. >                 Call    DoStreamError
  210. >                 or      eax,-1
  211. >               @@2:
  212. >                 mov     ecx,Self
  213. >                 mov     [ecx].TDosStream.Handle,eax
  214. > end;
  215. > 
  216. > destructor TDosStream.Done; assembler; {$USES ebx} {$FRAME+}
  217. > asm
  218. >                 mov     eax,Self
  219. >                 mov     ebx,[eax].TDosStream.Handle
  220. >                 cmp     ebx,-1
  221. >                 je      @@1
  222. >                 mov     ah,3Eh                  { Close file            }
  223. >                 Call    DosFn
  224. >               @@1:
  225. >                 push    0                       { [1]:DWord = VMT       }
  226. >                 push    Self                    { [2]:Pointer = Self    }
  227. >                 Call    TStream.Done            { Inherited Done;       }
  228. > end;
  229. > 
  230. > function TDosStream.GetPos: Longint; assembler; {$USES ebx} {$FRAME-}
  231. > asm
  232. >                 mov     eax,Self
  233. >                 cmp     [eax].TDosStream.Status,stOk
  234. >                 jne     @@1
  235. >                 xor     ecx,ecx                 { ecx = Distance        }
  236. >                 mov     ebx,[eax].TDosStream.Handle { ebx = File Handle }
  237. >                 mov     ax,4201h                { Get current position  }
  238. >                 Call    DosFn
  239. >                 jnc     @@2
  240. >                 mov     ecx,Self
  241. >                 mov     dl,stError
  242. >                 Call    DoStreamError           { eax = Current FilePtr }
  243. >               @@1:
  244. >                 or      eax,-1
  245. >               @@2:
  246. > end;
  247. > 
  248. > function TDosStream.GetSize: Longint; assembler; {$USES ebx} {$FRAME-}
  249. > asm
  250. >                 mov     eax,Self
  251. >                 cmp     [eax].TDosStream.Status,stOk
  252. >                 jne     @@1
  253. >                 xor     ecx,ecx                 { ecx = Distance        }
  254. >                 mov     ebx,[eax].TDosStream.Handle
  255. >                 mov     ax,4201h                { ebx = Handle          }
  256. >                 Call    DosFn
  257. >                 push    eax                     { Save current position }
  258. >                 xor     ecx,ecx
  259. >                 mov     ax,4202h                { Move to the EOF       }
  260. >                 Call    DosFn
  261. >                 pop     ecx
  262. >                 push    eax
  263. >                 mov     ax,4200h                { Restore old position  }
  264. >                 Call    DosFn
  265. >                 pop     eax
  266. >                 jnc     @@2
  267. >                 mov     ecx,Self
  268. >                 mov     dl,stError
  269. >                 Call    DoStreamError
  270. >               @@1:
  271. >                 or      eax,-1
  272. >               @@2:
  273. > end;
  274. > 
  275. > procedure TDosStream.Read(var Buf; Count: Word); assembler; {$USES ebx,edi} {$FRAME-}
  276. > asm
  277. >                 mov     edi,Self
  278. >                 cmp     [edi].TDosStream.Status,stOk
  279. >                 jne     @@2
  280. >                 mov     edx,Buf                 { edx = Buffer@         }
  281. >                 mov     ecx,Count               { ecx = Count           }
  282. >                 mov     ebx,[edi].TDosStream.Handle { ebx = File Handle }
  283. >                 mov     ah,3Fh                  { Read file             }
  284. >                 Call    DosFn
  285. >                 mov     dl,stError
  286. >                 jc      @@1
  287. >                 cmp     eax,ecx
  288. >                 je      @@3
  289. >                 xor     eax,eax
  290. >                 mov     dl,stReadError
  291. >               @@1:
  292. >                 mov     ecx,edi
  293. >                 Call    DoStreamError
  294. >               @@2:
  295. >                 mov     edi,Buf
  296. >                 mov     ecx,Count
  297. >                 xor     al,al
  298. >                 cld
  299. >                 rep     stosb
  300. >               @@3:
  301. > end;
  302. > 
  303. > procedure TDosStream.Seek(Pos: Longint); assembler; {$USES ebx} {$FRAME-}
  304. > asm
  305. >                 mov     eax,Self
  306. >                 cmp     [eax].TDosStream.Status,stOk
  307. >                 jne     @@2
  308. >                 mov     ecx,Pos
  309. >                 test    ecx,ecx
  310. >                 jns     @@1
  311. >                 xor     ecx,ecx
  312. >               @@1:
  313. >                 mov     ebx,[eax].TDosStream.Handle
  314. >                 mov     ax,4200h
  315. >                 Call    DosFn
  316. >                 jnc     @@2
  317. >                 mov     ecx,Self
  318. >                 mov     dl,stError
  319. >                 Call    DoStreamError
  320. >               @@2:
  321. > end;
  322. > 
  323. > procedure TDosStream.Truncate; assembler; {$USES ebx} {$FRAME-}
  324. > asm
  325. >                 mov     eax,Self
  326. >                 cmp     [eax].TDosStream.Status,stOk
  327. >                 jne     @@1
  328. >                 xor     ecx,ecx                 { ecx=0: Truncate file  }
  329. >                 mov     ebx,[eax].TDosStream.Handle
  330. >                 mov     ah,40h                  { Write file            }
  331. >                 Call    DosFn
  332. >                 jnc     @@1
  333. >                 mov     ecx,Self
  334. >                 mov     dl,stError
  335. >                 Call    DoStreamError
  336. >               @@1:
  337. > end;
  338. > 
  339. > procedure TDosStream.Write(var Buf; Count: Word); assembler; {$USES ebx} {$FRAME-}
  340. > asm
  341. >                 mov     eax,Self
  342. >                 cmp     [eax].TDosStream.Status,stOk
  343. >                 jne     @@2
  344. >                 mov     edx,Buf
  345. >                 mov     ecx,Count
  346. >                 mov     ebx,[eax].TDosStream.Handle
  347. >                 mov     ah,40h
  348. >                 Call    DosFn
  349. >                 mov     dl,stError
  350. >                 jc      @@1
  351. >                 cmp     eax,ecx
  352. >                 je      @@2
  353. >                 xor     eax,eax
  354. >                 mov     dl,stWriteError
  355. >               @@1:
  356. >                 mov     ecx,Self
  357. >                 Call    DoStreamError
  358. >               @@2:
  359. 979c884
  360. < {       ES:DI = TBufStream pointer                      }
  361. > {       edi   = TBufStream pointer                      }
  362. 982c887
  363. < procedure FlushBuffer; near; assembler;
  364. > procedure FlushBuffer; assembler; {$USES ebx} {$FRAME-}
  365. 984,1014c889,919
  366. <         MOV     CX,ES:[DI].TBufStream.BufPtr
  367. >                 mov     ecx,[edi].TBufStream.BufPtr
  368. >                 sub     ecx,[edi].TBufStream.BufEnd
  369. >                 je      @@3
  370. >                 mov     ebx,[edi].TDosStream.Handle
  371. >                 ja      @@1
  372. >                 cmp     al,1
  373. >                 je      @@4
  374. >                 mov     ax,4201h                { Seek from current position }
  375. >                 Call    DosFn
  376. >                 jmp     @@3
  377. >               @@1:
  378. >                 cmp     al,0
  379. >                 je      @@4
  380. >                 mov     edx,[edi].TBufStream.Buffer
  381. >                 mov     ah,40h
  382. >                 Call    DosFn
  383. >                 mov     dl,stError
  384. >                 jc      @@2
  385. >                 cmp     eax,ecx
  386. >                 je      @@3
  387. >                 xor     eax,eax
  388. >                 mov     dl,stWriteError
  389. >               @@2:
  390. >                 mov     ecx,edi
  391. >                 Call    DoStreamError
  392. >               @@3:
  393. >                 xor     eax,eax
  394. >                 mov     [edi].TBufStream.BufPtr,eax
  395. >                 mov     [edi].TBufStream.BufEnd,eax
  396. >                 cmp     [edi].TStream.Status,stOk
  397. >               @@4:
  398. 1017c922
  399. < constructor TBufStream.Init(FileName: FNameStr; Mode, Size: Word);
  400. > constructor TBufStream.Init(const FileName: FNameStr; Mode, Size: Word);
  401. 1034c939
  402. < procedure TBufStream.Flush; assembler;
  403. > procedure TBufStream.Flush; assembler;  {$USES edi} {$FRAME-}
  404. 1036,1155c941,1052
  405. <         LES     DI,Self
  406. >                 mov     edi,Self
  407. >                 cmp     [edi].TBufStream.Status,stOk
  408. >                 jne     @@1
  409. >                 mov     al,2                    { Read/Write mode }
  410. >                 Call    FlushBuffer
  411. >               @@1:
  412. > end;
  413. > 
  414. > function TBufStream.GetPos: Longint; assembler; {$USES edi} {$FRAME-}
  415. > asm
  416. >                 mov     edi,Self
  417. >                 push    edi
  418. >                 Call    TDosStream.GetPos
  419. >                 test    eax,eax
  420. >                 js      @@1
  421. >                 sub     eax,[edi].TBufStream.BufEnd
  422. >                 add     eax,[edi].TBufStream.BufPtr
  423. >               @@1:
  424. > end;
  425. > 
  426. > function TBufStream.GetSize: Longint; assembler; {$USES None} {$FRAME-}
  427. > asm
  428. >                 mov     eax,Self
  429. >                 push    eax
  430. >                 push    eax
  431. >                 Call    TBufStream.Flush
  432. >                 Call    TDosStream.GetSize
  433. > end;
  434. > 
  435. > procedure TBufStream.Read(var Buf; Count: Word); assembler; {$USES ebx,esi,edi} {$FRAME-}
  436. > asm
  437. >                 mov     edi,Self
  438. >                 cmp     [edi].TBufStream.Status,stOk
  439. >                 jne     @@6
  440. >                 mov     al,1                    { Write mode }
  441. >                 Call    FlushBuffer
  442. >                 jne     @@6
  443. >                 xor     ebx,ebx
  444. >               @@1:
  445. >                 mov     ecx,Count
  446. >                 sub     ecx,ebx
  447. >                 je      @@7
  448. >                 mov     edi,Self
  449. >                 mov     eax,[edi].TBufStream.BufEnd
  450. >                 sub     eax,[edi].TBufStream.BufPtr
  451. >                 ja      @@2
  452. >                 push    ecx
  453. >                 push    ebx
  454. >                 mov     edx,[edi].TBufStream.Buffer
  455. >                 mov     ecx,[edi].TBufStream.BufSize
  456. >                 mov     ebx,[edi].TBufStream.Handle
  457. >                 mov     ah,3Fh
  458. >                 Call    DosFn
  459. >                 pop     ebx
  460. >                 pop     ecx
  461. >                 mov     dl,stError
  462. >                 jc      @@5
  463. >                 and     [edi].TBufStream.BufPtr,0
  464. >                 mov     [edi].TBufStream.BufEnd,eax
  465. >                 test    eax,eax
  466. >                 je      @@4
  467. >               @@2:
  468. >                 cmp     ecx,eax
  469. >                 jb      @@3
  470. >                 mov     ecx,eax
  471. >               @@3:
  472. >                 mov     esi,[edi].TBufStream.Buffer
  473. >                 add     esi,[edi].TBufStream.BufPtr
  474. >                 add     [edi].TBufStream.BufPtr,ecx
  475. >                 mov     edi,Buf
  476. >                 add     edi,ebx
  477. >                 add     ebx,ecx
  478. >                 cld
  479. >                 rep     movsb
  480. >                 jmp     @@1
  481. >               @@4:
  482. >                 mov     dl,stReadError
  483. >               @@5:
  484. >                 mov     ecx,edi
  485. >                 Call    DoStreamError
  486. >               @@6:
  487. >                 mov     edi,Buf
  488. >                 mov     ecx,Count
  489. >                 xor     al,al
  490. >                 cld
  491. >                 rep     stosb
  492. >               @@7:
  493. > end;
  494. > 
  495. > procedure TBufStream.Seek(Pos: Longint); assembler; {$USES edi} {$FRAME-}
  496. > asm
  497. >                 mov     edi,Self
  498. >                 push    edi
  499. >                 Call    TDosStream.GetPos
  500. >                 test    eax,eax
  501. >                 js      @@2
  502. >                 sub     eax,Pos
  503. >                 jne     @@1
  504. >                 test    eax,eax
  505. >                 je      @@1
  506. >                 mov     edx,[edi].TBufStream.BufEnd
  507. >                 sub     edx,eax
  508. >                 jb      @@1
  509. >                 mov     [edi].TBufStream.BufPtr,edx
  510. >                 jmp     @@2
  511. >               @@1:
  512. >                 push    edi
  513. >                 Call    TBufStream.Flush
  514. >                 push    Pos
  515. >                 push    edi
  516. >                 Call    TDosStream.Seek
  517. >               @@2:
  518. 1164,1261c1061
  519. < procedure TBufStream.Write(var Buf; Count: Word); assembler;
  520. > procedure TBufStream.Write(var Buf; Count: Word); assembler; {$USES esi,edi} {$FRAME-}
  521. 1263,1517c1063,1101
  522. <         XOR     AX,AX
  523. >                 mov     edi,Self
  524. >                 cmp     [edi].TBufStream.Status,stOk
  525. >                 jne     @@4
  526. >                 mov     al,0                    { Read mode }
  527. >                 Call    FlushBuffer
  528. >                 jne     @@4
  529. >                 xor     edx,edx
  530. >               @@1:
  531. >                 mov     ecx,Count
  532. >                 sub     ecx,edx
  533. >                 je      @@4
  534. >                 mov     edi,Self
  535. >                 mov     eax,[edi].TBufStream.BufSize
  536. >                 sub     eax,[edi].TBufStream.BufPtr
  537. >                 ja      @@2
  538. >                 push    ecx
  539. >                 push    edx
  540. >                 mov     al,1                    { Write mode }
  541. >                 Call    FlushBuffer
  542. >                 pop     edx
  543. >                 pop     ecx
  544. >                 jne     @@4
  545. >                 mov     eax,[edi].TBufStream.BufSize
  546. >               @@2:
  547. >                 cmp     ecx,eax
  548. >                 jb      @@3
  549. >                 mov     ecx,eax
  550. >               @@3:
  551. >                 mov     eax,[edi].TBufStream.BufPtr
  552. >                 add     [edi].TBufStream.BufPtr,ecx
  553. >                 mov     edi,[edi].TBufStream.Buffer
  554. >                 add     edi,eax
  555. >                 mov     esi,Buf
  556. >                 add     esi,edx
  557. >                 add     edx,ecx
  558. >                 cld
  559. >                 rep     movsb
  560. >                 jmp     @@1
  561. >               @@4:
  562. 1523,1527c1107,1108
  563. <   MaxSegArraySize = 16384;
  564. >   MaxBlockArraySize = 512 * 1024 * 1024 div 4;
  565. >   DefaultBlockSize = 8 * 1024;
  566. 1529,1544c1110,1124
  567. < {$ELSE}
  568. > { Selects TMemoryStream memory block                            }
  569. > { In    edi   = TMemoryStream pointer                           }
  570. > { Out   ecx   = Distance between position and end of block      }
  571. > {       esi   = Position within the selected block              }
  572. > 
  573. > procedure MemSelectBlock; assembler; {$USES None} {$FRAME-}
  574. > asm
  575. >                 mov     eax,[edi].TMemoryStream.Position
  576. >                 xor     edx,edx
  577. >                 mov     ecx,[edi].TMemoryStream.BlockSize
  578. >                 div     ecx
  579. >                 sub     ecx,edx
  580. >                 mov     esi,edx
  581. >                 shl     eax,2
  582. >                 mov     [edi].TMemoryStream.CurBlock,eax
  583. 1550c1130
  584. < constructor TMemoryStream.Init(ALimit: Longint; ABlockSize: Word); assembler;
  585. > constructor TMemoryStream.Init(ALimit: Longint; ABlockSize: Word); assembler; {$USES edi} {$FRAME+}
  586. 1552,1591c1132,1158
  587. <         XOR     AX,AX
  588. >                 push    0
  589. >                 push    Self
  590. >                 Call    TStream.Init
  591. >                 mov     edi,Self
  592. >                 cmp     ABlockSize,0
  593. >                 jnz     @@1
  594. >                 mov     ABlockSize,DefaultBlockSize
  595. >               @@1:
  596. >                 mov     ecx,ABlockSize
  597. >                 mov     eax,ALimit
  598. >                 xor     edx,edx
  599. >                 div     ecx
  600. >                 neg     edx
  601. >                 adc     eax,0
  602. >                 mov     [edi].TMemoryStream.BlockSize,ecx
  603. >                 push    eax                     { [1]:DWord = ALimit    }
  604. >                 push    edi                     { [2]:Pointer = Self    }
  605. >                 Call    ChangeListSize
  606. >                 test    al,al
  607. >                 jnz     @@2
  608. >                 mov     dl,stInitError
  609. >                 mov     ecx,edi
  610. >                 Call    DoStreamError
  611. >                 and     ALimit,0
  612. >               @@2:
  613. >                 mov     eax,ALimit
  614. >                 mov     [edi].TMemoryStream.Size,eax
  615. 1602c1169
  616. <   AItems: PWordArray;
  617. >   AItems: PPtrArray;
  618. 1607,1608c1174,1175
  619. <   if ALimit > MaxSegArraySize then ALimit := MaxSegArraySize;
  620. >   if ALimit > MaxBlockArraySize then ALimit := MaxBlockArraySize;
  621. >   if ALimit <> BlockCount then
  622. 1612c1179
  623. <       AItems := MemAlloc(ALimit * SizeOf(Word));
  624. >       AItems := MemAlloc(ALimit * SizeOf(Pointer));
  625. 1614,1617c1181,1184
  626. <       FillChar(AItems^, ALimit * SizeOf(Word), 0);
  627. >       FillChar(AItems^, ALimit * SizeOf(Pointer), 0);
  628. >       if (BlockCount <> 0) and (BlockList <> nil) then
  629. >         if BlockCount > ALimit then
  630. >           Move(BlockList^, AItems^, ALimit * SizeOf(Pointer))
  631. 1619c1186
  632. <           Move(SegList^, AItems^, SegCount * SizeOf(Word));
  633. >           Move(BlockList^, AItems^, BlockCount * SizeOf(Pointer));
  634. 1621c1188
  635. <     if ALimit < SegCount then
  636. >     if ALimit < BlockCount then
  637. 1624c1191
  638. <       Term := SegCount - 1;
  639. >       Term := BlockCount - 1;
  640. 1627,1628c1194,1195
  641. <         if SegList^[Dif] <> 0 then
  642. >         if BlockList^[Dif] <> nil then
  643. >           FreeMem(BlockList^[Dif], BlockSize);
  644. 1634c1201
  645. <       Dif := SegCount;
  646. >       Dif := BlockCount;
  647. 1638c1205
  648. <         NewBlock := MemAllocSeg(BlockSize);
  649. >         NewBlock := MemAlloc(BlockSize);
  650. 1640c1207
  651. <         else AItems^[Dif] := PtrRec(NewBlock).Seg;
  652. >         else AItems^[Dif] := NewBlock;
  653. 1646,1648c1213,1215
  654. <     if SegCount <> 0 then FreeMem(SegList, SegCount * SizeOf(Word));
  655. >     if BlockCount <> 0 then FreeMem(BlockList, BlockCount * SizeOf(Pointer));
  656. >     BlockList := AItems;
  657. >     BlockCount := ALimit;
  658. 1652,1836c1219,1369
  659. < function TMemoryStream.GetPos: Longint; assembler;
  660. > function TMemoryStream.GetPos: Longint;
  661. > begin
  662. >   if Status = stOk then GetPos := Position else GetPos := -1;
  663. > end;
  664. > 
  665. > function TMemoryStream.GetSize: Longint;
  666. > begin
  667. >   if Status = stOk then GetSize := Size else GetSize := -1;
  668. > end;
  669. > 
  670. > procedure TMemoryStream.Read(var Buf; Count: Word); assembler; {$USES ebx,esi,edi} {$FRAME+}
  671. > asm
  672. >                 mov     edi,Self
  673. >                 cmp     [edi].TMemoryStream.Status,stOk
  674. >                 jne     @@3
  675. >                 xor     ebx,ebx
  676. >                 mov     eax,[edi].TMemoryStream.Position
  677. >                 add     eax,Count
  678. >                 cmp     eax,[edi].TMemoryStream.Size
  679. >                 jbe     @@7
  680. >                 xor     eax,eax
  681. >                 mov     ecx,edi
  682. >                 mov     dl,stReadError
  683. >                 Call    DoStreamError
  684. >               @@3:
  685. >                 mov     edi,Buf
  686. >                 mov     ecx,Count
  687. >                 xor     al,al
  688. >                 cld
  689. >                 rep     stosb
  690. >                 jmp     @@8
  691. >               @@5:
  692. >                 Call    MemSelectBlock
  693. >                 mov     eax,Count
  694. >                 sub     eax,ebx
  695. >                 cmp     ecx,eax
  696. >                 jb      @@6
  697. >                 mov     ecx,eax
  698. >               @@6:
  699. >                 add     [edi].TMemoryStream.Position,ecx
  700. >                 push    edi
  701. >                 mov     edx,[edi].TMemoryStream.CurBlock
  702. >                 mov     eax,[edi].TMemoryStream.BlockList
  703. >                 add     esi,[eax+edx]           { Block base pointer }
  704. >                 mov     edi,Buf
  705. >                 add     edi,ebx
  706. >                 add     ebx,ecx
  707. >                 mov     al,cl
  708. >                 shr     ecx,2
  709. >                 and     al,11b
  710. >                 cld
  711. >                 rep     movsd
  712. >                 mov     cl,al
  713. >                 rep     movsb
  714. >                 pop     edi
  715. >               @@7:
  716. >                 cmp     ebx,Count
  717. >                 jb      @@5
  718. >               @@8:
  719. > end;
  720. > 
  721. > procedure TMemoryStream.Seek(Pos: Longint);
  722. > begin
  723. >   if Status = stOk then
  724. >     if Pos > 0 then Position := Pos else Position := 0;
  725. > end;
  726. > 
  727. > procedure TMemoryStream.Truncate; assembler; {$USES None} {$FRAME-}
  728. > asm
  729. >                 mov     ecx,Self
  730. >                 cmp     [ecx].TMemoryStream.Status,stOk
  731. >                 jne     @@2
  732. >                 mov     eax,[ecx].TMemoryStream.Position
  733. >                 xor     edx,edx
  734. >                 div     [ecx].TMemoryStream.BlockSize
  735. >                 neg     edx
  736. >                 adc     eax,0
  737. >                 push    eax                     { [1]:DWord = ALimit    }
  738. >                 push    ecx                     { [2]:Pointer = Self    }
  739. >                 Call    ChangeListSize
  740. >                 mov     ecx,Self
  741. >                 test    al,al
  742. >                 jnz     @@1
  743. >                 mov     dl,stError
  744. >                 Call    DoStreamError
  745. >                 jmp     @@2
  746. >               @@1:
  747. >                 mov     eax,[ecx].TMemoryStream.Position
  748. >                 mov     [ecx].TMemoryStream.Size,eax
  749. >               @@2:
  750. > end;
  751. > 
  752. > procedure TMemoryStream.Write(var Buf; Count: Word); assembler; {$USES ebx,esi,edi} {$FRAME+}
  753. > asm
  754. >                 mov     edi,Self
  755. >                 cmp     [edi].TMemoryStream.Status,stOk
  756. >                 jne     @@7
  757. >                 xor     ebx,ebx
  758. >                 mov     eax,[edi].TMemoryStream.Position
  759. >                 add     eax,Count
  760. >                 xor     edx,edx
  761. >                 div     [edi].TMemoryStream.BlockSize
  762. >                 neg     edx
  763. >                 adc     eax,0
  764. >                 cmp     eax,[edi].TMemoryStream.BlockCount
  765. >                 jbe     @@4
  766. >                 push    eax                     { [1]:DWord = ALimit    }
  767. >                 push    edi                     { [2]:Pointer = Self    }
  768. >                 Call    ChangeListSize
  769. >                 test    al,al
  770. >                 jnz     @@4
  771. >               @@1:
  772. >                 mov     ecx,edi
  773. >                 mov     dl,stWriteError
  774. >                 Call    DoStreamError
  775. >                 jmp     @@7
  776. >               @@2:
  777. >                 Call    MemSelectBlock
  778. >                 mov     eax,Count
  779. >                 sub     eax,ebx
  780. >                 cmp     ecx,eax
  781. >                 jb      @@3
  782. >                 mov     ecx,eax
  783. >               @@3:
  784. >                 add     [edi].TMemoryStream.Position,ecx
  785. >                 push    edi
  786. >                 mov     edx,[edi].TMemoryStream.CurBlock
  787. >                 mov     eax,[edi].TMemoryStream.BlockList
  788. >                 add     esi,[eax+edx]
  789. >                 mov     edi,esi
  790. >                 mov     esi,Buf
  791. >                 add     esi,ebx
  792. >                 add     ebx,ecx
  793. >                 mov     al,cl
  794. >                 shr     ecx,2
  795. >                 and     al,11b
  796. >                 cld
  797. >                 rep     movsd
  798. >                 mov     cl,al
  799. >                 rep     movsb
  800. >                 pop     edi
  801. >               @@4:
  802. >                 cmp     ebx,Count
  803. >                 jb      @@2
  804. >               @@5:
  805. >                 mov     eax,[edi].TMemoryStream.Position
  806. >                 cmp     eax,[edi].TMemoryStream.Size
  807. >                 jbe     @@7
  808. >               @@6:
  809. >                 mov     [edi].TMemoryStream.Size,eax
  810. >               @@7:
  811. 1845,1852c1378,1390
  812. < procedure CollectionError; near; assembler;
  813. > { Reports collection error                                      }
  814. > { In     al   = Error code                                      }
  815. > {       edx   = Error info                                      }
  816. > {       edi   = TCollection pointer                             }
  817. > 
  818. > procedure CollectionError; assembler; {$USES None} {$FRAME-}
  819. > asm
  820. >                 movsx   eax,al
  821. >                 push    eax                     { [1]:DWord = Error code }
  822. >                 push    edx                     { [2]:DWord = Error info }
  823. >                 push    edi                     { [3]:Pointer = Self     }
  824. >                 mov     eax,[edi]
  825. >                 Call    DWord Ptr [eax].TCollection_Error
  826. 1886c1424
  827. < function TCollection.At(Index: Integer): Pointer; assembler;
  828. > function TCollection.At(Index: Integer): Pointer; assembler; {$USES edi} {$FRAME-}
  829. 1888,1934c1426,1463
  830. <         LES     DI,Self
  831. >                 mov     edi,Self
  832. >                 mov     edx,Index
  833. >                 test    edx,edx
  834. >                 jl      @@1
  835. >                 cmp     edx,[edi].TCollection.Count
  836. >                 jge     @@1
  837. >                 mov     edi,[edi].TCollection.Items
  838. >                 mov     eax,[edi+edx*4]
  839. >                 jmp     @@2
  840. >               @@1:
  841. >                 mov     al,coIndexError
  842. >                 Call    CollectionError
  843. >                 xor     eax,eax
  844. >               @@2:
  845. > end;
  846. > 
  847. > procedure TCollection.AtDelete(Index: Integer); assembler; {$USES esi,edi} {$FRAME-}
  848. > asm
  849. >                 mov     edi,Self
  850. >                 mov     edx,Index
  851. >                 test    edx,edx
  852. >                 jl      @@1
  853. >                 cmp     edx,[edi].TCollection.Count
  854. >                 jge     @@1
  855. >                 dec     [edi].TCollection.Count
  856. >                 mov     ecx,[edi].TCollection.Count
  857. >                 sub     ecx,edx
  858. >                 je      @@2
  859. >                 cld
  860. >                 mov     edi,[edi].TCollection.Items
  861. >                 lea     edi,[edi+edx*4]
  862. >                 lea     esi,[edi+4]
  863. >                 rep     movsd
  864. >                 jmp     @@2
  865. >               @@1:
  866. >                 mov     al,coIndexError
  867. >                 Call    CollectionError
  868. >               @@2:
  869. 1946c1475
  870. < procedure TCollection.AtInsert(Index: Integer; Item: Pointer); assembler;
  871. > procedure TCollection.AtInsert(Index: Integer; Item: Pointer); assembler; {USES esi, edi} {$FRAME-}
  872. 1948,2019c1477,1537
  873. <         LES     DI,Self
  874. >                 mov     edi,Self
  875. >                 mov     edx,Index
  876. >                 test    edx,edx
  877. >                 jl      @@3
  878. >                 mov     ecx,[edi].TCollection.Count
  879. >                 cmp     edx,ecx
  880. >                 jg      @@3
  881. >                 cmp     ecx,[edi].TCollection.Limit
  882. >                 jne     @@1
  883. >                 push    ecx
  884. >                 push    edx
  885. >                 add     ecx,[edi].TCollection.Delta
  886. >                 push    ecx                     { [1]:DWord = ALimit    }
  887. >                 push    edi                     { [2]:Pointer = Self    }
  888. >                 mov     eax,[edi]
  889. >                 Call    DWord Ptr [eax].TCollection_SetLimit
  890. >                 pop     edx
  891. >                 pop     ecx
  892. >                 cmp     ecx,[edi].TCollection.Limit
  893. >                 je      @@4
  894. >               @@1:
  895. >                 inc     [edi].TCollection.Count
  896. >                 std
  897. >                 mov     edi,[edi].TCollection.Items
  898. >                 lea     edi,[edi+ecx*4]
  899. >                 sub     ecx,edx
  900. >                 je      @@2
  901. >                 lea     esi,[edi-4]
  902. >                 rep     movsd
  903. >               @@2:
  904. >                 mov     eax,Item
  905. >                 stosd
  906. >                 cld
  907. >                 jmp     @@6
  908. >               @@3:
  909. >                 mov     al,coIndexError
  910. >                 jmp     @@5
  911. >               @@4:
  912. >                 mov     al,coOverflow
  913. >                 mov     edx,ecx
  914. >               @@5:
  915. >                 Call    CollectionError
  916. >               @@6:
  917. > end;
  918. > 
  919. > procedure TCollection.AtPut(Index: Integer; Item: Pointer); assembler; {$USES edi} {$FRAME-}
  920. > asm
  921. >                 mov     eax,Item
  922. >                 mov     edi,Self
  923. >                 mov     edx,Index
  924. >                 test    edx,edx
  925. >                 jl      @@1
  926. >                 cmp     edx,[edi].TCollection.Count
  927. >                 jge     @@1
  928. >                 mov     edi,[edi].TCollection.Items
  929. >                 mov     [edi+edx*4],eax
  930. >                 jmp     @@2
  931. >               @@1:
  932. >                 mov     al,coIndexError
  933. >                 Call    CollectionError
  934. >               @@2:
  935. 2037c1555
  936. < function TCollection.FirstThat(Test: Pointer): Pointer; assembler;
  937. > function TCollection.FirstThat(Test: Pointer): Pointer; assembler; {$USES ebx} {$FRAME-}
  938. 2039,2095c1557,1596
  939. <         LES     DI,Self
  940. >                 mov     edx,Self
  941. >                 mov     ecx,[edx].TCollection.Count
  942. >                 jecxz   @@3
  943. >                 mov     ebx,Test
  944. >                 mov     edx,[edx].TCollection.Items
  945. >               @@1:
  946. >                 push    edx
  947. >                 push    ecx
  948. >                 push    DWord Ptr [edx]         { [1]:Pointer = Item }
  949. >                 Call    ebx
  950. >                 pop     ecx
  951. >                 pop     edx
  952. >                 test    al,al
  953. >                 jnz     @@2
  954. >                 add     edx,4
  955. >                 loop    @@1
  956. >                 jmp     @@3
  957. >               @@2:
  958. >                 mov     ecx,[edx]
  959. >               @@3:
  960. >                 mov     eax,ecx
  961. > end;
  962. > 
  963. > procedure TCollection.ForEach(Action: Pointer); assembler; {$USES ebx} {$FRAME-}
  964. > asm
  965. >                 mov     edx,Self
  966. >                 mov     ecx,[edx].TCollection.Count
  967. >                 jecxz   @@2
  968. >                 mov     ebx,Action
  969. >                 mov     edx,[edx].TCollection.Items
  970. >               @@1:
  971. >                 push    edx
  972. >                 push    ecx
  973. >                 push    DWord Ptr [edx]         { [1]:Pointer = Item }
  974. >                 Call    ebx
  975. >                 pop     ecx
  976. >                 pop     edx
  977. >                 add     edx,4
  978. >                 loop    @@1
  979. >               @@2:
  980. 2122c1623
  981. < function TCollection.IndexOf(Item: Pointer): Integer; assembler;
  982. > function TCollection.IndexOf(Item: Pointer): Integer; assembler; {$USES edi} {$FRAME-}
  983. 2124,2149c1625,1642
  984. <         MOV     AX,Item.Word[0]
  985. >                 mov     eax,Item
  986. >                 mov     edi,Self
  987. >                 mov     ecx,[edi].TCollection.Count
  988. >                 jecxz   @@1
  989. >                 mov     edi,[edi].TCollection.Items
  990. >                 mov     edx,edi
  991. >                 cld
  992. >                 repne   scasd
  993. >                 jne     @@1
  994. >                 mov     eax,edi
  995. >                 sub     eax,edx
  996. >                 shr     eax,2
  997. >                 dec     eax
  998. >                 jmp     @@2
  999. >               @@1:
  1000. >                 xor     eax,eax
  1001. >                 dec     eax
  1002. >               @@2:
  1003. 2157c1650
  1004. < function TCollection.LastThat(Test: Pointer): Pointer; assembler;
  1005. > function TCollection.LastThat(Test: Pointer): Pointer; assembler; {$USES ebx} {$FRAME-}
  1006. 2159,2223c1652,1694
  1007. <         LES     DI,Self
  1008. >                 mov     edx,Self
  1009. >                 mov     ecx,[edx].TCollection.Count
  1010. >                 jecxz   @@3
  1011. >                 mov     edx,[edx].TCollection.Items
  1012. >                 lea     edx,[edx+ecx*4]
  1013. >                 mov     ebx,Test
  1014. >               @@1:
  1015. >                 sub     edx,4
  1016. >                 push    edx
  1017. >                 push    ecx
  1018. >                 push    DWord Ptr [edx]         { [1]:Pointer = Item }
  1019. >                 Call    ebx
  1020. >                 pop     ecx
  1021. >                 pop     edx
  1022. >                 test    al,al
  1023. >                 jnz     @@2
  1024. >                 loop    @@1
  1025. >                 jmp     @@3
  1026. >               @@2:
  1027. >                 mov     ecx,[edx]
  1028. >               @@3:
  1029. >                 mov     eax,ecx
  1030. > end;
  1031. > 
  1032. > procedure TCollection.Pack; assembler; {$USES esi,edi} {$FRAME-}
  1033. > asm
  1034. >                 mov     edx,Self
  1035. >                 mov     ecx,[edx].TCollection.Count
  1036. >                 jecxz   @@3
  1037. >                 mov     edi,[edx].TCollection.Items
  1038. >                 mov     esi,edi
  1039. >                 cld
  1040. >               @@1:
  1041. >                 lodsd
  1042. >                 test    eax,eax
  1043. >                 jz      @@2
  1044. >                 stosd
  1045. >               @@2:
  1046. >                 loop    @@1
  1047. >                 sub     edi,[edx].TCollection.Items
  1048. >                 shr     edi,2
  1049. >                 mov     [edx].TCollection.Count,edi
  1050. >               @@3:
  1051. 2253c1724
  1052. < procedure DoPutItem(P: Pointer); far;
  1053. > procedure DoPutItem(P: Pointer);
  1054. 2338a1810,1811
  1055. > {$USES esi,edi} {$FRAME-}
  1056. > 
  1057. 2341,2359c1814,1832
  1058. <         PUSH    DS
  1059. >                 cld
  1060. >                 xor     eax,eax
  1061. >                 xor     edx,edx
  1062. >                 mov     esi,Key1
  1063. >                 mov     edi,Key2
  1064. >                 lodsb
  1065. >                 mov     dl,[edi]
  1066. >                 inc     edi
  1067. >                 mov     ecx,eax
  1068. >                 cmp     cl,dl
  1069. >                 jbe     @@1
  1070. >                 mov     cl,dl
  1071. >               @@1:
  1072. >                 repe    cmpsb
  1073. >                 je      @@2
  1074. >                 mov     al,[esi-1]
  1075. >                 mov     dl,[edi-1]
  1076. >               @@2:
  1077. >                 sub     eax,edx
  1078. 2399,2400d1871
  1079. < {$IFNDEF Windows }
  1080. 2441c1912
  1081. < function TResourceCollection.KeyOf(Item: Pointer): Pointer; assembler;
  1082. > function TResourceCollection.KeyOf(Item: Pointer): Pointer; assembler; {$USES None} {$FRAME-}
  1083. 2443,2445c1914,1915
  1084. <         MOV     AX,Item.Word[0]
  1085. >                 mov     eax,Item
  1086. >                 add     eax,OFFSET TResourceItem.Key
  1087. 2459,2460d1928
  1088. < {$IFDEF NewExeFormat}
  1089. 2462,2473c1930,1941
  1090. <     eHdrSize:   Word;
  1091. >     eHdrSize:   SmallWord;
  1092. >     eMinAbove:  SmallWord;
  1093. >     eMaxAbove:  SmallWord;
  1094. >     eInitSS:    SmallWord;
  1095. >     eInitSP:    SmallWord;
  1096. >     eCheckSum:  SmallWord;
  1097. >     eInitPC:    SmallWord;
  1098. >     eInitCS:    SmallWord;
  1099. >     eRelocOfs:  SmallWord;
  1100. >     eOvlyNum:   SmallWord;
  1101. >     eRelocTab:  SmallWord;
  1102. >     eSpace:     array [1..30] of Byte;
  1103. 2477,2478d1944
  1104. < {$ENDIF}
  1105. 2480c1946
  1106. <     Signature: Word;
  1107. >     Signature: SmallWord;
  1108. 2483,2485c1949,1951
  1109. <         LastCount: Word;
  1110. >         LastCount: SmallWord;
  1111. >         PageCount: SmallWord;
  1112. >         ReloCount: SmallWord);
  1113. 2487c1953
  1114. <         InfoType: Word;
  1115. >         InfoType: SmallWord;
  1116. 2494,2495d1959
  1117. < {$IFDEF NewExeFormat}
  1118. 2498,2499d1961
  1119. < {$ENDIF}
  1120. 2513,2515c1975
  1121. < {$IFDEF NewExeFormat}
  1122. >         $5A4D:                                  { 'MZ' }
  1123. 2521c1981
  1124. <         $454E:
  1125. >         $584C:                                  { 'LX' }
  1126. 2526c1986
  1127. <         $4246:
  1128. >         $4246:                                  { 'FB' }
  1129. 2530c1990
  1130. <               $5250:                                    {Found Resource}
  1131. >               $5250:                            {'PR': Found Resource}
  1132. 2535,2536c1995,1996
  1133. <               $4C42: Dec(BasePos, Header.InfoSize - 8); {Found BackLink}
  1134. >               $4C42: Dec(BasePos, Header.InfoSize - 8); {'BL': Found BackLink}
  1135. >               $4648: Dec(BasePos, SizeOf(THeader) * 2); {'HF': Found HelpFile}
  1136. 2541,2542c2001,2002
  1137. <         $424E:
  1138. >         $424E:                                  { 'NB' }
  1139. >           if Header.InfoType = $3230 then       { '02': Found Debug Info}
  1140. 2547,2564d2006
  1141. < 
  1142. 2665c2107
  1143. < procedure DoCopyResource(Item: PResourceItem); far;
  1144. > procedure DoCopyResource(Item: PResourceItem);
  1145. 2710c2152
  1146. < function TStringList.Get(Key: Word): String; assembler;
  1147. > function TStringList.Get(Key: Word): String; assembler; {$USES ebx,esi,edi} {$FRAME+}
  1148. 2712,2741c2154,2180
  1149. <         PUSH    DS
  1150. >                 mov     esi,Self
  1151. >                 mov     edi,@Result
  1152. >                 cld
  1153. >                 mov     ecx,[esi].TStringList.IndexSize
  1154. >                 jecxz   @@2
  1155. >                 mov     ebx,Key
  1156. >                 mov     esi,[esi].TStringList.Index
  1157. >               @@1:
  1158. >                 mov     edx,ebx
  1159. >                 lodsd
  1160. >                 sub     edx,eax
  1161. >                 lodsd
  1162. >                 cmp     edx,eax
  1163. >                 lodsd
  1164. >                 jb      @@3
  1165. >                 loop    @@1
  1166. >               @@2:
  1167. >                 xor     al,al                   { Empty string }
  1168. >                 stosb
  1169. >                 jmp     @@4
  1170. >               @@3:
  1171. >                 push    edi                     { [1]:Pointer = String  }
  1172. >                 push    eax                     { [2]:DWord   = Offset  }
  1173. >                 push    edx                     { [3]:DWord   = Skip    }
  1174. >                 push    Self                    { [4]:Pointer = Self    }
  1175. >                 Call    TStringList.ReadStr
  1176. >               @@4:
  1177. 2806c2245
  1178. < procedure CheckEmpty; near; assembler;
  1179. > procedure CheckEmpty; assembler; {$USES None} {$FRAME-}
  1180. 2808,2970c2247,2399
  1181. <         MOV     AX,ES:[DI].TRect.A.X
  1182. >                 mov     eax,[edi].TRect.A.X
  1183. >                 cmp     eax,[edi].TRect.B.X
  1184. >                 jge     @@1
  1185. >                 mov     eax,[edi].TRect.A.Y
  1186. >                 cmp     eax,[edi].TRect.B.Y
  1187. >                 jl      @@2
  1188. >               @@1:
  1189. >                 cld
  1190. >                 xor     eax,eax
  1191. >                 stosd
  1192. >                 stosd
  1193. >                 stosd
  1194. >                 stosd
  1195. >               @@2:
  1196. > end;
  1197. > 
  1198. > procedure TRect.Assign(XA, YA, XB, YB: Integer); assembler; {$USES edi} {$FRAME-}
  1199. > asm
  1200. >                 mov     edi,Self
  1201. >                 cld
  1202. >                 mov     eax,XA
  1203. >                 stosd
  1204. >                 mov     eax,YA
  1205. >                 stosd
  1206. >                 mov     eax,XB
  1207. >                 stosd
  1208. >                 mov     eax,YB
  1209. >                 stosd
  1210. > end;
  1211. > 
  1212. > procedure TRect.Copy(R: TRect); assembler; {$USES esi,edi} {$FRAME-}
  1213. > asm
  1214. >                 mov     esi,R
  1215. >                 mov     edi,Self
  1216. >                 cld
  1217. >                 movsd
  1218. >                 movsd
  1219. >                 movsd
  1220. >                 movsd
  1221. > end;
  1222. > 
  1223. > procedure TRect.Move(ADX, ADY: Integer); assembler; {$USES None} {$FRAME-}
  1224. > asm
  1225. >                 mov     ecx,Self
  1226. >                 mov     eax,ADX
  1227. >                 add     [ecx].TRect.A.X,eax
  1228. >                 add     [ecx].TRect.B.X,eax
  1229. >                 mov     eax,ADY
  1230. >                 add     [ecx].TRect.A.Y,eax
  1231. >                 add     [ecx].TRect.B.Y,eax
  1232. > end;
  1233. > 
  1234. > procedure TRect.Grow(ADX, ADY: Integer); assembler; {$USES edi} {$FRAME-}
  1235. > asm
  1236. >                 mov     edi,Self
  1237. >                 mov     eax,ADX
  1238. >                 sub     [edi].TRect.A.X,eax
  1239. >                 add     [edi].TRect.B.X,eax
  1240. >                 mov     eax,ADY
  1241. >                 sub     [edi].TRect.A.Y,eax
  1242. >                 add     [edi].TRect.B.Y,eax
  1243. >                 Call    CheckEmpty
  1244. > end;
  1245. > 
  1246. > procedure TRect.Intersect(R: TRect); assembler; {$USES esi,edi} {$FRAME-}
  1247. > asm
  1248. >                 mov     esi,R
  1249. >                 mov     edi,Self
  1250. >                 cld
  1251. >                 lodsd
  1252. >                 scasd
  1253. >                 jle     @@1
  1254. >                 sub     edi,4
  1255. >                 stosd
  1256. >               @@1:
  1257. >                 lodsd
  1258. >                 scasd
  1259. >                 jle     @@2
  1260. >                 sub     edi,4
  1261. >                 stosd
  1262. >               @@2:
  1263. >                 lodsd
  1264. >                 scasd
  1265. >                 jge     @@3
  1266. >                 sub     edi,4
  1267. >                 stosd
  1268. >               @@3:
  1269. >                 lodsd
  1270. >                 scasd
  1271. >                 jge     @@4
  1272. >                 sub     edi,4
  1273. >                 stosd
  1274. >               @@4:
  1275. >                 sub     edi,TYPE TRect
  1276. >                 Call    CheckEmpty
  1277. > end;
  1278. > 
  1279. > procedure TRect.Union(R: TRect); assembler; {$USES esi,edi} {$FRAME-}
  1280. > asm
  1281. >                 mov     esi,R
  1282. >                 mov     edi,Self
  1283. >                 cld
  1284. >                 lodsd
  1285. >                 scasd
  1286. >                 jge     @@1
  1287. >                 sub     edi,4
  1288. >                 stosd
  1289. >               @@1:
  1290. >                 lodsd
  1291. >                 scasd
  1292. >                 jge     @@2
  1293. >                 sub     edi,4
  1294. >                 stosd
  1295. >               @@2:
  1296. >                 lodsd
  1297. >                 scasd
  1298. >                 jle     @@3
  1299. >                 sub     edi,4
  1300. >                 stosd
  1301. >               @@3:
  1302. >                 lodsd
  1303. >                 scasd
  1304. >                 jle     @@4
  1305. >                 sub     edi,4
  1306. >                 stosd
  1307. >               @@4:
  1308. > end;
  1309. > 
  1310. > function TRect.Contains(P: TPoint): Boolean; assembler; {$USES None} {$FRAME-}
  1311. > asm
  1312. >                 mov     ecx,Self
  1313. >                 mov     al,0
  1314. >                 mov     edx,P.X
  1315. >                 cmp     edx,[ecx].TRect.A.X
  1316. >                 jl      @@1
  1317. >                 cmp     edx,[ecx].TRect.B.X
  1318. >                 jge     @@1
  1319. >                 mov     edx,P.Y
  1320. >                 cmp     edx,[ecx].TRect.A.Y
  1321. >                 jl      @@1
  1322. >                 cmp     edx,[ecx].TRect.B.Y
  1323. >                 setl    al
  1324. >               @@1:
  1325. > end;
  1326. > 
  1327. > function TRect.Equals(R: TRect): Boolean; assembler; {$USES esi,edi} {$FRAME-}
  1328. > asm
  1329. >                 mov     esi,R
  1330. >                 mov     edi,Self
  1331. >                 mov     ecx,4
  1332. >                 cld
  1333. >                 repe    cmpsd
  1334. >                 sete    al
  1335. 2975,2984c2404,2412
  1336. <         LES     DI,Self
  1337. >                 mov     ecx,Self
  1338. >                 mov     al,1
  1339. >                 mov     edx,[ecx].TRect.A.X
  1340. >                 cmp     edx,[ecx].TRect.B.X
  1341. >                 jge     @@1
  1342. >                 mov     edx,[ecx].TRect.A.Y
  1343. >                 cmp     edx,[ecx].TRect.B.Y
  1344. >                 setge   al
  1345. >               @@1:
  1346. 2987,2988d2414
  1347. < {$ENDIF}
  1348. 3014a2441,2549
  1349. > end;
  1350. > 
  1351. > { Peforms services analogous to DOS INT 21h Fns: 3Ch,3Dh,3Eh,3Fh,40h,42h }
  1352. > 
  1353. > procedure DosFn; assembler; {$USES ecx} {$FRAME+}
  1354. > var
  1355. >   Written,NewPtr,Handle,Result,Fn: Longint;
  1356. > asm
  1357. >                 cmp     ah,42h
  1358. >                 je      @@Seek
  1359. >                 cmp     ah,3Fh
  1360. >                 je      @@Read
  1361. >                 cmp     ah,40h
  1362. >                 je      @@Write
  1363. >                 cmp     ah,3Eh
  1364. >                 je      @@Close         { 3Ch, 3Dh                      }
  1365. > { Open or create file}
  1366. >                 mov     Fn,eax
  1367. >                 push    0               { [8]:Pointer = @EAs            }
  1368. >                 or      al,40h          { Deny none                     }
  1369. >                 cmp     ah,3Ch
  1370. >                 jne     @@1
  1371. >                 mov     al,42h          { Create: Read/Write access     }
  1372. >               @@1:
  1373. >                 movzx   eax,al
  1374. >                 push    eax             { [7]:DWord = OpenMode          }
  1375. >                 mov     al,1            { If file exist, open it        }
  1376. >                 cmp     Fn.Byte[1],3Dh
  1377. >                 je      @@2
  1378. >                 mov     al,12h          { If file doesn't exist, create it, if exist truncate }
  1379. >               @@2:
  1380. >                 push    eax             { [6]:DWord = OpenFlags         }
  1381. >                 push    ecx             { [5]:DWord = Attr              }
  1382. >                 push    0               { [4]:DWord = File Size         }
  1383. >                 lea     eax,Result      { [3]:Pointer =  @OpenResult    }
  1384. >                 push    eax
  1385. >                 lea     eax,Handle      { [2]:Pointer = @Handle         }
  1386. >                 push    eax
  1387. >                 push    edx             { [1]:Pointer = file name       }
  1388. >                 Call    DosOpen
  1389. >                 add     esp,8*4         { Stack cleanup after "C" call  }
  1390. >                 test    eax,eax
  1391. >                 stc
  1392. >                 jnz     @@RET
  1393. >                 mov     eax,Handle
  1394. >                 jmp     @@OK
  1395. > { Seek file }
  1396. >               @@Seek:
  1397. >                 lea     edx,NewPtr      { [4]:Pointer = @NewPtr         }
  1398. >                 push    edx
  1399. >                 movzx   eax,al          { [3]:DWord = Method            }
  1400. >                 push    eax
  1401. >                 push    ecx             { [2]:DWord = Distance          }
  1402. >                 push    ebx             { [1]:DWord = File Handle       }
  1403. >                 Call    DosSetFilePtr
  1404. >                 add     esp,4*4         { Stack cleanup after "C" call  }
  1405. >                 test    eax,eax
  1406. >                 stc
  1407. >                 jnz     @@RET
  1408. >                 mov     eax,NewPtr
  1409. >                 jmp     @@OK
  1410. > { Read file }
  1411. >               @@Read:
  1412. >                 lea     eax,Written     { [4]:Pointer = @BytesRead      }
  1413. >                 push    eax
  1414. >                 push    ecx             { [3]:DWord   = ReadCount       }
  1415. >                 push    edx             { [2]:Pointer = @Buffer         }
  1416. >                 push    ebx             { [1]:DWord = File Handle       }
  1417. >                 Call    DosRead
  1418. >                 jmp     @@3
  1419. > { Write file }
  1420. >               @@Write:
  1421. >                 jecxz   @@Truncate
  1422. >                 lea     eax,Written
  1423. >                 push    eax             { [4]:Pointer = @BytesWritten   }
  1424. >                 push    ecx             { [3]:DWord   = WriteCount      }
  1425. >                 push    edx             { [2]:Pointer = @Buffer         }
  1426. >                 push    ebx             { [1]:DWord = File Handle       }
  1427. >                 Call    DosWrite
  1428. >               @@3:
  1429. >                 add     esp,4*4         { Stack cleanup after "C" call  }
  1430. >                 test    eax,eax
  1431. >                 stc
  1432. >                 jnz     @@RET
  1433. >                 mov     eax,Written
  1434. >                 jmp     @@OK
  1435. > { Write 0 bytes = Truncate file }
  1436. >               @@Truncate:               { Seek mode: Current Pointer    }
  1437. >                 mov     ax,4201h        { ebx = Handle                  }
  1438. >                 Call    DosFn           { ecx = 0 = Distance            }
  1439. >                 jc      @@RET           { eax = Current File Pointer    }
  1440. >                 push    eax             { [2]:Longint = New File Size   }
  1441. >                 push    ebx             { [1]:Longint = File Handle     }
  1442. >                 Call    DosSetFileSize
  1443. >                 add     esp,2*4
  1444. >                 test    eax,eax
  1445. >                 stc
  1446. >                 jnz     @@RET
  1447. >                 jmp     @@OK
  1448. > { Close file }
  1449. >               @@Close:
  1450. >                 push    ebx             { [1]:DWord = File Handle       }
  1451. >                 Call    DosClose
  1452. >                 test    eax,eax
  1453. >                 stc
  1454. >                 jnz     @@RET
  1455. >               @@OK:
  1456. >                 clc
  1457. >               @@RET:
  1458. Comparing BP7\VALIDATE.PAS and VP\VALIDATE.PAS 
  1459. 13c13
  1460. < {$O+,F+,X+,I-,S-}
  1461. > {$X+,I-,S-,Cdecl-}
  1462. 17c17
  1463. < uses Objects;
  1464. > uses Objects, Use32;
  1465. 168,170d167
  1466. < {$IFDEF Windows}
  1467. 172d168
  1468. < {$ENDIF Windows}
  1469. 255,267d250
  1470. < {$IFDEF Windows}
  1471. 274,275d256
  1472. < {$ENDIF Windows}
  1473. 293c274
  1474. < function IsNumber(Chr: Char): Boolean; near; assembler;
  1475. > function IsNumber(Chr: Char): Boolean; assembler; {$USES None} {$FRAME-}
  1476. 295,302c276,282
  1477. <         XOR     AL,AL
  1478. >                 xor     al,al
  1479. >                 mov     ah,Chr
  1480. >                 cmp     ah,'0'
  1481. >                 jb      @@1
  1482. >                 cmp     ah,'9'
  1483. >                 setbe   al
  1484. >               @@1:
  1485. 305c285
  1486. < function IsLetter(Chr: Char): Boolean; near; assembler;
  1487. > function IsLetter(Chr: Char): Boolean; assembler; {$USES None] {$FRAME-}
  1488. 307,315c287,294
  1489. <         XOR     AL,AL
  1490. >                 xor     al,al
  1491. >                 mov     ah,Chr
  1492. >                 and     ah,0DFH                 { To upper }
  1493. >                 cmp     ah,'A'
  1494. >                 jb      @@1
  1495. >                 cmp     ah,'Z'
  1496. >                 setbe   al
  1497. >               @@1:
  1498. 318,319c297,299
  1499. < function IsSpecial(Chr: Char; const Special: string): Boolean; near;
  1500. > {$USES edi} {$FRAME-}
  1501. > 
  1502. > function IsSpecial(Chr: Char; const Special: String): Boolean; assembler;
  1503. 321,331c301,308
  1504. <         XOR     AH,AH
  1505. >                 xor     ecx,ecx
  1506. >                 mov     edi,Special
  1507. >                 mov     cl,[edi]
  1508. >                 inc     edi
  1509. >                 mov     al,Chr
  1510. >                 cld
  1511. >                 repne   scasb
  1512. >                 sete    al
  1513. 337c314,316
  1514. < function NumChar(Chr: Char; const S: string): Byte; near; assembler;
  1515. > {$USES edi} {$FRAME-}
  1516. > 
  1517. > function NumChar(Chr: Char; const S: String): Byte; assembler;
  1518. 339,350c318,330
  1519. <         XOR     AH,AH
  1520. >                 xor     ecx,ecx
  1521. >                 xor     eax,eax
  1522. >                 mov     edi,S
  1523. >                 mov     cl,[edi]
  1524. >                 mov     al,Chr
  1525. >               @@1:
  1526. >                 repne   scasb
  1527. >                 jne     @@2
  1528. >                 inc     ah
  1529. >                 test    ecx,ecx
  1530. >                 jnz     @@1
  1531. >               @@2:
  1532. >                 mov     al,ah
  1533. 773,781d752
  1534. < {$IFDEF Windows}
  1535. 787,788d757
  1536. < {$ENDIF Windows}
  1537. 805,819d773
  1538. < {$IFDEF Windows}
  1539. 830,831d783
  1540. < {$ENDIF Windows}
  1541. 907,916d858
  1542. < {$IFDEF Windows}
  1543. 922,923d863
  1544. < {$ENDIF Windows}
  1545. 929,933c869
  1546. <   asm
  1547. >   Str := @S;
  1548. Comparing BP7\APP.PAS and VP\APP.PAS 
  1549. 13c13
  1550. < {$O+,F+,X+,I-,S-}
  1551. > {$X+,I-,S-,Cdecl-}
  1552. 17c17
  1553. < uses Objects, Drivers, Memory, HistList, Views, Menus, Dialogs;
  1554. > uses Objects, Drivers, Memory, HistList, Views, Menus, Dialogs, Use32;
  1555. 240c240
  1556. < uses Dos;
  1557. > uses Dos, Os2Base;
  1558. 379c379
  1559. < function ISqr(X: Integer): Integer; assembler;
  1560. > function ISqr(X: Integer): Integer; assembler; {$USES ebx} {$FRAME-}
  1561. 381,389c381,389
  1562. <         MOV     CX,X
  1563. >                 mov     ecx,X
  1564. >                 xor     ebx,ebx
  1565. >               @@1:
  1566. >                 inc     ebx
  1567. >                 mov     eax,ebx
  1568. >                 imul    eax
  1569. >                 cmp     eax,ecx
  1570. >                 jle     @@1
  1571. >                 lea     eax,[ebx-1]
  1572. 430c430
  1573. <   DividerLoc := LongDiv(LongMul(Hi - Lo, Pos), Num) + Lo;
  1574. >   DividerLoc := ((Hi - Lo) * Pos) div Num + Lo;
  1575. 612a613
  1576. >   DosSleep(31);
  1577. 766d766
  1578. <   SwapVectors;
  1579. 768d767
  1580. <   SwapVectors;
  1581. 770a770
  1582. >   InitKeyboard;
  1583. 809c809
  1584. <   PrintStr('Type EXIT to return...');
  1585. >   PrintStr(#13#10'Type EXIT to return...'#13#10);
  1586. Comparing BP7\COLORSEL.PAS and VP\COLORSEL.PAS 
  1587. 13c13
  1588. < {$O+,F+,X+,I-,S-}
  1589. > {$X+,I-,S-,Cdecl-}
  1590. 17c17
  1591. < uses Objects, Drivers, Views, Dialogs;
  1592. > uses Objects, Drivers, Views, Dialogs, Use32;
  1593. Comparing BP7\DRIVERS.PAS and VP\DRIVERS.PAS 
  1594. 10a11,18
  1595. > { Drivers unit has been rewritten completely.           }
  1596. > { OS/2 system error handler is used, so SysErrorFunc,   }
  1597. > { SystemError,SysColorAttr,SysMonoAttr and SaveInt09    }
  1598. > { are not available. MouseIntFlag variable is not       }
  1599. > { supported also.                                       }
  1600. > { New services are introduced to support keystroke      }
  1601. > { macros.                                               }
  1602. > 
  1603. 13,14c21
  1604. < {$X+,I-,S-,P-}
  1605. > {$X+,I-,S-,P-,Cdecl-}
  1606. 18c25
  1607. < uses Objects;
  1608. > uses Objects, Use32;
  1609. 80a88,119
  1610. > { Additional keyboard codes that Borland forgot to define }
  1611. > 
  1612. >  kbCtrlA      = $1E01;  kbCtrlB     = $3002;  kbCtrlC     = $2E03;
  1613. >  kbCtrlD      = $2004;  kbCtrlE     = $1205;  kbCtrlF     = $2106;
  1614. >  kbCtrlG      = $2207;  kbCtrlH     = $2308;  kbCtrlI     = $1709;
  1615. >  kbCtrlJ      = $240A;  kbCtrlK     = $250B;  kbCtrlL     = $260C;
  1616. >  kbCtrlM      = $320D;  kbCtrlN     = $310E;  kbCtrlO     = $180F;
  1617. >  kbCtrlP      = $1910;  kbCtrlQ     = $1011;  kbCtrlR     = $1312;
  1618. >  kbCtrlS      = $1F13;  kbCtrlT     = $1414;  kbCtrlU     = $1615;
  1619. >  kbCtrlV      = $2F16;  kbCtrlW     = $1117;  kbCtrlX     = $2D18;
  1620. >  kbCtrlY      = $1519;  kbCtrlZ     = $2C1A;
  1621. > 
  1622. > { 101-key AT keyboard }
  1623. > 
  1624. >  kbAltTab     = $A500; kbAltDel     = $A300;  kbAltIns    = $A200;
  1625. >  kbAltPgDn    = $A100; kbAltDown    = $A000;  kbAltEnd    = $9F00;
  1626. >  kbAltRight   = $9D00; kbAltLeft    = $9B00;  kbAltPgUp   = $9900;
  1627. >  kbAltUp      = $9800; kbAltHome    = $9700;  kbCtrlTab   = $9400;
  1628. >  kbCtrlGreyPlus=$9000; kbCtrlCenter = $8F00;  kbCtrlMinus = $8E00;
  1629. >  kbCtrlUp     = $8D00; kbAltF12     = $8C00;  kbAltF11    = $8B00;
  1630. >  kbCtrlF12    = $8A00; kbCtrlF11    = $8900;  kbShiftF12  = $8800;
  1631. >  kbShiftF11   = $8700; kbF12        = $8600;  kbF11       = $8500;
  1632. >  kbAltGrayPlus= $4E00; kbCenter     = $4C00;  kbAltGreyAst= $3700;
  1633. >  kbAltSlash   = $3500; kbAltPeriod  = $3400;  kbAltComma  = $3300;
  1634. >  kbAltBackSlash=$2B00; kbAltOpQuote = $2900;  kbAltQuote  = $2800;
  1635. >  kbAltSemicolon=$2700; kbAltRgtBrack= $1B00;  kbAltLftBrack=$1A00;
  1636. >  kbAltEsc     = $0100; kbCtrlDown   = $9100;
  1637. > 
  1638. > { Special keys }
  1639. > 
  1640. > kbAltShiftBack = $0900;
  1641. > 
  1642. 112c151,152
  1643. <           0: (KeyCode: Word);
  1644. >           0: (KeyCode: SmallWord;
  1645. >               ShiftState: Byte);
  1646. 125a166,168
  1647. >   TShiftStateHandler = function(var ShiftState: Byte): Boolean;
  1648. >   TCtrlBreakAction = procedure;
  1649. > 
  1650. 134a178,180
  1651. >   GetShiftStateHandler: TShiftStateHandler = nil;
  1652. >   CtrlBreakAction: TCtrlBreakAction = nil;
  1653. >   KeyDownMask: Word = evKeyDown;
  1654. 137,140d182
  1655. < 
  1656. 147a190,192
  1657. > { These procedures are called from BASM code, }
  1658. > { so they should not change registers         }
  1659. > {$SAVES ALL}
  1660. 149a195,196
  1661. > procedure UpdateMouseWhere;
  1662. > {$SAVES ebx,esi,edi}
  1663. 169a217
  1664. >   CheckSnow: Boolean = False;   { not used }
  1665. 179d226
  1666. <   CheckSnow: Boolean;
  1667. 181c228
  1668. <   CursorLines: Word;
  1669. >   CursorLines: SmallWord;
  1670. 190,194c237
  1671. < { ******** SYSTEM ERROR HANDLER ******** }
  1672. > { Keyboard }
  1673. 196c239
  1674. <   TSysErrorFunc = function(ErrorCode: Integer; Drive: Byte): Integer;
  1675. > procedure InitKeyboard;
  1676. 198,203d240
  1677. < { Default system error handler routine }
  1678. 206,209c243
  1679. <   SaveInt09: Pointer = nil;
  1680. > const
  1681. 211c245
  1682. <   SaveCtrlBreak: Boolean = False;
  1683. >   SaveCtrlBreak: Boolean = False;       { not used }
  1684. 213c247
  1685. <   FailSysErrors: Boolean = False;
  1686. >   FailSysErrors: Boolean = False;       { not used }
  1687. 245,249c279
  1688. < { ******** EVENT MANAGER ******** }
  1689. > uses Dos, Os2Def, Os2Base, Xcpt;
  1690. 251c281
  1691. <   EventQSize = 16;
  1692. > { ******** EVENT MANAGER ******** }
  1693. 260d289
  1694. <   LastWhere: TPoint;
  1695. 265,269d293
  1696. <   EventCount: Word;
  1697. 271,273c295,297
  1698. < var
  1699. >   hMou: SmallWord;
  1700. >   ProtectArea: NoPtrRect;
  1701. >   MouseMSec: Longint;
  1702. 275c299,301
  1703. < { Detect mouse driver }
  1704. >   VioMode: VioModeInfo;
  1705. >   StartupVioMode: VioModeInfo;
  1706. >   StartupCursor: VioCursorInfo;
  1707. 277,295c303
  1708. < procedure DetectMouse; near; assembler;
  1709. > { Detects mouse driver, moves mouse pointer to the top left corner }
  1710. 297c305,319
  1711. < { Store event in GetMouseEvent and GetKeyEvent }
  1712. > procedure DetectMouse;
  1713. > var
  1714. >   MouLoc: PtrLoc;
  1715. >   Buttons: SmallWord;
  1716. > begin
  1717. >   ButtonCount := 0;
  1718. >   if MouOpen(nil, hMou) = 0 then
  1719. >   begin
  1720. >     MouGetNumButtons(Buttons,hMou);
  1721. >     ButtonCount := Buttons;
  1722. >     MouLoc.Row := 0;
  1723. >     MouLoc.Col := 0;
  1724. >     MouSetPtrPos(MouLoc, hMou);
  1725. >   end;
  1726. > end;
  1727. 299,317c321
  1728. < procedure StoreEvent; near; assembler;
  1729. > { Shows mouse pointer }
  1730. 319,354c323,327
  1731. < procedure GetMouseState; near; assembler;
  1732. > procedure ShowMouse;
  1733. > var
  1734. >   Status: SmallWord;
  1735. > begin
  1736. >   if ButtonCount <> 0 then MouDrawPtr(hMou);
  1737. 357,391c330
  1738. < procedure MouseInt; far; assembler;
  1739. > { Hides mouse pointer }
  1740. 393,425c332,334
  1741. < procedure InitEvents; assembler;
  1742. > procedure HideMouse;
  1743. > begin
  1744. >   if ButtonCount <> 0 then MouRemovePtr(ProtectArea, hMou);
  1745. 428,442c337,357
  1746. < procedure DoneEvents; assembler;
  1747. > { Initializes Turbo Vision's event manager by setting event mask and    }
  1748. > { showing the mouse. Called automatically by TApplication.Init.         }
  1749. > 
  1750. > procedure InitEvents;
  1751. > var
  1752. >   MouLoc: PtrLoc;
  1753. >   EventMask: SmallWord;
  1754. > begin
  1755. >   if ButtonCount <> 0 then
  1756. >   begin                                  { Mouse is available    }
  1757. >     DownButtons := 0;
  1758. >     LastDouble  := False;
  1759. >     MouGetPtrPos(MouLoc, hMou);
  1760. >     MouseWhere.X := MouLoc.Col;
  1761. >     MouseWhere.Y := MouLoc.Row;
  1762. >     MouDrawPtr(hMou);
  1763. >     LastButtons := 0;                    { Assume that no button is pressed }
  1764. >     EventMask := $FFFF;
  1765. >     MouSetEventMask(EventMask, hMou);    { Select all events }
  1766. >     MouseEvents := True;
  1767. >   end;
  1768. 445,453c360,373
  1769. < procedure ShowMouse; assembler;
  1770. > { Terminates Turbo Vision's event manager and hides the mouse. Called }
  1771. > { automatically by TApplication.Done.                                 }
  1772. > 
  1773. > procedure DoneEvents;
  1774. > var
  1775. >   EventMask: SmallWord;
  1776. > begin
  1777. >   if ButtonCount <> 0 then
  1778. >   begin
  1779. >     HideMouse;
  1780. >     EventMask := 0;
  1781. >     MouSetEventMask(EventMask, hMou);   { Mask all events }
  1782. >     MouseEvents := False;
  1783. >   end;
  1784. 456,464c376,406
  1785. < procedure HideMouse; assembler;
  1786. > { Checks whether a mouse event is available by polling the mouse event  }
  1787. > { queue maintained by OS/2. If a mouse event has occurred, Event.What   }
  1788. > { is set to evMouseDown, evMouseUp,evMouseMove, or evMouseAuto;         }
  1789. > { Event.Buttons is set to mbLeftButton or mbRightButton;                }
  1790. > { Event.Double is set to True or False;
  1791. > { Event.Where is set to the mouse position in global coordinates.       }
  1792. > { If no mouse events are available, Event.What is set to evNothing.     }
  1793. > { GetMouseEvent is called by TProgram.GetEvent.                         }
  1794. > 
  1795. > procedure GetMouseEvent(var Event: TEvent);
  1796. > var
  1797. >   MouEvent: MouEventInfo;
  1798. >   MouQInfo: MouQueInfo;
  1799. >   CurTicks: Word;
  1800. >   B1,B2: Byte;
  1801. > const
  1802. >   WaitFlag: SmallWord = mou_NoWait;
  1803. > 
  1804. > procedure StoreEvent(MouWhat: Word);
  1805. > begin
  1806. >   LastButtons := MouseButtons;
  1807. >   MouseWhere.X := MouEvent.Col;
  1808. >   MouseWhere.Y := MouEvent.Row;
  1809. >   with Event do
  1810. >   begin
  1811. >     What := MouWhat;
  1812. >     Buttons := MouseButtons;
  1813. >     Double  := LastDouble;
  1814. >     Where.X := MouEvent.Col;
  1815. >     Where.Y := MouEvent.Row;
  1816. >   end;
  1817. 467,528c409,472
  1818. < procedure GetMouseEvent(var Event: TEvent); assembler;
  1819. > { GetMouseEvent body }
  1820. > 
  1821. > begin
  1822. >   if not MouseEvents then Event.What := evNothing
  1823. > else
  1824. >   begin
  1825. >     MouGetNumQueEl(MouQInfo, hMou);
  1826. >     if MouQinfo.cEvents = 0 then
  1827. >     begin
  1828. >       MouseButtons := LastButtons;
  1829. >       DosQuerySysInfo(qsv_Ms_Count, qsv_Ms_Count, MouEvent.Time, SizeOf(MouEvent.Time));
  1830. >       MouEvent.Col  := MouseWhere.X;
  1831. >       MouEvent.Row  := MouseWhere.Y;
  1832. >     end
  1833. >    else
  1834. >     begin
  1835. >       MouReadEventQue(MouEvent, WaitFlag, hMou);
  1836. >       if MouseReverse then
  1837. >       begin
  1838. >         B1 := mbRightButton;
  1839. >         B2 := mbLeftButton;
  1840. >       end
  1841. >      else
  1842. >       begin
  1843. >         B1 := mbLeftButton;
  1844. >         B2 := mbRightButton;
  1845. >       end;
  1846. >       if (MouEvent.fs and (mouse_Motion_With_Bn1_Down or mouse_Bn1_Down)) <> 0
  1847. >         then MouseButtons := B1 else MouseButtons := 0;
  1848. >       if (MouEvent.fs and (mouse_Motion_With_Bn2_Down or mouse_Bn2_Down)) <> 0
  1849. >         then MouseButtons := MouseButtons or B2;
  1850. >     end;
  1851. >     { ms -> ticks: 1 DOS timer tick = 55ms }
  1852. >     CurTicks := MouEvent.Time div 55;
  1853. >     MouseMSec := MouEvent.Time;
  1854. >     { Process mouse event }
  1855. >     if (LastButtons <> 0) and (MouseButtons = 0) then StoreEvent(evMouseUp) { button is released }
  1856. >    else
  1857. >     if  LastButtons = MouseButtons then
  1858. >     begin
  1859. >       if (MouEvent.Row <> MouseWhere.Y) or (MouEvent.Col <> MouseWhere.X) then StoreEvent(evMouseMove)
  1860. >      else
  1861. >       if (MouseButtons <> 0) and ((CurTicks - AutoTicks) >= AutoDelay) then
  1862. >       begin
  1863. >         AutoTicks := CurTicks;
  1864. >         AutoDelay := 1;
  1865. >         StoreEvent(evMouseAuto);
  1866. >       end
  1867. >      else StoreEvent(evNothing);
  1868. >     end
  1869. >    else               { CurButton <> 0, LastButton = 0 }
  1870. >     begin
  1871. >       LastDouble := False;
  1872. >       if (MouseButtons = DownButtons) and (MouEvent.Row = DownWhere.Y) and (MouEvent.Col = DownWhere.X)
  1873. >       and ((CurTicks - DownTicks) < DoubleDelay) then LastDouble := True;
  1874. >       DownButtons := MouseButtons;
  1875. >       DownWhere.Y := MouEvent.Row;
  1876. >       DownWhere.X := MouEvent.Col;
  1877. >       DownTicks   := CurTicks;
  1878. >       AutoTicks   := CurTicks;
  1879. >       AutoDelay   := RepeatDelay;
  1880. >       StoreEvent(evMouseDown);
  1881. >     end;
  1882. >   end;
  1883. 531,544c475,485
  1884. < procedure GetKeyEvent(var Event: TEvent); assembler;
  1885. > { Initializes keyboard. Setups keyboard BINARY mode that allows Ctrl-C  }
  1886. > { to be handled in a normal way as an ordinal keystroke.                }
  1887. > 
  1888. > procedure InitKeyboard;
  1889. > var
  1890. >   Key: KbdInfo;
  1891. > begin
  1892. >   Key.cb := SizeOf(KbdInfo);
  1893. >   KbdGetStatus(Key,0);        { Disable ASCII & Enable raw (binary) mode}
  1894. >   Key.fsMask := (Key.fsMask and (not keyboard_Ascii_Mode)) or keyboard_Binary_Mode;
  1895. >   KbdSetStatus(Key,0);
  1896. 547,550c488,508
  1897. < function GetShiftState: Byte; assembler;
  1898. > { UpdateMouseWhere is called from Views.WriteView procedure just before }
  1899. > { output to screen is to occur. It's too slow to query mouse pointer    }
  1900. > { location each time this procedure is called. That's why appoximate    }
  1901. > { approach is used instead. Mouse pointer location is queried only      }
  1902. > { after some defined time interval (5ms) elapsed since pointer location }
  1903. > { was known exactly. Surely, this doesn't fix the mouse "dropping"      }
  1904. > { problem completely, however experiments show rather good results.     }
  1905. > 
  1906. > procedure UpdateMouseWhere;
  1907. > var
  1908. >   MouLoc: PtrLoc;
  1909. >   MSec: Longint;
  1910. > begin
  1911. >   DosQuerySysInfo(qsv_Ms_Count, qsv_Ms_Count, MSec, SizeOf(MSec));
  1912. >   if MSec - MouseMSec >= 5 then
  1913. >   begin
  1914. >     MouseMSec := MSec;
  1915. >     MouGetPtrPos(MouLoc, hMou);
  1916. >     MouseWhere.X := MouLoc.Col;
  1917. >     MouseWhere.Y := MouLoc.Row;
  1918. >   end;
  1919. 553c511,514
  1920. < { ******** SCREEN MANAGER ******** }
  1921. > { Checks whether a keyboard event is available. If a key has been       }
  1922. > { pressed, Event.What is set to evKeyDown and Event.KeyCode is set to   }
  1923. > { the scan code of the key. Otherwise, Event.What is set to evNothing.  }
  1924. > { GetKeyEvent is called by TProgram.GetEvent.                           }
  1925. 554a516
  1926. > procedure GetKeyEvent(var Event: TEvent);
  1927. 556,558c518,527
  1928. <   Equipment: Word absolute $40:$10;
  1929. >   Key: KbdKeyInfo;
  1930. >   I: Integer;
  1931. > { Keyboard scan codes }
  1932. > const
  1933. >   scSpace    = $39;  scIns      = $52;  scDel      = $53;
  1934. >   scBack     = $0E;  scUp       = $48;  scDown     = $50;
  1935. >   scLeft     = $4B;  scRight    = $4D;  scHome     = $47;
  1936. >   scEnd      = $4F;  scPgUp     = $49;  scPgDn     = $51;
  1937. >   scCtrlIns  = $92;  scCtrlDel  = $93;  scCtrlUp   = $8D;
  1938. >   scCtrlDown = $91;
  1939. 560c529,530
  1940. < { Save registers and call video interrupt }
  1941. > const
  1942. >   kbShift    = kbLeftShift + kbRightShift;
  1943. 562,568c532,583
  1944. < procedure VideoInt; near; assembler;
  1945. > type
  1946. >   KeyTransEntry = record
  1947. >     Scan:  Byte;
  1948. >     Shift: Byte;
  1949. >     Code:  Word;
  1950. >   end;
  1951. > 
  1952. > const
  1953. >   KeyTranslateTable : array [1..15] of KeyTransEntry =
  1954. >     (( Scan: scSpace   ; Shift: kbAltShift   ; Code: kbAltSpace ),   { Alt-Space     }
  1955. >      ( Scan: scIns     ; Shift: kbCtrlShift  ; Code: kbCtrlIns  ),   { Ctrl-Ins      }
  1956. >      ( Scan: scCtrlIns ; Shift: kbCtrlShift  ; Code: kbCtrlIns  ),   { Ctrl-Ins      }
  1957. >      ( Scan: scIns     ; Shift: kbLeftShift  ; Code: kbShiftIns ),   { Shift-Ins     }
  1958. >      ( Scan: scIns     ; Shift: kbRightShift ; Code: kbShiftIns ),   { Shift-Ins     }
  1959. >      ( Scan: scIns     ; Shift: kbShift      ; Code: kbShiftIns ),   { Shift-Ins     }
  1960. >      ( Scan: scDel     ; Shift: kbCtrlShift  ; Code: kbCtrlDel  ),   { Ctrl-Del      }
  1961. >      ( Scan: scCtrlDel ; Shift: kbCtrlShift  ; Code: kbCtrlDel  ),   { Ctrl-Del      }
  1962. >      ( Scan: scDel     ; Shift: kbLeftShift  ; Code: kbShiftDel ),   { Shift-Del     }
  1963. >      ( Scan: scDel     ; Shift: kbRightShift ; Code: kbShiftDel ),   { Shift-Del     }
  1964. >      ( Scan: scDel     ; Shift: kbShift      ; Code: kbShiftDel ),   { Shift-Del     }
  1965. >      ( Scan: scBack    ; Shift: kbAltShift+kbLeftShift ; Code: kbAltShiftBack), { Alt-Shift-Backspace }
  1966. >      ( Scan: scBack    ; Shift: kbAltShift+kbRightShift; Code: kbAltShiftBack), { Alt-Shift-Backspace }
  1967. >      ( Scan: scBack    ; Shift: kbAltShift+kbShift     ; Code: kbAltShiftBack), { Alt-Shift-Backspace }
  1968. >      ( Scan: scBack    ; Shift: kbAltShift   ; Code: kbAltBack  ));  { Alt-Backspace }
  1969. > begin
  1970. >   KbdCharIn(Key, io_NoWait, 0);
  1971. >   if (Key.fbStatus and kbdtrf_Final_Char_In) = 0 then Event.What := evNothing
  1972. >  else
  1973. >   begin
  1974. >     with Event do                       { Key is ready }
  1975. >     begin
  1976. >       What := KeyDownMask;
  1977. >       CharCode := Key.chChar;
  1978. >       ScanCode := Key.chScan;
  1979. >       ShiftState := Key.fsState;
  1980. >       for I := Low(KeyTranslateTable) to High(KeyTranslateTable) do
  1981. >         with KeyTranslateTable[I] do
  1982. >         begin
  1983. >           if (Scan = Key.chScan ) and ((Shift and Key.fsState) = Shift) then
  1984. >           begin
  1985. >             KeyCode := Code;
  1986. >             Break;
  1987. >           end;
  1988. >         end;
  1989. >       if (CharCode = #$E0) and (ScanCode in
  1990. >           [scUp,scDown,scLeft,scRight,scIns,scDel,scHome,scEnd,scPgUp,scPgDn,
  1991. >           Hi(kbCtrlHome), Hi(kbCtrlEnd)  , Hi(kbCtrlPgUp), Hi(kbCtrlPgDn),
  1992. >           Hi(kbCtrlLeft), Hi(kbCtrlRight),    scCtrlUp,       scCtrlDown])
  1993. >         then CharCode := #0;                          { Grey Keys   }
  1994. >       if KeyCode = $E00D then KeyCode := kbEnter;     { Grey Enter  }
  1995. >     end;
  1996. >   end;
  1997. 571c586,588
  1998. < { Return CRT mode in AX and dimensions in DX }
  1999. > { Returns a byte containing the current Shift key state, as reported by }
  2000. > { OS/2. The return value contains a combination of the kbXXXX constants }
  2001. > { for shift states.                                                     }
  2002. 573,586c590,604
  2003. < procedure GetCrtMode; near; assembler;
  2004. > function GetShiftState: Byte;
  2005. > var
  2006. >   Key: KbdInfo;
  2007. >   ShiftState: Byte;
  2008. >   Handled: Boolean;
  2009. > begin
  2010. >   if @GetShiftStateHandler <> nil then Handled := GetShiftStateHandler(ShiftState)
  2011. >  else Handled := False;
  2012. >   if not Handled then
  2013. >   begin
  2014. >     Key.cb := SizeOf(KbdInfo);
  2015. >     KbdGetStatus(Key, 0);
  2016. >     ShiftState := Key.fsState;
  2017. >   end;
  2018. >   GetShiftState := ShiftState;
  2019. 589c607
  2020. < { Set CRT mode to value in AX }
  2021. > { ******** SCREEN MANAGER ******** }
  2022. 591,623c609,626
  2023. < procedure SetCrtMode; near; assembler;
  2024. > { Returns current CRT mode }
  2025. > 
  2026. > function GetCrtMode: Word;
  2027. > var
  2028. >   Mode: Word;
  2029. > begin
  2030. >   VioMode.cb := SizeOf(VioMode);
  2031. >   VioGetMode(VioMode, 0);
  2032. >   with VioMode do
  2033. >   begin
  2034. >     if (fbType and vgmt_DisableBurst) = 0
  2035. >       then Mode := smCO80 else Mode := smBW80;
  2036. >     if Color = 0 then Mode := smMono;
  2037. >     if Row > 25 then Inc(Mode, smFont8x8);
  2038. >     GetCrtMode := Mode;
  2039. >     if ((VioMode.fbType and vgmt_Graphics) <> 0) or
  2040. >       (Col <> 80) then GetCrtMode := 0;
  2041. >   end;
  2042. 626c629
  2043. < { Fix CRT mode in AX if required }
  2044. > { Setups CRT mode }
  2045. 628,637c631,669
  2046. < procedure FixCrtMode; near; assembler;
  2047. > procedure SetCrtMode(Mode: Word);
  2048. > var
  2049. >   BiosMode: Byte;
  2050. >   CurData: VioCursorInfo;
  2051. >   VideoConfig: VioConfigInfo;
  2052. > begin
  2053. >   BiosMode := Lo(Mode);
  2054. >   VideoConfig.cb := SizeOf(VideoConfig);
  2055. >   VioGetConfig(0, VideoConfig, 0);
  2056. >   with VioMode do
  2057. >   begin
  2058. >     cb := SizeOf(VioMode);
  2059. >     fbType := vgmt_Other;
  2060. >     Color := colors_16;         { Color }
  2061. >     Row := 25;                  { 80x25 }
  2062. >     Col := 80;
  2063. >     VRes := 400;
  2064. >     HRes := 720;
  2065. >     if (Mode and smFont8x8) <> 0 then
  2066. >     case VideoConfig.Adapter of { 80x43 }
  2067. >       display_Monochrome..display_CGA: ;
  2068. >       display_EGA:
  2069. >         begin
  2070. >           Row := 43; VRes := 350; HRes := 640;
  2071. >         end;
  2072. >       else                      { 80x50 }
  2073. >         begin
  2074. >           Row := 50; VRes := 400; HRes := 720;
  2075. >         end;
  2076. >     end;
  2077. >     case BiosMode of            { Black and white }
  2078. >       smBW80: fbType := vgmt_Other + vgmt_DisableBurst;
  2079. >       smMono:
  2080. >         begin                   { Monochrome }
  2081. >           HRes := 720; VRes := 350; Color := 0; fbType := 0;
  2082. >         end;
  2083. >     end;
  2084. >   end;
  2085. >   VioSetMode(VioMode, 0);
  2086. 640c672
  2087. < { Set CRT data areas and mouse range }
  2088. > { Fix CRT mode if required }
  2089. 642,685c674,679
  2090. < procedure SetCrtData; near; assembler;
  2091. > function FixCrtMode(Mode: Word): Word;
  2092. > begin
  2093. >   case Lo(Mode) of
  2094. >     smMono,smCO80,smBW80: FixCrtMode := Mode
  2095. >     else                  FixCrtMode := smCO80;
  2096. >   end;
  2097. 688c682
  2098. < { Detect video modes }
  2099. > { Sets CRT data areas and mouse range }
  2100. 690,694c684,708
  2101. < procedure DetectVideo; assembler;
  2102. > procedure SetCrtData;
  2103. > var
  2104. >   VideoConfig: VioConfigInfo;
  2105. >   BufSize: SmallWord;
  2106. >   CurData: VioCursorInfo;
  2107. > begin
  2108. >   ScreenMode := GetCrtMode;
  2109. >   ScreenHeight := VioMode.Row;
  2110. >   ScreenWidth := VioMode.Col;
  2111. >   ProtectArea.Row := 0;
  2112. >   ProtectArea.Col := 0;
  2113. >   ProtectArea.cRow := ScreenHeight - 1;
  2114. >   ProtectArea.cCol := ScreenWidth - 1;
  2115. >   ShowMouse;
  2116. >   HiResScreen  := False;
  2117. >   VideoConfig.cb := SizeOf(VideoConfig);
  2118. >   if (VioGetConfig(0, VideoConfig, 0) = 0) then
  2119. >     if VideoConfig.Adapter >= display_EGA then HiResScreen := True;
  2120. >   VioGetBuf(ScreenBuffer,BufSize,0);
  2121. >   SelToFlat(ScreenBuffer);
  2122. >   VioGetCurType(CurData, 0);                    { Get cursor lines }
  2123. >   WordRec(CursorLines).Hi := CurData.yStart;
  2124. >   WordRec(CursorLines).Lo := CurData.cEnd;
  2125. >   CurData.attr := $FFFF;
  2126. >   VioSetCurType(CurData,0);                     { Hide cursor }
  2127. 697,705c711,716
  2128. < procedure InitVideo; assembler;
  2129. > { Detects video modes }
  2130. > 
  2131. > procedure DetectVideo;
  2132. > begin
  2133. >   ScreenMode := FixCrtMode(GetCrtMode);
  2134. >   StartupVioMode := VioMode;
  2135. 708,721c719,730
  2136. < procedure DoneVideo; assembler;
  2137. > { Initializes Turbo Vision's video manager. Saves the current screen    }
  2138. > { mode in StartupMode, and switches the screen to the mode indicated by }
  2139. > { ScreenMode. The ScreenWidth, ScreenHeight, HiResScreen, ScreenBuffer, }
  2140. > { and CursorLines variables are updated accordingly.InitVideo is called }
  2141. > { automatically by TApplication.Init.                                   }
  2142. > 
  2143. > procedure InitVideo;
  2144. > begin
  2145. >   VioGetCurType(StartupCursor, 0);
  2146. >   StartupMode := GetCrtMode;
  2147. >   if StartupMode <> ScreenMode then SetCrtMode(ScreenMode);
  2148. >   SetCrtData;
  2149. 724,729c733,742
  2150. < procedure SetVideoMode(Mode: Word); assembler;
  2151. > { Terminates Turbo Vision's video manager by restoring the initial      }
  2152. > { screen mode, clearing the screen, and restoring the cursor. Called    }
  2153. > { automatically by TApplication.Done.                                   }
  2154. > 
  2155. > procedure DoneVideo;
  2156. > begin
  2157. >   if (StartupMode <> $FFFF) and (StartupMode <> ScreenMode) then
  2158. >     VioSetMode(StartupVioMode, 0);
  2159. >   ClearScreen;
  2160. >   VioSetCurType(StartupCursor, 0);
  2161. 732,754c745,748
  2162. < procedure ClearScreen; assembler;
  2163. > { Sets the video mode. Mode is one of the constants smCO80, smBW80, or smMono, }
  2164. > { optionally with smFont8x8 added to select 43- or 50-line mode on an EGA or   }
  2165. > { VGA. SetVideoMode initializes the same variables as InitVideo (except for    }
  2166. > { the StartupMode variable, which isn't affected).                             }
  2167. 756c750,754
  2168. < const
  2169. > procedure SetVideoMode(Mode: Word);
  2170. > begin
  2171. >   SetCrtMode(FixCrtMode(Mode));
  2172. >   SetCrtData;
  2173. > end;
  2174. 758c756
  2175. < { System error messages }
  2176. > { Clears the screen, moves cursor to the top left corner }
  2177. 760,794c758,764
  2178. <   SCriticalError:  string[31] = 'Critical disk error on drive %c';
  2179. > procedure ClearScreen;
  2180. > const
  2181. >   Cell: SmallWord = $0720;      { Space character, white on black }
  2182. > begin
  2183. >   VioScrollUp(0, 0, 65535, 65535, 65535, Cell, 0);
  2184. >   VioSetCurPos(0, 0, 0);
  2185. > end;
  2186. 796c766
  2187. < { System error handler routines }
  2188. > { ********************* SYSTEM ERROR HANDLER ************************** }
  2189. 798,799c768,771
  2190. < procedure InitSysError; external;
  2191. > { No critical error handler is implemented for OS/2.                    }
  2192. > { Default OS/2 system error handler traps all critical errors.          }
  2193. > { Unlike DOS critical error handler it doesn't corrupt user screen.     }
  2194. > { That's why it is not so interesting to write one more of your own.    }
  2195. 801,818c773,775
  2196. < procedure SwapStatusLine(var Buffer); near; assembler;
  2197. > { Ctrl-Break signal handler. Sets CtrlBreakHit to True whenever         }
  2198. > { Ctrl-Break is hit. Note: when keyboard is switched to the raw         }
  2199. > { (binary mode) mode xcpt_Signal_Intr signal (Ctrl-C) is not reported.  }
  2200. 820,846c777,791
  2201. < function SelectKey: Integer; near; assembler;
  2202. > function CtrlBreakHandler(Report:       PExceptionReportRecord;
  2203. >                           Registration: PExceptionRegistrationRecord;
  2204. >                           Context:      PContextRecord;
  2205. >                           P:            Pointer): ULong; cdecl;
  2206. > begin
  2207. >   CtrlBreakHandler := xcpt_Continue_Search;
  2208. >   if (Report^.ExceptionNum = xcpt_Signal) then
  2209. >     case Report^.ExceptionInfo[0] of
  2210. >       xcpt_Signal_Intr,xcpt_Signal_Break:
  2211. >         begin
  2212. >           CtrlBreakHit := True;
  2213. >           if Assigned(CtrlBreakAction) then CtrlBreakAction;
  2214. >           CtrlBreakHandler := xcpt_Continue_Execution;
  2215. >         end;
  2216. >     end;
  2217. 849c794,796
  2218. < {$V-}
  2219. > { Initializes Turbo Vision's system error handler. Called automatically }
  2220. > { by TApplication.Init. Since no error handler is available,InitSysError}
  2221. > { sets SysErrActive to True and does nothing.                           }
  2222. 851,856c798
  2223. < function SystemError(ErrorCode: Integer; Drive: Byte): Integer;
  2224. > procedure InitSysError;
  2225. 858,874c800
  2226. <   if FailSysErrors then
  2227. >   SysErrActive := True;
  2228. 877c803,810
  2229. < {$V+}
  2230. > { Terminates Turbo Vision's system error handler. Called automatically  }
  2231. > { by TApplication.Done. Since no error handler is available,DoneSysError}
  2232. > { sets SysErrActive to False and does nothing.                          }
  2233. > 
  2234. > procedure DoneSysError;
  2235. > begin
  2236. >   SysErrActive := False;
  2237. > end;
  2238. 959,961c892,907
  2239. < { String formatting routines }
  2240. > { A generalized string formatting routine. Given a string in Format     }
  2241. > { that includes format specifiers and a list of parameters in Params,   }
  2242. > { FormatStr produces a formatted output string in Result.               }
  2243. > { Format specifiers are of the form %[-][nnn]X, where                   }
  2244. > {   % indicates the beginning of a format specifier                     }
  2245. > {  [-] is an optional minus sign (-) indicating the parameter is to be  }
  2246. > {      left-justified (by default, parameters are right-justified)      }
  2247. > { [nnn] is an optional, decimal-number width specifier in the range     }
  2248. > {      0..255 (0 indicates no width specified, and non-zero means to    }
  2249. > {      display in a field of nnn characters)                            }
  2250. > {   X  is a format character:                                           }
  2251. > {   's' means the parameter is a pointer to a string.                   }
  2252. > {   'd' means the parameter is a Longint to be displayed in decimal.    }
  2253. > {   'c' means the low byte of the parameter is a character.             }
  2254. > {   'x' means the parameter is a Longint to be displayed in hexadecimal.}
  2255. > {   '#' sets the parameter index to nnn.                                }
  2256. 964c910,915
  2257. < external {FORMAT};
  2258. >   assembler; {$USES ebx,esi,edi} {$FRAME+}
  2259. > var
  2260. >   ParOfs: Longint;
  2261. >   Buffer: array [1..12] of Byte;
  2262. > const
  2263. >   HexDigits: array [0..15] of Char = '0123456789ABCDEF';
  2264. 966,978c917,1092
  2265. < procedure PrintStr(const S: String); assembler;
  2266. > { Convert next parameter to string              }
  2267. > { EXPECTS:      al    = Conversion character    }
  2268. > { RETURNS:      esi   = Pointer to string       }
  2269. > {               ecx   = String length           }
  2270. > 
  2271. > procedure Convert; assembler; {$USES None} {$FRAME-}
  2272. > asm
  2273. >                 mov     edx,eax
  2274. >                 mov     esi,Params
  2275. >                 lodsd
  2276. >                 mov     Params,esi
  2277. >                 xor     ecx,ecx
  2278. >                 lea     esi,Buffer[TYPE Buffer]
  2279. >                 and     dl,0DFh         { UpCase(ConversionChar) }
  2280. >                 cmp     dl,'C'
  2281. >                 je      @@ConvertChar
  2282. >                 cmp     dl,'S'
  2283. >                 je      @@ConvertStr
  2284. >                 cmp     dl,'D'
  2285. >                 je      @@ConvertDec
  2286. >                 cmp     dl,'X'
  2287. >                 jne     @@Done
  2288. > { ConvertHex }
  2289. >               @@1:
  2290. >                 mov     edx,eax
  2291. >                 and     edx,0Fh
  2292. >                 mov     dl,HexDigits.Byte[edx]
  2293. >                 dec     esi
  2294. >                 inc     ecx
  2295. >                 mov     [esi],dl
  2296. >                 shr     eax,4
  2297. >                 jnz     @@1
  2298. >                 jmp     @@Done
  2299. > @@ConvertDec:
  2300. >                 push    esi
  2301. >                 mov     ebx,eax
  2302. >                 mov     ecx,10
  2303. >                 test    eax,eax
  2304. >                 jns     @@2
  2305. >                 neg     eax
  2306. >               @@2:
  2307. >                 xor     edx,edx
  2308. >                 dec     esi
  2309. >                 div     ecx
  2310. >                 add     dl,'0'
  2311. >                 mov     [esi],dl
  2312. >                 test    eax,eax
  2313. >                 jnz     @@2
  2314. >                 pop     ecx
  2315. >                 sub     ecx,esi
  2316. >                 test    ebx,ebx
  2317. >                 jns     @@Done
  2318. >                 mov     al,'-'
  2319. > @@ConvertChar:
  2320. >                 inc     ecx
  2321. >                 dec     esi
  2322. >                 mov     [esi],al
  2323. >                 jmp     @@Done
  2324. > @@ConvertStr:
  2325. >                 test    eax,eax
  2326. >                 jz      @@Done
  2327. >                 mov     esi,eax
  2328. >                 lodsb
  2329. >                 mov     cl,al
  2330. >               @@Done:
  2331. > end;
  2332. > 
  2333. > { FormatStr body }
  2334. > 
  2335. > asm
  2336. >                 mov     eax,Params
  2337. >                 mov     ParOfs,eax
  2338. >                 xor     eax,eax
  2339. >                 mov     esi,Format
  2340. >                 mov     edi,Result
  2341. >                 inc     edi
  2342. >                 cld
  2343. >                 lodsb
  2344. >                 mov     ecx,eax
  2345. >               @@1:
  2346. >                 jecxz   @@9
  2347. >                 lodsb
  2348. >                 dec     ecx
  2349. >                 cmp     al,'%'
  2350. >                 je      @@3
  2351. >               @@2:
  2352. >                 stosb
  2353. >                 jmp     @@1
  2354. >               @@3:
  2355. >                 jecxz   @@9
  2356. >                 lodsb
  2357. >                 dec     ecx
  2358. >                 cmp     al,'%'
  2359. >                 je      @@2             { bh = Justify (0:right, 1:left) }
  2360. >                 mov     ebx,' '         { bl = Filler character          }
  2361. >                 xor     edx,edx         { edx = Field width (0:no width) }
  2362. >                 cmp     al,'0'
  2363. >                 jne     @@4
  2364. >                 mov     bl,al
  2365. >               @@4:
  2366. >                 cmp     al,'-'
  2367. >                 jne     @@5
  2368. >                 inc     bh
  2369. >                 jecxz   @@9
  2370. >                 lodsb
  2371. >                 dec     ecx
  2372. >               @@5:
  2373. >                 cmp     al,'0'
  2374. >                 jb      @@6
  2375. >                 cmp     al,'9'
  2376. >                 ja      @@6
  2377. >                 sub     al,'0'
  2378. >                 xchg    eax,edx
  2379. >                 mov     ah,10
  2380. >                 mul     ah
  2381. >                 add     al,dl
  2382. >                 xchg    eax,edx
  2383. >                 jecxz   @@9
  2384. >                 lodsb
  2385. >                 dec     ecx
  2386. >                 jmp     @@5
  2387. >               @@6:
  2388. >                 cmp     al,'#'
  2389. >                 jne     @@10
  2390. >                 shl     edx,2
  2391. >                 add     edx,ParOfs
  2392. >                 mov     Params,edx
  2393. >                 jmp     @@1
  2394. >               @@9:
  2395. >                 mov     eax,Result
  2396. >                 mov     ecx,edi
  2397. >                 sub     ecx,eax
  2398. >                 dec     ecx
  2399. >                 mov     [eax],cl
  2400. >                 jmp     @@Done
  2401. >               @@10:
  2402. >                 push    esi
  2403. >                 push    ecx
  2404. >                 push    edx
  2405. >                 push    ebx
  2406. >                 Call    Convert
  2407. >                 pop     ebx
  2408. >                 pop     edx
  2409. >                 test    edx,edx
  2410. >                 jz      @@12
  2411. >                 sub     edx,ecx
  2412. >                 jae     @@12
  2413. >                 test    bh,bh
  2414. >                 jnz     @@11
  2415. >                 sub     esi,edx
  2416. >               @@11:
  2417. >                 add     ecx,edx
  2418. >                 xor     edx,edx
  2419. >               @@12:
  2420. >                 test    bh,bh
  2421. >                 jz      @@13
  2422. >                 rep     movsb           { Copy formated parm (left-justified)}
  2423. >               @@13:
  2424. >                 xchg    ecx,edx
  2425. >                 mov     al,bl
  2426. >                 rep     stosb           { Fill unused space }
  2427. >                 xchg    ecx,edx
  2428. >                 rep     movsb           { Copy formated parm (right-justified)}
  2429. >                 pop     ecx
  2430. >                 pop     esi
  2431. >                 jmp     @@1
  2432. >               @@Done:
  2433. > end;
  2434. > 
  2435. > { Prints the string on the screen }
  2436. > 
  2437. > procedure PrintStr(const S: String);
  2438. > var
  2439. >   WCount: ULong;
  2440. > begin
  2441. >   DosWrite(1, S[1], Length(S), WCount);
  2442. 982a1097,1103
  2443. > { Moves text and video attributes into a buffer. Count bytes are moved  }
  2444. > { from Source into the low bytes of corresponding words in Dest. The    }
  2445. > { high bytes of the words in Dest are set to Attr, or remain unchanged  }
  2446. > { if Attr is zero.                                                      }
  2447. > 
  2448. > {$USES esi,edi} {$FRAME-}
  2449. > 
  2450. 985,1003c1106,1130
  2451. <         MOV     CX,Count
  2452. >                 mov     ecx,Count
  2453. >                 jecxz   @@4
  2454. >                 mov     edi,Dest
  2455. >                 mov     esi,Source
  2456. >                 mov     ah,Attr
  2457. >                 cld
  2458. >                 test    ah,ah
  2459. >                 jz      @@3
  2460. >               @@1:
  2461. >                 lodsb
  2462. >                 stosw
  2463. >                 loop    @@1
  2464. >                 jmp     @@4
  2465. >               @@2:
  2466. >                 inc     edi
  2467. >               @@3:
  2468. >                 movsb
  2469. >                 loop    @@2
  2470. >               @@4:
  2471. > end;
  2472. > 
  2473. > { Moves characters into a buffer. The low bytes of the first Count      }
  2474. > { words of Dest are set to C, or remain unchanged if C = #0. The high   }
  2475. > { bytes of the words are set to Attr, or remain unchanged if Attr is    }
  2476. > { zero.                                                                 }
  2477. 1004a1132,1133
  2478. > {$USES edi} {$FRAME-}
  2479. > 
  2480. 1007,1024c1136,1170
  2481. <         MOV     CX,Count
  2482. >                 mov     ecx,Count
  2483. >                 jecxz   @@4
  2484. >                 mov     edi,Dest
  2485. >                 mov     al,C
  2486. >                 mov     ah,Attr
  2487. >                 cld
  2488. >                 test    al,al
  2489. >                 jz      @@1
  2490. >                 test    ah,ah
  2491. >                 jz      @@3
  2492. >                 mov     edx,eax
  2493. >                 shl     eax,16
  2494. >                 mov     ax,dx
  2495. >                 shr     ecx,1
  2496. >                 rep     stosd
  2497. >                 adc     ecx,ecx
  2498. >                 rep     stosw
  2499. >                 jmp     @@4
  2500. >               @@1:
  2501. >                 mov     al,ah
  2502. >               @@2:
  2503. >                 inc     edi
  2504. >               @@3:
  2505. >                 stosb
  2506. >                 loop    @@2
  2507. >               @@4:
  2508. > end;
  2509. > 
  2510. > { Moves a two-colored string into a buffer. The characters in Str are   }
  2511. > { moved into the low bytes of corresponding words in Dest. The high     }
  2512. > { bytes of the words are set to Lo(Attr) or Hi(Attr). Tilde characters  }
  2513. > { (~) in the string toggle between the two attribute bytes passed in    }
  2514. > { the Attr word.                                                        }
  2515. > 
  2516. > {$USES esi,edi} {$FRAME-}
  2517. 1028,1047c1174,1198
  2518. <         MOV     DX,DS
  2519. >                 xor     ecx,ecx
  2520. >                 mov     esi,Str
  2521. >                 cld
  2522. >                 lodsb
  2523. >                 mov     cl,al
  2524. >                 jecxz   @@3
  2525. >                 mov     edi,Dest
  2526. >                 mov     edx,Attrs
  2527. >                 mov     ah,dl
  2528. >               @@1:
  2529. >                 lodsb
  2530. >                 cmp     al,'~'
  2531. >                 je      @@2
  2532. >                 stosw
  2533. >                 loop    @@1
  2534. >                 jmp     @@3
  2535. >               @@2:
  2536. >                 xchg    ah,dh
  2537. >                 loop    @@1
  2538. >               @@3:
  2539. > end;
  2540. > 
  2541. > { Moves a string into a buffer. The characters in Str are moved into    }
  2542. > { the low bytes of corresponding words in Dest. The high bytes of the   }
  2543. > { words are set to Attr, or remain unchanged if Attr is zero.           }
  2544. 1049,1070c1200
  2545. < procedure MoveStr(var Dest; const Str: String; Attr: Byte); assembler;
  2546. > {$USES esi,edi} {$FRAME-}
  2547. 1072c1202
  2548. < function CStrLen(const S: String): Integer; assembler;
  2549. > procedure MoveStr(var Dest; const Str: String; Attr: Byte); assembler;
  2550. 1074,1086c1204,1249
  2551. <         LES     DI,S
  2552. >                 xor     ecx,ecx
  2553. >                 mov     esi,Str
  2554. >                 cld
  2555. >                 lodsb
  2556. >                 mov     cl,al
  2557. >                 jecxz   @@4
  2558. >                 mov     edi,Dest
  2559. >                 mov     ah,Attr
  2560. >                 test    ah,ah
  2561. >                 jz      @@3
  2562. >               @@1:
  2563. >                 lodsb
  2564. >                 stosw
  2565. >                 loop    @@1
  2566. >                 jmp     @@4
  2567. >               @@2:
  2568. >                 inc     edi
  2569. >               @@3:
  2570. >                 movsb
  2571. >                 loop    @@2
  2572. >               @@4:
  2573. > end;
  2574. > 
  2575. > { Returns the length of string S, where S is a control string using     }
  2576. > { tilde characters ('~') to designate shortcut characters. The tildes   }
  2577. > { are excluded from the length of the string, as they will not appear   }
  2578. > { on the screen.                                                        }
  2579. > 
  2580. > function CStrLen(const S: String): Integer; assembler; {$USES edi} {$FRAME-}
  2581. > asm
  2582. >                 xor     ecx,ecx
  2583. >                 mov     edi,S
  2584. >                 mov     cl,[edi]
  2585. >                 inc     edi
  2586. >                 mov     edx,ecx
  2587. >                 jecxz   @@2
  2588. >                 mov     al,'~'
  2589. >                 cld
  2590. >               @@1:
  2591. >                 repne   scasb
  2592. >                 jne     @@2
  2593. >                 dec     edx
  2594. >                 test    esp,esp
  2595. >                 jmp     @@1
  2596. >               @@2:
  2597. >                 mov     eax,edx
  2598. 1092a1256
  2599. >   Times: ULong;
  2600. 1094c1258
  2601. < procedure ExitDrivers; far;
  2602. > procedure ExitDrivers;
  2603. 1097a1262
  2604. >   MouClose(hMou);
  2605. 1101a1267
  2606. >   InitKeyboard;
  2607. 1105a1272,1273
  2608. >   DosSetSignalExceptionFocus(True, Times);
  2609. >   SetExceptionHandler(@CtrlBreakHandler);
  2610. Comparing BP7\EDITORS.PAS and VP\EDITORS.PAS 
  2611. 17c17
  2612. < uses Drivers, Objects, Views, Dialogs;
  2613. > uses Drivers, Objects, Views, Dialogs, Use32;
  2614. 96c96
  2615. <   TEditBuffer = array[0..65519] of Char;
  2616. >   TEditBuffer = array[0..512*1024*1024-1] of Char;
  2617. 323c323
  2618. <   sfSearchFailed = $FFFF;
  2619. >   sfSearchFailed = $FFFFFFFF;
  2620. 326c326
  2621. <   FirstKeys: array[0..37 * 2] of Word = (37,
  2622. >   FirstKeys: array[0..37 * 2] of SmallWord = (37,
  2623. 346c346
  2624. <   QuickKeys: array[0..8 * 2] of Word = (8,
  2625. >   QuickKeys: array[0..8 * 2] of SmallWord = (8,
  2626. 351c351
  2627. <   BlockKeys: array[0..5 * 2] of Word = (5,
  2628. >   BlockKeys: array[0..5 * 2] of SmallWord = (5,
  2629. 486c486
  2630. <         if TPoint(Info).Y <= T.Y then
  2631. >         if TPoint(Info^).Y <= T.Y then
  2632. 494,527c494,496
  2633. < function Min(X, Y: Integer): Integer; near; assembler;
  2634. > function Min(X, Y: Integer): Integer;
  2635. > begin
  2636. >   if X <= Y then Min := X else Min := Y;
  2637. 530,542c499,501
  2638. < function CountLines(var Buf; Count: Word): Integer; near; assembler;
  2639. > function Max(X, Y: Integer): Integer;
  2640. > begin
  2641. >   if X >= Y then Max := X else Max := Y;
  2642. 545c504
  2643. < function ScanKeyMap(KeyMap: Pointer; KeyCode: Word): Word; near; assembler;
  2644. > function CountLines(var Buf; Count: Word): Integer; assembler; {$USES edi} {$FRAME-}
  2645. 547,564c506,535
  2646. <         PUSH    DS
  2647. >                 mov     edi,Buf
  2648. >                 mov     ecx,Count
  2649. >                 xor     edx,edx
  2650. >                 mov     al,0Dh
  2651. >                 cld
  2652. >               @@1:
  2653. >                 jecxz   @@2
  2654. >                 repne   scasb
  2655. >                 jne     @@2
  2656. >                 inc     edx
  2657. >                 jmp     @@1
  2658. >               @@2:
  2659. >                 mov     eax,edx
  2660. > end;
  2661. > 
  2662. > function ScanKeyMap(KeyMap: Pointer; KeyCode: Word): Word;
  2663. > var
  2664. >   I,Key: Word;
  2665. >   KeyTable: PWordArray absolute KeyMap;
  2666. > begin
  2667. >   for I := 1 to KeyTable^[0] do
  2668. >   begin
  2669. >     Key := KeyTable^[I*2-1];
  2670. >     if (Lo(Key) = Lo(KeyCode)) and ((Hi(Key) = 0) or (Hi(Key) = Hi(KeyCode))) then
  2671. >     begin
  2672. >       ScanKeyMap := KeyTable^[I*2];
  2673. >       Exit;
  2674. >     end;
  2675. >   end;
  2676. >   ScanKeyMap := 0;
  2677. 567c538
  2678. < function Scan(var Block; Size: Word; Str: String): Word; near; assembler;
  2679. > function Scan(var Block; Size: Word; Str: String): Word; assembler; {$USES ebx,esi,edi} {$FRAME-}
  2680. 569,612c540,586
  2681. <         PUSH    DS
  2682. >                 mov     edi,block
  2683. >                 mov     esi,Str
  2684. >                 mov     ecx,Size
  2685. >                 jecxz   @@3
  2686. >                 cld
  2687. >                 lodsb
  2688. >                 cmp     al,1
  2689. >                 jb      @@5
  2690. >                 ja      @@1
  2691. >                 lodsb
  2692. >                 repne   scasb
  2693. >                 jne     @@3
  2694. >                 jmp     @@5
  2695. >               @@1:
  2696. >                 movzx   ebx,al
  2697. >                 dec     ebx
  2698. >                 mov     edx,ecx
  2699. >                 sub     edx,eax
  2700. >                 jb      @@3
  2701. >                 lodsb
  2702. >                 inc     edx
  2703. >                 inc     edx
  2704. >               @@2:
  2705. >                 dec     edx
  2706. >                 mov     ecx,edx
  2707. >                 repne   scasb
  2708. >                 jne     @@3
  2709. >                 mov     edx,ecx
  2710. >                 mov     ecx,ebx
  2711. >                 rep     cmpsb
  2712. >                 je      @@4
  2713. >                 sub     ecx,ebx
  2714. >                 add     esi,ecx
  2715. >                 add     edi,ecx
  2716. >                 inc     edi
  2717. >                 test    edx,edx
  2718. >                 jne     @@2
  2719. >               @@3:
  2720. >                 xor     eax,eax
  2721. >                 jmp     @@6
  2722. >               @@4:
  2723. >                 sub     edi,ebx
  2724. >               @@5:
  2725. >                 mov     eax,edi
  2726. >                 sub     eax,Block
  2727. >               @@6:
  2728. >                 dec     eax
  2729. 615c589
  2730. < function IScan(var Block; Size: Word; Str: String): Word; near; assembler;
  2731. > function IScan(var Block; Size: Word; Str: String): Word; assembler; {$USES ebx,esi,edi} {$FRAME+}
  2732. 619,682c593,661
  2733. <         PUSH    DS
  2734. >                 lea     edi,S
  2735. >                 mov     esi,Str
  2736. >                 xor     eax,eax
  2737. >                 lodsb
  2738. >                 stosb
  2739. >                 mov     ecx,eax
  2740. >                 mov     ebx,eax
  2741. >                 jecxz   @@9
  2742. >               @@1:
  2743. >                 lodsb
  2744. >                 cmp     al,'a'
  2745. >                 jb      @@2
  2746. >                 cmp     al,'z'
  2747. >                 ja      @@2
  2748. >                 sub     al,'a'-'A'
  2749. >               @@2:
  2750. >                 stosb
  2751. >                 loop    @@1
  2752. >                 sub     edi,ebx
  2753. >                 mov     esi,Block
  2754. >                 mov     ecx,Size
  2755. >                 jecxz   @@8
  2756. >                 cld
  2757. >                 sub     ecx,ebx
  2758. >                 jb      @@8
  2759. >                 inc     ecx
  2760. >               @@4:
  2761. >                 mov     ah,[edi]
  2762. >                 and     ah,0DFh
  2763. >               @@5:
  2764. >                 lodsb
  2765. >                 and     al,0DFh
  2766. >                 cmp     al,ah
  2767. >                 loopne  @@5
  2768. >                 jne     @@8
  2769. >                 dec     esi
  2770. >                 mov     edx,ecx
  2771. >                 mov     ecx,ebx
  2772. >               @@6:
  2773. >                 repe    cmpsb
  2774. >                 je      @@10
  2775. >                 mov     al,[esi-1]
  2776. >                 cmp     al,'a'
  2777. >                 jb      @@7
  2778. >                 cmp     al,'z'
  2779. >                 ja      @@7
  2780. >                 sub     al,'a'-'A'
  2781. >               @@7:
  2782. >                 cmp     al,[edi-1]
  2783. >                 je      @@6
  2784. >                 sub     ecx,ebx
  2785. >                 lea     esi,[esi+ecx+1]
  2786. >                 add     edi,ecx
  2787. >                 mov     ecx,edx
  2788. >                 test    ecx,ecx
  2789. >                 jne     @@4
  2790. >               @@8:
  2791. >                 xor     eax,eax
  2792. >                 jmp     @@11
  2793. >               @@9:
  2794. >                 mov     eax,1
  2795. >                 jmp     @@11
  2796. >               @@10:
  2797. >                 sub     esi,ebx
  2798. >                 mov     eax,esi
  2799. >                 sub     eax,Block
  2800. >                 inc     eax
  2801. >               @@11:
  2802. >                 dec     eax
  2803. 736c715
  2804. <   if (Longint(Location) <> Longint(ALocation)) or
  2805. >   if (Location.X <> ALocation.X) or (Location.Y <> ALocation.Y) or
  2806. 794c773
  2807. < function TEditor.BufChar(P: Word): Char; assembler;
  2808. > function TEditor.BufChar(P: Word): Char; assembler; {$USES None} {$FRAME-}
  2809. 796,802c775,782
  2810. <         LES     DI,Self
  2811. >                 mov     ecx,Self
  2812. >                 mov     edx,P
  2813. >                 cmp     edx,[ecx].TEditor.CurPtr
  2814. >                 jb      @@1
  2815. >                 add     edx,[ecx].TEditor.GapLen
  2816. >               @@1:
  2817. >                 add     edx,[ecx].TEditor.Buffer
  2818. >                 mov     al,[edx]
  2819. 805c785
  2820. < function TEditor.BufPtr(P: Word): Word; assembler;
  2821. > function TEditor.BufPtr(P: Word): Word; assembler; {$USES None} {$FRAME-}
  2822. 807,812c787,792
  2823. <         LES     DI,Self
  2824. >                 mov     ecx,Self
  2825. >                 mov     eax,P
  2826. >                 cmp     eax,[ecx].TEditor.CurPtr
  2827. >                 jb      @@1
  2828. >                 add     eax,[ecx].TEditor.GapLen
  2829. >               @@1:
  2830. 875d854
  2831. <   ShiftState: Byte absolute $40:$17;
  2832. 880c859
  2833. <     if (ShiftState and $03 <> 0) and
  2834. >     if (GetShiftState and $03 <> 0) and
  2835. 953c932
  2836. <         I := EditorDialog(edReplacePrompt, Pointer(C));
  2837. >         I := EditorDialog(edReplacePrompt, @C);
  2838. 997c976
  2839. <   B: array[0..MaxLineLength - 1] of Word;
  2840. >   B: array[0..MaxLineLength - 1] of SmallWord;
  2841. 1028c1007
  2842. <   Width: Integer; Colors: Word); assembler;
  2843. >   Width: Integer; Colors: Word); assembler; {$USES ebx,esi,edi} {$FRAME+}
  2844. 1030,1083c1009,1070
  2845. <         PUSH    DS
  2846. >                 mov     ebx,Self
  2847. >                 mov     edi,DrawBuf
  2848. >                 mov     esi,LinePtr
  2849. >                 xor     edx,edx
  2850. >                 cld
  2851. >                 mov     ah,Colors.Byte[0]
  2852. >                 mov     ecx,[ebx].TEditor.SelStart
  2853. >                 Call    @@10
  2854. >                 mov     ah,Colors.Byte[1]
  2855. >                 mov     ecx,[ebx].TEditor.CurPtr
  2856. >                 Call    @@10
  2857. >                 add     esi,[ebx].TEditor.GapLen
  2858. >                 mov     ecx,[ebx].TEditor.SelEnd
  2859. >                 add     ecx,[ebx].TEditor.GapLen
  2860. >                 Call    @@10
  2861. >                 mov     ah,Colors.Byte[0]
  2862. >                 mov     ecx,[ebx].TEditor.BufSize
  2863. >                 Call    @@10
  2864. >                 jmp     @@31
  2865. >               @@10:
  2866. >                 sub     ecx,esi
  2867. >                 ja      @@11
  2868. >                 ret
  2869. >               @@11:
  2870. >                 mov     ebx,[ebx].TEditor.Buffer
  2871. >                 add     esi,ebx
  2872. >                 mov     ebx,Width
  2873. >               @@12:
  2874. >                 lodsb
  2875. >                 cmp     al,' '
  2876. >                 jb      @@20
  2877. >               @@13:
  2878. >                 stosw
  2879. >                 inc     edx
  2880. >               @@14:
  2881. >                 cmp     edx,ebx
  2882. >                 jae     @@30
  2883. >                 loop    @@12
  2884. >                 mov     ebx,Self
  2885. >                 sub     esi,[ebx].TEditor.Buffer
  2886. >                 ret
  2887. >               @@20:
  2888. >                 cmp     al,0Dh
  2889. >                 je      @@30
  2890. >                 cmp     al,09h
  2891. >                 jne     @@13
  2892. >                 mov     al,' '
  2893. >               @@21:
  2894. >                 stosw
  2895. >                 inc     edx
  2896. >                 test    dl,7
  2897. >                 jne     @@21
  2898. >                 jmp     @@14
  2899. >               @@30:
  2900. >                 pop     ecx
  2901. >               @@31:
  2902. >                 mov     al,' '
  2903. >                 mov     ecx,Width
  2904. >                 sub     ecx,edx
  2905. >                 jbe     @@32
  2906. >                 rep     stosw
  2907. >               @@32:
  2908. 1104d1090
  2909. <   ShiftState: Byte absolute $40:$17;
  2910. 1125c1111
  2911. <   if Selecting or (ShiftState and $03 <> 0) then SelectMode := smExtend;
  2912. >   if Selecting or (GetShiftState and $03 <> 0) then SelectMode := smExtend;
  2913. 1256c1242
  2914. <     if (NewSize > $FFF0) or not SetBufSize(NewSize) then
  2915. >     if not SetBufSize(NewSize) then
  2916. 1322c1308
  2917. < function TEditor.LineEnd(P: Word): Word; assembler;
  2918. > function TEditor.LineEnd(P: Word): Word; assembler; {$USES ebx,esi,edi} {$FRAME-}
  2919. 1324,1347c1310,1335
  2920. <         PUSH    DS
  2921. >                 mov     esi,Self
  2922. >                 mov     ebx,[esi].TEditor.Buffer
  2923. >                 mov     edi,P
  2924. >                 mov     al,0Dh
  2925. >                 cld
  2926. >                 mov     ecx,[esi].TEditor.CurPtr
  2927. >                 sub     ecx,edi
  2928. >                 jbe     @@1
  2929. >                 add     edi,ebx
  2930. >                 repne   scasb
  2931. >                 je      @@2
  2932. >                 mov     edi,[esi].TEditor.CurPtr
  2933. >               @@1:
  2934. >                 mov     ecx,[esi].TEditor.BufLen
  2935. >                 sub     ecx,edi
  2936. >                 jecxz   @@4
  2937. >                 add     ebx,[esi].TEditor.GapLen
  2938. >                 add     edi,ebx
  2939. >                 repne   scasb
  2940. >                 jne     @@3
  2941. >               @@2:
  2942. >                 dec     edi
  2943. >               @@3:
  2944. >                 sub     edi,ebx
  2945. >               @@4:
  2946. >                 mov     eax,edi
  2947. 1375c1363
  2948. < function TEditor.LineStart(P: Word): Word; assembler;
  2949. > function TEditor.LineStart(P: Word): Word; assembler; {$USES ebx,esi,edi} {$FRAME-}
  2950. 1377,1412c1365,1400
  2951. <         PUSH    DS
  2952. >                 mov     esi,Self
  2953. >                 mov     ebx,[esi].TEditor.Buffer
  2954. >                 mov     edi,P
  2955. >                 mov     al,0Dh
  2956. >                 std
  2957. >                 mov     ecx,edi
  2958. >                 sub     ecx,[esi].TEditor.CurPtr
  2959. >                 jbe     @@1
  2960. >                 add     ebx,[esi].TEditor.GapLen
  2961. >                 lea     edi,[edi+ebx-1]
  2962. >                 repne   scasb
  2963. >                 je      @@2
  2964. >                 sub     ebx,[esi].TEditor.GapLen
  2965. >                 mov     edi,[esi].TEditor.CurPtr
  2966. >               @@1:
  2967. >                 mov     ecx,edi
  2968. >                 jecxz   @@4
  2969. >                 lea     edi,[edi+ebx-1]
  2970. >                 repne   scasb
  2971. >                 jne     @@3
  2972. >               @@2:
  2973. >                 inc     edi
  2974. >                 inc     edi
  2975. >                 sub     edi,ebx
  2976. >                 cmp     edi,[esi].TEditor.CurPtr
  2977. >                 je      @@4
  2978. >                 cmp     edi,[esi].TEditor.BufLen
  2979. >                 je      @@4
  2980. >                 cmp     [ebx+edi].Byte,0Ah
  2981. >                 jne     @@4
  2982. >                 inc     edi
  2983. >                 jmp     @@4
  2984. >               @@3:
  2985. >                 xor     edi,edi
  2986. >               @@4:
  2987. >                 mov     eax,edi
  2988. 1433c1421
  2989. < function TEditor.NextChar(P: Word): Word; assembler;
  2990. > function TEditor.NextChar(P: Word): Word; assembler; {$USES ebx,esi,edi} {$FRAME-}
  2991. 1435,1451c1423,1439
  2992. <         PUSH    DS
  2993. >                 mov     esi,Self
  2994. >                 mov     edi,P
  2995. >                 cmp     edi,[esi].TEditor.BufLen
  2996. >                 je      @@2
  2997. >                 inc     edi
  2998. >                 cmp     edi,[esi].TEditor.BufLen
  2999. >                 je      @@2
  3000. >                 mov     ebx,[esi].TEditor.Buffer
  3001. >                 cmp     edi,[esi].TEditor.CurPtr
  3002. >                 jb      @@1
  3003. >                 add     ebx,[esi].TEditor.GapLen
  3004. >               @@1:
  3005. >                 cmp     [ebx+edi-1].Word,0A0Dh
  3006. >                 jne     @@2
  3007. >                 inc     edi
  3008. >               @@2:
  3009. >                 mov     eax,edi
  3010. 1468c1456
  3011. < function TEditor.PrevChar(P: Word): Word; assembler;
  3012. > function TEditor.PrevChar(P: Word): Word; assembler; {$USES ebx,esi,edi} {$FRAME-}
  3013. 1470,1485c1458,1473
  3014. <         PUSH    DS
  3015. >                 mov     esi,Self
  3016. >                 mov     edi,P
  3017. >                 test    edi,edi
  3018. >                 je      @@2
  3019. >                 dec     edi
  3020. >                 je      @@2
  3021. >                 mov     ebx,[esi].TEditor.Buffer
  3022. >                 cmp     edi,[esi].TEditor.CurPtr
  3023. >                 jb      @@1
  3024. >                 add     ebx,[esi].TEditor.GapLen
  3025. >               @@1:
  3026. >                 cmp     [ebx+edi-1].Word,0A0Dh
  3027. >                 jne     @@2
  3028. >                 dec     edi
  3029. >               @@2:
  3030. >                 mov     eax,edi
  3031. 1569,1570c1557,1558
  3032. <   Longint(CurPos) := 0;
  3033. >   CurPos.X := 0; CurPos.Y := 0;
  3034. >   Delta.X := 0; Delta.Y := 0;
  3035. 1848c1836
  3036. <   if Buffer <> nil then DisposeBuffer(Buffer);
  3037. >   inherited DoneBuffer;
  3038. 1887c1875
  3039. <     if (FSize > $FFF0) or not SetBufSize(Word(FSize)) then
  3040. >     if not SetBufSize(Word(FSize)) then
  3041. 1956a1945
  3042. >   P: Pointer;
  3043. 1958a1948
  3044. >   if NewSize > SizeOf(TEditBuffer) then Exit;
  3045. 1960,1961c1950
  3046. <     if NewSize > $F000 then NewSize := $FFF0 else
  3047. >     NewSize := (NewSize + $0FFF) and $FFFF000;
  3048. 1965c1954,1960
  3049. <       if not SetBufferSize(Buffer, NewSize) then Exit;
  3050. >     begin
  3051. >       P := MemAlloc(NewSize);
  3052. >       if P = nil then Exit;
  3053. >       Move(Buffer^, P^, BufSize);
  3054. >       FreeMem(Buffer, BufSize);
  3055. >       Buffer := P;
  3056. >     end;
  3057. 1968c1963,1973
  3058. <     if NewSize < BufSize then SetBufferSize(Buffer, NewSize);
  3059. >     if NewSize < BufSize then
  3060. >     begin
  3061. >       P := MemAlloc(NewSize);
  3062. >       if P = nil then NewSize := BufSize
  3063. >      else
  3064. >       begin
  3065. >         Move(Buffer^, P^, BufSize);
  3066. >         FreeMem(Buffer, BufSize);
  3067. >         Buffer := P;
  3068. >       end;
  3069. >     end;
  3070. Comparing BP7\MEMORY.PAS and VP\MEMORY.PAS 
  3071. 13c13
  3072. < {$O+,F+,X+,I-,S-,Q-}
  3073. > {$X+,I-,S-,Q-}
  3074. 16a17,18
  3075. > uses Use32;
  3076. > 
  3077. 18d19
  3078. <   MaxHeapSize: Word = 655360 div 16;    { 640K }
  3079. 20d20
  3080. <   MaxBufMem: Word = 65536 div 16;       {  64K }
  3081. 28d27
  3082. < function MemAllocSeg(Size: Word): Pointer;
  3083. 36c35
  3084. < {$IFNDEF DPMI}
  3085. > { The following procedure is not implemented
  3086. 38,40c37
  3087. < procedure GetBufMem(var P: Pointer; Size: Word);
  3088. > function MemAllocSeg(Size: Word): Pointer;
  3089. 42c39
  3090. < {$ENDIF}
  3091. > }
  3092. 48c45
  3093. <     Ofs, Seg: Word;
  3094. >     Ofs: Longint;
  3095. 51,52d47
  3096. < {$IFDEF DPMI}
  3097. 57a53,60
  3098. >     Size: Word;
  3099. >     Data: record end;
  3100. >   end;
  3101. > 
  3102. >   PBuffer = ^TBuffer;
  3103. >   TBuffer = record
  3104. >     Next: PBuffer;
  3105. >     Size: Word;
  3106. 63a67
  3107. >   BufferList: PBuffer = nil;
  3108. 67,79d70
  3109. < function MemAllocateBlock(HeapHandle, Size, Attributes: Word;
  3110. 101c92
  3111. < function HeapNotify(Size: Word): Integer; far;
  3112. > function HeapNotify(Size: Word): Integer;
  3113. 149,161d139
  3114. < function MemAllocSeg(Size: Word): Pointer;
  3115. 167,169c145
  3116. <   PtrRec(Cache).Ofs := 0;
  3117. >   if MaxAvail >= Size then GetMem(Cache,Size) else Cache := nil;
  3118. 178a155
  3119. >     Cache^.Size := Size;
  3120. 189d165
  3121. <   PtrRec(Cache).Seg := PtrRec(P).Seg;
  3122. 200c176
  3123. <     MemFreeBlock(PtrRec(Cache).Seg);
  3124. >     FreeMem(Cache,Cache^.Size);
  3125. 205,322d180
  3126. < begin
  3127. 324c182
  3128. <   P: Pointer;
  3129. >   Buffer: PBuffer;
  3130. 326,329c184,186
  3131. <   HeapResult := 1;
  3132. >   Inc(Size, SizeOf(TBuffer));
  3133. >   Buffer := MemAlloc(Size);
  3134. >   if Buffer <> nil then
  3135. 331,332c188,191
  3136. <     FreeMem(P, Size);
  3137. >     Buffer^.Next := BufferList;
  3138. >     Buffer^.Size := Size;
  3139. >     BufferList := Buffer;
  3140. >     Inc(PtrRec(Buffer).Ofs, SizeOf(TBuffer));
  3141. 334c193
  3142. <   MemAlloc := P;
  3143. >   P := Buffer;
  3144. 337c196
  3145. < function MemAllocSeg(Size: Word): Pointer;
  3146. > procedure DisposeBuffer(P: Pointer);
  3147. 339c198
  3148. <   P, T: Pointer;
  3149. >   Buffer,PrevBuf: PBuffer;
  3150. 341,342d199
  3151. <   Size := (Size + 7) and $FFF8;
  3152. 345c202,205
  3153. <     if PtrRec(P).Ofs = 0 then
  3154. >     Dec(PtrRec(P).Ofs, SizeOf(TBuffer));
  3155. >     Buffer := BufferList;
  3156. >     PrevBuf := nil;
  3157. >     while (Buffer <> nil) and (P <> Buffer) do
  3158. 347,349c207,210
  3159. <       PtrRec(T).Ofs := Size and 15;
  3160. >       PrevBuf := Buffer;
  3161. >       Buffer := Buffer^.Next;
  3162. >     end;
  3163. >     if Buffer <> nil then
  3164. 351,353c212,213
  3165. <       T := P;
  3166. >       if PrevBuf = nil then BufferList := Buffer^.Next else PrevBuf^.Next := Buffer^.Next;
  3167. >       FreeMem(Buffer,Buffer^.Size);
  3168. 355,511d214
  3169. <     FreeMem(T, 8);
  3170. 515,518c218
  3171. < procedure NewBuffer(var P: Pointer; Size: Word);
  3172. > function GetBufferSize(P: Pointer): Word;
  3173. 520,521c220,221
  3174. <   BufSize := (Size + 15) shr 4 + 1;
  3175. >   if P = nil then GetBufferSize := 0
  3176. >  else
  3177. 523,527c223,224
  3178. <     Buffer := Ptr(BufHeapPtr, 0);
  3179. >     Dec(PtrRec(P).Ofs,SizeOf(TBuffer));
  3180. >     GetBufferSize := PBuffer(P)^.Size;
  3181. 531,542d227
  3182. < procedure DisposeBuffer(P: Pointer);
  3183. 544,545d228
  3184. < var
  3185. 547,548d229
  3186. <   Dec(PtrRec(P).Seg);
  3187. 550,565d230
  3188. <   if BufHeapPtr + NewSize - GetBufSize(P) <= BufHeapEnd then
  3189. 567,582d231
  3190. < 
  3191. Comparing BP7\MENUS.PAS and VP\MENUS.PAS 
  3192. 13c13
  3193. < {$O+,F+,X+,I-,S-}
  3194. > {$X+,I-,S-,Cdecl-}
  3195. 17c17
  3196. < uses Objects, Drivers, Views;
  3197. > uses Objects, Drivers, Views, Use32;
  3198. 1126c1126
  3199. <       if I + L < Size.X then
  3200. >       if I + L - 1 < Size.X then                { !!!  -1 is added }
  3201. 1135,1137c1135,1137
  3202. <         MoveChar(B[I], ' ', Byte(Color), 1);
  3203. >        {MoveChar(B[I], ' ', Byte(Color), 1);    !!!!  }
  3204. >         MoveCStr(B[I], T^.Text^, Color);                { [I+1] }
  3205. >         MoveChar(B[I + L], ' ', Byte(CNormal), 1);      { [I+L+1],' ',Byte(Color) }
  3206. 1139c1139
  3207. <       Inc(I, L + 2);
  3208. >       Inc(I, L + 1);                                    { L+2 }
  3209. 1192c1192
  3210. <       K := I + CStrLen(T^.Text^) + 2;
  3211. >       K := I + CStrLen(T^.Text^) + 1;  { !!! + 2 }
  3212. 1222c1222
  3213. <           Event.InfoPtr := nil;
  3214. >           Event.InfoPtr := T;
  3215. Comparing BP7\MSGBOX.PAS and VP\MSGBOX.PAS 
  3216. 13c13
  3217. < {$O+,F+,X+,I-,S-}
  3218. > {$X+,I-,S-}
  3219. 17c17
  3220. < uses Objects;
  3221. > uses Objects, Use32;
  3222. Comparing BP7\TEXTVIEW.PAS and VP\TEXTVIEW.PAS 
  3223. 13c13
  3224. < {$O+,F+,X+,I-,S-}
  3225. > {$X+,I-,S-,Cdecl-}
  3226. 17c17
  3227. < uses Objects, Drivers, Views, Dos;
  3228. > uses Objects, Drivers, Views, Dos, Use32;
  3229. 194c194
  3230. < procedure DecDi; near; assembler;
  3231. > procedure DecEDi; assembler; {$USES None} {$FRAME-}
  3232. 196,199c196,200
  3233. <         CMP     DI,WORD PTR [SI].TTerminal.Buffer
  3234. >                 cmp     edi,[esi].TTerminal.Buffer
  3235. >                 ja      @@1
  3236. >                 add     edi,[esi].TTerminal.BufSize
  3237. >               @@1:
  3238. >                 dec     edi
  3239. 202c203
  3240. < procedure IncDi; near; assembler;
  3241. > procedure IncEDi; assembler; {$USES None} {$FRAME-}
  3242. 204,210c205,211
  3243. <         INC     DI
  3244. >                 inc     edi
  3245. >                 mov     eax,[esi].TTerminal.Buffer
  3246. >                 add     eax,[esi].TTerminal.BufSize
  3247. >                 cmp     edi,eax
  3248. >                 jb      @@1
  3249. >                 mov     edi,[esi].TTerminal.Buffer
  3250. >               @@1:
  3251. 212a214,215
  3252. > {$USES esi,edi} {$FRAME-}
  3253. > 
  3254. 217,257c220,266
  3255. <         PUSH    DS
  3256. >                 mov     esi,Self
  3257. >                 mov     edi,[esi].TTerminal.Buffer
  3258. >                 add     edi,Pos
  3259. >               @@1:
  3260. >                 mov     ecx,Lines
  3261. >                 jecxz   @@6
  3262. >                 mov     eax,[esi].TTerminal.QueBack
  3263. >                 add     eax,[esi].TTerminal.Buffer
  3264. >                 cmp     edi,eax
  3265. >                 je      @@7
  3266. >                 Call    DecEDI
  3267. >               @@2:
  3268. >                 mov     eax,[esi].TTerminal.QueBack
  3269. >                 add     eax,[esi].TTerminal.Buffer
  3270. >                 cmp     edi,eax
  3271. >                 ja      @@3
  3272. >                 mov     ecx,edi
  3273. >                 sub     ecx,[esi].TTerminal.Buffer
  3274. >                 jmp     @@4
  3275. >               @@3:
  3276. >                 mov     ecx,edi
  3277. >                 sub     ecx,eax
  3278. >               @@4:
  3279. >                 mov     al,LineSeparator
  3280. >                 inc     ecx
  3281. >                 std
  3282. >                 repne   scasb
  3283. >                 je      @@5
  3284. >                 mov     eax,edi
  3285. >                 sub     eax,[esi].TTerminal.Buffer
  3286. >                 inc     eax
  3287. >                 cmp     eax,[esi].TTerminal.QueBack
  3288. >                 je      @@8
  3289. >                 mov     edi,[esi].TTerminal.Buffer
  3290. >                 add     edi,[esi].TTerminal.BufSize
  3291. >                 dec     edi
  3292. >                 jmp     @@2
  3293. >               @@5:
  3294. >                 dec     Lines
  3295. >                 jnz     @@2
  3296. >               @@6:
  3297. >                 Call    IncEDI
  3298. >                 Call    IncEDI
  3299. >                 mov     eax,edi
  3300. >               @@7:
  3301. >                 sub     eax,[esi].TTerminal.Buffer
  3302. >               @@8:
  3303. 324c333
  3304. <     Filler: Array [1..12] of Char;
  3305. >     Filler: array [1..4] of Char;
  3306. 384c393
  3307. <     Handle := $FFFF;
  3308. >     Handle := $FFFFFFFF;
  3309. Comparing BP7\DIALOGS.PAS and VP\DIALOGS.PAS 
  3310. 13c13
  3311. < {$O+,F+,X+,I-,S-}
  3312. > {$X+,I-,S-,Cdecl-}
  3313. 17c17
  3314. < uses Objects, Drivers, Views, Validate;
  3315. > uses Objects, Drivers, Views, Validate, Use32;
  3316. 633,641d632
  3317. < function Max(A, B: Integer): Integer;
  3318. 1354,1372c1345,1349
  3319. < function TCluster.ButtonState(Item: Integer): Boolean; assembler;
  3320. > function TCluster.ButtonState(Item: Integer): Boolean;
  3321. > begin
  3322. >   if Item > 31
  3323. >     then ButtonState := False
  3324. >     else ButtonState := ((1 shl Item) and EnableMask) <> 0;
  3325. 1585,1613c1562,1581
  3326. < procedure TCluster.SetButtonState(AMask: Longint; Enable: Boolean); assembler;
  3327. > procedure TCluster.SetButtonState(AMask: Longint; Enable: Boolean);
  3328. > var
  3329. >   I,M: Longint;
  3330. > begin
  3331. >   if Enable then EnableMask := EnableMask or AMask
  3332. >             else EnableMask := EnableMask and not AMask;
  3333. >   if Strings.Count <= 32 then
  3334. >   begin
  3335. >     M := 1;
  3336. >     for I := 1 to Strings.Count do
  3337. >     begin
  3338. >       if (M and EnableMask) <> 0 then
  3339. >       begin
  3340. >         Options := Options or ofSelectable;
  3341. >         Exit;
  3342. >       end;
  3343. >       M := M shl 1;
  3344. >     end;
  3345. >     Options := Options and not ofSelectable;
  3346. >   end;
  3347. Comparing BP7\HISTLIST.PAS and VP\HISTLIST.PAS 
  3348. 13c13
  3349. < {$O+,F+,X+,I-,S-}
  3350. > {$X+,I-,S-,Cdecl-}
  3351. 18,21c18,21
  3352. <     Byte Byte String          Byte Byte String
  3353. >      Longint  String        StrLen Longint String        StrLen
  3354. >     +----------------------------+----------------------------+--...--+
  3355. >     |  Id   | History string | L |  Id   | History string | L |
  3356. >     +----------------------------+----------------------------+--...--+
  3357. 27c27
  3358. < uses Objects;
  3359. > uses Objects, Use32;
  3360. 31c31
  3361. <   HistorySize: Word = 1024;
  3362. >   HistorySize: Word = 2*1024;
  3363. 34,36c34,36
  3364. < procedure HistoryAdd(Id: Byte; const Str: String);
  3365. > procedure HistoryAdd(Id: Longint; const Str: String);
  3366. > function HistoryCount(Id: Longint): Word;
  3367. > function HistoryStr(Id: Longint; Index: Integer): String;
  3368. 48c48
  3369. <   CurId: Byte;
  3370. >   CurId: Longint;
  3371. 53c53
  3372. < procedure AdvanceStringPointer; near; assembler;
  3373. > procedure AdvanceStringPointer; assembler; {$USES esi} {$FRAME-}
  3374. 55,77c55,77
  3375. <         PUSH    DS
  3376. >                 mov     ecx,HistoryUsed
  3377. >                 mov     edx,CurId
  3378. >                 mov     esi,CurString
  3379. >                 test    esi,esi
  3380. >                 jz      @@4
  3381. >                 cld
  3382. >                 cmp     esi,HistoryBlock
  3383. >                 jne     @@2
  3384. >                 cmp     esi,ecx
  3385. >                 je      @@3
  3386. >               @@1:
  3387. >                 lodsd                   { History Id  }
  3388. >                 cmp     eax,edx         { edx = CurId }
  3389. >                 je      @@4
  3390. >               @@2:
  3391. >                 movzx   eax,Byte Ptr [esi]
  3392. >                 lea     esi,[esi+eax+2]
  3393. >                 cmp     esi,ecx         { ecx = HistoryUsed }
  3394. >                 jb      @@1
  3395. >               @@3:
  3396. >                 xor     esi,esi
  3397. >               @@4:
  3398. >                 mov     CurString,esi
  3399. 82c82
  3400. < procedure DeleteString; near; assembler;
  3401. > procedure DeleteString; assembler; {$USES esi,edi} {$FRAME-}
  3402. 84,100c84,92
  3403. <         PUSH    DS
  3404. >                 cld
  3405. >                 mov     ecx,HistoryUsed
  3406. >                 mov     esi,CurString
  3407. >                 lea     edi,[esi-TYPE Longint]
  3408. >                 movzx   eax,Byte Ptr [esi]
  3409. >                 lea     esi,[esi+eax+2]
  3410. >                 sub     ecx,esi
  3411. >                 rep     movsb
  3412. >                 mov     HistoryUsed,edi
  3413. 105c97
  3414. < procedure InsertString(Id: Byte; const Str: String); near; assembler;
  3415. > procedure InsertString(Id: Longint; const Str: String); assembler; {$USES ebx,esi,edi} {$FRAME-}
  3416. 107,160c99,139
  3417. <         PUSH    DS
  3418. > { Position edi to the end the buffer  }
  3419. > {          edx to beginning of buffer }
  3420. >                 mov     edx,HistoryBlock
  3421. >                 mov     edi,HistoryUsed
  3422. >                 mov     esi,Str
  3423. >                 movzx   ebx,Byte Ptr [esi]
  3424. >                 add     ebx,TYPE Longint + TYPE Byte + TYPE Byte
  3425. >               @@1:
  3426. >                 mov     eax,edi
  3427. >                 add     eax,ebx
  3428. >                 sub     eax,edx         { edx = HistoryBlock }
  3429. >                 cmp     eax,HistorySize
  3430. >                 jb      @@2
  3431. > { Drop the last string off the end of the list }
  3432. >                 movzx   eax,Byte Ptr [edi-1] { Last string length }
  3433. >                 sub     edi,eax
  3434. >                 sub     edi,TYPE Longint + TYPE Byte + TYPE Byte
  3435. >                 jmp     @@1
  3436. > { Move the table down the size of the string }
  3437. >               @@2:
  3438. >                 std
  3439. >                 mov     esi,edi
  3440. >                 add     edi,ebx
  3441. >                 mov     HistoryUsed,edi
  3442. >                 mov     ecx,esi
  3443. >                 sub     ecx,edx         { edx = HistoryBlock }
  3444. >                 dec     esi
  3445. >                 dec     edi
  3446. >                 rep     movsb
  3447. > { Copy the string into the position }
  3448. >                 cld
  3449. >                 mov     edi,edx         { edx = HistoryBlock }
  3450. >                 mov     eax,Id
  3451. >                 stosd                   { Id     }
  3452. >                 mov     esi,Str
  3453. >                 xor     eax,eax
  3454. >                 lodsb
  3455. >                 stosb                   { StrLen }
  3456. >                 mov     ecx,eax
  3457. >                 rep     movsb           { String }
  3458. >                 stosb                   { StrLen }
  3459. 163c142
  3460. < procedure StartId(Id: Byte); near;
  3461. > procedure StartId(Id: Longint);
  3462. 169c148
  3463. < function HistoryCount(Id: Byte): Word;
  3464. > function HistoryCount(Id: Longint): Word;
  3465. 184c163
  3466. < procedure HistoryAdd(Id: Byte; const Str: String);
  3467. > procedure HistoryAdd(Id: Longint; const Str: String);
  3468. 201c180
  3469. < function HistoryStr(Id: Byte; Index: Integer): String;
  3470. > function HistoryStr(Id: Longint; Index: Integer): String;
  3471. 214,215c193
  3472. <   PChar(HistoryBlock)^ := #0;
  3473. >   HistoryUsed := Longint(HistoryBlock);
  3474. 222c200
  3475. <   Size := HistoryUsed - PtrRec(HistoryBlock).Ofs;
  3476. >   Size := HistoryUsed - Longint(HistoryBlock);
  3477. 233c211
  3478. <   HistoryUsed := PtrRec(HistoryBlock).Ofs + Size;
  3479. >   HistoryUsed := Longint(HistoryBlock) + Size;
  3480. Comparing BP7\OUTLINE.PAS and VP\OUTLINE.PAS 
  3481. 13c13
  3482. < {$O+,F+,X+,I-,S-,R-}
  3483. > {$X+,I-,S-,R-,Cdecl-}
  3484. 17c17
  3485. < uses Objects, Drivers, Views;
  3486. > uses Objects, Drivers, Views, Use32;
  3487. 289c289
  3488. <   const Chars: String): String; assembler;
  3489. >   const Chars: String): String; assembler; {$USES ebx,esi,edi} {$FRAME-}
  3490. 298,299c298
  3491. <         PUSH    DS
  3492. >                 cld
  3493. 302,312c301,311
  3494. <         XOR     BX,BX
  3495. >                 xor     ebx,ebx
  3496. >                 mov     eax,Flags
  3497. >                 mov     Expanded,bl
  3498. >                 shr     eax,1
  3499. >                 adc     Expanded,bl
  3500. >                 mov     Children,bl
  3501. >                 shr     eax,1
  3502. >                 adc     Children,bl
  3503. >                 mov     Last,bl
  3504. >                 shr     eax,1
  3505. >                 adc     Last,bl
  3506. 315,321c314,319
  3507. <         LDS     SI,Chars
  3508. >                 mov     esi,Chars
  3509. >                 inc     esi
  3510. >                 mov     edi,@Result
  3511. >                 inc     edi
  3512. >                 mov     edx,Lines
  3513. >                 inc     Level
  3514. 324,338c322,335
  3515. <         JMP     @@2
  3516. >                 jmp     @@2
  3517. >               @@1:
  3518. >                 xor     ebx,ebx
  3519. >                 shr     edx,1
  3520. >                 rcl     ebx,1
  3521. >                 mov     al,[esi].FillerOrBar[ebx]
  3522. >                 stosb
  3523. >                 mov     al,[esi].FillerOrBar
  3524. >                 mov     ecx,LevWidth
  3525. >                 dec     ecx
  3526. >                 rep     stosb
  3527. >               @@2:
  3528. >                 dec     Level
  3529. >                 jnz     @@1
  3530. 341,365c338,362
  3531. <         MOV     BH,0
  3532. >                 mov     ecx,EndWidth
  3533. >                 dec     ecx
  3534. >                 jz      @@4
  3535. >                 mov     bl,Last
  3536. >                 mov     al,[esi].YorL[ebx]
  3537. >                 stosb
  3538. >                 dec     ecx
  3539. >                 jz      @@4
  3540. >                 dec     ecx
  3541. >                 jz      @@3
  3542. >                 mov     al,[esi].StraightOrTee
  3543. >                 rep     stosb
  3544. >               @@3:
  3545. >                 mov     bl,Children
  3546. >                 mov     al,[esi].StraightOrTee[ebx]
  3547. >                 stosb
  3548. >               @@4:
  3549. >                 mov     bl,Expanded
  3550. >                 mov     al,[esi].Retracted[ebx]
  3551. >                 stosb
  3552. >                 mov     eax,edi
  3553. >                 mov     edi,@Result
  3554. >                 sub     eax,edi
  3555. >                 dec     eax
  3556. >                 stosb
  3557. 370,373c367,370
  3558. < function CallerFrame: Word; inline(
  3559. > function CallerFrame: Word; assembler; {$USES None} {$FRAME-}
  3560. > asm
  3561. >                 mov     eax,[ebp]
  3562. > end;
  3563. 403c400
  3564. < { Called whenever Node is receives focus }
  3565. > { Called whenever Node receives focus }
  3566. 521,522d517
  3567. <   label
  3568. 527c522
  3569. <     Children: Boolean;
  3570. >     Children,Done: Boolean;
  3571. 541a537,544
  3572. >     { IMPORTANT! Virtual Pascal's code generation differs from BP's one.}
  3573. >     { In the prolog of a nested procedure Virtual Pascal uses 'ENTER'   }
  3574. >     { CPU instruction with the appropriate lexical (nested) level.      }
  3575. >     { Exact lexical level of a procedure that issues FirstThat or       }
  3576. >     { ForEach is NOT known here. So I made an assumption that FirstThat }
  3577. >     { or ForEach CANNOT BE ISSUED FROM THE PROCEDURE WITH THE LEXICAL   }
  3578. >     { LEVEL GREATER THAN 3. For example, FirstThat function is called   }
  3579. >     { in a GetFocusedGraphic function which lexical level is 2.         }
  3580. 543,557c546,568
  3581. <         LES     DI,Cur                     { Push Cur }
  3582. >                 push    DWord Ptr [ebp-12] { Preserve local variables   }
  3583. >                 push    DWord Ptr [ebp-8]
  3584. >                 mov     ecx,[ebp-4]     { Load parent frame into ecx    }
  3585. >                 push    ecx             { Save it on stack              }
  3586. >                 push    Cur             { [1] = Cur: Pointer;           }
  3587. >                 push    Level           { [2] = Level: Integer;         }
  3588. >                 push    DWord Ptr [ecx+OFFSET Position] { [3] = Position: Integer; }
  3589. >                 push    Lines           { [4] = Lines: LongInt;         }
  3590. >                 push    Flags           { [5] = Flags: Word;            }
  3591. >                 mov     edx,[ecx+OFFSET CallerFrame]
  3592. >                 mov     eax,[edx-4]     { Copy stack frames of the      }
  3593. >                 mov     [ebp-4],eax     { parents                       }
  3594. >                 mov     eax,[edx-8]
  3595. >                 mov     [ebp-8],eax
  3596. >                 mov     eax,[edx-12]
  3597. >                 mov     [ebp-12],eax
  3598. >                 Call    DWord Ptr [ecx+OFFSET Action]
  3599. >                 pop     ecx
  3600. >                 pop     DWord Ptr [ebp-8]
  3601. >                 pop     DWord Ptr [ebp-12]
  3602. >                 mov     [ebp-4],ecx     { Restore parent frame          }
  3603. >                 and     al,[ecx+OFFSET CheckRslt].Boolean { Force to 0 if CheckRslt False }
  3604. >                 setnz   Done
  3605. 559a571,572
  3606. >     if Done then Exit;
  3607. > 
  3608. 574d586
  3609. <   Retn:
  3610. 580c592
  3611. <   asm                           { Convert 0, 1 to 0, FF }
  3612. >   asm   {$SAVES ALL}            { Convert 0, 1 to 0, FF }
  3613. 877c889
  3614. <    
  3615. > 
  3616. Comparing BP7\STDDLG.PAS and VP\STDDLG.PAS 
  3617. 13c13
  3618. < {$O+,F+,V-,X+,I-,S-}
  3619. > {$V-,X+,I-,S-,Cdecl-}
  3620. 17c17
  3621. < uses Objects, Drivers, Views, Dialogs, Dos;
  3622. > uses Objects, Drivers, Views, Dialogs, Os2Def, Os2Base, Dos, Use32;
  3623. 27c27
  3624. <   cmChDir       = 804;   { Used by TChDirDialog internally }
  3625. >   cmChangeDir   = 804;   { Used by TChDirDialog internally }
  3626. 46c46
  3627. <     Name: string[12];
  3628. >     Name: String;
  3629. 101c101
  3630. <     procedure ReadDirectory(AWildCard: PathStr);
  3631. >     procedure ReadDirectory(AWildCard: PathStr); virtual;
  3632. 152d151
  3633. <   private
  3634. 213d211
  3635. <   private
  3636. 295a294,296
  3637. > function PathValid(var Path: PathStr): Boolean; { !!! made public }
  3638. > function IsWild(const S: String): Boolean;      { !!! made public }
  3639. > function IsDir(const S: String): Boolean;       { !!! made public }
  3640. 301,319c302,308
  3641. < function DriveValid(Drive: Char): Boolean; near; assembler;
  3642. > function DriveValid(Drive: Char): Boolean;
  3643. > var
  3644. >   DriveNum,LogDrvMap: ULong;
  3645. > begin                   { LogDrvMap: Bit 0: 'A:', Bit 1: 'B:', etc }
  3646. >   if DosQueryCurrentDisk(DriveNum,LogDrvMap) = 0
  3647. >     then DriveValid := ((1 shl (Ord(Drive) - Ord('A'))) and LogDrvMap) <> 0
  3648. >     else DriveValid := False;
  3649. 333a323
  3650. >     FindClose(SR);
  3651. 339c329
  3652. <   IllegalChars = ';,=+<>|"[] \';
  3653. >   IllegalChars = ';,=+<>|"[] ';
  3654. 346c336
  3655. < function Contains(S1, S2: String): Boolean; near; assembler;
  3656. > function Contains(S1, S2: String): Boolean; assembler; {$USES esi,edi}{$FRAME-}
  3657. 348,371c338,363
  3658. <         PUSH    DS
  3659. >                 cld
  3660. >                 xor     eax,eax
  3661. >                 xor     ecx,ecx
  3662. >                 mov     esi,S1
  3663. >                 mov     edx,S2
  3664. >                 lodsb
  3665. >                 test    al,al
  3666. >                 jz      @@4
  3667. >                 mov     ah,al
  3668. >                 mov     cl,[edx]
  3669. >                 inc     edx
  3670. >               @@1:
  3671. >                 push    ecx
  3672. >                 mov     edi,edx
  3673. >                 lodsb
  3674. >                 repne   scasb
  3675. >                 pop     ecx
  3676. >                 je      @@3
  3677. >                 dec     ah
  3678. >                 jnz     @@1
  3679. >               @@2:
  3680. >                 xor     al,al
  3681. >                 jmp     @@4
  3682. >               @@3:
  3683. >                 mov     al,1
  3684. >               @@4:
  3685. 393c385
  3686. <  
  3687. > 
  3688. 409a402
  3689. >   FindClose(SR);
  3690. 677a671
  3691. >   FindClose(S);
  3692. 692a687
  3693. >   FindClose(S);
  3694. 708a704
  3695. >       FindClose(S);
  3696. 752c748
  3697. <   Month: array[1..12] of String[3] = 
  3698. >   Month: array[1..12] of String[3] =
  3699. 950c946
  3700. < function NoWildChars(S: String): String; near; assembler;
  3701. > function NoWildChars(S: String): String; assembler; {$USES esi,edi} {$FRAME-}
  3702. 952,972c948,968
  3703. <         PUSH    DS
  3704. >                 mov     esi,S
  3705. >                 xor     eax,eax
  3706. >                 lodsb
  3707. >                 mov     ecx,eax
  3708. >                 mov     edx,@Result
  3709. >                 lea     edi,[edx+1]
  3710. >                 jecxz   @@3
  3711. >               @@1:
  3712. >                 lodsb
  3713. >                 cmp     al,'?'
  3714. >                 je      @@2
  3715. >                 cmp     al,'*'
  3716. >                 je      @@2
  3717. >                 stosb
  3718. >               @@2:
  3719. >                 loop    @@1
  3720. >               @@3:
  3721. >                 mov     eax,edi
  3722. >                 sub     eax,edx
  3723. >                 dec     eax
  3724. >                 mov     [edx],al
  3725. 1076,1078c1072,1074
  3726. <           Directory := NewSTr(FName+'\');
  3727. >           Directory := NewSTr(FName+'\');
  3728. >           if Command <> cmFileInit then FileList^.Select;
  3729. >           FileList^.ReadDirectory(Directory^+WildCard);
  3730. 1179c1175
  3731. < function NewDirEntry(const DisplayText, Directory: String): PDirEntry; near;
  3732. > function NewDirEntry(const DisplayText, Directory: String): PDirEntry;
  3733. 1189,1193c1185,1190
  3734. < function GetCurDrive: Char; near; assembler;
  3735. > function GetCurDrive: Char;
  3736. > var
  3737. >   DriveNum,LogDrvMap: ULong;
  3738. > begin
  3739. >   DosQueryCurrentDisk(DriveNum,LogDrvMap);      { DriveNum: 1='A', 2='B', etc }
  3740. >   GetCurDrive := Chr(DriveNum + Ord('A') - 1);
  3741. 1209c1206
  3742. <         begin
  3743. >         begin
  3744. 1211,1212c1208,1209
  3745. <           begin
  3746. >           begin
  3747. >             S := FirstDir + OldC;
  3748. 1216c1213
  3749. <           AList^.Insert(NewDirEntry(S, OldC + ':\'));
  3750. >           AList^.Insert(NewDirEntry(S, OldC + ':\'));
  3751. 1259,1262c1256,1259
  3752. <         begin
  3753. >         begin
  3754. >           S := FirstDir;
  3755. >           isFirst := False;
  3756. >         end else S := MiddleDir;
  3757. 1266a1264
  3758. >     FindClose(SR);
  3759. Comparing BP7\VIEWS.PAS and VP\VIEWS.PAS 
  3760. 13c13
  3761. < {$O+,F+,X+,I-,S-}
  3762. > {$X+,I-,S-,Cdecl-}
  3763. 17c17
  3764. < uses Objects, Drivers, Memory;
  3765. > uses Objects, Drivers, Memory, Use32;
  3766. 192c192
  3767. <   TDrawBuffer = array[0..MaxViewWidth - 1] of Word;
  3768. >   TDrawBuffer = array[0..MaxViewWidth - 1] of SmallWord;
  3769. 423c423
  3770. <   TVideoBuf = array[0..3999] of Word;
  3771. >   TVideoBuf = array[0..3999] of SmallWord;
  3772. 621a622,623
  3773. > uses Os2Def, Os2Base;
  3774. > 
  3775. 642a645,663
  3776. > { Far16 functions cannot be called directly from BASM code because Virtual    }
  3777. > { Pascal calls 16-bit functions via special run-time library thunk routine.   }
  3778. > { That is why these interface function are used instead.                      }
  3779. > 
  3780. > function Vio32ShowBuf(BufOfs,Len,VioHandle: Word): ApiRet;
  3781. > begin
  3782. >   VioShowBuf(BufOfs,Len,VioHandle);
  3783. > end;
  3784. > 
  3785. > function Vio32SetCurPos(Row,Column: Word; VioHandle: Word): ApiRet;
  3786. > begin
  3787. >   VioSetCurPos(Row,Column,VioHandle);
  3788. > end;
  3789. > 
  3790. > function Vio32SetCurType(var CurData: VioCursorInfo; VioHandle: Word): ApiRet;
  3791. > begin
  3792. >   VioSetCurType(CurData,VioHandle);
  3793. > end;
  3794. > 
  3795. 647c668
  3796. < procedure MapColor; near; assembler;
  3797. > procedure MapColor; assembler; {$USES ebx} {$FRAME-}
  3798. 649c670
  3799. <   Self = 6;
  3800. >   Self = 8;
  3801. 652,681c673,698
  3802. <         OR      AL,AL
  3803. >                 test    al,al
  3804. >                 jz      @@3
  3805. >                 mov     ecx,[ebp].Self
  3806. >               @@1:
  3807. >                 push    ecx
  3808. >                 push    eax
  3809. >                 push    ecx                     { [1]:Pointer = Self    }
  3810. >                 mov     ecx,[ecx]
  3811. >                 Call    DWord Ptr [ecx].TView_GetPalette
  3812. >                 mov     ebx,eax
  3813. >                 pop     eax
  3814. >                 pop     ecx
  3815. >                 test    ebx,ebx
  3816. >                 jz      @@2
  3817. >                 cmp     al,[ebx]
  3818. >                 ja      @@3
  3819. >                 xlat
  3820. >                 test    al,al
  3821. >                 jz      @@3
  3822. >               @@2:
  3823. >                 mov     ecx,[ecx].TView.Owner
  3824. >                 jecxz   @@4
  3825. >                 jmp     @@1
  3826. >               @@3:
  3827. >                 mov     al,ErrorAttr
  3828. >               @@4:
  3829. 688c705
  3830. < procedure MapCPair; near; assembler;
  3831. > procedure MapCPair; assembler; {$USES None} {$FRAME-}
  3832. 690,695c707,713
  3833. <         OR      AH,AH
  3834. >                 test    ah,ah
  3835. >                 jz      @@1
  3836. >                 xchg    al,ah
  3837. >                 Call    MapColor
  3838. >                 xchg    al,ah
  3839. >               @@1:
  3840. >                 Call    MapColor
  3841. 699,702c717,720
  3842. < { In    AX    = Y coordinate                            }
  3843. > { In    eax   = Y coordinate                            }
  3844. > {       ebx   = X coordinate                            }
  3845. > {       ecx   = Count                                   }
  3846. > {       edi   = Buffer Pointer                          }
  3847. 704c722
  3848. < procedure WriteView; near; assembler;
  3849. > procedure WriteView; assembler; {$USES None} {$FRAME-}
  3850. 706c724
  3851. <   Self   =   6;
  3852. >   Self   =   8;
  3853. 709c727
  3854. <   BufOfs = -10;
  3855. >   BufOfs = -12;
  3856. 711,937c729,935
  3857. <         MOV     [BP].BufOfs,BX
  3858. >                 mov     [ebp].BufOfs,ebx
  3859. >                 mov     [ebp].Buffer[0],edi
  3860. >                 add     ecx,ebx
  3861. >                 xor     edx,edx         { edx = Flag (0:Char&Attr,1:Char only) }
  3862. >                 mov     edi,[ebp].Self
  3863. >                 test    eax,eax
  3864. >                 jl      @@3
  3865. >                 cmp     eax,[edi].TView.Size.Y
  3866. >                 jge     @@3
  3867. >                 test    ebx,ebx
  3868. >                 jge     @@1
  3869. >                 xor     ebx,ebx
  3870. >               @@1:
  3871. >                 cmp     ecx,[edi].TView.Size.X
  3872. >                 jle     @@2
  3873. >                 mov     ecx,[edi].TView.Size.X
  3874. >               @@2:
  3875. >                 cmp     ebx,ecx
  3876. >                 jl      @@10
  3877. >               @@3:
  3878. >                 ret
  3879. > 
  3880. >               @@10:
  3881. >                 test    [edi].TView.State,sfVisible
  3882. >                 jz      @@3
  3883. >                 cmp     [edi].TView.Owner,0
  3884. >                 jz      @@3
  3885. >                 mov     [ebp].Target,edi
  3886. >                 add     eax,[edi].TView.Origin.Y
  3887. >                 mov     esi,[edi].TView.Origin.X
  3888. >                 add     ebx,esi
  3889. >                 add     ecx,esi
  3890. >                 add     [ebp].BufOfs,esi
  3891. >                 mov     edi,[edi].TView.Owner
  3892. >                 cmp     eax,[edi].TGroup.Clip.A.Y
  3893. >                 jl      @@3
  3894. >                 cmp     eax,[edi].TGroup.Clip.B.Y
  3895. >                 jge     @@3
  3896. >                 cmp     ebx,[edi].TGroup.Clip.A.X
  3897. >                 jge     @@11
  3898. >                 mov     ebx,[edi].TGroup.Clip.A.X
  3899. >               @@11:
  3900. >                 cmp     ecx,[edi].TGroup.Clip.B.X
  3901. >                 jle     @@12
  3902. >                 mov     ecx,[edi].TGroup.Clip.B.X
  3903. >               @@12:
  3904. >                 cmp     ebx,ecx
  3905. >                 jge     @@3
  3906. >                 mov     edi,[edi].TGroup.Last
  3907. >               @@20:
  3908. >                 mov     edi,[edi].TView.Next
  3909. >                 cmp     edi,[ebp].Target
  3910. >                 je      @@40
  3911. >                 test    [edi].TView.State,sfVisible
  3912. >                 jz      @@20
  3913. >                 mov     esi,[edi].TView.Origin.Y
  3914. >                 cmp     eax,esi
  3915. >                 jl      @@20
  3916. >                 add     esi,[edi].TView.Size.Y
  3917. >                 cmp     eax,esi
  3918. >                 jl      @@23
  3919. >                 test    [edi].TView.State,sfShadow
  3920. >                 jz      @@20
  3921. >                 add     esi,ShadowSize.Y
  3922. >                 cmp     eax,esi
  3923. >                 jge     @@20
  3924. >                 mov     esi,[edi].TView.Origin.X
  3925. >                 add     esi,ShadowSize.X
  3926. >                 cmp     ebx,esi
  3927. >                 jge     @@22
  3928. >                 cmp     ecx,esi
  3929. >                 jle     @@20
  3930. >                 Call    @@30
  3931. >               @@22:
  3932. >                 add     esi,[edi].TView.Size.X
  3933. >                 jmp     @@26
  3934. >               @@23:
  3935. >                 mov     esi,[edi].TView.Origin.X
  3936. >                 cmp     ebx,esi
  3937. >                 jge     @@24
  3938. >                 cmp     ecx,esi
  3939. >                 jle     @@20
  3940. >                 Call    @@30
  3941. >               @@24:
  3942. >                 add     esi,[edi].TView.Size.X
  3943. >                 cmp     ebx,esi
  3944. >                 jge     @@25
  3945. >                 cmp     ecx,esi
  3946. >                 jle     @@31
  3947. >                 mov     ebx,esi
  3948. >               @@25:
  3949. >                 test    [edi].TView.State,sfShadow
  3950. >                 je      @@20
  3951. >                 push    esi
  3952. >                 mov     esi,[edi].TView.Origin.Y
  3953. >                 add     esi,ShadowSize.Y
  3954. >                 cmp     eax,esi
  3955. >                 pop     esi
  3956. >                 jl      @@27
  3957. >                 add     esi,ShadowSize.X
  3958. >               @@26:
  3959. >                 cmp     ebx,esi
  3960. >                 jge     @@27
  3961. >                 inc     edx
  3962. >                 cmp     ecx,esi
  3963. >                 jle     @@27
  3964. >                 Call    @@30
  3965. >                 dec     edx
  3966. >               @@27:
  3967. >                 jmp     @@20
  3968. > 
  3969. >               @@30:
  3970. >                 push    DWord Ptr [ebp].Target
  3971. >                 push    DWord Ptr [ebp].BufOfs
  3972. >                 push    edi
  3973. >                 push    esi
  3974. >                 push    edx
  3975. >                 push    ecx
  3976. >                 push    eax
  3977. >                 mov     ecx,esi
  3978. >                 Call    @@20
  3979. >                 pop     eax
  3980. >                 pop     ecx
  3981. >                 pop     edx
  3982. >                 pop     esi
  3983. >                 pop     edi
  3984. >                 pop     DWord Ptr [ebp].BufOfs
  3985. >                 pop     DWord Ptr [ebp].Target
  3986. >                 mov     ebx,esi
  3987. >               @@31:
  3988. >                 ret
  3989. > 
  3990. >               @@40:
  3991. >                 mov     edi,[edi].TView.Owner
  3992. >                 mov     esi,[edi].TGroup.Buffer
  3993. >                 test    esi,esi
  3994. >                 jz      @@44
  3995. >                 cmp     esi,ScreenBuffer
  3996. >                 jne     @@43
  3997. >                 Call    UpdateMouseWhere
  3998. >                 cmp     eax,MouseWhere.Y
  3999. >                 jne     @@43
  4000. >                 cmp     ebx,MouseWhere.X
  4001. >                 ja      @@43
  4002. >                 cmp     ecx,MouseWhere.X
  4003. >                 jbe     @@43
  4004. >                 Call    HideMouse
  4005. >                 Call    @@50
  4006. >                 Call    ShowMouse
  4007. >                 jmp     @@44
  4008. >               @@43:
  4009. >                 Call    @@50
  4010. >               @@44:
  4011. >                 cmp     [edi].TGroup.LockFlag,0
  4012. >                 jne     @@31
  4013. >                 jmp     @@10
  4014. > 
  4015. > { Copy to Buffer }
  4016. > 
  4017. >               @@50:
  4018. >                 push    edi
  4019. >                 push    ecx
  4020. >                 push    ebx
  4021. >                 push    eax
  4022. >                 mul     [edi].TView.Size.X.Byte[0]
  4023. >                 add     eax,ebx
  4024. >                 lea     edi,[esi+eax*2]
  4025. >                 xor     al,al
  4026. >                 mov     ah,ShadowAttr
  4027. >                 sub     ecx,ebx
  4028. >                 xchg    esi,ebx
  4029. >                 sub     esi,[ebp].BufOfs
  4030. >                 shl     esi,1
  4031. >                 add     esi,[ebp].Buffer
  4032. >                 push    edi
  4033. >                 push    ecx
  4034. >                 cld
  4035. >                 test    edx,edx
  4036. >                 jnz     @@52
  4037. >                 shr     ecx,1
  4038. >                 rep     movsd
  4039. >                 adc     ecx,ecx
  4040. >                 rep     movsw
  4041. >                 jmp     @@53
  4042. >               @@52:
  4043. >                 lodsb
  4044. >                 inc     esi
  4045. >                 stosw
  4046. >                 loop    @@52
  4047. >               @@53:
  4048. >                 pop     ecx
  4049. >                 pop     edi
  4050. >                 mov     eax,ScreenBuffer
  4051. >                 cmp     ebx,eax
  4052. >                 jne     @@54
  4053. >                 shl     ecx,1
  4054. >                 sub     edi,eax
  4055. >                 push    edi                     { [1]:DWord = Offset }
  4056. >                 push    ecx                     { [2]:DWord = Length }
  4057. >                 push    0                       { [3]:DWord = Handle }
  4058. >                 Call    Vio32ShowBuf
  4059. >               @@54:
  4060. >                 pop     eax
  4061. >                 pop     ebx
  4062. >                 pop     ecx
  4063. >                 pop     edi
  4064. >                 ret
  4065. 1222c1220
  4066. < procedure TView.GetBounds(var Bounds: TRect); assembler;
  4067. > procedure TView.GetBounds(var Bounds: TRect); assembler; {$USES esi,edi}{$FRAME-}
  4068. 1224,1241c1222,1237
  4069. <         PUSH    DS
  4070. >                 mov     esi,Self
  4071. >                 add     esi,OFFSET TView.Origin
  4072. >                 mov     edi,Bounds
  4073. >                 cld
  4074. >                 lodsd                           {Origin.X}
  4075. >                 mov     ecx,eax
  4076. >                 stosd
  4077. >                 lodsd                           {Origin.Y}
  4078. >                 mov     edx,eax
  4079. >                 stosd
  4080. >                 lodsd                           {Size.X}
  4081. >                 add     eax,ecx
  4082. >                 stosd
  4083. >                 lodsd                           {Size.Y}
  4084. >                 add     eax,edx
  4085. >                 stosd
  4086. 1249c1245
  4087. < function TView.Exposed: Boolean; assembler;
  4088. > function TView.Exposed: Boolean; assembler; {$USES ebx,esi,edi} {$FRAME+}
  4089. 1253,1353c1249,1354
  4090. <         LES     DI,Self
  4091. >                 mov     edi,Self
  4092. >                 test    [edi].TView.State,sfExposed
  4093. >                 je      @@2
  4094. >                 xor     eax,eax
  4095. >                 cmp     eax,[edi].TView.Size.X
  4096. >                 jge     @@2
  4097. >                 cmp     eax,[edi].TView.Size.Y
  4098. >                 jge     @@2
  4099. >               @@1:
  4100. >                 xor     ebx,ebx
  4101. >                 mov     ecx,[edi].TView.Size.X
  4102. >                 push    eax
  4103. >                 Call    @@11
  4104. >                 pop     eax
  4105. >                 jnc     @@3
  4106. >                 mov     edi,Self
  4107. >                 inc     eax
  4108. >                 cmp     eax,[edi].TView.Size.Y
  4109. >                 jl      @@1
  4110. >               @@2:
  4111. >                 mov     al,0
  4112. >                 jmp     @@30
  4113. >               @@3:
  4114. >                 mov     al,1
  4115. >                 jmp     @@30
  4116. > 
  4117. >               @@8:
  4118. >                 stc
  4119. >               @@9:
  4120. >                 ret
  4121. > 
  4122. >               @@10:
  4123. >                 mov     edi,[edi].TView.Owner
  4124. >                 cmp     [edi].TGroup.Buffer,0
  4125. >                 jne     @@9
  4126. >               @@11:
  4127. >                 mov     Target,edi
  4128. >                 add     eax,[edi].TView.Origin.Y
  4129. >                 mov     esi,[edi].TView.Origin.X
  4130. >                 add     ebx,esi
  4131. >                 add     ecx,esi
  4132. >                 mov     edi,[edi].TView.Owner
  4133. >                 test    edi,edi
  4134. >                 jz      @@9
  4135. >                 cmp     eax,[edi].TGroup.Clip.A.Y
  4136. >                 jl      @@8
  4137. >                 cmp     eax,[edi].TGroup.Clip.B.Y
  4138. >                 jge     @@8
  4139. >                 cmp     ebx,[edi].TGroup.Clip.A.X
  4140. >                 jge     @@12
  4141. >                 mov     ebx,[edi].TGroup.Clip.A.X
  4142. >               @@12:
  4143. >                 cmp     ecx,[edi].TGroup.Clip.B.X
  4144. >                 jle     @@13
  4145. >                 mov     ecx,[edi].TGroup.Clip.B.X
  4146. >               @@13:
  4147. >                 cmp     ebx,ecx
  4148. >                 jge     @@8
  4149. >                 mov     edi,[edi].TGroup.Last
  4150. >               @@20:
  4151. >                 mov     edi,[edi].TView.Next
  4152. >                 cmp     edi,Target
  4153. >                 je      @@10
  4154. >                 test    [edi].TView.State,sfVisible
  4155. >                 jz      @@20
  4156. >                 mov     esi,[edi].TView.Origin.Y
  4157. >                 cmp     eax,esi
  4158. >                 jl      @@20
  4159. >                 add     esi,[edi].TView.Size.Y
  4160. >                 cmp     eax,esi
  4161. >                 jge     @@20
  4162. >                 mov     esi,[edi].TView.Origin.X
  4163. >                 cmp     ebx,esi
  4164. >                 jl      @@22
  4165. >                 add     esi,[edi].TView.Size.X
  4166. >                 cmp     ebx,esi
  4167. >                 jge     @@20
  4168. >                 mov     ebx,esi
  4169. >                 cmp     ebx,ecx
  4170. >                 jl      @@20
  4171. >                 stc
  4172. >                 ret
  4173. >               @@22:
  4174. >                 cmp     ecx,esi
  4175. >                 jle     @@20
  4176. >                 add     esi,[edi].TView.Size.X
  4177. >                 cmp     ecx,esi
  4178. >                 jg      @@23
  4179. >                 mov     ecx,[edi].TView.Origin.X
  4180. >                 jmp     @@20
  4181. >               @@23:
  4182. >                 push    Target
  4183. >                 push    edi
  4184. >                 push    esi
  4185. >                 push    ecx
  4186. >                 push    eax
  4187. >                 mov     ecx,[edi].TView.Origin.X
  4188. >                 Call    @@20
  4189. >                 pop     eax
  4190. >                 pop     ecx
  4191. >                 pop     ebx
  4192. >                 pop     edi
  4193. >                 pop     Target
  4194. >                 jc      @@20
  4195. >                 retn
  4196. >               @@30:
  4197. 1385c1386
  4198. < function TView.GetColor(Color: Word): Word; assembler;
  4199. > function TView.GetColor(Color: Word): Word; assembler; {$USES None} {$FRAME+}
  4200. 1387,1388c1388,1389
  4201. <         MOV     AX,Color
  4202. >                 mov     eax,Color
  4203. >                 Call    MapCPair
  4204. 1405c1406
  4205. < procedure TView.GetExtent(var Extent: TRect); assembler;
  4206. > procedure TView.GetExtent(var Extent: TRect); assembler; {$USES esi,edi}{$FRAME-}
  4207. 1407,1417c1408,1416
  4208. <         PUSH    DS
  4209. >                 mov     esi,Self
  4210. >                 add     esi,OFFSET TView.Size
  4211. >                 mov     edi,Extent
  4212. >                 cld
  4213. >                 xor     eax,eax
  4214. >                 stosd
  4215. >                 stosd
  4216. >                 movsd
  4217. >                 movsd
  4218. 1519a1519,1520
  4219. > {$USES None} {$FRAME-}
  4220. > 
  4221. 1522,1537c1523,1536
  4222. <         LES     DI,Self
  4223. >                 mov     ecx,Self
  4224. >                 xor     eax,eax
  4225. >                 mov     edx,eax
  4226. >               @@1:
  4227. >                 add     eax,[ecx].TView.Origin.X
  4228. >                 add     edx,[ecx].TView.Origin.Y
  4229. >                 mov     ecx,[ecx].TView.Owner
  4230. >                 test    ecx,ecx
  4231. >                 jnz     @@1
  4232. >                 add     eax,Source.X
  4233. >                 add     edx,Source.Y
  4234. >                 mov     ecx,Dest
  4235. >                 mov     [ecx].TPoint.X,eax
  4236. >                 mov     [ecx].TPoint.Y,edx
  4237. 1539a1539,1540
  4238. > {$USES None} {$FRAME-}
  4239. > 
  4240. 1542,1559c1543,1558
  4241. <         LES     DI,Self
  4242. >                 mov     ecx,Self
  4243. >                 xor     eax,eax
  4244. >                 mov     edx,eax
  4245. >               @@1:
  4246. >                 add     eax,[ecx].TView.Origin.X
  4247. >                 add     edx,[ecx].TView.Origin.Y
  4248. >                 mov     ecx,[ecx].TView.Owner
  4249. >                 test    ecx,ecx
  4250. >                 jnz     @@1
  4251. >                 neg     eax
  4252. >                 neg     edx
  4253. >                 add     eax,Source.X
  4254. >                 add     edx,Source.Y
  4255. >                 mov     ecx,Dest
  4256. >                 mov     [ecx].TPoint.X,eax
  4257. >                 mov     [ecx].TPoint.Y,edx
  4258. 1595c1594
  4259. < function TView.Prev: PView; assembler;
  4260. > function TView.Prev: PView; assembler; {$USES None} {$FRAME-}
  4261. 1597,1607c1596,1602
  4262. <         LES     DI,Self
  4263. >                 mov     edx,Self
  4264. >                 mov     ecx,edx
  4265. >               @@1:
  4266. >                 mov     eax,edx
  4267. >                 mov     edx,[edx].TView.Next
  4268. >                 cmp     edx,ecx
  4269. >                 jne     @@1
  4270. 1635c1630
  4271. <       
  4272. > 
  4273. 1665c1660,1662
  4274. < procedure TView.ResetCursor; assembler;
  4275. > procedure TView.ResetCursor; assembler; {$USES esi,edi} {$FRAME-}
  4276. > const
  4277. >   CurData: VioCursorInfo = (yStart: 0; cEnd: 0; cx: 1; attr: 0);
  4278. 1667,1730c1664,1738
  4279. <         LES     DI,Self
  4280. >                 mov     edi,Self
  4281. >                 mov     eax,[edi].TView.State
  4282. >                 not     eax
  4283. >                 test    eax,sfVisible+sfCursorVis+sfFocused
  4284. >                 jne     @@Hide
  4285. >                 mov     eax,[edi].TView.Cursor.Y
  4286. >                 mov     edx,[edi].TView.Cursor.X
  4287. >               @@1:
  4288. >                 test    eax,eax
  4289. >                 jl      @@Hide
  4290. >                 cmp     eax,[edi].TView.Size.Y
  4291. >                 jge     @@Hide
  4292. >                 test    edx,edx
  4293. >                 jl      @@Hide
  4294. >                 cmp     edx,[edi].TView.Size.X
  4295. >                 jge     @@Hide
  4296. >                 add     eax,[edi].TView.Origin.Y
  4297. >                 add     edx,[edi].TView.Origin.X
  4298. >                 mov     ecx,edi
  4299. >                 mov     edi,[edi].TView.Owner
  4300. >                 test    edi,edi
  4301. >                 jz      @@Show
  4302. >                 test    [edi].TView.State,sfVisible
  4303. >                 je      @@Hide
  4304. >                 mov     edi,[edi].TGroup.Last
  4305. >               @@2:
  4306. >                 mov     edi,[edi].TView.Next
  4307. >                 cmp     ecx,edi
  4308. >                 jne     @@3
  4309. >                 mov     edi,[edi].TView.Owner
  4310. >                 jmp     @@1
  4311. >               @@3:
  4312. >                 test    [edi].TView.State,sfVisible
  4313. >                 je      @@2
  4314. >                 mov     esi,[edi].TView.Origin.Y
  4315. >                 cmp     eax,esi
  4316. >                 jl      @@2
  4317. >                 add     esi,[edi].TView.Size.Y
  4318. >                 cmp     eax,esi
  4319. >                 jge     @@2
  4320. >                 mov     esi,[edi].TView.Origin.X
  4321. >                 cmp     edx,esi
  4322. >                 jl      @@2
  4323. >                 add     esi,[edi].TView.Size.X
  4324. >                 cmp     edx,esi
  4325. >                 jge     @@2
  4326. >               @@Hide:
  4327. >                 xor     eax,eax
  4328. >                 dec     eax                     { Color = -1: Invisible }
  4329. >                 xor     ecx,ecx
  4330. >                 jmp     @@4
  4331. > { Set Cursor Position }
  4332. >               @@Show:
  4333. >                 push    eax                     { [1]:DWord = Row       }
  4334. >                 push    edx                     { [2]:DWord = Column    }
  4335. >                 push    0                       { [3]:Word = Handle     }
  4336. >                 Call    Vio32SetCurPos
  4337. > { Set Cursor Shape }
  4338. >                 xor     eax,eax                 { Color: Visible    }
  4339. >                 mov     cx,CursorLines
  4340. >                 mov     edi,Self
  4341. >                 test    [edi].TView.State,sfCursorIns
  4342. >                 jz      @@4
  4343. >                 mov     ch,1
  4344. >                 test    cl,cl
  4345. >                 jne     @@4
  4346. >                 mov     cl,7
  4347. >               @@4:
  4348. >                 lea     edx,CurData
  4349. >                 mov     [edx].VioCursorInfo.attr,ax
  4350. >                 mov     [edx].VioCursorInfo.yStart.Byte,ch
  4351. >                 mov     [edx].VioCursorInfo.cEnd.Byte,cl
  4352. >                 push    edx                     { [1]:Pointer= @CurData }
  4353. >                 push    0                       { [2]:DWord  = Handle   }
  4354. >                 Call    Vio32SetCurType
  4355. 1740c1748
  4356. < procedure TView.SetBounds(var Bounds: TRect); assembler;
  4357. > procedure TView.SetBounds(var Bounds: TRect); assembler; {$USES None} {$FRAME-}
  4358. 1742,1755c1750,1761
  4359. <         PUSH    DS
  4360. >                 mov     edx,Self
  4361. >                 mov     ecx,Bounds
  4362. >                 mov     eax,[ecx].TRect.A.X
  4363. >                 mov     [edx].Origin.X,eax
  4364. >                 mov     eax,[ecx].TRect.A.Y
  4365. >                 mov     [edx].Origin.Y,eax
  4366. >                 mov     eax,[ecx].TRect.B.X
  4367. >                 sub     eax,[ecx].TRect.A.X
  4368. >                 mov     [edx].Size.X,eax
  4369. >                 mov     eax,[ecx].TRect.B.Y
  4370. >                 sub     eax,[ecx].TRect.A.Y
  4371. >                 mov     [edx].Size.Y,eax
  4372. 1824,1827c1830,1837
  4373. <   Longint(Min) := 0;
  4374. >   Min.X := 0;
  4375. >   Min.Y := 0;
  4376. >   if Owner <> nil then Max := Owner^.Size
  4377. >  else
  4378. >   begin
  4379. >     Max.X := MaxLongint;
  4380. >     Max.Y := MaxLongint;
  4381. >   end;
  4382. 1860a1871,1872
  4383. > {$USES ebx,esi,edi} {$FRAME+}
  4384. > 
  4385. 1867,1880c1879,1893
  4386. <         CMP     H,0
  4387. >                 cmp     H,0
  4388. >                 jle     @@2
  4389. >               @@1:
  4390. >                 mov     eax,Y
  4391. >                 mov     ebx,X
  4392. >                 mov     ecx,W
  4393. >                 mov     edi,Buf
  4394. >                 Call    WriteView
  4395. >                 mov     eax,W
  4396. >                 shl     eax,1
  4397. >                 add     Buf,eax
  4398. >                 inc     Y
  4399. >                 dec     H
  4400. >                 jnz     @@1
  4401. >               @@2:
  4402. 1882a1896,1897
  4403. > {$USES ebx,esi,edi} {$FRAME+}
  4404. > 
  4405. 1890,1914c1905,1937
  4406. <         MOV     AL,Color
  4407. >                 mov     al,Color
  4408. >                 Call    MapColor
  4409. >                 mov     ah,al
  4410. >                 mov     al,C
  4411. >                 mov     ecx,Count
  4412. >                 test    ecx,ecx
  4413. >                 jle     @@2
  4414. >                 cmp     ecx,256
  4415. >                 jle     @@1
  4416. >                 mov     ecx,256
  4417. >               @@1:
  4418. >                 lea     ebx,[ecx*2+2]
  4419. >                 and     ebx,NOT 11b
  4420. >                 sub     esp,ebx
  4421. >                 mov     edi,esp
  4422. >                 mov     edx,eax
  4423. >                 shl     eax,16
  4424. >                 mov     ax,dx
  4425. >                 mov     edx,ecx
  4426. >                 cld
  4427. >                 shr     ecx,1
  4428. >                 rep     stosd
  4429. >                 adc     ecx,ecx
  4430. >                 rep     stosw
  4431. >                 mov     ecx,edx
  4432. >                 mov     edi,esp
  4433. >                 mov     eax,Y
  4434. >                 push    ebx
  4435. >                 mov     ebx,X
  4436. >                 Call    WriteView
  4437. >                 pop     eax
  4438. >                 add     esp,eax
  4439. >               @@2:
  4440. 1916a1940,1941
  4441. > {$USES ebx,esi,edi} {$FRAME+}
  4442. > 
  4443. 1923,1933c1948,1959
  4444. <         CMP     H,0
  4445. >                 cmp     H,0
  4446. >                 jle     @@2
  4447. >               @@1:
  4448. >                 mov     eax,Y
  4449. >                 mov     ebx,X
  4450. >                 mov     ecx,W
  4451. >                 mov     edi,Buf
  4452. >                 Call    WriteView
  4453. >                 inc     Y
  4454. >                 dec     H
  4455. >                 jne     @@1
  4456. >               @@2:
  4457. 1935a1962,1963
  4458. > {$USES ebx,esi,edi} {$FRAME+}
  4459. > 
  4460. 1942,1970c1970,1996
  4461. <         MOV     AL,Color
  4462. >                 mov     al,Color
  4463. >                 Call    MapColor
  4464. >                 mov     ah,al
  4465. >                 mov     esi,Str
  4466. >                 xor     ecx,ecx
  4467. >                 cld
  4468. >                 lodsb
  4469. >                 mov     cl,al
  4470. >                 jecxz   @@2
  4471. >                 lea     ebx,[ecx*2+2]
  4472. >                 and     ebx,NOT 11b
  4473. >                 sub     esp,ebx
  4474. >                 mov     edi,esp
  4475. >                 mov     edx,ecx
  4476. >               @@1:
  4477. >                 lodsb
  4478. >                 stosw
  4479. >                 loop    @@1
  4480. >                 mov     ecx,edx
  4481. >                 mov     edi,esp
  4482. >                 mov     eax,Y
  4483. >                 push    ebx
  4484. >                 mov     ebx,X
  4485. >                 Call    WriteView
  4486. >                 pop     eax
  4487. >                 add     esp,eax
  4488. >               @@2:
  4489. 1983c2009
  4490. <   Color: Byte); assembler;
  4491. >   Color: Byte); assembler; {$USES ebx,esi,edi} {$FRAME-}
  4492. 1993,2065c2019,2093
  4493. <         LES     BX,Self
  4494. >                 mov     ebx,Self
  4495. >                 mov     edx,[ebx].TFrame.Size.X
  4496. >                 lea     ecx,[edx-2]
  4497. >                 mov     esi,OFFSET InitFrame
  4498. >                 add     esi,N
  4499. >                 lea     edi,FrameMask
  4500. >                 cld
  4501. >                 movsb
  4502. >                 lodsb
  4503. >                 rep     stosb
  4504. >                 movsb
  4505. >                 mov     ebx,[ebx].TFrame.Owner
  4506. >                 mov     ebx,[ebx].TGroup.Last
  4507. >                 dec     edx
  4508. >               @@1:
  4509. >                 mov     ebx,[ebx].TView.Next
  4510. >                 cmp     ebx,Self
  4511. >                 je      @@10
  4512. >               @@2:
  4513. >                 test    [ebx].TView.Options,ofFramed
  4514. >                 je      @@1
  4515. >                 test    [ebx].TView.State,sfVisible
  4516. >                 je      @@1
  4517. >                 mov     eax,Y
  4518. >                 sub     eax,[ebx].TView.Origin.Y
  4519. >                 jl      @@3
  4520. >                 cmp     eax,[ebx].TView.Size.Y
  4521. >                 jg      @@1
  4522. >                 mov     ax,0005h
  4523. >                 jl      @@4
  4524. >                 mov     ax,0A03h
  4525. >                 jmp     @@4
  4526. >               @@3:
  4527. >                 inc     eax
  4528. >                 jne     @@1
  4529. >                 mov     ax,0A06h
  4530. >               @@4:
  4531. >                 mov     esi,[ebx].TView.Origin.X
  4532. >                 mov     edi,[ebx].TView.Size.X
  4533. >                 add     edi,esi
  4534. >                 cmp     esi,1
  4535. >                 jg      @@5
  4536. >                 xor     esi,esi
  4537. >                 inc     esi
  4538. >               @@5:
  4539. >                 cmp     edi,edx
  4540. >                 jl      @@6
  4541. >                 mov     edi,edx
  4542. >               @@6:
  4543. >                 cmp     esi,edi
  4544. >                 jge     @@1
  4545. >                 or      Byte Ptr FrameMask[esi-1],AL
  4546. >                 xor     al,ah
  4547. >                 or      Byte Ptr FrameMask[edi],AL
  4548. >                 test    ah,ah
  4549. >                 jz      @@1
  4550. >                 mov     ecx,edi
  4551. >                 sub     ecx,esi
  4552. >               @@8:
  4553. >                 or      Byte Ptr FrameMask[esi],ah
  4554. >                 inc     esi
  4555. >                 loop    @@8
  4556. >                 jmp     @@1
  4557. >               @@10:
  4558. >                 inc     edx
  4559. >                 mov     ah,Color
  4560. >                 mov     ebx,OFFSET FrameChars
  4561. >                 mov     ecx,edx
  4562. >                 lea     esi,FrameMask
  4563. >                 mov     edi,FrameBuf
  4564. >               @@11:
  4565. >                 lodsb
  4566. >                 xlat
  4567. >                 stosw
  4568. >                 loop    @@11
  4569. 2130c2158
  4570. <       else if Longint(Owner^.Size) = Longint(Max) then
  4571. >       else if (Owner^.Size.X = Max.X) and (Owner^.Size.Y = Max.Y) then
  4572. 2306c2334
  4573. <     GetPos := LongDiv(LongMul(Value - Min, GetSize - 3) + R shr 1, R) + 1;
  4574. >     GetPos := ((Value - Min) * (GetSize - 3) + R shr 1) div R + 1;
  4575. 2388c2416
  4576. <             SetValue(LongDiv(LongMul(P - 1, Max - Min) + S shr 1, S) + Min);
  4577. >             SetValue(((P - 1) * (Max - Min) + S shr 1) div S + Min);
  4578. 2900c2928
  4579. <   EventMask := $FFFF;
  4580. >   EventMask := $FFFFFFFF;
  4581. 2909a2938
  4582. >   SaveESP: Word;
  4583. 2917,2929c2946,2956
  4584. <   asm
  4585. >   asm         {$SAVES ebx,edx,esi}
  4586. >                 mov     SaveESP,esp
  4587. >                 mov     ecx,Count
  4588. >                 shl     ecx,2
  4589. >                 sub     esp,ecx
  4590. >                 mov     FixupList,esp
  4591. >                 mov     edi,esp
  4592. >                 xor     eax,eax
  4593. >                 shr     ecx,2
  4594. >                 cld
  4595. >                 rep     stosd
  4596. 2952a2980
  4597. >   asm   mov esp,SaveESP   end;
  4598. 2977c3005
  4599. < function TGroup.At(Index: Integer): PView; assembler;
  4600. > function TGroup.At(Index: Integer): PView; assembler; {$USES None} {$FRAME-}
  4601. 2979,2985c3007,3012
  4602. <         LES     DI,Self
  4603. >                 mov     eax,Self
  4604. >                 mov     eax,[eax].TGroup.Last
  4605. >                 mov     ecx,Index
  4606. >               @@1:
  4607. >                 mov     eax,[eax].TView.Next
  4608. >                 loop    @@1
  4609. 2990c3017
  4610. <   procedure DoAwaken(P: PView); far;
  4611. >   procedure DoAwaken(P: PView);
  4612. 3003c3030
  4613. < procedure DoCalcChange(P: PView); far;
  4614. > procedure DoCalcChange(P: PView);
  4615. 3014c3041
  4616. <   if Longint(D) = 0 then
  4617. >   if (D.X or D.Y) = 0 then
  4618. 3034c3061
  4619. < procedure AddSubviewDataSize(P: PView); far;
  4620. > procedure AddSubviewDataSize(P: PView);
  4621. 3152c3179
  4622. < function Matches(P: PView): Boolean; far;
  4623. > function Matches(P: PView): Boolean;
  4624. 3162c3189
  4625. < function TGroup.FirstThat(P: Pointer): PView; assembler;
  4626. > function TGroup.FirstThat(P: Pointer): PView; assembler; {$USES None} {$FRAME-}
  4627. 3166,3193c3193,3210
  4628. <         LES     DI,Self
  4629. >                 mov     eax,Self
  4630. >                 mov     eax,[eax].TGroup.Last
  4631. >                 test    eax,eax
  4632. >                 jz      @@2
  4633. >                 mov     ALast,eax
  4634. >               @@1:
  4635. >                 mov     ecx,P
  4636. >                 mov     eax,[eax].TView.Next
  4637. >                 push    eax
  4638. >                 push    eax                     {[1]:Pointer = PView }
  4639. >                 Call    ecx
  4640. >                 test    al,al
  4641. >                 pop     eax
  4642. >                 jnz     @@2
  4643. >                 cmp     eax,ALast
  4644. >                 jne     @@1
  4645. >                 xor     eax,eax
  4646. >               @@2:
  4647. 3221c3238
  4648. < procedure TGroup.ForEach(P: Pointer); assembler;
  4649. > procedure TGroup.ForEach(P: Pointer); assembler; {$USES ebx} {$FRAME-}
  4650. 3225,3249c3242,3259
  4651. <         LES     DI,Self
  4652. >                 mov     ecx,Self
  4653. >                 mov     ecx,[ecx].TGroup.Last
  4654. >                 jecxz   @@4
  4655. >                 mov     ebx,P
  4656. >                 mov     ALast,ecx
  4657. >                 mov     ecx,[ecx].TView.Next
  4658. >               @@1:
  4659. >                 cmp     ecx,ALast
  4660. >                 je      @@3
  4661. >                 push    [ecx].TView.Next
  4662. >                 push    ecx
  4663. >                 Call    ebx
  4664. >                 pop     ecx
  4665. >                 jmp     @@1
  4666. >               @@3:
  4667. >                 push    ecx
  4668. >                 Call    ebx
  4669. >               @@4:
  4670. 3258,3259c3268
  4671. < { Allocate a group buffer if the group is exposed, buffered, and
  4672. > { Allocate a group buffer if the group is exposed and buffered }
  4673. 3261c3270
  4674. < procedure TGroup.GetBuffer; assembler;
  4675. > procedure TGroup.GetBuffer; assembler; {$USES None} {$FRAME-}
  4676. 3263,3282c3272,3289
  4677. <         LES     DI,Self
  4678. >                 mov     ecx,Self
  4679. >                 test    [ecx].State,sfExposed
  4680. >                 jz      @@1
  4681. >                 test    [ecx].Options,ofBuffered
  4682. >                 jz      @@1
  4683. >                 cmp     [ecx].Buffer,0
  4684. >                 jnz     @@1
  4685. >                 mov     eax,[ecx].TView.Size.X
  4686. >                 mul     [ecx].TView.Size.Y
  4687. >                 jo      @@1
  4688. >                 shl     eax,1
  4689. >                 jc      @@1
  4690. >                 js      @@1
  4691. >                 lea     ecx,[ecx].TView.Buffer
  4692. >                 push    ecx             { [1]:Pointer = @ of the buffer@ }
  4693. >                 push    eax             { [2]:Pointer = Buffer Size      }
  4694. >                 Call    NewCache
  4695. >               @@1:
  4696. 3327c3334
  4697. < procedure DoHandleEvent(P: PView); far;
  4698. > procedure DoHandleEvent(P: PView);
  4699. 3338c3345
  4700. < function ContainsMouse(P: PView): Boolean; far;
  4701. > function ContainsMouse(P: PView): Boolean;
  4702. 3363c3370
  4703. < function TGroup.IndexOf(P: PView): Integer; assembler;
  4704. > function TGroup.IndexOf(P: PView): Integer; assembler; {$USES None} {$FRAME-}
  4705. 3365,3385c3372,3386
  4706. <         LES     DI,Self
  4707. >                 mov     ecx,Self
  4708. >                 mov     ecx,[ecx].TGroup.Last
  4709. >                 jecxz   @@2
  4710. >                 mov     edx,ecx
  4711. >                 xor     eax,eax
  4712. >               @@1:
  4713. >                 inc     eax
  4714. >                 mov     ecx,[ecx].TView.Next
  4715. >                 cmp     ecx,P
  4716. >                 je      @@3
  4717. >                 cmp     ecx,edx
  4718. >                 jne     @@1
  4719. >               @@2:
  4720. >                 xor     eax,eax
  4721. >               @@3:
  4722. 3451c3452
  4723. < procedure TGroup.RemoveView(P: PView); assembler;
  4724. > procedure TGroup.RemoveView(P: PView); assembler; {$USES edi} {$FRAME+}
  4725. 3453,3498c3454,3479
  4726. <         PUSH    DS
  4727. >                 mov     edx,Self
  4728. >                 mov     edi,P
  4729. >                 mov     edx,[edx].TGroup.Last
  4730. >                 test    edx,edx
  4731. >                 jz      @@4
  4732. >                 mov     eax,edx
  4733. >               @@1:
  4734. >                 mov     ecx,[edx].TView.Next
  4735. >                 cmp     ecx,edi
  4736. >                 je      @@2
  4737. >                 cmp     ecx,eax
  4738. >                 je      @@4
  4739. >                 mov     edx,ecx
  4740. >                 jmp     @@1
  4741. >               @@2:
  4742. >                 mov     ecx,[edi].TView.Next
  4743. >                 mov     [edx].TView.Next,ecx
  4744. >                 cmp     eax,edi
  4745. >                 jne     @@4
  4746. >                 cmp     ecx,edi
  4747. >                 jne     @@3
  4748. >                 xor     edx,edx
  4749. >               @@3:
  4750. >                 mov     edi,Self
  4751. >                 mov     [edi].TView.Last,edx
  4752. >               @@4:
  4753. 3566c3547
  4754. < procedure DoSetState(P: PView); far;
  4755. > procedure DoSetState(P: PView);
  4756. 3571c3552
  4757. < procedure DoExpose(P: PView); far;
  4758. > procedure DoExpose(P: PView);
  4759. 3600c3581
  4760. < procedure DoPut(P: PView); far;
  4761. > procedure DoPut(P: PView);
  4762. 3627c3608
  4763. < function IsInvalid(P: PView): Boolean; far;
  4764. > function IsInvalid(P: PView): Boolean;
  4765. 3820c3801
  4766. <   if Longint(Size) <> Longint(Max) then
  4767. >   if (Size.X <> Max.X) or (Size.Y <> Max.Y) then
  4768. 3823c3804,3805
  4769. <     Longint(R.A) := 0;
  4770. >     R.A.X := 0;
  4771. >     R.A.Y := 0;
  4772.