Subversion Repositories pentevo

#include "std.h"

#include "resource.h"

#include "emul.h"

#include "vars.h"

#include "debug.h"

#include "dbgpaint.h"

#include "dbglabls.h"

#include "memory.h"

#include "config.h"

#include "util.h"

MON_LABELS mon_labels;

void MON_LABELS::start_watching_labels()

{

   addpath(userfile, "?");

   hNewUserLabels = FindFirstChangeNotification(userfile, 0, FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE);

   addpath(userfile, "user.l");

}

void MON_LABELS::stop_watching_labels()

{

   if (!hNewUserLabels || hNewUserLabels == INVALID_HANDLE_VALUE) return;

   CloseHandle(hNewUserLabels);

   hNewUserLabels = INVALID_HANDLE_VALUE;

}

void MON_LABELS::notify_user_labels()

{

   if (hNewUserLabels == INVALID_HANDLE_VALUE) return;

   // load labels at first check

   if (hNewUserLabels == nullptr) { start_watching_labels(); import_file(); return; }

   if (WaitForSingleObject(hNewUserLabels, 0) != WAIT_OBJECT_0) return;

   import_file();

   FindNextChangeNotification(hNewUserLabels);

}

unsigned MON_LABELS::add_name(char *name)

{

   size_t len = strlen(name)+1, new_size = names_size + len;

   if (new_size > align_by(names_size, 4096U))

      names = (char*)realloc(names, align_by(new_size, 4096U));

   unsigned result = names_size;

   memcpy(names + result, name, len);

   names_size = unsigned(new_size);

   return result;

}

void MON_LABELS::clear(unsigned char *start, unsigned size)

{

   unsigned dst = 0;

   for (unsigned src = 0; src < n_pairs; src++)

      if ((unsigned)(pairs[src].address - start) > size)

         pairs[dst++] = pairs[src];

   n_pairs = dst;

   // pack `names'

   char *pnames = names; names = nullptr; names_size = 0;

   for (unsigned l = 0; l < n_pairs; l++)

      pairs[l].name_offs = add_name(pnames + pairs[l].name_offs);

   free(pnames);

}

static int __cdecl labels_sort_func(const void *e1, const void *e2)

{

    const MON_LABEL *a = (const MON_LABEL*)e1;

    const MON_LABEL *b = (const MON_LABEL*)e2;

   return int(ptrdiff_t(a->address - b->address));

}

void MON_LABELS::sort()

{

   qsort(pairs, n_pairs, sizeof(MON_LABEL), labels_sort_func);

}

void MON_LABELS::add(unsigned char *address, char *name)

{

   if (n_pairs >= align_by(n_pairs, 1024U))

      pairs = (MON_LABEL*)realloc(pairs, sizeof(MON_LABEL) * align_by(n_pairs+1, 1024U));

   pairs[n_pairs].address = address;

   pairs[n_pairs].name_offs = add_name(name);

   n_pairs++;

}

char *MON_LABELS::find(unsigned char *address)

{

   unsigned l = 0, r = n_pairs;

   for (;;) {

      if (l >= r) return nullptr;

      unsigned m = (l+r)/2;

      if (pairs[m].address == address) return names + pairs[m].name_offs;

      if (pairs[m].address < address) l = m+1; else r = m;

   }

}

unsigned MON_LABELS::load(char *filename, unsigned char *base, unsigned size)

