control.cod

模拟电梯程序

  0020a	8b 55 08	 mov	 edx, DWORD PTR _startPtr$[ebp]
  0020d	8b 02		 mov	 eax, DWORD PTR [edx]
  0020f	89 45 fc	 mov	 DWORD PTR _curruntPtr$[ebp], eax
$L53022:

; 93   :                    while(curruntPtr!=NULL){

  00212	83 7d fc 00	 cmp	 DWORD PTR _curruntPtr$[ebp], 0
  00216	74 34		 je	 SHORT $L53023

; 94   :                       if((curruntPtr->CallDirection==1||curruntPtr->CallDirection==0)&&
; 95   :                          (curruntPtr->CallFloor<GoalFloor))

  00218	8b 4d fc	 mov	 ecx, DWORD PTR _curruntPtr$[ebp]
  0021b	83 39 01	 cmp	 DWORD PTR [ecx], 1
  0021e	74 08		 je	 SHORT $L53025
  00220	8b 55 fc	 mov	 edx, DWORD PTR _curruntPtr$[ebp]
  00223	83 3a 00	 cmp	 DWORD PTR [edx], 0
  00226	75 19		 jne	 SHORT $L53024
$L53025:
  00228	8b 45 fc	 mov	 eax, DWORD PTR _curruntPtr$[ebp]
  0022b	8b 48 04	 mov	 ecx, DWORD PTR [eax+4]
  0022e	3b 0d 00 00 00
	00		 cmp	 ecx, DWORD PTR _GoalFloor
  00234	7d 0b		 jge	 SHORT $L53024

; 96   :                          GoalFloor=curruntPtr->CallFloor;

  00236	8b 55 fc	 mov	 edx, DWORD PTR _curruntPtr$[ebp]
  00239	8b 42 04	 mov	 eax, DWORD PTR [edx+4]
  0023c	a3 00 00 00 00	 mov	 DWORD PTR _GoalFloor, eax
$L53024:

; 97   :                       curruntPtr=curruntPtr->Nextptr;

  00241	8b 4d fc	 mov	 ecx, DWORD PTR _curruntPtr$[ebp]
  00244	8b 51 08	 mov	 edx, DWORD PTR [ecx+8]
  00247	89 55 fc	 mov	 DWORD PTR _curruntPtr$[ebp], edx

; 98   :                    }

  0024a	eb c6		 jmp	 SHORT $L53022
$L53023:

