   bkptexec.c (21 Feb 1997 16:39:36)
           d:\tbird\bkptexec.c (04 Feb 1997 18:20:48)
===================
       8       8  |**     This server handles source and assembly level control of emulation
       9       9  |**     and breakpoints.
+             10  |**
-     10          |**                     
      11      11  |**  Status:  TESTED
      12      12  |**
+             13  |**  $Log:   S:/tbird/mt2_186/bkptexec/bkptexec.c_v  $
-     13          |**  $Log:   S:/tbird/arcm306/bkptexec/bkptexec.c_v  $
      14      14  |** 
+             15  |**    Rev 1.2   04 Feb 1997 18:20:48   Judy
-     15          |**    Rev 1.6   09 Sep 1996 09:32:58   kevin
-     16          |** hera's modification
      17      16  |** 
+             17  |**    Rev 1.1   13 Jan 1997 10:41:32   Judy
+             18  |** fixed a bug that can not set HW breakpoint after doing go_into_call 
-     18          |**    Rev 1.5   02 Aug 1996 13:19:06   kevin
-     19          |** To revise BxInserBkptNamesAndOffset and BxSetBkptWithIndex for supporting
-     20          |** ASM file.
      21      19  |** 
+             20  |**    Rev 1.0   16 Dec 1996 14:51:38   Judy
-     22          |**    Rev 1.1   23 Jul 1996 16:00:46   Judy
-     23          |** To revise BxInsertBkptNamesAndOffset and BxSetBkptWithIndex for supporting
-     24          |** ASM file load.
> (   27)     21  |** Initial revision.
      25      22  |** 
+             23  |**    Rev 1.82   21 Oct 1994 18:30:56   nghia
+             24  |** Revised BxSetSrcBkptFromCli to check for valid code address after looking
+             25  |** up for symbol information.  When symbols are protected mode symbols and
+             26  |** their bases are not yet updated, symbols look-up using linear address can
+             27  |** produce invalid symbol matching.  Also, revised bkptTable to skip over
+             28  |** allocate modRefName if module does not have any reference information.
+             29  |** Added check for valid bkptAddr before destroy the address.
-     26          |**    Rev 1.0   23 Jul 1996 13:51:26   Judy
<     27  (   21) |** Initial revision.
      28      30  |** 
+             31  |**    Rev 1.81   21 Oct 1994 09:02:24   nghia
+             32  |** Fixed event notification (Pmode) for reset while the processor is halted.
-     29          |**    Rev 1.4   03 Jan 1996 10:41:50   kevin
-     30          |** in BxEmul
-     31          |** in BxEmulStateChange(), using SdReadMemberNoInputCheck instead of
-     32          |** SdnReadMember
      33      33  |** 
+             34  |**    Rev 1.80   13 Oct 1994 13:13:32   nghia
+             35  |** Fixed PPR 9775.  enumRunningSpinFlag does not reset if error occurred in
+             36  |** the BxLLStartEmulation() routine.
-     34          |**    Rev 1.3   20 Dec 1995 15:23:56   kevin
-     35          |** modified addrhasnobkpt()
      36      37  |** 
+             38  |**    Rev 1.79   02 Aug 1994 18:33:46   nghia
+             39  |** Revised internal breakpoint setting to skip extracting symbol information to
+             40  |** speed up the step.
+             41  |** Fixed bug in GoUntil routine that destroy address descriptor that already
+             42  |** destroyed.
+             43  |** Revised the while(#) with it nested number for debugging purposes.
-     37          |**    Rev 1.2   11 Dec 1995 11:55:54   kevin
-     38          |** gene's modification: ssi/sso
      39      44  |** 
+             45  |**    Rev 1.78   28 Jul 1994 11:53:24   nghia
+             46  |** Fixed bug in set bkpt for ASM module that have line number without function
+             47  |** block.
+             48  |** Fixed classic Windows DLL bug - Callback function must have EXPORT.
-     40          |**    Rev 1.1   01 Dec 1995 10:54:46   kevin
-     41          |** joyce's modification
      42      49  |** 
+             50  |**    Rev 1.77   22 Jul 1994 14:28:26   john
+             51  |** Added changes made in 1.72.1.1
+             52  |** 
+             53  |**    Rev 1.76   12 Jul 1994 11:25:16   ernie
+             54  |** Changed firmware protocol for single-step.  The firmware now writes
+             55  |** to the SD_EMULATION_RESULT member only once, when the command is
+             56  |** completely done.  This allows the bkpt server to check for success
+             57  |** without a race condition.
+             58  |** 
+             59  |**    Rev 1.75   17 Jun 1994 15:30:22   dennis
+             60  |** Changed all breakpoint address descriptors to be linear.
+             61  |** 
+             62  |**    Rev 1.74   10 Jun 1994 11:25:20   dennis
+             63  |** Fix a bug where the breakpoints were not being removed when a program was
+             64  |** loaded without symbols.
+             65  |** 
+             66  |**    Rev 1.73   09 Jun 1994 13:41:56   dennis
+             67  |** Changed call from AdrGetAddrOffset to AdrGetAddrPhysicalOffset. This will
+             68  |** now use the segment and offset to calculate the physical offset.
-     43          |**    Rev 1.0   07 Sep 1995 10:04:32   gene
-     44          |** Initial revision.
      45      69  |** 
      46      70  |**    Rev 1.72   06 Apr 1994 16:46:24   nghia
===================
      87     111  |**    Rev 1.63   09 Jun 1993 09:05:48   ernie
      88     112  |** Performance enhancements:
+            113  |** 1. Eliminated EVENT_BX_LL_* events and moved processing for those
-     89          |** 1. Eliminated BX_LL_* events and moved processing for those
      90     114  |**    events directly into BxEmulStateChange().
      91     115  |** 2. Rearchitected SrcStep() to use fewer emulation sessions and use
===================
     139     163  |** Fixed: bug in EVENT_BKPT_EDIT reporting when temp internal bkpt removed
     140     164  |**
+            165  |**    Rev 1.52   08 Dec 1992 06:51:32   bruce
-    141          |**    Rev 1.52   08 Dec 1992 06:51:32   brucea
     142     166  |** Changed: BxGetBkptCount from BxAnyBkptsSet which now returns number of
     143     167  |**    current bkpts set, minus any internal temporaries
===================
     461     485  |** Initial revision.
     462     486  |**
+            487  |**  $Header:   S:/tbird/mt2_186/bkptexec/bkptexec.c_v   1.2   04 Feb 1997 18:20:48   Judy  $
-    463          |**  $Header:   S:/tbird/arcm306/bkptexec/bkptexec.c_v   1.6   09 Sep 1996 09:32:58   kevin  $
     464     488  |**
     465     489  |**  Copyright (C) 1991,92 Microtek International.  All rights reserved.
===================
     468     492  |
     469     493  |
+            494  |               /****************************
+            495  |            *                          *
+            496  |            *       INCLUDE FILES      *
+            497  |            *                          *
+            498  |            ****************************/
-    470          |                       /****************************
-    471          |                        *                          *
-    472          |                        *       INCLUDE FILES      *
-    473          |                        *                          *
-    474          |                        ****************************/
     475     499  |#ifndef _ADDR_
     476     500  |#include "addr.h"
===================
     557     581  |#endif
     558     582  |
+            583  |#ifndef _TBIRDMEM_
+            584  |#include "tbirdmem.h"
+            585  |#endif
-    559          |                       /****************************
-    560          |                        *                          *
-    561          |                        *     GLOBAL DEFINITIONS   *
-    562          |                        *                          *
-    563          |                        ****************************/
> ( 3798)    586  |
+            587  |#define ICE_USER_HALT -13
> ( 3793)    588  |
+            589  |RETCODE EXPORT iceGetCpuStatus(U8 *goEnd);
+            590  |RETCODE EXPORT iceRunUntil(U32 addr);
+            591  |RETCODE EXPORT iceStepRange(U32 addr1, U32 addr2);
+            592  |RETCODE EXPORT Sds2AbiFwUnloadRegisters(BOOLEAN patchPCSP);
+            593  |RETCODE EXPORT Sds2AbiFwLoadRegisters(VOID);
+            594  |VOID GetReturnPC(U32 *retPC, BOOLEAN *inValid);
+            595  |RETCODE EXPORT iceGetMemN(U32 addr, U8 *buff, U16 len);
> ( 3778)    596  |
+            597  |               /****************************
+            598  |            *                          *
+            599  |            *     GLOBAL DEFINITIONS   *
+            600  |            *                          *
+            601  |            ****************************/
     564     602  |
     565     603  |#undef DEBUG
===================
     568     606  |extern HANDLE cliServerHandle;  /* return address for CLI results */
     569     607  |
+            608  |               /****************************
+            609  |            *                          *
+            610  |            *     LOCAL DEFINITIONS    *
+            611  |            *                          *
+            612  |            ****************************/
+            613  |CHAR dummyNameStr[MAX_SYMNAME_LENGTH] = "";
-    570          |                       /****************************
-    571          |                        *                          *
-    572          |                        *     LOCAL DEFINITIONS    *
-    573          |                        *                          *
-    574          |                        ****************************/
     575     614  |
+            615  |               /****************************
+            616  |            *                          *
+            617  |            *     LOCAL STORAGE        *
+            618  |            *                          *
+            619  |            ****************************/
-    576          |                       /****************************
-    577          |                        *                          *
-    578          |                        *     LOCAL STORAGE        *
-    579          |                        *                          *
-    580          |                        ****************************/
     581     620  |/*
     582     621  |** the current breakpoint table
     583     622  |*/
     584     623  |BX_BREAKPOINT bkptTable[MAX_NUM_BKPT];
     585     624  |RETCODE       globalEscPushed;   /* returns ESC error if happened
+            625  |                    while in call-back */
-    586          |                                    while in call-back */
     587     626  |
     588     627  |
===================
     605     644  |   BX_GO_STEP
     606     645  |} BX_GO_TYPE;
> ( 3770)    646  |
+            647  |typedef struct {
+            648  |   SYM_DESCRIPTOR functionDesc;
+            649  |   SYM_DESCRIPTOR moduleDesc;
+            650  |   LPSTR funcNamePtr;
+            651  |   FUNC_CLASS funcClass;
+            652  |   U32 stackSize;
+            653  |   DESCRIPTOR funcAddrRangeDesc;
+            654  |   U8 frameType;
+            655  |   U32 pushMask;
+            656  |   U8 numParams;
+            657  |   SYM_DESCRIPTOR firstLocal;
+            658  |   U16 localListCount;
+            659  |   U8 funcName[80];
+            660  |} FUNC_INFO_TYPE;
     607     661  |
     608     662  |/*----------------------------------------------------------
===================
     671     725  |PRIVATE DESCRIPTOR haltDesc;
     672     726  |PRIVATE DESCRIPTOR bkAddrDesc, bkSpaceDesc, bkIdDesc, bkCmdDesc,
+            727  |           bkEnableDesc, bkResultDesc;
-    673          |                   bkEnableDesc, bkResultDesc;
     674     728  |
     675     729  |/*------------------------------------------------------------------------
===================
     685     739  |PRIVATE BOOLEAN demonstrationVersion = FALSE;
     686     740  |
+            741  |               /****************************
+            742  |            *                          *
+            743  |            *        PROTOTYPES        *
+            744  |            *                          *
+            745  |            ****************************/
-    687          |                       /****************************
-    688          |                        *                          *
-    689          |                        *        PROTOTYPES        *
-    690          |                        *                          *
-    691          |                        ****************************/
     692     746  |
     693     747  |/*---------------------------------------------------------------------------
===================
     699     753  |RETCODE PRIVATE
     700     754  |BxGetSrcAddressRange(DESCRIPTOR     currentPC,
+            755  |             BX_GRANULARITY granularity,
+            756  |             DESCRIPTOR FAR *rangeDesc);
-    701          |                     BX_GRANULARITY granularity,
-    702          |                     DESCRIPTOR FAR *rangeDesc);
     703     757  |
     704     758  |/*---------------------------------------------------------------------------
===================
     726     780  |RETCODE PRIVATE
     727     781  |BxLocalGoUntilCallReturn(BX_GRANULARITY      gran,
+            782  |             BX_CALL_RETURN_TYPE callReturnType);
-    728          |                         BX_CALL_RETURN_TYPE callReturnType);
     729     783  |
     730     784  |/*---------------------------------------------------------------------------
===================
     750     804  |** BxEmulStateChange
     751     805  |----------------------------------------------------------------------------*/
+            806  |VOID EXPORT BxEmulStateChange(DESCRIPTOR desc);
-    752          |VOID FAR PASCAL BxEmulStateChange(DESCRIPTOR desc);
     753     807  |
     754     808  |/*---------------------------------------------------------------------------
===================
     825     879  |RETCODE PRIVATE BxIsFunction(DESCRIPTOR addrDesc, BOOLEAN *isFunc);
     826     880  |
-    827          |PRIVATE RETCODE BxSetAddrSpace(DESCRIPTOR addrDesc);
     828     881  |RETCODE InitStepMask(VOID);
     829     882  |
+            883  |            /****************************
+            884  |             *                          *
+            885  |             *      EXECUTABLE CODE     *
+            886  |             *                          *
+            887  |             ****************************/
-    830          |                        /****************************
-    831          |                         *                          *
-    832          |                         *      EXECUTABLE CODE     *
-    833          |                         *                          *
-    834          |                         ****************************/
     835     888  |
     836     889  |/*----------------------------------------------------------------------
===================
     846     899  |   HeapDump(&amountAllocated, &amountFreed);
     847     900  |   sprintf((LPSTR)buff, (LPSTR)"Allocated: %ld, Freed: %ld, Active: %ld",
+            901  |       amountAllocated, amountFreed, amountAllocated-amountFreed);
-    848          |           amountAllocated, amountFreed, amountAllocated-amountFreed);
     849     902  |   BxSendCliMessage((LPSTR)buff);
     850     903  |   return GOOD;
===================
     868     921  |   lpEmulProc = MakeProcInstance((FARPROC) BxEmulStateChange, hLib);
     869     922  |   if((err = SdRegister(SD_EMULATION_STATE,
+            923  |            lpEmulProc,
+            924  |            &emulStateDesc))!=GOOD)
-    870          |                        lpEmulProc,
-    871          |                        &emulStateDesc))!=GOOD)
     872     925  |      return err;
     873     926  |   if((err = SdRegister(SD_EMULATION_RESULT,
+            927  |            NULL,
+            928  |            &emulResultDesc))!=GOOD)
-    874          |                        NULL,
-    875          |                        &emulResultDesc))!=GOOD)
     876     929  |      return err;
     877     930  |   if((err = SdRegister(SD_STEP, NULLPTR, &singleStepDesc))!=GOOD)
===================
     897     950  |      BOOLEAN timedOut;
     898     951  |      if((err = SdWriteCmdReadResponse(bkCmdDesc, (U8 FAR *)&bkptCmd, GOOD,
+            952  |     bkResultDesc, 0L, &timedOut)) != GOOD) return(err);
-    899          |         bkResultDesc, 0L, &timedOut)) != GOOD) return(err);
     900     953  |   }
     901     954  |
     902     955  |   /* register to receive events from ... */
     903     956  |   lpBxCallback = MakeProcInstance((FARPROC) BxCallback, hLib);
     904     957  |   if ((err = EnlRegister(EVENT_SYMBOL_INIT_LOAD,
+            958  |              (EVCALLBACK) lpBxCallback,
+            959  |              &descEvt))!=GOOD)
-    905          |                          (EVCALLBACK) lpBxCallback,
-    906          |                          &descEvt))!=GOOD)
     907     960  |      return err;
     908     961  |   if ((err = EnlRegister(EVENT_SYMBOL_DELETED,
+            962  |              (EVCALLBACK) lpBxCallback,
+            963  |              &descEvt))!=GOOD)
-    909          |                          (EVCALLBACK) lpBxCallback,
-    910          |                          &descEvt))!=GOOD)
     911     964  |      return err;
     912     965  |   /* base addr modified */
     913     966  |   if ((err = EnlRegister(EVENT_SYMBOL_BASE_CHANGED,
+            967  |              (EVCALLBACK) lpBxCallback,
+            968  |              &descEvt))!=GOOD)
-    914          |                          (EVCALLBACK) lpBxCallback,
-    915          |                          &descEvt))!=GOOD)
     916     969  |      return err;
     917     970  |   if ((err = EnlRegister(EVENT_BKPT_HALTED,
+            971  |              (EVCALLBACK) lpBxCallback,
+            972  |              &descEvt))!=GOOD)
-    918          |                          (EVCALLBACK) lpBxCallback,
-    919          |                          &descEvt))!=GOOD)
> ( 3255)    973  |      return err;
> ( 3215)    974  |
+            975  |   /*               Modified by Dennis Lamb, June 10, 1994.           */
+            976  |   /* Added this to handle the case where a program is loaded without */
+            977  |   /* any symbols. This fixes a bug where the breakpoints were not    */
+            978  |   /* removed when the program was loaded without symbols.            */
+            979  |   if ((err = EnlRegister(EVENT_LDR_LOADCOMPLETE,
+            980  |              (EVCALLBACK) lpBxCallback,
+            981  |              &descEvt))!=GOOD)
     920     982  |      return err;
     921     983  |
===================
     984    1046  |      /* !!! needs to be the event which occurs when the load is complete */
     985    1047  |      /* eventually want to recalculate symbolic bkpts when new load done;
+           1048  |     this requires saving module/func name, func size, plus offset from
+           1049  |     start of function in order to recalculate bkpt from function
+           1050  |     beginning.  The criteria for recalculating symbolic bkpts is if the
+           1051  |     function size hasn't changed */
+           1052  |      /* Added EVENT_LDR_LOADCOMPLETE to handle the situation when a program
+           1053  |         is loaded without symbols. */
+           1054  |      case EVENT_LDR_LOADCOMPLETE:
-    986          |         this requires saving module/func name, func size, plus offset from
-    987          |         start of function in order to recalculate bkpt from function
-    988          |         beginning.  The criteria for recalculating symbolic bkpts is if the
-    989          |         function size hasn't changed */
     990    1055  |      case EVENT_SYMBOL_INIT_LOAD:
+           1056  |     err = BxRemoveAllBkpts();
+           1057  |        if (err) {
+           1058  |           ErrDisplayError(err, CHECK_MODE);
+           1059  |        }
+           1060  |        break;
-    991          |         err = BxRemoveAllBkpts();
-    992          |            if (err) {
-    993          |               ErrDisplayError(err, CHECK_MODE);
<    994  ( 2781) |            }
-    995          |            break;
     996    1061  |
     997    1062  |      case EVENT_SYMBOL_DELETED:
     998    1063  |      case EVENT_SYMBOL_BASE_CHANGED:
+           1064  |     /* !!! for now, remove all bkpts; eventually must tag bkpt with flag
+           1065  |        indicating no symbols; then recalc when symbols reloaded */
+           1066  |     err = BxRemoveAllBkpts();
+           1067  |        if (err) {
+           1068  |           ErrDisplayError(err, CHECK_MODE);
+           1069  |        }
+           1070  |     break;
-    999          |         /* !!! for now, remove all bkpts; eventually must tag bkpt with flag
-   1000          |            indicating no symbols; then recalc when symbols reloaded */
-   1001          |         err = BxRemoveAllBkpts();
-   1002          |            if (err) {
-   1003          |               ErrDisplayError(err, CHECK_MODE);
-   1004          |            }
<   1005  ( 2784) |         break;
    1006    1071  |
    1007    1072  |      case EVENT_BKPT_HALTED: /* HL emulation halted */
+           1073  |     /* display address and next instruction if in CLI */
+           1074  |     if (GOOD != (firstErr = CLIGetActive(&hCLIModule))) {
+           1075  |        goto CLEANUP_1;
+           1076  |     }
+           1077  |     if (!hCLIModule) {
+           1078  |        break;  /* not in CLI */
+           1079  |     } else {
+           1080  |        if (GOOD !=
+           1081  |           (firstErr = CpuGetPC(&currentPCDesc))) { /* alloc's addr */
+           1082  |           goto CLEANUP_1;
+           1083  |        }
+           1084  |        if (GOOD != (firstErr = DadSetDasmAddr(dasmID, currentPCDesc))) {
+           1085  |           goto CLEANUP_2;
+           1086  |        }
+           1087  |        /* disassemble next instruction */
+           1088  |        /* buf storage is alloc'ed by this call; must be TFree'd
+           1089  |           before leaving function */
+           1090  |        if (GOOD !=
+           1091  |           (firstErr = DadDasmInst(dasmID, 1, &buf, &bufLength))) {
+           1092  |           goto CLEANUP_2;
+           1093  |        }
+           1094  |        /* send out the text */
+           1095  |        firstErr = BxSendCliMessage(buf);
+           1096  |     }
+           1097  |     err = TFree((LPSTR)(buf));
-   1008          |         /* display address and next instruction if in CLI */
-   1009          |         if (GOOD != (firstErr = CLIGetActive(&hCLIModule))) {
-   1010          |            goto CLEANUP_1;
<   1011  ( 2783) |         }
-   1012          |         if (!hCLIModule) {
-   1013          |            break;  /* not in CLI */
-   1014          |         } else {
-   1015          |            if (GOOD !=
-   1016          |               (firstErr = CpuGetPC(&currentPCDesc))) { /* alloc's addr */
-   1017          |               goto CLEANUP_1;
-   1018          |            }
-   1019          |            if (GOOD != (firstErr = DadSetDasmAddr(dasmID, currentPCDesc))) {
-   1020          |               goto CLEANUP_2;
-   1021          |            }
-   1022          |            /* disassemble next instruction */
-   1023          |            /* buf storage is alloc'ed by this call; must be TFree'd
-   1024          |               before leaving function */
-   1025          |            if (GOOD !=
-   1026          |               (firstErr = DadDasmInst(dasmID, 1, &buf, &bufLength))) {
-   1027          |               goto CLEANUP_2;
-   1028          |            }
-   1029          |            /* send out the text */
-   1030          |            firstErr = BxSendCliMessage(buf);
-   1031          |         }
-   1032          |         err = TFree((LPSTR)(buf));
    1033    1098  |
    1034    1099  |      CLEANUP_2:
+           1100  |     err = AdrDestroyAddress(currentPCDesc);
+           1101  |     if (GOOD == firstErr)
+           1102  |        firstErr = err;
-   1035          |         err = AdrDestroyAddress(currentPCDesc);
-   1036          |         if (GOOD == firstErr)
-   1037          |            firstErr = err;
    1038    1103  |
    1039    1104  |      CLEANUP_1:
+           1105  |     if (GOOD != firstErr) {
+           1106  |        if (ER_ABORT_FROM_ESC == firstErr) {
+           1107  |           globalEscPushed = ER_ABORT_FROM_ESC;
+           1108  |        } else {
+           1109  |           ErrDisplayError(firstErr, CHECK_MODE);
+           1110  |        }
+           1111  |     }
+           1112  |     break;
-   1040          |         if (GOOD != firstErr) {
-   1041          |            if (ER_ABORT_FROM_ESC == firstErr) {
-   1042          |               globalEscPushed = ER_ABORT_FROM_ESC;
-   1043          |            } else {
-   1044          |               ErrDisplayError(firstErr, CHECK_MODE);
-   1045          |            }
-   1046          |         }
-   1047          |         break;
    1048    1113  |
    1049    1114  |      default:
+           1115  |     ErrDisplayError(ER_BX_INVALID_CALLBACK, CHECK_MODE);
-   1050          |         ErrDisplayError(ER_BX_INVALID_CALLBACK, CHECK_MODE);
    1051    1116  |
    1052    1117  |   } /* end of switch */
===================
    1096    1161  |RETCODE EXPORT
    1097    1162  |BxSetSrcBkpt(BX_BPSTATE     state,
+           1163  |         BX_BPLIFE      life,
+           1164  |         SYM_DESCRIPTOR module,
+           1165  |         LINENUM_TYPE   lineNum,
+           1166  |         COLUMN_TYPE    columnStart,
+           1167  |         LPSTR          lineText,
+           1168  |         DESCRIPTOR     bkptRangeDesc,
+           1169  |         DESCRIPTOR FAR *desc) {
-   1098          |             BX_BPLIFE      life,
-   1099          |             SYM_DESCRIPTOR module,
-   1100          |             LINENUM_TYPE   lineNum,
-   1101          |             COLUMN_TYPE    columnStart,
-   1102          |             LPSTR          lineText,
-   1103          |             DESCRIPTOR     bkptRangeDesc,
-   1104          |             DESCRIPTOR FAR *desc) {
    1105    1170  |
    1106    1171  |   RETCODE            err;
===================
    1114    1179  |   U32                symbolOffset;
    1115    1180  |   U16                bufLen;
+           1181  |   BOOLEAN            dummy;
    1116    1182  |
    1117    1183  |   if((err = BkProcessorMustBeHaltedAbsolute())!=GOOD)
===================
    1120    1186  |   /* remove processor dependency */
    1121    1187  |   if (FAMILY_68K == staticProcFamily) {
+           1188  |      if((err = AdrSetAddrSpace(bkptRangeDesc, SPACE_SP)) != GOOD) {
+           1189  |     AdrDestroyAddress(bkptRangeDesc);
+           1190  |     return err;
-   1122          |      if((err = BxSetAddrSpace(bkptRangeDesc)) != GOOD) {
-   1123          |         AdrDestroyAddress(bkptRangeDesc);
-   1124          |         return err;
    1125    1191  |      }
    1126    1192  |   }
    1127    1193  |   /* Get Bkpt address range */
    1128    1194  |   if (columnStart)  {
    1129    1195  |      if((err = SymGetLinenumStmt(module, lineNum, columnStart, bkptRangeDesc,
+           1196  |                  &actualLineNum, &columnRange, &nextIndex))
+           1197  |     !=GOOD) {
+           1198  |     AdrDestroyAddress(bkptRangeDesc);
+           1199  |     return err;
-   1130          |                                  &actualLineNum, &columnRange, &nextIndex))
-   1131          |         !=GOOD) {
-   1132          |         AdrDestroyAddress(bkptRangeDesc);
-   1133          |         return err;
    1134    1200  |      }
    1135    1201  |   } else {
    1136    1202  |      if((err = SymGetLinenum(module, lineNum, bkptRangeDesc, &actualLineNum,
+           1203  |                  &(columnRange.columnStart), &nextIndex))
+           1204  |     !=GOOD) {
+           1205  |     AdrDestroyAddress(bkptRangeDesc);
+           1206  |     return err;
-   1137          |                              &(columnRange.columnStart), &nextIndex))
-   1138          |         !=GOOD) {
-   1139          |         AdrDestroyAddress(bkptRangeDesc);
-   1140          |         return err;
    1141    1207  |      }
    1142    1208  |      /* fill in end range, since SymGetLinenum doesn't */
    1143    1209  |      columnRange.columnEnd = SYM_MAX_COLUMN;
    1144    1210  |   }
> ( 1730)   1211  |
+           1212  |   /* Convert bkptRangeDesc to ADDR_LINEAR type */
+           1213  |   if ((err = AdrConvertAddress(bkptRangeDesc, ADDR_LINEAR, 
+           1214  |        (BOOLEAN FAR *)&dummy)) != GOOD) {
+           1215  |      AdrDestroyAddress(bkptRangeDesc);
> ( 3214)   1216  |      return err;
> ( 1809)   1217  |   }
> ( 1706)   1218  |
    1145    1219  |   /* Check for Location already has breakpoint and bkpt availability */
    1146    1220  |   if ((err = AddrHasNoBkpt(bkptRangeDesc, life)) != GOOD) {
===================
    1175    1249  |   /* look up module, function by address                    */
    1176    1250  |   err = SymMapAddr2Symbol(bkptRangeDesc,
+           1251  |               &memoryClass,
+           1252  |               &symbolType,
+           1253  |               &symbolOffset,
+           1254  |               &lowestLevelDesc,
+           1255  |               &functionDesc,
+           1256  |               &moduleDesc);
-   1177          |                           &memoryClass,
-   1178          |                           &symbolType,
-   1179          |                           &symbolOffset,
-   1180          |                           &lowestLevelDesc,
-   1181          |                           &functionDesc,
-   1182          |                           &moduleDesc);
    1183    1257  |   if (err != GOOD) {
    1184    1258  |      /* fall out if the symbol lookup is not found; means that no
+           1259  |     symbolics attached to bkpt */
-   1185          |         symbolics attached to bkpt */
    1186    1260  |      if (ER_ADDRESS_NOT_FOUND != err) { /* error but not NOT_FOUND err */
+           1261  |     return err;
-   1187          |         return err;
    1188    1262  |      }
    1189    1263  |   } else { /* good symbol lookup */
    1190    1264  |      bkptTable[index].function = functionDesc;  /* could be NULL_SYMBOL */
    1191    1265  |      if (moduleDesc != NULL_SYMBOL) {
+           1266  |     if (GOOD != (err = BxInsertBkptNamesAndOffset(index)))
+           1267  |        return err;
-   1192          |         if (GOOD != (err = BxInsertBkptNamesAndOffset(index)))
-   1193          |            return err;
    1194    1268  |      }
    1195    1269  |   } /* end of symbol stuffing */
===================
    1229    1303  |   if (bkptTable[index].state == BX_ENABLED) {  /* only program if enabled */
    1230    1304  |      if (GOOD != (err = BkptProgramBkpt(index))) {
+           1305  |     /* if failed, clear breakpoint */
+           1306  |     BxRemoveBkpt(*desc);
+           1307  |     return err;
-   1231          |         /* if failed, clear breakpoint */
-   1232          |         if (err == ER_TOO_MANY_XBRKS) {
-   1233          |            (VOID)BxRemoveBkpt(*desc);
-   1234          |         }
-   1235          |         return err;
    1236    1308  |      }
    1237    1309  |   }