{

   int virt_addr;

   FILE *in = fopen(filename, "rt");

   if (!in)

   {

       errmsg("can't find label file %s", filename);

       return 0;

   }

   clear(base, size);

   unsigned l_counter = 0, loaded = 0; char *txt = nullptr;

   size_t l; //Alone Coder 0.36.7

   while (!feof(in)) {

      char line[64];

      if (!fgets(line, sizeof(line), in)) break;

      l_counter++;

      for (/*int*/ l = strlen(line); l && line[l-1] <= ' '; l--);

      line[l] = 0;

      if (!l) continue;

      unsigned val = 0, offset = 0;

      virt_addr = 0;

      if (l >= 6 && line[0]!=':' && line[4] == ' ')

      { // àäðåñ áåç íîìåðà áàíêà xxxx label

         for (l = 0; l < 4; l++)

         {

            if (!ishex(line[l]))

                goto ll_err;

            val = (val * 0x10) + hex(line[l]);

         }

         txt = line+5;

      }

      else if (l >= 7 && line[0]==':' && line[5] == ' ')

      { // :xxxx label -- virtual addresses (in Z80 addr space, not coupled to pages)

         for (l = 1; l < 5; l++)

         {

            if (!ishex(line[l]))

               goto ll_err;

            val = (val * 0x10) + hex(line[l]);

         }

         txt = line+6;

         virt_addr = 1;

      }

      else if (l >= 9 && line[2] == ':' && line[7] == ' ')

      { // àäðåñ ñíîìåðîì áàíêà bb:xxxx label

         for (l = 0; l < 2; l++)

         {

            if (!ishex(line[l]))

                goto ll_err;

            val = (val * 0x10) + hex(line[l]);

         }

         for (l = 3; l < 7; l++)

         {

            if (!ishex(line[l]))

                goto ll_err;

            offset = (offset * 0x10) + hex(line[l]);

         }

         val = val*PAGE + (offset & (PAGE-1));

         txt = line+8;

      }

      else

      {

ll_err:

         color(CONSCLR_ERROR);

         printf("error in %s, line %u\n", filename, l_counter);

         continue;

      }

      if (!virt_addr && (val < size))

      {

          add(base+val, txt);

          loaded++;

      }

      else if (virt_addr)

      {

          add(((unsigned char *)NULL)+val, txt);

          loaded++;

      }

   }

   fclose(in);

   sort();

   return loaded;

}

unsigned MON_LABELS::alasm_chain_len(unsigned char *page, unsigned offset, unsigned &end)

{

   unsigned count = 0;

   for (;;) {

      if (offset >= 0x3FFC) return 0;

      unsigned s1 = page[offset], sz = s1 & 0x3F;

      if (!s1 || offset == 0x3E00) { end = offset+1; return count; }

      if (sz < 6) return 0;

      unsigned char sym = page[offset+sz-1];

      if (sym >= '0' && sym <= '9') return 0;

      for (unsigned ptr = 5; ptr < sz; ptr++)

         if (!alasm_valid_char[page[offset+ptr]]) return 0;

      if (!(s1 & 0xC0)) count++;

      offset += sz;

   }

}

void MON_LABELS::find_alasm()

