home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / st_txl / ibefehle.c < prev    next >
Encoding:
C/C++ Source or Header  |  1985-07-18  |  11.0 KB  |  461 lines
  1. /* ibefehle.c
  2. In diesem File befinden sich die Befehle des
  3. Interpreters.
  4. (c) 1990 Michael Beising & TOOLBOX
  5. */
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include "interp.h"
  11.  
  12. /* Benötigte Globalvariablen */
  13. extern    PRGZEILE    *FirstLine;        /* erste Interpreterzeile */
  14. extern    PRGZEILE    *ActLine;        /* aktuelle interpretierte Zeile */
  15. extern    char        *LinePos;        /* Zeilenposition der aktuellen Zeile*/
  16. extern    int        Steuer;                /* der aufrufenden Routine wird mit-    */
  17.                                     /* geteilt, um was es sich handelt.         */
  18. extern    char    ScanBuffer[ZEILENLAENGE]; /* Ergebnisbuffer des Scanners */
  19. extern  int     traceFlag;          /* Trace ja/nein*/
  20. extern  TOKBEF  TokBefDesc[];
  21.  
  22. /* cset() Zuweisen eines Wertes einer Variablen */
  23. int    
  24. cset(void)
  25. {
  26. VAR        Variable;
  27.  
  28.     Scan ();    /* Name der Variablen lesen */
  29.     if (Steuer == ALPHA) {
  30.       strcpy (Variable.VarName,ScanBuffer);        /* Variablennamen setzen */
  31.       Scan ();
  32.       if ((Steuer == SONDER) && (*ScanBuffer == '=')) {
  33.         SetVar (&Variable);
  34.         
  35.       }
  36.       else
  37.         serror ("Zuweisung erwartet! ");
  38.     }
  39.     else
  40.       serror ("Variablenname erwartet! ");
  41.  
  42. return (OK);
  43. }
  44.  
  45. /* cdruck () Ausgabe von Werten auf dem Bildschirm
  46.  
  47.    dies können in der neuen Version auch Ausdrücke sein,
  48.    diese werden dann zuerst berechnet, und das Ergebnis gedruckt
  49.    
  50. */
  51. int
  52. cdruck(void)
  53. {
  54. VAR        Wert;
  55.  
  56.    if ( CalcExpression( &Wert ) == OK ){
  57.      switch ( Wert.VarType ) {
  58.        case     STRING:
  59.           printf ( "%s",Wert.VarWert.variable.text );
  60.        break;
  61.        case     ZIFFER:
  62.           printf ( "%d",Wert.VarWert.variable.integer );
  63.        break;
  64.        case  FLONUM :
  65.         printf( "%f",Wert.VarWert.variable.Flotype );
  66.        break;
  67.        default :
  68.         fatal_error("zu druckender Typ ist unbekannt\n" );
  69.        break;
  70.      }
  71.    }
  72.    else
  73.      if ( Steuer == EOLCHAR ) printf("\n");
  74.      else serror( "ungültiger Ausdruck" );
  75.  
  76. return (OK);
  77. }
  78.  
  79. /* cgoto () Fortführen des Programms an einer anderen Stelle */
  80. extern    int    GetNextLine;        /* Nächste Zeile ausführen */
  81.  
  82.  
  83. int ccommands()
  84. {
  85. int i=0, x;
  86.  printf("\n\nNachfolgende Befehle sind unter dem TXL-Interpreter verfügbar :\n");
  87.  printf("---------------------------------------------------------------\n");
  88.  while( (char *)TokBefDesc[i].Befehl != NULL )
  89.       {
  90.        x++;
  91.        if (x >4)
  92.           {
  93.            printf("\n");
  94.            x=0;
  95.           }
  96.        printf("%s\t",(char *)TokBefDesc[i++].Befehl);
  97.       }
  98.  printf("\n\n");
  99. return(OK);
  100. }
  101.  
  102.  
  103. int
  104. cgoto(void)
  105. {
  106. register    int    error,LineNumber;
  107.  
  108.     Scan ();
  109.             /* Ist es eine Ziffer und gibt es ein Programm dazu? */
  110.     if ((Steuer == ZIFFER) && FirstLine)    {
  111.       LineNumber = atoi (ScanBuffer);    /* Calculate Jump Line */
  112.       if (FindInsPos (LineNumber,&ActLine)) {
  113.         ActLine = ActLine->PrevZeile;
  114.         GetNextLine = FALSE;        /* Zeile ist aktuelle Zeile */
  115.         return (OK);
  116.       }
  117.       else {
  118.         printf ("\n Sprungziel nicht gefunden! ");
  119.         return (FALSE);                /* Sprungziel nicht gefunden */
  120.       }
  121.     }
  122.     else
  123.       printf ("\n Kein Programm im Speicher! ");
  124.  
  125. return (OK);
  126. }
  127.  
  128.  
  129. /* cif () bedingte Ausführung von Befehlen */
  130. int
  131. cif()
  132. {
  133. int    result = OK;
  134.  
  135.         /* Wenn Bedingung nicht erfüllt, dann übernächste Zeile */
  136.     if (CmpVar ()) {
  137.       ActLine = ActLine->NextZeile; /* Dann-Zeile auswählen */
  138.       LinePos = ActLine->Zeile;        /* Zeilenanfang */
  139.       result = InterpLine ();        /* Dann-Zweig ausführen */
  140.       ActLine = ActLine->NextZeile;
  141.     }
  142.     else
  143.       if (ActLine->NextZeile)
  144.         ActLine = ActLine->NextZeile;    /* Sonst-Zweig ausführen */
  145.       else
  146.         serror (" Kein Sonst-Zweig vorhanden! ");
  147.     
  148. return (result);
  149. }
  150.  
  151.  
  152. int
  153. crun ()
  154. {
  155.  
  156.     if (FirstLine) {
  157.       ActLine = FirstLine;
  158.       /* alle Zeilen bis zur letzten oder bis Ende-Befehl ausführen */
  159.       DoProgram ();
  160.     }
  161.     else
  162.       printf ("\n Kein Programm im Speicher! \n");
  163.  
  164. return (OK);
  165. }
  166.  
  167. /* cende () ende des Interpreterprogramms */
  168. extern PRGZEILE *FirstLine;
  169.  
  170. int
  171. cende ()
  172. {
  173.  
  174.     printf ("\n Normales Programmende... \n");
  175.     
  176. return (FALSE);
  177. }
  178.  
  179.  
  180. /*    cexit: Ende des Interpreters */
  181.  
  182. int
  183. cexit ()
  184. {
  185.   printf ("\n Interpreter verlassen... \n");
  186.   exit (0);
  187.  
  188. return (OK);
  189. }
  190.  
  191. int
  192. cmerke ()
  193. {
  194.  
  195. return (OK);
  196. }
  197.  
  198. /* clist: Auflisten des aktuellen Programms
  199. */
  200.  
  201. int
  202. clist ()
  203. {
  204. PRGZEILE    *FindZeile;
  205. char        *Line;
  206.  
  207.     
  208.          /* Wenn es eine erste Zeile gibt, setze Zeiger darauf */
  209.     if ((FindZeile = FirstLine) != NULL) {
  210.         printf ("\n    ### Aktuelles Programm auflisten: ###\n");
  211.         while ( FindZeile) {
  212.           ShowLine (FindZeile);
  213.           FindZeile = FindZeile->NextZeile;
  214.         }
  215.         printf ("\n    ### Ende des aktuellen Programms! ###\n");
  216.     }
  217.     
  218. return (TRUE);
  219. }
  220.  
  221. /*    cload
  222.     Laden eines Interpreterprogramms in den Hauptspeicher.
  223. */
  224.  
  225. int
  226. cload ()
  227. {
  228.  
  229.     Scan();        /* Filename einlesen */
  230.     if (Steuer == STRING) {
  231.       SetFileName (ScanBuffer);    /* Filename setzen */
  232.       ReadProg ();                /* Programm einlesen */
  233.     }
  234.     else
  235.       serror ("Kein Filename angegeben! ");
  236.  
  237. return (OK);    
  238. }
  239.  
  240. /*    csave
  241.     Speichern eines Interpreterprogramms in den Hauptspeicher.
  242. */
  243.  
  244. int
  245. csave ()
  246. {
  247.  
  248.     Scan();        /* Filename einlesen */
  249.     if (Steuer == STRING) {
  250.       SetFileName (ScanBuffer);    /* Filename setzen */
  251.       WriteProg ();                /* Programm einlesen */
  252.     }
  253.     else
  254.       serror ("Kein Filename angegeben! ");
  255. return (OK);
  256. }
  257.  
  258. /*    cneu
  259.     Aktuelles Programm aus dem Speicher löschen.
  260. */
  261.  
  262. int
  263. cneu ()
  264. {
  265.     ClearProg ();            /* Programm löschen */
  266.     
  267. return (OK);
  268. }
  269.  
  270. /* ctrcon   Trace einschalten, d.h. Einzelschrittmodus */
  271.  
  272. int ctrcon()
  273. {
  274.  printf( "\nWachhund liegt auf der Lauer ( Hilfe mit <H> )\n" );
  275.  traceFlag = TRUE;
  276.  return ( OK );
  277. }
  278.  
  279. /* ctrcoff  Trace ausschalten */
  280.  
  281. int ctrcoff()
  282. {
  283.  traceFlag = FALSE;
  284.  return ( OK );
  285. }
  286.  
  287. /* cwdog : den Tracer für EINE Kontrolle aufrufen
  288.            es wird nicht in den Einzelschrittmodus geschaltet
  289. */
  290.  
  291. int cwdog()
  292. {
  293.   printf( "wuff wuff\n" );
  294.   printf( "<H> bringt Hilfe\n" );
  295.   Trace();
  296.   return( OK );
  297. }
  298.  
  299. /* creadvar : lies einen Wert ein, und weist ihn einer Variablen zu
  300.               es können auch usdrücke angegeben werden, die dann
  301.               zuerst berechnet werden
  302.               Strings müssen in " eingeschlossen sein
  303. */
  304.  
  305. int creadvar()
  306. {
  307. VAR   NewVar;
  308. char  wert[ZEILENLAENGE];
  309.  
  310.   Scan();
  311.   if ( Steuer != ALPHA ){
  312.     serror( "<lese> erwartet einen Variablenbezeichner" );
  313.     return( FALSE );
  314.   }
  315.  
  316.   strcpy(NewVar.VarName,ScanBuffer );
  317.   putchar( '?' ); gets( wert );
  318.   if (!strchr(wert,';')) strcat (wert,";");  /*wenn kein ; dann anf.*/
  319.   LinePos = wert; SkipChar();
  320.   SetVar( &NewVar );
  321.   
  322.   return( OK );
  323. }
  324.  
  325. /* ccopy : 
  326.    Syntax : kopiere Stringausdruck "," Stringvariable "," num. Ausdruck
  327.    
  328.    kopiert Stringausdruck ab der durch den numerischen Ausdruck
  329.    bestimmten Position in die Stringvariable
  330.    
  331.    Bsp.  kopiere "hey",s,2
  332.          kopiert "hey" ab Position 2 in s
  333. */
  334.    
  335. int ccopy()
  336. {
  337. VAR     src,          /* zu kopierender Teil */
  338.         *dst;         /* Original, hier wird einkopiert */
  339. size_t  dlen,newlen;
  340. char    *s,*d;        /* Hilfzeiger zum kopieren */
  341. long    abda;         /* ab  da einkopieren */
  342.  
  343.   src.VarWert.variable.text = NULL;
  344.   CalcExpression( &src );
  345.   if ( src.VarType != STRING ){
  346.     serror( "String erwartet als 1.P." ); return( FALSE );
  347.   }
  348.   if ( !TestComma()) return ( FALSE );
  349.   
  350.   if ( !GetStringVar( &dst )) return ( FALSE );
  351.   Scan(); /* Komma lesen */
  352.   if ( !TestComma()) return ( FALSE );
  353.   if ( ! GetLong ( &abda )) return ( FALSE );
  354.   
  355.   dlen = strlen( dst->VarWert.variable.text ); /* Länge des Orignals */
  356.   newlen = abda + strlen(src.VarWert.variable.text );
  357.   if ( newlen > dlen ) 
  358.     /* mehr Speicher anfordern, wenn String durch kopieren länger */
  359.     dst->VarWert.variable.text = realloc( dst->VarWert.variable.text,newlen );
  360.  
  361.   s = src.VarWert.variable.text;          /* dies hier ... */
  362.   d = dst->VarWert.variable.text + abda;  /* ... nach da ... */ 
  363.   
  364.   while ( *s != '\0' ) *d++ = *s++;  /* ... kopieren */
  365.   if ( dlen < newlen ) *d ='\0';     /* wenn neuer String länger,
  366.                                         '\0' anhängen */
  367.   return( OK );
  368. }
  369.  
  370. /* cins : 
  371.    Syntax : einfuegen Stringausdruck "," Stringvariable "," num. Ausdruck
  372.    
  373.    fügt Stringausdruck ab der durch den numerischen Ausdruck
  374.    bestimmten Position in die Stringvariable ein
  375.    
  376.    Bsp. einfuegen "hallo",s,3
  377.         fügt "hallo" an Position 3 in s ein
  378. */
  379.  
  380. int cins()
  381. {
  382. VAR     src,        /* einzufügender Teil */
  383.         *dst;       /* Original */
  384. size_t  slen,dlen;
  385. char    *s,*d,*ins; /* Hilfszeiger zum Platz schaffen u. kopieren */
  386. long    abda;        /* ab hier einfügen */
  387.  
  388.   src.VarWert.variable.text = NULL;
  389.   CalcExpression( &src );
  390.   if ( src.VarType != STRING ){
  391.     serror( "String erwartet als 1.P." ); return( FALSE );
  392.   }
  393.   if ( !TestComma()){ printf(" nach P1\n" ); return( FALSE ); }
  394.   if ( !GetStringVar ( &dst )) return ( FALSE );
  395.   Scan(); /* Komma lesen */
  396.   if ( !TestComma()){ printf( "nach P2\n" ); return ( FALSE ); }
  397.   if ( ! GetLong( &abda )) return ( FALSE );
  398.   
  399.   dlen = strlen( dst->VarWert.variable.text );
  400.   slen = strlen(src.VarWert.variable.text );
  401.  
  402.   /* der String wird länger => mehr Speicher */
  403.   dst->VarWert.variable.text = realloc( dst->VarWert.variable.text,slen+dlen );
  404.  
  405.   s = dst->VarWert.variable.text + ( dlen - 1 );
  406.   d = dst->VarWert.variable.text + ( dlen + slen );
  407.   *d = '\0'; d--;
  408.   
  409.   /* bis hier Platz schaffen */
  410.   ins = dst->VarWert.variable.text + abda;
  411.   
  412.   while ( s >= ins ) *d-- = *s--;   /* nach rechts schieben */
  413.   
  414.   s = src.VarWert.variable.text;       /* das hier einsetzen */
  415.   while ( *s != '\0' ) *ins++ = *s++; /* und endlich einsetzen */
  416.  
  417.   return( OK );
  418. }
  419.  
  420. /* cdel :
  421.    Syntax : loesche Stringvariable "," 1. num. Ausdruck "," 2. num. Ausdruck
  422.    
  423.    löscht die durch den 1. num. Ausdruck bestimmte Anzahl von
  424.    Zeichen ab der durch den 2. Ausdruck bestimmten Position in
  425.    der Stringvariablen
  426.    
  427.    Bsp. loesche s,laenge(s)-1,1
  428.         löscht alle Zeichen ab dem ersten
  429. */
  430.  
  431. int cdel()
  432. {
  433. VAR      *str;     /* in diesem String wird gelöscht */
  434. long     abda,     /* ab da wird gelöscht */
  435.          schieb;   /* löschen durch linksschieben der Zeichen,
  436.                       die hinter dem zu löschenden Teil stehen */
  437. char     *s,*d;    /* Hilfszeiger */
  438. size_t   len;      /* ursprüngliche Länge */
  439.  
  440.   if ( !GetStringVar ( &str )) return ( FALSE );
  441.   len = strlen( str->VarWert.variable.text );
  442.   Scan(); /* Komma lesen */
  443.   if ( !TestComma()) return ( FALSE );
  444.   if ( !GetLong( &schieb )) return ( FALSE ); /* 2.P. */
  445.   if ( !TestComma()) return ( FALSE );
  446.   if ( !GetLong( &abda )) return ( FALSE ); /* 3.P. */
  447.   
  448.   if ( abda >= len ) return(OK);  /* abda hinter Stringende */
  449.   schieb += abda;                 /* von hier an schieben */
  450.   if ( schieb > len ) schieb = len; /* aber nicht mehr als da sind */
  451.   
  452.   d = str->VarWert.variable.text;
  453.   s = d + schieb;  d += abda;
  454.   while (( *d++ = *s++ ) != '\0' ); /* schieb schieb hurra */
  455.   *s = '\0';                        /* neues Ende */
  456.   
  457.   return( OK );
  458. }/* cdel */
  459.  
  460. /* Ende des Files IBEFEHLE.C */
  461.