===================
    1262    1334  |RETCODE
    1263    1335  |BxSetSrcBkptFromCli(BKPT_INDEX     index,
+           1336  |            BX_BPSTATE     state,
+           1337  |            BX_BPLIFE      life,
+           1338  |            SYM_DESCRIPTOR symbol,   /* may not be a module */
+           1339  |            LINENUM_TYPE   actualLinenum,
+           1340  |            COLUMN_TYPE    actualColumnStart,
+           1341  |            COLUMN_TYPE    actualColumnEnd,
+           1342  |            LPSTR          lineText,
+           1343  |            DESCRIPTOR     bkptAddr,
+           1344  |            U16            cliBkptNum,
+           1345  |            DESCRIPTOR FAR *desc)  {
-   1264          |                    BX_BPSTATE     state,
-   1265          |                    BX_BPLIFE      life,
-   1266          |                    SYM_DESCRIPTOR symbol,   /* may not be a module */
-   1267          |                    LINENUM_TYPE   actualLinenum,
-   1268          |                    COLUMN_TYPE    actualColumnStart,
-   1269          |                    COLUMN_TYPE    actualColumnEnd,
-   1270          |                    LPSTR          lineText,
-   1271          |                    DESCRIPTOR     bkptAddr,
-   1272          |                    U16            cliBkptNum,
-   1273          |                    DESCRIPTOR FAR *desc)  {
    1274    1346  |
    1275    1347  |   RETCODE        err;
===================
    1279    1351  |   SYM_TYPE_TYPE  symbolType;
    1280    1352  |   U32            symbolOffset;
+           1353  |   BOOLEAN        isValid, dummy;
-   1281          |   BOOLEAN        isValid;
    1282    1354  |
    1283    1355  |   if((err = BkProcessorMustBeHaltedAbsolute())!=GOOD)
    1284    1356  |      return err;
+           1357  |       
+           1358  |   /* Convert bkptRangeDesc to ADDR_LINEAR type */
+           1359  |   if ((err = AdrConvertAddress(bkptAddr, ADDR_LINEAR, 
+           1360  |        (BOOLEAN FAR *)&dummy)) != GOOD)  return err;
-   1285          |   if(GOOD !=
> ( 1702)   1361  |
+           1362  |   if (GOOD !=
    1286    1363  |      (err = AdrIsValidCodeAddress(bkptAddr, (BOOLEAN FAR *)&isValid)))
    1287    1364  |      return err;
===================
    1303    1380  |   bkptTable[index].columnRange.columnStart = actualColumnStart;
    1304    1381  |   bkptTable[index].columnRange.columnEnd = actualColumnEnd;
+           1382  |   bkptTable[index].module = NULL_SYMBOL;
    1305    1383  |
    1306    1384  |   /*---------------------*/
===================
    1310    1388  |   /* look up module, function by address */
    1311    1389  |   err = SymMapAddr2Symbol(bkptAddr,
+           1390  |               &memoryClass,
+           1391  |               &symbolType,
+           1392  |               &symbolOffset,
+           1393  |               &lowestLevelDesc,
+           1394  |               &functionDesc,
+           1395  |               &moduleDesc);
-   1312          |                           &memoryClass,
-   1313          |                           &symbolType,
-   1314          |                           &symbolOffset,
-   1315          |                           &lowestLevelDesc,
-   1316          |                           &functionDesc,
-   1317          |                           &moduleDesc);
> ( 1810)   1396  |   
    1318    1397  |   if (GOOD != err) {
+           1398  |      // fall out if the symbol lookup is not found; means that no
+           1399  |      // symbolics attached to bkpt
+           1400  |      // error but not NOT_FOUND err. This is OK for Assembly module
+           1401  |      if (ER_ADDRESS_NOT_FOUND != err) { 
+           1402  |     return err;
+           1403  |      }
-   1319          |      /* fall out if the symbol lookup is not found; means that no
-   1320          |         symbolics attached to bkpt */
-   1321          |      bkptTable[index].module = NULL_SYMBOL;
> ( 1674)   1404  |   } else { /* good symbol lookup */
+           1405  |      if (memoryClass == CODE_ADDR) {
+           1406  |     bkptTable[index].module = moduleDesc;
+           1407  |     bkptTable[index].function = functionDesc;  /* could be NULL_SYMBOL */
+           1408  |     if (moduleDesc != NULL_SYMBOL) {
+           1409  |        if (GOOD != (err = BxInsertBkptNamesAndOffset(index)))
+           1410  |           return err;
+           1411  |     }
<   1322  ( 1735) |      if (ER_ADDRESS_NOT_FOUND != err) { /* error but not NOT_FOUND err */
-   1323          |         return err;
<   1324  ( 1737) |      }
<   1325  ( 1738) |   } else { /* good symbol lookup */
-   1326          |      bkptTable[index].module = moduleDesc;
-   1327          |      bkptTable[index].function = functionDesc;  /* could be NULL_SYMBOL */
-   1328          |      if (moduleDesc != NULL_SYMBOL) {
-   1329          |         if (GOOD != (err = BxInsertBkptNamesAndOffset(index)))
-   1330          |            return err;
    1331    1412  |      }
    1332    1413  |   } /* end of symbol stuffing */
===================
    1355    1436  |   if (bkptTable[index].state == BX_ENABLED) {  /* only program if enabled */
    1356    1437  |      if (GOOD != (err = BkptProgramBkpt(index))) {
+           1438  |     /* if failed, clear breakpoint */
+           1439  |     BxRemoveBkpt(*desc);
+           1440  |     return err;
-   1357          |         /* if failed, clear breakpoint */
-   1358          |         if (err == ER_TOO_MANY_XBRKS) {
-   1359          |            (VOID)BxRemoveBkpt(*desc);
-   1360          |         }
-   1361          |         return err;
    1362    1441  |      }
    1363    1442  |   }
===================
    1371    1450  |----------------------------------------------------------------------------*/
    1372    1451  |RETCODE EXPORT BxGetSrcBkpt(DESCRIPTOR         desc,
+           1452  |                BX_BPSTATE FAR     *state,
+           1453  |                BX_BPLIFE FAR      *life,
+           1454  |                SYM_DESCRIPTOR FAR *module,
+           1455  |                LINENUM_TYPE FAR   *linenum,
+           1456  |                COLUMN_TYPE FAR    *columnStart,
+           1457  |                COLUMN_TYPE FAR    *columnEnd) {
-   1373          |                            BX_BPSTATE FAR     *state,
-   1374          |                            BX_BPLIFE FAR      *life,
-   1375          |                            SYM_DESCRIPTOR FAR *module,
-   1376          |                            LINENUM_TYPE FAR   *linenum,
-   1377          |                            COLUMN_TYPE FAR    *columnStart,
-   1378          |                            COLUMN_TYPE FAR    *columnEnd) {
    1379    1458  |
    1380    1459  |   if ((BKPT_INDEX)desc >= MAX_NUM_BKPT)
===================
    1397    1476  |----------------------------------------------------------------------------*/
    1398    1477  |RETCODE EXPORT BxGetSrcBkptNames(DESCRIPTOR     desc,
+           1478  |                 DESCRIPTOR FAR *modRefName,
+           1479  |                 DESCRIPTOR FAR *modName,
+           1480  |                 DESCRIPTOR FAR *functionName) {
-   1399          |                                 DESCRIPTOR FAR *modRefName,
-   1400          |                                 DESCRIPTOR FAR *modName,
-   1401          |                                 DESCRIPTOR FAR *functionName) {
    1402    1481  |
    1403    1482  |   if ((BKPT_INDEX)desc >= MAX_NUM_BKPT)
===================
    1428    1507  |RETCODE EXPORT
    1429    1508  |BxGetSrcBkptNext(SYM_DESCRIPTOR moduleFilter,
+           1509  |         DESCRIPTOR FAR *loopDesc,
+           1510  |         DESCRIPTOR FAR *bkptDesc)  {
-   1430          |                 DESCRIPTOR FAR *loopDesc,
-   1431          |                 DESCRIPTOR FAR *bkptDesc)  {
    1432    1511  |
    1433    1512  |   if (moduleFilter == NULL_SYMBOL)
===================
    1436    1515  |   while (TRUE)  {
    1437    1516  |      if (*loopDesc >= MAX_NUM_BKPT) /* loopDesc is 0-based index */
+           1517  |     return ER_BX_LOOP_COMPLETE;
-   1438          |         return ER_BX_LOOP_COMPLETE;
    1439    1518  |
    1440    1519  |      if ((bkptTable[(BKPT_INDEX)(*loopDesc)].module == moduleFilter) &&
+           1520  |      (bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_NOT_BEING_USED) &&
+           1521  |      (bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_SET_INTERNAL)) {
+           1522  |     *bkptDesc = *loopDesc;
+           1523  |     (*loopDesc)++;
+           1524  |     return GOOD;
-   1441          |          (bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_NOT_BEING_USED) &&
-   1442          |          (bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_SET_INTERNAL)) {
-   1443          |         *bkptDesc = *loopDesc;
-   1444          |         (*loopDesc)++;
-   1445          |         return GOOD;
    1446    1525  |      }
    1447    1526  |      (*loopDesc)++;
===================
    1464    1543  |RETCODE EXPORT
    1465    1544  |BxGetBkptByAddressNext(DESCRIPTOR addrDesc,
+           1545  |               DESCRIPTOR FAR *loopDesc,
+           1546  |               DESCRIPTOR FAR *bkptDesc) {
-   1466          |                       DESCRIPTOR FAR *loopDesc,
-   1467          |                       DESCRIPTOR FAR *bkptDesc) {
    1468    1547  |   RETCODE err;
    1469    1548  |   BOOLEAN isInRange;
    1470    1549  |
    1471    1550  |   while (TRUE)  {
    1472    1551  |      if (*loopDesc >= MAX_NUM_BKPT) /* loopDesc is 0-based index */
+           1552  |     return ER_BX_LOOP_COMPLETE;
-   1473          |         return ER_BX_LOOP_COMPLETE;
    1474    1553  |
    1475    1554  |      if ((bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_NOT_BEING_USED) &&
+           1555  |      (bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_SET_INTERNAL)) {
+           1556  |     err = AdrIsPhysicalAddrInRange(
+           1557  |                bkptTable[(BKPT_INDEX)(*loopDesc)].addr,
+           1558  |                addrDesc,
+           1559  |                &isInRange);
+           1560  |     if (GOOD != err) {
+           1561  |        /* make sure caller won't continue to loop in case they don't
+           1562  |           check for error condition */
+           1563  |        *loopDesc = MAX_NUM_BKPT;
+           1564  |        return err;
+           1565  |     }
+           1566  |     if (isInRange) {
+           1567  |        *bkptDesc = *loopDesc;
+           1568  |        (*loopDesc)++;
+           1569  |        return GOOD;
+           1570  |     }
-   1476          |          (bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_SET_INTERNAL)) {
-   1477          |         err = AdrIsPhysicalAddrInRange(
-   1478          |                                bkptTable[(BKPT_INDEX)(*loopDesc)].addr,
-   1479          |                                addrDesc,
-   1480          |                                &isInRange);
-   1481          |         if (GOOD != err) {
-   1482          |            /* make sure caller won't continue to loop in case they don't
-   1483          |               check for error condition */
-   1484          |            *loopDesc = MAX_NUM_BKPT;
-   1485          |            return err;
-   1486          |         }
-   1487          |         if (isInRange) {
-   1488          |            *bkptDesc = *loopDesc;
-   1489          |            (*loopDesc)++;
-   1490          |            return GOOD;
-   1491          |         }
    1492    1571  |     }
    1493    1572  |     (*loopDesc)++;
===================
    1510    1589  |RETCODE EXPORT
    1511    1590  |BxGetAllBkptNext(DESCRIPTOR FAR *loopDesc,
+           1591  |         DESCRIPTOR FAR *bkptDesc)  {
-   1512          |                 DESCRIPTOR FAR *bkptDesc)  {
    1513    1592  |
    1514    1593  |   while (TRUE)  {
    1515    1594  |      if (*loopDesc >= MAX_NUM_BKPT) /* loopDesc is 0-based index */
+           1595  |     return ER_BX_LOOP_COMPLETE;
-   1516          |         return ER_BX_LOOP_COMPLETE;
    1517    1596  |
    1518    1597  |      if ((bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_NOT_BEING_USED) &&
+           1598  |      (bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_SET_INTERNAL)) {
+           1599  |     *bkptDesc = *loopDesc;
+           1600  |     (*loopDesc)++;
+           1601  |     return GOOD;
-   1519          |          (bkptTable[(BKPT_INDEX)(*loopDesc)].type != BX_SET_INTERNAL)) {
-   1520          |         *bkptDesc = *loopDesc;
-   1521          |         (*loopDesc)++;
-   1522          |         return GOOD;
    1523    1602  |      }
    1524    1603  |      (*loopDesc)++;
    1525    1604  |   } /* end while */
    1526    1605  |}  /* end of BxGetAllBkptNext */
    1527    1606  |
-   1528          |/*---------------------------------------------------------------------------
-   1529          |** BxSetBkptWithSpaceFromSR - asm/address only setup (no symbolic input)
-   1530          |----------------------------------------------------------------------------*/
-   1531          |RETCODE EXPORT BxSetBkptWithSpaceFromSR(BX_BPSTATE state, BX_BPLIFE life,
-   1532          |                                   DESCRIPTOR addr, DESCRIPTOR FAR *desc) {
> ( 1557)   1607  |
> ( 1558)   1608  |/*---------------------------------------------------------------------------
> ( 1559)   1609  |** BxSetBkpt - asm/address only setup (no symbolic input)
> ( 1561)   1610  |----------------------------------------------------------------------------*/
> ( 1562)   1611  |RETCODE EXPORT BxSetBkpt(BX_BPSTATE state, BX_BPLIFE life,
+           1612  |             DESCRIPTOR addr, DESCRIPTOR FAR *desc) {
    1533    1613  |   RETCODE    err;
    1534    1614  |   BKPT_INDEX index;
===================
    1538    1618  |   /* remove processor dependency */
    1539    1619  |   if (FAMILY_68K == staticProcFamily) {
+           1620  |      if((err = AdrSetAddrSpace(addr, SPACE_SP)) != GOOD) {
+           1621  |     AdrDestroyAddress(addr);
+           1622  |     return err;
+           1623  |      }
-   1540          |      if ((err = BxSetAddrSpace(addr)) != GOOD)
-   1541          |         goto CLEANUP;
    1542    1624  |   }
> ( 1566)   1625  |
    1543    1626  |   /* Check for bkpt duplication */
    1544    1627  |   if ((err = AddrHasNoBkpt(addr, life)) != GOOD) {
===================
    1547    1630  |      return(err == ER_BX_ALREADY_HAS_BKPT ? GOOD : err);
    1548    1631  |   }
+           1632  |   
-   1549          |   if ((err = GetAvailableBkpt(&index))!=GOOD)
<   1550  ( 1911) |      goto CLEANUP;
-   1551          |   return BxSetBkptWithIndex(index, state, life, addr, NOT_CLI, desc);
<   1552  ( 1915) |
-   1553          |CLEANUP:
-   1554          |   AdrDestroyAddress(addr);   /* remove memory before returning error */
-   1555          |   return err;
-   1556          |} /* end of BxSetBkptWithSpaceFromSR */
<   1557  ( 1607) |
<   1558  ( 1608) |/*---------------------------------------------------------------------------
<   1559  ( 1609) |** BxSetBkpt - asm/address only setup (no symbolic input)
-   1560          |**             the caller has to take care of the addr space.
<   1561  ( 1610) |----------------------------------------------------------------------------*/
<   1562  ( 1611) |RETCODE EXPORT BxSetBkpt(BX_BPSTATE state, BX_BPLIFE life,
-   1563          |                         DESCRIPTOR addr, DESCRIPTOR FAR *desc) {
-   1564          |   RETCODE    err;
-   1565          |   BKPT_INDEX index;
<   1566  ( 1625) |
<   1567  ( 1681) |   if((err = BkProcessorMustBeHaltedAbsolute())!=GOOD)
<   1568  ( 1920) |      goto CLEANUP;
<   1569  ( 1922) |
-   1570          |   /* Check for bkpt duplication */
-   1571          |   if ((err = AddrHasNoBkpt(addr, life)) != GOOD) {
-   1572          |      AdrDestroyAddress(addr);   /* remove desc before returning */
-   1573          |      // Exit, report warning handled by AddrHasNoBkpt()
-   1574          |      return(err == ER_BX_ALREADY_HAS_BKPT ? GOOD : err);
<   1575  ( 1921) |   }
    1576    1633  |   if ((err = GetAvailableBkpt(&index))!=GOOD)
===================
    1593    1650  |**       life:  temporary or permanent lifetime
    1594    1651  |**       bkptAddr: address of breakpoint; consumed by this function even
+           1652  |**                 if it returns an error. This function will convert
+           1653  |**                 the address to LINEAR address type.
-   1595          |**                 if it returns an error
    1596    1654  |**       cliBkptNum: which user-entered bkpt number; NOT_CLI is used to
    1597    1655  |**          represent setting bkpt from caller other than CLI.
===================
    1604    1662  |RETCODE
    1605    1663  |BxSetBkptWithIndex(BKPT_INDEX     index,
+           1664  |           BX_BPSTATE     state,
+           1665  |           BX_BPLIFE      life,
+           1666  |           DESCRIPTOR     bkptAddr,
+           1667  |           U16            cliBkptNum,
+           1668  |           DESCRIPTOR FAR *desc) {
-   1606          |                   BX_BPSTATE     state,
-   1607          |                   BX_BPLIFE      life,
-   1608          |                   DESCRIPTOR     bkptAddr,
-   1609          |                   U16            cliBkptNum,
-   1610          |                   DESCRIPTOR FAR *desc) {
    1611    1669  |
    1612    1670  |   RETCODE            err, firstErr = GOOD;
===================
    1619    1677  |   SYM_TYPE_TYPE      symbolType;
    1620    1678  |   U32                symbolOffset;
+           1679  |   BOOLEAN            isValid, dummy;
-   1621          |   BOOLEAN            isValid;
    1622    1680  |
> ( 1567)   1681  |   if((err = BkProcessorMustBeHaltedAbsolute())!=GOOD)
<   1623  ( 3268) |   if((err = BkProcessorMustBeHaltedAbsolute())!=GOOD)
    1624    1682  |      goto CLEANUP_2;
+           1683  |       
+           1684  |   /* Convert bkptAddr to ADDR_LINEAR type */
+           1685  |   if ((err = AdrConvertAddress(bkptAddr, ADDR_LINEAR, 
+           1686  |        (BOOLEAN FAR *)&dummy)) != GOOD) goto CLEANUP_2; 
+           1687  |   
    1625    1688  |   if(GOOD !=
    1626    1689  |      (err = AdrIsValidCodeAddress(bkptAddr, (BOOLEAN FAR *)&isValid)))
===================
    1637    1700  |   bkptTable[index].symMatch = FALSE;
    1638    1701  |   bkptTable[index].module = NULL_SYMBOL;
+           1702  |   bkptTable[index].function = NULL_SYMBOL;
    1639    1703  |   bkptTable[index].addr = bkptAddr;
    1640    1704  |   bkptTable[index].state = state;
    1641    1705  |   bkptTable[index].life = life;
-   1642          |   bkptTable[index].statementTextPtr = NULL_SYMBOL;
    1643    1706  |
    1644    1707  |   /* If the breakpoint is internal - skip over symbolic filling stuffs
===================
    1647    1710  |   if (life == BX_TEMPORARY_INTERNAL)
    1648    1711  |      goto INTERNAL_BKPT;
+           1712  |   
<   1649  ( 1875) |
    1650    1713  |   /*
===================
    1658    1721  |   if (FAMILY_68K == staticProcFamily) {
    1659    1722  |      if(GOOD != (err = AdrSetAddrSpace(addrRangeDesc, SPACE_SP)))
+           1723  |     goto CLEANUP_1;
-   1660          |         goto CLEANUP_1;
    1661    1724  |   }
    1662    1725  |   /* look up module, function by address */
    1663    1726  |   err = SymMapAddr2Symbol(bkptAddr,
+           1727  |               &memoryClass,
+           1728  |               &symbolType,
+           1729  |               &symbolOffset,
+           1730  |               &lowestLevelDesc,
+           1731  |               &functionDesc,
+           1732  |               &moduleDesc);
+           1733  |   
+           1734  |   if (err != GOOD) {
-   1664          |                           &memoryClass,
-   1665          |                           &symbolType,
-   1666          |                           &symbolOffset,
-   1667          |                           &lowestLevelDesc,
-   1668          |                           &functionDesc,
-   1669          |                           &moduleDesc);
-   1670          |   if (GOOD != err) {
-   1671          |      if (ER_ADDRESS_NOT_FOUND != err) { /* error but not NOT_FOUND err */
-   1672          |         goto CLEANUP_1;
> ( 1322)   1735  |      if (ER_ADDRESS_NOT_FOUND != err) { /* error but not NOT_FOUND err */
+           1736  |     goto CLEANUP_1;
> ( 1324)   1737  |      }
> ( 1325)   1738  |   } else { /* good symbol lookup */
+           1739  |      // Make sure that symbol look up is mapped to a code address
+           1740  |      if (memoryClass != CODE_ADDR) {
+           1741  |     goto NOSYMBOL_BKPT;
    1673    1742  |      }
<   1674  ( 1404) |   } else { /* good symbol lookup */
    1675    1743  |      err = SymMapAddr2LinenumStmt(bkptAddr,
+           1744  |                   moduleDesc,
+           1745  |                   &linenum,
+           1746  |                   &columnRange,
+           1747  |                   addrRangeDesc,
+           1748  |                   &nextIndex);
-   1676          |                                   moduleDesc,
-   1677          |                                   &linenum,
-   1678          |                                   &columnRange,
-   1679          |                                   addrRangeDesc,
-   1680          |                                   &nextIndex);
    1681    1749  |      if (GOOD != err) {
+           1750  |     /* error but not NOT_FOUND err and NO_LINENUM_ADDED err */
+           1751  |     /* NOTES: 09/21/93 - Nghia
+           1752  |     ** Support ASM module which does not have line number information
+           1753  |     */
+           1754  |     if ((ER_ADDRESS_NOT_FOUND != err) &&
+           1755  |         (ER_NO_LINENUMS_ADDED != err)) { 
+           1756  |        goto CLEANUP_1;
+           1757  |     }
-   1682          |         /* error but not NOT_FOUND err and NO_LINENUM_ADDED err */
-   1683          |         /* NOTES: 09/21/93 - Nghia
-   1684          |         ** Support ASM module which does not have line number information
-   1685          |         */
-   1686          |         if ((ER_ADDRESS_NOT_FOUND != err) &&
-   1687          |             (ER_NO_LINENUMS_ADDED != err)) { 
-   1688          |            goto CLEANUP_1;
-   1689          |         }
    1690    1758  |      } else { /* valid symbol and linenum */
+           1759  |     bkptTable[index].symMatch = TRUE;
+           1760  |     bkptTable[index].module = moduleDesc;
+           1761  |     bkptTable[index].function = functionDesc;  /* could be NULL_SYMBOL */
+           1762  |     bkptTable[index].lineNumber = linenum;
+           1763  |     bkptTable[index].columnRange = columnRange;
+           1764  |     if (moduleDesc != NULL_SYMBOL) {
+           1765  |        if (GOOD != (err = BxInsertBkptNamesAndOffset(index)))
+           1766  |           goto CLEANUP_1;
+           1767  |     }
-   1691          |         bkptTable[index].symMatch = TRUE;
-   1692          |         bkptTable[index].module = moduleDesc;
-   1693          |         bkptTable[index].function = functionDesc;  /* could be NULL_SYMBOL */
-   1694          |         bkptTable[index].lineNumber = linenum;
-   1695          |         bkptTable[index].columnRange = columnRange;
-   1696          |         if (moduleDesc != NULL_SYMBOL) {
-   1697          |            if (GOOD != (err = BxInsertBkptNamesAndOffset(index)))
-   1698          |               goto CLEANUP_1;
-   1699          |         }
    1700    1768  |      }
    1701    1769  |   } /* end of symbol stuffing */
+           1770  |NOSYMBOL_BKPT:   
<   1702  ( 1361) |
    1703    1771  |   /* normal cleanup */
    1704    1772  |   err = AdrDestroyAddress(addrRangeDesc);  
    1705    1773  |   if (GOOD == firstErr) firstErr = err;
+           1774  |   
<   1706  ( 1218) |
> ( 1718)   1775  |INTERNAL_BKPT:   
    1707    1776  |   /*----------------------*/
    1708    1777  |   /* fill in rest of data */
===================
    1731    1797  |      /* must get unused .cliBkptNumber and save, since all bkpts get one */
    1732    1798  |      if (GOOD != (err = CreateCliBkptNum(&num)))
+           1799  |     goto CLEANUP_1;
-   1733          |         goto CLEANUP_2;
    1734    1800  |      bkptTable[index].cliBkptNumber = num;
    1735    1801  |      bkptTable[index].type = BX_SET_FROM_ASM;
===================
    1747    1813  |   if (bkptTable[index].state == BX_ENABLED) {  /* only program if enabled */
    1748    1814  |      if ((err = BkptProgramBkpt(index)) != GOOD) {
+           1815  |     /* if failed, clear breakpoint */
+           1816  |     BxRemoveBkpt(*desc);
+           1817  |     return(err);
-   1749          |         /* if failed, clear breakpoint */
-   1750          |         BxRemoveBkpt(*desc); /* this call destroys bkptAddr */
-   1751          |         return(err);
    1752    1818  |      }
    1753    1819  |      if (GOOD == firstErr) firstErr = err;
===================
    1756    1822  |   if (GOOD == firstErr) { /* only notify if all's well */
    1757    1823  |      if (bkptTable[index].life == BX_TEMPORARY_INTERNAL) {
+           1824  |     return GOOD;   /* do not report to outside if temporary internal */
-   1758          |         return GOOD;   /* do not report to outside if temporary internal */
    1759    1825  |      } else {
+           1826  |     return EnlEventNotify(EVENT_BKPT_EDIT);
-   1760          |         return EnlEventNotify(EVENT_BKPT_EDIT);
    1761    1827  |      }
    1762    1828  |   } else {
===================
    1776    1842  |      err = AdrDestroyAddress(bkptAddr);  /* remove passed-in addr */
    1777    1843  |      if (GOOD == firstErr) firstErr = err;
+           1844  |      bkptTable[index].addr = NULL;
    1778    1845  |   }
    1779    1846  |   return firstErr;
===================
    1790    1857  |----------------------------------------------------------------------------*/
    1791    1858  |RETCODE BxInsertBkptNamesAndOffset(BKPT_INDEX index)  {
+           1859  |   RETCODE      err, firstErr = GOOD;
+           1860  |   U16          bufLen;
+           1861  |   S8           buf[MAX_SYMNAME_LENGTH];
+           1862  |   DESCRIPTOR   tmpAddrDesc;
+           1863  |   ADDR_COMPARE result;
+           1864  |   BOOLEAN      dummy;  
+           1865  |    
<   1792  ( 2499) |
-   1793          |   U32        funcStartAddr, bkptStartAddr;
-   1794          |   RETCODE    err, firstErr = GOOD;
-   1795          |   U16        bufLen;
-   1796          |   S8         buf[MAX_SYMNAME_LENGTH];
-   1797          |   DESCRIPTOR tmpAddrDesc;
<   1798  ( 2660) |
    1799    1866  |   /* get names */
    1800    1867  |   /* places malloc'ed descriptor into bkpt element */
    1801    1868  |   firstErr = SymGetSymbolName(bkptTable[index].module,
+           1869  |                   &bkptTable[index].modName);
-   1802          |                               &bkptTable[index].modName);
-   1803          |   // Notes: Nghia 10/26/94
-   1804          |   // Support ASM module, which has line # but no function
    1805    1870  |   if (bkptTable[index].function != NULL_SYMBOL) {                             
    1806    1871  |      err = SymGetSymbolName(bkptTable[index].function,
+           1872  |                 &bkptTable[index].functionName);
-   1807          |                             &bkptTable[index].functionName);
    1808    1873  |      if (GOOD == firstErr) firstErr = err;
+           1874  |   }   
> ( 1649)   1875  |
+           1876  |   // allocate memory for the modRefName if there is module reference
+           1877  |   // else leave it as NULL
<   1809  ( 1217) |   }
<   1810  ( 1396) |   
===================
    1819    1886  |      bkptTable[index].modRefName = (DESCRIPTOR)TMalloc((U32)(bufLen + 1));
    1820    1887  |      if (!bkptTable[index].modRefName) {
+           1888  |     return ER_OUT_OF_MEMORY;  /* priority over firstErr */
-   1821          |         return ER_OUT_OF_MEMORY;  /* priority over firstErr */
    1822    1889  |      }
    1823    1890  |      /* copy from tmp into TMalloc'ed memory */
    1824    1891  |      strcpy((LPSTR)(bkptTable[index].modRefName), &buf[0]);
    1825    1892  |   }
+           1893  |   
    1826    1894  |   if (GOOD != firstErr)
    1827    1895  |      return firstErr;  /* don't continue if already errs */
===================
    1836    1904  |
    1837    1905  |   if (GOOD != (err = AdrDuplicateAddress(bkptTable[index].addr,
+           1906  |           &tmpAddrDesc)))
-   1838          |               &tmpAddrDesc)))
    1839    1907  |      return err;
+           1908  |   // Get address descriptor of the start function
<   1840  ( 2669) |
    1841    1909  |   if (GOOD != (err = SymGetSymbolAddress(bkptTable[index].function,
+           1910  |                      tmpAddrDesc)))
-   1842          |                                          tmpAddrDesc)))
-   1843          |      goto CLEANUP;
> ( 1550)   1911  |      goto CLEANUP;
+           1912  |   // Convert to ADDR_LINEAR 
+           1913  |   if (GOOD != (err = AdrConvertAddress(tmpAddrDesc, ADDR_LINEAR, 
+           1914  |      (BOOLEAN FAR *) &dummy))) goto CLEANUP;
> ( 1552)   1915  |
+           1916  |   // make sure that the breakpoint address is still in the function
+           1917  |   if ((GOOD != (err = AdrCompareAddresses(bkptTable[index].addr,
+           1918  |      tmpAddrDesc, &result))) || (result == SECOND_ADDR_GREATER)) {
+           1919  |      err = (err != GOOD) ? err : ER_BX_BKPT_LESSTHAN_FUNC;
> ( 1568)   1920  |      goto CLEANUP;
> ( 1575)   1921  |   }
> ( 1569)   1922  |
+           1923  |   /* Compute the offset from the start of the function */ 
+           1924  |   err = AdrRangeOfAddresses(tmpAddrDesc, bkptTable[index].addr, 
+           1925  |                  (U32 FAR *) &bkptTable[index].funcAddrOffset); 
<   1844  ( 2673) |
-   1845          |   if (GOOD != (err = AdrGetAddrOffset(tmpAddrDesc, &funcStartAddr)))
-   1846          |      goto CLEANUP;
<   1847  ( 2678) |
-   1848          |   if (GOOD != (err = AdrGetAddrOffset(bkptTable[index].addr,
-   1849          |                                       &bkptStartAddr)))
-   1850          |      goto CLEANUP;
-   1851          |   /* !!! NOT PORTABLE */
-   1852          |   if (bkptStartAddr < funcStartAddr) {
-   1853          |      err = ER_BX_BKPT_LESSTHAN_FUNC;
-   1854          |      goto CLEANUP;
<   1855  ( 2925) |   }
-   1856          |   bkptTable[index].funcAddrOffset = bkptStartAddr - funcStartAddr;
    1857    1926  |
    1858    1927  |CLEANUP:
===================
    1892    1961  |   RETCODE err, firstErr = GOOD;
    1893    1962  |
+           1963  |   if (bkptTable[index].addr)
+           1964  |      firstErr = AdrDestroyAddress(bkptTable[index].addr);
-   1894          |   firstErr = AdrDestroyAddress(bkptTable[index].addr);
    1895    1965  |
    1896    1966  |   if (NULL_SYMBOL != bkptTable[index].modRefName) {
    1897    1967  |      err = TFree((LPSTR)(bkptTable[index].modRefName));
    1898    1968  |      if (GOOD == firstErr)
+           1969  |     firstErr = err;
-   1899          |         firstErr = err;
    1900    1970  |      bkptTable[index].modRefName = 0L;
    1901    1971  |   }
===================
    1904    1974  |      err = TFree((LPSTR)(bkptTable[index].modName));
    1905    1975  |      if (GOOD == firstErr)
+           1976  |     firstErr = err;
-   1906          |         firstErr = err;
    1907    1977  |      bkptTable[index].modName = 0L;
    1908    1978  |   }
===================
    1911    1981  |      err = TFree((LPSTR)(bkptTable[index].functionName));
    1912    1982  |      if (GOOD == firstErr)
+           1983  |     firstErr = err;
-   1913          |         firstErr = err;
    1914    1984  |      bkptTable[index].functionName = 0L;
    1915    1985  |   }
===================
    1918    1988  |      err = TFree(bkptTable[index].statementTextPtr);
    1919    1989  |      if (GOOD == firstErr)
+           1990  |     firstErr = err;
-   1920          |         firstErr = err;
    1921    1991  |      bkptTable[index].statementTextPtr = 0L;
    1922    1992  |   }
===================
    1929    1999  |----------------------------------------------------------------------------*/
    1930    2000  |RETCODE EXPORT BxGetBkpt(DESCRIPTOR desc,
+           2001  |             BX_BPSTATE FAR *state,
+           2002  |             BX_BPLIFE FAR *life,
+           2003  |             DESCRIPTOR FAR *addr) {
-   1931          |                         BX_BPSTATE FAR *state,
-   1932          |                         BX_BPLIFE FAR *life,
-   1933          |                         DESCRIPTOR FAR *addr) {
    1934    2004  |
    1935    2005  |   RETCODE err;
===================
    1942    2012  |   if (GOOD != (err =
    1943    2013  |      AdrDuplicateAddress(bkptTable[(BKPT_INDEX)desc].addr,
+           2014  |              addr)))
-   1944          |                          addr)))
    1945    2015  |      return err;
    1946    2016  |   return GOOD;
===================
    1961    2031  |      bkptTable[(BKPT_INDEX)desc].state = BX_ENABLED;
    1962    2032  |      if (GOOD != (err = BkptProgramBkpt((BKPT_INDEX)desc)))
+           2033  |     return err;
-   1963          |         return err;
    1964    2034  |      return EnlEventNotify(EVENT_BKPT_EDIT);
    1965    2035  |   }
===================
    1983    2053  |      bkptTable[(BKPT_INDEX)desc].state = BX_DISABLED;
    1984    2054  |      if (GOOD != (err = BkptProgramBkpt((BKPT_INDEX)desc)))
+           2055  |     return err;
-   1985          |         return err;
    1986    2056  |      return EnlEventNotify(EVENT_BKPT_EDIT);
    1987    2057  |   }
