Changeset 551 for trunk/dll/mle.c


Ignore:
Timestamp:
Feb 28, 2007, 2:33:51 AM (19 years ago)
Author:
Gregg Young
Message:

Indentation cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/mle.c

    r528 r551  
    4242        ((c) + (char) 47)) : (c))
    4343
    44 
    45 LONG MLEgetlinetext (HWND h,LONG l,CHAR *buf,INT maxlen)
     44LONG MLEgetlinetext(HWND h, LONG l, CHAR * buf, INT maxlen)
    4645{
    4746  /* get text of line l from MLE */
    4847
    49   IPT s,e;
    50 
    51   s = MLEstartofline(h,l);
    52   e = MLElinelenleft(h,s);
    53   return MLEtextatpos(h,s,buf,min((INT)e,maxlen));
    54 }
    55 
    56 
    57 LONG MLEdeleteline (HWND h,LONG l)
     48  IPT s, e;
     49
     50  s = MLEstartofline(h, l);
     51  e = MLElinelenleft(h, s);
     52  return MLEtextatpos(h, s, buf, min((INT) e, maxlen));
     53}
     54
     55LONG MLEdeleteline(HWND h, LONG l)
    5856{
    5957  /* delete line l from MLE */
    6058
    61   IPT s,e;
    62 
    63   s = MLEstartofline(h,l);
    64   e = MLElinelenleft(h,s);
    65   return MLEdelete(h,s,e);
    66 }
    67 
    68 
    69 LONG MLEdeletecurline (HWND h)
     59  IPT s, e;
     60
     61  s = MLEstartofline(h, l);
     62  e = MLElinelenleft(h, s);
     63  return MLEdelete(h, s, e);
     64}
     65
     66LONG MLEdeletecurline(HWND h)
    7067{
    7168  /* delete current line from MLE */
    … …  
    7471
    7572  l = MLEcurline(h);
    76   return MLEdeleteline(h,l);
    77 }
    78 
    79 
    80 LONG MLEdeletetoeol (HWND h)
     73  return MLEdeleteline(h, l);
     74}
     75
     76LONG MLEdeletetoeol(HWND h)
    8177{
    8278  /* delete from cursor pos to end of line */
    8379
    84   IPT s,e;
     80  IPT s, e;
    8581
    8682  s = MLEcurpos(h);
    8783  e = MLEcurlenleft(h);
    88   return MLEdelete(h,s,e);
     84  return MLEdelete(h, s, e);
    8985}
    9086
    9187#pragma alloc_text(FMMLE,MLEclearall,MLEtextatcursor,MLEtextatpos,MLEsizeofsel)
    9288
    93 
    94 VOID MLEclearall (HWND h)
     89VOID MLEclearall(HWND h)
    9590{
    9691  /* remove all text from MLE */
    … …  
    9893
    9994  len = MLEgetlen(h);
    100   if(len)
    101     MLEdelete(h,0,len);
    102 }
    103 
    104 
    105 LONG MLEtextatcursor (HWND h,CHAR *buffer,INT buflen)
     95  if (len)
     96    MLEdelete(h, 0, len);
     97}
     98
     99LONG MLEtextatcursor(HWND h, CHAR * buffer, INT buflen)
    106100{
    107101  /* place up to buflen chars of text from cursor pos into buffer
    … …  
    109103   */
    110104
    111   IPT  i;
     105  IPT i;
    112106
    113107  i = MLEcurpos(h);
    114   return MLEtextatpos(h,i,buffer,buflen);
    115 }
    116 
    117 
    118 LONG MLEtextatpos (HWND h,IPT i,CHAR *buffer,INT buflen)
     108  return MLEtextatpos(h, i, buffer, buflen);
     109}
     110
     111LONG MLEtextatpos(HWND h, IPT i, CHAR * buffer, INT buflen)
    119112{
    120113  /* place up to buflen chars of text from pos i in buffer
    … …  
    122115   */
    123116
    124   WinSendMsg(h,MLM_SETIMPORTEXPORT,MPFROMP(buffer),
    125              MPFROMLONG((LONG)buflen));
    126   return(LONG)WinSendMsg(h,MLM_EXPORT,
    127                          MPFROMP(&i),
    128                          MPFROMLONG((PLONG)&buflen));
    129 }
    130 
    131 
    132 LONG MLEsizeofsel (HWND h)
     117  WinSendMsg(h, MLM_SETIMPORTEXPORT, MPFROMP(buffer),
     118             MPFROMLONG((LONG) buflen));
     119  return (LONG) WinSendMsg(h, MLM_EXPORT,
     120                           MPFROMP(&i), MPFROMLONG((PLONG) & buflen));
     121}
     122
     123LONG MLEsizeofsel(HWND h)
    133124{
    134125  /* return length of selected text */
    135126
    136   IPT cursor,anchor,test;
     127  IPT cursor, anchor, test;
    137128
    138129  cursor = MLEcurpos(h);
    139130  anchor = MLEancpos(h);
    140   test = min(cursor,anchor);
     131  test = min(cursor, anchor);
    141132  /* MLE fakes us out; get real length in bytes */
    142   return (LONG)WinSendMsg(h,MLM_QUERYFORMATTEXTLENGTH,
    143                           MPFROMLONG(test),
    144                           MPFROMLONG((LONG)((cursor < anchor) ?
    145                           (anchor - cursor):
    146                           (cursor - anchor))));
    147 }
    148 
     133  return (LONG) WinSendMsg(h, MLM_QUERYFORMATTEXTLENGTH,
     134                           MPFROMLONG(test),
     135                           MPFROMLONG((LONG) ((cursor < anchor) ?
     136                                              (anchor - cursor) :
     137                                              (cursor - anchor))));
     138}
    149139
    150140#pragma alloc_text(FMMLE3,MLEdoblock,MLEquotepara,MLEinternet)
    151141
    152 VOID MLEinternet (HWND h,BOOL ftp)
     142VOID MLEinternet(HWND h, BOOL ftp)
    153143{
    154144  CHAR *temp = NULL;
    155   IPT   ancpos,curpos,here;
    156   LONG  len,oldlen;
     145  IPT ancpos, curpos, here;
     146  LONG len, oldlen;
    157147  APIRET rc;
    158148
    159149  len = MLEsizeofsel(h);
    160   len = min(2048,len);
     150  len = min(2048, len);
    161151  oldlen = len;
    162152  if (len) {
    163153    len++;
    164     rc = DosAllocMem((PVOID)&temp,4096,
    165                      PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
     154    rc = DosAllocMem((PVOID) & temp, 4096,
     155                     PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
    166156    if (rc || !temp)
    167       Dos_Error(MB_CANCEL,rc,h,pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
     157      Dos_Error(MB_CANCEL, rc, h, pszSrcFile, __LINE__,
     158                GetPString(IDS_OUTOFMEMORY));
    168159    else {
    169160      ancpos = MLEancpos(h);
    170161      curpos = MLEcurpos(h);
    171       here = min(curpos,ancpos);
    172       WinSendMsg(h,MLM_SETIMPORTEXPORT,MPFROMP(temp),MPFROMLONG(len));
    173       len = (LONG)WinSendMsg(h,MLM_EXPORT,MPFROMP(&here),MPFROMP(&len));
     162      here = min(curpos, ancpos);
     163      WinSendMsg(h, MLM_SETIMPORTEXPORT, MPFROMP(temp), MPFROMLONG(len));
     164      len = (LONG) WinSendMsg(h, MLM_EXPORT, MPFROMP(&here), MPFROMP(&len));
    174165      if (len <= 1)
    175         Runtime_Error(pszSrcFile, __LINE__, "len <= 1");
     166        Runtime_Error(pszSrcFile, __LINE__, "len <= 1");
    176167      else {
    177         if(len > oldlen)
    178           len--;
    179         temp[len] = 0;
    180         bstripcr(temp);
    181         if(*temp) {
    182           if(ftp && *ftprun)
    183             runemf2(SEPARATE | WINDOWED,
    184                     h,
    185                     NULL,
    186                     NULL,
    187                     "%s %s",
    188                     ftprun,
    189                     temp);
    190           else if(!ftp && *httprun)
    191             runemf2(SEPARATE | WINDOWED,
    192                     h,
    193                     NULL,
    194                     NULL,
    195                     "%s %s",
    196                     httprun,
    197                     temp);
    198         }
     168        if (len > oldlen)
     169          len--;
     170        temp[len] = 0;
     171        bstripcr(temp);
     172        if (*temp) {
     173          if (ftp && *ftprun)
     174            runemf2(SEPARATE | WINDOWED,
     175                    h, NULL, NULL, "%s %s", ftprun, temp);
     176          else if (!ftp && *httprun)
     177            runemf2(SEPARATE | WINDOWED,
     178                    h, NULL, NULL, "%s %s", httprun, temp);
     179        }
    199180      }
    200181      DosFreeMem(temp);
    … …  
    203184}
    204185
    205 
    206 BOOL MLEdoblock (HWND h,INT action,CHAR *filename)
     186BOOL MLEdoblock(HWND h, INT action, CHAR * filename)
    207187{
    208188  /* perform action on text in selection */
    209189
    210190  register CHAR *p;
    211   CHAR *sel,*temp = NULL;
    212   IPT  ancpos,curpos,here;
    213   LONG sellen,oldlen;
     191  CHAR *sel, *temp = NULL;
     192  IPT ancpos, curpos, here;
     193  LONG sellen, oldlen;
    214194  APIRET rc;
    215195
    216196  oldlen = MLEsizeofsel(h);
    217   if(!oldlen)
     197  if (!oldlen)
    218198    return TRUE;
    219   sel = xmallocz((size_t)(oldlen + 2),pszSrcFile,__LINE__);
     199  sel = xmallocz((size_t) (oldlen + 2), pszSrcFile, __LINE__);
    220200  if (!sel)
    221201    return FALSE;
    222   rc = DosAllocMem((PVOID)&temp,32768L,
    223                    PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
     202  rc = DosAllocMem((PVOID) & temp, 32768L,
     203                   PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
    224204  if (rc || !temp) {
    225     Dos_Error(MB_CANCEL,rc,h,pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
     205    Dos_Error(MB_CANCEL, rc, h, pszSrcFile, __LINE__,
     206              GetPString(IDS_OUTOFMEMORY));
    226207    free(sel);
    227208    DosPostEventSem(CompactSem);
    … …  
    231212  ancpos = MLEancpos(h);
    232213  curpos = MLEcurpos(h);
    233   here = min(curpos,ancpos);
     214  here = min(curpos, ancpos);
    234215  p = sel;
    235216  MLEdisable(h);
    236   while(oldlen > 0) {
    237     sellen = min(oldlen + 1,32701);
    238     WinSendMsg(h,MLM_SETIMPORTEXPORT,MPFROMP(temp),MPFROMLONG(sellen));
    239     sellen = (LONG)WinSendMsg(h,MLM_EXPORT,MPFROMP(&here),MPFROMP(&sellen));
     217  while (oldlen > 0) {
     218    sellen = min(oldlen + 1, 32701);
     219    WinSendMsg(h, MLM_SETIMPORTEXPORT, MPFROMP(temp), MPFROMLONG(sellen));
     220    sellen =
     221      (LONG) WinSendMsg(h, MLM_EXPORT, MPFROMP(&here), MPFROMP(&sellen));
    240222    if (sellen < 1) {
    241223      Runtime_Error(pszSrcFile, __LINE__, "len < 1");
    … …  
    244226      return FALSE;
    245227    }
    246     if(sellen > min(oldlen,32700))
     228    if (sellen > min(oldlen, 32700))
    247229      sellen--;
    248     memcpy(p,temp,sellen);
     230    memcpy(p, temp, sellen);
    249231    p += sellen;
    250232    oldlen -= sellen;
    251233  }
    252   switch(action) {
    253     case APPENDCLIP:
    254       SaveToClip(h,sel,TRUE);
     234  switch (action) {
     235  case APPENDCLIP:
     236    SaveToClip(h, sel, TRUE);
     237    DosFreeMem(temp);
     238    free(sel);
     239    MLEenable(h);
     240    DosPostEventSem(CompactSem);
     241    return TRUE;
     242
     243  case WRITE:
     244    {
     245      FILE *fp;
     246
     247      fp = fopen(filename, "a+");
     248      if (!fp)
     249        fp = xfopen(filename, "w", pszSrcFile, __LINE__);
     250      if (fp) {
     251        fseek(fp, 0L, SEEK_END);
     252        fwrite(sel, 1, strlen(sel), fp);
     253        fclose(fp);
     254      }
     255#ifdef __DEBUG_ALLOC__
     256      _heap_check();
     257#endif
    255258      DosFreeMem(temp);
    256259      free(sel);
    … …  
    258261      DosPostEventSem(CompactSem);
    259262      return TRUE;
    260 
    261     case WRITE:
    262       {
    263         FILE *fp;
    264 
    265         fp = fopen(filename,"a+");
    266         if(!fp)
    267           fp = xfopen(filename,"w",pszSrcFile,__LINE__);
    268         if (fp) {
    269           fseek(fp,0L,SEEK_END);
    270           fwrite(sel,1,strlen(sel),fp);
    271           fclose(fp);
    272         }
    273 #ifdef __DEBUG_ALLOC__
    274         _heap_check();
    275 #endif
    276         DosFreeMem(temp);
    277         free(sel);
    278         MLEenable(h);
    279         DosPostEventSem(CompactSem);
    280         return TRUE;
     263    }
     264
     265  case UPPERCASE:
     266    p = sel;
     267    while (*p) {
     268      if (isalpha(*p))
     269        *p = toupper(*p);
     270      p++;
     271    }
     272    break;
     273
     274  case LOWERCASE:
     275    p = sel;
     276    while (*p) {
     277      if (isalpha(*p))
     278        *p = tolower(*p);
     279      p++;
     280    }
     281    break;
     282
     283  case TOGGLECASE:
     284    p = sel;
     285    while (*p) {
     286      if (isalpha(*p)) {
     287        if (islower(*p))
     288          *p = toupper(*p);
     289        else
     290          *p = tolower(*p);
    281291      }
    282 
    283     case UPPERCASE:
    284       p = sel;
    285       while(*p) {
    286         if(isalpha(*p))
    287           *p = toupper(*p);
    288         p++;
     292      p++;
     293    }
     294    break;
     295
     296  case ROT13:
     297    p = sel;
     298    while (*p) {
     299      *p = DOROT13(*p); // fixme condition both true and false?
     300      p++;
     301    }
     302    break;
     303
     304  case XOR:
     305    p = sel;
     306    while (*p) {
     307      *p = (~*p);
     308      p++;
     309    }
     310    break;
     311
     312  case FORMAT:
     313    p = sel;
     314    while (*p) {
     315      if (*p == '\r') {
     316        memmove(p, p + 1, strlen(p));
     317        continue;
    289318      }
    290       break;
    291 
    292     case LOWERCASE:
    293       p = sel;
    294       while(*p) {
    295         if(isalpha(*p))
    296           *p = tolower(*p);
    297         p++;
     319      if (*p == '\n') {
     320        *p = ' ';
     321        continue;
    298322      }
    299       break;
    300 
    301     case TOGGLECASE:
    302       p = sel;
    303       while(*p) {
    304         if(isalpha(*p)) {
    305           if(islower(*p))
    306             *p = toupper(*p);
    307           else
    308             *p = tolower(*p);
    309         }
    310         p++;
    311       }
    312       break;
    313 
    314     case ROT13:
    315       p = sel;
    316       while(*p) {
    317         *p = DOROT13(*p);
    318         p++;
    319       }
    320       break;
    321 
    322     case XOR:
    323       p = sel;
    324       while(*p) {
    325         *p = (~*p);
    326         p++;
    327       }
    328       break;
    329 
    330     case FORMAT:
    331       p = sel;
    332       while(*p) {
    333         if(*p == '\r') {
    334           memmove(p,p + 1,strlen(p));
    335           continue;
    336         }
    337         if(*p == '\n') {
    338           *p = ' ';
    339           continue;
    340         }
    341         p++;
    342       }
    343       break;
    344 
    345     default:        /* unknown action */
     323      p++;
     324    }
     325    break;
     326
     327  default:                              /* unknown action */
    346328#ifdef __DEBUG_ALLOC__
    347329    _heap_check();
    348330#endif
    349       DosFreeMem(temp);
    350       free(sel);
    351       DosPostEventSem(CompactSem);
    352       MLEenable(h);
    353       return FALSE;
     331    DosFreeMem(temp);
     332    free(sel);
     333    DosPostEventSem(CompactSem);
     334    MLEenable(h);
     335    return FALSE;
    354336  }
    355337
    356338  /* replace selection with altered text */
    357339  p = sel;
    358   here = min(curpos,ancpos);
    359   MLEclear(h);      /* delete current selection */
    360   sellen = oldlen = strlen(sel);  /* actual number of bytes */
    361   while(oldlen > 0) {
    362     sellen = min(oldlen,32700);
    363     memcpy(temp,p,sellen);
    364     WinSendMsg(h,
    365                MLM_SETIMPORTEXPORT,
    366                MPFROMP(temp),
    367                MPFROMLONG(sellen));
    368     sellen = (LONG)WinSendMsg(h,
    369                               MLM_IMPORT,
    370                               MPFROMP(&here),
    371                               MPFROMLONG(sellen));
     340  here = min(curpos, ancpos);
     341  MLEclear(h);                          /* delete current selection */
     342  sellen = oldlen = strlen(sel);        /* actual number of bytes */
     343  while (oldlen > 0) {
     344    sellen = min(oldlen, 32700);
     345    memcpy(temp, p, sellen);
     346    WinSendMsg(h, MLM_SETIMPORTEXPORT, MPFROMP(temp), MPFROMLONG(sellen));
     347    sellen = (LONG) WinSendMsg(h,
     348                               MLM_IMPORT,
     349                               MPFROMP(&here), MPFROMLONG(sellen));
    372350    if (!sellen) {
    373351      Runtime_Error(pszSrcFile, __LINE__, "sellen 0");
    … …  
    376354    p += sellen;
    377355    oldlen -= sellen;
    378     if(oldlen && *p == '\n' /* && *(p - 1) == '\r' */)
     356    if (oldlen && *p == '\n' /* && *(p - 1) == '\r' */ )
    379357      p--;
    380   } // while
    381   WinSendMsg(h,MLM_SETSEL,MPFROMLONG(ancpos),MPFROMLONG(curpos));
     358  }                                     // while
     359  WinSendMsg(h, MLM_SETSEL, MPFROMLONG(ancpos), MPFROMLONG(curpos));
    382360  MLEenable(h);
    383361#ifdef __DEBUG_ALLOC__
    384     _heap_check();
     362  _heap_check();
    385363#endif
    386364  DosFreeMem(temp);
    … …  
    390368}
    391369
    392 
    393 BOOL MLEquotepara (HWND h,CHAR *initials,BOOL fQuoteOld)
     370BOOL MLEquotepara(HWND h, CHAR * initials, BOOL fQuoteOld)
    394371{
    395372  LONG num;
    396   CHAR lineend[2],line[8],*p;
    397 
    398   if(!initials || !*initials)
     373  CHAR lineend[2], line[8], *p;
     374
     375  if (!initials || !*initials)
    399376    initials = " > ";
    400377  num = MLEcurline(h);
    401   while(MLElinelen(h,num) < 3L && MLEnumlines(h) >= num)
     378  while (MLElinelen(h, num) < 3L && MLEnumlines(h) >= num)
    402379    num++;
    403   while(MLElinelen(h,num) > 2L && MLEnumlines(h) >= num) {
    404     memset(line,0,8);
    405     MLEgetlinetext(h,num,line,7L);
     380  while (MLElinelen(h, num) > 2L && MLEnumlines(h) >= num) {
     381    memset(line, 0, 8);
     382    MLEgetlinetext(h, num, line, 7L);
    406383    line[7] = 0;
    407     if((p = strchr(line,'>')) == NULL) {
    408       MLEsetcurpos(h,MLEstartofline(h,num));
    409       MLEinsert(h,initials);
    410       MLEsetcurpos(h,(MLEstartofline(h,num) + MLElinelen(h,num)) - 1L);
    411       MLEtextatcursor(h,lineend,2L);
    412       if(*lineend != '\r' && *lineend != '\n')
    413         MLEinsert(h,"\n");
    414     }
    415     else if(fQuoteOld) {
    416       while(isspace(line[strlen(line) - 1]))
    417         line[strlen(line) - 1] = 0;
    418       MLEsetcurpos(h,MLEstartofline(h,num) + (p - line));
    419       MLEinsert(h,">");
     384    if ((p = strchr(line, '>')) == NULL) {
     385      MLEsetcurpos(h, MLEstartofline(h, num));
     386      MLEinsert(h, initials);
     387      MLEsetcurpos(h, (MLEstartofline(h, num) + MLElinelen(h, num)) - 1L);
     388      MLEtextatcursor(h, lineend, 2L);
     389      if (*lineend != '\r' && *lineend != '\n')
     390        MLEinsert(h, "\n");
     391    }
     392    else if (fQuoteOld) {
     393      while (isspace(line[strlen(line) - 1]))
     394        line[strlen(line) - 1] = 0;
     395      MLEsetcurpos(h, MLEstartofline(h, num) + (p - line));
     396      MLEinsert(h, ">");
    420397    }
    421398    num++;
    422399  }
    423   MLEsetcurpos(h,MLEstartofline(h,num));
     400  MLEsetcurpos(h, MLEstartofline(h, num));
    424401  return TRUE;
    425402}
    … …  
    427404#pragma alloc_text(FMMLE4,MLEAutoLoad,MLEHexLoad,MLEinsertfile,LoadThread,MLEbackgroundload)
    428405
    429 
    430 BOOL MLEAutoLoad (HWND h,CHAR *filename)
     406BOOL MLEAutoLoad(HWND h, CHAR * filename)
    431407{
    432408  XMLEWNDPTR *vw;
    433409
    434   vw = (XMLEWNDPTR *)WinQueryWindowPtr(WinQueryWindow(h,QW_PARENT),0);
    435   if(vw && vw->size != sizeof(XMLEWNDPTR))
     410  vw = (XMLEWNDPTR *) WinQueryWindowPtr(WinQueryWindow(h, QW_PARENT), 0);
     411  if (vw && vw->size != sizeof(XMLEWNDPTR))
    436412    vw = NULL;
    437   if(TestBinary(filename)) {
    438     if(vw)
     413  if (TestBinary(filename)) {
     414    if (vw)
    439415      vw->hex = 1;
    440     return MLEHexLoad(h,filename);
    441   }
    442   if(vw)
     416    return MLEHexLoad(h, filename);
     417  }
     418  if (vw)
    443419    vw->hex = 2;
    444   return MLEloadfile(h,filename);
    445 }
    446 
    447 
    448 BOOL MLEHexLoad (HWND h,CHAR *filename)
     420  return MLEloadfile(h, filename);
     421}
     422
     423BOOL MLEHexLoad(HWND h, CHAR * filename)
    449424{
    450425  /* insert a file into the current position in the MLE */
    451426
    452   HAB         hab;
    453   CHAR       *buffer = NULL,*hexbuff = NULL;
    454   IPT         iptOffset = -1L;
    455   ULONG       numread,howmuch,numimport,action,len,left = 0L;
    456   BOOL        ret = TRUE,first = TRUE;
    457   CHAR        titletext[512];
    458   HWND        grandpa;
     427  HAB hab;
     428  CHAR *buffer = NULL, *hexbuff = NULL;
     429  IPT iptOffset = -1L;
     430  ULONG numread, howmuch, numimport, action, len, left = 0L;
     431  BOOL ret = TRUE, first = TRUE;
     432  CHAR titletext[512];
     433  HWND grandpa;
    459434  XMLEWNDPTR *vw;
    460   HFILE       handle;
    461   APIRET      rc;
     435  HFILE handle;
     436  APIRET rc;
    462437
    463438  *titletext = 0;
    464439  hab = WinQueryAnchorBlock(h);
    465   vw = (XMLEWNDPTR *)WinQueryWindowPtr(WinQueryWindow(h,QW_PARENT),0);
    466   if(vw && vw->size != sizeof(XMLEWNDPTR))
     440  vw = (XMLEWNDPTR *) WinQueryWindowPtr(WinQueryWindow(h, QW_PARENT), 0);
     441  if (vw && vw->size != sizeof(XMLEWNDPTR))
    467442    vw = NULL;
    468443  grandpa = GrandparentOf(h);
    469444  *titletext = 0;
    470   WinQueryWindowText(grandpa,512,titletext);
    471   rc = DosOpen(filename,&handle,&action,0L,0L,
    472                OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
    473                OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
    474                OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
    475                OPEN_ACCESS_READONLY,0L);
     445  WinQueryWindowText(grandpa, 512, titletext);
     446  rc = DosOpen(filename, &handle, &action, 0L, 0L,
     447               OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
     448               OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
     449               OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
     450               OPEN_ACCESS_READONLY, 0L);
    476451  if (rc) {
    477452    ret = FALSE;
    … …  
    481456    DosChgFilePtr(handle, 0L, FILE_BEGIN, &action);
    482457    if (len) {
    483       rc = DosAllocMem((PVOID)&hexbuff,50001L,
    484                        PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
     458      rc = DosAllocMem((PVOID) & hexbuff, 50001L,
     459                       PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
    485460      if (rc || !hexbuff) {
    486         Dos_Error(MB_CANCEL,rc,h,pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
    487         ret = FALSE;
     461        Dos_Error(MB_CANCEL, rc, h, pszSrcFile, __LINE__,
     462                  GetPString(IDS_OUTOFMEMORY));
     463        ret = FALSE;
    488464      }
    489465      else {
    490         buffer = xmalloc(10000,pszSrcFile,__LINE__);
    491         if (!buffer)
    492           ret = FALSE;
     466        buffer = xmalloc(10000, pszSrcFile, __LINE__);
     467        if (!buffer)
     468          ret = FALSE;
    493469        else {
    494           MLEclearall(h);
    495           WinSendMsg(h,MLM_SETIMPORTEXPORT,MPFROMP(hexbuff),
    496                      MPFROMLONG(50000L));
    497           if(!DosRead(handle,buffer,min(10000,len),&numread) && numread) {
    498 
    499             CHAR s[81];
    500 
    501             MLEsetwrap(h,FALSE);
    502             WinSetSysValue(HWND_DESKTOP,SV_INSERTMODE,FALSE);
    503             *hexbuff = 0;
    504             numimport = CreateHexDump(buffer,
    505                                       numread,
    506                                       hexbuff,
    507                                       50000,
    508                                       left,
    509                                       TRUE);
    510             while(len && numimport) {  /* import entire file */
    511               left += numread;
    512               len -= numread;
    513               if(!WinIsWindow(hab,h) || (vw && vw->killme))
    514                 break;
    515               howmuch = (INT)WinSendMsg(h,
    516                                         MLM_IMPORT,
    517                                         MPFROMP(&iptOffset),
    518                                         MPFROMLONG(numimport));
    519               if(first && len) {
    520                 MLEdisable(h);
    521                 WinEnableWindowUpdate(h,FALSE);
    522                 first = FALSE;
    523               }
     470          MLEclearall(h);
     471          WinSendMsg(h, MLM_SETIMPORTEXPORT, MPFROMP(hexbuff),
     472                     MPFROMLONG(50000L));
     473          if (!DosRead(handle, buffer, min(10000, len), &numread) && numread) {
     474
     475            CHAR s[81];
     476
     477            MLEsetwrap(h, FALSE);
     478            WinSetSysValue(HWND_DESKTOP, SV_INSERTMODE, FALSE);
     479            *hexbuff = 0;
     480            numimport = CreateHexDump(buffer,
     481                                      numread, hexbuff, 50000, left, TRUE);
     482            while (len && numimport) {  /* import entire file */
     483              left += numread;
     484              len -= numread;
     485              if (!WinIsWindow(hab, h) || (vw && vw->killme))
     486                break;
     487              howmuch = (INT) WinSendMsg(h,
     488                                         MLM_IMPORT,
     489                                         MPFROMP(&iptOffset),
     490                                         MPFROMLONG(numimport));
     491              if (first && len) {
     492                MLEdisable(h);
     493                WinEnableWindowUpdate(h, FALSE);
     494                first = FALSE;
     495              }
    524496// fprintf(stderr,"%d bytes of %d imported\n",howmuch,numimport);
    525               if(howmuch < 1) {
    526                 numimport = 0;
    527                 break;
    528               }
    529               while(howmuch < numimport) {
    530                 numimport -= howmuch;
    531                 memmove(hexbuff,hexbuff + howmuch,numimport);
    532                 DosSleep(0L);
    533                 if(!WinIsWindow(hab,h) ||
    534                    (vw &&
    535                     vw->killme))
    536                   break;
    537                 howmuch = (INT)WinSendMsg(h,
    538                                           MLM_IMPORT,
    539                                           MPFROMP(&iptOffset),
    540                                           MPFROMLONG((LONG)numimport));
    541                 if(howmuch < 1)
    542                   break;
    543               }
    544               if(DosRead(handle,buffer,min(10000,len),&numread) || !numread) {
    545                 numimport = 0;
    546                 break;
    547               }
    548               *hexbuff = 0;
    549               numimport = CreateHexDump(buffer,numread,hexbuff,50000,left,TRUE);
    550               if(numimport < 1 ||
    551                  !WinIsWindow(hab,h) ||
    552                  (vw &&
    553                   vw->killme)) {
    554                 numimport = 0;
    555                 break;
    556               }
    557               sprintf(s,
    558                       GetPString(IDS_LOADINGMLETEXT),
    559                       len);
    560               WinSetWindowText(grandpa,s);
    561             }
    562             DosSleep(1L);
    563           }
    564           else
    565             ret = FALSE;
    566           free(buffer);
    567         }
    568         DosFreeMem(hexbuff);
     497              if (howmuch < 1) {
     498                numimport = 0;
     499                break;
     500              }
     501              while (howmuch < numimport) {
     502                numimport -= howmuch;
     503                memmove(hexbuff, hexbuff + howmuch, numimport);
     504                DosSleep(0L);
     505                if (!WinIsWindow(hab, h) || (vw && vw->killme))
     506                  break;
     507                howmuch = (INT) WinSendMsg(h,
     508                                           MLM_IMPORT,
     509                                           MPFROMP(&iptOffset),
     510                                           MPFROMLONG((LONG) numimport));
     511                if (howmuch < 1)
     512                  break;
     513              }
     514              if (DosRead(handle, buffer, min(10000, len), &numread)
     515                  || !numread) {
     516                numimport = 0;
     517                break;
     518              }
     519              *hexbuff = 0;
     520              numimport =
     521                CreateHexDump(buffer, numread, hexbuff, 50000, left, TRUE);
     522              if (numimport < 1 || !WinIsWindow(hab, h) || (vw && vw->killme)) {
     523                numimport = 0;
     524                break;
     525              }
     526              sprintf(s, GetPString(IDS_LOADINGMLETEXT), len);
     527              WinSetWindowText(grandpa, s);
     528            }
     529            DosSleep(1L);
     530          }
     531          else
     532            ret = FALSE;
     533          free(buffer);
     534        }
     535        DosFreeMem(hexbuff);
    569536      }
    570537    }
    571     if(WinIsWindow(hab,h))
    572       WinSetWindowText(grandpa,titletext);
     538    if (WinIsWindow(hab, h))
     539      WinSetWindowText(grandpa, titletext);
    573540    DosClose(handle);
    574541  }
    575   if(!first) {
    576     WinEnableWindowUpdate(h,TRUE);
     542  if (!first) {
     543    WinEnableWindowUpdate(h, TRUE);
    577544    MLEenable(h);
    578545  }
    579   MLEsetchanged(h,FALSE);
     546  MLEsetchanged(h, FALSE);
    580547  return ret;
    581548}
    582549
    583 
    584550//== MLEinsertfile() insert a file into the current position in the MLE ==
    585551
    586 BOOL MLEinsertfile (HWND h,CHAR *filename)
    587 {
    588 
    589   HAB   hab;
     552BOOL MLEinsertfile(HWND h, CHAR * filename)
     553{
     554
     555  HAB hab;
    590556  FILE *fp;
    591   CHAR  *buffer = NULL;
    592   INT   len;
    593   IPT   iptOffset = -1L;
    594   INT   numread,howmuch,tempnum,x;
    595   BOOL  ret = TRUE,first = TRUE,once = FALSE,dont = FALSE;
    596   CHAR  titletext[512];
    597   HWND  grandpa;
     557  CHAR *buffer = NULL;
     558  INT len;
     559  IPT iptOffset = -1L;
     560  INT numread, howmuch, tempnum, x;
     561  BOOL ret = TRUE, first = TRUE, once = FALSE, dont = FALSE;
     562  CHAR titletext[512];
     563  HWND grandpa;
    598564  XMLEWNDPTR *vw;
    599565  APIRET rc;
    … …  
    601567  *titletext = 0;
    602568  hab = WinQueryAnchorBlock(h);
    603   vw = (XMLEWNDPTR *)WinQueryWindowPtr(WinQueryWindow(h,QW_PARENT),0);
    604   if(vw && vw->size != sizeof(XMLEWNDPTR))
     569  vw = (XMLEWNDPTR *) WinQueryWindowPtr(WinQueryWindow(h, QW_PARENT), 0);
     570  if (vw && vw->size != sizeof(XMLEWNDPTR))
    605571    vw = NULL;
    606572  grandpa = GrandparentOf(h);
    607573  *titletext = 0;
    608   WinQueryWindowText(grandpa,
    609                      512,
    610                      titletext);
    611   fp = _fsopen(filename,"r",SH_DENYNO);
     574  WinQueryWindowText(grandpa, 512, titletext);
     575  fp = _fsopen(filename, "r", SH_DENYNO);
    612576  if (!fp)
    613577    ret = FALSE;
    614578  else {
    615     setvbuf(fp,NULL,_IONBF,0);
    616     fseek(fp,0L,SEEK_END);
    617     len = (INT)ftell(fp);
    618     fseek(fp,0L,SEEK_SET);
    619     if(len && len != -1) {
    620       rc = DosAllocMem((PVOID)&buffer,
    621                        50000L,
    622                        PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
     579    setvbuf(fp, NULL, _IONBF, 0);
     580    fseek(fp, 0L, SEEK_END);
     581    len = (INT) ftell(fp);
     582    fseek(fp, 0L, SEEK_SET);
     583    if (len && len != -1) {
     584      rc = DosAllocMem((PVOID) & buffer,
     585                       50000L, PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
    623586      if (rc || !buffer) {
    624         Dos_Error(MB_CANCEL,rc,h,pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
    625         ret = FALSE;
     587        Dos_Error(MB_CANCEL, rc, h, pszSrcFile, __LINE__,
     588                  GetPString(IDS_OUTOFMEMORY));
     589        ret = FALSE;
    626590      }
    627591      else {
    628         WinSendMsg(h,
    629                    MLM_SETIMPORTEXPORT,
    630                    MPFROMP(buffer),
    631                    MPFROMLONG(50000L));
    632         numread = fread(buffer,
    633                         1,
    634                         min(50000,len),
    635                         fp);
    636         if(numread < 1)
    637           ret = FALSE;
    638         while(len &&
    639               numread > 0) {  /* here we go... */
    640 
    641           CHAR s[81];
    642 
    643           while(numread > 0) {  /* import entire file */
    644             if(!WinIsWindow(hab,h) ||
    645                (vw &&
    646                 vw->killme))
    647               break;
    648             if(strlen(buffer) < numread) {
    649               if(!once && !dont)
    650                 rc = saymsg(MB_YESNOCANCEL,
    651                             HWND_DESKTOP,
    652                             GetPString(IDS_WARNINGTEXT),
    653                             GetPString(IDS_TEXTNULSTEXT));
    654               else if(once)
    655                 rc = MBID_YES;
    656               else if(dont)
    657                 rc = MBID_NO;
    658               if(rc == MBID_YES) {
    659                 once = FALSE;
    660                 for(x = 0;x < numread;x++) {
    661                   if(!buffer[x])
    662                     buffer[x] = ' ';
    663                 }
    664               }
    665               else if(rc == MBID_CANCEL) {
    666                 len = 0;
    667                 numread = 0;
    668                 saymsg(MB_ENTER,
    669                        HWND_DESKTOP,
    670                        GetPString(IDS_OBEYTEXT),
    671                        GetPString(IDS_LOADCANCELLEDTEXT));
    672                 break;
    673               }
    674               else if(rc == MBID_NO)
    675                 dont = TRUE;
    676             }
    677             howmuch = (INT)WinSendMsg(h,
    678                                       MLM_IMPORT,
    679                                       MPFROMP(&iptOffset),
    680                                       MPFROMLONG((LONG)numread));
    681             if(first &&
    682                !feof(fp)) {
    683               MLEdisable(h);
    684               WinEnableWindowUpdate(h,FALSE);
    685               first = FALSE;
    686             }
     592        WinSendMsg(h,
     593                   MLM_SETIMPORTEXPORT, MPFROMP(buffer), MPFROMLONG(50000L));
     594        numread = fread(buffer, 1, min(50000, len), fp);
     595        if (numread < 1)
     596          ret = FALSE;
     597        while (len && numread > 0) {    /* here we go... */
     598
     599          CHAR s[81];
     600
     601          while (numread > 0) {         /* import entire file */
     602            if (!WinIsWindow(hab, h) || (vw && vw->killme))
     603              break;
     604            if (strlen(buffer) < numread) {
     605              if (!once && !dont)
     606                rc = saymsg(MB_YESNOCANCEL,
     607                            HWND_DESKTOP,
     608                            GetPString(IDS_WARNINGTEXT),
     609                            GetPString(IDS_TEXTNULSTEXT));
     610              else if (once)
     611                rc = MBID_YES;
     612              else if (dont)
     613                rc = MBID_NO;
     614              if (rc == MBID_YES) {
     615                once = FALSE;
     616                for (x = 0; x < numread; x++) {
     617                  if (!buffer[x])
     618                    buffer[x] = ' ';
     619                }
     620              }
     621              else if (rc == MBID_CANCEL) {
     622                len = 0;
     623                numread = 0;
     624                saymsg(MB_ENTER,
     625                       HWND_DESKTOP,
     626                       GetPString(IDS_OBEYTEXT),
     627                       GetPString(IDS_LOADCANCELLEDTEXT));
     628                break;
     629              }
     630              else if (rc == MBID_NO)
     631                dont = TRUE;
     632            }
     633            howmuch = (INT) WinSendMsg(h,
     634                                       MLM_IMPORT,
     635                                       MPFROMP(&iptOffset),
     636                                       MPFROMLONG((LONG) numread));
     637            if (first && !feof(fp)) {
     638              MLEdisable(h);
     639              WinEnableWindowUpdate(h, FALSE);
     640              first = FALSE;
     641            }
    687642// fprintf(stderr,"%d bytes of %d imported\n",howmuch,numread);
    688             if(howmuch < 1) {
    689               numread = 0;
    690               break;
    691             }
    692             len -= howmuch;
    693             if(howmuch < numread) {
    694               numread -= howmuch;
    695               memmove(buffer,
    696                       buffer + howmuch,
    697                       numread);
    698               if(numread &&
    699                  len) {
    700                 tempnum = numread;
    701                 numread = fread(buffer + tempnum,
    702                                 1,
    703                                 min(50000 - tempnum,len),
    704                                 fp);
    705                 if(numread > 1)
    706                   numread += tempnum;
    707                 else
    708                   numread = tempnum;
    709               }
    710               DosSleep(0L);
    711             }
    712             else
    713               numread = fread(buffer,
    714                               1,
    715                               min(50000,len),
    716                               fp);
    717             if(numread < 1 ||
    718                !WinIsWindow(hab,h) ||
    719                (vw &&
    720                 vw->killme)) {
    721               numread = 0;
    722               break;
    723             }
    724             sprintf(s,
    725                     GetPString(IDS_LOADINGMLETEXT),
    726                     len);
    727             WinSetWindowText(grandpa,s);
    728           }
    729           DosSleep(1L);
    730         }
    731         DosFreeMem(buffer);
     643            if (howmuch < 1) {
     644              numread = 0;
     645              break;
     646            }
     647            len -= howmuch;
     648            if (howmuch < numread) {
     649              numread -= howmuch;
     650              memmove(buffer, buffer + howmuch, numread);
     651              if (numread && len) {
     652                tempnum = numread;
     653                numread = fread(buffer + tempnum,
     654                                1, min(50000 - tempnum, len), fp);
     655                if (numread > 1)
     656                  numread += tempnum;
     657                else
     658                  numread = tempnum;
     659              }
     660              DosSleep(0L);
     661            }
     662            else
     663              numread = fread(buffer, 1, min(50000, len), fp);
     664            if (numread < 1 || !WinIsWindow(hab, h) || (vw && vw->killme)) {
     665              numread = 0;
     666              break;
     667            }
     668            sprintf(s, GetPString(IDS_LOADINGMLETEXT), len);
     669            WinSetWindowText(grandpa, s);
     670          }
     671          DosSleep(1L);
     672        }
     673        DosFreeMem(buffer);
    732674      }
    733675    }
    734     if(WinIsWindow(hab,h))
    735       WinSetWindowText(grandpa,titletext);
     676    if (WinIsWindow(hab, h))
     677      WinSetWindowText(grandpa, titletext);
    736678    fclose(fp);
    737679  }
    738   if(!first) {
    739     WinEnableWindowUpdate(h,TRUE);
     680  if (!first) {
     681    WinEnableWindowUpdate(h, TRUE);
    740682    MLEenable(h);
    741683  }
    … …  
    743685}
    744686
    745 
    746 typedef struct {
     687typedef struct
     688{
    747689  USHORT size;
    748690  USHORT hex;
    749   HWND   h;
    750   CHAR   filename[CCHMAXPATH];
    751   HWND   hwndReport;
    752   HWND   msg;
    753 } BKGLOAD;
    754 
    755 
    756 VOID LoadThread (VOID *arg)
     691  HWND h;
     692  CHAR filename[CCHMAXPATH];
     693  HWND hwndReport;
     694  HWND msg;
     695}
     696BKGLOAD;
     697
     698VOID LoadThread(VOID * arg)
    757699{
    758700  BKGLOAD *bkg;
    759   BOOL     fSuccess;
    760   HAB      thab;
    761   HMQ      thmq;
     701  BOOL fSuccess;
     702  HAB thab;
     703  HMQ thmq;
    762704
    763705  DosError(FERR_DISABLEHARDERR);
    764706
    765   bkg = (BKGLOAD *)arg;
    766   if(bkg) {
     707  bkg = (BKGLOAD *) arg;
     708  if (bkg) {
    767709    thab = WinInitialize(0);
    768     if(thab) {
    769       thmq = WinCreateMsgQueue(thab,0);
    770       if(thmq) {
    771         WinCancelShutdown(thmq,TRUE);
    772         IncrThreadUsage();
    773         priority_normal();
    774         if(bkg->hex == 1)
    775           fSuccess = MLEHexLoad(bkg->h,bkg->filename);
    776         else if(bkg->hex == 2)
    777           fSuccess = MLEloadfile(bkg->h,bkg->filename);
    778         else
    779           fSuccess = MLEAutoLoad(bkg->h,bkg->filename);
    780         priority_bumped();
    781         if(bkg->hwndReport && WinIsWindow(thab,bkg->hwndReport))
    782           PostMsg(bkg->hwndReport,bkg->msg,MPFROMLONG(fSuccess),
    783                      MPFROMP(bkg->filename));
     710    if (thab) {
     711      thmq = WinCreateMsgQueue(thab, 0);
     712      if (thmq) {
     713        WinCancelShutdown(thmq, TRUE);
     714        IncrThreadUsage();
     715        priority_normal();
     716        if (bkg->hex == 1)
     717          fSuccess = MLEHexLoad(bkg->h, bkg->filename);
     718        else if (bkg->hex == 2)
     719          fSuccess = MLEloadfile(bkg->h, bkg->filename);
     720        else
     721          fSuccess = MLEAutoLoad(bkg->h, bkg->filename);
     722        priority_bumped();
     723        if (bkg->hwndReport && WinIsWindow(thab, bkg->hwndReport))
     724          PostMsg(bkg->hwndReport, bkg->msg, MPFROMLONG(fSuccess),
     725                  MPFROMP(bkg->filename));
    784726#ifdef __DEBUG_ALLOC__
    785         _heap_check();
     727        _heap_check();
    786728#endif
    787         free(bkg);
    788         WinDestroyMsgQueue(thmq);
     729        free(bkg);
     730        WinDestroyMsgQueue(thmq);
    789731      }
    790732      DecrThreadUsage();
    … …  
    793735    }
    794736    // fixme to be gone?
    795     PostMsg(bkg->hwndReport,bkg->msg,MPVOID,MPVOID);
    796   }
    797 }
    798 
    799 
    800 INT MLEbackgroundload (HWND hwndReport,ULONG msg,HWND h,CHAR *filename,
    801                        INT hex)
     737    PostMsg(bkg->hwndReport, bkg->msg, MPVOID, MPVOID);
     738  }
     739}
     740
     741INT MLEbackgroundload(HWND hwndReport, ULONG msg, HWND h, CHAR * filename,
     742                      INT hex)
    802743{
    803744  /* load a file into the MLE in the background (via a separate thread)
    … …  
    808749  INT rc;
    809750
    810   bkg = xmallocz(sizeof(BKGLOAD),pszSrcFile,__LINE__);
     751  bkg = xmallocz(sizeof(BKGLOAD), pszSrcFile, __LINE__);
    811752  if (!bkg)
    812753    return -1;
    813754  bkg->size = sizeof(BKGLOAD);
    814   bkg->hex = (USHORT)hex;
     755  bkg->hex = (USHORT) hex;
    815756  bkg->hwndReport = hwndReport;
    816757  bkg->msg = msg;
    817758  bkg->h = h;
    818   strcpy(bkg->filename,filename);
    819   rc = _beginthread(LoadThread,NULL,65536,bkg);
     759  strcpy(bkg->filename, filename);
     760  rc = _beginthread(LoadThread, NULL, 65536, bkg);
    820761  if (rc == -1)
    821     Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
     762    Runtime_Error(pszSrcFile, __LINE__,
     763                  GetPString(IDS_COULDNTSTARTTHREADTEXT));
    822764  return rc;
    823765}
    … …  
    825767#pragma alloc_text(FMMLE5,MLEloadfile,MLEexportfile)
    826768
    827 BOOL MLEloadfile (HWND h,CHAR *filename)
     769BOOL MLEloadfile(HWND h, CHAR * filename)
    828770{
    829771  /* load a file into the MLE, getting rid of whatever was already
    … …  
    833775
    834776  FILESTATUS3 fsa;
    835   BOOL        ret;
    836 
    837   if(!DosQueryPathInfo(filename,FIL_STANDARD,&fsa,(ULONG)sizeof(fsa)) &&
    838      !(fsa.attrFile & FILE_DIRECTORY)) {
     777  BOOL ret;
     778
     779  if (!DosQueryPathInfo(filename, FIL_STANDARD, &fsa, (ULONG) sizeof(fsa)) &&
     780      !(fsa.attrFile & FILE_DIRECTORY)) {
    839781    MLEclearall(h);
    840     ret = MLEinsertfile(h,filename);
    841     MLEsetchanged(h,FALSE);
     782    ret = MLEinsertfile(h, filename);
     783    MLEsetchanged(h, FALSE);
    842784    return ret;
    843785  }
    … …  
    845787}
    846788
    847 
    848 BOOL MLEexportfile (HWND h,CHAR *filename,INT tabspaces,
    849                     BOOL striptraillines,BOOL striptrailspaces)
     789BOOL MLEexportfile(HWND h, CHAR * filename, INT tabspaces,
     790                   BOOL striptraillines, BOOL striptrailspaces)
    850791{
    851792  /* save the MLE contents as a file.  Format the output so that
    … …  
    857798  CHAR *p;
    858799  BOOL ok = TRUE;
    859   INT  blanklines = 0;
     800  INT blanklines = 0;
    860801  BOOL fWrap = MLEgetwrap(h);
    861802  APIRET rc;
    862803
    863804  // saymsg(MB_ENTER,h,DEBUG_STRING,"len = %ld",MLEgetlen(h));
    864   if(!MLEgetlen(h))   /* nothing to save; forget it */
     805  if (!MLEgetlen(h))                    /* nothing to save; forget it */
    865806    return TRUE;
    866807
    867   MLEsetwrap(h, FALSE);         // Need wrap off to export MLFIE_NOTRANS
    868 
    869   if(striptraillines) {
     808  MLEsetwrap(h, FALSE);                 // Need wrap off to export MLFIE_NOTRANS
     809
     810  if (striptraillines) {
    870811
    871812    register LONG x;
    872     LONG          numlines;
     813    LONG numlines;
    873814
    874815    numlines = MLEnumlines(h);
    875     for(x = numlines;x;x--) {
    876       if(MLElinelen(h,x - 1L) < 2)
    877         MLEdeleteline(h,x - 1L);
     816    for (x = numlines; x; x--) {
     817      if (MLElinelen(h, x - 1L) < 2)
     818        MLEdeleteline(h, x - 1L);
    878819      else
    879         break;
    880     }
    881     if(!MLEgetlen(h))
    882     {
     820        break;
     821    }
     822    if (!MLEgetlen(h)) {
    883823      /* nothing to save; forget it */
    884824      MLEsetwrap(h, fWrap);             // Restore
    … …  
    887827  }
    888828
    889   rc = DosAllocMem((PVOID)&buffer,4096L,
    890                    PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
     829  rc = DosAllocMem((PVOID) & buffer, 4096L,
     830                   PAG_COMMIT | OBJ_TILE | PAG_READ | PAG_WRITE);
    891831  if (rc || !buffer) {
    892     Dos_Error(MB_CANCEL,rc,h,pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
     832    Dos_Error(MB_CANCEL, rc, h, pszSrcFile, __LINE__,
     833              GetPString(IDS_OUTOFMEMORY));
    893834    ok = FALSE;
    894835  }
    895   else
    896   {
    897     fp = fopen(filename,"a+");
     836  else {
     837    fp = fopen(filename, "a+");
    898838    if (!fp)
    899       fp = xfopen(filename,"w",pszSrcFile,__LINE__);
     839      fp = xfopen(filename, "w", pszSrcFile, __LINE__);
    900840    if (!fp)
    901841      ok = FALSE;
    902842    else {
    903       LONG numlines,ret,len,wl,temp;
    904       IPT  s;
    905 
    906       fseek(fp,0L,SEEK_END);
     843      LONG numlines, ret, len, wl, temp;
     844      IPT s;
     845
     846      fseek(fp, 0L, SEEK_END);
    907847      numlines = MLEnumlines(h);
    908848
    909       WinSendMsg(h,MLM_SETIMPORTEXPORT,MPFROMP(buffer),
    910                  MPFROMLONG(4095L));
    911       for(temp = 0;temp < numlines;temp++) {
    912         s = MLEstartofline(h,temp);
    913         wl = len = (LONG)MLElinelenleft(h,s);
    914         ret = (LONG)WinSendMsg(h,MLM_EXPORT,MPFROMP(&s),
    915                                MPFROMP(&len));
    916         if(ret < 0)
    917           break;
    918         wl = min(wl,ret);
    919         buffer[wl] = 0;
    920         if(*buffer) {
    921           p = buffer + strlen(buffer) - 1;
    922           while(p >= buffer && (*p == '\n' || *p == '\r')) {
    923             *p = 0;
    924             p--;
    925           }
    926         }
    927         if(tabspaces) {
    928           p = buffer;
    929           while(*p) {
    930             if(*p == '\t') {
    931               *p = ' ';
    932               memmove((p + tabspaces) - 1,p,strlen(p) + 1);
    933               memset(p,' ',tabspaces);
    934             }
    935             p++;
    936           }
    937         }
    938         if(striptrailspaces && *buffer) {
    939           p = buffer + strlen(buffer) - 1;
    940           while(p >= buffer && (*p == ' ' || *p == '\t')) {
    941             *p = 0;
    942             p--;
    943           }
    944         }
    945         if(striptraillines) {
    946           if(!*buffer) {
    947             blanklines++;
    948             continue;
    949           }
    950           else {
    951             while(blanklines) {
    952               fwrite("\n",1,1,fp);
    953               blanklines--;
    954             }
    955           }
    956         }
    957         strcat(buffer,"\n");
    958         // buffer = translate_out(buffer,4095,h,filename);
    959         if(fwrite(buffer,1,strlen(buffer),fp) < 1) {
    960           saymsg(MB_ENTER,
    961                  h,
    962                  GetPString(IDS_ARGHTEXT),
    963                  GetPString(IDS_WRITEERRORTEXT));
    964           break;
    965         }
    966       } // for lines
    967     }
    968   }
    969 
    970   MLEsetwrap(h, fWrap);         // Restore
     849      WinSendMsg(h, MLM_SETIMPORTEXPORT, MPFROMP(buffer), MPFROMLONG(4095L));
     850      for (temp = 0; temp < numlines; temp++) {
     851        s = MLEstartofline(h, temp);
     852        wl = len = (LONG) MLElinelenleft(h, s);
     853        ret = (LONG) WinSendMsg(h, MLM_EXPORT, MPFROMP(&s), MPFROMP(&len));
     854        if (ret < 0)
     855          break;
     856        wl = min(wl, ret);
     857        buffer[wl] = 0;
     858        if (*buffer) {
     859          p = buffer + strlen(buffer) - 1;
     860          while (p >= buffer && (*p == '\n' || *p == '\r')) {
     861            *p = 0;
     862            p--;
     863          }
     864        }
     865        if (tabspaces) {
     866          p = buffer;
     867          while (*p) {
     868            if (*p == '\t') {
     869              *p = ' ';
     870              memmove((p + tabspaces) - 1, p, strlen(p) + 1);
     871              memset(p, ' ', tabspaces);
     872            }
     873            p++;
     874          }
     875        }
     876        if (striptrailspaces && *buffer) {
     877          p = buffer + strlen(buffer) - 1;
     878          while (p >= buffer && (*p == ' ' || *p == '\t')) {
     879            *p = 0;
     880            p--;
     881          }
     882        }
     883        if (striptraillines) {
     884          if (!*buffer) {
     885            blanklines++;
     886            continue;
     887          }
     888          else {
     889            while (blanklines) {
     890              fwrite("\n", 1, 1, fp);
     891              blanklines--;
     892            }
     893          }
     894        }
     895        strcat(buffer, "\n");
     896        // buffer = translate_out(buffer,4095,h,filename);
     897        if (fwrite(buffer, 1, strlen(buffer), fp) < 1) {
     898          saymsg(MB_ENTER,
     899                 h, GetPString(IDS_ARGHTEXT), GetPString(IDS_WRITEERRORTEXT));
     900          break;
     901        }
     902      }                                 // for lines
     903    }
     904  }
     905
     906  MLEsetwrap(h, fWrap);                 // Restore
    971907
    972908  if (fp)
    … …  
    978914}
    979915
    980 
    981916#pragma alloc_text(FMMLE3,MLEfindfirst,MLEfindnext,SandRDlgProc)
    982917
    983 MRESULT EXPENTRY SandRDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     918MRESULT EXPENTRY SandRDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    984919{
    985920  /* initiate search(/replace)s in edit mode */
    … …  
    987922  SRCHPTR *vw;
    988923
    989   if(msg != WM_INITDLG)
    990     vw = (SRCHPTR *)WinQueryWindowPtr(hwnd,0);
     924  if (msg != WM_INITDLG)
     925    vw = (SRCHPTR *) WinQueryWindowPtr(hwnd, 0);
    991926  else
    992927    vw = NULL;
    993928
    994   switch(msg) {
    995     case WM_INITDLG:
    996       vw = (SRCHPTR *)mp2;
    997       if(!vw) {
    998         WinDismissDlg(hwnd,0);
    999         break;
     929  switch (msg) {
     930  case WM_INITDLG:
     931    vw = (SRCHPTR *) mp2;
     932    if (!vw) {
     933      WinDismissDlg(hwnd, 0);
     934      break;
     935    }
     936    WinSetWindowPtr(hwnd, 0, (PVOID) mp2);
     937    WinSendDlgItemMsg(hwnd, SRCH_SEARCH, EM_SETTEXTLIMIT,
     938                      MPFROM2SHORT(256, 0), MPVOID);
     939    WinSendDlgItemMsg(hwnd, SRCH_REPLACE, EM_SETTEXTLIMIT,
     940                      MPFROM2SHORT(256, 0), MPVOID);
     941    if (*vw->search)
     942      WinSetDlgItemText(hwnd, SRCH_SEARCH, vw->search);
     943    if (!MLEgetreadonly(vw->hwndmle)) {
     944      if (*vw->replace)
     945        WinSetDlgItemText(hwnd, SRCH_REPLACE, vw->replace);
     946      WinSendDlgItemMsg(hwnd, SRCH_SANDR, BM_SETCHECK,
     947                        MPFROM2SHORT(vw->sandr, 0), MPVOID);
     948      WinSendDlgItemMsg(hwnd, SRCH_RALL, BM_SETCHECK,
     949                        MPFROM2SHORT(vw->rall, 0), MPVOID);
     950    }
     951    else {
     952      WinEnableWindow(WinWindowFromID(hwnd, SRCH_SANDR), FALSE);
     953      WinEnableWindow(WinWindowFromID(hwnd, SRCH_RALL), FALSE);
     954      WinEnableWindow(WinWindowFromID(hwnd, SRCH_REPLACE), FALSE);
     955      WinShowWindow(WinWindowFromID(hwnd, SRCH_REPLACE), FALSE);
     956      *vw->replace = 0;
     957      vw->sandr = FALSE;
     958      vw->rall = FALSE;
     959    }
     960    memset(&vw->se, 0, sizeof(MLE_SEARCHDATA));
     961    vw->se.cb = sizeof(MLE_SEARCHDATA);
     962    vw->se.pchFind = (PCHAR) vw->search;
     963    vw->se.cchFind = (SHORT) strlen(vw->search);
     964    vw->se.pchReplace = (PCHAR) vw->replace;
     965    vw->se.cchReplace = (SHORT) strlen(vw->replace);
     966    vw->se.iptStart = MLEcurpos(vw->hwndmle);
     967    vw->se.iptStop = -1L;
     968    vw->se.cchFound = 0;
     969    PosOverOkay(hwnd);
     970    break;
     971
     972  case WM_CONTROL:
     973    return 0;
     974
     975  case WM_COMMAND:
     976    switch (SHORT1FROMMP(mp1)) {
     977    case IDM_HELP:
     978      saymsg(MB_ENTER | MB_ICONASTERISK,
     979             hwnd,
     980             NullStr,
     981             GetPString(IDS_ENTERSEARCHSTRINGTEXT),
     982             (MLEgetreadonly(vw->hwndmle)) ?
     983             "." : GetPString(IDS_REPLACESTRINGTEXT));
     984      break;
     985
     986    case DID_CANCEL:
     987      WinDismissDlg(hwnd, 0);
     988      break;
     989
     990    case DID_OK:
     991      WinShowWindow(hwnd, FALSE);
     992      {
     993        CHAR temp[257];
     994        APIRET ret;
     995
     996        if ((USHORT) WinSendDlgItemMsg(hwnd, SRCH_SANDR, BM_QUERYCHECK,
     997                                       MPVOID, MPVOID))
     998          vw->sandr = TRUE;
     999        else
     1000          vw->sandr = FALSE;
     1001        if ((USHORT) WinSendDlgItemMsg(hwnd, SRCH_RALL, BM_QUERYCHECK,
     1002                                       MPVOID, MPVOID))
     1003          vw->rall = TRUE;
     1004        else
     1005          vw->rall = FALSE;
     1006        *vw->replace = 0;
     1007        WinQueryDlgItemText(hwnd, SRCH_REPLACE, 256, vw->replace);
     1008        vw->se.cchReplace = (SHORT) strlen(vw->replace);
     1009        WinQueryDlgItemText(hwnd, SRCH_SEARCH, 256, temp);
     1010        if (*temp) {
     1011          strcpy(vw->search, temp);
     1012          vw->se.cchFind = (SHORT) strlen(vw->search);
     1013          if (!WinSendMsg(vw->hwndmle, MLM_SEARCH,
     1014                          MPFROMLONG(MLFSEARCH_SELECTMATCH |
     1015                                     (MLFSEARCH_CASESENSITIVE *
     1016                                      (vw->fInsensitive ==
     1017                                       FALSE)) | (MLFSEARCH_CHANGEALL *
     1018                                                  (vw->rall != 0))),
     1019                          MPFROMP(&vw->se))) {
     1020            saymsg(MB_ENTER | MB_ICONASTERISK, hwnd, NullStr,
     1021                   GetPString(IDS_STRINGNOTFOUNDTEXT), vw->search);
     1022            WinDismissDlg(hwnd, 0);
     1023            break;
     1024          }
     1025          else if (vw->sandr && !vw->rall) {
     1026            ret = saymsg(MB_YESNOCANCEL,
     1027                         hwnd,
     1028                         NullStr,
     1029                         GetPString(IDS_CONFIRMREPLACETEXT), vw->replace);
     1030            if (ret == MBID_YES)
     1031              MLEinsert(vw->hwndmle, vw->replace);
     1032            else if (ret == MBID_CANCEL) {
     1033              WinDismissDlg(hwnd, 0);
     1034              break;
     1035            }
     1036            WinDismissDlg(hwnd, 1);
     1037            break;
     1038          }
     1039        }
     1040        WinDismissDlg(hwnd, 0);
    10001041      }
    1001       WinSetWindowPtr(hwnd,0,(PVOID)mp2);
    1002       WinSendDlgItemMsg(hwnd,SRCH_SEARCH,EM_SETTEXTLIMIT,
    1003                         MPFROM2SHORT(256,0),MPVOID);
    1004       WinSendDlgItemMsg(hwnd,SRCH_REPLACE,EM_SETTEXTLIMIT,
    1005                         MPFROM2SHORT(256,0),MPVOID);
    1006       if(*vw->search)
    1007         WinSetDlgItemText(hwnd,SRCH_SEARCH,vw->search);
    1008       if(!MLEgetreadonly(vw->hwndmle)) {
    1009         if(*vw->replace)
    1010           WinSetDlgItemText(hwnd,SRCH_REPLACE,vw->replace);
    1011         WinSendDlgItemMsg(hwnd,SRCH_SANDR,BM_SETCHECK,
    1012                           MPFROM2SHORT(vw->sandr,0),MPVOID);
    1013         WinSendDlgItemMsg(hwnd,SRCH_RALL,BM_SETCHECK,
    1014                           MPFROM2SHORT(vw->rall,0),MPVOID);
    1015       }
    1016       else {
    1017         WinEnableWindow(WinWindowFromID(hwnd,SRCH_SANDR),FALSE);
    1018         WinEnableWindow(WinWindowFromID(hwnd,SRCH_RALL),FALSE);
    1019         WinEnableWindow(WinWindowFromID(hwnd,SRCH_REPLACE),FALSE);
    1020         WinShowWindow(WinWindowFromID(hwnd,SRCH_REPLACE),FALSE);
    1021         *vw->replace = 0;
    1022         vw->sandr = FALSE;
    1023         vw->rall = FALSE;
    1024       }
    1025       memset(&vw->se,0,sizeof(MLE_SEARCHDATA));
    1026       vw->se.cb = sizeof(MLE_SEARCHDATA);
    1027       vw->se.pchFind = (PCHAR)vw->search;
    1028       vw->se.cchFind = (SHORT)strlen(vw->search);
    1029       vw->se.pchReplace = (PCHAR)vw->replace;
    1030       vw->se.cchReplace = (SHORT)strlen(vw->replace);
    1031       vw->se.iptStart = MLEcurpos(vw->hwndmle);
    1032       vw->se.iptStop = -1L;
    1033       vw->se.cchFound = 0;
    1034       PosOverOkay(hwnd);
    10351042      break;
    1036 
    1037     case WM_CONTROL:
    1038       return 0;
    1039 
    1040     case WM_COMMAND:
    1041       switch(SHORT1FROMMP(mp1)) {
    1042         case IDM_HELP:
    1043           saymsg(MB_ENTER | MB_ICONASTERISK,
    1044                  hwnd,
    1045                  NullStr,
    1046                  GetPString(IDS_ENTERSEARCHSTRINGTEXT),
    1047                  (MLEgetreadonly(vw->hwndmle)) ?
    1048                  "." : GetPString(IDS_REPLACESTRINGTEXT));
    1049           break;
    1050 
    1051         case DID_CANCEL:
    1052           WinDismissDlg(hwnd,0);
    1053           break;
    1054 
    1055         case DID_OK:
    1056           WinShowWindow(hwnd,FALSE);
    1057           {
    1058             CHAR   temp[257];
    1059             APIRET ret;
    1060 
    1061             if((USHORT)WinSendDlgItemMsg(hwnd,SRCH_SANDR,BM_QUERYCHECK,
    1062                                          MPVOID,MPVOID))
    1063               vw->sandr = TRUE;
    1064             else
    1065               vw->sandr = FALSE;
    1066             if((USHORT)WinSendDlgItemMsg(hwnd,SRCH_RALL,BM_QUERYCHECK,
    1067                                          MPVOID,MPVOID))
    1068               vw->rall = TRUE;
    1069             else
    1070               vw->rall = FALSE;
    1071             *vw->replace = 0;
    1072             WinQueryDlgItemText(hwnd,SRCH_REPLACE,256,vw->replace);
    1073             vw->se.cchReplace = (SHORT)strlen(vw->replace);
    1074             WinQueryDlgItemText(hwnd,SRCH_SEARCH,256,temp);
    1075             if(*temp) {
    1076               strcpy(vw->search,temp);
    1077               vw->se.cchFind = (SHORT)strlen(vw->search);
    1078               if(!WinSendMsg(vw->hwndmle,MLM_SEARCH,
    1079                             MPFROMLONG(MLFSEARCH_SELECTMATCH |
    1080                             (MLFSEARCH_CASESENSITIVE * (vw->fInsensitive == FALSE)) |
    1081                             (MLFSEARCH_CHANGEALL * (vw->rall != 0))),
    1082                             MPFROMP(&vw->se))) {
    1083                 saymsg(MB_ENTER | MB_ICONASTERISK,
    1084                        hwnd,
    1085                        NullStr,
    1086                        GetPString(IDS_STRINGNOTFOUNDTEXT),
    1087                        vw->search);
    1088                 WinDismissDlg(hwnd,0);
    1089                 break;
    1090               }
    1091               else if(vw->sandr && !vw->rall) {
    1092                 ret = saymsg(MB_YESNOCANCEL,
    1093                              hwnd,
    1094                              NullStr,
    1095                              GetPString(IDS_CONFIRMREPLACETEXT),
    1096                              vw->replace);
    1097                 if(ret == MBID_YES)
    1098                   MLEinsert(vw->hwndmle,vw->replace);
    1099                 else if(ret == MBID_CANCEL) {
    1100                   WinDismissDlg(hwnd,0);
    1101                   break;
    1102                 }
    1103                 WinDismissDlg(hwnd,1);
    1104                 break;
    1105               }
    1106             }
    1107             WinDismissDlg(hwnd,0);
    1108           }
    1109           break;
    1110       }
    1111       return 0;
    1112 
    1113     case WM_CLOSE:
    1114       break;
    1115   }
    1116 
    1117   return WinDefDlgProc(hwnd,msg,mp1,mp2);
    1118 }
    1119 
    1120 
    1121 BOOL MLEfindfirst (HWND hwnd,SRCHPTR *vw)
    1122 {
    1123   if(MLEsizeofsel(vw->hwndmle) < 256L) {
    1124     MLEgetseltext(vw->hwndmle,vw->search);
     1043    }
     1044    return 0;
     1045
     1046  case WM_CLOSE:
     1047    break;
     1048  }
     1049
     1050  return WinDefDlgProc(hwnd, msg, mp1, mp2);
     1051}
     1052
     1053BOOL MLEfindfirst(HWND hwnd, SRCHPTR * vw)
     1054{
     1055  if (MLEsizeofsel(vw->hwndmle) < 256L) {
     1056    MLEgetseltext(vw->hwndmle, vw->search);
    11251057    vw->search[255] = 0;
    11261058  }
    1127   if(WinDlgBox(HWND_DESKTOP,hwnd,SandRDlgProc,FM3ModHandle,
    1128                SRCH_FRAME,MPFROMP(vw)) && *vw->search)
     1059  if (WinDlgBox(HWND_DESKTOP, hwnd, SandRDlgProc, FM3ModHandle,
     1060                SRCH_FRAME, MPFROMP(vw)) && *vw->search)
    11291061    return TRUE;
    11301062  return FALSE;
    11311063}
    11321064
    1133 
    1134 INT MLEfindnext (HWND hwnd,SRCHPTR *vw)
    1135 {
    1136   if(!*vw->search)
     1065INT MLEfindnext(HWND hwnd, SRCHPTR * vw)
     1066{
     1067  if (!*vw->search)
    11371068    return -1;
    11381069  else {
    11391070    vw->se.iptStart++;
    1140     if(!WinSendMsg(vw->hwndmle,MLM_SEARCH,
    1141                   MPFROMLONG(MLFSEARCH_SELECTMATCH |
    1142                   (MLFSEARCH_CASESENSITIVE * (vw->fInsensitive == FALSE)) |
    1143                   (MLFSEARCH_CHANGEALL * (vw->rall))),
    1144                   MPFROMP(&vw->se)))
    1145       saymsg(MB_ENTER | MB_ICONASTERISK,
    1146              hwnd,
    1147              NullStr,
    1148              GetPString(IDS_STRINGNOTFOUNDTEXT),
    1149              vw->search);
    1150     else if(vw->sandr && !vw->rall) {
     1071    if (!WinSendMsg(vw->hwndmle, MLM_SEARCH,
     1072                    MPFROMLONG(MLFSEARCH_SELECTMATCH |
     1073                               (MLFSEARCH_CASESENSITIVE *
     1074                                (vw->fInsensitive ==
     1075                                 FALSE)) | (MLFSEARCH_CHANGEALL *
     1076                                            (vw->rall))), MPFROMP(&vw->se)))
     1077      saymsg(MB_ENTER | MB_ICONASTERISK, hwnd, NullStr,
     1078             GetPString(IDS_STRINGNOTFOUNDTEXT), vw->search);
     1079    else if (vw->sandr && !vw->rall) {
    11511080
    11521081      APIRET ret;
    11531082
    11541083      ret = saymsg(MB_YESNOCANCEL,
    1155                    hwnd,
    1156                    NullStr,
    1157                    GetPString(IDS_CONFIRMREPLACETEXT),
    1158                    vw->replace);
    1159       if(ret == MBID_YES)
    1160         MLEinsert(vw->hwndmle,vw->replace);
    1161       if(ret != MBID_CANCEL)
    1162         return 1;
     1084                   hwnd,
     1085                   NullStr, GetPString(IDS_CONFIRMREPLACETEXT), vw->replace);
     1086      if (ret == MBID_YES)
     1087        MLEinsert(vw->hwndmle, vw->replace);
     1088      if (ret != MBID_CANCEL)
     1089        return 1;
    11631090    }
    11641091  }
Note: See TracChangeset for help on using the changeset viewer.