home *** CD-ROM | disk | FTP | other *** search
/ Oakland CPM Archive / oakcpm.iso / cpm / aztec-c / minder.ark / MNDPRS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-06-19  |  9.1 KB  |  457 lines
  1. /* parse - Various useful parse routines
  2.  
  3.     Included are
  4.  
  5.         confrm        Get confirmation (cr)
  6.         getfnm        Get file name
  7.         getenm        Get event name
  8.         getrol        Get rest of line.
  9.         getuqs        Get unquoted string
  10.         getlin        Get a line of text
  11.         noise        Process noise words
  12.         COMNDi        Call COMND; say "invalid" if bad return
  13.  
  14. */
  15.  
  16. #include    "minder.h"        /* Get minder defs */
  17. #include    "comnd.h"        /* Use COMND defs */
  18. #include    "setjmp.h"        /* setjmp/longjmp def */
  19.  
  20. /* Local definitions */
  21.  
  22. extern    char    **venkfr();        /* valid event name fetch routine */
  23. extern    EVT    *evnadr();        /* Convert addr of EVT_NAM to addr
  24.                        of EVT block */
  25.  
  26. /* External variables */
  27.  
  28. extern    EVT    *Evthdr;        /* Heads the list of EVT blocks */
  29. extern    CFB    Inicfb;            /* CFB for initialization */
  30. extern    CSB    Tmpcsb;            /* Temp command state block */
  31. extern    jmp_buf    Tmpenv;            /* setjmp buffer for Tmpcsb */
  32. extern    char    *Usrnam;        /* Addr of current user's name */
  33.  
  34. /* External routines */
  35.  
  36.  
  37.  
  38. /* Locals */
  39.  
  40.  
  41. static    WORD    CCevt[] = {        /* CC for event names */
  42.             0x0000,        /* ^@ ^A ^B ^C ^D ^E ^F ^G */
  43.             0x3000,        /* ^H ^I ^J ^K ^L ^M ^N ^O */
  44.             0x0000,        /* ^P ^Q ^R ^S ^T ^U ^V ^W */
  45.             0x0000,        /* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
  46.             0xC000,        /* sp  !  "  #  $  %  &  ' */
  47.             0x0023,        /*  (  )  *  +  ,  -  .  / */
  48.             0xAAAA,        /*  0  1  2  3  4  5  6  7 */
  49.             0xA000,        /*  8  9  :  ;  <  =  >  ? */
  50.             0x2AAA,        /*  @  A  B  C  D  E  F  G */
  51.             0xAAAA,        /*  H  I  J  K  L  M  N  O */
  52.             0xAAAA,        /*  P  Q  R  S  T  U  V  W */
  53.             0xA802,        /*  X  Y  Z  [  \  ]  ^  _ */
  54.             0x2AAA,        /*  `  a  b  c  d  e  f  g */
  55.             0xAAAA,        /*  h  i  j  k  l  m  n  o */
  56.             0xAAAA,        /*  p  q  r  s  t  u  v  w */
  57.             0xA800        /*  x  y  z  {  |  }  ~ dl */
  58.               };
  59.  
  60. static    CFB    Cfmcfb = {_CMCFM, 0, 0, 0, 0, 0};
  61. static    CGK    Enfcgk = {0, venkfr};    /* keyword fetch block for evnames */
  62. static    CFB    Fnmcfb = {_CMUQS, _CFHPP|_CFSDH, 0, 0, "File name", 0};
  63. static    CFB    Glncfb = {_CMTXT, _CFSDH, 0, 0, 0, 0};
  64. static    CFB    Noicfb = {_CMNOI, 0, 0, 0, 0, 0};
  65. static    CFB    Rolcfb = {_CMTXT, _CFHPP|_CFSDH, 0, 0, "x", 0};
  66. static    CFB    Uqscfb = {_CMUQS, _CFHPP|_CFSDH, 0, 0, "x", 0};
  67. static    CFB    Vencfb = {_CMGSK, _CFHPP|_CFCC, 0, &Enfcgk,
  68.             "Event name, ", 0, CCevt};
  69.  
  70.  
  71.  
  72. /*
  73.  
  74. *//* getenm (CSBptr)
  75.  
  76.     Get a valid event name from the current parse
  77.  
  78.  
  79. Accepts :
  80.  
  81.     CSBptr        Address of command state block
  82.  
  83.  
  84. Returns :
  85.  
  86.     <value>        NULL if error
  87.             address of EVT block for event if no error
  88.  
  89.  
  90. */
  91.  
  92. EVT *getenm (CSBptr)
  93.  
  94. CSB        *CSBptr;        /* Addr of command state block */
  95.  
  96. {
  97. if (COMNDi (CSBptr, &Vencfb) != _CROK)    /* Get event name */
  98.     return (NULL);            /* Return failure if failed.. */
  99.  
  100. return (evnadr (CSBptr -> CSB_RVL._ADR));    /* Return the result */
  101. }
  102. /*
  103.  
  104. *//* getfnm (CSBptr, fnm)
  105.  
  106.     Get file name from current parse
  107.  
  108.  
  109. Accepts :
  110.  
  111.     CSBptr        Address of command state block
  112.     fnm        Where to put the file name
  113.  
  114. Returns :
  115.  
  116.     <value>        TRUE if OK parse
  117.             FALSE if not
  118.  
  119. */
  120.  
  121. getfnm (CSBptr, fnm)
  122.  
  123. CSB        *CSBptr;        /* Addr of CSB */
  124. char        *fnm;            /* File name */
  125.  
  126. {
  127. if (COMNDi (CSBptr, &Fnmcfb) != _CROK)    /* Do the parse */
  128.     return (FALSE);
  129. strcpy (fnm, CSBptr -> CSB_ABF);    /* Copy name from atom buffer */
  130. return (TRUE);
  131. }
  132. /*
  133.  
  134. *//* getuqs (CSBptr, help, uqs)
  135.  
  136.     Get unquoted string from current parse
  137.  
  138.  
  139. Accepts :
  140.  
  141.     CSBptr        Address of command state block
  142.     help        Help text for incremental help
  143.     uqs        Where to put the string
  144.  
  145. Returns :
  146.  
  147.     <value>        TRUE if OK parse
  148.             FALSE if not
  149.  
  150. */
  151.  
  152. getuqs (CSBptr, help, uqs)
  153.  
  154. CSB        *CSBptr;        /* Addr of CSB */
  155. char        *help;            /* Help text */
  156. char        *uqs;            /* String buffer */
  157.  
  158. {
  159. Uqscfb.CFB_HLP = help;            /* Set help text */
  160. if (COMNDi (CSBptr, &Uqscfb) != _CROK)    /* Do the parse */
  161.     return (FALSE);
  162. strcpy (uqs, CSBptr -> CSB_ABF);    /* Copy string from atom buffer */
  163. return (TRUE);
  164. }
  165. /*
  166.  
  167. *//* getrol (CSBptr, help, text)
  168.  
  169.     Get rest of line from current parse
  170.  
  171.  
  172. Accepts :
  173.  
  174.     CSBptr        Address of command state block
  175.     help        Help text for incremental help
  176.     text        Where to put the string
  177.  
  178. Returns :
  179.  
  180.     <value>        TRUE if OK parse
  181.             FALSE if not
  182.  
  183. */
  184.  
  185. getrol (CSBptr, help, text)
  186.  
  187. CSB        *CSBptr;        /* Addr of CSB */
  188. char        *help;            /* Help text */
  189. char        *text;            /* Text buffer */
  190.  
  191. {
  192. Rolcfb.CFB_HLP = help;            /* Set help text */
  193. if (COMNDi (CSBptr, &Rolcfb) != _CROK)    /* Do the parse */
  194.     return (FALSE);
  195. strcpy (text, CSBptr -> CSB_ABF);    /* Copy text from atom buffer */
  196. return (TRUE);
  197. }
  198. /*
  199.  
  200. *//* getlin (prmpt)
  201.  
  202.     Gets a line of text, using the temporay command block
  203.  
  204.  
  205. Accepts :
  206.  
  207.     prompt        Address of prompt string
  208.  
  209.  
  210. Returns :
  211.  
  212.     <data in Tmpabf>
  213.  
  214. */
  215.  
  216. getlin (prmpt)
  217.  
  218. char        *prmpt;            /* Addr of prompt string */
  219.  
  220. {
  221. Tmpcsb.CSB_PMT = prmpt;            /* Set prompt */
  222. if (COMND (&Tmpcsb, &Inicfb) != _CROK) /* eh? */
  223.     {
  224.     printf ("Fatal error initializing COMND\n");
  225.     exit();
  226.     }
  227.  
  228. setjmp (Tmpenv);            /* Mark here for reparse */
  229.  
  230. COMND (&Tmpcsb, &Glncfb);        /* Collect line */
  231. confrm(&Tmpcsb);            /* Confirm */
  232. }
  233. /*
  234.  
  235. *//* noise (CSBptr, gws)
  236.  
  237.     Parse a guide word string
  238.  
  239.  
  240. Accepts :
  241.  
  242.     CSBptr        Address of command state block
  243.     gws        Address of guide word string
  244.  
  245.  
  246. Returns :
  247.  
  248.     <value>        TRUE if ok,
  249.             FALSE if not
  250.  
  251. */
  252.  
  253. noise (CSBptr, gws)
  254.  
  255. CSB        *CSBptr;        /* Addr of command state block */
  256. char        *gws;            /* Addr of guide word string */
  257.  
  258. {
  259. IND    int    i;            /* Scratch */
  260.  
  261. Noicfb.CFB_DEF = gws;            /* Store addr of guide word string */
  262. i = COMND (CSBptr, &Noicfb);        /* Get confirmation */
  263. if (i == _CROK)                /* If ok */
  264.     return (TRUE);            /*  return */
  265. printf ("Invalid guide string\n");    /* Give error */
  266. return (FALSE);                /* Return */
  267. }
  268. /*
  269.  
  270. *//* confrm (CSBptr)
  271.  
  272.     Get confirmation
  273.  
  274.  
  275. Accepts :
  276.  
  277.     CSBptr        Address of command state block
  278.  
  279.  
  280. Returns :
  281.  
  282.     <value>        TRUE if ok,
  283.             FALSE if not
  284.  
  285. */
  286.  
  287. confrm (CSBptr)
  288.  
  289. CSB        *CSBptr;        /* Addr of command state block */
  290.  
  291. {
  292. IND    int    i;            /* Scratch */
  293.  
  294. i = COMND (CSBptr, &Cfmcfb);        /* Get confirmation */
  295. if (i == _CROK)                /* If ok */
  296.     return (TRUE);            /*  return */
  297. printf (" Not confirmed; CR expected, not \"");
  298. echups (CSBptr);
  299. printf ("\"\n");
  300. return (FALSE);                /* Return */
  301. }
  302. /*
  303.  
  304. *//* COMNDi (CSBptr, CFBptr)
  305.  
  306.     Call COMND; say "invalid" if bad return.
  307.  
  308.  
  309. Accepts :
  310.  
  311.     CSBptr        Address of the command state block to use
  312.     CFBptr        Address of command function block
  313.  
  314.  
  315. Returns :
  316.  
  317.     <value>        Value as returned by COMND
  318.  
  319. */
  320.  
  321. COMNDi (CSBptr, CFBptr)
  322.  
  323. CSB        *CSBptr;        /* Command state block addr */
  324. CFB        *CFBptr;        /* Command function block addr */
  325.  
  326. {
  327. IND    int    i;            /* Scratch */
  328.  
  329. i = COMND (CSBptr, CFBptr);        /* do the COMND call */
  330. if (i != _CROK)                /* If it wasn't ok... */
  331.     {
  332.     printf (" ??Invalid -- Can not recognize \"");
  333.     echups (CSBptr);
  334.     printf ("\"... use ? instead.\n");
  335.     }
  336. return (i);                /* Return the result */
  337. }
  338. /*
  339.  
  340. *//* echups (CSBptr)
  341.  
  342.     Echo the unparsed portion of the command line
  343.  
  344.  
  345. Accepts :
  346.  
  347.     CSBptr        Addr of CSB
  348.  
  349.  
  350. Returns :
  351.  
  352. */
  353.  
  354. echups (CSBptr)
  355.  
  356. CSB        *CSBptr;        /* Addr of command state block */
  357.  
  358. {
  359. IND    int    i;            /* Scratch */
  360. IND    char    *sptr;            /* String ptr */
  361.  
  362. sptr = &CSBptr->CSB_BUF[CSBptr->CSB_PRS]; /* Get start address */
  363. i = CSBptr->CSB_FLN - CSBptr->CSB_PRS;    /* # of chars */
  364. while (i--)
  365.     putchar(*sptr++);
  366. }
  367. /*
  368.  
  369. *//* venkfr (base, str)
  370.  
  371.     Fetches next user name given previous name in list
  372.  
  373. This is a keyword fetch routine which is used in conjunction with the
  374. COMND general-storage-keyword facility.
  375.  
  376.  
  377. Accepts :
  378.  
  379.     base        Base variable (ignored)
  380.     str        Address of previous event name ptr in list, or
  381.             NULL to return the first one
  382.  
  383.  
  384. Returns :
  385.  
  386.     <value>        NULL if no more names in list
  387.             address of event name pointer (in EVT block) if some.
  388.  
  389. */
  390.  
  391. char **venkfr (base, str)
  392.  
  393. char        *base;            /* A base address */
  394. char        **str;            /* Addr of string pointer */
  395.  
  396. {
  397. IND    EVT    *EVTptr;        /* Points to EVT block */
  398.  
  399. if (str == NULL)            /* If null pointer */
  400.     EVTptr = Evthdr;            /*  use list header */
  401. else                    /* Otherwise */
  402.     EVTptr = evnadr (str) -> EVT_FLK;    /*  get next in list */
  403.  
  404. while (EVTptr)                /* Validate recipient */
  405.     {
  406.     if (chkfor(EVTptr))            /* If OK */
  407.     break;                /*  then use it */
  408.     if (Usrnam)                /* OK if from us, too */
  409.     if (EVTptr -> EVT_FRM)
  410.         if (nccmp (Usrnam, EVTptr -> EVT_FRM) == 0)
  411.         break;
  412.  
  413.     EVTptr = EVTptr -> EVT_FLK;        /*  try the next one */
  414.     }
  415.  
  416. if (EVTptr)                /* If any pointer */
  417.     return (&EVTptr -> EVT_NAM);    /*  return addr of name pointer */
  418. else                    /* Otherwise */
  419.     return (NULL);            /* Come up empty */
  420. }
  421. /*
  422.  
  423. *//* evnadr (str)
  424.  
  425.     Convert address of a EVT_NAM element to the address
  426. of the EVT block.
  427.  
  428.  
  429. Accepts :
  430.  
  431.     str        Address of a EVT_NAM element.
  432.  
  433.  
  434.  
  435. Returns :
  436.  
  437.     <value>        Address of a corresponding EVT block.
  438.  
  439. */
  440.  
  441. EVT *evnadr (str)
  442.  
  443. char        **str;            /* Points to str ptr */
  444.  
  445. {
  446. IND    EVT    *EVTptr;        /* EVT ptr */
  447. IND    int    i;            /* integer */
  448. IND    char    *cp1, *cp2;        /* CHAR pointers */
  449.  
  450. cp1 = str;                /* Get byte address */
  451. EVTptr = str;                /* Calculate offset from base */
  452. cp2 = &EVTptr -> EVT_NAM;
  453. i = cp2-cp1;                /* Byte offset */
  454. cp1 = cp1-i;                /* Adjust it the other way */
  455. return (cp1);                /* Return it. */
  456. }
  457.