===================
    2005    2075  |   for (i=0; (bkptPassCount && (i<MAX_NUM_BKPT)); i++) {
    2006    2076  |      if (bkptTable[i].type != BX_NOT_BEING_USED) {
+           2077  |     if (bkptTable[(BKPT_INDEX)i].state == BX_DISABLED) {
+           2078  |        bkptTable[(BKPT_INDEX)i].state = BX_ENABLED;
+           2079  |        if (GOOD != (err = BkptProgramBkpt((BKPT_INDEX)i)))
+           2080  |           return err;
+           2081  |        bkptChanged = TRUE;
+           2082  |     }
-   2007          |         if (bkptTable[(BKPT_INDEX)i].state == BX_DISABLED) {
-   2008          |            bkptTable[(BKPT_INDEX)i].state = BX_ENABLED;
-   2009          |            if (GOOD != (err = BkptProgramBkpt((BKPT_INDEX)i)))
-   2010          |               return err;
-   2011          |            bkptChanged = TRUE;
-   2012          |         }
    2013    2083  |      bkptPassCount--;
    2014    2084  |      }
===================
    2036    2106  |   for (i=0; (bkptPassCount && (i<MAX_NUM_BKPT)); i++) {
    2037    2107  |      if (bkptTable[i].type != BX_NOT_BEING_USED) {
+           2108  |     if (bkptTable[(BKPT_INDEX)i].state == BX_ENABLED) {
+           2109  |        bkptTable[(BKPT_INDEX)i].state = BX_DISABLED;
+           2110  |        if (GOOD != (err = BkptProgramBkpt((BKPT_INDEX)i)))
+           2111  |           return err;
+           2112  |        bkptChanged = TRUE;
+           2113  |     }
-   2038          |         if (bkptTable[(BKPT_INDEX)i].state == BX_ENABLED) {
-   2039          |            bkptTable[(BKPT_INDEX)i].state = BX_DISABLED;
-   2040          |            if (GOOD != (err = BkptProgramBkpt((BKPT_INDEX)i)))
-   2041          |               return err;
-   2042          |            bkptChanged = TRUE;
-   2043          |         }
    2044    2114  |      bkptPassCount--;
    2045    2115  |      }
===================
    2067    2137  |   if (bkptTable[(BKPT_INDEX)desc].type != BX_NOT_BEING_USED) {
    2068    2138  |      if (BX_TEMPORARY_INTERNAL == bkptTable[(BKPT_INDEX)desc].life)
+           2139  |     tempInternalBkpt = TRUE;
-   2069          |         tempInternalBkpt = TRUE;
    2070    2140  |      bkptTable[(BKPT_INDEX)desc].type = BX_NOT_BEING_USED;
    2071    2141  |      if (bkptCount)
+           2142  |     bkptCount--;
-   2072          |         bkptCount--;
    2073    2143  |
    2074    2144  |      if (bkptTable[(BKPT_INDEX)desc].state == BX_ENABLED) {
+           2145  |     err  = BkptProgramBkpt((BKPT_INDEX)desc);
-   2075          |         err  = BkptProgramBkpt((BKPT_INDEX)desc);
    2076    2146  |      }
    2077    2147  |      err1 = BxRemoveBkptAllocation((BKPT_INDEX)desc);
    2078    2148  |      if (err)
+           2149  |     return err;
-   2079          |         return err;
    2080    2150  |      if (err1)
+           2151  |     return err1;
-   2081          |         return err1;
    2082    2152  |      if (FALSE == tempInternalBkpt)
+           2153  |     return EnlEventNotify(EVENT_BKPT_EDIT);
-   2083          |         return EnlEventNotify(EVENT_BKPT_EDIT);
    2084    2154  |   }
    2085    2155  |   return GOOD;
===================
    2106    2176  |   for (i=0; i < MAX_NUM_BKPT; i++) {
    2107    2177  |      if (bkptTable[i].type != BX_NOT_BEING_USED) {
+           2178  |     bkptTable[i].type = BX_NOT_BEING_USED;
+           2179  |     if (BX_TEMPORARY_INTERNAL != bkptTable[i].life)
+           2180  |        anyBkptNotTempInternal = TRUE;
+           2181  |     if (bkptTable[i].state == BX_ENABLED) {
+           2182  |        err  = BkptProgramBkpt(i);
+           2183  |     }
+           2184  |     if (GOOD == firstErr)
+           2185  |        firstErr = err;
+           2186  |     err = BxRemoveBkptAllocation(i);  /* remove all alloc'ed bkpt data */
+           2187  |     if (GOOD == firstErr)
+           2188  |        firstErr = err;
-   2108          |         bkptTable[i].type = BX_NOT_BEING_USED;
-   2109          |         if (BX_TEMPORARY_INTERNAL != bkptTable[i].life)
-   2110          |            anyBkptNotTempInternal = TRUE;
-   2111          |         if (bkptTable[i].state == BX_ENABLED) {
-   2112          |            err  = BkptProgramBkpt(i);
-   2113          |         }
-   2114          |         if (GOOD == firstErr)
-   2115          |            firstErr = err;
-   2116          |         err = BxRemoveBkptAllocation(i);  /* remove all alloc'ed bkpt data */
-   2117          |         if (GOOD == firstErr)
-   2118          |            firstErr = err;
    2119    2189  |      }
    2120    2190  |   }
===================
    2162    2232  |   for (i=0; (bkptPassCount && (i<MAX_NUM_BKPT)); i++) {
    2163    2233  |      if (bkptTable[i].type != BX_NOT_BEING_USED) {
+           2234  |     bkptPassCount--;
+           2235  |     if (bkptTable[i].life == BX_TEMPORARY_INTERNAL) {
+           2236  |        bkptTable[i].type = BX_NOT_BEING_USED;
+           2237  |        err = BkptProgramBkpt(i);
+           2238  |        if (GOOD == firstErr)
+           2239  |           firstErr = err;
+           2240  |        /* remove all alloc'ed bkpt data */
+           2241  |        err = BxRemoveBkptAllocation(i);
+           2242  |        if (GOOD == firstErr)
+           2243  |           firstErr = err;
+           2244  |        bkptCount--;
+           2245  |     }
-   2164          |         bkptPassCount--;
-   2165          |         if (bkptTable[i].life == BX_TEMPORARY_INTERNAL) {
-   2166          |            bkptTable[i].type = BX_NOT_BEING_USED;
-   2167          |            err = BkptProgramBkpt(i);
-   2168          |            if (GOOD == firstErr)
-   2169          |               firstErr = err;
-   2170          |            /* remove all alloc'ed bkpt data */
-   2171          |            err = BxRemoveBkptAllocation(i);
-   2172          |            if (GOOD == firstErr)
-   2173          |               firstErr = err;
-   2174          |            bkptCount--;
-   2175          |         }
    2176    2246  |      /* NOTE: event notification is not generated when internal bkpt */
    2177    2247  |      }
===================
    2213    2283  |      bkptPassCount--;
    2214    2284  |      if ((bkptTable[i].type != BX_NOT_BEING_USED) &&
+           2285  |     (bkptTable[i].life == BX_TEMPORARY) &&
+           2286  |     (AdrComparePhysicalAddresses(currentPCDesc,
+           2287  |              bkptTable[i].addr, &compareResult) == GOOD)) {
+           2288  |     if (EQUAL_ADDRS == compareResult) {
+           2289  |        firstErr = BxRemoveBkpt(i);
+           2290  |        *tempMatch = TRUE;
+           2291  |        break;
+           2292  |     }
-   2215          |         (bkptTable[i].life == BX_TEMPORARY) &&
-   2216          |         (AdrComparePhysicalAddresses(currentPCDesc,
-   2217          |                            bkptTable[i].addr, &compareResult) == GOOD)) {
-   2218          |         if (EQUAL_ADDRS == compareResult) {
-   2219          |            firstErr = BxRemoveBkpt(i);
-   2220          |            *tempMatch = TRUE;
-   2221          |            break;
-   2222          |         }
    2223    2293  |      }
    2224    2294  |   }
===================
    2255    2325  |      bkptPassCount--;
    2256    2326  |      if ((bkptTable[i].type != BX_NOT_BEING_USED) &&
+           2327  |     (bkptTable[i].life == BX_TEMPORARY_INTERNAL) &&
+           2328  |     (AdrComparePhysicalAddresses(matchAddr, bkptTable[i].addr,
+           2329  |                   &compareResult) == GOOD)) {
+           2330  |      /* until a match is found */  
+           2331  |      if (EQUAL_ADDRS == compareResult) {
+           2332  |         *match = TRUE;
+           2333  |         return GOOD;
+           2334  |      }
-   2257          |         (bkptTable[i].life == BX_TEMPORARY_INTERNAL) &&
-   2258          |         (AdrCompareAddresses(matchAddr, bkptTable[i].addr,
-   2259          |                                   &compareResult) == GOOD)) {
-   2260          |          /* until a match is found */  
-   2261          |          if (EQUAL_ADDRS == compareResult) {
-   2262          |             *match = TRUE;
-   2263          |             return GOOD;
-   2264          |          }
    2265    2335  |      }
    2266    2336  |   }
===================
    2282    2352  |   BOOLEAN    timedOut;
    2283    2353  |   RETCODE    err;
+           2354  |   U16 segment;
+           2355  |   U32 seg;
+           2356  |   ADDR_SEGSEL_TYPE segType;
    2284    2357  |
    2285    2358  |   if ((bkptTable[index].type == BX_NOT_BEING_USED) ||
===================
    2290    2363  |   }
    2291    2364  |   bkptId = (U16)index;
-   2292          |   if((err = AdrGetAddrOffset(bkptTable[index].addr,
-   2293          |                              (U32 FAR *)&bkptAddr))!=GOOD)
> ( 1728)   2365  |
+           2366  |   // Get the linear offset of breakpoint address and set
+           2367  |   if((err = AdrGetAddrOffset(bkptTable[index].addr,             
+           2368  |                  (U32 FAR *)&bkptAddr))!=GOOD)
    2294    2369  |      return err;
+           2370  |   AdrGetAddrSegmentSelector(bkptTable[index].addr, &segType, &segment);
+           2371  |   seg = (U32)segment;
+           2372  |   bkptAddr -= seg*16;
+           2373  |   bkptAddr += seg << 16;
    2295    2374  |
    2296    2375  |   /* remove processor dependency */
    2297    2376  |   if (FAMILY_68K == staticProcFamily) {
    2298    2377  |      if((err=AdrGetAddrSpace(bkptTable[index].addr,
+           2378  |                  (ADDR_SPACE FAR *)&bkptSpace))!=GOOD)
+           2379  |     return err;
-   2299          |                              (ADDR_SPACE FAR *)&bkptSpace))!=GOOD)
-   2300          |         return err;
    2301    2380  |   }
    2302    2381  |   /*---------------------------------
===================
    2307    2386  |   if (FAMILY_68K == staticProcFamily) {
    2308    2387  |      if((err = SdWriteMember(bkSpaceDesc, (U8 FAR *)&bkptSpace, GOOD))!=GOOD)
+           2388  |     return err;
-   2309          |         return err;
    2310    2389  |   }
    2311    2390  |   if((err = SdWriteMember(bkIdDesc, (U8 FAR *)&bkptId, GOOD))!=GOOD)
===================
    2324    2403  |   for((*index)=0; (*index)<MAX_NUM_BKPT; (*index)++) {
    2325    2404  |      if(bkptTable[*index].type == BX_NOT_BEING_USED)
+           2405  |     return GOOD;
-   2326          |         return GOOD;
    2327    2406  |   }
    2328    2407  |   return ER_BX_NO_BKPT_AVAILABLE ;
===================
    2348    2427  |      --bkptPassCount;
    2349    2428  |      if ((bkptTable[index].type != BX_NOT_BEING_USED) &&
+           2429  |     (bkptTable[index].life != BX_TEMPORARY_INTERNAL) &&
+           2430  |     (AdrComparePhysicalAddresses(bkptTable[index].addr, addrDesc,
+           2431  |              (ADDR_COMPARE FAR *) &result) == GOOD)) {
+           2432  |     if (result == EQUAL_ADDRS) {
+           2433  |        S8 addrBuf[ADDR_BUFF_SZ];
+           2434  |        if ((err = AdrConvAddressToTextWithParams(bkptTable[index].addr,
+           2435  |            TRUE, FALSE, (LPSTR)addrBuf)) !=GOOD)
+           2436  |           return(err);
+           2437  |        /* Format the string message */
+           2438  |        sprintf(tmpStr, "address = %s, bkpt id = @%d.", addrBuf,
+           2439  |           bkptTable[index].cliBkptNumber);
+           2440  |        ErrDisplayString(ER_BX_ALREADY_HAS_BKPT, (LPSTR)tmpStr, CHECK_MODE);
+           2441  |        return(ER_BX_ALREADY_HAS_BKPT);
+           2442  |     }
-   2350          |         (bkptTable[index].life != BX_TEMPORARY_INTERNAL) &&
-   2351          |         (AdrComparePhysicalAddresses(bkptTable[index].addr, addrDesc,
-   2352          |                          (ADDR_COMPARE FAR *) &result) == GOOD)) {
<   2353  ( 2777) |         if (result == EQUAL_ADDRS) {
-   2354          |            S8 addrBuf[ADDR_BUFF_SZ], spaceBuf[ADDR_BUFF_SZ];
-   2355          |            ADDR_SPACE space;
<   2356  ( 2736) |
-   2357          |            if ((err = AdrConvAddressToTextWithParams(bkptTable[index].addr,
-   2358          |                    TRUE, FALSE, (LPSTR)addrBuf)) !=GOOD)
-   2359          |               return(err);
-   2360          |            if (((err = AdrGetAddrSpace(bkptTable[index].addr, &space)) !=GOOD) ||
-   2361          |                ((err = AdrGetSpaceStr(space, spaceBuf)) !=GOOD))
-   2362          |               return(err);
-   2363          |            /* Format the string message */
-   2364          |            sprintf(tmpStr, "address = %s (%s), bkpt id = @%d.", addrBuf,
-   2365          |                    spaceBuf, bkptTable[index].cliBkptNumber);
-   2366          |            ErrDisplayString(ER_BX_ALREADY_HAS_BKPT, (LPSTR)tmpStr, CHECK_MODE);
-   2367          |            return(ER_BX_ALREADY_HAS_BKPT);
-   2368          |         }
    2369    2443  |      }
    2370    2444  |   }
===================
    2398    2472  |RETCODE PRIVATE
    2399    2473  |BxGetSrcAddressRange(DESCRIPTOR     currentPC,
+           2474  |             BX_GRANULARITY granularity,
+           2475  |             DESCRIPTOR FAR *rangeDesc) {
-   2400          |                     BX_GRANULARITY granularity,
-   2401          |                     DESCRIPTOR FAR *rangeDesc) {
    2402    2476  |
    2403    2477  |   RETCODE            err, firstErr = GOOD;
===================
    2417    2491  |   if ((lookaheadModule) && (!lookaheadLinenumIndex)) {
    2418    2492  |      if (granularity == BX_LINE_GRAN) {
+           2493  |     err = SymGetLinenumByIndex(lookaheadModule,
+           2494  |                    lookaheadLinenumIndex,
+           2495  |                    *rangeDesc, /* addr desc to fill in */
+           2496  |                    &nextLinenumIndex,
+           2497  |                    &linenum,
+           2498  |                    &column);
-   2419          |         err = SymGetLinenumByIndex(lookaheadModule,
-   2420          |                                    lookaheadLinenumIndex,
-   2421          |                                    *rangeDesc, /* addr desc to fill in */
-   2422          |                                    &nextLinenumIndex,
-   2423          |                                    &linenum,
-   2424          |                                    &column);
> ( 1792)   2499  |
<   2425  ( 2896) |
    2426    2500  |      } else {
+           2501  |     err = SymGetLinenumStmtByIndex(lookaheadModule,
+           2502  |                    lookaheadLinenumIndex,
+           2503  |                    *rangeDesc,
+           2504  |                    &linenum,
+           2505  |                    &columnRange,
+           2506  |                    &nextLinenumIndex);
-   2427          |         err = SymGetLinenumStmtByIndex(lookaheadModule,
-   2428          |                                        lookaheadLinenumIndex,
-   2429          |                                        *rangeDesc,
-   2430          |                                        &linenum,
-   2431          |                                        &columnRange,
-   2432          |                                        &nextLinenumIndex);
    2433    2507  |      }
    2434    2508  |      if ((err != GOOD) && (err != ER_LINENUM_INDEX_TOO_LARGE))
+           2509  |     goto CLEANUP;
-   2435          |         goto CLEANUP;
    2436    2510  |      lookaheadLinenumIndex = nextLinenumIndex; /* save for next time */
    2437    2511  |
    2438    2512  |      /* now see if requested address within address range of linenum/stmt */
    2439    2513  |      if (GOOD != (err = AdrIsAddrInRange(currentPC, *rangeDesc, &isInRange)))
+           2514  |     goto CLEANUP;
-   2440          |         goto CLEANUP;
    2441    2515  |      if (isInRange)
+           2516  |     return GOOD;
-   2442          |         return GOOD;
    2443    2517  |      /* otherwise fall thru and use the SymMapAddr2Linenum... to get linenum
+           2518  |     address range */
-   2444          |         address range */
    2445    2519  |   }
    2446    2520  |   /* find module, linenum, column match for requested address */
===================
    2449    2523  |   if (granularity == BX_LINE_GRAN) {
    2450    2524  |      err = SymMapAddr2LinenumModule(currentPC,
+           2525  |                     &module,
+           2526  |                     moduleRangeDesc, /* module addr range */
+           2527  |                     &linenum,
+           2528  |                     &column,
+           2529  |                     *rangeDesc, /* addr desc to fill in */
+           2530  |                     &nextLinenumIndex);
-   2451          |                                     &module,
-   2452          |                                     moduleRangeDesc, /* module addr range */
-   2453          |                                     &linenum,
-   2454          |                                     &column,
-   2455          |                                     *rangeDesc, /* addr desc to fill in */
-   2456          |                                     &nextLinenumIndex);
    2457    2531  |   } else { /* stmt */
    2458    2532  |      err =
+           2533  |     SymMapAddr2LinenumStmtModule(currentPC,
+           2534  |                      &module,
+           2535  |                      moduleRangeDesc,/* module addr range */
+           2536  |                      &linenum,
+           2537  |                      &columnRange,
+           2538  |                      *rangeDesc, /* addr desc to fill in */
+           2539  |                      &nextLinenumIndex);
-   2459          |         SymMapAddr2LinenumStmtModule(currentPC,
-   2460          |                                      &module,
-   2461          |                                      moduleRangeDesc,/* module addr range */
-   2462          |                                      &linenum,
-   2463          |                                      &columnRange,
-   2464          |                                      *rangeDesc, /* addr desc to fill in */
-   2465          |                                      &nextLinenumIndex);
    2466    2540  |   }
    2467    2541  |   firstErr = err;
===================
    2499    2570  |RETCODE EXPORT BxSrcStep(BX_STEP_TYPE type, BX_GRANULARITY gran, U32 count) {
    2500    2571  |   RETCODE err,err2;
+           2572  |   DESCRIPTOR pcAddrDesc, srcRangeDesc, tmpAddrDesc;
-   2501          |   DESCRIPTOR pcAddrDesc, srcRangeDesc;
    2502    2573  |   BOOLEAN   abortFromEsc;
    2503    2574  |
===================
    2516    2587  |      return(err);
    2517    2588  |   }
+           2589  |   /* clear any ESC previously hit */
<   2518  ( 3073) |
<   2519  ( 3089) |
-   2520          | /* clear any ESC previously hit */
    2521    2590  |   err = TskCheckAbort(&abortFromEsc);
    2522    2591  |   if(err!=GOOD) {
===================
    2525    2594  |      return err;
    2526    2595  |   }
+           2596  |   tmpAddrDesc=pcAddrDesc;   /*<Judy 2/3/1997> */
<   2527  ( 3105) |
    2528    2597  |   while (count--) {
+           2598  |      err=BxSrcStepFast(type,gran,&pcAddrDesc,&srcRangeDesc);
-   2529          |// jerry     err=BxSrcStepFast(type,gran,&pcAddrDesc,&srcRangeDesc);
-   2530          |// jerry     BxRemoveAllInternalBkpts();
-   2531          |// jerry     if (err == ER_TOO_MANY_XBRKS) {
-   2532          |         err=BxSrcStepSlow(type,gran,&pcAddrDesc,&srcRangeDesc);
-   2533          |         BxRemoveAllInternalBkpts();
-   2534          |// jerry     }
> ( 2881)   2599  |      BxRemoveAllInternalBkpts();
+           2600  |      if (err == ER_TOO_MANY_XBRKS) {
+           2601  |     err=BxSrcStepSlow(type,gran,&pcAddrDesc,&srcRangeDesc);
+           2602  |     BxRemoveAllInternalBkpts();
+           2603  |      }
    2535    2604  |      if (err != GOOD) break;
    2536    2605  |   }
+           2606  |   pcAddrDesc=tmpAddrDesc;   /*<Judy 2/3/1997> */
    2537    2607  |   err2 = EnlEventNotify(EVENT_BKPT_HALTED);
    2538    2608  |   if (!err) err = err2;
