home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / dos_txl / source / editor.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-19  |  22.8 KB  |  938 lines
  1. /* EDITOR.C
  2.    Editor für TXL-Interpreter
  3.    (c) 1991 Elmar Warken
  4. */
  5.  
  6. #include <stdlib.h>
  7. #include <dos.h>
  8. #include <mem.h>
  9. #include <conio.h>
  10. #include <string.h>
  11. #include <stdio.h>
  12. #include <ctype.h>
  13. #include <alloc.h>
  14. #include "interp.h"
  15. #include "macros.c"
  16. #include "windows.h"
  17.  
  18. /* Benötigte Globalvariablen */
  19. extern    PRGZEILE    *FirstLine;        
  20. extern    PRGZEILE    *ActLine;        
  21. extern    char        *LinePos;        
  22. extern    int        Steuer;            
  23. extern    char    ScanBuffer[ZEILENLAENGE]; 
  24.  
  25. extern  TOKBEF  TokBefDesc[]; 
  26.  
  27. extern struct windowdata *FirstWindow;
  28. extern int WindowCounter;
  29.  
  30. char *TESTER="rt";
  31.  
  32. typedef struct asciiz { 
  33.   char *Zeile;
  34.   struct asciiz *Next,*Prev;
  35. } ASCIIZEILE;
  36.  
  37. typedef struct editordata
  38. {
  39.   ASCIIZEILE *First,*FirstView,*Act,*BlockBegin,*BlockEnd;      
  40.   /**** erte gesamt, erste sichtbare, Cursorzeile, BlockMarkierung ***/
  41.  
  42.   int cx,cy,ax,ay;/*** Cursorposition, erste Spalte ***/
  43.   int insert,TXL; /*** TXL : handelt es sich die aktuelle Programmdatei ? ***/
  44.   int m1x,m1y,m2x,m2y;  /*** Blockmarkierungen Anfang und Ende : 
  45.             /*** Zeile und Spalte ***/
  46.   char name[50];
  47. } EditorData;
  48.  
  49. void ShowEditor(EditorData *ED)
  50. {
  51.   ASCIIZEILE *line;
  52.   char x1,y1,breite,hoehe,col;
  53.   int startx,starty;
  54.   char status[50];     /** Statuszeile **/
  55.  
  56.   int i,inversx1,inversx2,teilinvers;
  57.  
  58.   line=ED->Act;
  59.   col=FirstWindow->BackCol;
  60.   x1=FirstWindow->x1+1;
  61.   y1=FirstWindow->y1+1;
  62.   breite=FirstWindow->x2-x1-1;
  63.   hoehe=FirstWindow->y2-y1-1;
  64.  
  65.   startx=ED->ax;
  66.   if (ED->cx > ED->ax+breite-1) startx=ED->cx-breite+1; 
  67.     else if (ED->cx < ED->ax) startx=ED->cx-1; 
  68.   if (startx==0) startx=1;
  69.  
  70.   starty=ED->ay;
  71.   if (ED->cy > ED->ay+hoehe-1) starty=ED->cy-hoehe+1;
  72.     else if (ED->cy < ED->ay) starty=ED->cy-1;
  73.   if (starty==0) starty=1;
  74.  
  75.   ED->ay=starty;
  76.   ED->ax=startx;
  77.  
  78.   for (i=1; i<=ED->cy-starty; line=line->Prev, i++);
  79.  
  80.   for (i=1; (i<=FirstWindow->Hoehe-2) && (line!=NULL); line=line->Next, i++)
  81.   { 
  82.     SET_POS(x1,y1+i-1);
  83.  
  84.     if ((ED->m1y < starty+i-1) && (ED->m2y > starty+i-1))
  85.     {
  86.       col=FirstWindow->BackCol+16;
  87.       teilinvers=0;
  88.     }
  89.     else 
  90.     { /** Blockmarkierung berechnen **/
  91.       inversx1=x1; inversx2=x1+FirstWindow->Breite-1;
  92.       col=FirstWindow->BackCol;
  93.       teilinvers=0;
  94.       if (ED->m2y == starty+i-1)
  95.       {    inversx2=x1+ED->m2x-startx; teilinvers=1; }
  96.       if (ED->m1y == starty+i-1)
  97.       {    inversx1=x1+ED->m1x-startx; teilinvers=1; }
  98.       if ((inversx2<x1) || (inversx1>FirstWindow->Breite-1))
  99.     teilinvers=0;
  100.       else
  101.       {
  102.     if (inversx1<x1) inversx1=x1;
  103.     if (inversx2>x1+FirstWindow->Breite-3) inversx2=x1+FirstWindow->Breite-3;
  104.       }
  105.     }
  106.     if ((ED->ax-1) > strlen(line->Zeile))
  107.       WR_STRMAX("",col,FirstWindow->Breite-2);
  108.     else 
  109.     { 
  110.       WR_STRMAX((line->Zeile)+ED->ax-1,col,FirstWindow->Breite-2);
  111.       if (teilinvers)
  112.       {
  113.     SET_POS(inversx1,y1+i-1);
  114.     WR_ASTR(inversx2-inversx1+1,FirstWindow->BackCol+16);
  115.       }
  116.     }
  117.   }
  118.   /* Auffüllen der restlichen Zeilen */
  119.   for (; i<=FirstWindow->Hoehe-2 ; i++)
  120.   { 
  121.     SET_POS(x1,y1+i-1);
  122.     WR_STRMAX("",col,FirstWindow->Breite-2);
  123.   }
  124.   gotoxy(x1+ED->cx-ED->ax,y1+ED->cy-ED->ay);
  125.   sprintf(status," Zeile %d, Spalte %d ",ED->cy,ED->cx);
  126.   if (ED->insert) strcat(status,"  INS ");
  127.     else strcat(status,"      ");
  128.   TopBottomFirstWin(ED->name,status);
  129. }
  130.  
  131. char *GetTXLStr(PRGZEILE *FromStr) /* reserviert auch neuen Speicher */
  132. {
  133.   char NewStr[300], *LINE, *ExactSpace;
  134.  
  135.   LINE=FromStr->Zeile;
  136.   strcpy(NewStr,"");
  137.  
  138.   if (*LINE) {  
  139.     sprintf(NewStr,"%03d %s ",FromStr->LineNumber,
  140.                   TokBefDesc[(*LINE-TOKMIN)&0xff].Befehl);
  141.     LINE++;
  142.     if (*LINE) strcat(NewStr,LINE);
  143.   }
  144.   ExactSpace=malloc(strlen(NewStr)+1);
  145.   return(strcpy(ExactSpace,NewStr));
  146. }
  147.  
  148. char workline[300];
  149. char *altline;
  150. int fkeys[50];
  151. int gosub_position; /* Zwischenspeicher für aufgerufenes Unterprogramm */
  152. int ppc;         /* soll Programm von Präprozessor bearbeitet werden ? */    
  153.  
  154. int StoreWorkLine(EditorData *ED)
  155. {
  156.   if (altline) {
  157.     free(altline);  /* wenn != NULL */
  158.     altline=NULL;
  159.   }
  160.   if ((ED->Act->Zeile=malloc(strlen(workline)+1))==NULL)
  161.   { 
  162.     Message(" Speicherplatz voll.");
  163.     return(FALSE);
  164.   }
  165.   strcpy(ED->Act->Zeile,workline);
  166.   return(OK);
  167. }
  168.  
  169. void LoadWorkLine(EditorData *ED)
  170. {
  171.   strcpy(workline,ED->Act->Zeile);
  172.   altline=ED->Act->Zeile;
  173.   ED->Act->Zeile=workline;
  174. }
  175.  
  176. int InsertLine(EditorData *ED)
  177. {
  178.   ASCIIZEILE *neu;
  179.   char *NeueZeile;
  180.  
  181.   ED->cy++; 
  182.   if (altline) free(altline);  /* wenn != NULL */
  183.   ED->Act->Zeile=malloc(ED->cx);
  184.   strncpy(ED->Act->Zeile,workline,ED->cx-1);
  185.   ED->Act->Zeile[ED->cx-1]=0;
  186.   if (((neu=malloc(sizeof(ASCIIZEILE)))==NULL) || coreleft()<512)
  187.   {
  188.     Message(" Speicherplatz voll.");
  189.     return(FALSE);
  190.   }
  191.   altline=NULL;
  192.   neu->Prev=ED->Act;
  193.   neu->Next=ED->Act->Next;
  194.   ED->Act->Next=neu;
  195.   neu->Next->Prev=neu;
  196.   strcpy(workline,&workline[ED->cx-1]);
  197.   ED->Act=neu;
  198.   ED->Act->Zeile=workline;
  199.   ED->cx=1;
  200.   return(OK);
  201. }
  202.  
  203. void EditorInsert(EditorData *ED, char *str, int max)
  204. {
  205.   char *work,*c,i=1;
  206.   int verschieb=strlen(str);
  207.  
  208.   if (verschieb>max) verschieb=max;
  209.   if (strlen(workline)+strlen(str)<300)
  210.   {
  211.     memmove(&workline[ED->cx+verschieb-1],&workline[ED->cx-1],strlen(workline)-ED->cx+2);
  212.     c=str;
  213.     work=&workline[ED->cx-1]; 
  214.     while (*c && (i++<=max)) *work++=*c++; 
  215.     ED->cx+=strlen(str);
  216.   }
  217. }
  218.  
  219. void SaveFile(char *name, EditorData *ED)
  220. {
  221.   FILE *f;
  222.   ASCIIZEILE *akt;
  223.  
  224.   akt=ED->First;
  225.   if ((f=fopen(name,"wt"))==NULL)
  226.   {
  227.     Message(" Fehler beim Öffnen der Datei. ");
  228.     return;
  229.   }
  230.   while (akt && akt->Zeile)  
  231.   {
  232.     if ( ( fputs(akt->Zeile,f)==EOF) ||
  233.      ( fputs("\n",f)      ==EOF) )
  234.     {
  235.       if (*akt->Zeile)
  236.       {
  237.     Message(" Fehler beim Schreiben der Datei. ");
  238.     return;
  239.       } 
  240.       else fputs("\n",f);
  241.     }
  242.  
  243.     akt=akt->Next;
  244.   }
  245.   fclose(f);
  246. }
  247.  
  248. int _EditorAction(EditorData *ED, int fNum, char zeichen)
  249. {
  250.   StoreWorkLine(ED);
  251.   EditorAction(ED,fNum,zeichen);
  252.   LoadWorkLine(ED);
  253. }
  254.  
  255. int EditorAction(EditorData *ED, int fNum, char zeichen)
  256. {
  257.   int i,aktlen=strlen(workline);
  258.   ASCIIZEILE *neu,*blockhelp;
  259.   char dateiname[60],help,buffer[300];
  260.   FILE *f;
  261.   int Return=OK;
  262.  
  263.   LoadWorkLine(ED);
  264.   switch(fNum)
  265.   {
  266.     case 0 : if (aktlen<300)
  267.          {
  268.         if (ED->insert) memmove(&workline[ED->cx],&workline[ED->cx-1],aktlen-ED->cx+2);
  269.           else if (aktlen<=ED->cx) 
  270.             workline[ED->cx]=0;
  271.         workline[ED->cx-1]=(char)zeichen; ED->cx++;
  272.         aktlen=strlen(workline);
  273.          } break;
  274.     case 4 : ED->cx--; break;
  275.     case 6 : ED->cx++; break;
  276.     case 9 :
  277.     case 8 : if (ED->cy>1) {
  278.            ED->cy--; 
  279.            StoreWorkLine(ED);
  280.            ED->Act=ED->Act->Prev;
  281.            if (fNum==9)
  282.          for (i=2; (i<=FirstWindow->Hoehe-3) && ED->Act->Prev; i++)
  283.            {  ED->Act=ED->Act->Prev; ED->cy--;  }
  284.            LoadWorkLine(ED);
  285.          }
  286.          break;
  287.     case 2 :
  288.     case 3 : if (ED->Act->Next) { 
  289.            ED->cy++; 
  290.            StoreWorkLine(ED);
  291.            ED->Act=ED->Act->Next;
  292.            if (fNum==3)
  293.          for (i=2; (i<=FirstWindow->Hoehe-3) && ED->Act->Next; i++)
  294.            {  ED->Act=ED->Act->Next; ED->cy++;  }
  295.            LoadWorkLine(ED);
  296.          }
  297.          break;
  298.     case 25 : ED->cy=1;
  299.           StoreWorkLine(ED);
  300.           ED->Act=ED->First;
  301.           LoadWorkLine(ED);
  302.           break;
  303.     case 26 : StoreWorkLine(ED);
  304.           while (ED->Act->Next) 
  305.         { ED->Act=ED->Act->Next; ED->cy++; }
  306.           LoadWorkLine(ED);
  307.           break;
  308.     case 7 : ED->cx=1; break;
  309.     case 1 : ED->cx=aktlen+1; break;
  310.     case 11 : if ((aktlen>0) && (ED->cx<=aktlen)) 
  311.         memmove(&workline[ED->cx-1],&workline[ED->cx],aktlen-ED->cx+2); 
  312.           else if (ED->Act->Next)
  313.           {
  314.         strcat(workline,ED->Act->Next->Zeile);
  315.         free(ED->Act->Next->Zeile);
  316.         ED->Act->Next=ED->Act->Next->Next;
  317.         ED->Act->Next->Prev=ED->Act;
  318.           }
  319.           break;
  320.     case 10 : ED->insert=!ED->insert; break;
  321.     case 13 : Return=InsertLine(ED);
  322.         aktlen=strlen(workline);
  323.         break;
  324.     case 12 : if ((aktlen>0) && (ED->cx>1)) {
  325.         memmove(&workline[ED->cx-2],&workline[ED->cx-1],aktlen-ED->cx+2); 
  326.         ED->cx--;
  327.           }
  328.           break;
  329.     case 14 : strcpy(workline,"");
  330.           if (ED->Act->Next) {
  331.         if (altline) free(altline);
  332.         ED->Act->Prev->Next=ED->Act->Next;
  333.         ED->Act->Next->Prev=ED->Act->Prev;
  334.         neu=ED->Act->Next;
  335.         free(ED->Act);
  336.         ED->Act=neu;
  337.         strcpy(workline,ED->Act->Zeile);
  338.         altline=ED->Act->Zeile;
  339.         ED->Act->Zeile=workline;
  340.           }
  341.           break;   
  342.     case 15 : if (ED->cx>1)
  343.           {
  344.         if (isalpha(workline[ED->cx]))
  345.           while (isalpha(workline[ED->cx-2]) && ED->cx>1) 
  346.             ED->cx--;
  347.         while (!isalpha(workline[ED->cx-2]) && ED->cx>1) 
  348.           ED->cx--;
  349.         while (isalpha(workline[ED->cx-2]) && ED->cx>1) 
  350.           ED->cx--;
  351.           } break;
  352.     case 16 : if (ED->cx<aktlen)
  353.           {
  354.         if (isalpha(workline[ED->cx-1]))
  355.           while (isalpha(workline[ED->cx]) && ED->cx<aktlen) 
  356.             ED->cx++;
  357.         while (!isalpha(workline[ED->cx]) && ED->cx<aktlen) 
  358.           ED->cx++;
  359.         ED->cx++;
  360.           } break;
  361.     case 17 :
  362.     case 18 : if (fNum==17) { 
  363.         ED->BlockBegin=ED->Act; 
  364.         ED->m1x=ED->cx;
  365.         ED->m1y=ED->cy;    
  366.           } else
  367.           { ED->BlockEnd=ED->Act; 
  368.         ED->m2x=ED->cx;
  369.         ED->m2y=ED->cy;
  370.           }
  371.           if (ED->m1y>ED->m2y) ED->m2y=ED->m1y;
  372.           if ((ED->m1y==ED->m2y) && (ED->m1x>ED->m2x))
  373.         ED->m2x=ED->m1x;
  374.           break;
  375.     case 19 : /*** Copy Block **/
  376.         
  377.           if (ED->m1y==ED->m2y)
  378.           {             /* Sonderfall : Anfang und Ende in einer Zeile */
  379.         EditorInsert(ED,&ED->BlockBegin->Zeile[ED->m1x-1],ED->m2x-ED->m1x+1);
  380.         break;
  381.           }    
  382.           EditorInsert(ED,&ED->BlockBegin->Zeile[ED->m1x-1],300);
  383.           _EditorAction(ED,13,0); /** Return **/
  384.           blockhelp=ED->BlockBegin->Next;
  385.           for (i=ED->m1y+1; i<ED->m2y; i++)
  386.           {
  387.         EditorInsert(ED,blockhelp->Zeile,300);
  388.         _EditorAction(ED,13,0); /** Return **/
  389.         blockhelp=blockhelp->Next;
  390.           }    
  391.           EditorInsert(ED,blockhelp->Zeile,ED->m2x);
  392.           break;
  393.     case 20 : /** DelBlock **/
  394.           ED->cy=ED->m1y;      /** Cursor an Blockposition setzen **/
  395.           StoreWorkLine(ED);
  396.           ED->Act=ED->BlockBegin;
  397.           ED->cx=ED->m1x;
  398.           LoadWorkLine(ED);
  399.  
  400.           if (ED->m1y==ED->m2y)
  401.           {             /* Sonderfall : Anfang und Ende in einer Zeile */
  402.         memmove(&workline[ED->m1x-1],&workline[ED->m2x],ED->m2x-ED->m1x+2);
  403.         ED->BlockBegin=ED->BlockEnd=NULL; 
  404.         ED->m1x=ED->m2x=ED->m1y=ED->m2y=0;
  405.         break;
  406.           }    
  407.  
  408.           workline[ED->cx-1]=0;  /** löschen **/
  409.           _EditorAction(ED,2,0);
  410.           for (i=ED->m1y+1; i<ED->m2y; i++)
  411.         _EditorAction(ED,14,0); /** Ctrl-Y simulieren **/
  412.           memmove(&workline[0],&workline[ED->m2x],strlen(workline)-ED->m2x+2);
  413.           
  414.           _EditorAction(ED,8,0);  /** 1 Zeile hoch **/
  415.           _EditorAction(ED,1,0);  /** und mit nächster verbinden. **/
  416.           _EditorAction(ED,11,0);
  417.  
  418.           ED->BlockBegin=ED->BlockEnd=NULL; 
  419.           ED->m1x=ED->m2x=ED->m1y=ED->m2y=0;
  420.  
  421.           break;    
  422.     case 21 : /** Move Block **/
  423.           _EditorAction(ED,19,0);
  424.           _EditorAction(ED,20,0);
  425.           break;
  426.     case 22 : /** Datei als Block einlesen **/
  427.           WinReadStr(" Dateiname : ",dateiname,60);
  428.  
  429.           if ((f=fopen(dateiname,"rt"))==NULL)
  430.           {
  431.         Message(" Fehler beim Öffnen der Datei. ");
  432.         return(FALSE);
  433.           }
  434.           _EditorAction(ED,17,0); /* Blockanfang markieren */
  435.           while ((!feof(f)) && (fgets(buffer,300,f)))
  436.           {
  437.         if (buffer[strlen(buffer)-1]=='\n')
  438.           buffer[strlen(buffer)-1]=0;    /** "\n" löschen **/
  439.         EditorInsert(ED,buffer,300);
  440.         _EditorAction(ED,18,0); /* Blockende vorläufig markieren */
  441.         if (_EditorAction(ED,13,0)==FALSE)
  442.         {
  443.           fclose(f);
  444.           return(FALSE);
  445.         }
  446.           }  
  447.           fclose(f);
  448.  
  449.           break;    
  450.     case 24 : /** Block als Datei speichern **/
  451.           WinReadStr(" Dateiname : ",dateiname,60);
  452.  
  453.           ED->cy=ED->m1y;      /** Cursor an Blockposition setzen **/
  454.           StoreWorkLine(ED);
  455.           ED->Act=ED->BlockBegin;
  456.           ED->cx=ED->m1x;
  457.           LoadWorkLine(ED);
  458.  
  459.           if ((f=fopen(dateiname,"wt"))==NULL)
  460.           {
  461.         Message(" Fehler beim Öffnen der Datei. ");
  462.         return(FALSE);
  463.           }
  464.  
  465.           if (ED->m1y==ED->m2y)
  466.           {             /* Sonderfall : Anfang und Ende in einer Zeile */
  467.         help=workline[ED->m2x];
  468.         workline[ED->m2x]=0;
  469.         if ( (fputs(&workline[ED->m1x-1],f)==EOF) ||
  470.              (fputs("\n",f)==EOF))
  471.         {
  472.           Message(" Fehler beim Schreiben der Datei. ");
  473.           return(FALSE);
  474.         }
  475.  
  476.         workline[ED->m2x]=help;
  477.         fclose(f);
  478.         break;
  479.           }    
  480.  
  481.           fputs(&workline[ED->cx-1],f);
  482.           fputs("\n",f);
  483.           _EditorAction(ED,2,0);
  484.           for (i=ED->m1y+1; i<ED->m2y; i++)
  485.           {
  486.         fputs(workline,f);
  487.         fputs("\n",f);
  488.         _EditorAction(ED,2,0);
  489.           }
  490.           help=workline[ED->m2x];
  491.           workline[ED->m2x]=0;
  492.           fputs(workline,f);
  493.           fputs("\n",f);
  494.           workline[ED->m2x]=help;
  495.           fclose(f);
  496.  
  497.           break;    
  498.     case 23 : SaveFile(ED->name,ED); break;
  499.     case 31 : do {
  500.         help=getch();
  501.         if (help==0) {
  502.           help=getch();
  503.           switch(help)
  504.           {
  505.             case 75 : MoveWindow(-1,0); break;
  506.             case 77 : MoveWindow( 1,0); break;
  507.             case 72 : MoveWindow(0,-1); break;
  508.             case 80 : MoveWindow(0, 1); break;
  509.           }
  510.         }
  511.           } while (help != 27); break;
  512.     case 30 : do {
  513.         help=getch();
  514.         if (help==0) {
  515.           help=getch();
  516.           switch(help)
  517.           {
  518.             case 75 : ResizeWindow(-1,0); break;
  519.             case 77 : ResizeWindow( 1,0); break;
  520.             case 72 : ResizeWindow(0,-1); break;
  521.             case 80 : ResizeWindow(0, 1); break;
  522.           }
  523.         }
  524.           } while (help != 27); break;
  525.     case 32 : NewKoorWindow(1,1,80,25); break;
  526.   }
  527.   aktlen=strlen(workline);
  528.   if (!ED->cx) ED->cx=1;
  529.   if (ED->cy<1) ED->cy=1;
  530.   if (ED->cx>aktlen+1) ED->cx=aktlen+1;
  531.   StoreWorkLine(ED);
  532.   return(Return);
  533. }
  534.  
  535. void EditorProc(EditorData *ED)
  536. {
  537.   int c,extended,i;
  538.  
  539.   gosub_position=0;
  540.   ppc=0;
  541.   do
  542.   {
  543.     c=getch();
  544.     if (!c) 
  545.     { 
  546.       extended=getch();
  547.       switch(extended)
  548.       {
  549.     case 75 : EditorAction(ED,4,0); break;
  550.     case 77 : EditorAction(ED,6,0); break;
  551.     case 73 : EditorAction(ED,9,0); break;
  552.     case 72 : EditorAction(ED,8,0); break;
  553.     case 80 : EditorAction(ED,2,0); break;
  554.     case 81 : EditorAction(ED,3,0); break;
  555.     case 71 : EditorAction(ED,7,0); break;
  556.     case 79 : EditorAction(ED,1,0); break;
  557.     case 83 : EditorAction(ED,11,0); break;
  558.     case 82 : EditorAction(ED,10,0); break;
  559.     case 115 :EditorAction(ED,15,0); break;
  560.     case 116 :EditorAction(ED,16,0); break;
  561.     case 132 :EditorAction(ED,25,0); break;
  562.     case 118 :EditorAction(ED,26,0); break;
  563.     case 19 :EditorAction(ED,30,0); break;
  564.     case 50 :EditorAction(ED,31,0); break;
  565.     case 44 :EditorAction(ED,32,0); break;
  566.  
  567.  
  568.     /*** Tastenbelegung von 76 Tasten ( F1-F10 und "F11 bis F76") ***/
  569.     /*** F11-F20 : Shift-Fx, F21-F30 : Ctrl-Fx, F31-F40 : Alt-Fx  ***/
  570.     /*** F41-F50 : Alt-1 bis Alt-0                       ***/    
  571.  
  572.      default : if ((extended>58) && (extended<69))
  573.           { 
  574.             if (fkeys[extended-59]) 
  575.               if ((gosub_position=fkeys[extended-59])!=0)
  576.             c=27;   /** Simulation von <ESC> **/
  577.           }
  578.           else if ((extended>83) && (extended<114))
  579.           { 
  580.             if (fkeys[extended-74]) 
  581.               if ((gosub_position=fkeys[extended-74])!=0)
  582.             c=27;   
  583.           }
  584.           else if ((extended>119) && (extended<130))
  585.           { 
  586.             if (fkeys[extended-80]) 
  587.               if ((gosub_position=fkeys[extended-80])!=0)
  588.             c=27;   
  589.           }
  590.       }
  591.     } else {      /*** Zeichen ohne Extended Code ***/
  592.       switch(c)
  593.       {                           
  594.     case 13 : EditorAction(ED,13,0); break;
  595.     case  8 : EditorAction(ED,12,0); break;
  596.     case 27 : break;
  597.     case 25 : EditorAction(ED,14,0); break;
  598.     case  2 : EditorAction(ED,17,0); break;
  599.     case  5 : EditorAction(ED,18,0); break;
  600.     case  3 : EditorAction(ED,19,0); break;
  601.     case  4 : EditorAction(ED,20,0); break;
  602.     case 22 : EditorAction(ED,21,0); break;
  603.     case 18 : EditorAction(ED,22,0); break;
  604.     case 23 : EditorAction(ED,24,0); break;
  605.     case 19 : EditorAction(ED,23,0); break;
  606.     case 20 : EditorAction(ED,23,0); /** Ctrl-T : Präprozessor **/
  607.           ppc=1; 
  608.           c=27; break;
  609.     default : if (c>27) EditorAction(ED,0,c); break;
  610.       }
  611.     }
  612.   ShowEditor(ED);
  613.   } while(c!=27); /** bis ESC gedrückt wurde. **/
  614. }
  615.  
  616. void GetTXLProg(EditorData *ED)
  617. {
  618.   PRGZEILE *TXL;
  619.   ASCIIZEILE *ASCII,*neu;
  620.  
  621.   ASCII=malloc(sizeof(*ASCII));
  622.   ASCII->Next=NULL; ASCII->Prev=NULL;
  623.   ASCII->Zeile=NULL;
  624.   ED->First=ED->Act=ED->FirstView=ASCII;
  625.  
  626.   if ((TXL = FirstLine) != NULL) {
  627.     while (TXL) {
  628.       ASCII->Zeile=GetTXLStr(TXL);
  629.       if (TXL)
  630.       {
  631.     neu=malloc(sizeof(*neu));
  632.     ASCII->Next=neu;
  633.     neu->Prev=ASCII;
  634.     neu->Zeile=NULL;
  635.     neu->Next=NULL;
  636.     ASCII=neu;
  637.     TXL = TXL->NextZeile;
  638.       } else ASCII->Next=NULL;
  639.     }
  640.   }
  641.   strcpy(ED->name,"AKTUELL.TXL");
  642. }
  643.  
  644. void ClearEditor(EditorData *ED)
  645. {
  646.   ASCIIZEILE *akt,*next;
  647.  
  648.   akt=ED->First;
  649.   while (akt)  
  650.   {
  651.     if (akt->Zeile)
  652.       free(akt->Zeile);
  653.     next=akt->Next;
  654.     free(akt);
  655.     akt=next; 
  656.   }
  657. }
  658.  
  659. int LoadFile(char *name, EditorData *ED)
  660. {
  661.   PRGZEILE *TXL;
  662.   ASCIIZEILE *ASCII,*neu;
  663.   FILE *f;
  664.   char s[300];
  665.  
  666.   ASCII=malloc(sizeof(*ASCII));
  667.   ASCII->Next=NULL; 
  668.   ASCII->Prev=NULL;
  669.   ASCII->Zeile=NULL;
  670.   ED->First=ED->Act=ED->FirstView=ASCII;
  671.  
  672.   if ((f=fopen(name,"rt"))==NULL)
  673.   {
  674.     strcpy(ED->name,name);
  675.     return(OK);
  676.   }
  677.  
  678.   while (!feof(f) && ((fgets(s,300,f))!=NULL))
  679.   {
  680.     if (s[strlen(s)-1]=='\n')
  681.       s[strlen(s)-1]=0;    /** "\n" löschen **/
  682.     if ((ASCII->Zeile=malloc(strlen(s)+1))==NULL)
  683.     {
  684.       ClearEditor(ED);
  685.       Message(" Nicht genügend Speicherplatz. ");
  686.       return(FALSE);
  687.     }
  688.  
  689.     strcpy(ASCII->Zeile,s);
  690.     if (!feof(f))
  691.     {
  692.       if ((neu=malloc(sizeof(*neu)))==FALSE)
  693.       {
  694.     ClearEditor(ED);
  695.     Message(" Nicht genügend Speicherplatz. ");
  696.     return(FALSE);
  697.       }
  698.       ASCII->Next=neu;
  699.       neu->Prev=ASCII;
  700.       neu->Zeile=NULL;
  701.       neu->Next=NULL;
  702.       ASCII=neu;
  703.     }
  704.     else 
  705.       ASCII->Next=NULL; 
  706.   }
  707.   fclose(f);
  708.   strcpy(ED->name,name);
  709.   return(OK);
  710. }
  711.  
  712. EditorData Editor[10];  /** Editoren 0 bis 9 **/
  713.  
  714. int cinitedit(void)  /** initialisiert einen Editor im obersten Fenster **/
  715. {
  716.   long num; 
  717.   char *loadname;
  718.  
  719.   if (!GetIntegerParam(&num)) 
  720.     { serror(" Editornummer erwartet. "); return(FALSE); }
  721.  
  722.   Editor[num].cx=Editor[num].cy=1;  Editor[num].ay=Editor[num].ax=1;
  723.   Editor[num].insert=1; Editor[num].BlockBegin=Editor[num].BlockEnd=NULL;
  724.   Editor[num].m1x=Editor[num].m2x=Editor[num].m2y=Editor[num].m1y=0;
  725.  
  726.   if (GetStringParam(&loadname)) 
  727.   {  
  728.      if (LoadFile(loadname,&Editor[num])==FALSE)
  729.      { 
  730.        CloseFirstWindow();
  731.        serror(" Fehler beim Laden der Datei! "); 
  732.        return(FALSE); 
  733.      }
  734.      Editor[num].TXL=0; 
  735.   }
  736.   else 
  737.   {  GetTXLProg(&Editor[num]); Editor[num].TXL=1; }
  738.  
  739.   ShowEditor(&Editor[num]);
  740.   return(OK);
  741. }
  742.  
  743. int cendedit(void)   /** Schließt Editor **/
  744.              /** Der Editor muß im obersten Fenster sein. **/
  745. {
  746.   long num; 
  747.  
  748.   if (!GetIntegerParam(&num))  
  749.     { serror(" Editornummer erwartet. "); return(FALSE); }
  750.  
  751.   CloseFirstWindow();
  752.   if (Editor[num].TXL) 
  753.   {  
  754.     SaveFile(Editor[num].name,&Editor[num]);
  755.     SetFileName(Editor[num].name); 
  756.     ReadProg(); 
  757.   }
  758.   ClearEditor(&Editor[num]);
  759.   return(OK);
  760. }
  761.  
  762. int cshoweditor(void)
  763. {
  764.   long num; 
  765.  
  766.   if (!GetIntegerParam(&num))  
  767.     { serror(" Editornummer erwartet. "); return(FALSE); }
  768.  
  769.   ShowEditor(&Editor[num]);
  770.   return(OK);
  771. }
  772.  
  773. int ceditorproc(void) /** Tastatureingabe **/
  774. {
  775.   long num; 
  776.  
  777.   if (!GetIntegerParam(&num))  
  778.     { serror(" Editornummer erwartet. "); return(FALSE); }
  779.  
  780.   do
  781.   {
  782.     ShowEditor(&Editor[num]);
  783.     EditorProc(&Editor[num]);
  784.   } while ((gosub_position) && dogosub(gosub_position));
  785.  
  786.   return(OK);
  787. }
  788.  
  789. int cneuedit(void)
  790. {
  791.   EditorData DATA;
  792.   char CX,CY,*loadname;
  793.   int TXL;     /** wird TXL-Programm bearbeitet? ***/
  794.  
  795.   CX=wherex(); CY=wherey();
  796.   OpenWindow(4,3,76,23,36,33,66,33);
  797.  
  798.   DATA.cx=DATA.cy=1;  DATA.ay=DATA.ax=1;
  799.   DATA.insert=1;
  800.   DATA.BlockBegin=DATA.BlockEnd=NULL;
  801.   DATA.m1x=DATA.m2x=DATA.m2y=DATA.m1y=0;
  802.  
  803.   if (GetStringParam(&loadname)) 
  804.   {  
  805.     if (LoadFile(loadname,&DATA)==FALSE)
  806.     { 
  807.       CloseFirstWindow();
  808.       serror(" Fehler beim Laden der Datei! "); 
  809.       return(FALSE); 
  810.     }
  811.     TXL=0; 
  812.   }
  813.   else 
  814.   {  GetTXLProg(&DATA); TXL=1; }
  815.  
  816.   do
  817.   {
  818.     ShowEditor(&DATA);
  819.     EditorProc(&DATA);
  820.   } while ((gosub_position) && dogosub(gosub_position));
  821.  
  822.   CloseFirstWindow();
  823.   gotoxy(CX,CY);
  824.   if (ppc)
  825.   {
  826.     /*** in TXL-Programm umwandeln ***/
  827.     TransformFile(DATA.name,"AKTUELL.TXL");
  828.     SetFileName("AKTUELL.TXL"); ReadProg(); /** Einlesen in Programmspeicher **/
  829.   }
  830.   else if (TXL)  
  831.   { 
  832.     /** automat. Speichern, wenn aktuelles TXL-Prog. bearbeitet wird **/
  833.     SaveFile(DATA.name,&DATA);
  834.     SetFileName(DATA.name); ReadProg(); /** Einlesen in Programmspeicher **/
  835.   }
  836.   ClearEditor(&DATA);
  837.  
  838.   return(OK);
  839. }
  840.  
  841. int csetfkey(void)     
  842. {
  843.   long taste,zeile;
  844.  
  845.   if (!GetIntegerParam(&taste)) 
  846.     { serror(" Funktionstastennummer erwartet! "); return(FALSE); }
  847.   if (!GetIntegerParam(&zeile)) 
  848.     { serror(" Zeilennummer erwartet! "); return(FALSE); }
  849.  
  850.   if ((taste<51) && (taste>0))
  851.     fkeys[taste-1]=zeile;
  852.   return(OK);
  853. }
  854.  
  855. int csetlinebuf(void) 
  856. {
  857.   Scan();
  858.   strcpy(workline,ScanBuffer);
  859.  
  860.   return(OK);
  861. }
  862.  
  863. int cinsertstring(void)
  864. {
  865.   long EditorNummer;
  866.   char *strp;
  867.  
  868.   if (GetIntegerParam(&EditorNummer) &&
  869.       GetStringParam(&strp) )
  870.   {
  871.     LoadWorkLine(&Editor[EditorNummer]);
  872.     EditorInsert(&Editor[EditorNummer],strp,300);
  873.     StoreWorkLine(&Editor[EditorNummer]);
  874.     return(OK);
  875.   } 
  876.   serror(" Parameterfehler bei InsertString! ");
  877.   return(FALSE);
  878. }
  879.  
  880. int cedfunction(void)
  881. {
  882.   long EditorNr,FuncNr,Char;
  883.  
  884.   if ((GetIntegerParam(&EditorNr)==OK) && 
  885.       (GetIntegerParam(&FuncNr)==OK) &&
  886.       (GetIntegerParam(&Char)==OK))
  887.   {
  888.     EditorAction(&Editor[EditorNr],FuncNr,Char);
  889.     return(OK);
  890.   } 
  891.   serror(" Parameterfehler bei EditorFunktion! ");
  892.   return(FALSE);
  893. }
  894.  
  895. int cGetEdString(void)
  896. {
  897.   char *strp;
  898.   long EditorNummer;
  899.  
  900.   if (GetIntegerParam(&EditorNummer) && 
  901.       GetStrVarParam(&strp))
  902.   {
  903.     LoadWorkLine(&Editor[EditorNummer]);
  904.     SetVarStr(ScanBuffer,workline);
  905.     StoreWorkLine(&Editor[EditorNummer]);
  906.     return(OK);
  907.   } else 
  908.   { 
  909.     serror(" Nur Stringvariable bei GetEditorString erlaubt.");
  910.     return(FALSE);
  911.   }
  912. }
  913.  
  914. /* Parameter in TXL : Stringvariable, Editornummer (für Cursorposition) */
  915. int cGetEdWord(void)
  916. {
  917.   char *strp,*namep,work2[300];
  918.   long EditorNummer;
  919.  
  920.   if (GetIntegerParam(&EditorNummer) && 
  921.       GetVarNameParam(&namep) )
  922.   {
  923.     LoadWorkLine(&Editor[EditorNummer]);
  924.     strcpy(work2,&workline[Editor[EditorNummer].cx-1]);
  925.     StoreWorkLine(&Editor[EditorNummer]);
  926.     strp=work2;
  927.     while (isalpha(*strp))
  928.       strp++;
  929.     *strp=0;
  930.     SetVarStr(namep,work2);
  931.   } else 
  932.   { 
  933.     serror(" Parameterfehler bei GetEditorWord.");
  934.     return(FALSE);
  935.   }
  936.   return(OK);
  937. }
  938.