; 103  :        else{/*当电梯运行时*/ 

  0024c	e9 c2 00 00 00	 jmp	 $L53042
$L52981:

; 104  :           if(CurrentDirection==1){

  00251	83 3d 00 00 00
	00 01		 cmp	 DWORD PTR _CurrentDirection, 1
  00258	75 5e		 jne	 SHORT $L53027

; 105  :              if((*startPtr)!=NULL){

  0025a	8b 45 08	 mov	 eax, DWORD PTR _startPtr$[ebp]
  0025d	83 38 00	 cmp	 DWORD PTR [eax], 0
  00260	74 54		 je	 SHORT $L53033

; 106  :                 curruntPtr=*startPtr;

  00262	8b 4d 08	 mov	 ecx, DWORD PTR _startPtr$[ebp]
  00265	8b 11		 mov	 edx, DWORD PTR [ecx]
  00267	89 55 fc	 mov	 DWORD PTR _curruntPtr$[ebp], edx
$L53032:

; 107  :                 while(curruntPtr!=NULL){

  0026a	83 7d fc 00	 cmp	 DWORD PTR _curruntPtr$[ebp], 0
  0026e	74 46		 je	 SHORT $L53033

; 108  :                    if((curruntPtr->CallDirection==1||curruntPtr->CallDirection==0)&&
; 109  : 					   (curruntPtr->CallFloor>StatusFloor+1)&&(curruntPtr->CallFloor<GoalFloor))

  00270	8b 45 fc	 mov	 eax, DWORD PTR _curruntPtr$[ebp]
  00273	83 38 01	 cmp	 DWORD PTR [eax], 1
  00276	74 08		 je	 SHORT $L53035
  00278	8b 4d fc	 mov	 ecx, DWORD PTR _curruntPtr$[ebp]
  0027b	83 39 00	 cmp	 DWORD PTR [ecx], 0
  0027e	75 2b		 jne	 SHORT $L53034
$L53035:
  00280	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _StatusFloor
  00286	83 c2 01	 add	 edx, 1
  00289	8b 45 fc	 mov	 eax, DWORD PTR _curruntPtr$[ebp]
  0028c	39 50 04	 cmp	 DWORD PTR [eax+4], edx
  0028f	7e 1a		 jle	 SHORT $L53034
  00291	8b 4d fc	 mov	 ecx, DWORD PTR _curruntPtr$[ebp]
  00294	8b 51 04	 mov	 edx, DWORD PTR [ecx+4]
  00297	3b 15 00 00 00
	00		 cmp	 edx, DWORD PTR _GoalFloor
  0029d	7d 0c		 jge	 SHORT $L53034

; 110  :                       GoalFloor=curruntPtr->CallFloor;

  0029f	8b 45 fc	 mov	 eax, DWORD PTR _curruntPtr$[ebp]
  002a2	8b 48 04	 mov	 ecx, DWORD PTR [eax+4]
  002a5	89 0d 00 00 00
	00		 mov	 DWORD PTR _GoalFloor, ecx
$L53034:

; 111  :                    curruntPtr=curruntPtr->Nextptr;

  002ab	8b 55 fc	 mov	 edx, DWORD PTR _curruntPtr$[ebp]
  002ae	8b 42 08	 mov	 eax, DWORD PTR [edx+8]
  002b1	89 45 fc	 mov	 DWORD PTR _curruntPtr$[ebp], eax

; 112  :                 }

  002b4	eb b4		 jmp	 SHORT $L53032
$L53033:

; 115  :           else{

  002b6	eb 5b		 jmp	 SHORT $L53042
$L53027:

; 116  :              if((*startPtr)!=NULL){

  002b8	8b 4d 08	 mov	 ecx, DWORD PTR _startPtr$[ebp]
  002bb	83 39 00	 cmp	 DWORD PTR [ecx], 0
  002be	74 53		 je	 SHORT $L53042

; 117  :                 curruntPtr=*startPtr;

  002c0	8b 55 08	 mov	 edx, DWORD PTR _startPtr$[ebp]
  002c3	8b 02		 mov	 eax, DWORD PTR [edx]
  002c5	89 45 fc	 mov	 DWORD PTR _curruntPtr$[ebp], eax
$L53041:

; 118  :                 while(curruntPtr!=NULL){

  002c8	83 7d fc 00	 cmp	 DWORD PTR _curruntPtr$[ebp], 0
  002cc	74 45		 je	 SHORT $L53042

; 119  :                    if((curruntPtr->CallDirection==2||curruntPtr->CallDirection==0)&&
; 120  :                       (curruntPtr->CallFloor<StatusFloor-1)&&(curruntPtr->CallFloor>GoalFloor))

  002ce	8b 4d fc	 mov	 ecx, DWORD PTR _curruntPtr$[ebp]
  002d1	83 39 02	 cmp	 DWORD PTR [ecx], 2
  002d4	74 08		 je	 SHORT $L53044
  002d6	8b 55 fc	 mov	 edx, DWORD PTR _curruntPtr$[ebp]
  002d9	83 3a 00	 cmp	 DWORD PTR [edx], 0
  002dc	75 2a		 jne	 SHORT $L53043
$L53044:
  002de	a1 00 00 00 00	 mov	 eax, DWORD PTR _StatusFloor
  002e3	83 e8 01	 sub	 eax, 1
  002e6	8b 4d fc	 mov	 ecx, DWORD PTR _curruntPtr$[ebp]
  002e9	39 41 04	 cmp	 DWORD PTR [ecx+4], eax
  002ec	7d 1a		 jge	 SHORT $L53043
  002ee	8b 55 fc	 mov	 edx, DWORD PTR _curruntPtr$[ebp]
  002f1	8b 42 04	 mov	 eax, DWORD PTR [edx+4]
  002f4	3b 05 00 00 00
	00		 cmp	 eax, DWORD PTR _GoalFloor
  002fa	7e 0c		 jle	 SHORT $L53043

; 121  :                       GoalFloor=curruntPtr->CallFloor;

  002fc	8b 4d fc	 mov	 ecx, DWORD PTR _curruntPtr$[ebp]
  002ff	8b 51 04	 mov	 edx, DWORD PTR [ecx+4]
  00302	89 15 00 00 00
	00		 mov	 DWORD PTR _GoalFloor, edx
$L53043:

; 122  :                    curruntPtr=curruntPtr->Nextptr;

  00308	8b 45 fc	 mov	 eax, DWORD PTR _curruntPtr$[ebp]
  0030b	8b 48 08	 mov	 ecx, DWORD PTR [eax+8]
  0030e	89 4d fc	 mov	 DWORD PTR _curruntPtr$[ebp], ecx

; 123  :                 }

  00311	eb b5		 jmp	 SHORT $L53041
$L53042:

; 128  : }         

  00313	5f		 pop	 edi
  00314	5e		 pop	 esi
  00315	5b		 pop	 ebx
  00316	8b e5		 mov	 esp, ebp
  00318	5d		 pop	 ebp
  00319	c3		 ret	 0
_ChangeGoalFloor ENDP
_TEXT	ENDS
EXTRN	_malloc:NEAR
;	COMDAT _ChangeCurrentFloor
_TEXT	SEGMENT
_startPtr$ = 8
_ChangeCurrentFloor PROC NEAR				; COMDAT

; 131  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 40	 sub	 esp, 64			; 00000040H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi
  00009	8d 7d c0	 lea	 edi, DWORD PTR [ebp-64]
  0000c	b9 10 00 00 00	 mov	 ecx, 16			; 00000010H
  00011	b8 cc cc cc cc	 mov	 eax, -858993460		; ccccccccH
  00016	f3 ab		 rep stosd

; 132  :      
; 133  :     if(State==0){

  00018	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _State, 0
  0001f	0f 85 b5 00 00
	00		 jne	 $L53048

; 134  :        if(GoalFloor!=0){

  00025	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _GoalFloor, 0
  0002c	0f 84 a3 00 00
	00		 je	 $L53054

; 135  :           if(StatusFloor==GoalFloor){

  00032	a1 00 00 00 00	 mov	 eax, DWORD PTR _StatusFloor
  00037	3b 05 00 00 00
	00		 cmp	 eax, DWORD PTR _GoalFloor
  0003d	75 4a		 jne	 SHORT $L53050

; 136  :              State=1;

  0003f	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _State, 1

; 137  :              CountTime=1;

  00049	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _CountTime, 1

; 138  :              *startPtr=malloc(sizeof(PAUSE));

  00053	6a 08		 push	 8
  00055	e8 00 00 00 00	 call	 _malloc
  0005a	83 c4 04	 add	 esp, 4
  0005d	8b 4d 08	 mov	 ecx, DWORD PTR _startPtr$[ebp]
  00060	89 01		 mov	 DWORD PTR [ecx], eax

; 139  :              (*startPtr)->PauseTime=Time;

  00062	8b 55 08	 mov	 edx, DWORD PTR _startPtr$[ebp]
  00065	8b 02		 mov	 eax, DWORD PTR [edx]
  00067	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _Time
  0006d	89 08		 mov	 DWORD PTR [eax], ecx

; 140  :              (*startPtr)->PauseFloor=StatusFloor;

  0006f	8b 55 08	 mov	 edx, DWORD PTR _startPtr$[ebp]
  00072	8b 02		 mov	 eax, DWORD PTR [edx]
  00074	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _StatusFloor
  0007a	89 48 04	 mov	 DWORD PTR [eax+4], ecx

; 141  :              GoalFloor=0;

  0007d	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _GoalFloor, 0

; 143  :           else{

  00087	eb 4c		 jmp	 SHORT $L53054
$L53050:

; 144  :              if(StatusFloor<GoalFloor){

  00089	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _StatusFloor
  0008f	3b 15 00 00 00
	00		 cmp	 edx, DWORD PTR _GoalFloor
  00095	7d 20		 jge	 SHORT $L53053

; 145  :                 State=2;

  00097	c7 05 00 00 00
	00 02 00 00 00	 mov	 DWORD PTR _State, 2

; 146  :                 CountTime=1;

  000a1	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _CountTime, 1

; 147  :                 CurrentDirection=1;

  000ab	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _CurrentDirection, 1

; 149  :              else{

  000b5	eb 1e		 jmp	 SHORT $L53054
$L53053:

; 150  :                 State=2;

  000b7	c7 05 00 00 00
	00 02 00 00 00	 mov	 DWORD PTR _State, 2

; 151  :                 CountTime=1;

  000c1	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _CountTime, 1

; 152  :                 CurrentDirection=2;

  000cb	c7 05 00 00 00
	00 02 00 00 00	 mov	 DWORD PTR _CurrentDirection, 2
$L53054:

; 157  :     else{

  000d5	e9 11 01 00 00	 jmp	 $L53069
$L53048:

; 158  :        if(CountTime==RunTime){               

  000da	a1 00 00 00 00	 mov	 eax, DWORD PTR _CountTime
  000df	3b 05 00 00 00
	00		 cmp	 eax, DWORD PTR _RunTime
  000e5	0f 85 f1 00 00
	00		 jne	 $L53056

; 159  :           if(State==1){

  000eb	83 3d 00 00 00
	00 01		 cmp	 DWORD PTR _State, 1
  000f2	75 69		 jne	 SHORT $L53057

; 160  :              if(GoalFloor!=0){

  000f4	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _GoalFloor, 0
  000fb	74 54		 je	 SHORT $L53058

; 161  : 				 if(GoalFloor==StatusFloor){

  000fd	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _GoalFloor
  00103	3b 0d 00 00 00
	00		 cmp	 ecx, DWORD PTR _StatusFloor
  00109	75 16		 jne	 SHORT $L53059

; 162  : 					 State=1;

  0010b	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _State, 1

; 163  : 				     GoalFloor=0;

  00115	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _GoalFloor, 0

; 165  : 				 else{

  0011f	eb 2e		 jmp	 SHORT $L53062
$L53059:

; 166  :                    State=2;

  00121	c7 05 00 00 00
	00 02 00 00 00	 mov	 DWORD PTR _State, 2

; 167  :                    if(StatusFloor<GoalFloor)

  0012b	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _StatusFloor
  00131	3b 15 00 00 00
	00		 cmp	 edx, DWORD PTR _GoalFloor
  00137	7d 0c		 jge	 SHORT $L53061

; 168  :                       CurrentDirection=1;

  00139	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _CurrentDirection, 1

; 169  :                    else

  00143	eb 0a		 jmp	 SHORT $L53062
$L53061:

; 170  :                       CurrentDirection=2;

  00145	c7 05 00 00 00
	00 02 00 00 00	 mov	 DWORD PTR _CurrentDirection, 2
$L53062:

; 173  :              else

  0014f	eb 0a		 jmp	 SHORT $L53063
$L53058:

; 174  :                 State=0;

  00151	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _State, 0
$L53063:

; 176  :           else{

  0015b	eb 73		 jmp	 SHORT $L53067
$L53057:

; 177  :                 if(CurrentDirection==1)

  0015d	83 3d 00 00 00
	00 01		 cmp	 DWORD PTR _CurrentDirection, 1
  00164	75 0f		 jne	 SHORT $L53065

; 178  :                    StatusFloor++;

  00166	a1 00 00 00 00	 mov	 eax, DWORD PTR _StatusFloor
  0016b	83 c0 01	 add	 eax, 1
  0016e	a3 00 00 00 00	 mov	 DWORD PTR _StatusFloor, eax

; 179  :                 else

  00173	eb 0f		 jmp	 SHORT $L53066
$L53065:

; 180  :                    StatusFloor--;

  00175	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _StatusFloor
  0017b	83 e9 01	 sub	 ecx, 1
  0017e	89 0d 00 00 00
	00		 mov	 DWORD PTR _StatusFloor, ecx
$L53066:

; 181  : 		        if(StatusFloor==GoalFloor){

  00184	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _StatusFloor
  0018a	3b 15 00 00 00
	00		 cmp	 edx, DWORD PTR _GoalFloor
  00190	75 3e		 jne	 SHORT $L53067

; 182  :                 State=1;

  00192	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _State, 1

; 183  :                 *startPtr=malloc(sizeof(PAUSE));

  0019c	6a 08		 push	 8
  0019e	e8 00 00 00 00	 call	 _malloc
  001a3	83 c4 04	 add	 esp, 4
  001a6	8b 4d 08	 mov	 ecx, DWORD PTR _startPtr$[ebp]
  001a9	89 01		 mov	 DWORD PTR [ecx], eax

; 184  :                 (*startPtr)->PauseTime=Time;

  001ab	8b 55 08	 mov	 edx, DWORD PTR _startPtr$[ebp]
  001ae	8b 02		 mov	 eax, DWORD PTR [edx]
  001b0	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _Time
  001b6	89 08		 mov	 DWORD PTR [eax], ecx

; 185  :                 (*startPtr)->PauseFloor=StatusFloor;

  001b8	8b 55 08	 mov	 edx, DWORD PTR _startPtr$[ebp]
  001bb	8b 02		 mov	 eax, DWORD PTR [edx]
  001bd	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _StatusFloor
  001c3	89 48 04	 mov	 DWORD PTR [eax+4], ecx

; 186  :                 GoalFloor=0;

  001c6	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _GoalFloor, 0
$L53067:

; 189  :           
; 190  :           CountTime=1;

  001d0	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _CountTime, 1

; 192  :        else{

  001da	eb 0f		 jmp	 SHORT $L53069
$L53056:

; 193  :           CountTime++;

  001dc	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _CountTime
  001e2	83 c2 01	 add	 edx, 1
  001e5	89 15 00 00 00
	00		 mov	 DWORD PTR _CountTime, edx
$L53069:

; 196  : }

  001eb	5f		 pop	 edi
  001ec	5e		 pop	 esi
  001ed	5b		 pop	 ebx
  001ee	83 c4 40	 add	 esp, 64			; 00000040H
  001f1	3b ec		 cmp	 ebp, esp
  001f3	e8 00 00 00 00	 call	 __chkesp
  001f8	8b e5		 mov	 esp, ebp
  001fa	5d		 pop	 ebp
  001fb	c3		 ret	 0
_ChangeCurrentFloor ENDP
_TEXT	ENDS
END