===================
    2586    2656  |      DESCRIPTOR *pcAddrDesc, DESCRIPTOR *srcRangeDesc) {
    2587    2657  |   RETCODE err;
+           2658  |   BOOLEAN abortFromEsc = FALSE;
+           2659  |   U32 srcStart, srcEnd;
-   2588          |   BOOLEAN   abortFromEsc;
> ( 1798)   2660  |
+           2661  |   Sds2AbiFwUnloadRegisters(TRUE);
+           2662  |   if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
<   2589  ( 3148) |
    2590    2663  |   while (1) {
+           2664  |      ADDR_SEGSEL_TYPE segType;
+           2665  |      U16 seg;
+           2666  |      U32 addrSeg;
+           2667  |      BOOLEAN inRange;
<   2591  ( 2737) |      /*
-   2592          |      ** Disassemble source range, inserting breakpoints for each transfer
-   2593          |      ** Process whole range, even if PC starts in the middle.
<   2594  ( 2739) |      */
-   2595          |      if ((err = AdrCopyAddress(*srcRangeDesc, *pcAddrDesc)) != GOOD)
-   2596          |         return(err);   /* start at beginning of source range */
    2597    2668  |      if ((err = DadSetDasmAddr(dasmID, *pcAddrDesc)) != GOOD) return(err);
-   2598          |      while (1) {
-   2599          |         DESCRIPTOR bkptDesc, transferAddrDesc;
-   2600          |         TRANSFER_TYPE transferType;
-   2601          |         BOOLEAN inRange, bkptUsed;
> ( 1840)   2669  |
+           2670  |      while (2) {
+           2671  |     DESCRIPTOR bkptDesc, transferAddrDesc;
+           2672  |     TRANSFER_TYPE transferType;
> ( 1844)   2673  |
+           2674  |     if (GOOD != (err = TskCheckAbort(&abortFromEsc)))
+           2675  |        return err;
+           2676  |     if (abortFromEsc)
+           2677  |        return(ER_ABORT_FROM_ESC);
> ( 1847)   2678  |
+           2679  |     if ((err = AdrDuplicateAddress(*pcAddrDesc, &transferAddrDesc))
+           2680  |        != GOOD) return(err);
+           2681  |     if ((err = DadSetDasmAddr(dasmID, *pcAddrDesc)) != GOOD) return(err);
+           2682  |     if ((err = DadDasmIsTransfer(dasmID, transferAddrDesc, &transferType))
+           2683  |        != GOOD) {
+           2684  |        if (transferAddrDesc) AdrDestroyAddress(transferAddrDesc);
+           2685  |        return(err);
+           2686  |     }
+           2687  |     if (*pcAddrDesc) {
+           2688  |        if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
+           2689  |     }
+           2690  |     if ((err = DadGetDasmAddr(dasmID, pcAddrDesc)) != GOOD) return(err);
+           2691  |     if (transferType.transfer) {
+           2692  |        if (transferType.call) {
+           2693  |           BOOLEAN isFunc;
+           2694  |           if ((err = BxIsFunction(transferAddrDesc, &isFunc)) != GOOD)
+           2695  |          return(err);
+           2696  |           if (!isFunc || type == BX_STEP_OVER) {
+           2697  |          AdrGetAddrOffset(*pcAddrDesc, &srcStart);
+           2698  |          AdrGetAddrSegmentSelector(*pcAddrDesc, &segType, &seg);
+           2699  |          addrSeg = (U32)seg;
+           2700  |          srcStart += addrSeg << 16;
+           2701  |          if (iceRunUntil(srcStart) == ICE_USER_HALT) {
+           2702  |             if (transferAddrDesc) {
+           2703  |            if ((err = AdrDestroyAddress(transferAddrDesc)) != GOOD)
+           2704  |               return(err);
+           2705  |             }
+           2706  |             Sds2AbiFwUnloadRegisters(TRUE);
+           2707  |             return(ER_ABORT_FROM_ESC);
+           2708  |          }
+           2709  |           }
+           2710  |        } else { /* JMP or conditional JMP */
+           2711  |//               if (type == BX_STEP_OVER) {
+           2712  |          AdrGetAddrOffset(*srcRangeDesc, &srcStart);
+           2713  |          AdrGetAddrOffset(*pcAddrDesc, &srcEnd);
+           2714  |          AdrGetAddrSegmentSelector(*srcRangeDesc, &segType, &seg);
+           2715  |          addrSeg = (U32)seg;
+           2716  |          srcStart += addrSeg << 16;
+           2717  |          srcEnd += addrSeg << 16;
+           2718  |          iceStepRange(srcStart, srcEnd-1);
+           2719  |          Sds2AbiFwUnloadRegisters(TRUE);
+           2720  |          if (*pcAddrDesc) {
+           2721  |             if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) 
+           2722  |            return(err);
+           2723  |          }
+           2724  |          if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
+           2725  |//               }
+           2726  |        }
+           2727  |     }
+           2728  |     if (transferAddrDesc) {
+           2729  |        if ((err = AdrDestroyAddress(transferAddrDesc)) != GOOD)
+           2730  |           return(err);
+           2731  |     }
+           2732  |     if ((err = AdrIsAddrInRange(*pcAddrDesc, *srcRangeDesc, &inRange))
+           2733  |        != GOOD) return(err);
+           2734  |     if (!inRange) break;
+           2735  |      } /* while (2) */
> ( 2356)   2736  |
> ( 2591)   2737  |      /*
+           2738  |      ** step until PC is outside source range
> ( 2594)   2739  |      */
+           2740  |      Sds2AbiFwUnloadRegisters(TRUE);
+           2741  |      if (*pcAddrDesc) {
+           2742  |     if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
+           2743  |      }
+           2744  |      if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
+           2745  |      if ((err = AdrIsAddrInRange(*pcAddrDesc, *srcRangeDesc, &inRange))
+           2746  |     != GOOD) return(err);
+           2747  |      if (inRange) {
+           2748  |     AdrGetAddrOffset(*srcRangeDesc, &srcStart);
+           2749  |     AdrGetEndAddrOffset(*srcRangeDesc, &srcEnd);
+           2750  |     AdrGetAddrSegmentSelector(*srcRangeDesc, &segType, &seg);
+           2751  |     addrSeg = (U32)seg;
+           2752  |     srcStart += addrSeg << 16;
+           2753  |     srcEnd += addrSeg << 16;
+           2754  |     iceStepRange(srcStart, srcEnd);
+           2755  |      }
+           2756  |      Sds2AbiFwUnloadRegisters(TRUE);
+           2757  |      if (*pcAddrDesc) {
+           2758  |     if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
<   2602  ( 3166) |
<   2603  ( 3267) |
-   2604          |         err = TskCheckAbort(&abortFromEsc);
-   2605          |         if(err!=GOOD) return err;
-   2606          |         if (abortFromEsc)
-   2607          |            return(ER_ABORT_FROM_ESC);
<   2608  ( 3270) |
-   2609          |         if ((err = AdrDuplicateAddress(*pcAddrDesc, &transferAddrDesc))
-   2610          |            != GOOD) return(err);
-   2611          |         if ((err = DadSetDasmAddr(dasmID, *pcAddrDesc)) != GOOD) return(err);
-   2612          |         if ((err = DadDasmIsTransfer(dasmID, transferAddrDesc, &transferType))
-   2613          |            != GOOD) {
-   2614          |            AdrDestroyAddress(transferAddrDesc);
-   2615          |            return(err);
-   2616          |         }
-   2617          |         bkptUsed=FALSE;
-   2618          |         if (transferType.transfer) {
-   2619          |            if (transferType.call) {
-   2620          |               if ((type == BX_STEP_INTO) && transferType.destKnown) {
-   2621          |                  /* Dest known--set bkpt at destination if symbolic */
-   2622          |                  BOOLEAN isFunc;
-   2623          |                  if ((err = BxIsFunction(transferAddrDesc, &isFunc)) != GOOD)
-   2624          |                     return(err);
-   2625          |                  if (isFunc) {
-   2626          |                     if ((err = BxSetBkptWithSpaceFromSR(BX_ENABLED,BX_TEMPORARY_INTERNAL,
-   2627          |                        transferAddrDesc, &bkptDesc)) != GOOD) return(err);
-   2628          |                     bkptUsed=TRUE;
-   2629          |                  }
-   2630          |               } else if (type == BX_STEP_INTO) {
-   2631          |                  /* Destination unknown--Set bkpt at call instruction */
-   2632          |                  if ((err = AdrCopyAddress(*pcAddrDesc, transferAddrDesc))
-   2633          |                     != GOOD) return(err);
-   2634          |                  if ((err = BxSetBkptWithSpaceFromSR(BX_ENABLED,BX_TEMPORARY_INTERNAL,
-   2635          |                     transferAddrDesc, &bkptDesc)) != GOOD) return(err);
-   2636          |                  bkptUsed=TRUE;
-   2637          |               }
-   2638          |            } else if (transferType.destKnown) {
-   2639          |               if ((err = AdrIsAddrInRange(transferAddrDesc, *srcRangeDesc,
-   2640          |                  &inRange)) != GOOD) return(err);
-   2641          |               if (!inRange) {
-   2642          |                  if ((err = BxSetBkptWithSpaceFromSR(BX_ENABLED,BX_TEMPORARY_INTERNAL,
-   2643          |                     transferAddrDesc, &bkptDesc)) != GOOD) return(err);
-   2644          |                  bkptUsed=TRUE;
-   2645          |               }
-   2646          |            } else {
-   2647          |               if ((err = AdrCopyAddress(*pcAddrDesc, transferAddrDesc))
-   2648          |                  != GOOD) return(err);
-   2649          |               if ((err = BxSetBkptWithSpaceFromSR(BX_ENABLED,BX_TEMPORARY_INTERNAL,
-   2650          |                  transferAddrDesc, &bkptDesc)) != GOOD) return(err);
-   2651          |               bkptUsed=TRUE;
-   2652          |            }
-   2653          |         }
-   2654          |         if (!bkptUsed) {   /* no bkpt set above...have to destroy addr */
-   2655          |            if ((err = AdrDestroyAddress(transferAddrDesc)) != GOOD)
-   2656          |               return(err);
-   2657          |         }
-   2658          |         if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
-   2659          |         if ((err = DadGetDasmAddr(dasmID, pcAddrDesc)) != GOOD) return(err);
-   2660          |         if ((err = AdrIsAddrInRange(*pcAddrDesc, *srcRangeDesc, &inRange))
-   2661          |            != GOOD) return(err);
-   2662          |         if (!inRange) {
-   2663          |            if ((err = AdrDuplicateAddress(*pcAddrDesc, &transferAddrDesc))
-   2664          |               != GOOD) return(err);
-   2665          |            if ((err = BxSetBkptWithSpaceFromSR(BX_ENABLED,BX_TEMPORARY_INTERNAL,
-   2666          |               transferAddrDesc, &bkptDesc)) != GOOD) return(err);
-   2667          |            break;
-   2668          |         }
<   2669  ( 2940) |      }
> ( 2724)   2759  |      }
+           2760  |      if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
+           2761  |      
    2670    2762  |      /*
-   2671          |      ** Go/step until PC is outside source range
> ( 2711)   2763  |      ** If PC is at starting address of new source line, done
    2672    2764  |      */
-   2673          |      while (1) {
-   2674          |         BOOLEAN bkptMatch;
-   2675          |         BOOLEAN inRange;
<   2676  ( 3399) |
-   2677          |         err = TskCheckAbort(&abortFromEsc);
-   2678          |         if(err!=GOOD) return err;
-   2679          |         if (abortFromEsc)
-   2680          |            return(ER_ABORT_FROM_ESC);
<   2681  ( 3410) |
-   2682          |         if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
-   2683          |         if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
-   2684          |         if ((err = BxBkptMatchInternal(*pcAddrDesc, &bkptMatch)) != GOOD)
-   2685          |            return(err);
-   2686          |         if (!bkptMatch) {  /* Do not GO if bkpt on current instruction */
-   2687          |            if (!demonstrationVersion) {
-   2688          |               if ((err = BxMLStartEmulation(BX_GO_STEP)) != GOOD) return(err);
-   2689          |               if ((err = BxWaitForEmulationHalt()) != GOOD) return(err);
-   2690          |            } else {
-   2691          |               if ((err = BxStepUntilBkpt()) != GOOD) return(err);
-   2692          |            }                        //jerry
-   2693          |            if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
-   2694          |            if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
-   2695          |            if ((err = BxBkptMatchInternal(*pcAddrDesc, &bkptMatch)) != GOOD)
-   2696          |               return(err);
-   2697          |            if (!bkptMatch) return(GOOD);     /* hit some other breakpoint */
-   2698          |            if ((err = AdrIsAddrInRange(*pcAddrDesc, *srcRangeDesc, &inRange))
-   2699          |               != GOOD) return(err);
-   2700          |            if (!inRange) break;          /* we are out of source line */
-   2701          |         }
-   2702          |         if ((err =  BxLLAsmStepInto(1L)) != GOOD) return(err);
-   2703          |         if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
-   2704          |         if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
-   2705          |         if ((err = AdrIsAddrInRange(*pcAddrDesc, *srcRangeDesc, &inRange))
-   2706          |            != GOOD) return(err);
-   2707          |         if (!inRange) break;
<   2708  ( 3713) |      }
<   2709  ( 3320) |      BxRemoveAllInternalBkpts();
-   2710          |      /*
<   2711  ( 2763) |      ** If PC is at starting address of new source line, done
-   2712          |      */
    2713    2765  |      {
+           2766  |     ADDR_COMPARE result;
+           2767  |     if (*srcRangeDesc) {
+           2768  |        if ((err = AdrDestroyAddress(*srcRangeDesc)) != GOOD) return(err);
+           2769  |     }
+           2770  |     if ((err = BxGetSrcAddressRange(*pcAddrDesc,gran,srcRangeDesc))
+           2771  |        != GOOD) {
+           2772  |        *srcRangeDesc = NULL;
+           2773  |        break;   /* err set when pc is not in any source module */
+           2774  |     }
+           2775  |     if ((err = AdrCompareAddresses(*srcRangeDesc, *pcAddrDesc, &result))
+           2776  |        != GOOD) return(err);
-   2714          |         ADDR_COMPARE result;
-   2715          |         if ((err = AdrDestroyAddress(*srcRangeDesc)) != GOOD) return(err);
-   2716          |         if ((err = BxGetSrcAddressRange(*pcAddrDesc,gran,srcRangeDesc))
-   2717          |            != GOOD) {
-   2718          |            *srcRangeDesc = NULL;
-   2719          |            break;   /* err set when pc is not in any source module */
-   2720          |         }
-   2721          |         if ((err = AdrCompareAddresses(*srcRangeDesc, *pcAddrDesc, &result))
-   2722          |            != GOOD) return(err);
-   2723          |         if (result == EQUAL_ADDRS) break;
> ( 2353)   2777  |         if (result == EQUAL_ADDRS) {
+           2778  |            /* <Judy 2/3/1997> */
+           2779  |            if (*pcAddrDesc) {
+           2780  |               if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
> (  994)   2781  |            }
+           2782  |            /* <Judy 2/3/1997> */
> ( 1011)   2783  |         }
> ( 1005)   2784  |         break;
+           2785  |      }
+           2786  |   } /* while (1) */
<   2724  ( 2759) |      }
<   2725  ( 2941) |   }
===================
    2750    2811  |      DESCRIPTOR *pcAddrDesc, DESCRIPTOR *srcRangeDesc) {
    2751    2812  |   RETCODE err;
+           2813  |   BOOLEAN abortFromEsc;
-   2752          |   BOOLEAN   abortFromEsc;
<   2753  ( 3444) |
    2754    2814  |
===================
    2758    2818  |      DESCRIPTOR nextAddrDesc, bkptDesc;
    2759    2819  |
+           2820  |      if ((err = TskCheckAbort(&abortFromEsc)) != GOOD)
+           2821  |     return err;
+           2822  |      if (abortFromEsc)
+           2823  |     return ER_ABORT_FROM_ESC;
<   2760  ( 3823) |      err = TskCheckAbort(&abortFromEsc);
-   2761          |      if(err!=GOOD) return err;
-   2762          |      if (abortFromEsc!=0)
-   2763          |         return(ER_ABORT_FROM_ESC);
    2764    2824  |
    2765    2825  |      if ((err = DadSetDasmAddr(dasmID, *pcAddrDesc)) != GOOD) return(err);
    2766    2826  |      if ((err = DadDasmIsTransfer(dasmID, *pcAddrDesc, &transferType))
+           2827  |     != GOOD) return(err);
-   2767          |         != GOOD) return(err);
    2768    2828  |      bkptUsed=FALSE;
    2769    2829  |      if (transferType.transfer && transferType.call) {
+           2830  |     BOOLEAN isFunc=FALSE;
+           2831  |     if ((type == BX_STEP_INTO) && transferType.destKnown) {
+           2832  |        if ((err = BxIsFunction(*pcAddrDesc, &isFunc)) != GOOD)
+           2833  |           return(err);
+           2834  |     }
+           2835  |     if (!isFunc || (type == BX_STEP_OVER)) {
+           2836  |        /* set bkpt on instruction after call */
+           2837  |        if ((err = DadGetDasmAddr(dasmID, &nextAddrDesc)) != GOOD)
+           2838  |           return(err);
+           2839  |        if ((err = BxSetBkpt(BX_ENABLED,BX_TEMPORARY_INTERNAL,
+           2840  |           nextAddrDesc, &bkptDesc)) != GOOD) return(err);
+           2841  |        bkptUsed=TRUE;
+           2842  |        if (!demonstrationVersion) {
+           2843  |           if ((err = BxMLStartEmulation(BX_GO_STEP))!=GOOD) return(err);
+           2844  |           if ((err = BxWaitForEmulationHalt()) != GOOD) return(err);
+           2845  |        } else {
+           2846  |           if ((err = BxStepUntilBkpt()) != GOOD) return(err);
+           2847  |        }
+           2848  |        if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
+           2849  |        if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
+           2850  |        if ((err = BxBkptMatchInternal(*pcAddrDesc, &bkptMatch)) != GOOD)
+           2851  |           return(err);
+           2852  |        BxRemoveAllInternalBkpts();
+           2853  |        if (!bkptMatch) return(GOOD);
+           2854  |     }
-   2770          |         BOOLEAN isFunc=FALSE;
-   2771          |         if ((type == BX_STEP_INTO) && transferType.destKnown) {
-   2772          |            if ((err = BxIsFunction(*pcAddrDesc, &isFunc)) != GOOD)
-   2773          |               return(err);
-   2774          |         }
-   2775          |         if (!isFunc || (type == BX_STEP_OVER)) {
-   2776          |            /* set bkpt on instruction after call */
-   2777          |            if ((err = DadGetDasmAddr(dasmID, &nextAddrDesc)) != GOOD)
-   2778          |               return(err);
-   2779          |            if ((err = BxSetBkptWithSpaceFromSR(BX_ENABLED,BX_TEMPORARY_INTERNAL,
-   2780          |               nextAddrDesc, &bkptDesc)) != GOOD) return(err);
-   2781          |            bkptUsed=TRUE;
-   2782          |            if (!demonstrationVersion) {
-   2783          |               if ((err = BxMLStartEmulation(BX_GO_STEP))!=GOOD) return(err);
-   2784          |               if ((err = BxWaitForEmulationHalt()) != GOOD) return(err);
-   2785          |            } else {
-   2786          |               if ((err = BxStepUntilBkpt()) != GOOD) return(err);
-   2787          |            }
-   2788          |            if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
-   2789          |            if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
-   2790          |            if ((err = BxBkptMatchInternal(*pcAddrDesc, &bkptMatch)) != GOOD)
-   2791          |               return(err);
-   2792          |            BxRemoveAllInternalBkpts();
-   2793          |            if (!bkptMatch) return(GOOD);
-   2794          |         }
    2795    2855  |      }
    2796    2856  |      if (!bkptUsed) {         /* no GO done above...do step */
+           2857  |     if ((err = BxLLAsmStepInto(1L)) != GOOD) return(err);
+           2858  |     if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
+           2859  |     if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
-   2797          |         if ((err = BxLLAsmStepInto(1L)) != GOOD) return(err);
-   2798          |         if ((err = AdrDestroyAddress(*pcAddrDesc)) != GOOD) return(err);
-   2799          |         if ((err = CpuGetPC(pcAddrDesc)) != GOOD) return(err);
    2800    2860  |      }
    2801    2861  |      if ((err = AdrIsAddrInRange(*pcAddrDesc, *srcRangeDesc, &inRange))
+           2862  |      != GOOD) return(err);
-   2802          |          != GOOD) return(err);
    2803    2863  |      if (inRange) continue;   /* still in original source range */
    2804    2864  |      /*
    2805    2865  |      ** If PC is at starting address of new source line, done
    2806    2866  |      */
    2807    2867  |      {
+           2868  |     ADDR_COMPARE result;
+           2869  |     if ((err = AdrDestroyAddress(*srcRangeDesc)) != GOOD) return(err);
+           2870  |     if ((err = BxGetSrcAddressRange(*pcAddrDesc,gran,srcRangeDesc))
+           2871  |        != GOOD) {
+           2872  |        *srcRangeDesc = NULL;
+           2873  |        break;
+           2874  |     }
+           2875  |     if ((err = AdrCompareAddresses(*srcRangeDesc, *pcAddrDesc, &result))
+           2876  |        != GOOD) return(err);
+           2877  |     if (result == EQUAL_ADDRS) break;
-   2808          |         ADDR_COMPARE result;
-   2809          |         if ((err = AdrDestroyAddress(*srcRangeDesc)) != GOOD) return(err);
-   2810          |         if ((err = BxGetSrcAddressRange(*pcAddrDesc,gran,srcRangeDesc))
-   2811          |            != GOOD) {
-   2812          |            *srcRangeDesc = NULL;
-   2813          |            break;
-   2814          |         }
-   2815          |         if ((err = AdrCompareAddresses(*srcRangeDesc, *pcAddrDesc, &result))
-   2816          |            != GOOD) return(err);
-   2817          |         if (result == EQUAL_ADDRS) break;
    2818    2878  |      }
    2819    2879  |   }
===================
    2834    2894  |   U32 offset;
    2835    2895  |   *isFunc = FALSE;
> ( 2425)   2896  |
    2836    2897  |   err = SymMapAddr2Symbol(addrDesc, &memoryClass, &symbolType, &offset,
    2837    2898  |      &outputSymbol, &funcDescriptor, &moduleDescriptor);
    2838    2899  |   if (err == ER_ADDRESS_NOT_FOUND) {
    2839    2900  |      *isFunc = FALSE;
    2840    2901  |      return(GOOD);
+           2902  |   } else if (err != GOOD) return(err);
+           2903  |   *isFunc = (funcDescriptor != NULL_SYMBOL);
<   2841  ( 3047) |   }
-   2842          |   else if (err != GOOD) return(err);
<   2843  ( 3465) |
-   2844          |   if (funcDescriptor != NULL_SYMBOL)
-   2845          |      *isFunc = TRUE;
-   2846          |   else if (funcDescriptor == NULL_SYMBOL && moduleDescriptor != NULL_SYMBOL)
-   2847          |      *isFunc = TRUE;
    2848    2904  |   return(GOOD);
    2849    2905  |}
===================
    2856    2912  |RETCODE EXPORT
    2857    2913  |BxGoUntilCallReturn(BX_GRANULARITY      gran,
+           2914  |            BX_CALL_RETURN_TYPE callReturnType) {
-   2858          |                    BX_CALL_RETURN_TYPE callReturnType) {
    2859    2915  |
    2860    2916  |   RETCODE err, firstErr;
===================
    2864    2920  |
    2865    2921  |   /* set up for go until */
+           2922  |   if (GOOD != (err = BxLocalGoUntilCallReturn(gran, callReturnType))) {
-   2866          |   if (GOOD != (err = BxLocalGoUntilCallReturn(gran, callReturnType)))
> ( 2875)   2923  |      BxRemoveAllInternalBkpts();
    2867    2924  |      return err;
> ( 1855)   2925  |   }
> ( 2472)   2926  |
<   2868  ( 3490) |
    2869    2927  |   /* set up for the callback */
    2870    2928  |   granState = gran;  /* needed after emu halted */
> ( 2483)   2929  |
+           2930  |   if (demonstrationVersion) {
+           2931  |      if (GOOD != (err = BxStepUntilBkpt())) {
+           2932  |     BxRemoveAllInternalBkpts();
+           2933  |     return err;
+           2934  |      }
+           2935  |   } else {
+           2936  |      /* start emulation */
+           2937  |      if (GOOD != (err = BxMLStartEmulation(BX_GO_UNTIL))) {
+           2938  |     BxRemoveAllInternalBkpts();
+           2939  |     return err;
> ( 2669)   2940  |      }
> ( 2725)   2941  |   }
<   2871  ( 3527) |
-   2872          |if(demonstrationVersion) {
<   2873  ( 3576) |
-   2874          |   if (GOOD != (err = BxStepUntilBkpt())) {
<   2875  ( 2923) |      BxRemoveAllInternalBkpts();
<   2876  ( 3269) |      return err;
<   2877  ( 3279) |   }
<   2878  ( 3987) |} else {
-   2879          |   /* start emulation */
-   2880          |   if (GOOD != (err = BxMLStartEmulation(BX_GO_UNTIL))) {
<   2881  ( 2599) |      BxRemoveAllInternalBkpts();
<   2882  ( 3321) |      return err;
===================
    2929    2986  |RETCODE PRIVATE
    2930    2987  |BxLocalGoUntilCallReturn(BX_GRANULARITY      gran,
+           2988  |             BX_CALL_RETURN_TYPE callReturnType) {
-   2931          |                         BX_CALL_RETURN_TYPE callReturnType) {
    2932    2989  |
    2933    2990  |   RETCODE err = GOOD, firstErr = GOOD;
    2934    2991  |   SYM_DESCRIPTOR currentFunc;
+           2992  |   DESCRIPTOR     funcAddrDesc, dasmAddrDesc, linenumAddrDesc,
+           2993  |          bkptAddrRangeDesc, dummyAddrDesc;
-   2935          |   DESCRIPTOR     funcAddrDesc, dasmAddrDesc, linenumAddrDesc, bkptAddrRangeDesc;
-   2936          |   DESCRIPTOR     dummyAddrDesc;
-   2937          |   LPSTR          nameStrPtr;
    2938    2994  |   FUNC_CLASS     funcClass;
    2939    2995  |   U32            stackSize;
+           2996  |   BOOLEAN        isValidCall, isInRange, bkptAlreadySet = FALSE;
-   2940          |   BOOLEAN        isValidCall;
-   2941          |   BOOLEAN        isInRange, bkptAlreadySet = FALSE;
    2942    2997  |   DESCRIPTOR     bkptDesc;   /* return value from setting bkpt */
    2943    2998  |   U16            localBkptCount = 0;
===================
    2959    3013  |      return ER_SYM_NO_FUNCTION_MATCH;
    2960    3014  |   /* Use the current PC instead of the default address descriptor */
+           3015  |   if (GOOD != (err = CpuGetPC(&funcAddrDesc)))  return err;
-   2961          |   if (GOOD != (err = CpuGetPC(&funcAddrDesc)))
<   2962  ( 3702) |      return err;
    2963    3016  |   if (GOOD != (err = AdrDuplicateAddress(funcAddrDesc, &dummyAddrDesc)))
===================
    2966    3019  |      goto CLEANUP_3;
    2967    3020  |
-   2968          |   nameStrPtr = TMalloc(MAX_SYMNAME_LENGTH);
-   2969          |   if (!nameStrPtr)
-   2970          |      return ER_OUT_OF_MEMORY;
    2971    3021  |   firstErr = SymGetFunc(currentFunc,
+           3022  |             (LPSTR)dummyNameStr,  /* name not used */
+           3023  |             &funcClass,
+           3024  |             &stackSize,
+           3025  |             funcAddrDesc);
-   2972          |                         nameStrPtr,  /* name not used */
-   2973          |                         &funcClass,
-   2974          |                         &stackSize,
-   2975          |                         funcAddrDesc);
-   2976          |   err = TFree((LPSTR)nameStrPtr);
-   2977          |   if (firstErr || err) {
> ( 2484)   3026  |
+           3027  |   if (firstErr != GOOD) goto CLEANUP_3;
+           3028  |   
<   2978  ( 3046) |      goto CLEANUP_3;
<   2979  ( 3475) |   }
===================
    2986    3035  |   /* start disassembling at beginning of function */
    2987    3036  |   if (GOOD != (err = AdrDuplicateAddress(funcAddrDesc,
+           3037  |                      &dasmAddrDesc)))
-   2988          |                                          &dasmAddrDesc)))
    2989    3038  |       goto CLEANUP_3;
    2990    3039  |
    2991    3040  |   /* init the linenum range */
    2992    3041  |   if (GOOD != (err = BxGetSrcAddressRange(dasmAddrDesc,
+           3042  |                       gran,
+           3043  |                       &linenumAddrDesc))) {
+           3044  |      // linenumAddrDesc is already destroyed
+           3045  |      AdrDestroyAddress(dasmAddrDesc);
-   2993          |                                           gran,
-   2994          |                                           &linenumAddrDesc)))
-   2995          |      goto CLEANUP_2;
> ( 2978)   3046  |      goto CLEANUP_3;
> ( 2841)   3047  |   }
+           3048  |   
<   2996  ( 3694) |
    2997    3049  |   /* set up start address of disassembly; does NOT consume addr */
