home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / mysys / debug / array.asm
Assembly Source File  |  2000-05-30  |  22KB  |  964 lines
  1.     TITLE    M:\MYSQL-3.23\mysys\array.c
  2.     .386P
  3. include listing.inc
  4. if @Version gt 510
  5. .model FLAT
  6. else
  7. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  8. _TEXT    ENDS
  9. _DATA    SEGMENT DWORD USE32 PUBLIC 'DATA'
  10. _DATA    ENDS
  11. CONST    SEGMENT DWORD USE32 PUBLIC 'CONST'
  12. CONST    ENDS
  13. _BSS    SEGMENT DWORD USE32 PUBLIC 'BSS'
  14. _BSS    ENDS
  15. $$SYMBOLS    SEGMENT BYTE USE32 'DEBSYM'
  16. $$SYMBOLS    ENDS
  17. $$TYPES    SEGMENT BYTE USE32 'DEBTYP'
  18. $$TYPES    ENDS
  19. _TLS    SEGMENT DWORD USE32 PUBLIC 'TLS'
  20. _TLS    ENDS
  21. ;    COMDAT ??_C@_0BM@KBJE@m?3?2mysql?93?423?2mysys?2array?4c?$AA@
  22. CONST    SEGMENT DWORD USE32 PUBLIC 'CONST'
  23. CONST    ENDS
  24. ;    COMDAT ??_C@_0BD@GCMA@init_dynamic_array?$AA@
  25. CONST    SEGMENT DWORD USE32 PUBLIC 'CONST'
  26. CONST    ENDS
  27. ;    COMDAT ?__LINE__Var@?1??init_dynamic_array@@9@9
  28. _DATA    SEGMENT DWORD USE32 PUBLIC 'DATA'
  29. _DATA    ENDS
  30. ;    COMDAT ??_C@_07EANM@warning?$AA@
  31. CONST    SEGMENT DWORD USE32 PUBLIC 'CONST'
  32. CONST    ENDS
  33. ;    COMDAT ??_C@_0CH@JLMH@To?5big?5array?5idx?3?5?$CFd?0?5array?5size@
  34. CONST    SEGMENT DWORD USE32 PUBLIC 'CONST'
  35. CONST    ENDS
  36. ;    COMDAT ?__LINE__Var@?1??get_dynamic@@9@9
  37. _DATA    SEGMENT DWORD USE32 PUBLIC 'DATA'
  38. _DATA    ENDS
  39. ;    COMDAT _init_dynamic_array
  40. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  41. _TEXT    ENDS
  42. ;    COMDAT _insert_dynamic
  43. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  44. _TEXT    ENDS
  45. ;    COMDAT _alloc_dynamic
  46. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  47. _TEXT    ENDS
  48. ;    COMDAT _pop_dynamic
  49. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  50. _TEXT    ENDS
  51. ;    COMDAT _set_dynamic
  52. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  53. _TEXT    ENDS
  54. ;    COMDAT _get_dynamic
  55. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  56. _TEXT    ENDS
  57. ;    COMDAT _delete_dynamic
  58. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  59. _TEXT    ENDS
  60. ;    COMDAT _delete_dynamic_element
  61. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  62. _TEXT    ENDS
  63. ;    COMDAT _freeze_size
  64. _TEXT    SEGMENT PARA USE32 PUBLIC 'CODE'
  65. _TEXT    ENDS
  66. FLAT    GROUP _DATA, CONST, _BSS
  67.     ASSUME    CS: FLAT, DS: FLAT, SS: FLAT
  68. endif
  69. PUBLIC    _init_dynamic_array
  70. PUBLIC    ?__LINE__Var@?1??init_dynamic_array@@9@9    ; __LINE__Var
  71. PUBLIC    ??_C@_0BM@KBJE@m?3?2mysql?93?423?2mysys?2array?4c?$AA@ ; `string'
  72. PUBLIC    ??_C@_0BD@GCMA@init_dynamic_array?$AA@        ; `string'
  73. EXTRN    _my_malloc:NEAR
  74. EXTRN    __db_enter_:NEAR
  75. EXTRN    __db_return_:NEAR
  76. ;    COMDAT ?__LINE__Var@?1??init_dynamic_array@@9@9
  77. ; File m:\mysql-3.23\mysys\array.c
  78. _DATA    SEGMENT
  79. ?__LINE__Var@?1??init_dynamic_array@@9@9 DW 014H    ; __LINE__Var
  80. _DATA    ENDS
  81. ;    COMDAT ??_C@_0BM@KBJE@m?3?2mysql?93?423?2mysys?2array?4c?$AA@
  82. CONST    SEGMENT
  83. ??_C@_0BM@KBJE@m?3?2mysql?93?423?2mysys?2array?4c?$AA@ DB 'm:\mysql-3.23\'
  84.     DB    'mysys\array.c', 00H                ; `string'
  85. CONST    ENDS
  86. ;    COMDAT ??_C@_0BD@GCMA@init_dynamic_array?$AA@
  87. CONST    SEGMENT
  88. ??_C@_0BD@GCMA@init_dynamic_array?$AA@ DB 'init_dynamic_array', 00H ; `string'
  89. CONST    ENDS
  90. ;    COMDAT _init_dynamic_array
  91. _TEXT    SEGMENT
  92. _array$ = 8
  93. _element_size$ = 12
  94. _init_alloc$ = 16
  95. _alloc_increment$ = 20
  96. __db_func_$ = -4
  97. __db_file_$ = -8
  98. __db_level_$ = -12
  99. __db_framep_$ = -16
  100. _init_dynamic_array PROC NEAR                ; COMDAT
  101.  
  102. ; 20   : {
  103.  
  104.     push    ebp
  105.     mov    ebp, esp
  106.     sub    esp, 84                    ; 00000054H
  107.     push    ebx
  108.     push    esi
  109.     push    edi
  110.  
  111. ; 21   :   DBUG_ENTER("init_dynamic_array");
  112.  
  113.     lea    eax, DWORD PTR __db_framep_$[ebp]
  114.     push    eax
  115.     lea    ecx, DWORD PTR __db_level_$[ebp]
  116.     push    ecx
  117.     lea    edx, DWORD PTR __db_file_$[ebp]
  118.     push    edx
  119.     lea    eax, DWORD PTR __db_func_$[ebp]
  120.     push    eax
  121.     movsx    ecx, WORD PTR ?__LINE__Var@?1??init_dynamic_array@@9@9 ; __LINE__Var
  122.     add    ecx, 1
  123.     push    ecx
  124.     push    OFFSET FLAT:??_C@_0BM@KBJE@m?3?2mysql?93?423?2mysys?2array?4c?$AA@ ; `string'
  125.     push    OFFSET FLAT:??_C@_0BD@GCMA@init_dynamic_array?$AA@ ; `string'
  126.     call    __db_enter_
  127.     add    esp, 28                    ; 0000001cH
  128.  
  129. ; 22   :   if (!alloc_increment)
  130.  
  131.     cmp    DWORD PTR _alloc_increment$[ebp], 0
  132.     jne    SHORT $L67298
  133.  
  134. ; 24   :     alloc_increment=max((8192-MALLOC_OVERHEAD)/element_size,16);
  135.  
  136.     mov    eax, 8184                ; 00001ff8H
  137.     xor    edx, edx
  138.     div    DWORD PTR _element_size$[ebp]
  139.     cmp    eax, 16                    ; 00000010H
  140.     jbe    SHORT $L67389
  141.     mov    eax, 8184                ; 00001ff8H
  142.     xor    edx, edx
  143.     div    DWORD PTR _element_size$[ebp]
  144.     mov    DWORD PTR -20+[ebp], eax
  145.     jmp    SHORT $L67390
  146. $L67389:
  147.     mov    DWORD PTR -20+[ebp], 16            ; 00000010H
  148. $L67390:
  149.     mov    edx, DWORD PTR -20+[ebp]
  150.     mov    DWORD PTR _alloc_increment$[ebp], edx
  151.  
  152. ; 25   :     if (init_alloc > 8 && alloc_increment > init_alloc * 2)
  153.  
  154.     cmp    DWORD PTR _init_alloc$[ebp], 8
  155.     jbe    SHORT $L67298
  156.     mov    eax, DWORD PTR _init_alloc$[ebp]
  157.     shl    eax, 1
  158.     cmp    DWORD PTR _alloc_increment$[ebp], eax
  159.     jbe    SHORT $L67298
  160.  
  161. ; 26   :       alloc_increment=init_alloc*2;
  162.  
  163.     mov    ecx, DWORD PTR _init_alloc$[ebp]
  164.     shl    ecx, 1
  165.     mov    DWORD PTR _alloc_increment$[ebp], ecx
  166. $L67298:
  167.  
  168. ; 28   : 
  169. ; 29   :   if (!init_alloc)
  170.  
  171.     cmp    DWORD PTR _init_alloc$[ebp], 0
  172.     jne    SHORT $L67299
  173.  
  174. ; 30   :     init_alloc=alloc_increment;
  175.  
  176.     mov    edx, DWORD PTR _alloc_increment$[ebp]
  177.     mov    DWORD PTR _init_alloc$[ebp], edx
  178. $L67299:
  179.  
  180. ; 31   :   array->elements=0;
  181.  
  182.     mov    eax, DWORD PTR _array$[ebp]
  183.     mov    DWORD PTR [eax+4], 0
  184.  
  185. ; 32   :   array->max_element=init_alloc;
  186.  
  187.     mov    ecx, DWORD PTR _array$[ebp]
  188.     mov    edx, DWORD PTR _init_alloc$[ebp]
  189.     mov    DWORD PTR [ecx+8], edx
  190.  
  191. ; 33   :   array->alloc_increment=alloc_increment;
  192.  
  193.     mov    eax, DWORD PTR _array$[ebp]
  194.     mov    ecx, DWORD PTR _alloc_increment$[ebp]
  195.     mov    DWORD PTR [eax+12], ecx
  196.  
  197. ; 34   :   array->size_of_element=element_size;
  198.  
  199.     mov    edx, DWORD PTR _array$[ebp]
  200.     mov    eax, DWORD PTR _element_size$[ebp]
  201.     mov    DWORD PTR [edx+16], eax
  202.  
  203. ; 35   :   if (!(array->buffer=(char*) my_malloc(element_size*init_alloc,MYF(MY_WME))))
  204.  
  205.     push    16                    ; 00000010H
  206.     mov    ecx, DWORD PTR _element_size$[ebp]
  207.     imul    ecx, DWORD PTR _init_alloc$[ebp]
  208.     push    ecx
  209.     call    _my_malloc
  210.     add    esp, 8
  211.     mov    edx, DWORD PTR _array$[ebp]
  212.     mov    DWORD PTR [edx], eax
  213.     mov    eax, DWORD PTR _array$[ebp]
  214.     cmp    DWORD PTR [eax], 0
  215.     jne    SHORT $L67302
  216.  
  217. ; 37   :     array->max_element=0;
  218.  
  219.     mov    ecx, DWORD PTR _array$[ebp]
  220.     mov    DWORD PTR [ecx+8], 0
  221.  
  222. ; 38   :     DBUG_RETURN(TRUE);
  223.  
  224.     lea    edx, DWORD PTR __db_level_$[ebp]
  225.     push    edx
  226.     lea    eax, DWORD PTR __db_file_$[ebp]
  227.     push    eax
  228.     lea    ecx, DWORD PTR __db_func_$[ebp]
  229.     push    ecx
  230.     movsx    edx, WORD PTR ?__LINE__Var@?1??init_dynamic_array@@9@9 ; __LINE__Var
  231.     add    edx, 18                    ; 00000012H
  232.     push    edx
  233.     call    __db_return_
  234.     add    esp, 16                    ; 00000010H
  235.     mov    al, 1
  236.     jmp    SHORT $L67289
  237. $L67302:
  238.  
  239. ; 40   :   DBUG_RETURN(FALSE);
  240.  
  241.     lea    eax, DWORD PTR __db_level_$[ebp]
  242.     push    eax
  243.     lea    ecx, DWORD PTR __db_file_$[ebp]
  244.     push    ecx
  245.     lea    edx, DWORD PTR __db_func_$[ebp]
  246.     push    edx
  247.     movsx    eax, WORD PTR ?__LINE__Var@?1??init_dynamic_array@@9@9 ; __LINE__Var
  248.     add    eax, 20                    ; 00000014H
  249.     push    eax
  250.     call    __db_return_
  251.     add    esp, 16                    ; 00000010H
  252.     xor    al, al
  253. $L67289:
  254.  
  255. ; 41   : }
  256.  
  257.     pop    edi
  258.     pop    esi
  259.     pop    ebx
  260.     mov    esp, ebp
  261.     pop    ebp
  262.     ret    0
  263. _init_dynamic_array ENDP
  264. _TEXT    ENDS
  265. PUBLIC    _insert_dynamic
  266. PUBLIC    _alloc_dynamic
  267. EXTRN    _memcpy:NEAR
  268. ;    COMDAT _insert_dynamic
  269. _TEXT    SEGMENT
  270. _array$ = 8
  271. _element$ = 12
  272. _buffer$ = -4
  273. _insert_dynamic PROC NEAR                ; COMDAT
  274.  
  275. ; 45   : {
  276.  
  277.     push    ebp
  278.     mov    ebp, esp
  279.     sub    esp, 68                    ; 00000044H
  280.     push    ebx
  281.     push    esi
  282.     push    edi
  283.  
  284. ; 46   :   gptr buffer;
  285. ; 47   :   if (array->elements == array->max_element)
  286.  
  287.     mov    eax, DWORD PTR _array$[ebp]
  288.     mov    ecx, DWORD PTR _array$[ebp]
  289.     mov    edx, DWORD PTR [eax+4]
  290.     cmp    edx, DWORD PTR [ecx+8]
  291.     jne    SHORT $L67309
  292.  
  293. ; 49   :     if (!(buffer=alloc_dynamic(array)))
  294.  
  295.     mov    eax, DWORD PTR _array$[ebp]
  296.     push    eax
  297.     call    _alloc_dynamic
  298.     add    esp, 4
  299.     mov    DWORD PTR _buffer$[ebp], eax
  300.     cmp    DWORD PTR _buffer$[ebp], 0
  301.     jne    SHORT $L67310
  302.  
  303. ; 50   :       return TRUE;
  304.  
  305.     mov    al, 1
  306.     jmp    SHORT $L67307
  307. $L67310:
  308.  
  309. ; 52   :   else
  310.  
  311.     jmp    SHORT $L67311
  312. $L67309:
  313.  
  314. ; 54   :     buffer=array->buffer+(array->elements * array->size_of_element);
  315.  
  316.     mov    ecx, DWORD PTR _array$[ebp]
  317.     mov    edx, DWORD PTR _array$[ebp]
  318.     mov    eax, DWORD PTR [ecx+4]
  319.     imul    eax, DWORD PTR [edx+16]
  320.     mov    ecx, DWORD PTR _array$[ebp]
  321.     mov    edx, DWORD PTR [ecx]
  322.     add    edx, eax
  323.     mov    DWORD PTR _buffer$[ebp], edx
  324.  
  325. ; 55   :     array->elements++;
  326.  
  327.     mov    eax, DWORD PTR _array$[ebp]
  328.     mov    ecx, DWORD PTR [eax+4]
  329.     add    ecx, 1
  330.     mov    edx, DWORD PTR _array$[ebp]
  331.     mov    DWORD PTR [edx+4], ecx
  332. $L67311:
  333.  
  334. ; 57   :   memcpy(buffer,element,(size_t) array->size_of_element);
  335.  
  336.     mov    eax, DWORD PTR _array$[ebp]
  337.     mov    ecx, DWORD PTR [eax+16]
  338.     push    ecx
  339.     mov    edx, DWORD PTR _element$[ebp]
  340.     push    edx
  341.     mov    eax, DWORD PTR _buffer$[ebp]
  342.     push    eax
  343.     call    _memcpy
  344.     add    esp, 12                    ; 0000000cH
  345.  
  346. ; 58   :   return FALSE;
  347.  
  348.     xor    al, al
  349. $L67307:
  350.  
  351. ; 59   : }
  352.  
  353.     pop    edi
  354.     pop    esi
  355.     pop    ebx
  356.     mov    esp, ebp
  357.     pop    ebp
  358.     ret    0
  359. _insert_dynamic ENDP
  360. _TEXT    ENDS
  361. EXTRN    _my_realloc:NEAR
  362. ;    COMDAT _alloc_dynamic
  363. _TEXT    SEGMENT
  364. _array$ = 8
  365. _new_ptr$67317 = -4
  366. _alloc_dynamic PROC NEAR                ; COMDAT
  367.  
  368. ; 65   : {
  369.  
  370.     push    ebp
  371.     mov    ebp, esp
  372.     sub    esp, 68                    ; 00000044H
  373.     push    ebx
  374.     push    esi
  375.     push    edi
  376.  
  377. ; 66   :   if (array->elements == array->max_element)
  378.  
  379.     mov    eax, DWORD PTR _array$[ebp]
  380.     mov    ecx, DWORD PTR _array$[ebp]
  381.     mov    edx, DWORD PTR [eax+4]
  382.     cmp    edx, DWORD PTR [ecx+8]
  383.     jne    SHORT $L67316
  384.  
  385. ; 68   :     char *new_ptr;
  386. ; 69   :     if (!(new_ptr=(char*) my_realloc(array->buffer,(array->max_element+
  387. ; 70   :                      array->alloc_increment)*
  388. ; 71   :                      array->size_of_element,
  389. ; 72   :                      MYF(MY_WME | MY_ALLOW_ZERO_PTR))))
  390.  
  391.     push    80                    ; 00000050H
  392.     mov    eax, DWORD PTR _array$[ebp]
  393.     mov    ecx, DWORD PTR [eax+8]
  394.     mov    edx, DWORD PTR _array$[ebp]
  395.     add    ecx, DWORD PTR [edx+12]
  396.     mov    eax, DWORD PTR _array$[ebp]
  397.     imul    ecx, DWORD PTR [eax+16]
  398.     push    ecx
  399.     mov    ecx, DWORD PTR _array$[ebp]
  400.     mov    edx, DWORD PTR [ecx]
  401.     push    edx
  402.     call    _my_realloc
  403.     add    esp, 12                    ; 0000000cH
  404.     mov    DWORD PTR _new_ptr$67317[ebp], eax
  405.     cmp    DWORD PTR _new_ptr$67317[ebp], 0
  406.     jne    SHORT $L67320
  407.  
  408. ; 73   :       return 0;
  409.  
  410.     xor    eax, eax
  411.     jmp    SHORT $L67315
  412. $L67320:
  413.  
  414. ; 74   :     array->buffer=new_ptr;
  415.  
  416.     mov    eax, DWORD PTR _array$[ebp]
  417.     mov    ecx, DWORD PTR _new_ptr$67317[ebp]
  418.     mov    DWORD PTR [eax], ecx
  419.  
  420. ; 75   :     array->max_element+=array->alloc_increment;
  421.  
  422.     mov    edx, DWORD PTR _array$[ebp]
  423.     mov    eax, DWORD PTR [edx+8]
  424.     mov    ecx, DWORD PTR _array$[ebp]
  425.     add    eax, DWORD PTR [ecx+12]
  426.     mov    edx, DWORD PTR _array$[ebp]
  427.     mov    DWORD PTR [edx+8], eax
  428. $L67316:
  429.  
  430. ; 77   :   return array->buffer+(array->elements++ * array->size_of_element);
  431.  
  432.     mov    eax, DWORD PTR _array$[ebp]
  433.     mov    ecx, DWORD PTR _array$[ebp]
  434.     mov    edx, DWORD PTR [eax+4]
  435.     imul    edx, DWORD PTR [ecx+16]
  436.     mov    eax, DWORD PTR _array$[ebp]
  437.     mov    eax, DWORD PTR [eax]
  438.     add    eax, edx
  439.     mov    ecx, DWORD PTR _array$[ebp]
  440.     mov    edx, DWORD PTR [ecx+4]
  441.     add    edx, 1
  442.     mov    ecx, DWORD PTR _array$[ebp]
  443.     mov    DWORD PTR [ecx+4], edx
  444. $L67315:
  445.  
  446. ; 78   : }
  447.  
  448.     pop    edi
  449.     pop    esi
  450.     pop    ebx
  451.     mov    esp, ebp
  452.     pop    ebp
  453.     ret    0
  454. _alloc_dynamic ENDP
  455. _TEXT    ENDS
  456. PUBLIC    _pop_dynamic
  457. ;    COMDAT _pop_dynamic
  458. _TEXT    SEGMENT
  459. _array$ = 8
  460. _pop_dynamic PROC NEAR                    ; COMDAT
  461.  
  462. ; 84   : {
  463.  
  464.     push    ebp
  465.     mov    ebp, esp
  466.     sub    esp, 64                    ; 00000040H
  467.     push    ebx
  468.     push    esi
  469.     push    edi
  470.  
  471. ; 85   :   if (array->elements)
  472.  
  473.     mov    eax, DWORD PTR _array$[ebp]
  474.     cmp    DWORD PTR [eax+4], 0
  475.     je    SHORT $L67324
  476.  
  477. ; 86   :     return array->buffer+(--array->elements * array->size_of_element);
  478.  
  479.     mov    ecx, DWORD PTR _array$[ebp]
  480.     mov    edx, DWORD PTR [ecx+4]
  481.     sub    edx, 1
  482.     mov    eax, DWORD PTR _array$[ebp]
  483.     mov    DWORD PTR [eax+4], edx
  484.     mov    ecx, DWORD PTR _array$[ebp]
  485.     mov    edx, DWORD PTR _array$[ebp]
  486.     mov    eax, DWORD PTR [ecx+4]
  487.     imul    eax, DWORD PTR [edx+16]
  488.     mov    ecx, DWORD PTR _array$[ebp]
  489.     mov    edx, DWORD PTR [ecx]
  490.     add    eax, edx
  491.     jmp    SHORT $L67323
  492. $L67324:
  493.  
  494. ; 87   :   return 0;
  495.  
  496.     xor    eax, eax
  497. $L67323:
  498.  
  499. ; 88   : }
  500.  
  501.     pop    edi
  502.     pop    esi
  503.     pop    ebx
  504.     mov    esp, ebp
  505.     pop    ebp
  506.     ret    0
  507. _pop_dynamic ENDP
  508. _TEXT    ENDS
  509. PUBLIC    _set_dynamic
  510. EXTRN    _memset:NEAR
  511. ;    COMDAT _set_dynamic
  512. _TEXT    SEGMENT
  513. _array$ = 8
  514. _element$ = 12
  515. _idx$ = 16
  516. _size$67334 = -4
  517. _new_ptr$67335 = -8
  518. _set_dynamic PROC NEAR                    ; COMDAT
  519.  
  520. ; 92   : {
  521.  
  522.     push    ebp
  523.     mov    ebp, esp
  524.     sub    esp, 72                    ; 00000048H
  525.     push    ebx
  526.     push    esi
  527.     push    edi
  528.  
  529. ; 93   :   if (idx >= array->elements)
  530.  
  531.     mov    eax, DWORD PTR _array$[ebp]
  532.     mov    ecx, DWORD PTR _idx$[ebp]
  533.     cmp    ecx, DWORD PTR [eax+4]
  534.     jb    $L67332
  535.  
  536. ; 95   :     if (idx >= array->max_element)
  537.  
  538.     mov    edx, DWORD PTR _array$[ebp]
  539.     mov    eax, DWORD PTR _idx$[ebp]
  540.     cmp    eax, DWORD PTR [edx+8]
  541.     jb    SHORT $L67333
  542.  
  543. ; 97   :       uint size;
  544. ; 98   :       char *new_ptr;
  545. ; 99   :       size=(idx+array->alloc_increment)/array->alloc_increment;
  546.  
  547.     mov    ecx, DWORD PTR _array$[ebp]
  548.     mov    eax, DWORD PTR _idx$[ebp]
  549.     add    eax, DWORD PTR [ecx+12]
  550.     mov    ecx, DWORD PTR _array$[ebp]
  551.     xor    edx, edx
  552.     div    DWORD PTR [ecx+12]
  553.     mov    DWORD PTR _size$67334[ebp], eax
  554.  
  555. ; 100  :       size*= array->alloc_increment;
  556.  
  557.     mov    edx, DWORD PTR _array$[ebp]
  558.     mov    eax, DWORD PTR _size$67334[ebp]
  559.     imul    eax, DWORD PTR [edx+12]
  560.     mov    DWORD PTR _size$67334[ebp], eax
  561.  
  562. ; 101  :       if (!(new_ptr=(char*) my_realloc(array->buffer,size*
  563. ; 102  :                        array->size_of_element,
  564. ; 103  :                        MYF(MY_WME | MY_ALLOW_ZERO_PTR))))
  565.  
  566.     push    80                    ; 00000050H
  567.     mov    ecx, DWORD PTR _array$[ebp]
  568.     mov    edx, DWORD PTR _size$67334[ebp]
  569.     imul    edx, DWORD PTR [ecx+16]
  570.     push    edx
  571.     mov    eax, DWORD PTR _array$[ebp]
  572.     mov    ecx, DWORD PTR [eax]
  573.     push    ecx
  574.     call    _my_realloc
  575.     add    esp, 12                    ; 0000000cH
  576.     mov    DWORD PTR _new_ptr$67335[ebp], eax
  577.     cmp    DWORD PTR _new_ptr$67335[ebp], 0
  578.     jne    SHORT $L67338
  579.  
  580. ; 104  :     return TRUE;
  581.  
  582.     mov    al, 1
  583.     jmp    SHORT $L67331
  584. $L67338:
  585.  
  586. ; 105  :       array->buffer=new_ptr;
  587.  
  588.     mov    edx, DWORD PTR _array$[ebp]
  589.     mov    eax, DWORD PTR _new_ptr$67335[ebp]
  590.     mov    DWORD PTR [edx], eax
  591.  
  592. ; 106  :       array->max_element=size;
  593.  
  594.     mov    ecx, DWORD PTR _array$[ebp]
  595.     mov    edx, DWORD PTR _size$67334[ebp]
  596.     mov    DWORD PTR [ecx+8], edx
  597. $L67333:
  598.  
  599. ; 108  :     bzero((gptr) (array->buffer+array->elements*array->size_of_element),
  600. ; 109  :       (idx - array->elements)*array->size_of_element);
  601.  
  602.     mov    eax, DWORD PTR _array$[ebp]
  603.     mov    ecx, DWORD PTR _idx$[ebp]
  604.     sub    ecx, DWORD PTR [eax+4]
  605.     mov    edx, DWORD PTR _array$[ebp]
  606.     imul    ecx, DWORD PTR [edx+16]
  607.     push    ecx
  608.     push    0
  609.     mov    eax, DWORD PTR _array$[ebp]
  610.     mov    ecx, DWORD PTR _array$[ebp]
  611.     mov    edx, DWORD PTR [eax+4]
  612.     imul    edx, DWORD PTR [ecx+16]
  613.     mov    eax, DWORD PTR _array$[ebp]
  614.     mov    ecx, DWORD PTR [eax]
  615.     add    ecx, edx
  616.     push    ecx
  617.     call    _memset
  618.     add    esp, 12                    ; 0000000cH
  619.  
  620. ; 110  :     array->elements=idx+1;
  621.  
  622.     mov    edx, DWORD PTR _idx$[ebp]
  623.     add    edx, 1
  624.     mov    eax, DWORD PTR _array$[ebp]
  625.     mov    DWORD PTR [eax+4], edx
  626. $L67332:
  627.  
  628. ; 112  :   memcpy(array->buffer+(idx * array->size_of_element),element,
  629. ; 113  :      (size_t) array->size_of_element);
  630.  
  631.     mov    ecx, DWORD PTR _array$[ebp]
  632.     mov    edx, DWORD PTR [ecx+16]
  633.     push    edx
  634.     mov    eax, DWORD PTR _element$[ebp]
  635.     push    eax
  636.     mov    ecx, DWORD PTR _array$[ebp]
  637.     mov    edx, DWORD PTR _idx$[ebp]
  638.     imul    edx, DWORD PTR [ecx+16]
  639.     mov    eax, DWORD PTR _array$[ebp]
  640.     mov    ecx, DWORD PTR [eax]
  641.     add    ecx, edx
  642.     push    ecx
  643.     call    _memcpy
  644.     add    esp, 12                    ; 0000000cH
  645.  
  646. ; 114  :   return FALSE;
  647.  
  648.     xor    al, al
  649. $L67331:
  650.  
  651. ; 115  : }
  652.  
  653.     pop    edi
  654.     pop    esi
  655.     pop    ebx
  656.     mov    esp, ebp
  657.     pop    ebp
  658.     ret    0
  659. _set_dynamic ENDP
  660. _TEXT    ENDS
  661. PUBLIC    _get_dynamic
  662. PUBLIC    ?__LINE__Var@?1??get_dynamic@@9@9        ; __LINE__Var
  663. PUBLIC    ??_C@_07EANM@warning?$AA@            ; `string'
  664. PUBLIC    ??_C@_0CH@JLMH@To?5big?5array?5idx?3?5?$CFd?0?5array?5size@ ; `string'
  665. EXTRN    __db_on_:DWORD
  666. EXTRN    __db_pargs_:NEAR
  667. EXTRN    __db_doprnt_:NEAR
  668. ;    COMDAT ?__LINE__Var@?1??get_dynamic@@9@9
  669. ; File m:\mysql-3.23\mysys\array.c
  670. _DATA    SEGMENT
  671. ?__LINE__Var@?1??get_dynamic@@9@9 DW 077H        ; __LINE__Var
  672. _DATA    ENDS
  673. ;    COMDAT ??_C@_07EANM@warning?$AA@
  674. CONST    SEGMENT
  675. ??_C@_07EANM@warning?$AA@ DB 'warning', 00H        ; `string'
  676. CONST    ENDS
  677. ;    COMDAT ??_C@_0CH@JLMH@To?5big?5array?5idx?3?5?$CFd?0?5array?5size@
  678. CONST    SEGMENT
  679. ??_C@_0CH@JLMH@To?5big?5array?5idx?3?5?$CFd?0?5array?5size@ DB 'To big ar'
  680.     DB    'ray idx: %d, array size is %d', 00H        ; `string'
  681. CONST    ENDS
  682. ;    COMDAT _get_dynamic
  683. _TEXT    SEGMENT
  684. _array$ = 8
  685. _element$ = 12
  686. _idx$ = 16
  687. _get_dynamic PROC NEAR                    ; COMDAT
  688.  
  689. ; 119  : {
  690.  
  691.     push    ebp
  692.     mov    ebp, esp
  693.     sub    esp, 64                    ; 00000040H
  694.     push    ebx
  695.     push    esi
  696.     push    edi
  697.  
  698. ; 120  :   if (idx >= array->elements)
  699.  
  700.     mov    eax, DWORD PTR _array$[ebp]
  701.     mov    ecx, DWORD PTR _idx$[ebp]
  702.     cmp    ecx, DWORD PTR [eax+4]
  703.     jb    SHORT $L67348
  704.  
  705. ; 123  :               idx,array->elements));
  706.  
  707.     cmp    DWORD PTR __db_on_, 0
  708.     je    SHORT $L67350
  709.     push    OFFSET FLAT:??_C@_07EANM@warning?$AA@    ; `string'
  710.     movsx    edx, WORD PTR ?__LINE__Var@?1??get_dynamic@@9@9 ; __LINE__Var
  711.     add    edx, 4
  712.     push    edx
  713.     call    __db_pargs_
  714.     add    esp, 8
  715.     mov    eax, DWORD PTR _array$[ebp]
  716.     mov    ecx, DWORD PTR [eax+4]
  717.     push    ecx
  718.     mov    edx, DWORD PTR _idx$[ebp]
  719.     push    edx
  720.     push    OFFSET FLAT:??_C@_0CH@JLMH@To?5big?5array?5idx?3?5?$CFd?0?5array?5size@ ; `string'
  721.     call    __db_doprnt_
  722.     add    esp, 12                    ; 0000000cH
  723. $L67350:
  724.  
  725. ; 124  :     bzero(element,array->size_of_element);
  726.  
  727.     mov    eax, DWORD PTR _array$[ebp]
  728.     mov    ecx, DWORD PTR [eax+16]
  729.     push    ecx
  730.     push    0
  731.     mov    edx, DWORD PTR _element$[ebp]
  732.     push    edx
  733.     call    _memset
  734.     add    esp, 12                    ; 0000000cH
  735.  
  736. ; 125  :     return;
  737.  
  738.     jmp    SHORT $L67347
  739. $L67348:
  740.  
  741. ; 127  :   memcpy(element,array->buffer+idx*array->size_of_element,
  742. ; 128  :      (size_t) array->size_of_element);
  743.  
  744.     mov    eax, DWORD PTR _array$[ebp]
  745.     mov    ecx, DWORD PTR [eax+16]
  746.     push    ecx
  747.     mov    edx, DWORD PTR _array$[ebp]
  748.     mov    eax, DWORD PTR _idx$[ebp]
  749.     imul    eax, DWORD PTR [edx+16]
  750.     mov    ecx, DWORD PTR _array$[ebp]
  751.     mov    edx, DWORD PTR [ecx]
  752.     add    edx, eax
  753.     push    edx
  754.     mov    eax, DWORD PTR _element$[ebp]
  755.     push    eax
  756.     call    _memcpy
  757.     add    esp, 12                    ; 0000000cH
  758. $L67347:
  759.  
  760. ; 129  : }
  761.  
  762.     pop    edi
  763.     pop    esi
  764.     pop    ebx
  765.     mov    esp, ebp
  766.     pop    ebp
  767.     ret    0
  768. _get_dynamic ENDP
  769. _TEXT    ENDS
  770. PUBLIC    _delete_dynamic
  771. EXTRN    _my_no_flags_free:NEAR
  772. ;    COMDAT _delete_dynamic
  773. _TEXT    SEGMENT
  774. _array$ = 8
  775. _delete_dynamic PROC NEAR                ; COMDAT
  776.  
  777. ; 133  : {
  778.  
  779.     push    ebp
  780.     mov    ebp, esp
  781.     sub    esp, 64                    ; 00000040H
  782.     push    ebx
  783.     push    esi
  784.     push    edi
  785.  
  786. ; 134  :   if (array->buffer)
  787.  
  788.     mov    eax, DWORD PTR _array$[ebp]
  789.     cmp    DWORD PTR [eax], 0
  790.     je    SHORT $L67357
  791.  
  792. ; 136  :     my_free(array->buffer,MYF(MY_WME));
  793.  
  794.     mov    ecx, DWORD PTR _array$[ebp]
  795.     mov    edx, DWORD PTR [ecx]
  796.     push    edx
  797.     call    _my_no_flags_free
  798.     add    esp, 4
  799.  
  800. ; 137  :     array->buffer=0;
  801.  
  802.     mov    eax, DWORD PTR _array$[ebp]
  803.     mov    DWORD PTR [eax], 0
  804.  
  805. ; 138  :     array->elements=array->max_element=0;
  806.  
  807.     mov    ecx, DWORD PTR _array$[ebp]
  808.     mov    DWORD PTR [ecx+8], 0
  809.     mov    edx, DWORD PTR _array$[ebp]
  810.     mov    DWORD PTR [edx+4], 0
  811. $L67357:
  812.  
  813. ; 140  : }
  814.  
  815.     pop    edi
  816.     pop    esi
  817.     pop    ebx
  818.     mov    esp, ebp
  819.     pop    ebp
  820.     ret    0
  821. _delete_dynamic ENDP
  822. _TEXT    ENDS
  823. PUBLIC    _delete_dynamic_element
  824. EXTRN    _memmove:NEAR
  825. ;    COMDAT _delete_dynamic_element
  826. _TEXT    SEGMENT
  827. _array$ = 8
  828. _idx$ = 12
  829. _ptr$ = -4
  830. _delete_dynamic_element PROC NEAR            ; COMDAT
  831.  
  832. ; 144  : {
  833.  
  834.     push    ebp
  835.     mov    ebp, esp
  836.     sub    esp, 68                    ; 00000044H
  837.     push    ebx
  838.     push    esi
  839.     push    edi
  840.  
  841. ; 145  :   char *ptr=array->buffer+array->size_of_element*idx;
  842.  
  843.     mov    eax, DWORD PTR _array$[ebp]
  844.     mov    ecx, DWORD PTR [eax+16]
  845.     imul    ecx, DWORD PTR _idx$[ebp]
  846.     mov    edx, DWORD PTR _array$[ebp]
  847.     mov    eax, DWORD PTR [edx]
  848.     add    eax, ecx
  849.     mov    DWORD PTR _ptr$[ebp], eax
  850.  
  851. ; 146  :   array->elements--;
  852.  
  853.     mov    ecx, DWORD PTR _array$[ebp]
  854.     mov    edx, DWORD PTR [ecx+4]
  855.     sub    edx, 1
  856.     mov    eax, DWORD PTR _array$[ebp]
  857.     mov    DWORD PTR [eax+4], edx
  858.  
  859. ; 147  :   memmove(ptr,ptr+array->size_of_element,
  860. ; 148  :       (array->elements-idx)*array->size_of_element);
  861.  
  862.     mov    ecx, DWORD PTR _array$[ebp]
  863.     mov    edx, DWORD PTR [ecx+4]
  864.     sub    edx, DWORD PTR _idx$[ebp]
  865.     mov    eax, DWORD PTR _array$[ebp]
  866.     imul    edx, DWORD PTR [eax+16]
  867.     push    edx
  868.     mov    ecx, DWORD PTR _array$[ebp]
  869.     mov    edx, DWORD PTR _ptr$[ebp]
  870.     add    edx, DWORD PTR [ecx+16]
  871.     push    edx
  872.     mov    eax, DWORD PTR _ptr$[ebp]
  873.     push    eax
  874.     call    _memmove
  875.     add    esp, 12                    ; 0000000cH
  876.  
  877. ; 149  : }
  878.  
  879.     pop    edi
  880.     pop    esi
  881.     pop    ebx
  882.     mov    esp, ebp
  883.     pop    ebp
  884.     ret    0
  885. _delete_dynamic_element ENDP
  886. _TEXT    ENDS
  887. PUBLIC    _freeze_size
  888. ;    COMDAT _freeze_size
  889. _TEXT    SEGMENT
  890. _array$ = 8
  891. _elements$ = -4
  892. _freeze_size PROC NEAR                    ; COMDAT
  893.  
  894. ; 153  : {
  895.  
  896.     push    ebp
  897.     mov    ebp, esp
  898.     sub    esp, 72                    ; 00000048H
  899.     push    ebx
  900.     push    esi
  901.     push    edi
  902.  
  903. ; 154  :   uint elements=max(array->elements,1);
  904.  
  905.     mov    eax, DWORD PTR _array$[ebp]
  906.     cmp    DWORD PTR [eax+4], 1
  907.     jbe    SHORT $L67407
  908.     mov    ecx, DWORD PTR _array$[ebp]
  909.     mov    edx, DWORD PTR [ecx+4]
  910.     mov    DWORD PTR -8+[ebp], edx
  911.     jmp    SHORT $L67408
  912. $L67407:
  913.     mov    DWORD PTR -8+[ebp], 1
  914. $L67408:
  915.     mov    eax, DWORD PTR -8+[ebp]
  916.     mov    DWORD PTR _elements$[ebp], eax
  917.  
  918. ; 155  : 
  919. ; 156  :   if (array->buffer && array->max_element != elements)
  920.  
  921.     mov    ecx, DWORD PTR _array$[ebp]
  922.     cmp    DWORD PTR [ecx], 0
  923.     je    SHORT $L67368
  924.     mov    edx, DWORD PTR _array$[ebp]
  925.     mov    eax, DWORD PTR [edx+8]
  926.     cmp    eax, DWORD PTR _elements$[ebp]
  927.     je    SHORT $L67368
  928.  
  929. ; 158  :     array->buffer=(char*) my_realloc(array->buffer,
  930. ; 159  :                      elements*array->size_of_element,
  931. ; 160  :                      MYF(MY_WME));
  932.  
  933.     push    16                    ; 00000010H
  934.     mov    ecx, DWORD PTR _array$[ebp]
  935.     mov    edx, DWORD PTR _elements$[ebp]
  936.     imul    edx, DWORD PTR [ecx+16]
  937.     push    edx
  938.     mov    eax, DWORD PTR _array$[ebp]
  939.     mov    ecx, DWORD PTR [eax]
  940.     push    ecx
  941.     call    _my_realloc
  942.     add    esp, 12                    ; 0000000cH
  943.     mov    edx, DWORD PTR _array$[ebp]
  944.     mov    DWORD PTR [edx], eax
  945.  
  946. ; 161  :     array->max_element=elements;
  947.  
  948.     mov    eax, DWORD PTR _array$[ebp]
  949.     mov    ecx, DWORD PTR _elements$[ebp]
  950.     mov    DWORD PTR [eax+8], ecx
  951. $L67368:
  952.  
  953. ; 163  : }
  954.  
  955.     pop    edi
  956.     pop    esi
  957.     pop    ebx
  958.     mov    esp, ebp
  959.     pop    ebp
  960.     ret    0
  961. _freeze_size ENDP
  962. _TEXT    ENDS
  963. END
  964.