home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / dos_txl / source / neuutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-01-30  |  28.9 KB  |  1,396 lines
  1.  
  2. #include <dos.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <conio.h>
  6. #include <process.h>
  7. #include <stdlib.h>
  8. #include "interp.h"
  9.  
  10. #define  F1          9059
  11. #define  F2          9060
  12. #define  F3          9061
  13. #define  F4          9062
  14. #define  F5          9063
  15. #define  F6          9064
  16. #define  F7          9065
  17. #define  F8          9066
  18. #define  F9          9067
  19. #define  F10         9068
  20.  
  21.  
  22. /*            Crtl          */
  23.  
  24. #define  SF1         9084
  25. #define  SF2         9085
  26. #define  SF3         9086
  27. #define  SF4         9087
  28. #define  SF5         9088
  29. #define  SF6         9089
  30. #define  SF7         9090
  31. #define  SF8         9091
  32. #define  SF9         9092
  33. #define  SF10        9093
  34. #define  CF1         9094
  35. #define  CF2         9095
  36. #define  CF3         9096
  37. #define  CF4         9097
  38. #define  CF5         9098
  39. #define  CF6         9099
  40. #define  CF7         9100
  41. #define  CF8         9101
  42. #define  CF9         9102
  43. #define  CF10        9103
  44.  
  45.  
  46. /*                ALT              */
  47.  
  48. #define  AF1         9104
  49. #define  AF2         9105
  50. #define  AF3         9106
  51. #define  AF4         9107
  52. #define  AF5         9108
  53. #define  AF6         9109
  54. #define  AF7         9110
  55. #define  AF8         9111
  56. #define  AF9         9112
  57. #define  AF10        9113
  58.  
  59.  
  60. #define  ESC         9027
  61. #define  BKSP        9008
  62. #define  ENTER       9013
  63. #define  CENTER      9010
  64. #define  TAB         9009
  65. #define  STAB        9015
  66. #define  INS         9082
  67. #define  DEL         9083
  68. #define  HOME        9071
  69. #define  END         9079
  70. #define  PGUP        9073
  71. #define  PGDN        9081
  72.  
  73.  
  74. /*         Cursortasten        */
  75.  
  76. #define  CRUP        9072
  77. #define  CRDN        9080
  78. #define  CRLI        9075
  79. #define  CRRE        9077
  80.  
  81.  
  82. /*        Ctrl Cursor          */
  83.  
  84. #define  CCRLI       9115
  85. #define  CCRRE       9116
  86.  
  87.  
  88. #define PERI 0x11
  89. #define V_IO 0x10
  90. #define zeichen9 "1234567890.-"
  91. #define zeichenD "1234567890"
  92.  
  93. void cls(void);
  94. void clrline(int zeile);
  95. unsigned int scr_adr(void);
  96. void zeig(unsigned int z,unsigned int s,unsigned char *txt);
  97. void zeigz(unsigned int z,unsigned int s, char zeichen);
  98. void set_color(int v,int h);
  99. void set_attr(int o,int ol,int u,int ur,int v,int h);
  100. void savescreen(int o,int ol,int u,int ur,unsigned char *tab);
  101. void restscreen(int o,int ol,int u,int ur,unsigned char *tab);
  102. void warte(void);
  103. int box(int o, int ol, int u, int ur,unsigned char *zeichen);
  104. int charsuch(unsigned char *str, char was);
  105. int m_lese(int zeile, int spalte,unsigned char *maske,int *abb);
  106. void setcr(unsigned int zeile,unsigned int spalte);
  107. int zeile(void);
  108. int spalte(void);
  109. int lesech(void);
  110. void str_ins(unsigned char *str, int w, int l, char c,unsigned char *pic);
  111. void str_del(unsigned char *str, int w, int l,unsigned char *pic);
  112. int dezmove(unsigned char *str, unsigned char *pic);
  113. int nummove(unsigned char *str);
  114. int dezset(unsigned char *str, unsigned char *pic);
  115. void lese(int zeile, int spalte, unsigned char *str, unsigned char *pic, int *abb);
  116. void alltrim(unsigned char *str,unsigned char *neustr);
  117.  
  118. void pperror(unsigned char *Fehler, unsigned char *prog);
  119. int iparam(long *var, unsigned char *prog);
  120. int fparam(double *var, unsigned char *prog);
  121. int strparam(unsigned char *var, int len, unsigned char *prog);
  122. int allstrparam(unsigned char *var, int len, unsigned char *prog);
  123.  
  124.  
  125. int           _set_f_v   =7;
  126. int           _set_f_h   =0;
  127. unsigned int  _cr_zeile  =0;
  128. unsigned int  _cr_spalte =0;
  129. int           _lastkey   =10;
  130.  
  131.  
  132. int           ParamVar=FALSE;
  133. unsigned char ParamType=0;
  134. unsigned char ParamName[NAMLEN];
  135.  
  136.  
  137. /* Benötigte Globalvariablen */
  138. extern  int             Steuer;                 /* der aufrufenden Routine wird mit-    */
  139. extern    char    ScanBuffer[ZEILENLAENGE]; /* Ergebnisbuffer des Scanners */
  140.  
  141.  
  142. /* pperror ()  Ein Syntaxfehler ist aufgetreten.  */
  143. extern    int        IntError;
  144.  
  145. void
  146. pperror (unsigned char *Fehler, unsigned char *prog)
  147. {
  148.     printf ("\n Syntaxfehler : %s  in Funktion <%s>\n",Fehler,prog);
  149.     IntError = TRUE;
  150. }
  151.  
  152.  
  153. int
  154. iparam(long *var, unsigned char *prog)
  155.  
  156. {
  157.    VAR  *Variable;
  158.    ParamVar=FALSE;
  159.    strcpy(ParamName,"                    ");
  160.     Scan();
  161.  
  162.     switch (Steuer)
  163.         {
  164.         case ALPHA:
  165.             /* wenn es eine Variable gibt, merken! */
  166.             if ((Variable = IsVariable (ScanBuffer)) != NULL)
  167.                 {
  168.                 switch (Variable->VarType)
  169.                     {
  170.                     case FIXNUM:
  171.                         *(var)=Variable->VarWert.variable.integer;
  172.                         ParamVar=OK;
  173.                         ParamType=FIXNUM;
  174.                         strcpy(ParamName,ScanBuffer);
  175.                         break;
  176.                     default:
  177.                         pperror ("{Variable ist kein Integer-Typ}",prog);
  178.                         return(FALSE);
  179.                     }
  180.                 }
  181.             else
  182.                 {
  183.                 pperror ("{ungültiger oder kein Var-Name}",prog);
  184.                 return(FALSE);
  185.                 }
  186.             break;
  187.  
  188.         case ZIFFER:
  189.             *(var)=atol(ScanBuffer);
  190.             break;
  191.         default:
  192.             pperror ("{falscher Parameter}",prog);
  193.             return(FALSE);
  194.  
  195.         }
  196.   return(OK);
  197.  
  198. }
  199.  
  200. int
  201. fparam(double *var, unsigned char *prog)
  202.  
  203. {
  204.    VAR  *Variable;
  205.    ParamVar=FALSE;
  206.    strcpy(ParamName,"                    ");
  207.     Scan();
  208.  
  209.     switch (Steuer)
  210.         {
  211.         case ALPHA:
  212.             /* wenn es eine Variable gibt, merken! */
  213.             if ((Variable = IsVariable (ScanBuffer)) != NULL)
  214.                 {
  215.                 switch (Variable->VarType)
  216.                     {
  217.                     case FLONUM:
  218.                         *(var)=Variable->VarWert.variable.Flotype;
  219.                         ParamVar=OK;
  220.                         ParamType=FLONUM;
  221.                         strcpy(ParamName,ScanBuffer);
  222.                         break;
  223.                     default:
  224.                         pperror ("{Variable ist kein Dezimal-Typ}",prog);
  225.                         return(FALSE);
  226.                     }
  227.                 }
  228.             else
  229.                 {
  230.                 pperror ("{ungültiger oder kein Var-Name}",prog);
  231.                 return(FALSE);
  232.                 }
  233.             break;
  234.  
  235.         case ZIFFER:
  236.         case FLONUM:
  237.             *(var)=atof(ScanBuffer);
  238.             break;
  239.  
  240.         default:
  241.             pperror ("{falscher Parameter}",prog);
  242.             return(FALSE);
  243.  
  244.         }
  245.   return(OK);
  246.  
  247. }
  248.  
  249. int
  250. strparam(unsigned char *var, int len, unsigned char *prog)
  251.  
  252. {
  253.    VAR  *Variable;
  254.    ParamVar=FALSE;
  255.    strcpy(ParamName,"                    ");
  256.  
  257.     Scan();
  258.  
  259.     switch (Steuer)
  260.         {
  261.         case ALPHA:
  262.             /* wenn es eine Variable gibt, merken! */
  263.             if ((Variable = IsVariable (ScanBuffer)) != NULL)
  264.                 {
  265.                 switch (Variable->VarType)
  266.                     {
  267.                     case STRING:
  268.                         strncpy(var,Variable->VarWert.variable.text,len);
  269.                         var[len]='\0';
  270.                         ParamVar=OK;
  271.                         ParamType=STRING;
  272.                         strcpy(ParamName,ScanBuffer);
  273.                         break;
  274.                     default:
  275.                         pperror ("{Variable ist kein String-Typ}",prog);
  276.                         return(FALSE);
  277.                     }
  278.                 }
  279.             else
  280.                 {
  281.                 pperror ("{ungültiger oder kein Var-Name}",prog);
  282.                 return(FALSE);
  283.                 }
  284.             break;
  285.  
  286.         case STRING:
  287.             strncpy(var,ScanBuffer,len);
  288.             var[len]='\0';
  289.             break;
  290.         default:
  291.             pperror ("{falscher Parameter}",prog);
  292.             return(FALSE);
  293.  
  294.         }
  295.   return(OK);
  296.  
  297. }
  298.  
  299. int
  300. allstrparam(unsigned char *var, int len, unsigned char *prog)
  301.  
  302. {
  303.    VAR  *Variable;
  304.    ParamVar=FALSE;
  305.    strcpy(ParamName,"                    ");
  306.     Scan();
  307.  
  308.     switch (Steuer)
  309.         {
  310.         case ALPHA:
  311.             /* wenn es eine Variable gibt, merken! */
  312.             if ((Variable = IsVariable (ScanBuffer)) != NULL)
  313.                 {
  314.                 switch (Variable->VarType)
  315.                     {
  316.                     case STRING:
  317.                         strncpy(var,Variable->VarWert.variable.text,len);
  318.                         var[len]='\0';
  319.                         ParamVar=OK;
  320.                         ParamType=STRING;
  321.                         strcpy(ParamName,ScanBuffer);
  322.                         break;
  323.  
  324.                     case FIXNUM:
  325.                         ltoa(Variable->VarWert.variable.integer,var,10);
  326.                         var[len]='\0';
  327.                         ParamVar=OK;
  328.                         ParamType=FIXNUM;
  329.                         strcpy(ParamName,ScanBuffer);
  330.                         break;
  331.  
  332.                     case FLONUM:
  333.                         sprintf(var,"%lf",Variable->VarWert.variable.Flotype);
  334.                         var[len]='\0';
  335.                         ParamVar=OK;
  336.                         ParamType=FLONUM;
  337.                         strcpy(ParamName,ScanBuffer);
  338.                         break;
  339.  
  340.                     default:
  341.                         pperror ("{Variablen-Typ ist nicht Implementiert}",prog);
  342.                         return(FALSE);
  343.                     }
  344.                 }
  345.             else
  346.                 {
  347.                 pperror ("{ungültiger oder kein Var-Name}",prog);
  348.                 return(FALSE);
  349.                 }
  350.             break;
  351.  
  352.         case STRING:
  353.             strncpy(var,ScanBuffer,len);
  354.             var[len]='\0';
  355.             break;
  356.  
  357.         case FLONUM:
  358.         case ZIFFER:
  359.             strncpy(var,ScanBuffer,len);
  360.             var[len]='\0';
  361.             break;
  362.  
  363.         default:
  364.             pperror ("{falscher Parameter}",prog);
  365.             return(FALSE);
  366.  
  367.         }
  368.   return(OK);
  369.  
  370. }
  371.  
  372.  
  373.  
  374. /*
  375.                  Die möglichen Farben :
  376.  
  377.    0 schwarz 
  378.    1 blau    
  379.    2 grün    
  380.    3 türkis  
  381.    4 rot     
  382.    5 lila    
  383.    6 braun   
  384.    7 weiss   
  385.                  Beispiel :
  386.                  ----------
  387.  
  388. main()
  389. {
  390.  set_color(7,1);                                   weiss auf blau
  391.  cls();                                             bildschirm löschen
  392.  zeig(0,0,"X");                                     ein X auf position 0,0
  393.  set_color(7,2);                                   weiss auf grün
  394.  zeig(10,10,"Das ist ein String an Pos 10,10 !");   ein str. auf position 10,10
  395.  zeig(24,79,"X");                                   ein X auf position 24,79
  396.  set_color(7,0);                                   weiss auf schwarz
  397. }                                                   (standard)
  398.  
  399. */
  400.  
  401. /* ****************************************************
  402.     Löscht den Bildschirm. ( Farbe von set_color() )
  403. */
  404.  
  405. void cls()
  406. {
  407.  static unsigned char str[]="                                                                                ";
  408.  int i=0;
  409.  for(;i<25;zeig(i,0,str),i++)
  410.     ;
  411. }
  412.  
  413. /* ****************************************************
  414.     Löscht eine Bildschirmzeile. ( Farbe von set_color() )
  415. */
  416.  
  417. void clrline(int zeile)
  418. {
  419.  static unsigned char str[]="                                                                                ";
  420.  
  421.  zeig(zeile,0,str);
  422.  
  423. }
  424.  
  425. /**********************************************************************
  426.     Interne Function
  427. */
  428.  
  429. unsigned int scr_adr()
  430.  
  431. {
  432. union REGS regs;
  433. int86(PERI,®s,®s);
  434. if ((regs.x.ax & 0x30) == 0x30)
  435.       return(0xb000);
  436.  else return(0xb800);
  437. }
  438.  
  439. /* ****************************************************
  440.     Setzt den Cursor an die gewünschte Bildschirmposition
  441. */
  442.  
  443. void setcr(unsigned int zeile,unsigned int spalte)
  444. {
  445.     union REGS regs;
  446.  
  447.     regs.h.ah = 2;               /* Funktionsnummer 'Cursor setzen' */
  448.     regs.h.dl = (unsigned int) spalte;          /* Spalte u. Zeile übergeben */
  449.     regs.h.dh = (unsigned int) zeile;
  450.     regs.h.bh = 0;
  451.     int86(0x10, ®s, ®s);    /* Interruptaufruf */
  452.     _cr_zeile  =zeile;
  453.     _cr_spalte =spalte;
  454. }
  455.  
  456.  
  457. /**********************************************************************/
  458. /* Die Funktion zeile() gibt Zeilenposition von Cursor zurück.        */
  459. /**********************************************************************/
  460. /* Übergebene Parameter:                                              */
  461. /*                       keiner                                       */
  462. /*--------------------------------------------------------------------*/
  463. /* Rückgabewert :        Zeilenpositon von Cursor                     */
  464. /**********************************************************************/
  465.  
  466. int zeile()
  467. {
  468.     return(_cr_zeile);
  469. }
  470.  
  471. /**********************************************************************/
  472. /* Die Funktion spalte() gibt Spaltenposition von Cursor zurück.      */
  473. /**********************************************************************/
  474. /* Übergebene Parameter:                                              */
  475. /*                       keiner                                       */
  476. /*--------------------------------------------------------------------*/
  477. /* Rückgabewert :        Spaltenpositon von Cursor                    */
  478. /**********************************************************************/
  479.  
  480. int spalte()
  481. {
  482.     return(_cr_spalte);
  483. }
  484.  
  485.  
  486.  
  487. /* ****************************************************
  488.     ZEIG();
  489.  
  490.     Zeigt einen Sting am Bildschirm in der
  491.     Farbe die Sie mit set_color() eingestellt haben.
  492.  
  493.     z    = Zeile     (0 - 24)
  494.     s    = Spalte    (0 - 79)
  495.     *txt = Ausgabestring
  496.  
  497. */
  498.  
  499. void zeig(unsigned int z,unsigned int s,unsigned char *txt)
  500. {
  501.  unsigned int z_pos;
  502.  int anzahl,y;
  503.  char _set_farbe;
  504.  unsigned char far *scr_mon=MK_FP(0xB000,0x0000);  /*  Adresse Mono   */
  505.  unsigned char far *scr_col=MK_FP(0xB000,0x8000);  /*  Adresse Farbe  */
  506.  unsigned int i;
  507.  _set_farbe=(_set_f_h*16)+_set_f_v;
  508.  anzahl = strlen(txt);          /*      Länge des Strings für Farbe  */
  509.  z_pos  = (z*160)+(s*2)-1;      /*      Position Zeichen             */
  510.  
  511. /*      String schreiben        */
  512.  
  513.  if (scr_adr()==0xb800)
  514.   {
  515.   for(y=0,i=z_pos;y<anzahl && *(txt+y)!='\0'; y++)
  516.     {
  517.     *(scr_col+i+2)=_set_farbe;
  518.     i++;
  519.     *(scr_col+i)=*(txt+y);
  520.     i++;
  521.     }
  522.   }
  523.  else
  524.   {
  525.   for(y=0,i=z_pos;y<anzahl && *(txt+y)!='\0'; y++)
  526.     {
  527.     *(scr_mon+i+2)=_set_farbe;
  528.     i++;
  529.     *(scr_mon+i)=*(txt+y);
  530.     i++;
  531.     }
  532.   }
  533. }
  534.  
  535. /* ****************************************************
  536.     ZEIGZ();
  537.  
  538.     Zeigt ein Zeichen am Bildschirm in der
  539.     Farbe die Sie mit set_color() eingestellt haben.
  540.  
  541.     z       = Zeile     (0 - 24)
  542.     s       = Spalte    (0 - 79)
  543.     zeichen = Ausgabezeichen
  544.  
  545. */
  546.  
  547. void zeigz(unsigned int z,unsigned int s, char zeichen)
  548. {
  549.  unsigned int z_pos;
  550.  char _set_farbe; 
  551.  char far *scr_mon=MK_FP(0xB000,0x0000);  /*  Adresse Mono   */
  552.  char far *scr_col=MK_FP(0xB000,0x8000);  /*  Adresse Farbe  */
  553.  _set_farbe=(_set_f_h*16)+_set_f_v;
  554.  z_pos  = (z*160)+(s*2);        /*      Position Zeichen             */
  555.  
  556. /*      Zeichen schreiben        */
  557.  
  558.  if (scr_adr()==0xb800)
  559.   {
  560.     *(scr_col+z_pos+1)=_set_farbe;
  561.     *(scr_col+z_pos)  =zeichen;
  562.   }
  563.  else
  564.   {
  565.     *(scr_mon+z_pos+1)=_set_farbe;
  566.     *(scr_mon+z_pos)  =zeichen;
  567.   }
  568. }
  569.  
  570. /**********************************************************************
  571.  
  572.     Sellt die Farbe ein, die für zeig(),cls()  ect.
  573.     verwendet werden soll.
  574.  
  575.     v = Vordergrundfarbe
  576.     h = Hintergrundfarbe
  577. */
  578.  
  579. void set_color(int v,int h)
  580. {
  581.     _set_f_h   = h;
  582.     _set_f_v   = v;
  583. }
  584.  
  585. /* ****************************************************
  586.     SET_ATTR()
  587.     Parameter   o,ol,u,ur   Bildschirmkoordinaten
  588.                 vom Bildschirmausschmitt,
  589.                 in dem die Farbattribute
  590.                 geändert werden sollen.
  591.  
  592.             v           Vordergrundfarbe.
  593.             h           Hintergrundfarbe.
  594. */
  595.  
  596. void set_attr(int o,int ol,int u,int ur,int v,int h)
  597. {
  598.  unsigned int z_pos,y,yy;
  599.  int anzahl,laenge;
  600.  char far *scr_mon=MK_FP(0xB000,0x0000);  /*  Adresse Mono   */
  601.  char far *scr_col=MK_FP(0xB000,0x8000);  /*  Adresse Farbe  */
  602.  unsigned int i,si;
  603.  char farbe;
  604.  farbe = (h*16)+v;
  605.  laenge = ur-ol+1;
  606.  anzahl = u-o+1;
  607.  z_pos  = (o*160)+(ol*2)+1;       /*      Position im Bildschirm-Momory  */
  608.  
  609.  i=z_pos;
  610.  si=i;
  611.  if (scr_adr()==0xb800)         /*  Frage ob Color  */
  612.     {
  613.     for(yy=0;yy<anzahl; yy++)
  614.         {
  615.         for(y=0;y<laenge; y++)
  616.             {
  617.             *(scr_col+i)=farbe;      /* Farbe setzten */
  618.             i+=2;
  619.             }
  620.         i=si+160;
  621.         si=i;
  622.         }
  623.     }
  624.  else
  625.     {
  626.     for(yy=0;yy<anzahl; yy++)
  627.         {
  628.         for(y=0;y<laenge; y++)
  629.             {
  630.             *(scr_mon+i)=farbe;
  631.             i+=2;
  632.             }
  633.         i=si+160;
  634.         si=i;
  635.         }
  636.     }
  637.  
  638. }
  639.  
  640.  
  641.  
  642. /* ************************************************************************
  643.  
  644.     SAVESCREEN()    Sichert den Bildschirm an den angegebenen Koordinaten.
  645.     RESTSCREEN()    Schreibt die Sicherung wirder auf den Bildschirm.
  646.  
  647.  
  648.     Beispiel :
  649.     ----------
  650.  
  651.  
  652.      static unsigned char s_screen[61];
  653.  
  654.      set_color(2,0);
  655.      cls();
  656.      zeig(10,0,"Orginal :");
  657.      zeig(10,10,"1234567890");
  658.      zeig(11,10,"1234567890");
  659.      zeig(12,10,"1234567890");
  660.  
  661.      savescreen(10,10,12,19,s_screen);
  662.  
  663.      set_color(4,0);
  664.      zeig(15,0,"SaveSTR :");
  665.      zeig(15,10,s_screen);
  666.      zeig(20,0,"Restore :");
  667.     
  668.      restscreen(20,20,22,29,s_screen);
  669.     
  670.      zeig(24,10,"beliebige Taste weiter ...");
  671.      warte();
  672.  
  673.  
  674. *****************************************************
  675.  
  676.     Parameter   o,ol,u,ur   Bildschirmkoordinaten
  677.                             vom Bildschirmausschmitt,
  678.                 der gesichert werden soll.
  679.  
  680.             *tab        String in den der Bildschirm
  681.                 gesichert werden soll.
  682.                 Die Länge des Sting's errechnet sich
  683.                 durch folgende Formel :
  684.  
  685.                 ( (ur-ol+1) * (u-o+1) ) * 2 + 1
  686.                          oder
  687.                 (Anzahl Sicherungszeichen) * 2 + 1
  688.  
  689.  
  690.                zB.    012345678901234567890.....
  691.                   1
  692.                   2        abcdefg
  693.                   3        ABCDEFG
  694.                   .
  695.                   .
  696.  
  697.                   Stringlänge = ( (15-9+1) * (3-2+1) ) * 2 + 1
  698.                   oder          14 * 2 + 1
  699.  
  700.                   savescreen(2,9,3,15,string);
  701.  
  702. */
  703.  
  704. void savescreen(int o,int ol,int u,int ur,unsigned char *tab)
  705.  
  706. {
  707.  unsigned int z_pos,y,yy;
  708.  int anzahl,laenge;
  709.  char far *scr_mon=MK_FP(0xB000,0x0000);  /*  Adresse Mono   */
  710.  char far *scr_col=MK_FP(0xB000,0x8000);  /*  Adresse Farbe  */
  711.  unsigned int i,si,tot;
  712.  laenge = 2*(ur-ol+1);
  713.  anzahl = u-o+1;
  714.  z_pos  = (o*160)+(ol*2);       /*     Position im Bildschirm-Merory    */
  715.  
  716. /*      String speichern        */
  717.  tot=0;
  718.  i=z_pos;
  719.  si=i;
  720.  if (scr_adr()==0xb800)         /*  Frage ob Color  */
  721.     {
  722.     for(yy=0;yy<anzahl; yy++)
  723.         {
  724.         for(y=0;y<laenge; y++)
  725.             {
  726.             *(tab+tot)=*(scr_col+i);
  727.             tot++;
  728.             i++;
  729.             }
  730.         i=si+160;
  731.         si=i;
  732.         }
  733.     }
  734.  else
  735.     {
  736.     for(yy=0;yy<anzahl; yy++)
  737.         {
  738.         for(y=0;y<laenge; y++)
  739.             {
  740.             *(tab+tot)=*(scr_mon+i);
  741.             tot++;
  742.             i++;
  743.             }
  744.         i=si+160;
  745.         si=i;
  746.         }
  747.     }
  748.  *(tab+tot)='\0';
  749. }
  750.  
  751. /* ****************************************************
  752.  
  753.     Parameter   o,ol,u,ur   Bildschirmkoordinaten
  754.                             vom Bildschirmausschmitt,
  755.                             der geschrieben werden soll.
  756.  
  757.                 *tab        String, der mit SAVESCREEN
  758.                             erstellt wurde.
  759. */
  760.  
  761. void restscreen(int o,int ol,int u,int ur,unsigned char *tab)
  762. {
  763.  unsigned int z_pos,y,yy;
  764.  int anzahl,laenge;
  765.  char far *scr_mon=MK_FP(0xB000,0x0000);  /*  Adresse Mono   */
  766.  char far *scr_col=MK_FP(0xB000,0x8000);  /*  Adresse Farbe  */
  767.  unsigned int i,si,tot;
  768.  laenge = 2*(ur-ol+1);
  769.  anzahl = u-o+1;
  770.  z_pos  = (o*160)+(ol*2);       /*      Position im Bildschirm-Momory  */
  771.  
  772. /*      String schreiben        */
  773.  tot=0;
  774.  i=z_pos;
  775.  si=i;
  776.  if (scr_adr()==0xb800)         /*  Frage ob Color  */
  777.     {
  778.     for(yy=0;yy<anzahl; yy++)
  779.         {
  780.         for(y=0;y<laenge; y++)
  781.             {
  782.             *(scr_col+i)=*(tab+tot);      /* Zeichen für Zeichen schreiben */
  783.             tot++;
  784.             i++;
  785.             }
  786.         i=si+160;
  787.         si=i;
  788.         }
  789.     }
  790.  else
  791.     {
  792.     for(yy=0;yy<anzahl; yy++)
  793.         {
  794.         for(y=0;y<laenge; y++)
  795.             {
  796.             *(scr_mon+i)=*(tab+tot);
  797.             tot++;
  798.             i++;
  799.             }
  800.         i=si+160;
  801.         si=i;
  802.         }
  803.     }
  804.  
  805. }
  806.  
  807.  
  808. /* ****************************************************
  809.     Wartet auf einen Tastendruck.
  810. */
  811.  
  812. void warte()
  813. {
  814.     char c=0;
  815.     while (c==0)
  816.         c = getch();
  817. }
  818.  
  819. /* *******************************************************
  820.     Zeichnet eine Box auf den Bildschirm.
  821.     Parameter :   o,ol,u,ur    obere Zeile, Spalte untere Zeile, Spalte
  822.                   *zeichen     Boxstring "╔═╗║╝═╚║ "
  823.  
  824.                   zB.          "abcdefgh#"           abbbc
  825.                                                      d###h
  826.                                                      gfffe
  827.  
  828.  
  829. */
  830.  
  831. int box(int o, int ol, int u, int ur,unsigned char *zeichen)
  832. {
  833.     int laenge,hoehe,i,y;
  834.     char v[2], h[2];
  835.     static unsigned char oben[81], mitte[81], unten[81];
  836.     laenge = ur - ol;
  837.     hoehe  = u  - o;
  838.     if(strlen(zeichen) < 8)
  839.         return(0);
  840.     *oben=*zeichen;
  841.     for(i=1;i<laenge;*(oben+ i++)=*(zeichen+1))
  842.         ;
  843.     *(oben+ i++)=*(zeichen+2);
  844.     *(oben+i)='\0';
  845.     zeig(o,ol,oben);
  846.     *unten=*(zeichen+6);
  847.     for(i=1;i<laenge;*(unten+ i++)=*(zeichen+5))
  848.         ;
  849.     *(unten+ i++)=*(zeichen+4);
  850.     *(unten+ i)='\0';
  851.     if (*(zeichen+8) != '\0')
  852.         {
  853.         *mitte=*(zeichen+3);
  854.         for(i=1;i<laenge;*(mitte+ i++)=*(zeichen+8))
  855.             ;
  856.         *(mitte+ i++)=*(zeichen+7);
  857.         *(mitte+ i)='\0';
  858.         for(i=1;i<hoehe;zeig(o+i++,ol,mitte))
  859.             ;
  860.         }
  861.     else
  862.         {
  863.         *v     = *(zeichen+3);
  864.         *(v+1) = '\0';
  865.         *h     = *(zeichen+7);
  866.         *(h+1) = '\0';
  867.         for(i=1;i<hoehe;zeig(o+i,ur,v),zeig(o+i++,ol,h))
  868.             ;
  869.         }
  870.  
  871.     zeig(u,ol,unten);
  872.     return(1);
  873. }
  874.  
  875.  
  876. /* ********************************************************** 
  877.     Gibt die Position eines Charakters in einem String zurück
  878.     Parameter : *str       String der durchsucht wird
  879.                 was        Charakter der gesucht wird
  880.  
  881.     return    Position von Charakter im String
  882.               [a][b][c][d][\0]
  883.                   ^
  884.                   Position 2
  885. */
  886.  
  887. int charsuch(unsigned char *str, char was)
  888. {
  889.     int i,y;
  890.     y = strlen(str);
  891.     if(was > 96 && was < 123)           /* wenn kleinbuchstabe, */
  892.         was = was -32;              /* in grosser verwandeln  */
  893.     for(i=0;*(str+i) != was && i < y;i++)
  894.         ;
  895.     if (i < y)
  896.         return(i+1);
  897.     else
  898.         return(0);
  899. }
  900.  
  901.  
  902.  
  903.  
  904. /* ************************************************************
  905.     Liest ein Zeichen ein.
  906.     Parameter : keine
  907.  
  908.     return    Asciiwert vom Zeichen.
  909.           > 9000 = Spezialtaste
  910.                zB.: ENTER, ESC, TAB, INS, DEL, F1 .....
  911. */
  912.  
  913. int lesech()
  914. {
  915.     int z;
  916.     z=getch();
  917.     switch((int)z)
  918.         {
  919.         case 0 :
  920.             z=getch();
  921.         case 8  :
  922.         case 27 :
  923.         case 13 :
  924.         case 10 :
  925.         case 9  :
  926.             _lastkey=9000+(int)z;
  927.             break;
  928.  
  929.         default :
  930.             _lastkey=z;
  931.         }
  932.  
  933.     return(_lastkey);
  934. }
  935.  
  936. /* ************************************************************
  937.     String vom Bildschirm einlesen.
  938.  
  939.     Parameter :    zeile,spalte      Position am Bildschirm.
  940.                *str              String der Eingelesen werden soll.
  941.                *pic              Maske für Eingabe.
  942.                      9    =  alle Zeichen die in zeichen9
  943.                          definiert sind. (1234567890)
  944.  
  945.                      D    =  Datum einlesen
  946.  
  947.                      X    =  Zeichen > 31 und < 224
  948.  
  949.                     ' '   =  An dieser Position im
  950.                          String können keine Daten
  951.                          eingegeben werden.
  952.  
  953.             *abb            Zahlenarray mit den Abbruchtasten.
  954.  
  955.  
  956.     Abbruch  :  immer mit ENTER und den mitgegebenen Abbruchtasten.
  957.  
  958.     Return   :  nichts (Es wird der Orginalstring verändert !)
  959.  
  960.  
  961.  
  962.     Beispiel :
  963.  
  964.  
  965.     int abbruch[]={ESC,PGDN};
  966.  
  967.     main()
  968.     }
  969.     static unsigned char str[]="          ";
  970.     static unsigned char datum[]="00.00.0000";
  971.  
  972.     FILE *datei;
  973.  
  974.     cls();
  975.     zeig(6,0,"Dateiname :");
  976.     lese(6,12,str,"XXXXXXXXXX",abbruch);
  977.     if (str[0]==' ' || _lastkey == ESC)
  978.         return;
  979.     datei = fopen(str,"at");
  980.     if (datei == 0)
  981.         {
  982.         datei = fopen(str,"wt");
  983.         if (datei == 0)
  984.         {
  985.         zeig(8,0,"Datei konnte nicht eröffnet werden !");
  986.         return;
  987.         }
  988.     zeig(10,0,"Datum :");
  989.     lese(10,10,datum,"DD.DD.DDDD",abbruch);
  990.     if (_lastkey != ESC)
  991.         fprintf(datei,"Das Datum ist  %s\n", datum);
  992.     fclose(datei);
  993.  
  994.     }
  995.  
  996. */
  997.  
  998. void lese(int zeile, int spalte, unsigned char *str, unsigned char *pic, int *abb)
  999. {
  1000.     int i = 0;
  1001.     int y = 0;
  1002.     int len;
  1003.     int ab= 0;
  1004.     int dezimal=0;
  1005.     int loeschen=1;
  1006.     char *a;
  1007.     y   = strlen(pic);
  1008.     len = strlen(str)-1;
  1009.     if(strchr(pic,'.')!=NULL)
  1010.         dezimal=1;
  1011.  
  1012.     zeig(zeile, spalte, str);
  1013.     setcr(zeile,spalte);
  1014.     _lastkey = lesech();
  1015.     while (_lastkey != ENTER)
  1016.     {
  1017.  
  1018.         if ((int) _lastkey > 9000 || i == y )
  1019.  
  1020.             switch(_lastkey)
  1021.             {
  1022.  
  1023.             case CRLI :      /* linker Cursor */
  1024.                 if (i > 0)
  1025.                     i--;
  1026.                 for(;(pic[i] == ' ' || pic[i] == '.') && i > 0;i--);
  1027.                 zeig(zeile,spalte,str);
  1028.                 setcr(zeile, spalte+i);
  1029.                 break;
  1030.  
  1031.             case CRRE :      /* rechter Cursor */
  1032.                 if (i < y-1)
  1033.                     i++;
  1034.                 for(;(pic[i] == ' ' || pic[i]=='.') && i < y-1;i++);
  1035.                 zeig(zeile,spalte,str);
  1036.                 setcr(zeile, spalte+i);  
  1037.                 break;
  1038.  
  1039.             case END :      /* End */
  1040.                 i = y-1;
  1041.                 for(;str[i] == ' ' && i > 0;i--);
  1042.                 i++;
  1043.                 for(;(pic[i] == ' ' || pic[i] == '.') && i > 0;i--)
  1044.                     ;
  1045.                 zeig(zeile,spalte,str);
  1046.                 setcr(zeile,spalte+i);
  1047.                 break;
  1048.  
  1049.             case HOME :      /* Home */
  1050.                 i = 0;
  1051.                 for(;(pic[i] == ' ' || pic[i] == '.') && i < y-1;i++);
  1052.                 zeig(zeile,spalte,str);
  1053.                 setcr(zeile,spalte+i);
  1054.                 break;
  1055.  
  1056.             case DEL :      /* Del */
  1057.                 str_del(str,i,y,pic);
  1058.                 zeig(zeile, spalte, str);
  1059.                 setcr(zeile,spalte+i);
  1060.                 break;
  1061.  
  1062.             case BKSP  :      /* Backspace */
  1063.                 if (i > 0)
  1064.                     {
  1065.                     i--;
  1066.                     for(;(pic[i] == ' ' || pic[i] == '.') && i > 0;i--);
  1067.                     str_del(str,i,y,pic);
  1068.                     zeig(zeile, spalte, str);
  1069.                     setcr(zeile,spalte+i);
  1070.                     }
  1071.                 break;
  1072.  
  1073.  
  1074.             case INS :      /* Ins */
  1075.                 str_ins(str,i,y,' ',pic);
  1076.                 zeig(zeile, spalte, str);
  1077.                 setcr(zeile,spalte+i);
  1078.                 break;
  1079.  
  1080.             default :      /*  Prüfen ob abbrechen   */
  1081.                 for(ab=0; abb[ab] != '\0' && abb[ab] != _lastkey; ab++)
  1082.                     ;
  1083.                 if (abb[ab] != '\0')
  1084.                     {
  1085.                     if(charsuch(pic,'9') != 0)
  1086.                         {
  1087.                         if(dezimal)
  1088.                             dezmove(str,pic);
  1089.                         else
  1090.                             nummove(str);
  1091.                         zeig(zeile,spalte,str);
  1092.                         }
  1093.                     return;
  1094.                     }
  1095.  
  1096.  
  1097.             }
  1098.         else
  1099.             switch(pic[i])
  1100.             {
  1101.             case 'X' :
  1102.                 if (_lastkey > 31 && _lastkey < 224)
  1103.                     {
  1104.                     zeigz(zeile,spalte+i,_lastkey);
  1105.                     str[i] = _lastkey;
  1106.                     i++;
  1107.                     for(;pic[i] == ' ' && i < y;zeigz(zeile,spalte+i,' '),i++);
  1108.                     zeig(zeile,spalte,str);
  1109.                     setcr(zeile,spalte+i);
  1110.                     }
  1111.                 else
  1112.                     putch(7);
  1113.                 break;
  1114.  
  1115.             case '9' :
  1116.                 if(_lastkey == '.' && !dezimal)
  1117.                     {
  1118.                     putch(7);
  1119.                     break;
  1120.                     }
  1121.                 a = strchr(zeichen9, _lastkey);
  1122.                 if (a != NULL)
  1123.                     {
  1124.                     if(loeschen)
  1125.                         {
  1126.                         loeschen=0;
  1127.                         for(;len>=0;len--)
  1128.                             if(str[len]!='.')
  1129.                                 str[len]=' ';
  1130.                         }
  1131.                     if(_lastkey == '.')
  1132.                         {
  1133.                         if( (charsuch(pic,'.')-1) < i)
  1134.                             {
  1135.                             putch(7);
  1136.                             break;
  1137.                             }
  1138.                         str[i]='.';
  1139.                         if( (i=dezmove(str,pic)) == 0)
  1140.                             {
  1141.                             putch(7);
  1142.                             break;
  1143.                             }
  1144.                         i=0;
  1145.                         for(;pic[i] != '.' && i < y;i++)
  1146.                             ;
  1147.                         i++;
  1148.                         zeig(zeile,spalte,str);
  1149.                         setcr(zeile, spalte+i);
  1150.                         }
  1151.                     else
  1152.                         {
  1153.                         zeigz(zeile,spalte+i,_lastkey);
  1154.                         str[i] = _lastkey;
  1155.                         i++;
  1156.                         for(;(pic[i] == ' ' || pic[i] == '.') && i < y;zeigz(zeile,spalte+i,' '),i++)
  1157.                             ;
  1158.                         zeig(zeile,spalte,str);
  1159.                         setcr(zeile, spalte+i);
  1160.                         }
  1161.                     }
  1162.                 else
  1163.                     putch(7);
  1164.                 break;
  1165.  
  1166.             case 'D' :
  1167.                 a = strchr(zeichenD, _lastkey);
  1168.                 if (a != NULL)
  1169.                     {
  1170.                     zeigz(zeile,spalte+i,_lastkey);
  1171.                     str[i] = _lastkey;
  1172.                     i++;
  1173.                     for(;(pic[i] == ' ' || pic[i] == '.') && i < y;zeigz(zeile,spalte+i,' '),i++)
  1174.                         ;
  1175.                     zeig(zeile,spalte,str);
  1176.                     setcr(zeile, spalte+i);
  1177.                     }
  1178.                 else
  1179.                     putch(7);
  1180.                 break;
  1181.  
  1182.             default :
  1183.                     zeig(1,1,"Falscher Typ in PIC");
  1184.                     warte();
  1185.                     zeig(1,1,"                   ");
  1186.                     return;
  1187.  
  1188.             }
  1189.         _lastkey = lesech();
  1190.     }
  1191.     if(charsuch(pic,'9') != 0)
  1192.         {
  1193.         if(dezimal)
  1194.             dezmove(str,pic);
  1195.         else
  1196.             nummove(str);
  1197.         zeig(zeile,spalte,str);
  1198.         }
  1199.     return;
  1200. }
  1201.  
  1202.  
  1203.  
  1204. /* *********************************************************
  1205.     Intere Function
  1206. */
  1207.  
  1208. void str_del(unsigned char *str, int w, int l, unsigned char *pic)
  1209. {
  1210.     int n,ww,ll;
  1211.     ww =w;
  1212.     while (ww < l)
  1213.         {
  1214.         for(;(pic[ww] == ' ' || pic[ww] == '.') && ww < l;)
  1215.             ww++;
  1216.  
  1217.         n=ww+1;
  1218.         for(;(pic[n] == ' ' || pic[n] == '.') && n < l;)
  1219.             n++;
  1220.         if (n < l)
  1221.             str[ww] = str[n];
  1222.         ww=n;
  1223.         }
  1224.  
  1225.     ll=l;
  1226.     for(;(pic[ll-1] == ' ' || pic[l-1] == '.')  && ll-1 > w;)
  1227.         ll--;
  1228.     if(ll-1 > w)
  1229.         str[ll-1] = ' ';
  1230. }
  1231.  
  1232. /* *****************************************************
  1233.     Interne Function
  1234. */
  1235.  
  1236. void str_ins(unsigned char *str, int w, int l, char c, unsigned char *pic)
  1237. {
  1238.     int n;
  1239.     if (w >= l)
  1240.         return;
  1241.     while (l > w)
  1242.         {
  1243.         for(;(pic[l-1] == ' ' || pic[l-1] == '.') && l > w;)
  1244.             l--;
  1245.         n=l-1;
  1246.         for(;(pic[n-1] == ' ' || pic[n-1] == '.') && n > w;)
  1247.             n--;
  1248.         str[l-1] = str[n-1];
  1249.         l=n;
  1250.         }
  1251.     str[w] = c;
  1252. }
  1253.  
  1254.  
  1255. /* ****************************************************** */
  1256. int dezmove(unsigned char *str, unsigned char *pic)
  1257. {
  1258.     int r,y,pos,l;
  1259.     if( (r=charsuch(pic,'.')) == 0)
  1260.         {
  1261.         nummove(str);
  1262.         return(r);
  1263.         }
  1264.     r--;
  1265.     pos=charsuch(str,'.');
  1266.     pos--;
  1267.     for(y=r-1,l=pos-1;l>=0;l--,y--)
  1268.         {
  1269.         str[y]=str[l];
  1270.         }
  1271.     for(;y>=0;--y)
  1272.         str[y]=' ';
  1273.  
  1274.     str[r]='.';
  1275.  
  1276.     for(y=r-1;y>=0;--y)
  1277.         {
  1278.         if(str[y]==' ')
  1279.             {
  1280.             for(l=y-1;l>=0 && str[l]==' ';)
  1281.                 --l;
  1282.             if(l < 0)
  1283.                 break;
  1284.             str[y]=str[l];
  1285.             str[l]=' ';
  1286.             }
  1287.         }
  1288.     
  1289.     if(str[r-1]==' ')
  1290.         str[r-1]='0';
  1291.     for(y=r+1;str[y] !='\0';++y)
  1292.         {
  1293.         if(str[y]==' ')
  1294.             str[y]='0';
  1295.         }
  1296.  
  1297.     return(r);
  1298. }
  1299.  
  1300. /* ****************************************************** */
  1301. int dezset(unsigned char *str, unsigned char *pic)
  1302. {
  1303.     int r,y,pos,l;
  1304.  
  1305.     if( (r=charsuch(pic,'.')) == 0)
  1306.         {
  1307.         l=strlen(pic);
  1308.         for(y=0;y<l && str[y]!='.';y++)
  1309.             ;
  1310.         for(;y<l;y++)
  1311.             str_ins(str,0,l,' ',pic);
  1312.         str[l]='\0';
  1313.         return(1);
  1314.         }
  1315.     r--;
  1316.     if( (pos=charsuch(str,'.')) == 0)
  1317.         {
  1318.         l=strlen(str);
  1319.         str[l]='.';
  1320.         str[l+1]='\0';
  1321.         pos=l+1;
  1322.         }
  1323.  
  1324.     pos--;
  1325.  
  1326.     if(r<pos)
  1327.         {
  1328.         l=strlen(str);
  1329.         pic[r]='9';
  1330.         for(y=r;y<pos;y++)
  1331.             {
  1332.             str_del(str,0,l,pic);
  1333.             str[l-1]='0';
  1334.             }
  1335.         pic[r]='.';
  1336.         }
  1337.     if(r>pos)
  1338.         {
  1339.         l=strlen(pic);
  1340.         pic[r]='9';
  1341.         for(y=pos;y<r;y++)
  1342.             {
  1343.             str_ins(str,0,l,' ',pic);
  1344.             }
  1345.         pic[r]='.';
  1346.         }
  1347.     str[r]='.';
  1348.  
  1349.     l=strlen(pic);
  1350.     str[l]='\0';
  1351.  
  1352.     for(r++;r<l;r++)
  1353.         {
  1354.         if(str[r]==' ' || str[r] == 0)
  1355.             str[r]='0';
  1356.         }
  1357.  
  1358.     return(1);
  1359. }
  1360.  
  1361.  
  1362. /* ****************************************************** */
  1363. int nummove(unsigned char *str)
  1364. {
  1365.     int y,l;
  1366.     y=strlen(str)-1;
  1367.     for(;y>=0;--y)
  1368.         {
  1369.         if(str[y]==' ')
  1370.             {
  1371.             for(l=y-1;l>=0 && str[l]==' ';)
  1372.                 --l;
  1373.             if(l < 0)
  1374.                 break;
  1375.             str[y]=str[l];
  1376.             str[l]=' ';
  1377.             }
  1378.         }
  1379.     return(1);
  1380. }
  1381.  
  1382. /* ****************************************************** */
  1383.  
  1384. void alltrim(unsigned char *str,unsigned char *neustr)
  1385.  
  1386. {
  1387.     int i,y;
  1388.     for(i=0;str[i]==' ';i++)
  1389.         ;
  1390.     for(y=0;str[i]!='\0';i++,y++)
  1391.         neustr[y]=str[i];
  1392.     for(y--;neustr[y]==' ';y--)
  1393.         ;
  1394.     neustr[++y]='\0';
  1395. }
  1396.