===================
    3009    3061  |      /* disassemble instruction */
    3010    3062  |      if (GOOD != (err =
+           3063  |     DadDasmIsCallOrRTS(dasmID, dummyAddrDesc, &instrType)))
+           3064  |     goto CLEANUP_1;
-   3011          |         DadDasmIsCallOrRTS(dasmID, dummyAddrDesc, &instrType)))
-   3012          |         goto CLEANUP_1;
    3013    3065  |
    3014    3066  |      if ((instrType == INST_CALL) && (callReturnType == BX_CALL_RETURN)) {
+           3067  |     /* see if destination address is valid function;
+           3068  |        if not, don't set bkpt on */
+           3069  |     MEM_ADDR_CLASS memoryClass;
+           3070  |     SYM_TYPE_TYPE  symbolType;
+           3071  |     SYM_DESCRIPTOR outputSymbol, funcDescriptor, moduleDescriptor;
+           3072  |     U32            offset;
-   3015          |         /* see if destination address is valid function;
-   3016          |            if not, don't set bkpt on */
-   3017          |         MEM_ADDR_CLASS memoryClass;
-   3018          |         SYM_TYPE_TYPE  symbolType;
-   3019          |         SYM_DESCRIPTOR outputSymbol, funcDescriptor, moduleDescriptor;
-   3020          |         U32            offset;
> ( 2518)   3073  |
+           3074  |     if (GOOD != (err = SymMapAddr2Symbol(dummyAddrDesc,
+           3075  |                          &memoryClass,
+           3076  |                          &symbolType,
+           3077  |                          &offset,
+           3078  |                          &outputSymbol,
+           3079  |                          &funcDescriptor,
+           3080  |                          &moduleDescriptor))) {
+           3081  |        goto CLEANUP_1;
+           3082  |     }
+           3083  |     if (funcDescriptor != NULL_SYMBOL) {  /* function found */
+           3084  |        isValidCall = TRUE;
+           3085  |     }
<   3021  ( 3700) |
-   3022          |         if (GOOD != (err = SymMapAddr2Symbol(dummyAddrDesc,
-   3023          |                                              &memoryClass,
-   3024          |                                              &symbolType,
-   3025          |                                              &offset,
-   3026          |                                              &outputSymbol,
-   3027          |                                              &funcDescriptor,
-   3028          |                                              &moduleDescriptor))) {
-   3029          |            goto CLEANUP_1;
-   3030          |         }
-   3031          |         if (funcDescriptor != NULL_SYMBOL) {  /* function found */
-   3032          |            isValidCall = TRUE;
-   3033          |         }
    3034    3086  |      }
    3035    3087  |      if (isValidCall || (instrType == INST_RETURN)) {
+           3088  |     if (BX_ASM_GRAN == gran) {
-   3036          |         if (BX_ASM_GRAN == gran) {
> ( 2519)   3089  |
+           3090  |        /* dup the disasm address and set bkpt on it */
+           3091  |        if (GOOD != (err =
+           3092  |           AdrDuplicateAddress(dasmAddrDesc, &bkptAddrRangeDesc)))
+           3093  |           goto CLEANUP_1;
+           3094  |        /* remove processor dependency */
+           3095  |        if (FAMILY_68K == staticProcFamily) {
+           3096  |           if(GOOD != (err = AdrSetAddrSpace(bkptAddrRangeDesc, SPACE_SP)))
+           3097  |          return err;
+           3098  |        }
+           3099  |        if (GOOD != (err =
+           3100  |           BxSetBkpt(BX_ENABLED, BX_TEMPORARY_INTERNAL,
+           3101  |             bkptAddrRangeDesc, &bkptDesc)))  { /* consumes addr */
+           3102  |           goto CLEANUP_1;
+           3103  |        }
+           3104  |        localBkptCount++;
> ( 2527)   3105  |
+           3106  |     } else { /* line or stmt gran */
+           3107  |        /* !!! insert test for destination with source */
+           3108  |        if (GOOD != (err =
+           3109  |           AdrIsAddrInRange(dasmAddrDesc, linenumAddrDesc, &isInRange)))
+           3110  |          goto CLEANUP_1;
+           3111  |        if (!isInRange) {  /* outside linenum range; get new one */
+           3112  |           /* at this point linenumAddrDesc is valid; must destroy and
+           3113  |          get new one from BxGetSrcAddressRange */
+           3114  |           if (GOOD != (err = AdrDestroyAddress(linenumAddrDesc)))
+           3115  |          goto CLEANUP_1;
+           3116  |           if (GOOD != (err =
+           3117  |          BxGetSrcAddressRange(dasmAddrDesc,
+           3118  |                       gran,
+           3119  |                       &linenumAddrDesc))) { /* creates addr */
+           3120  |          // linenumAddrDesc is already destroyed
+           3121  |          AdrDestroyAddress(dasmAddrDesc);
+           3122  |          goto CLEANUP_3;
+           3123  |           }
<   3037  ( 3703) |
-   3038          |            /* dup the disasm address and set bkpt on it */
-   3039          |            if (GOOD != (err =
-   3040          |               AdrDuplicateAddress(dasmAddrDesc, &bkptAddrRangeDesc)))
-   3041          |               goto CLEANUP_1;
-   3042          |            /* remove processor dependency */
-   3043          |            if (FAMILY_68K == staticProcFamily) {
-   3044          |               if(GOOD != (err = BxSetAddrSpace(bkptAddrRangeDesc)))
-   3045          |                  return err;
-   3046          |            }
-   3047          |            if (GOOD != (err =
-   3048          |               BxSetBkptWithSpaceFromSR(BX_ENABLED, BX_TEMPORARY_INTERNAL,
-   3049          |                         bkptAddrRangeDesc, &bkptDesc)))  { /* consumes addr */
-   3050          |               goto CLEANUP_1;
-   3051          |            }
-   3052          |            localBkptCount++;
<   3053  ( 3706) |
-   3054          |         } else { /* line or stmt gran */
-   3055          |            /* !!! insert test for destination with source */
-   3056          |            if (GOOD != (err =
-   3057          |               AdrIsAddrInRange(dasmAddrDesc, linenumAddrDesc, &isInRange)))
-   3058          |                  goto CLEANUP_1;
-   3059          |            if (!isInRange) {  /* outside linenum range; get new one */
-   3060          |               /* at this point linenumAddrDesc is valid; must destroy and
-   3061          |                  get new one from BxGetSrcAddressRange */
-   3062          |               if (GOOD != (err = AdrDestroyAddress(linenumAddrDesc)))
-   3063          |                  goto CLEANUP_1;
-   3064          |               if (GOOD != (err =
-   3065          |                  BxGetSrcAddressRange(dasmAddrDesc,
-   3066          |                                       gran,
-   3067          |                                       &linenumAddrDesc))){ /* creates addr */
-   3068          |                  goto CLEANUP_1;
-   3069          |               }
> ( 3096)   3124  |#ifdef DEBUG
> ( 3097)   3125  |/* !!! test code */
+           3126  |           err = AdrGetAddrOffset(linenumAddrDesc, &tStartAddr);
+           3127  |           err = AdrGetEndAddrOffset(linenumAddrDesc, &tEndAddr);
> ( 3099)   3128  |#endif
+           3129  |           bkptAlreadySet = FALSE;
+           3130  |        }
+           3131  |        if (!bkptAlreadySet) {
+           3132  |           if (GOOD != (err = AdrDuplicateAddress(linenumAddrDesc,
+           3133  |                              &bkptAddrRangeDesc)))
+           3134  |          goto CLEANUP_1;
+           3135  |           /* remove processor dependency */
+           3136  |           if (FAMILY_68K == staticProcFamily) {
+           3137  |          if (GOOD != (err =
+           3138  |                   AdrSetAddrSpace(bkptAddrRangeDesc, SPACE_SP))) {
+           3139  |             AdrDestroyAddress(bkptAddrRangeDesc);
+           3140  |             goto CLEANUP_1;
+           3141  |          }
+           3142  |           }
+           3143  |           if (GOOD != (err =
+           3144  |          BxSetBkpt(BX_ENABLED, BX_TEMPORARY_INTERNAL,
+           3145  |                bkptAddrRangeDesc, &bkptDesc))) {  /* saves addr */
+           3146  |          goto CLEANUP_1;
+           3147  |           }
> ( 2589)   3148  |
    3070    3149  |#ifdef DEBUG
    3071    3150  |/* !!! test code */
+           3151  |           err = AdrGetAddrOffset(bkptAddrRangeDesc, &tBkptAddr);
-   3072          |               err = AdrGetAddrOffset(linenumAddrDesc, &tStartAddr);
-   3073          |               err = AdrGetEndAddrOffset(linenumAddrDesc, &tEndAddr);
    3074    3152  |#endif
+           3153  |           bkptAlreadySet = TRUE;
+           3154  |           localBkptCount++;
+           3155  |        }
+           3156  |     } /* end of gran if stmt */
-   3075          |               bkptAlreadySet = FALSE;
-   3076          |            }
-   3077          |            if (!bkptAlreadySet) {
<   3078  ( 3812) |
-   3079          |               if (GOOD != (err = AdrDuplicateAddress(linenumAddrDesc,
-   3080          |                                                      &bkptAddrRangeDesc)))
-   3081          |                  goto CLEANUP_1;
-   3082          |               /* remove processor dependency */
-   3083          |               if (FAMILY_68K == staticProcFamily) {
-   3084          |                  if (GOOD != (err =
-   3085          |                               BxSetAddrSpace(bkptAddrRangeDesc))) {
-   3086          |                     AdrDestroyAddress(bkptAddrRangeDesc);
-   3087          |                     goto CLEANUP_1;
-   3088          |                  }
-   3089          |               }
-   3090          |               if (GOOD != (err =
-   3091          |                  BxSetBkptWithSpaceFromSR(BX_ENABLED, BX_TEMPORARY_INTERNAL,
-   3092          |                            bkptAddrRangeDesc, &bkptDesc))) {  /* saves addr */
-   3093          |                  goto CLEANUP_1;
-   3094          |               }
<   3095  ( 3822) |
<   3096  ( 3124) |#ifdef DEBUG
<   3097  ( 3125) |/* !!! test code */
-   3098          |               err = AdrGetAddrOffset(bkptAddrRangeDesc, &tBkptAddr);
<   3099  ( 3128) |#endif
-   3100          |               bkptAlreadySet = TRUE;
-   3101          |               localBkptCount++;
-   3102          |            }
-   3103          |         } /* end of gran if stmt */
    3104    3157  |      } /* end of if (instrType == INST_CALL) */
    3105    3158  |
    3106    3159  |      /* get rid of previous addr copy */
    3107    3160  |      if (GOOD != (err = AdrDestroyAddress(dasmAddrDesc)))
+           3161  |     goto CLEANUP_2;
-   3108          |         goto CLEANUP_2;
    3109    3162  |
    3110    3163  |      /* check to see if still in the function range (produces new addr) */
    3111    3164  |      if (GOOD != (err = DadGetDasmAddr(dasmID, &dasmAddrDesc)))
+           3165  |     goto CLEANUP_2;
-   3112          |         goto CLEANUP_2;
> ( 2602)   3166  |
<   3113  ( 3847) |
    3114    3167  |      if (GOOD != (err =
+           3168  |     AdrIsAddrInRange(dasmAddrDesc, funcAddrDesc, &isInRange)))
+           3169  |     goto CLEANUP_1;
-   3115          |         AdrIsAddrInRange(dasmAddrDesc, funcAddrDesc, &isInRange)))
-   3116          |         goto CLEANUP_1;
    3117    3170  |
    3118    3171  |      if (!isInRange)  /* outside function range */
+           3172  |     break; /* leave while loop */
-   3119          |         break; /* leave while loop */
    3120    3173  |
    3121    3174  |#ifdef DEBUG
===================
    3205    3258  |RETCODE EXPORT
    3206    3259  |BxGoIntoCallReturn(BX_GRANULARITY      gran,
+           3260  |           BX_CALL_RETURN_TYPE callReturnType) {
-   3207          |                   BX_CALL_RETURN_TYPE callReturnType) {
    3208    3261  |
    3209    3262  |   RETCODE     err, firstErr = GOOD;
    3210    3263  |   DESCRIPTOR  currentPCDesc, dummyAddrDesc;
    3211    3264  |   CALL_TYPE   instrType;
+           3265  |   U32 retPC;
+           3266  |   BOOLEAN inValid;
> ( 2603)   3267  |
> ( 1623)   3268  |   if((err = BkProcessorMustBeHaltedAbsolute())!=GOOD)
> ( 2876)   3269  |      return err;
> ( 2608)   3270  |
+           3271  |   if (callReturnType == BX_RETURN_ONLY) {
+           3272  |      GetReturnPC(&retPC, &inValid);
+           3273  |      if (inValid == TRUE) goto OTHER_WAY;
+           3274  |      err = iceRunUntil(retPC);
+           3275  |      Sds2AbiFwUnloadRegisters(TRUE);
+           3276  |      EnlEventNotify(EVENT_BKPT_HALTED);
+           3277  |      if (err == ICE_USER_HALT) return(ER_ABORT_FROM_ESC);
+           3278  |      else return (GOOD);
> ( 2877)   3279  |   }
+           3280  |OTHER_WAY:
<   3212  ( 3945) |
-   3213          |   if((err = BkProcessorMustBeHaltedAbsolute())!=GOOD)
<   3214  ( 1216) |      return err;
<   3215  (  974) |
===================
    3252    3317  |   /* use asm granularity in order to set bkpts on JSR and RTS so after
    3253    3318  |      the bkpt, one single step will go into or out of the function */
+           3319  |   if (GOOD != (err = BxLocalGoUntilCallReturn(BX_ASM_GRAN, callReturnType))) {
-   3254          |   if (GOOD != (err = BxLocalGoUntilCallReturn(BX_ASM_GRAN, callReturnType)))
> ( 2709)   3320  |      BxRemoveAllInternalBkpts();
> ( 2882)   3321  |      return err;
> ( 2883)   3322  |   }
<   3255  (  973) |      return err;
    3256    3323  |
===================
    3311    3378  |   if (bkptWasSet) { /* only check for internal bkpt if some set */
    3312    3379  |      if (GOOD != (err = CpuGetPC(&currentPCDesc))) /* allocs address */
+           3380  |     goto CLEANUP_2;
-   3313          |         goto CLEANUP_2;
    3314    3381  |
    3315    3382  |      if (GOOD != (err = BxBkptMatchInternal(currentPCDesc, &match)))
+           3383  |     goto CLEANUP_1;
-   3316          |         goto CLEANUP_1;
    3317    3384  |
    3318    3385  |      if (GOOD != (err = AdrDestroyAddress(currentPCDesc)))
+           3386  |     goto CLEANUP_2;
-   3319          |         goto CLEANUP_2;
    3320    3387  |   }
    3321    3388  |   if ((match) || (!bkptWasSet)) {
    3322    3389  |      if (GOOD != (err = BxLLAsmStepInto(1L)))
+           3390  |     goto CLEANUP_2;
-   3323          |         goto CLEANUP_2;
    3324    3391  |
    3325    3392  |      if (BX_ASM_GRAN != granState) {
+           3393  |     /* get currentPC; get line/stmt range of that addr */
+           3394  |     if (GOOD != (err = CpuGetPC(&currentPCDesc)))
+           3395  |        goto CLEANUP_2;
+           3396  |     if (GOOD != (err =
+           3397  |        BxGetSrcAddressRange(currentPCDesc, granState, &linenumAddrDesc)))
+           3398  |        goto CLEANUP_1;
-   3326          |         /* get currentPC; get line/stmt range of that addr */
-   3327          |         if (GOOD != (err = CpuGetPC(&currentPCDesc)))
-   3328          |            goto CLEANUP_2;
-   3329          |         if (GOOD != (err =
-   3330          |            BxGetSrcAddressRange(currentPCDesc, granState, &linenumAddrDesc)))
-   3331          |            goto CLEANUP_1;
> ( 2676)   3399  |
+           3400  |     /* compare currentPC addr to line/stmt start of range.
+           3401  |        if same, done, else step into for this line/stmt */
+           3402  |     if (GOOD != (err = AdrCompareAddresses(currentPCDesc,
+           3403  |                        linenumAddrDesc,
+           3404  |                        &compareResult)))
+           3405  |        goto CLEANUP_1;
+           3406  |     if (GOOD != (err = AdrDestroyAddress(currentPCDesc)))
+           3407  |        goto CLEANUP_2;
+           3408  |     if (GOOD != (err = AdrDestroyAddress(linenumAddrDesc)))
+           3409  |        goto CLEANUP_2;
> ( 2681)   3410  |
+           3411  |     if (EQUAL_ADDRS != compareResult) {
+           3412  |        err = BxSrcStep(BX_STEP_INTO, granState, 1L);
+           3413  |     }
+           3414  |     /* fall thru to CLEANUP_1 */
<   3332  ( 3953) |
-   3333          |         /* compare currentPC addr to line/stmt start of range.
-   3334          |            if same, done, else step into for this line/stmt */
-   3335          |         if (GOOD != (err = AdrCompareAddresses(currentPCDesc,
-   3336          |                                                linenumAddrDesc,
-   3337          |                                                &compareResult)))
-   3338          |            goto CLEANUP_1;
-   3339          |         if (GOOD != (err = AdrDestroyAddress(currentPCDesc)))
-   3340          |            goto CLEANUP_2;
-   3341          |         if (GOOD != (err = AdrDestroyAddress(linenumAddrDesc)))
-   3342          |            goto CLEANUP_2;
<   3343  ( 3968) |
-   3344          |         if (EQUAL_ADDRS != compareResult) {
-   3345          |            err = BxSrcStep(BX_STEP_INTO, granState, 1L);
-   3346          |         }
-   3347          |         /* fall thru to CLEANUP_1 */
    3348    3415  |      }
    3349    3416  |   }
===================
    3375    3442  |   return firstErr;
    3376    3443  |} /* end of BxGoIntoCallReturnPostBkpt */
