home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 455.lha / ParM / Parse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-10  |  5.7 KB  |  293 lines
  1. /*
  2.  *    Parse.c - Copyright © 1990 by S.R. & P.C.
  3.  *
  4.  *    Created:    16 Jun 1990
  5.  *    Modified:    06 Jul 1990
  6.  *
  7.  *    Make>> make
  8.  */
  9.  
  10. /*
  11. #define DO_ARP_COPIES
  12. #include <libraries/arpbase.h>
  13. #include <functions.h>
  14. #include <exec/memory.h>
  15. #include <stdio.h>
  16. */
  17.  
  18. #include <dos_functions.h>
  19. #include <arpdos_pragmas.h>
  20.  
  21. #include "ParM.h"
  22.  
  23. #define SYNTAX(msg) { Err(msg); return FALSE; }
  24.  
  25. /*    tokens  */
  26.  
  27. #define CMDWIN        1
  28. #define RB            2
  29. #define WB            3    
  30. #define CLI            4    
  31. #define PRI            5
  32. #define STACK        6
  33. #define MENU        7
  34. #define SUBMENU        8
  35. #define ENDSUBMENU    9
  36. #define ITEM        10
  37. #define COLOR        11
  38. #define STR            12    /* not a keyword! */
  39.  
  40. #define MAX_KEYWORD 11
  41.  
  42.  
  43. /*****                external functions                    *****/
  44.  
  45. extern void Warn(const char *);
  46. extern void AddMenu(char *);
  47. extern void AddSubMenu(char *);
  48. extern void AddEntry(char *, char *, char *, char*, char, char, long, short);
  49. extern void EndSubMenu(void);
  50. extern void FreeMenus(void);
  51. extern void CleanUp(void);
  52.  
  53.  
  54. /*****                 global functions                    *****/
  55.  
  56. BOOL ParseMenus( void );
  57.  
  58.  
  59. /*****                 global variables                    *****/
  60.  
  61. extern struct Window *Win;
  62. extern char CurCfg[];
  63. extern char CmdWindow[];
  64. extern UBYTE menu_pen;
  65.  
  66.  
  67. /*****                 local variables                    *****/
  68.  
  69. static char *KeyWordTab[] = {
  70.     NULL,        /* possible implementation of an END keyword */
  71.     "CMDWIN",
  72.     "RB",
  73.     "WB",
  74.     "CLI",
  75.     "PRI",
  76.     "STACK",
  77.     "MENU",
  78.     "SUBMENU",
  79.     "ENDSUBMENU",
  80.     "ITEM",
  81.     "COLOR"
  82. };
  83.  
  84. /*    status  */
  85.  
  86. #define STAT_BEGIN        0
  87. #define STAT_MENU        1
  88. #define STAT_SUBMENU    2
  89. #define STAT_ITEM        4
  90.  
  91. static char *filebuf,*fp;
  92. static char tok[80];
  93.  
  94.  
  95. /* add the position of the error to the error message */
  96.  
  97. static void Err( char *msg )
  98. {
  99.     char buf[80];
  100.  
  101.     SPrintf(buf,"%s, char %ld",msg,fp-filebuf);
  102.     Warn(buf);
  103. }
  104.  
  105.  
  106.  
  107. /* rfp is a register variable used to replace global fp pointer in
  108.  * get_token() body. Then, fp must be restored before leaving function */
  109.  
  110. static char get_token( void )
  111. {
  112.     register char *p,*rfp;
  113.     short i;
  114.     char quote;
  115.  
  116.     rfp = fp;
  117. retry:
  118.     while(isspace(*rfp)) rfp++;    /* skip extra spaces */
  119.     if(*rfp=='#') {                /* comment */
  120.         while(*rfp!='\n' && *rfp) rfp++;
  121.         goto retry;
  122.     }
  123.     if(!isprint(*rfp) || *rfp=='{' || *rfp=='}') {
  124.         fp = rfp;
  125.         return *fp++;        /* '{', '}', '\0', or invalid char */
  126.     }
  127.     /* scan string */
  128.     p = tok;
  129.     if(*rfp=='"') {
  130.         rfp++;
  131.         quote = TRUE;
  132.     } else
  133.         quote = FALSE;
  134.     while( (quote && *rfp!='"') || (!quote && isspace(*rfp)==0) )
  135.         *p++ = *rfp++;
  136.     *p = NULL;
  137.     if (quote) rfp++; /* skip closing '"' */
  138.     for( i=1 ; i<=MAX_KEYWORD ; i++ ) {
  139.         if (!Strcmp(tok ,KeyWordTab[i])) break; /* arp Strcmp() is not case sensitive */
  140.     }
  141.     fp = rfp;
  142.     return i;
  143. }
  144.  
  145.  
  146. static BOOL ParseConfig( void ) {
  147.     char t,shortcut,mode;
  148.     long stack;
  149.     short pri;
  150.     USHORT status = STAT_BEGIN;
  151.     register char *p, c;
  152.     char itemstr[80], cmd[80], args[200], win[80];
  153.  
  154.     while(t=get_token()) {
  155.         switch( t ) {
  156.         case CMDWIN :
  157.             get_token();
  158.             strcpy(CmdWindow, tok);
  159.             break;
  160.         case COLOR :
  161.             get_token();
  162.             menu_pen = ( (menu_pen=Atol(tok)) == Win->BlockPen ) ? Win->DetailPen : menu_pen;
  163.             break;
  164.         case MENU :
  165.             if ( !(status & (STAT_MENU|STAT_ITEM)) && status != STAT_BEGIN )
  166.                 SYNTAX("Unexpected MENU statement")
  167.             status = STAT_MENU;
  168.             get_token();
  169.             AddMenu(tok);
  170.             break;
  171.         case SUBMENU :
  172.             if ( !(status & STAT_MENU) || (status & STAT_SUBMENU) )
  173.                 SYNTAX("Unexpected SUBMENU")
  174.             status = STAT_SUBMENU;
  175.             get_token();
  176.             AddSubMenu(tok);
  177.             break;
  178.         case ENDSUBMENU :
  179.             if ( !(status & STAT_SUBMENU) || !(status & STAT_ITEM) )
  180.                 SYNTAX("Unexpected ENDSUBMENU")
  181.             EndSubMenu();
  182.             status = STAT_MENU|STAT_ITEM;
  183.             break;
  184.         case ITEM :
  185.             if (status == STAT_BEGIN) SYNTAX("Unexpected ITEM")
  186.             status |= STAT_ITEM;
  187.             shortcut = pri = stack = 0;
  188.             if (get_token()=='{') {    /* command char */
  189.                 shortcut = *fp++;
  190.                 if(get_token() != '}') SYNTAX("Missing closing '}'");
  191.                 get_token();
  192.             }
  193.             strcpy(itemstr,tok);
  194.             t=get_token();
  195.             get_token();
  196.             switch( t ) {
  197.             case WB :
  198.                 mode = 'w';
  199.                 args[0] = '\0';
  200.                 strcpy(cmd,tok);
  201.                 break;
  202.             case RB :
  203.                 mode = 'r';
  204.                 strcpy(cmd,tok);
  205.                 p = args;
  206.                 while ((c=*fp++) != '\n' && c ) *p++ = c;
  207.                 *p = '\0';
  208.                 break;
  209.             case CLI :
  210.                 mode = 'c';
  211.                 strcpy(win,tok);
  212.                 while( (t=get_token())!=STR ) {
  213.                     get_token();
  214.                     switch( t ) {
  215.                     case STACK :
  216.                         stack = Atol(tok);
  217.                         break;
  218.                     case PRI :
  219.                         pri = Atol(tok);
  220.                         if (pri < -128 || pri > 127) SYNTAX("Invalid priority")
  221.                         break;
  222.                     default :
  223.                         Err("STACK | PRI Expected");
  224.                         return FALSE;
  225.                     }
  226.                 }
  227.                 strcpy(cmd,tok);
  228.                 p = args;
  229.                 while ((c=*fp++) != '\n' && c ) *p++ = c;
  230.                 *p = '\0';
  231.                 break;
  232.             default :
  233.                 Err("WB | RB | CLI Expected");
  234.                 return FALSE;
  235.             }
  236.             AddEntry(itemstr, cmd, args, win, shortcut, mode, stack, pri);
  237.             break;
  238.         default :
  239.             Err("Keyword expected");
  240.             return FALSE;
  241.         }
  242.     }
  243.     return TRUE;
  244. }
  245.  
  246.  
  247. BOOL ParseMenus( void )
  248. {
  249.     BPTR lock,cfg;
  250.     struct FileInfoBlock *fib;
  251.     long bufsize,nch;
  252.     BOOL stat;
  253.     BOOL pb = TRUE;
  254.     char msg[80];
  255.  
  256.     if ( !(lock=Lock(CurCfg, ACCESS_READ)) ) {
  257.         strcpy(msg, "Can't open ");
  258.         strcat(msg, CurCfg);
  259.         Warn(msg);
  260.         return FALSE;
  261.     }
  262.     if (fib = (struct FileInfoBlock *)
  263.               AllocMem(sizeof(struct FileInfoBlock), MEMF_PUBLIC|MEMF_CLEAR) ) {
  264.         if (Examine(lock, (BPTR)fib)) {
  265.             if ( fib->fib_DirEntryType < 0 ) {
  266.                 bufsize = fib->fib_Size+2;
  267.                 if (filebuf = AllocMem( bufsize , MEMF_PUBLIC|MEMF_CLEAR)) {
  268.                     cfg = Open(CurCfg, MODE_OLDFILE);
  269.                     nch = Read(cfg, filebuf, bufsize-1);
  270.                     Close(cfg);
  271.                     if (nch == fib->fib_Size) {
  272.                         fp = filebuf;
  273.                         stat = ParseConfig();
  274.                         CleanUp();    /* setup items width */
  275.                         pb = FALSE;
  276.                     }
  277.                     FreeMem(filebuf, bufsize);
  278.                 }
  279.             }
  280.         }
  281.         FreeMem(fib, sizeof(struct FileInfoBlock));
  282.     }
  283.     UnLock(lock);
  284.     if (pb) {
  285.         strcpy(msg, "Error reading ");
  286.         strcat(msg, CurCfg);
  287.         Warn(msg);
  288.         return FALSE;
  289.     }
  290.     return stat;
  291. }
  292.  
  293.