home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / stg_v4.lzh / edt.c < prev    next >
C/C++ Source or Header  |  1994-11-11  |  14KB  |  732 lines
  1. /*
  2.  * 89/??/?? StG original concept and specs for DB9 format
  3.  * 90/09/?? StG coding began
  4.  * 91/05/27 StG updated to new naming conventions, fixed bugs
  5.  * 91/07/28 StG cleanup
  6.  *
  7.  * _Dsp(psFld,pcDat) - display field
  8.  * _Edt(psFld,pcDat) - edit field
  9.  *
  10.  * psFld - field structure to control edit/display
  11.  * pcDat - pointer to data to edit (offset 
  12.  *
  13.  * psFld->acFld_Mask - mask for display/edit of data
  14.  *   '_' - char from data (# of these is data len)
  15.  *       - all other chars are displayed as is
  16.  * psFld->acFld_Opt - option codes (defined in db9.h)
  17.  *
  18.  * psFld->oFld_Pos - offset from dat
  19.  * psFld->oFld_Len - number of bytes
  20.  *
  21.  * returns:
  22.  *  0 - ESC, changes aborted 
  23.  *  otherwise key pressed is returned
  24.  *  
  25. */
  26.  
  27. #define ERR (-1)
  28.  
  29. #include "db9.h"
  30. #include "key.h"
  31.  
  32. extern int errno;
  33.  
  34. #define EDTMAX 256
  35.  
  36. int _edtcsr=-1;  /* cursor position in data */
  37. int _edtchg=0;  /* field changed flag */
  38. int _dspflg=0;
  39.  
  40. char _edtchr[128];    /* accepted chars */
  41.  
  42. char _edtbuf[EDTMAX];
  43. char _dspbuf[EDTMAX];
  44.  
  45. char *_pcBS=0;
  46. char *_pcSPC=0;
  47.  
  48. char *malloc();
  49.  
  50. void
  51. _InitBSPC()
  52. {
  53.     _pcBS=malloc(EDTMAX+1);
  54.     if (!_pcBS)
  55.         exit(errno);
  56.  
  57.     _pcSPC=malloc(EDTMAX+1);
  58.     if (!_pcSPC)
  59.         exit(errno);
  60.  
  61.     MSET(_pcBS,8,EDTMAX);
  62.     *(_pcBS+EDTMAX)=0;
  63.     MSET(_pcSPC,32,EDTMAX);
  64.     *(_pcSPC+EDTMAX)=0;
  65. }
  66.  
  67. /* display data at ptr, leave cursor at byte csr */
  68. _DispDriver(pcData,iToCursor)
  69. char *pcData;
  70. int iToCursor;
  71. {
  72.     static char acDispBuf[EDTMAX];
  73.     static int iCursor;
  74.     char *pcDispBuf;
  75.     int iTemp;
  76.  
  77.     /* preset backspace and space pattern buffers */
  78.     if (!_pcBS) _InitBSPC();
  79.  
  80.     /* if called with 0 pcData, reset buffer for new data */
  81.     if (!pcData)
  82.     {
  83.         MSET(acDispBuf,0,EDTMAX);
  84.         iCursor=0;
  85.         return(0);
  86.     }
  87.  
  88.     pcDispBuf=acDispBuf;
  89. dspagn:
  90.     /* find first char that doesn't match */
  91.     while (*pcDispBuf && *pcDispBuf==*pcData)
  92.     {
  93.         pcDispBuf++;
  94.         pcData++;
  95.     }
  96.  
  97.     /* if strings match, must both be null */
  98.     if (*pcDispBuf==*pcData) goto dspdun;
  99.  
  100.     /* move cursor to first difference (pcDispBuf) */
  101.     iTemp=(pcDispBuf-acDispBuf)-iCursor;
  102.     if (iTemp<0) write(1,_pcBS,-iTemp);
  103.     if (iTemp>0) write(1,acDispBuf+iCursor,iTemp);
  104.     iCursor+=iTemp;
  105.  
  106.     /* count number of bytes being changed */
  107.     iTemp=0;
  108.     while (*pcData && *pcDispBuf!=*pcData)
  109.     {
  110.         *pcDispBuf++=*pcData++;
  111.         iTemp++;
  112.     }
  113.     if (!*pcData) *pcDispBuf=0;
  114.     /* and write them out */
  115.     if (iTemp)
  116.     {
  117.         write(1,pcDispBuf-iTemp,iTemp);
  118.         iCursor+=iTemp;
  119.         /* go through loop again to find any more */
  120.         goto dspagn;
  121.     }
  122.  
  123.     /* end of supplied string, clear rest of display */
  124.     if (*pcData) exit(1);
  125.     iTemp=0;
  126.     while (*pcDispBuf)
  127.     {
  128.         *pcDispBuf++=0;
  129.         iTemp++;
  130.     }
  131.     write(1,_pcSPC,iTemp);
  132.     write(1,_pcBS,iTemp);
  133.  
  134. dspdun:
  135.     /* move cursor to iToCursor */
  136.     iTemp=iToCursor-iCursor;
  137.     if (iTemp<0) write(1,_pcBS,-iTemp);
  138.     if (iTemp>0) write(1,acDispBuf+iCursor,iTemp);
  139.     iCursor=iToCursor;
  140.     return(0);
  141. }
  142.  
  143. #define AcceptChars(fm,to,ok) {int x=fm;while (x<=to) _edtchr[x++]=ok;}
  144.  
  145. _Dsp(psFld,pcDat)
  146. struct sFld_Block *psFld;
  147. char *pcDat;
  148. {    
  149.     _DispDriver(0,0);
  150.     _dspflg=1;
  151.     _edtcsr=-1;
  152.     return(_Edt(psFld,pcDat));
  153. }
  154.  
  155. _Edt(psFld,pcDat)
  156. struct sFld_Block *psFld;
  157. char *pcDat;
  158. {
  159.     char cKey,*pcTemp1,*pcTemp2,*pcTemp3;
  160.     int iTemp1,iTemp2;
  161.     O oTemp;
  162.     L lTemp;
  163.  
  164.     char cEdtNoNull;    /* null field okay */
  165.     char cEdtCaps;    /* 0=normal, 1=Caps, 2=CAPS */
  166.     char cEdtRight;    /* right justify */
  167.  
  168.     int _edtoff=0;  /* display offset from _dspbuf */
  169.     int _edtpos,_dspoff,_edtlen,_dspcsr;
  170.  
  171.     int _dsplen;    /* display length */
  172.  
  173.     /* if no ptrs reset */
  174.     if (!psFld || !pcDat)
  175.     {
  176.         _edtcsr=-1;                /* StG 92/12/04 */
  177.         _edtoff=0;
  178.         _DispDriver(0,0);
  179. #ifdef _UNIX
  180.         _Eko(0);
  181. #endif
  182.         return(0);
  183.     }
  184.  
  185. #ifdef _UNIX
  186.         _Eko(1);
  187. #endif
  188.  
  189.     pcDat+=psFld->oFld_Pos;
  190.  
  191.     if (psFld->oFld_Len>EDTMAX)
  192.     {
  193.         errno=DE_EDTLEN;
  194.         return(ERR);
  195.     }
  196.     cKey=0;
  197.  
  198.     /* count number of _'s */
  199.     _dsplen=0;
  200.     pcTemp1=psFld->acFld_Mask;
  201.     while (*pcTemp1)
  202.         if (*pcTemp1++=='_')
  203.             _dsplen++;
  204.  
  205.     /* clear table and flags */
  206.     AcceptChars(0,127,0);
  207.     cEdtNoNull=cEdtCaps=cEdtRight=0;
  208.  
  209.     pcTemp1=psFld->acFld_Opts;
  210.     if (!*pcTemp1) switch(psFld->cFld_Type)
  211.     {
  212.         case FT_SINT : pcTemp1="rn-"; break;
  213.         case FT_UINT : pcTemp1="rn"; break;
  214.         case FT_HEX  : pcTemp1="rxu"; break;
  215.         case FT_DATE : pcTemp1="rn"; break;
  216.         case FT_INET : pcTemp1="n"; break;
  217.         case FT_ASCII:
  218.         default: pcTemp1="*"; break;
  219.     }
  220.     while (*pcTemp1) switch(*pcTemp1++)
  221.     {
  222.         case FO_ALL  : AcceptChars(32,126,1); break;
  223.         case FO_ALPHA: AcceptChars('A','Z',1); AcceptChars('a','z',1); break;
  224.         case FO_SPACE: _edtchr[' ']=1; break;
  225.         case FO_HEX  : AcceptChars('A','F',1);
  226.         case FO_NUM  : AcceptChars('0','9',1); break;
  227.         case FO_DOT  : _edtchr['.']=1; break;
  228.         case FO_DASH : _edtchr['-']=1; break;
  229.         case FO_PUNCT: /* *-a-b-n */ break;
  230.         case FO_EXCLM: AcceptChars('!','!',1); break;
  231.  
  232.         case FO_ACCPT:
  233.             while (*pcTemp1 && *pcTemp1!='!') _edtchr[*pcTemp1++]=1;
  234.         case FO_EXCPT:
  235.             while (*pcTemp1) _edtchr[*pcTemp1++]=1;
  236.             break;
  237.  
  238.         case FO_UPPER: cEdtCaps=2; break;
  239.         case FO_CAP1 : cEdtCaps=1; break;
  240.         case FO_NULL : cEdtNoNull=1; break;
  241.         case FO_RIGHT: cEdtRight=1; break;
  242.         default: pcTemp1="";
  243.     }
  244.  
  245. /*     if (!_dspflg && _edtcsr<0) _edtcsr=0; */
  246.  
  247. edtagn:
  248.     /* based on storage type, copy dat to edtbuf */
  249.     switch (psFld->cFld_Type)
  250.     {
  251.     case FT_DATE:
  252.         iTemp1=psFld->oFld_Len;
  253.         pcTemp1=pcDat;
  254.         pcTemp2=_edtbuf;
  255.         while (iTemp1--)
  256.         {
  257.             iTemp2=*pcTemp1/10;
  258.             if (iTemp2>9)
  259.             {
  260.                 *pcTemp2++='*';
  261.                 *pcTemp2++='*';
  262.             }
  263.             else
  264.             {
  265.                 *pcTemp2++='0'+iTemp2;
  266.                 *pcTemp2++='0'+(*pcTemp1%10);
  267.             }
  268.             pcTemp1++;
  269.         }
  270.         *pcTemp2=0;
  271.         _edtlen=pcTemp2-_edtbuf;
  272.         break;
  273.  
  274.     case FT_INET:    /* internet address format */
  275.         iTemp1=psFld->oFld_Len;
  276.         pcTemp1=pcDat;
  277.         pcTemp2=_edtbuf;
  278.         while (iTemp1--)
  279.         {
  280.             iTemp2=(*pcTemp1&255)/100;
  281.             *pcTemp2++='0'+iTemp2;
  282.             *pcTemp2++='0'+((*pcTemp1&255)-iTemp2*100)/10;
  283.             *pcTemp2++='0'+((*pcTemp1&255)%10);
  284.             pcTemp1++;
  285.         }
  286.         *pcTemp2=0;
  287.         _edtlen=pcTemp2-_edtbuf;
  288.         break;
  289.  
  290.     case FT_HEX:
  291.         iTemp1=psFld->oFld_Len;
  292.         pcTemp1=pcDat;
  293.         pcTemp2=_edtbuf;
  294.         while (iTemp1--)
  295.         {
  296.             iTemp2=((*pcTemp1)>>4)&15;
  297.             if (iTemp2>9) iTemp2+=7;
  298.             *pcTemp2++='0'+iTemp2;
  299.  
  300.             iTemp2=(*pcTemp1++)&15;
  301.             if (iTemp2>9) iTemp2+=7;
  302.             *pcTemp2++='0'+iTemp2;
  303.         }
  304.         *pcTemp2=0;
  305.         _edtlen=pcTemp2-_edtbuf;
  306. /*        while (*_edtbuf=='0' && *(_edtbuf+1)) MCPY(_edtbuf,_edtbuf+1,psFld->oFld_Len); */
  307.         break;
  308.  
  309.     case FT_SINT:
  310.         iTemp1=psFld->oFld_Len;
  311.         if (iTemp1>4) iTemp1=4;
  312.  
  313.         pcTemp1=pcDat;
  314. #ifdef __MSDOS__
  315.         pcTemp1+=iTemp1;
  316. #endif
  317.         lTemp=0;
  318.         while (iTemp1--)
  319.         {
  320.             lTemp<<=8;
  321.             lTemp&=~255;
  322. #ifndef __MSDOS__
  323.             lTemp|=(*pcTemp1++)&255;
  324. #else
  325.             lTemp|=(*--pcTemp1)&255;
  326. #endif
  327.         }
  328.  
  329.  
  330.         switch (psFld->oFld_Len)
  331.         {
  332.         case 1: if (lTemp&0x000080) lTemp=(lTemp&0x00007F)-0x000080; break;
  333.         case 2: if (lTemp&0x008000) lTemp=(lTemp&0x007FFF)-0x008000; break;
  334.         case 3: if (lTemp&0x800000) lTemp=(lTemp&0x7FFFFF)-0x800000; break;
  335.         }
  336.  
  337.         oTemp=abs(lTemp);
  338.         if (oTemp<10)
  339.             _edtlen=1;
  340.         else if (oTemp<100)
  341.             _edtlen=2;
  342.         else if (oTemp<1000)
  343.             _edtlen=3;
  344.         else if (oTemp<10000)
  345.             _edtlen=4;
  346.         else if (oTemp<100000)
  347.             _edtlen=5;
  348.         else if (oTemp<1000000)
  349.             _edtlen=6;
  350.         else if (oTemp<10000000)
  351.             _edtlen=7;
  352.         else if (oTemp<100000000)
  353.             _edtlen=8;
  354.         else if (oTemp<1000000000)
  355.             _edtlen=9;
  356.         else
  357.             _edtlen=10;
  358.         if (lTemp<0)
  359.             _edtlen++;
  360.  
  361.         if (_edtlen>_dsplen)
  362.             _edtlen=_dsplen;
  363.  
  364.         pcTemp1=_edtbuf;
  365.         pcTemp1+=_edtlen;
  366.         *pcTemp1=0;
  367.         iTemp2=_edtlen;
  368.         while (iTemp2--)
  369.         {
  370.             *--pcTemp1='0'+(oTemp%10);
  371.             oTemp/=10;
  372.         }
  373.         if (lTemp<0)
  374.             *pcTemp1='-';
  375.         break;
  376.  
  377.     case FT_UINT:
  378.         iTemp1=psFld->oFld_Len;
  379.         if (iTemp1>4) iTemp1=4;
  380.  
  381.         _edtlen=10;
  382.         if (iTemp1==1) _edtlen=3;
  383.         if (iTemp1==2) _edtlen=5;
  384.         if (iTemp1==3) _edtlen=8;
  385.  
  386.         if (_edtlen>_dsplen)
  387.             _edtlen=_dsplen;
  388.  
  389.         pcTemp1=pcDat;
  390. #ifdef __MSDOS__
  391.         pcTemp1+=iTemp1;
  392. #endif
  393.         oTemp=0;
  394.         while (iTemp1--)
  395.         {
  396.             oTemp<<=8;
  397.             oTemp&=~255;
  398. #ifndef __MSDOS__
  399.             oTemp|=(*pcTemp1++)&255;
  400. #else
  401.             oTemp|=(*--pcTemp1)&255;
  402. #endif
  403.         }
  404.  
  405.         pcTemp1=_edtbuf;
  406.         pcTemp1+=_edtlen;
  407.         *pcTemp1=0;
  408.         iTemp2=_edtlen;
  409.         while (iTemp2--)
  410.         {
  411.             *--pcTemp1='0'+(oTemp%10);
  412.             oTemp/=10;
  413.         }
  414.         while (_edtbuf[0]=='0' && _edtbuf[1])
  415.             MCPY(_edtbuf,_edtbuf+1,_edtlen--);
  416.         break;
  417.  
  418.     default: /* assume FT_ASCII */
  419. /*        _edtlen=psFld->oFld_Len; */
  420.         MCPY(_edtbuf,pcDat,psFld->oFld_Len);
  421.         *(_edtbuf+psFld->oFld_Len)=0;
  422.         _edtlen=strlen(_edtbuf);
  423.     }
  424.     if (_edtlen>_dsplen)
  425.         _edtlen=_dsplen;
  426.  
  427.     _edtchg=0;
  428.     goto disnxt;
  429.  
  430. bell:
  431.     write(1,"\7",1);
  432.     goto edtnxt;
  433.  
  434. disnxt:
  435.  
  436.     if (cEdtRight)
  437.     {
  438.          if (!_dspflg && _edtcsr<0)
  439.              _edtcsr=_edtlen;
  440.         _dspoff=_dsplen-_edtlen;
  441.     }
  442.     else
  443.     {
  444.          if (!_dspflg && _edtcsr<0)
  445.          {
  446.              if (psFld->cFld_Type==FT_ASCII)
  447.                  _edtcsr=_edtlen;
  448.              else
  449.                  _edtcsr=0;
  450.          }
  451.  
  452.         _dspoff=0;
  453.     }
  454.  
  455.     /* copy edtbuf to dspbuf via msk */
  456.     _edtpos=_dspcsr=0;
  457.     pcTemp1=_edtbuf;
  458.     pcTemp2=psFld->acFld_Mask;
  459.     pcTemp3=_dspbuf;
  460.     while (*pcTemp2)
  461.     {
  462.         /* if mask is not _, copy it to display */
  463.         if (*pcTemp2!='_')
  464.         {
  465.             *pcTemp3++=*pcTemp2++;
  466.             continue;
  467.         }
  468.  
  469.         /* remember display position of cursor in edit buffer */
  470.         if (_edtcsr==_edtpos-_dspoff)
  471.             _dspcsr=(pcTemp3-_dspbuf);
  472.  
  473. /*        if (!*pcTemp1)*/
  474.         if (_edtpos<_dspoff || _edtpos>=_edtlen+_dspoff)
  475.             *pcTemp3++=(_dspflg?' ':'_');
  476.         else
  477.         {
  478.             if (*pcTemp1>126 || !_edtchr[*pcTemp1])
  479.             {
  480.                 *pcTemp3++='~';
  481.                 pcTemp1++;
  482.             }
  483.             else
  484.                 *pcTemp3++=*pcTemp1++;
  485.         }
  486.  
  487.         _edtpos++;
  488.         pcTemp2++;
  489.  
  490.         if (_edtcsr==_edtpos-_dspoff)
  491.             _dspcsr=(pcTemp3-_dspbuf);
  492.     }
  493.     *pcTemp1=0;
  494.     *pcTemp3=0;
  495.  
  496. /*    if (_edtlen!=_edtpos)
  497.         exit(1,writeln(2,"_Edt() bug: edtlen!=edtpos\n",80);
  498. */
  499.     if (_dspflg)
  500.         _dspcsr=0;
  501.  
  502.     if (_edtcsr>_edtlen)
  503.     {
  504.         _edtcsr=_edtlen;
  505.         goto disnxt;
  506.     }
  507.  
  508.     if (psFld->bFld_DispMax)
  509.     {
  510.         while (_dspcsr>_edtoff+psFld->bFld_DispMax)
  511.             _edtoff+=psFld->bFld_DispMax>>1;
  512.         while (_dspcsr<_edtoff)
  513.             _edtoff-=psFld->bFld_DispMax>>1;
  514.         if (_edtoff<0)
  515.             _edtoff=0;
  516.         *(_dspbuf+_edtoff+psFld->bFld_DispMax)=0;
  517.     }
  518.  
  519.     _DispDriver(_dspbuf+_edtoff,_dspcsr-_edtoff);
  520.     if (_dspflg)
  521.     {
  522.         _dspflg=0;
  523.         return(cKey);
  524.     }
  525.  
  526. edtnxt:
  527.     pcTemp1=_edtbuf+_edtcsr;
  528.  
  529.     cKey=_Key(1);
  530.  
  531.     if (cKey>=32 && cKey<=126)
  532.     {
  533.         if (_edtcsr==_dsplen)
  534.             goto bell;
  535.         if (cEdtCaps==2)
  536.             cKey=toupper(cKey);
  537.         if (!_edtchr[cKey])
  538.             goto bell;
  539.         MINS(pcTemp1+1,pcTemp1,_dsplen-_edtcsr-1);
  540.         if (_edtlen<_dsplen)
  541.             _edtlen++;
  542.         *pcTemp1=cKey;
  543.         _edtcsr++;
  544.         _edtchg=1;
  545.         goto disnxt;
  546.     }
  547.  
  548.     switch (cKey)
  549.     {
  550.     case KY_HOME:
  551.         _edtcsr=0;
  552.         goto disnxt;
  553.     case KY_LEFT:
  554.         if (!_edtcsr) goto bell;
  555.         _edtcsr--;
  556.         goto disnxt;
  557.     case KY_INS:
  558.         if (!_edtchr[' ']) goto bell;
  559.         MINS(pcTemp1+1,pcTemp1,_dsplen-_edtcsr-1);
  560.         if (_edtlen<_dsplen)
  561.             _edtlen++;
  562.         *pcTemp1=' ';
  563.         _edtchg=1;
  564.         goto disnxt;
  565.     case KY_DEL:
  566.         if (!_edtlen) goto bell;
  567. /*        if (!*pcTemp1 || _edtlen==_edtcsr) goto bell; */
  568.         MCPY(pcTemp1,pcTemp1+1,_dsplen-_edtcsr-1);
  569.         _edtbuf[--_edtlen]=0;
  570. /*        pcTemp1[_edtlen-_edtcsr-1]=0; */
  571.         _edtchg=1;
  572.         goto disnxt;
  573.     case KY_END:
  574.         if (_edtcsr==_edtlen) goto bell;
  575.         _edtcsr=_edtlen;
  576.         goto disnxt;
  577.     case KY_RIGHT:
  578.         if (_edtcsr==_edtlen) goto bell;
  579.         _edtcsr++;
  580.         goto disnxt;
  581.     case KY_BKSPC:
  582.         if (!_edtcsr) goto bell;
  583.         _edtcsr--;
  584.         pcTemp1--;
  585.         MCPY(pcTemp1,pcTemp1+1,_dsplen-_edtcsr-1);
  586.         _edtbuf[--_edtlen]=0;
  587. /*        pcTemp1[_edtlen-_edtcsr]=0; */
  588.         _edtchg=1;
  589.         goto disnxt;
  590.     case KY_KILL:
  591.         if (_edtlen==_edtcsr) goto bell;
  592.         _edtlen=_edtcsr;
  593.         _edtbuf[_edtlen]=0;
  594.         _edtchg=1;
  595.         goto disnxt;
  596.     }
  597.  
  598.     /* if esc and data changed, restart */
  599.     if (cKey==27 && _edtchg) goto edtagn;
  600.  
  601.     /* copy data back to dat */
  602.     switch(psFld->cFld_Type)
  603.     {
  604.     case FT_DATE:
  605.         pcTemp1=_edtbuf;
  606.         pcTemp2=pcDat;
  607.         iTemp1=_edtlen>>1;
  608.         while (iTemp1--)
  609.         {
  610.             if (*pcTemp1<'0' || *pcTemp1>'9' || *(pcTemp1+1)<'0' || *(pcTemp1+1)>'9')
  611.             {
  612.                 *pcTemp2++=-1;
  613.                 pcTemp1+=2;
  614.                 continue;
  615.             }
  616.             iTemp2=(*pcTemp1++)-'0';
  617.             iTemp2*=10;
  618.             iTemp2+=(*pcTemp1++)-'0';
  619.             *pcTemp2++=iTemp2;
  620.         }
  621.         break;
  622.  
  623.     case FT_INET:
  624.         pcTemp1=_edtbuf;
  625.         pcTemp2=pcDat;
  626.         iTemp1=_edtlen/3;
  627.         while (iTemp1--)
  628.         {
  629.             iTemp2=(*pcTemp1++)-'0';
  630.             iTemp2*=10;
  631.             iTemp2+=(*pcTemp1++)-'0';
  632.             iTemp2*=10;
  633.             iTemp2+=(*pcTemp1++)-'0';
  634.             *pcTemp2++=iTemp2;
  635.         }
  636.         break;
  637.  
  638.     case FT_HEX:
  639.         pcTemp1=_edtbuf;
  640.         while (*pcTemp1) pcTemp1++;
  641.         pcTemp2=pcDat;
  642.         iTemp1=_edtlen>>1;
  643.         if (iTemp1>psFld->oFld_Len) iTemp1=psFld->oFld_Len;
  644.         while (iTemp1--) *pcTemp2++=0;
  645.         iTemp1=_edtlen>>1;
  646.         if (iTemp1>psFld->oFld_Len) iTemp1=psFld->oFld_Len;
  647.         while (iTemp1--)
  648.         {
  649.             pcTemp2--;
  650.  
  651.             if (!*--pcTemp1) break;
  652.             iTemp2=*pcTemp1-'0';
  653.             if (iTemp2>9) iTemp2-=7;
  654.             *pcTemp2|=iTemp2&15;
  655.  
  656.             if (!*--pcTemp1) break;
  657.             iTemp2=*pcTemp1-'0';
  658.             if (iTemp2>9) iTemp2-=7;
  659.             *pcTemp2|=(iTemp2&15)<<4;
  660.         }
  661.         break;
  662.  
  663.     case FT_SINT:
  664.         pcTemp1=_edtbuf;
  665.         lTemp=0;
  666.         if (*pcTemp1=='-')
  667.             pcTemp1++;
  668.         while (*pcTemp1)
  669.         {
  670.             lTemp*=10;
  671.             lTemp+=(*pcTemp1++)-'0';
  672.         }
  673.  
  674.         iTemp1=psFld->oFld_Len;
  675.         if (iTemp1>4) iTemp1=4;
  676.  
  677.         if (*_edtbuf=='-')
  678.             lTemp=~lTemp+1;
  679.  
  680.         pcTemp1=pcDat;
  681. #ifndef __MSDOS__
  682.         pcTemp1+=iTemp1;
  683. #endif
  684.         while (iTemp1--)
  685.         {
  686. #ifdef __MSDOS__
  687.             *pcTemp1++=lTemp&255;
  688. #else
  689.             *--pcTemp1=lTemp&255;
  690. #endif
  691.             lTemp>>=8;
  692.         }
  693.  
  694.         break;
  695.  
  696.     case FT_UINT:
  697.         pcTemp1=_edtbuf;
  698.         oTemp=0;
  699.         while (*pcTemp1)
  700.         {
  701.             oTemp*=10;
  702.             oTemp+=(*pcTemp1++)-'0';
  703.         }
  704.  
  705.         iTemp1=psFld->oFld_Len;
  706.         if (iTemp1>4) iTemp1=4;
  707.  
  708.         pcTemp1=pcDat;
  709. #ifndef __MSDOS__
  710.         pcTemp1+=iTemp1;
  711. #endif
  712.         while (iTemp1--)
  713.         {
  714. #ifdef __MSDOS__
  715.             *pcTemp1++=oTemp&255;
  716. #else
  717.             *--pcTemp1=oTemp&255;
  718. #endif
  719.             oTemp>>=8;
  720.         }
  721.  
  722.         break;
  723.  
  724.     default:  /* assume FT_ASCII */
  725.         MSET(_edtbuf+_edtlen,0,psFld->oFld_Len-_edtlen);
  726.         MCPY(pcDat,_edtbuf,psFld->oFld_Len);
  727.     }
  728.  
  729.     _dspflg=1;  /* cause _Edt() to return(cKey) after redisplay */
  730.     goto disnxt;
  731. }
  732.