> ( 2753)   3444  |
+           3445  |VOID GetReturnPC(U32 *retPC, BOOLEAN *inValid)
+           3446  |{
> ( 4171)   3447  |RETCODE err;
+           3448  |MEM_ADDR_CLASS memClass;
+           3449  |SYM_TYPE_TYPE symType;
+           3450  |U32 offset;
+           3451  |U32 retType;
+           3452  |SYM_DESCRIPTOR symDesc,funcDesc,modDesc;
+           3453  |U32 spPtr, retIP, retCS, curSS;
+           3454  |U8 tmpBuff[10];
+           3455  |BOOLEAN framedFunction = TRUE;
+           3456  |DESCRIPTOR PCAddrDesc=NULL, tmpAddrDesc=NULL;
+           3457  |U8 level;
+           3458  |U32 attribute;
+           3459  |TYPE_HEADER_TYPE temphdr;
+           3460  |U8 tempbuf[MAX_SYMNAME_LENGTH];
+           3461  |FUNC_INFO_TYPE funcInfo;
+           3462  |ADDR_SEGSEL_TYPE segType;
+           3463  |U16 seg;
+           3464  |U32 addrSeg, funcStart;
> ( 2843)   3465  |
+           3466  |   *inValid = TRUE;
+           3467  |   Sds2AbiFwUnloadRegisters(TRUE);
+           3468  |   if ((err = CpuGetPC(&PCAddrDesc)) != GOOD)
+           3469  |      goto CLEANUP2;
+           3470  |   if ((err = SymMapAddr2Symbol(PCAddrDesc,&memClass,&symType,&offset,
+           3471  |                &symDesc,&funcDesc,&modDesc)) != GOOD) {
+           3472  |      // Returns an err based on address discrepancies
+           3473  |      // not lack of symbol information. 
+           3474  |      goto CLEANUP2;
> ( 2979)   3475  |   }
+           3476  |   if ((funcDesc == NULL_SYMBOL) && (memClass != CODE_ADDR))  {
+           3477  |      goto CLEANUP2;
+           3478  |   }
+           3479  |   temphdr.typeName = (LPSTR)tempbuf;
+           3480  |   funcInfo.funcNamePtr = (LPSTR)funcInfo.funcName;
+           3481  |   *(funcInfo.funcNamePtr) = '\0';
+           3482  |   funcInfo.functionDesc = funcDesc;
+           3483  |   funcInfo.moduleDesc = modDesc;
+           3484  |   funcInfo.frameType = -1;
+           3485  |   funcInfo.numParams = 0;
+           3486  |   funcInfo.firstLocal = 0;
+           3487  |   funcInfo.localListCount = 0;
+           3488  |   if ((err = AdrCreateAddress(&funcInfo.funcAddrRangeDesc)) != GOOD)
+           3489  |      goto CLEANUP2;
> ( 2868)   3490  |
+           3491  |   err = SymGetFunc(funcDesc,funcInfo.funcNamePtr,
+           3492  |      &funcInfo.funcClass,&funcInfo.stackSize,
+           3493  |      funcInfo.funcAddrRangeDesc);
+           3494  |   if (!err) {
+           3495  |      err = SymGetFuncType(funcDesc,&attribute,&funcInfo.frameType,
+           3496  |                 &funcInfo.pushMask, &temphdr,
+           3497  |                 &funcInfo.numParams, &level,
+           3498  |                 (LPSTR)tempbuf);
+           3499  |   }
+           3500  |   AdrDestroyAddress(funcInfo.funcAddrRangeDesc);
+           3501  |   if (!err) {
+           3502  |      retType = attribute;
+           3503  |   } else {
+           3504  |      funcInfo.funcAddrRangeDesc = NULL;
+           3505  |      goto CLEANUP2;
+           3506  |   }
+           3507  | /* check the first byte of function is 0x55 (PUSH BP) or 0xc8 (ENTER) */
+           3508  | /* if one of above code, it's a framed-function, otherwise it's frame-less */
+           3509  |   AdrCreateAddress(&tmpAddrDesc); 
+           3510  |   SymGetSymbolAddress(funcDesc, tmpAddrDesc);
+           3511  |   AdrGetAddrOffset(tmpAddrDesc, &funcStart);
+           3512  |   AdrGetAddrSegmentSelector(tmpAddrDesc, &segType, &seg);
+           3513  |   addrSeg = (U32)seg;
+           3514  |   funcStart += addrSeg << 16;
+           3515  |   iceGetMemN(funcStart, tmpBuff, 2);
+           3516  |   if ( tmpBuff[0] == 0xc8 || tmpBuff[0] == 0x55 || 
+           3517  |       (tmpBuff[0] == 0x66 && tmpBuff[1] == 0x55) ) { 
+           3518  |   } else 
+           3519  |      framedFunction = FALSE;
+           3520  | /* offset < 3, it's means BP is not push completed */
+           3521  |   if (framedFunction == FALSE || offset < 3) { 
+           3522  |      SdnReadMember(SDN_SP, (U8*)&spPtr);
+           3523  |   } else {
+           3524  |      SdnReadMember(SDN_EBP, (U8*)&spPtr);
+           3525  |      spPtr += 2;
+           3526  |   }
> ( 2871)   3527  |
+           3528  |   SdnReadMember(SDN_SS, (U8*)&curSS);
+           3529  |   spPtr += curSS << 16; 
+           3530  |   iceGetMemN(spPtr, tmpBuff, 2);
+           3531  |   retIP = *(U16 *)tmpBuff;
+           3532  |   if (retType) {
+           3533  |      spPtr += 2;
+           3534  |      iceGetMemN(spPtr, tmpBuff, 2);
+           3535  |      retCS = *(U16 *)tmpBuff;
+           3536  |   } else 
+           3537  |      SdnReadMember(SDN_CS, (U8*)&retCS);
+           3538  |   *retPC = (retCS << 16) + retIP;
+           3539  |   *inValid = FALSE;
+           3540  |CLEANUP2:
+           3541  |   if( tmpAddrDesc != NULL ) AdrDestroyAddress(tmpAddrDesc);
+           3542  |   AdrDestroyAddress(PCAddrDesc);
> ( 2884)   3543  |}
    3377    3544  |
    3378    3545  |
===================
    3395    3562  |   BOOLEAN    abortFromEsc;
    3396    3563  |
+           3564  |   if ((err = TskCheckAbort(&abortFromEsc)) != GOOD) return err;
<   3397  ( 3973) |
-   3398          |   err = TskCheckAbort(&abortFromEsc);
-   3399          |   if(err!=GOOD) return err;
<   3400  ( 3977) |
    3401    3565  |
    3402    3566  |   while (TRUE) {
    3403    3567  |      if (GOOD != (err = CpuGetPC(&currentPCDesc))) /* alloc's addr */
+           3568  |     return err;
-   3404          |         return err;
    3405    3569  |      if (GOOD != (err = DadSetDasmAddr(dasmID, currentPCDesc)))
+           3570  |     return err;
-   3406          |         return err;
    3407    3571  |      firstErr = DadDasmInst(dasmID, 1, &buf, &bufLength);
    3408    3572  |
    3409    3573  |      err = BxSendCliMessage(buf);
    3410    3574  |      if (GOOD == firstErr)
+           3575  |     firstErr = err;
-   3411          |         firstErr = err;
> ( 2873)   3576  |
<   3412  ( 4040) |
    3413    3577  |      err = AdrDestroyAddress(currentPCDesc);
    3414    3578  |      if (GOOD == firstErr)
+           3579  |     firstErr = err;
-   3415          |         firstErr = err;
    3416    3580  |
    3417    3581  |      err = TFree((LPSTR)(buf));
    3418    3582  |      if (GOOD == firstErr)
+           3583  |     firstErr = err;
-   3419          |         firstErr = err;
    3420    3584  |
    3421    3585  |      if (GOOD != firstErr)
+           3586  |     return firstErr;
-   3422          |         return firstErr;
    3423    3587  |
    3424    3588  |      /* get next address; alloc's addr */
    3425    3589  |      if (GOOD != (err = DadGetDasmAddr(dasmID, &currentPCDesc))) /* new adr*/
+           3590  |     return err;
-   3426          |         return err;
    3427    3591  |      if (GOOD != (err = AdrDuplicateAddress(currentPCDesc, &nextPCDesc)))
+           3592  |     goto CLEANUP_1;  /* nextPCDesc valid */
-   3428          |         goto CLEANUP_1;  /* nextPCDesc valid */
    3429    3593  |      /* set current PC to that value; TFrees descriptor */
    3430    3594  |      if (GOOD != (err = CpuSetPC(currentPCDesc)))  /* use up currentPCDesc */
+           3595  |     return err;
-   3431          |         return err;
    3432    3596  |
    3433    3597  |      /* only nextPCDesc valid here */
    3434    3598  |      /* check for bkpt */
    3435    3599  |      if (GOOD != (err = BxBkptMatchInternal(nextPCDesc, &match)))
+           3600  |     goto CLEANUP_1;
-   3436          |         goto CLEANUP_1;
    3437    3601  |      if (match) {
+           3602  |     if (GOOD !=
+           3603  |        (err = AdrConvAddressToTextWithParams(nextPCDesc,
+           3604  |                          TRUE,
+           3605  |                          FALSE,
+           3606  |                          addrBuf)))
+           3607  |        goto CLEANUP_1;
+           3608  |     tmpBuf[0] = '\0';
+           3609  |     strcat(tmpBuf, "internal breakpoint reached at address ");
+           3610  |     strcat(tmpBuf, addrBuf);
+           3611  |     if (GOOD != (err = BxSendCliMessage(tmpBuf)))
+           3612  |        goto CLEANUP_1;
-   3438          |         if (GOOD !=
-   3439          |            (err = AdrConvAddressToTextWithParams(nextPCDesc,
-   3440          |                                                  TRUE,
-   3441          |                                                  FALSE,
-   3442          |                                                  addrBuf)))
-   3443          |            goto CLEANUP_1;
-   3444          |         tmpBuf[0] = '\0';
-   3445          |         strcat(tmpBuf, "internal breakpoint reached at address ");
-   3446          |         strcat(tmpBuf, addrBuf);
-   3447          |         if (GOOD != (err = BxSendCliMessage(tmpBuf)))
-   3448          |            goto CLEANUP_1;
    3449    3613  |      }
    3450    3614  |      if (GOOD != (err = AdrDestroyAddress(nextPCDesc)))
+           3615  |     goto CLEANUP_2;
-   3451          |         goto CLEANUP_2;
    3452    3616  |
    3453    3617  |      TskCheckAbort(&abortFromEsc);  // ignore any error
    3454    3618  |      if (abortFromEsc)
+           3619  |     goto CLEANUP_2;
-   3455          |         goto CLEANUP_2;
    3456    3620  |   } /* end of while */
    3457    3621  |
===================
    3526    3690  |   return firstErr;
    3527    3691  |}  /* end of BxAsmStep */
> ( 2949)   3692  |
+           3693  |RETCODE EXPORT BxAsmStepRange(U32 addr1, U32 addr2) {
> ( 2996)   3694  |
+           3695  |   RETCODE err, firstErr;
+           3696  |   U16 stepCount = 1;
+           3697  |   DESCRIPTOR currentPCDesc;
+           3698  |   U32 currentPC;
+           3699  |   BOOLEAN            abortFromEsc;
> ( 3021)   3700  |
+           3701  |   if ((err = BkProcessorMustBeHaltedAbsolute())!=GOOD)
> ( 2962)   3702  |      return err;
> ( 3037)   3703  |
+           3704  |   err = EnlEventNotify(EVENT_HL_BKPTEXEC_EMUL_STARTED);
+           3705  |   if (err != GOOD) return(err);
> ( 3053)   3706  |
+           3707  |   for (;;) {
+           3708  |      firstErr = TskCheckAbort(&abortFromEsc);
+           3709  |      if (firstErr!=GOOD) break;
+           3710  |      if (abortFromEsc) {
+           3711  |         firstErr = ER_ABORT_FROM_ESC;
+           3712  |         break;
> ( 2708)   3713  |      }
+           3714  |      firstErr = BxLLAsmStepInto(stepCount);
+           3715  |      if (firstErr != GOOD) break;
+           3716  |      if (GOOD != (err = CpuGetPC(&currentPCDesc))) break;
+           3717  |      AdrGetAddrPhysicalOffset(currentPCDesc, &currentPC);
+           3718  |      if (currentPC < addr1 || currentPC > addr2) break;
+           3719  |   }
+           3720  |   err = EnlEventNotify(EVENT_BKPT_HALTED);
+           3721  |   if (GOOD == firstErr)
+           3722  |      firstErr = err;
+           3723  |   return firstErr;
+           3724  |}  /* end of BxAsmStepRange */
    3528    3725  |
    3529    3726  |
===================
    3535    3732  |   RETCODE            err = GOOD, firstErr;
    3536    3733  |   BOOLEAN            timedOut;
-   3537          |   EMULATION_STATE    emulState;
    3538    3734  |   U32                localStepCount;
    3539    3735  |   BOOLEAN            lastStep;  /* indicates when to exit step loop */
===================
    3553    3749  |   do {
    3554    3750  |      if (stepCount > STEP_INCREMENT) {
+           3751  |     stepCount = stepCount - STEP_INCREMENT;
+           3752  |     localStepCount = STEP_INCREMENT;
+           3753  |     lastStep = FALSE;
-   3555          |         stepCount = stepCount - STEP_INCREMENT;
-   3556          |         localStepCount = STEP_INCREMENT;
-   3557          |         lastStep = FALSE;
    3558    3754  |      } else {
+           3755  |     /* last step */
+           3756  |     localStepCount = stepCount;
+           3757  |     lastStep = TRUE;
-   3559          |         /* last step */
-   3560          |         localStepCount = stepCount;
-   3561          |         lastStep = TRUE;
    3562    3758  |      }
    3563    3759  |      /* only returns when emulator has started stepping */
    3564    3760  |      /* disable all bkpts */
    3565    3761  |      if((err = SdWriteMember(bkEnableDesc, (U8 FAR *)&enable, GOOD))!=GOOD)
+           3762  |     goto CLEANUP;
-   3566          |         goto CLEANUP;
    3567    3763  |      if((err = SdWriteCmdReadResponse(singleStepDesc,
+           3764  |                       (U8 FAR *)&localStepCount,
+           3765  |                       GOOD,
+           3766  |                       emulResultDesc,
+           3767  |                       0L,
+           3768  |                       &timedOut)
+           3769  |     )!=GOOD)
+           3770  |     goto CLEANUP;
-   3568          |                                       (U8 FAR *)&localStepCount,
-   3569          |                                       GOOD,
-   3570          |                                       emulResultDesc,
-   3571          |                                       0L,
-   3572          |                                       &timedOut)
-   3573          |         )!=GOOD)
-   3574          |         goto CLEANUP;
-   3575          |      do {
-   3576          |         /* spin until emulator stopped */
-   3577          |         if((err = SdReadMember(emulStateDesc, (U8 FAR *)&emulState))!=GOOD)
-   3578          |            goto CLEANUP;
<   3579  ( 4065) |
-   3580          |         if (emulState == EM_HALTED) {
-   3581          |            break;
-   3582          |         }
-   3583          |         /* removed ESC check since there is no way to abort a step at
-   3584          |            firmware level */
-   3585          |      } while (TRUE);
    3586    3771  |      /* check for exit in the outer step loop */
    3587    3772  |      err = TskCheckAbort(&abortFromEsc);
    3588    3773  |      if(err!=GOOD) {
+           3774  |     goto CLEANUP;
-   3589          |         goto CLEANUP;
    3590    3775  |      }
    3591    3776  |      if(abortFromEsc) {
+           3777  |     err = ER_ABORT_FROM_ESC;
+           3778  |     goto CLEANUP;
-   3592          |         err = ER_ABORT_FROM_ESC;
-   3593          |         goto CLEANUP;
    3594    3779  |      }
    3595    3780  |   } while (!lastStep);  /* end of outer while */
===================
    3600    3785  |   do {
    3601    3786  |      if (stepCount > 1L) {
+           3787  |     stepCount--;
+           3788  |     lastStep = FALSE;
-   3602          |         stepCount--;
-   3603          |         lastStep = FALSE;
    3604    3789  |      } else {
+           3790  |     /* last step */
+           3791  |     lastStep = TRUE;
-   3605          |         /* last step */
-   3606          |         lastStep = TRUE;
    3607    3792  |      }
    3608    3793  |
    3609    3794  |      /* display instruction to be executed and increment PC */
    3610    3795  |      if (GOOD != (err = CpuGetPC(&currentPCDesc)))
+           3796  |     goto CLEANUP;
-   3611          |         goto CLEANUP;
    3612    3797  |      if (GOOD != (err = DadSetDasmAddr(dasmID, currentPCDesc)))
+           3798  |     goto CLEANUP;
-   3613          |         goto CLEANUP;
    3614    3799  |      if (GOOD != (err = DadDasmInst(dasmID, 1, &buf, &bufLength)))
+           3800  |     goto CLEANUP;
-   3615          |         goto CLEANUP;
    3616    3801  |      if (GOOD != (err = BxSendCliMessage(buf)))
+           3802  |     goto CLEANUP;
-   3617          |         goto CLEANUP;
    3618    3803  |
    3619    3804  |      /* could, in future, create stack of return addresses upon seeing call.
+           3805  |     Upon return, pops stack and returns that address (simulating uP) */
-   3620          |         Upon return, pops stack and returns that address (simulating uP) */
    3621    3806  |      /* get next address */
    3622    3807  |      if (GOOD != (err = DadGetDasmAddr(dasmID, &currentPCDesc)))
+           3808  |     goto CLEANUP;
-   3623          |         goto CLEANUP;
    3624    3809  |      /* set current PC to that value; TFrees descriptor */
    3625    3810  |      if (GOOD != (err = CpuSetPC(currentPCDesc)))
+           3811  |     goto CLEANUP;
-   3626          |         goto CLEANUP;
> ( 3078)   3812  |
<   3627  ( 4115) |
    3628    3813  |      /* only returns when emulator has started stepping */
    3629    3814  |      if((err = SdWriteCmdReadResponse(singleStepDesc,
+           3815  |                       (U8 FAR *)&localStepCount,
+           3816  |                       GOOD,
+           3817  |                       emulResultDesc,
+           3818  |                       0L,
+           3819  |                       &timedOut)
+           3820  |     )!=GOOD)
+           3821  |     goto CLEANUP;
-   3630          |                                       (U8 FAR *)&localStepCount,
-   3631          |                                       GOOD,
-   3632          |                                       emulResultDesc,
-   3633          |                                       0L,
-   3634          |                                       &timedOut)
-   3635          |         )!=GOOD)
-   3636          |         goto CLEANUP;
-   3637          |      do {
-   3638          |         /* spin until emulator stopped or ESC pushed */
-   3639          |         if((err = SdReadMember(emulStateDesc, (U8 FAR *)&emulState))!=GOOD)
-   3640          |            goto CLEANUP;
> ( 3095)   3822  |
> ( 2760)   3823  |      err = TskCheckAbort(&abortFromEsc);
<   3641  ( 4201) |
-   3642          |         if (emulState == EM_HALTED) {
-   3643          |            break;
-   3644          |         }
-   3645          |      } while (TRUE);
<   3646  ( 4242) |
<   3647  ( 4289) |
-   3648          |      err = TskCheckAbort(&abortFromEsc);
    3649    3824  |      if(err!=GOOD) {
+           3825  |     goto CLEANUP;
-   3650          |         goto CLEANUP;
    3651    3826  |      }
    3652    3827  |      if (abortFromEsc) {
+           3828  |     err = ER_ABORT_FROM_ESC;
+           3829  |     goto CLEANUP;
-   3653          |         err = ER_ABORT_FROM_ESC;
-   3654          |         goto CLEANUP;
    3655    3830  |      }
    3656    3831  |   } while (!lastStep);  /* end of outer while */
===================
    3667    3842  |      err = SdnReadMember(SDN_BREAK_CAUSE, (U8 FAR *)&bkptCause);
    3668    3843  |      if (GOOD == err) {
+           3844  |     if (bkptCause != lastBkptCause) {
+           3845  |        /* update system var */
+           3846  |        bkptCauseSystemVar.integerValue = bkptCause;
-   3669          |         if (bkptCause != lastBkptCause) {
-   3670          |            /* update system var */
-   3671          |            bkptCauseSystemVar.integerValue = bkptCause;
> ( 3113)   3847  |
+           3848  |        SendMessage(cliServerHandle,  /* send system var info to CLI */
+           3849  |            CLI_SYSTEM_VARIABLE,
+           3850  |            0,                   /* don't dealloc mem */
+           3851  |            (DWORD)&bkptCauseSystemVar);
+           3852  |        lastBkptCause = bkptCause;
+           3853  |     }
<   3672  ( 4294) |
-   3673          |            SendMessage(cliServerHandle,  /* send system var info to CLI */
-   3674          |                        CLI_SYSTEM_VARIABLE,
-   3675          |                        0,                   /* don't dealloc mem */
-   3676          |                        (DWORD)&bkptCauseSystemVar);
-   3677          |            lastBkptCause = bkptCause;
-   3678          |         }
    3679    3854  |      }
    3680    3855  |   }
===================
    3720    3895  |      /* CpuGetPC alloc's address */
    3721    3896  |      if (GOOD != (err = CpuGetPC(&currentPCDesc)))
+           3897  |     goto CLEANUP_2;
-   3722          |         goto CLEANUP_2;
    3723    3898  |
    3724    3899  |      /* set up start address of disassembly; does NOT consume addr */
    3725    3900  |      if (GOOD != (err = DadSetDasmAddr(dasmID, currentPCDesc)))
+           3901  |     goto CLEANUP_1;
-   3726          |         goto CLEANUP_1;
    3727    3902  |
    3728    3903  |#ifdef DEBUG