{

   static const char label_chars[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@$_";

   memset(alasm_valid_char, 0, sizeof alasm_valid_char);

   for (const char *lbl = label_chars; *lbl; lbl++) alasm_valid_char[unsigned(*lbl)] = 1;

   alasm_found_tables = 0;

   for (unsigned page = 0; page < conf.ramsize*1024; page += PAGE) {

      for (unsigned offset = 0; offset < PAGE; offset++) {

         unsigned end, count = alasm_chain_len(RAM_BASE_M + page, offset, end);

         if (count < 2) continue;

         alasm_count[alasm_found_tables] = count;

         alasm_offset[alasm_found_tables] = page + offset;

         offset = end; alasm_found_tables++;

         if (alasm_found_tables == MAX_ALASM_LTABLES) return;

      }

   }

}

void MON_LABELS::import_alasm(unsigned offset, char *caption)

{

    (void)caption;

   clear_ram();

   unsigned char *base = RAM_BASE_M + offset;

   for (;;) { // #FE00/FF00/FFFC - end of labels?

      unsigned char sz = *base; if (!sz) break;

      if (!(sz & 0xC0)) {

         char lbl[64]; unsigned ptr = 0;

         for(unsigned k = sz; k > 5;)

         {

             k--;

             lbl[ptr++] = char(base[k]);

         }

         lbl[ptr] = 0;

         unsigned val = *(unsigned short*)(base+1);

         unsigned char *bs;

         switch (val & 0xC000) {

            case 0x4000: bs = RAM_BASE_M+5*PAGE; break;

            case 0x8000: bs = RAM_BASE_M+2*PAGE; break;

            case 0xC000: bs = RAM_BASE_M+0*PAGE; break;

            default: bs = nullptr;

         }

         if (bs) add(bs+(val & 0x3FFF), lbl);

      }

      base += (sz & 0x3F);

   }

   sort();

}

void MON_LABELS::find_xas()

{

   char look_page_6 = 0;

   const char *err = "XAS labels not found in bank #06";

   if(conf.mem_model == MM_PENTAGON && conf.ramsize > 128)

   {

       err = "XAS labels not found in banks #06,#46";

       look_page_6 = 1;

   }

   xaspage = 0;

   if (look_page_6 && RAM_BASE_M[PAGE*14+0x3FFF] == 5 && RAM_BASE_M[PAGE*14+0x1FFF] == 5) xaspage = 0x46;

   if (!xaspage && RAM_BASE_M[PAGE*6+0x3FFF] == 5 && RAM_BASE_M[PAGE*6+0x1FFF] == 5) xaspage = 0x06;

   if (!xaspage) strcpy(xas_errstr, err);

   else sprintf(xas_errstr, "XAS labels from bank #%02X", xaspage);

}

void MON_LABELS::import_xas()

{

   if (!xaspage) return;

   unsigned base = (xaspage == 0x46)? 0x0E*PAGE : (unsigned)xaspage*PAGE;

   clear_ram(); unsigned count = 0;

   int i; //Alone Coder 0.36.7

   for (int k = 0; k < 2; k++) {

      unsigned char *ptr = RAM_BASE_M + base + (k? 0x3FFD : 0x1FFD);

      for (;;) {

         if (ptr[2] < 5 || (ptr[2] & 0x80)) break;

         char lbl[16];

         for(/*int*/ i = 0; i < 7; i++)

         {

             lbl[i] = char(ptr[i - 7]);

         }

         for (i = 7; i && lbl[i-1]==' '; i--);

         lbl[i] = 0;

         unsigned val = *(unsigned short*)ptr;

         unsigned char *bs;

         switch (val & 0xC000) {

            case 0x4000: bs = RAM_BASE_M+5*PAGE; break;

            case 0x8000: bs = RAM_BASE_M+2*PAGE; break;

            case 0xC000: bs = RAM_BASE_M+0*PAGE; break;

            default: bs = nullptr;

         }

         if(bs)

         {

             add(bs + (val & 0x3FFF), lbl);

             count++;

         }

         ptr -= 9; if (ptr < RAM_BASE_M+base+9) break;

      }

   }

   sort();

   char ln[64]; sprintf(ln, "imported %u labels", count);

   MessageBox(GetForegroundWindow(), ln, xas_errstr, MB_OK | MB_ICONINFORMATION);

}

void MON_LABELS::import_menu()

{

   find_xas();

   find_alasm();

   MENUITEM items[MAX_ALASM_LTABLES+4] = { };

   unsigned menuptr = 0;

   items[menuptr].text = xas_errstr;

   items[menuptr].flags = xaspage? (MENUITEM::FLAGS)0 : MENUITEM::DISABLED;

   menuptr++;

   char alasm_text[MAX_ALASM_LTABLES][64];

   if (!alasm_found_tables) {

      sprintf(alasm_text[0], "No ALASM labels in whole %uK memory", conf.ramsize);

      items[menuptr].text = alasm_text[0];

      items[menuptr].flags = MENUITEM::DISABLED;

      menuptr++;

   } else {

      for (unsigned i = 0; i < alasm_found_tables; i++) {

         sprintf(alasm_text[i], "%u ALASM labels in page %u, offset #%04X", alasm_count[i], alasm_offset[i]/PAGE, (alasm_offset[i] & 0x3FFF) | 0xC000);

         items[menuptr].text = alasm_text[i];

         items[menuptr].flags = (MENUITEM::FLAGS)0;

         menuptr++;

      }

   }

   items[menuptr].text = nil;

   items[menuptr].flags = MENUITEM::DISABLED;

   menuptr++;

   items[menuptr].text = "CANCEL";

   items[menuptr].flags = MENUITEM::CENTER;

   menuptr++;

   MENUDEF menu = { items, menuptr, "import labels" };

   if (!handle_menu(&menu)) return;

   if (menu.pos == 0) import_xas();

   menu.pos--;

   if ((unsigned)menu.pos < alasm_found_tables) import_alasm(alasm_offset[menu.pos], alasm_text[menu.pos]);

}

void MON_LABELS::import_file()

{

   FILE *ff = fopen(userfile, "rb"); if (!ff) return; fclose(ff);

   unsigned count = load(userfile, RAM_BASE_M, conf.ramsize * 1024);

   if (!count) return;

   char tmp[0x200];

   sprintf(tmp, "loaded %u labels from\r\n%s", count, userfile);

   puts(tmp);

   //MessageBox(GetForegroundWindow(), tmp, "unreal discovered changes in user labels", MB_OK | MB_ICONINFORMATION);//removed by Alone Coder

}

void load_labels(char *filename, unsigned char *base, unsigned size)

{

   mon_labels.load(filename, base, size);

}

static char curlabel[64];

static unsigned lcount;

static void ShowLabels()

{

   SetDlgItemText(dlg, IDC_LABEL_TEXT, curlabel);

   HWND list = GetDlgItem(dlg, IDC_LABELS);

   while (SendMessage(list, LB_GETCOUNT, 0, 0))

      SendMessage(list, LB_DELETESTRING, 0, 0);

   size_t ln = strlen(curlabel); lcount = 0;

   char *s; //Alone Coder 0.36.7

   for (unsigned p = 0; p < 4; p++)

   {

      unsigned char *base = am_r(p*PAGE);

      for (unsigned i = 0; i < mon_labels.n_pairs; i++)

      {

         unsigned char *label = mon_labels.pairs[i].address;

         if (label < base || label >= base + PAGE)

             continue;

         char *name = mon_labels.pairs[i].name_offs + mon_labels.names;

         if (ln)

         {

            // unfortunately, strstr() is case sensitive, use loop

            for (/*char * */s = name; *s; s++)

               if (!strnicmp(s, curlabel, ln)) break;

            if (!*s) continue;

         }

         char zz[0x400];

         sprintf(zz, "%04X %s", unsigned((label - base) + (p * PAGE)), name);

         SendMessage(list, LB_ADDSTRING, 0, (LPARAM)zz); lcount++;

      }

   }

   SendMessage(list, LB_SETCURSEL, 0, 0);

   SetFocus(list);

}

static INT_PTR CALLBACK LabelsDlg(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)

{

    (void)lp;

   ::dlg = dlg;

   if (msg == WM_INITDIALOG)

   {

      *curlabel = 0;

      ShowLabels();

      return 1;

   }

   if (msg == WM_SYSCOMMAND && (wp & 0xFFF0) == SC_CLOSE) EndDialog(dlg, 0);

   if (msg == WM_VKEYTOITEM)

   {

       size_t sz = strlen(curlabel);

       wp = LOWORD(wp);

       if(wp == VK_BACK)

       {

           if(sz)

           {

               curlabel[sz - 1] = 0;

               ShowLabels();

           }

           else { deadkey: Beep(300, 100); }

       }

       else if((unsigned)(wp - '0') < 10 || (unsigned)(wp - 'A') < 26 || wp == '_')

       {

           if(sz == sizeof(curlabel) - 1)

           {

               goto deadkey;

           }

           curlabel[sz] = char(wp);

           curlabel[sz + 1] = 0;

           ShowLabels();

           if(!lcount)

           {

               curlabel[sz] = 0;

               ShowLabels();

               goto deadkey;

           }

       }

       else

       {

           return -1;

       }

       return -2;

   }

   if (msg != WM_COMMAND) return 0;

   unsigned id = LOWORD(wp), code = HIWORD(wp);

   if (id == IDCANCEL || id == IDOK) EndDialog(dlg, 0);

   if (id == IDOK || (id == IDC_LABELS && code == LBN_DBLCLK))

   {

      HWND list = GetDlgItem(dlg, IDC_LABELS);

      unsigned n = unsigned(SendMessage(list, LB_GETCURSEL, 0, 0));

      if (n >= lcount) return 0;

      char zz[0x400]; SendMessage(list, LB_GETTEXT, n, (LPARAM)zz);

      unsigned address; sscanf(zz, "%X", &address);

      void push_pos(); push_pos();

      CpuMgr.Cpu().trace_curs = CpuMgr.Cpu().trace_top = address;

      activedbg = WNDTRACE;

      EndDialog(dlg, 1);

      return 1;

   }

   return 0;

}

void mon_show_labels()

{

   DialogBox(hIn, MAKEINTRESOURCE(IDD_LABELS), wnd, LabelsDlg);

}