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