===================
    3734    3909  |      /* disassemble instruction */
    3735    3910  |      if (GOOD != (err =
+           3911  |     DadDasmIsCallOrRTS(dasmID, currentPCDesc, &instrType)))
+           3912  |     goto CLEANUP_1;
-   3736          |         DadDasmIsCallOrRTS(dasmID, currentPCDesc, &instrType)))
-   3737          |         goto CLEANUP_1;
    3738    3913  |
    3739    3914  |      if (instrType != INST_CALL) {
+           3915  |     err = BxLLAsmStepInto(1L);   /* step one instruction */
+           3916  |     if (GOOD != err) {
+           3917  |        goto CLEANUP_1;
+           3918  |     }
-   3740          |         err = BxLLAsmStepInto(1L);   /* step one instruction */
-   3741          |         if (GOOD != err) {
-   3742          |            goto CLEANUP_1;
-   3743          |         }
    3744    3919  |      } else {
+           3920  |     /* set breakpoint on instruction following */
+           3921  |     /* creates new addr */
+           3922  |     if (GOOD != (err = DadGetDasmAddr(dasmID, &nextAddrDesc)))
+           3923  |        goto CLEANUP_1;
+           3924  |     /* remove processor dependency */
+           3925  |     if (FAMILY_68K == staticProcFamily) {
+           3926  |        if(GOOD != (err = AdrSetAddrSpace(nextAddrDesc, SPACE_SP)))
+           3927  |           return err;
+           3928  |     }
+           3929  |     if (GOOD != (err = AdrCopyAddress(nextAddrDesc,
+           3930  |                       bkptAddrDesc)))
+           3931  |        goto CLEANUP_1;
-   3745          |         /* set breakpoint on instruction following */
-   3746          |         /* creates new addr */
-   3747          |         if (GOOD != (err = DadGetDasmAddr(dasmID, &nextAddrDesc)))
-   3748          |            goto CLEANUP_1;
-   3749          |         /* remove processor dependency */
-   3750          |         if (FAMILY_68K == staticProcFamily) {
-   3751          |            if(GOOD != (err = BxSetAddrSpace(nextAddrDesc)))
-   3752          |               return err;
-   3753          |         }
-   3754          |         if (GOOD != (err = AdrCopyAddress(nextAddrDesc,
-   3755          |                                           bkptAddrDesc)))
-   3756          |            goto CLEANUP_1;
    3757    3932  |
    3758    3933  |#ifdef DEBUG
===================
    3762    3937  |#endif
    3763    3938  |
+           3939  |     /* set breakpoint after CALL instruction */
+           3940  |     /* consumes address */
+           3941  |     if (GOOD != (err =
+           3942  |        BxSetBkpt(BX_ENABLED, BX_TEMPORARY_INTERNAL,
+           3943  |              nextAddrDesc, &bkptDesc)))
+           3944  |        goto CLEANUP_1;
-   3764          |         /* set breakpoint after CALL instruction */
-   3765          |         /* consumes address */
-   3766          |         if (GOOD != (err =
-   3767          |            BxSetBkptWithSpaceFromSR(BX_ENABLED, BX_TEMPORARY_INTERNAL,
-   3768          |                      nextAddrDesc, &bkptDesc)))
-   3769          |            goto CLEANUP_1;
> ( 3212)   3945  |
<   3770  (  646) |
    3771    3946  |if(!demonstrationVersion) {
+           3947  |     /* start emulation */
+           3948  |     steppingFlag = FALSE; /* disable so events will be generated */
+           3949  |     if (GOOD != (err = BxMLStartEmulation(BX_GO_STEP))) {
+           3950  |        BxRemoveAllInternalBkpts();
+           3951  |        goto CLEANUP_1;
+           3952  |     }
-   3772          |         /* start emulation */
-   3773          |         steppingFlag = FALSE; /* disable so events will be generated */
-   3774          |         if (GOOD != (err = BxMLStartEmulation(BX_GO_STEP))) {
-   3775          |            BxRemoveAllInternalBkpts();
-   3776          |            goto CLEANUP_1;
-   3777          |         }
> ( 3332)   3953  |
+           3954  |     /* spins on emuRunningSpinFlag */
+           3955  |     if (GOOD != (err = BxWaitForEmulationHalt())) {
+           3956  |        /* NOTE: purposely ignoring error since need to report
+           3957  |           error from previous function call */
+           3958  |        /* can easily get here if JSR is in infinite loop and user
+           3959  |           must hit ESC to get control back */
+           3960  |        /* get rid of any internal bkpts set by this function */
+           3961  |        BxRemoveAllInternalBkpts();
+           3962  |        goto CLEANUP_1;
+           3963  |     }
+           3964  |     steppingFlag = TRUE;
+           3965  |     /* remove temporary step bkpt after CALL instruction */
+           3966  |     if (GOOD != (err = BxRemoveBkpt(bkptDesc)))
+           3967  |        goto CLEANUP_1;
> ( 3343)   3968  |
+           3969  |     /* test to see if target stopped on step bkpt */
+           3970  |     /* delete previous PC addr so can get new one */
+           3971  |     if (GOOD != (err = AdrDestroyAddress(currentPCDesc)))
+           3972  |        goto CLEANUP_2;
> ( 3397)   3973  |
+           3974  |     /* creates new addr */
+           3975  |     if (GOOD != (err = CpuGetPC(&currentPCDesc)))
+           3976  |        goto CLEANUP_2;
> ( 3400)   3977  |
+           3978  |     if (GOOD != (err =
+           3979  |        AdrCompareAddresses(currentPCDesc,
+           3980  |                bkptAddrDesc,
+           3981  |                &compareResult)))
+           3982  |        goto CLEANUP_2;
+           3983  |     if (EQUAL_ADDRS != compareResult) {
+           3984  |        err = GOOD;    /* stop stepping because not step bkpt */
+           3985  |        goto CLEANUP_1;
+           3986  |     }
> ( 2878)   3987  |} else {
+           3988  |     if (GOOD != (err = BxStepUntilBkpt()))
+           3989  |        return err;
<   3778  (  596) |
-   3779          |         /* spins on emuRunningSpinFlag */
-   3780          |         if (GOOD != (err = BxWaitForEmulationHalt())) {
-   3781          |            /* NOTE: purposely ignoring error since need to report
-   3782          |               error from previous function call */
-   3783          |            /* can easily get here if JSR is in infinite loop and user
-   3784          |               must hit ESC to get control back */
-   3785          |            /* get rid of any internal bkpts set by this function */
-   3786          |            BxRemoveAllInternalBkpts();
-   3787          |            goto CLEANUP_1;
-   3788          |         }
-   3789          |         steppingFlag = TRUE;
-   3790          |         /* remove temporary step bkpt after CALL instruction */
-   3791          |         if (GOOD != (err = BxRemoveBkpt(bkptDesc)))
-   3792          |            goto CLEANUP_1;
<   3793  (  588) |
-   3794          |         /* test to see if target stopped on step bkpt */
-   3795          |         /* delete previous PC addr so can get new one */
-   3796          |         if (GOOD != (err = AdrDestroyAddress(currentPCDesc)))
-   3797          |            goto CLEANUP_2;
<   3798  (  586) |
-   3799          |         /* creates new addr */
-   3800          |         if (GOOD != (err = CpuGetPC(&currentPCDesc)))
-   3801          |            goto CLEANUP_2;
-   3802          |         /* added by vincent to eliminate address comparison error */
-   3803          |         /* due to different address spaces used. bkptAddrDesc is SPACE_SP */
-   3804          |         /* & currentPCDesc is set to SPACE_DEAULT which will be converted */
-   3805          |         /* to SPACE_SD */
-   3806          |         if(GOOD != (err = BxSetAddrSpace(currentPCDesc)))
-   3807          |            goto CLEANUP_1;
-   3808          |
-   3809          |         if (GOOD != (err =
-   3810          |            AdrCompareAddresses(currentPCDesc,
-   3811          |                                bkptAddrDesc,
-   3812          |                                &compareResult)))
-   3813          |            goto CLEANUP_2;
-   3814          |         if (EQUAL_ADDRS != compareResult) {
-   3815          |            err = GOOD;    /* stop stepping because not step bkpt */
-   3816          |            goto CLEANUP_1;
-   3817          |         }
-   3818          |} else {
-   3819          |         if (GOOD != (err = BxStepUntilBkpt()))
-   3820          |            return err;
    3821    3990  |}
    3822    3991  |      }  /* end of if (instrType == INST_CALL) */
===================
    3843    4012  |RETCODE EXPORT BxStartEmulation(VOID) {
    3844    4013  |
+           4014  |   return  BxMLStartEmulation(BX_GO_FOREVER);
-   3845          |   return BxMLStartEmulation(BX_GO_FOREVER);
-   3846          |
    3847    4015  |}  /* end of BxStartEmulation */
    3848    4016  |
===================
    3870    4038  |   BOOLEAN timedOut;
    3871    4039  |   HCURSOR hOldCursor, hHourGlassCursor;
-   3872          |   U32 pc;
> ( 3412)   4040  |
    3873    4041  |   if((err = BkProcessorMustBeHaltedAbsolute())!=GOOD)
    3874    4042  |      return err;
===================
    3890    4058  |   if((goState == BX_GO_FOREVER) && (staticSystemType==PROC_POWERPACK)) {
    3891    4059  |      /* start the trace before emulation */
+           4060  |      if((err = TrcTracingSet(TRUE))!=GOOD) {
+           4061  |     emuRunningSpinFlag = FALSE;
+           4062  |     return err;
+           4063  |      }
-   3892          |      if((err = TrcTracingSet(TRUE))!=GOOD)
-   3893          |         return err;
    3894    4064  |   }
-   3895          |   // add by jerry just for 2,20  perhaps will be delete
-   3896          |   BxAsmStep(1);
-   3897          |   //CpuGetPC(&pc);
-   3898          |
-   3899          |
-   3900          |   // end of end 2.20
> ( 3579)   4065  |
    3901    4066  |   /* enable breakpoints */
+           4067  |   if ((err = SdWriteMember(bkEnableDesc, (U8 FAR *)&enable, GOOD))!=GOOD) {
+           4068  |      emuRunningSpinFlag = FALSE;
-   3902          |   if((err = SdWriteMember(bkEnableDesc, (U8 FAR *)&enable, GOOD))!=GOOD)
    3903    4069  |      return err; /* don't start emulation if err */
+           4070  |   }
    3904    4071  |   err = SdWriteCmdReadResponse(goDesc,
+           4072  |                (U8 FAR *)&goCmd,
+           4073  |                GOOD,
+           4074  |                emulResultDesc,
+           4075  |                0L,
+           4076  |                &timedOut);
-   3905          |                                (U8 FAR *)&goCmd,
-   3906          |                                GOOD,
-   3907          |                                emulResultDesc,
-   3908          |                                0L,
-   3909          |                                &timedOut);
    3910    4077  |   SetCursor(hOldCursor);
+           4078  |   if (err != GOOD)
+           4079  |      emuRunningSpinFlag = FALSE;  /* go command failed */
-   3911          |   if (err) emuRunningSpinFlag = FALSE;  /* go command failed */
    3912    4080  |   return err;
    3913    4081  |}  /* end of BxLLStartEmulation */
===================
    3938    4106  |   hOldCursor = SetCursor(hHourGlassCursor);
    3939    4107  |
+           4108  |   if (staticSystemType==PROC_POWERPACK) {
-   3940          |   if(staticSystemType==PROC_POWERPACK) {
    3941    4109  |      /* start the trace before emulation */
+           4110  |      if ((err = TrcTracingSet(TRUE))!=GOOD) {
+           4111  |     emuRunningSpinFlag = FALSE;
+           4112  |     return err;
+           4113  |      }
-   3942          |      if((err = TrcTracingSet(TRUE))!=GOOD)
-   3943          |         return err;
    3944    4114  |   }
-   3945          |
> ( 3627)   4115  |
    3946    4116  |   /* enable breakpoints */
+           4117  |   if ((err = SdWriteMember(bkEnableDesc, (U8 FAR *)&enable, GOOD))!=GOOD) {
+           4118  |      emuRunningSpinFlag = FALSE;
-   3947          |   if((err = SdWriteMember(bkEnableDesc, (U8 FAR *)&enable, GOOD))!=GOOD)
    3948    4119  |      return err; /* don't start emulation if err */
+           4120  |   }
    3949    4121  |   err = SdWriteCmdReadResponse(resetAndGoDesc,
+           4122  |                (U8 FAR *)&resetAndGoCmd,
+           4123  |                GOOD,
+           4124  |                emulResultDesc,
+           4125  |                0L,
+           4126  |                &timedOut);
-   3950          |                                (U8 FAR *)&resetAndGoCmd,
-   3951          |                                GOOD,
-   3952          |                                emulResultDesc,
-   3953          |                                0L,
-   3954          |                                &timedOut);
    3955    4127  |   SetCursor(hOldCursor);
+           4128  |   if (err != GOOD) emuRunningSpinFlag = FALSE;
    3956    4129  |   return err;
    3957    4130  |}  /* end of BxResetAndStartEmulation */
===================
    3978    4151  |      /* process one message, then check for emulator halted */
    3979    4152  |      if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
+           4153  |     if (msg.message == WM_QUIT)
+           4154  |        break;
+           4155  |     TranslateMessage(&msg);
+           4156  |     DispatchMessage(&msg);
-   3980          |         if (msg.message == WM_QUIT)
-   3981          |            break;
-   3982          |         TranslateMessage(&msg);
-   3983          |         DispatchMessage(&msg);
    3984    4157  |      }
    3985    4158  |      /* must read SD to see if state change; if so, callback will set
+           4159  |     emuRunningSpinFlag FALSE */
-   3986          |         emuRunningSpinFlag FALSE */
    3987    4160  |      err = SdnReadMember(SDN_EMULATION_STATE, (U8 FAR*)&emulState);
    3988    4161  |
    3989    4162  |    // test for ESC key
    3990    4163  |      err = TskCheckAbort(&abortFromEsc);
    3991    4164  |      if(err!=GOOD) {
+           4165  |     BxLLHaltEmulation();       // ignore any error from halt
+           4166  |     emuRunningSpinFlag = FALSE;
+           4167  |     return err;
-   3992          |         BxLLHaltEmulation();       // ignore any error from halt
-   3993          |         emuRunningSpinFlag = FALSE;
-   3994          |         return err;
    3995    4168  |      }
    3996    4169  |      if (abortFromEsc) {
+           4170  |     err = BxLLHaltEmulation();
+           4171  |     emuRunningSpinFlag = FALSE;
+           4172  |     return ER_ABORT_FROM_ESC;
-   3997          |         err = BxLLHaltEmulation();
-   3998          |         emuRunningSpinFlag = FALSE;
-   3999          |         return ER_ABORT_FROM_ESC;
    4000    4173  |      }
    4001    4174  |
    4002    4175  |      if (!emuRunningSpinFlag)  /* flag cleared by callback */
+           4176  |     break;
-   4003          |         break;
    4004    4177  |   }
    4005    4178  |   return GOOD;
===================
    4025    4198  |   U8                 haltCmd = TRUE;
    4026    4199  |   BOOLEAN            timedOut;
+           4200  |   U8 goEndFlag;
-   4027          |
> ( 3641)   4201  |
+           4202  |   iceGetCpuStatus(&goEndFlag);
+           4203  |   if (goEndFlag) return GOOD;
+           4204  | 
    4028    4205  |   err = SdWriteCmdReadResponse(haltDesc,
+           4206  |                (U8 FAR *)&haltCmd,
+           4207  |                GOOD,
+           4208  |                emulResultDesc,
+           4209  |                0L,
+           4210  |                &timedOut);
+           4211  |   return err; 
-   4029          |                                (U8 FAR *)&haltCmd,
-   4030          |                                GOOD,
-   4031          |                                emulResultDesc,
-   4032          |                                0L,
-   4033          |                                &timedOut);
-   4034          |   return err;
    4035    4212  |}  /* end of BxLLHaltEmulation */
    4036    4213  |
===================
    4039    4216  |** BxEmulStateChange
    4040    4217  |----------------------------------------------------------------------------*/
+           4218  |VOID EXPORT BxEmulStateChange(DESCRIPTOR desc)  {
-   4041          |VOID FAR PASCAL BxEmulStateChange(DESCRIPTOR desc)  {
    4042    4219  |
    4043    4220  |   EMULATION_STATE emulState;
    4044    4221  |   RETCODE         err, firstErr;
+           4222  |   BREAK_CAUSE     bkptCause = CAUSE_NONE;
-   4045          |   BREAK_CAUSE     bkptCause;
    4046    4223  |   DESCRIPTOR      desc1;
    4047    4224  |
    4048    4225  |   if (steppingFlag)  /* skip the remainder of this function if in
+           4226  |             stepping mode */
-   4049          |                         stepping mode */
    4050    4227  |      return;
    4051    4228  |
===================
    4057    4234  |      case EM_RUNNING:
    4058    4235  |      case EM_STEPPING:
+           4236  |     /* update emulating system var, then send to CLI */
+           4237  |     emulatingSystemVar.integerValue = BX_EMULATING;
+           4238  |     SendMessage(cliServerHandle,
+           4239  |             CLI_SYSTEM_VARIABLE,
+           4240  |             0,                   /* don't dealloc mem */
+           4241  |             (DWORD)&emulatingSystemVar);
-   4059          |         /* update emulating system var, then send to CLI */
-   4060          |         emulatingSystemVar.integerValue = BX_EMULATING;
-   4061          |         SendMessage(cliServerHandle,
-   4062          |                     CLI_SYSTEM_VARIABLE,
-   4063          |                     0,                   /* don't dealloc mem */
-   4064          |                     (DWORD)&emulatingSystemVar);
-   4065          |
-   4066          |         /* skipping the low level event notification - at this point, it
-   4067          |            is not needed */
-   4068          |         if((err = SdRegister("break cause", NULLPTR, &desc1)) != GOOD)
-   4069          |            return(err);
-   4070          |         firstErr = SdReadMemberNoInputCheck(desc1, (U8 FAR *)&bkptCause);
-   4071          |         
-   4072          |         if (GOOD == firstErr) {
-   4073          |            if (bkptCause == CAUSE_PENDING && bkptCause != lastBkptCause) {
-   4074          |               firstErr = EnlEventNotify(EVENT_HL_BKPTEXEC_EMUL_PENDING);
-   4075          |               lastBkptCause = bkptCause;
-   4076          |               break;
-   4077          |            }
-   4078          |         } else break;
-   4079          |         firstErr = EnlEventNotify(EVENT_HL_BKPTEXEC_EMUL_STARTED);
-   4080          |         break;
> ( 3646)   4242  |
+           4243  |     if ((err = SdRegister("break cause",NULLPTR,&desc1)) != GOOD)
+           4244  |        return(err);
+           4245  |     firstErr = SdReadMemberNoInputCheck(desc1, (U8 FAR *)&bkptCause);
+           4246  |     if (GOOD == firstErr) {
+           4247  |        if (bkptCause == CAUSE_PENDING && bkptCause != lastBkptCause) {
+           4248  |           firstErr = EnlEventNotify(EVENT_HL_BKPTEXEC_EMUL_PENDING);
+           4249  |           lastBkptCause = bkptCause;
+           4250  |           break;
+           4251  |        }
+           4252  |     }
+           4253  |     else break;
+           4254  |     /* skipping the low level event notification - at this point, it
+           4255  |        is not needed */
+           4256  |     firstErr = EnlEventNotify(EVENT_HL_BKPTEXEC_EMUL_STARTED);
+           4257  |     break;
    4081    4258  |
    4082    4259  |      case EM_HALTED:
+           4260  |     /* get the cause; if different than last time, update system var */
+           4261  |     firstErr = SdnReadMember(SDN_BREAK_CAUSE, (U8 FAR *)&bkptCause);
+           4262  |     if (GOOD == firstErr) {
+           4263  |        if (bkptCause != lastBkptCause) {
+           4264  |           /* update system var */
+           4265  |           bkptCauseSystemVar.integerValue = bkptCause;
+           4266  |           SendMessage(cliServerHandle,  /* send system var info to CLI */
+           4267  |               CLI_SYSTEM_VARIABLE,
+           4268  |               0,                   /* don't dealloc mem */
+           4269  |               (DWORD)&bkptCauseSystemVar);
+           4270  |           lastBkptCause = bkptCause;
+           4271  |        }
+           4272  |     }
+           4273  |     /* fall thru */
-   4083          |         /* get the cause; if different than last time, update system var */
-   4084          |         firstErr = SdnReadMember(SDN_BREAK_CAUSE, (U8 FAR *)&bkptCause);
-   4085          |         if (GOOD == firstErr) {
-   4086          |            if (bkptCause != lastBkptCause) {
-   4087          |               /* update system var */
-   4088          |               bkptCauseSystemVar.integerValue = bkptCause;
-   4089          |
-   4090          |               SendMessage(cliServerHandle,  /* send system var info to CLI */
-   4091          |                           CLI_SYSTEM_VARIABLE,
-   4092          |                           0,                   /* don't dealloc mem */
-   4093          |                           (DWORD)&bkptCauseSystemVar);
-   4094          |               lastBkptCause = bkptCause;
-   4095          |            }
-   4096          |         }
-   4097          |         /* fall thru */
    4098    4274  |      case EM_HUNG:
+           4275  |     /* update emulating system var, then send to CLI */
+           4276  |     emulatingSystemVar.integerValue = BX_NOT_EMULATING;
+           4277  |     SendMessage(cliServerHandle,
+           4278  |             CLI_SYSTEM_VARIABLE,
+           4279  |             0,                   /* don't dealloc mem */
+           4280  |             (DWORD)&emulatingSystemVar);
+           4281  |     if (goState == BX_GO_FOREVER) {
+           4282  |        BOOLEAN tempMatch;
+           4283  |        /* remove go to cursor internal if programmed */
+           4284  |        firstErr = BxRemoveAllInternalBkpts();
+           4285  |        err = BxRemoveMatchingTemporary(&tempMatch);
+           4286  |        if (GOOD == firstErr) firstErr = err;
+           4287  |        err = EnlEventNotify(EVENT_BKPT_HALTED);
+           4288  |        if (GOOD == firstErr) firstErr = err;
-   4099          |         /* update emulating system var, then send to CLI */
-   4100          |         emulatingSystemVar.integerValue = BX_NOT_EMULATING;
-   4101          |         SendMessage(cliServerHandle,
-   4102          |                     CLI_SYSTEM_VARIABLE,
-   4103          |                     0,                   /* don't dealloc mem */
-   4104          |                     (DWORD)&emulatingSystemVar);
-   4105          |         if (goState == BX_GO_FOREVER) {
-   4106          |            BOOLEAN tempMatch;
-   4107          |            /* remove go to cursor internal if programmed */
-   4108          |            firstErr = BxRemoveAllInternalBkpts();
-   4109          |            err = BxRemoveMatchingTemporary(&tempMatch);
-   4110          |            if (GOOD == firstErr) firstErr = err;
-   4111          |            err = EnlEventNotify(EVENT_BKPT_HALTED);
-   4112          |            if (GOOD == firstErr) firstErr = err;
-   4113          |
-   4114          |            /* generate bkpt changed event if one matched the current pc */
-   4115          |            if (tempMatch)
-   4116          |               err = EnlEventNotify(EVENT_BKPT_EDIT);
-   4117          |            if (GOOD == firstErr) firstErr = err;
-   4118          |
-   4119          |            if (GOOD != firstErr) {
-   4120          |               if (ER_ABORT_FROM_ESC == firstErr) {
-   4121          |                  globalEscPushed = ER_ABORT_FROM_ESC;
-   4122          |               } else {
-   4123          |                  ErrDisplayError(firstErr, CHECK_MODE);
-   4124          |               }
-   4125          |            }
-   4126          |         }
-   4127          |         emuRunningSpinFlag = FALSE;
-   4128          |         break;
> ( 3647)   4289  |
+           4290  |        /* generate bkpt changed event if one matched the current pc */
+           4291  |        if (tempMatch)
+           4292  |           err = EnlEventNotify(EVENT_BKPT_EDIT);
+           4293  |        if (GOOD == firstErr) firstErr = err;
> ( 3672)   4294  |
+           4295  |        if (GOOD != firstErr) {
+           4296  |           if (ER_ABORT_FROM_ESC == firstErr) {
+           4297  |          globalEscPushed = ER_ABORT_FROM_ESC;
+           4298  |           } else {
+           4299  |          ErrDisplayError(firstErr, CHECK_MODE);
+           4300  |           }
+           4301  |        }
+           4302  |     } else {
+           4303  |        /* 10/19/20 - Nghia
+           4304  |        ** Reset while processor halted need to generate BKPT_HALTED
+           4305  |        ** event.  
+           4306  |        */
+           4307  |        if ((emulState == EM_HALTED) &&
+           4308  |        ((err = EnlEventNotify(EVENT_BKPT_HALTED)) != GOOD)) {
+           4309  |           ErrDisplayError(err, CHECK_MODE);
+           4310  |        }
+           4311  |     }
+           4312  |     emuRunningSpinFlag = FALSE;
+           4313  |     break;
    4129    4314  |
    4130    4315  |   } /* end of switch */
===================
    4166    4351  |}
    4167    4352  |
-   4168          |PRIVATE RETCODE BxSetAddrSpace(DESCRIPTOR addrDesc) {
-   4169          |SPACE_MODE spaceMode;
-   4170          |ADDR_SPACE addrSpace;
<   4171  ( 3447) |RETCODE err;
-   4172          |
-   4173          |   if ((err = CpuGetSpaceMode(&spaceMode)) != GOOD)
-   4174          |      return(err);
-   4175          |   addrSpace = (spaceMode == SUPERVISOR_MODE) ? SPACE_SP : SPACE_UP;
-   4176          |   return(AdrSetAddrSpace(addrDesc, addrSpace));
-   4177          |}
    4178    4353  |
    4179    4354  |/******************************** E O F ***********************************/
===================
