home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / dos_txl / source / util2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-16  |  5.8 KB  |  278 lines
  1. /***
  2.   Funktionen zur Parameterbearbeitung
  3.   und in TXL verwendbar :
  4.   Unterprogramme und Zufallszahlen 
  5.  
  6.   (c) 1991 Elmar Warken
  7. ***/
  8.  
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <alloc.h>
  13. #include <time.h>
  14. #include "interp.h"
  15.  
  16. /* Benötigte Globalvariablen */
  17. extern    PRGZEILE    *FirstLine;        /* erste Interpreterzeile */
  18. extern    PRGZEILE    *ActLine;        /* aktuelle interpretierte Zeile */
  19. extern    char        *LinePos;        /* Zeilenposition der aktuellen Zeile*/
  20. extern    int        Steuer;            /* der aufrufenden Routine wird mit-    */
  21. extern    VAR        *FirstVar;        /* Zeiger auf die erste Variable */
  22.                                     /* geteilt, um was es sich handelt.         */
  23. extern    char    ScanBuffer[ZEILENLAENGE]; /* Ergebnisbuffer des Scanners */
  24. extern  int     IntError;
  25. extern  int     GetNextLine;
  26. int ebene=0;
  27.  
  28. /**** wie DoProgram mit zusätzlicher Abbruchbedingung
  29.       ( "blockend" erreicht )                
  30. ****/
  31.  
  32. int cbegin(void)
  33. {      
  34.   register int error=TRUE;
  35.   int ausstieg=ebene;
  36.   ebene++;
  37.   ActLine=ActLine->NextZeile;
  38.   do {
  39.     LinePos = ActLine->Zeile; 
  40.     GetNextLine=TRUE;
  41.     error = InterpLine();
  42.     if (GetNextLine)
  43.       ActLine = ActLine->NextZeile;
  44.     if (IntError) break;
  45.   }
  46.   while ((ebene>ausstieg) && ActLine && error && (!IntError));
  47.  
  48.   return(OK);
  49. }
  50.  
  51. int cend(void)
  52. {
  53.   ebene--;
  54.  
  55.   return(OK);
  56. }
  57.  
  58. /*** wie goto, springt aber nach Ausführung eines Befehls
  59.      wieder zurück, dieser Befehl kann aber ein
  60.      ganzer Block sein. Kann nicht nur aus TXL,
  61.      sondern auch aus anderen Funktionen aufgerufen werden. ***/
  62.  
  63. int dogosub(int LineNumber)
  64. {
  65.   PRGZEILE *RETURN;
  66.  
  67.   Scan ();
  68.  
  69.   RETURN=ActLine;
  70.   if (FindInsPos (LineNumber,&ActLine)) {
  71.     LinePos=ActLine->Zeile;
  72.     InterpLine();
  73.     ActLine = RETURN;      /*** GetNextLine=TRUE ***/
  74.     return (OK);
  75.   }
  76.   else {
  77.     printf ("\n Sprungziel nicht gefunden! ");
  78.     return (FALSE);            
  79.   }
  80. }
  81.  
  82. int cgosub(void)
  83. {
  84.   long LineNumber;
  85.   PRGZEILE *RETURN;
  86.   int error;
  87.  
  88.   if (GetIntegerParam(&LineNumber) && FirstLine)    
  89.     error=dogosub(LineNumber);
  90.   else
  91.     printf ("\n Fehler bei GOSUB : kein Programm oder Parameterfehler! ");
  92.  
  93.   return (error);
  94. }
  95.  
  96. int crandom(void)
  97. {
  98.   char *VarName;
  99.   long num;
  100.  
  101.   if (GetIntegerParam(&num) && GetVarNameParam(&VarName))
  102.   {
  103.     SetVarInt(VarName,random(num));
  104.     return(OK);
  105.   }
  106.   serror(" in 'random'.");
  107.   return(FALSE);
  108. }
  109.  
  110. int crandomize(void)
  111. {
  112.   randomize();
  113.   return(OK);
  114. }
  115.  
  116. void SetVarInt(char *name,long wert)
  117. {
  118.   VAR *Variable;
  119.  
  120.   if ((Variable = IsVariable (name)) == NULL) 
  121.   {
  122.     DefVarInt(name,wert);
  123.     Variable = IsVariable (name);
  124.   }
  125.   else
  126.   { 
  127.     if (Variable->VarType==FIXNUM) 
  128.       Variable->VarWert.variable.integer=wert;
  129.     else 
  130.       serror("Variable hat falschen Typ! ");
  131.   }
  132. }
  133.  
  134. int DefVarInt (char *name, long val)
  135. {
  136.   VAR *Variable;
  137.  
  138.   if ((Variable = IsVariable (name)) == NULL) {
  139.     if ((Variable = malloc(sizeof (VAR))) == NULL) {
  140.       printf ("\n Kein Speicherplatz mehr für die Variable! ");
  141.       return(FALSE);
  142.     }
  143.  
  144.     strcpy (Variable->VarName,name);    
  145.     Variable->VarType = FIXNUM;            
  146.     Variable->NextVar = FirstVar;
  147.     Variable->VarWert.variable.integer=val;
  148.     FirstVar = Variable;        
  149.     return(OK);
  150.   }
  151.   return(FALSE);
  152. }
  153.  
  154. /* Nächster Parameter - Variable oder Konstante wird in "wert" zurückgegeben */
  155. /* Funktionsergebnis : OK oder FALSE */
  156. int GetIntegerParam(long *wert)  
  157. {
  158.   VAR *Variable;
  159.  
  160.   if (Scan()!=SCANOK) return(FALSE);
  161.  
  162.   if (Steuer==ZIFFER) 
  163.   {
  164.     *wert=atol(ScanBuffer);
  165.     return(OK);
  166.   }
  167.   if ((Variable = IsVariable (ScanBuffer)) != NULL) 
  168.   { 
  169.     if (Variable->VarType==FIXNUM) 
  170.       *wert=Variable->VarWert.variable.integer;
  171.     else 
  172.       return(FALSE);
  173.     return(OK);
  174.   }
  175.   return(FALSE);  
  176. }
  177.  
  178. /* Nächster Parameter - Variable oder Konstante wird in "wert" zurückgegeben */
  179. /* Funktionsergebnis : OK oder FALSE */
  180. int GetStringParam(char **wert)  
  181. {
  182.   VAR *Variable;
  183.  
  184.   if (Scan()!=SCANOK) return(FALSE);
  185.  
  186.   if (Steuer==STRING) 
  187.   {
  188.     *wert=ScanBuffer;
  189.     return(OK);
  190.   }
  191.   if ((Variable = IsVariable (ScanBuffer)) != NULL) 
  192.   { 
  193.     if (Variable->VarType==STRING) 
  194.       *wert=Variable->VarWert.variable.text;
  195.     else 
  196.       return(FALSE);
  197.     return(OK);
  198.   }
  199.   return(FALSE);  
  200. }
  201.  
  202. /* Nächster Parameter - Zahlenvariable */
  203. /* Funktionsergebnis : OK oder FALSE   */
  204. /* keine Fehlermeldung, wenn nicht OK, */
  205. /* da es sich um einen optionalen      */    
  206. /* Parameter handeln könnte            */
  207.     
  208. int GetNumbVarParam(long **wert)  
  209. {
  210.   VAR *Variable;
  211.  
  212.   if (Scan()!=SCANOK) return(FALSE);
  213.  
  214.   if (Steuer==ALPHA) 
  215.   {  
  216.     if ((Variable = IsVariable (ScanBuffer)) == NULL)
  217.     {  DefVarInt (ScanBuffer,0); 
  218.        Variable = IsVariable (ScanBuffer); }
  219.     if (Variable->VarType==FIXNUM) 
  220.       *wert=&Variable->VarWert.variable.integer;
  221.     else 
  222.       return(FALSE);
  223.     return(OK);
  224.   }
  225.   return(FALSE);  
  226. }
  227.  
  228. /* Nächster Parameter - Stringvariable */
  229. /* Funktionsergebnis : OK oder FALSE */
  230.  
  231. int GetStrVarParam(char **wert)  
  232. {
  233.   VAR *Variable;
  234.  
  235.   if (Scan()!=SCANOK) return(FALSE);
  236.  
  237.   if (Steuer==ALPHA) 
  238.   {
  239.     if ((Variable = IsVariable (ScanBuffer)) == NULL) 
  240.     {
  241.       DefVarStr(ScanBuffer,100);
  242.       Variable = IsVariable (ScanBuffer);
  243.     }
  244.     if (Variable->VarType==STRING) 
  245.       *wert=Variable->VarWert.variable.text;
  246.     else 
  247.       return(FALSE);
  248.     return(OK);
  249.   }
  250.   return(FALSE);  
  251. }
  252.  
  253.  
  254. /* Nächster Parameter - Variablenname */
  255. /* Funktionsergebnis : OK oder FALSE */
  256.  
  257. int GetVarNameParam(char **name)  
  258. {
  259.   VAR *Variable;
  260.  
  261.   if (Scan()!=SCANOK) return(FALSE);
  262.  
  263.   if (Steuer==ALPHA)  
  264.   { 
  265.     *name=ScanBuffer;
  266.     return(OK);
  267.   }
  268.   return(FALSE);  
  269. }
  270.  
  271. int GetSonderZeichen(char c)
  272. {
  273.   if (Scan () != SCANOK) return(FALSE);
  274.  
  275.   if ((Steuer == SONDER) && (*ScanBuffer == c)) 
  276.     return(OK);
  277.   else return(FALSE);
  278. }