home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume23 / jgraph / patch06b < prev    next >
Text File  |  1991-10-22  |  29KB  |  847 lines
  1. Newsgroups: comp.sources.misc
  2. From: jsp@Princeton.EDU (James Plank)
  3. Subject:  v23i100:  jgraph - A filter for plotting postscript graphs, Patch06b/2
  4. Message-ID: <1991Oct22.031830.1456@sparky.imd.sterling.com>
  5. X-Md4-Signature: 0109f7867f2f4c812022aa85a8fcfcff
  6. Date: Tue, 22 Oct 1991 03:18:30 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: jsp@Princeton.EDU (James Plank)
  10. Posting-number: Volume 23, Issue 100
  11. Archive-name: jgraph/patch06b
  12. Environment: UNIX, VMS, postscript
  13. Patch-To: jgraph: Volume 16, Issue 20
  14.  
  15. #!/bin/sh
  16. # do not concatenate these parts, unpack them in order with /bin/sh
  17. # file patch.6 continued
  18. #
  19. if test ! -r _shar_seq_.tmp; then
  20.     echo 'Please unpack part 1 first!'
  21.     exit 1
  22. fi
  23. (read Scheck
  24.  if test "$Scheck" != 2; then
  25.     echo Please unpack part "$Scheck" next!
  26.     exit 1
  27.  else
  28.     exit 0
  29.  fi
  30. ) < _shar_seq_.tmp || exit 1
  31. if test ! -f _shar_wnt_.tmp; then
  32.     echo 'x - still skipping patch.6'
  33. else
  34. echo 'x - continuing file patch.6'
  35. sed 's/^X//' << 'SHAR_EOF' >> 'patch.6' &&
  36. !   x = 0.0;
  37. !   max_y = 0.0;
  38. !   min_y = 0.0;
  39. !   for (g = first(gs->g); g != nil(gs->g); g = next(g)) {
  40. !     tmp_x = ABS(g->x_translate) * 2.0 + g->x_axis->psize;
  41. !     x = MAX(x, tmp_x);
  42. !     max_y = MAX(max_y, g->y_translate + g->y_axis->psize);
  43. !     if (g->y_translate > 0.0)
  44. !       min_y = MIN(min_y, g->y_translate + g->minval);
  45. !     else
  46. !       min_y = MIN(min_y, g->minval);
  47. X    }
  48. -   if (gs->height <= 0.00) gs->height = max_y - min_y; else gs->height *= FCPI;
  49. -   if (gs->width <= 0.00) gs->width = x; else gs->width *= FCPI;
  50. -   gs->bb[0] = 0.0;
  51. -   gs->bb[1] = min_y;
  52. -   gs->bb[2] = gs->width;
  53. -   gs->bb[3] = gs->height + min_y;
  54. X  }
  55. --- 474,510 ----
  56. X  process_graphs(gs)
  57. X  Graphs gs;
  58. X  {
  59. +   Graphs the_g;
  60. X    Graph g;
  61. X    float tmp_x, x, max_y, min_y;
  62. +   int do_bb, i;
  63. X  
  64. !   for (the_g = first(gs); the_g != nil(gs); the_g = next(the_g)) {
  65. !     for (g = first(the_g->g); g != nil(the_g->g); g = next(g)) process_graph(g);
  66. !     x = 0.0;
  67. !     max_y = 0.0;
  68. !     min_y = 0.0;
  69. !     for (g = first(the_g->g); g != nil(the_g->g); g = next(g)) {
  70. !       tmp_x = ABS(g->x_translate) * 2.0 + g->x_axis->psize;
  71. !       x = MAX(x, tmp_x);
  72. !       max_y = MAX(max_y, g->y_translate + g->y_axis->psize);
  73. !       if (g->y_translate > 0.0)
  74. !         min_y = MIN(min_y, g->y_translate + g->minval);
  75. !       else
  76. !         min_y = MIN(min_y, g->minval);
  77. !     }
  78. !     if (the_g->height <= 0.00) 
  79. !       the_g->height = max_y - min_y; 
  80. !     else 
  81. !       the_g->height *= FCPI;
  82. !     if (the_g->width <= 0.00) the_g->width = x; else the_g->width *= FCPI;
  83. !     do_bb = 1;
  84. !     for (i = 0; i < 4; i++) do_bb = (do_bb && the_g->bb[i] == FSIG);
  85. !     if (do_bb) {
  86. !       the_g->bb[0] = 0.0;
  87. !       the_g->bb[1] = min_y;
  88. !       the_g->bb[2] = the_g->width;
  89. !       the_g->bb[3] = the_g->height + min_y;
  90. !     } 
  91. X    }
  92. X  }
  93. *** /dev/null    Tue Oct  8 02:00:06 1991
  94. --- redexp.vms    Tue Oct  8 16:55:17 1991
  95. ***************
  96. *** 0 ****
  97. --- 1,526 ----
  98. + /*    --redexp.vms--
  99. +    This 'C' module may be included prior to the ``main'' programs on VMS in
  100. +    order to allow 'C' arguments to contain redirection symbols (<,>,>>) and
  101. +    VMS wild cards (*,%, ...], [-).  By including this module, two programs
  102. +    redirect() and expand() are run prior to turning control over to
  103. +    your main() entry point.
  104. + 
  105. +     redirect-- Gregg Townsend circa 1983,
  106. +     expand-- John Campbell circa 1987
  107. + 
  108. +    This code is public domain, others may use it freely. Credit, however, to
  109. +    Gregg Townsend (who wrote ``redirect()'') and John Campbell (who followed
  110. +    with ``expand()'') would be appreciated.  If someone writes the next
  111. +    logical successor ``pipe()'', please email a copy to
  112. +    ...!arizona!naucse!jdc (John Campbell) (Gregg works on unix :-).
  113. + 
  114. +    HISTORY
  115. + 
  116. + */
  117. + 
  118. + #include <rms.h>      /* No easy way to tell if this has already been included. */
  119. + #ifndef ERANGE
  120. + #include <stdlib.h>   /* Include only if missing. */
  121. + #endif
  122. + #ifndef __FILE
  123. + #include <stdio.h>    /* Include only if missing. */
  124. + #endif
  125. + #include <ctype.h>  /* Added for conversion to lower case  */
  126. + #ifndef __STRING_LOADED
  127. + #include <string.h>
  128. + #endif /* !__STRING_LOADED */
  129. + 
  130. + /* Expansion of wild cards is done using RMS. */
  131. +         struct NAMBLK { struct NAM nam;         /* VMS nam block structure */
  132. +                  char es[NAM$C_MAXRSS],         /* Extended string         */
  133. +                       rs[NAM$C_MAXRSS];         /* Resultant string        */
  134. +                };
  135. + 
  136. + #define ErrorExit 1
  137. + 
  138. + /* Allow the user to override _N_FARGS or _E_FLAG if they wish. */
  139. + #ifndef _N_FARGS
  140. + #define _N_FARGS 0 /* no automatic redirection please */
  141. + #endif
  142. + #ifndef _E_FLAG
  143. + #define _E_FLAG 4  /* only include dev and dir if different from default */
  144. + #endif
  145. + /*
  146. +    Since the following will possibly be included in a single module, try
  147. +    hard to avoid name conflicts. (Just being static doesn't cut it if
  148. +    compiled in the same module.)
  149. + */
  150. + #define redirect     _r_edirect
  151. + #define filearg      _f_ilearg
  152. + #define expand       _e_xpand
  153. + #define wild_found   _w_ild_found
  154. + #define wild_expand  _w_ild_expand
  155. + 
  156. + /* forward protypes */
  157. + static void redirect(int *argc, char *argv[], int nfargs);
  158. + char **expand (int *argc, const char *argv[], const int flag);
  159. + 
  160. + main(int argc, char *argv[], char *envp[])
  161. + {
  162. +    redirect (&argc, argv, _N_FARGS);
  163. +    argv = expand (&argc, argv, _E_FLAG);
  164. + 
  165. +    /* Make the user's main entry point this routine's entry point. */
  166. + #define main _user_main
  167. +    _user_main (argc, argv, envp);
  168. + }
  169. + 
  170. + /* ------------------------ REDIRECT code ------------------------ */
  171. + 
  172. + /*
  173. +  * redirect(&argc,argv,nfargs) - redirect standard I/O
  174. +  *    int *argc         number of command arguments (from call to main)
  175. +  *    char *argv[]      command argument list (from call to main)
  176. +  *    int nfargs        number of filename arguments to process
  177. +  *
  178. +  * argc and argv will be adjusted by redirect.
  179. +  *
  180. +  * redirect processes a program's command argument list and handles redirection
  181. +  * of stdin, and stdout.  Any arguments which redirect I/O are removed from the
  182. +  * argument list, and argc is adjusted accordingly.  redirect would typically be
  183. +  * called as the first statement in the main program.
  184. +  *
  185. +  * Files are redirected based on syntax or position of command arguments.
  186. +  * Arguments of the following forms always redirect a file:
  187. +  *
  188. +  *    <file     redirects standard input to read the given file
  189. +  *    >file     redirects standard output to write to the given file
  190. +  *    >>file    redirects standard output to append to the given file
  191. +  *
  192. +  * It is often useful to allow alternate input and output files as the
  193. +  * first two command arguments without requiring the <file and >file
  194. +  * syntax.  If the nfargs argument to redirect is 2 or more then the
  195. +  * first two command arguments, if supplied, will be interpreted in this
  196. +  * manner:  the first argument replaces stdin and the second stdout.
  197. +  * A filename of "-" may be specified to occupy a position without
  198. +  * performing any redirection.
  199. +  *
  200. +  * If nfargs is 1, only the first argument will be considered and will
  201. +  * replace standard input if given.  Any arguments processed by setting
  202. +  * nfargs > 0 will be removed from the argument list, and again argc will
  203. +  * be adjusted.  Positional redirection follows syntax-specified
  204. +  * redirection and therefore overrides it.
  205. +  *
  206. +  */
  207. + 
  208. + /* forward prototype for local routine */
  209. + static void filearg(int *argc, char *argv[], int n, int i, FILE *fp, char mode[]);
  210. + 
  211. + static void redirect(int *argc, char *argv[], int nfargs)
  212. + {
  213. +    int i;
  214. + 
  215. +    i = 1;
  216. +    while (i < *argc)  {         /* for every command argument... */
  217. +       switch (argv[i][0])  {            /* check first character */
  218. +          case '<':                      /* <file redirects stdin */
  219. +             filearg(argc,argv,i,1,stdin,"r");
  220. +             break;
  221. +          case '>':                      /* >file or >>file redirects stdout */
  222. +             if (argv[i][1] == '>')
  223. +                filearg(argc,argv,i,2,stdout,"a");
  224. +             else
  225. +                filearg(argc,argv,i,1,stdout,"w");
  226. +             break;
  227. +          default:                       /* not recognized, go on to next arg */
  228. +             i++;
  229. +       }
  230. +    }
  231. +    if (nfargs >= 1 && *argc > 1)        /* if positional redirection & 1 arg */
  232. +       filearg(argc,argv,1,0,stdin,"r"); /* then redirect stdin */
  233. +    if (nfargs >= 2 && *argc > 1)        /* likewise for 2nd arg if wanted */
  234. +       filearg(argc,argv,1,0,stdout,"w");/* redirect stdout */
  235. + }
  236. + 
  237. + /* local routine for redirect() */
  238. + /* filearg(&argc,argv,n,i,fp,mode) - redirect and remove file argument
  239. +  *    int *argc         number of command arguments (from call to main)
  240. +  *    char *argv[]      command argument list (from call to main)
  241. +  *    int n             argv entry to use as file name and then delete
  242. +  *    int i             first character of file name to use (skip '<' etc.)
  243. +  *    FILE *fp          file pointer for file to reopen (typically stdin etc.)
  244. +  *    char mode[]       file access mode (see freopen spec)
  245. +  */
  246. + 
  247. + static void filearg(int *argc, char *argv[], int n, int i, FILE *fp, char mode[])
  248. + {
  249. +    if (strcmp(argv[n]+i,"-"))           /* alter file if arg not "-" */
  250. +       fp = freopen(argv[n]+i,mode,fp,"mbf=8","mbc=16");
  251. +    if (fp == NULL)  {                   /* abort on error */
  252. +       fprintf(stderr,"%%can't open %s",argv[n]+i);
  253. +       exit(ErrorExit);
  254. +    }
  255. +    for ( ;  n < *argc;  n++)            /* move down following arguments */
  256. +       argv[n] = argv[n+1];
  257. +    *argc = *argc - 1;                   /* decrement argument count */
  258. + }
  259. + 
  260. + /* ------------------------ EXPAND code ------------------------ */
  261. + /*-
  262. +    ``expand()'' is a routine to expand wild-cards to file specifications.
  263. +    This routine is often used in conjunction with ``redirect()'' to provide
  264. +    both wild card expansion and standard file redirection prior to doing
  265. +    any real work in a 'C' program.
  266. + 
  267. +    Normal usage is to include the following line prior to using argc or
  268. +    argv in main():
  269. + 
  270. +      argv = expand (&argc, argv, 0);
  271. + 
  272. +    ``argc'' will be adjusted by ``expand()'', the return value from expand
  273. +    will replace ``argv''.
  274. + 
  275. +    ``expand()'' processes a program's command argument list and expands any
  276. +    wild cards into zero or more argv entries. Only arguments that posses VMS
  277. +    wild-cards are expanded. Wild cards searched for are ``*'', ``%'',
  278. +    ``...]'', and ``[-''. If the wild-card is found inside a single or double
  279. +    quote ("*" or '%') then they are not counted as wild-cards. Be aware that
  280. +    the expansion of a VMS wild card will match all VMS files, including
  281. +    directory files (".DIR;1").
  282. + 
  283. +    NOTE: The use of quotes in VMS requires thinking about how the CLI expands
  284. +    things before handing the argument line over to your program.  Do not
  285. +    expect "*" to avoid expansion, use """*""" instead.  Likewise, expression
  286. +    substitution precludes the use of (') to quote wild cards:
  287. +            $ A := HELLO
  288. +            $ ECHO 'a'   ! 'C' program that calls ``expand()''
  289. +            hello
  290. +    The easiest way to escape a wild-card may be "'*'".  The point is that
  291. +    ``expand()'' will only recognize quotes passed into main().
  292. +    Note: I have added '\' as an escape character -hdd.
  293. + 
  294. +    ``expand()'' references the VMS runtime routines, you will need to
  295. +    link with the 'C' RTL whenever expand is used.
  296. + 
  297. +    Parameters:
  298. + 
  299. +          argc:  Pointer to the number of command arguments (from main),
  300. +                 the contents of this parameter are modified.
  301. + 
  302. +          argv:  Pointer to the initial command argument list (from main),
  303. +                 the contents are copied into a new array which is returned
  304. +                 from this routine.
  305. + 
  306. +          flag:  Flag indicating how to expand wild-cards:
  307. +                    0 - Complete file name expansion
  308. +                    1 - only file name (no directory or version).
  309. +                    2 - directory info and file name (no version).
  310. +                    3 - file name and version info (no directory).
  311. +            4 - omit fields that are the same as RMS default.
  312. +  -*/
  313. + 
  314. + /* Local prototypes. */
  315. + int wild_found (char *string);
  316. + char **wild_expand (const char *string, char **argv, int *argc,
  317. +                     int extra, int flag);
  318. + /*
  319. +    General note: removing the prototyping and const keywords should
  320. +    allow this code to compile with VMS 'C' compilers prior to version
  321. +    2.3-024.
  322. + */
  323. + 
  324. + char **expand (int *argc, const char *argv[], const int flag)
  325. + {
  326. +    int i, nargc;
  327. +    char **nargv;
  328. +    char *s1;
  329. + 
  330. +    /* Get an initial amount of memory for the master nargv array. */
  331. +    if ((nargv = (char **)malloc ((*argc+1) * sizeof (char *))) == NULL) {
  332. +       fprintf (stderr, "Not enough memory to expand argument list\n");
  333. +       exit (ErrorExit);
  334. +    }
  335. +    /* Copy the command name (0th argument), but only the name of the exe */
  336. +    nargv[0] = strchr(argv[0],']');
  337. +    if (nargv[0] != NULL) {
  338. +        nargv[0]++;
  339. +        if ((s1=strrchr(nargv[0],'.')) != NULL) *s1 = '\0';
  340. +    } else {
  341. +        nargv[0] = argv[0];    /* if nothing suitable take original */
  342. +    }      
  343. + 
  344. +    /* Copy all other arguments, expanding those that have wild characters. */
  345. +    for (nargc = i = 1; i < *argc; i++) {
  346. +       if (wild_found(argv[i]))
  347. +          nargv = wild_expand(argv[i], nargv, &nargc, *argc-i, flag);
  348. +       else
  349. +          nargv[nargc++] = argv[i];
  350. +    }
  351. +    *argc = nargc;
  352. +    nargv[nargc] = NULL;  /* realloc always 0 fills, but... */
  353. + 
  354. +    return nargv;
  355. + }
  356. + 
  357. + static int wild_found (char *string)
  358. + /*
  359. +    Routine to search the given string for a VMS wild-card pattern.
  360. +    Returns 1 if "*", "%", "[-", or "...]" is found.  (This may not
  361. +    be all VMS wild-cards but it is enough for now--anyone that wants
  362. +    to recognize others can change this code.)
  363. + 
  364. +    Parameter:
  365. + 
  366. +       string: '\0' terminated character array.
  367. + */
  368. + {
  369. +    int state = 0;
  370. + 
  371. +    /* State of 0 is "rest" state.  State 1 on our way to [-, states 2-4
  372. +       on our way to ...], negative states indicate the two quotes (' -10,
  373. +       " -1).
  374. +    */
  375. +    for ( ;*string; string++) {
  376. +       switch (*string) {
  377. +       case '*':
  378. +       case '%':
  379. +          if (state >= 0)
  380. +             return 1;                    /* Unquoted % or * found. */
  381. +       break;
  382. +       case '[':
  383. +          if (state >= 0)
  384. +             state = 1;
  385. +       break;
  386. +       case ']':
  387. +          if (state == 4)
  388. +             return 1;                    /* Unquoted ...] found. */
  389. +          else if (state >= 0)
  390. +             state = 0;
  391. +       break;
  392. +       case '-':
  393. +          if (state == 1)
  394. +             return 1;                    /* Unquoted [- found. */
  395. +          else if (state >= 0)
  396. +             state = 0;
  397. +       break;
  398. +       case '.':
  399. +          if (state == 1 || state == 0)
  400. +             state = 2;                   /* First '.' */
  401. +          else if (state > 1 && state < 5)
  402. +             state++;                     /* ... == states 2, 3, 4 */
  403. +          else if (state >= 0)
  404. +             state = 0;
  405. +       break;
  406. +       case '\'':
  407. +          if (state <= -10)
  408. +             state += 10;           /* One ', possibly one " also */
  409. +          else if (state < 0)
  410. +             state -= 10;           /* 0 ', possibly one " */
  411. +          else
  412. +             state = -10;           /* No ' or " prior to this ' */
  413. +       break;
  414. +       case '"':
  415. +          if (state == -11)
  416. +             state = -10;           /* Both " and ' prior to this. */
  417. +          else if (state == -10)
  418. +             state = -11;           /* A ' prior to this. */
  419. +          else if (state == -1)
  420. +             state = 0;             /* A " prior to this. */
  421. +          else
  422. +             state = -1;            /* No ' or " prior to this " */
  423. +       break;
  424. +       case '\\':
  425. +          string = strcpy(string, string+1);
  426. +      state = 0;
  427. +       break;
  428. +       }
  429. +    }
  430. +    return 0;
  431. + }
  432. + 
  433. + 
  434. + static char **wild_expand(const char *wild, char **argv,
  435. +               int *argc, int extra, int flag)
  436. + /*
  437. +    Routine to expand wild into new arguments appended to the end
  438. +    of argv[*argc].  This routine must realloc in order to make room
  439. +    for the individual arguments and malloc for enough space for each
  440. +    of the arguments.  The return value is a new **argv.
  441. + 
  442. +    Parameters:
  443. + 
  444. +          wild:  '\0' terminated string that needs to be expanded.
  445. + 
  446. +          argv:  initial starting address of the argv array.
  447. + 
  448. +          argc:  pointer to an integer that tells the current end of the
  449. +                 argument list.
  450. + 
  451. +         extra:  The number of extra pointers that the returned argv
  452. +                 must have available for future assignments.
  453. + 
  454. +          flag:  Flag indicating how to expand wild-card:
  455. +                   0 - Complete file name expansion
  456. +                   1 - only file name (no directory or version).
  457. +                   2 - directory info and file name (no version)
  458. +                   3 - file name and version info (no directory).
  459. +           4 - omit fields that are the same as RMS default.
  460. + */
  461. + {
  462. +    int more_to_go = 1, err, length, status, len_wild, i, ddev_l, ddir_l;
  463. +    char *namptr;
  464. +    struct FAB fab_blk;
  465. +    struct NAMBLK nam_blk;
  466. +    char path[256];
  467. +    char *ddevice = &path[0];    /* default device and directory */
  468. +    char *ddirectory, *ppath;
  469. + 
  470. +    char *env = getenv("PATH");
  471. +    ppath = &path[0];
  472. +    while (*env) {
  473. +        char *p = env++;
  474. +        if ((*ppath++ = _toupper(*p)) == ':') {
  475. +        ddev_l = ppath - &path[0];
  476. +        *ppath++ = 0;
  477. +        ddirectory = ppath;
  478. +        }
  479. +    }
  480. +    *ppath++ = 0;
  481. +    ddir_l = ppath - ddirectory - 1;
  482. +    len_wild = strlen(wild);
  483. + 
  484. +    /* Initialize all the fab and nam fields needed for parse and search */
  485. + 
  486. +    fab_blk = cc$rms_fab;                   /* Initialize FAB structure */
  487. + 
  488. +    nam_blk.nam    = cc$rms_nam;            /* Initialize NAM structure */
  489. +    fab_blk.fab$l_dna = ".*";               /* Default file specif.     */
  490. +    fab_blk.fab$b_dns = 2;                  /* Length of default spec.  */
  491. +    fab_blk.fab$l_nam = &nam_blk.nam;       /* Set address of NAM in FAB*/
  492. +    nam_blk.nam.nam$b_ess = NAM$C_MAXRSS;   /* Set extended  string size*/
  493. +    nam_blk.nam.nam$l_esa = nam_blk.es;     /* and address              */
  494. +    nam_blk.nam.nam$b_rss = NAM$C_MAXRSS;   /* Set resultant string size*/
  495. +    nam_blk.nam.nam$l_rsa = nam_blk.rs;     /* and address              */
  496. +    nam_blk.nam.nam$l_rlf = NULL;           /* No related file address  */
  497. + 
  498. +    fab_blk.fab$l_fna = wild;           /* Address of file name string  */
  499. +    fab_blk.fab$b_fns = len_wild;       /* Length of file name string   */
  500. + 
  501. +    /* Prepare to enter the search loop, parse fab. */
  502. +    err = SYS$PARSE (&fab_blk);
  503. + 
  504. +    /* Catch the directory not found error and return no files found. */
  505. +    if (err != RMS$_NORMAL)
  506. +       exit(err);
  507. + 
  508. +    while (more_to_go) {
  509. +       err = SYS$SEARCH (&fab_blk);
  510. +       if (err == RMS$_NMF || err == RMS$_FNF)
  511. +          more_to_go = 0;               /* Done, no more files found */
  512. +       else if (err != RMS$_NORMAL)
  513. +          exit (err);
  514. +       else {
  515. +       /* Count that we now have this many arguments. */
  516. +          (*argc)++;
  517. + 
  518. +       /* Make sure there is room for a new pointer. */
  519. +          if ((argv = realloc (argv, (*argc + extra)*sizeof(char *))) == NULL) {
  520. +             fprintf (stderr, "Not enough memory to expand argument list\n");
  521. +             exit(ErrorExit);
  522. +          }
  523. + 
  524. +       /* Move the right name into the list. */
  525. +          switch (flag) {
  526. +          case 0:             /* Complete file name */
  527. +             length = nam_blk.nam.nam$b_rsl;
  528. +             namptr = nam_blk.rs;
  529. +             break;
  530. +          case 1:            /* File name only (no directory or version). */
  531. +             length = nam_blk.nam.nam$b_name + nam_blk.nam.nam$b_type;
  532. +             namptr = nam_blk.nam.nam$l_name;
  533. +             break;
  534. +          case 2:            /* directory and file name (no version) */
  535. +             length = nam_blk.nam.nam$b_rsl - nam_blk.nam.nam$b_ver;
  536. +             namptr = nam_blk.rs;
  537. +             break;
  538. +          case 3:            /* File name and version (no directory). */
  539. +             length = nam_blk.nam.nam$b_name +
  540. +                      nam_blk.nam.nam$b_type +
  541. +                      nam_blk.nam.nam$b_ver;
  542. +             namptr = nam_blk.nam.nam$l_name;
  543. +             break;
  544. +      case 4:         /* Remove redundant fields, no version */
  545. +             length = nam_blk.nam.nam$b_rsl - nam_blk.nam.nam$b_ver;
  546. +             namptr = nam_blk.rs;
  547. +         if ((nam_blk.nam.nam$b_dev==ddev_l) &&
  548. +             !strncmp(namptr, ddevice, nam_blk.nam.nam$b_dev)) {
  549. +             length -= nam_blk.nam.nam$b_dev;
  550. +             namptr += nam_blk.nam.nam$b_dev;
  551. +             if ((nam_blk.nam.nam$b_dir==ddir_l) &&
  552. +                 !strncmp(namptr, ddirectory, nam_blk.nam.nam$b_dir)) {
  553. +                 length -= nam_blk.nam.nam$b_dir;
  554. +                 namptr += nam_blk.nam.nam$b_dir;
  555. +             }
  556. +         }
  557. +             break;
  558. +          default:
  559. +             fprintf (stderr, "illegal flag used in VMS expand call\n");
  560. +             exit (ErrorExit);
  561. +      } /* end of switch */
  562. +      /* Copy the requested string into the argument array. */
  563. +          if ((argv[*argc-1] = malloc (length+1)) == NULL) {
  564. +             fprintf (stderr, "Not enough memory to expand argument list\n");
  565. +             exit (ErrorExit);
  566. +      }
  567. +          /* Copy the string, translate to lower case */
  568. +          /* strncpy (argv[*argc-1], namptr, length); */
  569. +          for (i=0; i<length; i++) {
  570. +          argv[*argc-1][i] = _tolower(*namptr);
  571. +          namptr++;
  572. +      }
  573. +          /* End of modification */
  574. +          argv[*argc-1][length] = '\0';
  575. +       }
  576. +    } /* end while (more_to_go) */
  577. +    return (argv);
  578. + }
  579. + 
  580. + /* Remove all the defines that might affect the user's code. */
  581. + 
  582. + #undef redirect
  583. + #undef filearg
  584. + #undef expand
  585. + #undef wild_found
  586. + #undef wild_expand
  587. + 
  588. + #if 0
  589. + /* ------------------------ ECHO sample code ------------------------ */
  590. + 
  591. + #include <stdio.h>
  592. + /* here come the 3 lines that make this Unix program into a VMS one: */
  593. + #ifdef VMS
  594. + #include <redexp.vms>
  595. + #endif
  596. + 
  597. + /*
  598. +    This main program allows you to run experiments with redexp.vms.
  599. +    Try $ echo *.*, $ echo -f1 [-...]*.*, $ echo -f[0-3] *.*.
  600. +    Questions about using "%", "\", etc. may be answered by testing
  601. +    with this version of echo.
  602. + 
  603. +    To use this, cut from the "#if 0" above up to the last #endif,
  604. +    and put the text in echo.c. Assuming you have defined VAXC$INCLUDE
  605. +    to also look in the directory where you put redexp.VMS, you should
  606. +    be able to compile and link echo. Define a symbol echo as
  607. +        echo :== $sys$disk:[]echo
  608. +    and you are ready to run.
  609. + 
  610. + */
  611. + main(argc, argv)
  612. + int argc;
  613. + char *argv[];
  614. + {
  615. +     int i = 0;
  616. + 
  617. +     while (i < argc) {
  618. +     printf("argv[%d]: %s\n", i, argv[i]);
  619. +     i++;    
  620. +     }
  621. + }
  622. + /* ------------------------ ECHO sample code end --------------------- */
  623. + #endif  /* if 0 */
  624. *** ../work/show.c    Tue Oct  8 17:36:30 1991
  625. --- show.c    Tue Oct  8 16:55:18 1991
  626. ***************
  627. *** 1,7 ****
  628. X  /* 
  629. X   * $Source: /n/fs/vd/jsp/src/jgraph/RCS/show.c,v $
  630. !  * $Revision: 5.0 $
  631. !  * $Date: 91/05/02 14:45:21 $
  632. X   * $Author: jsp $
  633. X   */ 
  634. X  
  635. --- 1,7 ----
  636. X  /* 
  637. X   * $Source: /n/fs/vd/jsp/src/jgraph/RCS/show.c,v $
  638. !  * $Revision: 6.0 $
  639. !  * $Date: 91/10/08 16:53:59 $
  640. X   * $Author: jsp $
  641. X   */ 
  642. X  
  643. ***************
  644. *** 9,15 ****
  645. X  #include <math.h>
  646. X  #include "jgraph.h"
  647. X  
  648. ! static int spaces(nsp)
  649. X  int nsp;
  650. X  {
  651. X    while(nsp-- > 0) putchar(' ');
  652. --- 9,15 ----
  653. X  #include <math.h>
  654. X  #include "jgraph.h"
  655. X  
  656. ! static spaces(nsp)
  657. X  int nsp;
  658. X  {
  659. X    while(nsp-- > 0) putchar(' ');
  660. ***************
  661. *** 68,73 ****
  662. --- 68,74 ----
  663. X  {
  664. X    Point p;
  665. X    int i;
  666. +   Flist fl;
  667. X  
  668. X    if (c->l->label != CNULL) {
  669. X      spaces(nsp); printf("label\n");
  670. ***************
  671. *** 99,107 ****
  672. X    spaces(nsp); printf("linetype ");
  673. X    if (c->linetype == '0')  printf("none ");
  674. X    else if (c->linetype == 's') printf("solid ");
  675. !   else if (c->linetype == '.') printf("dotted");
  676. X    else if (c->linetype == '-') printf("dashed ");
  677. X    printf("linethickness %f\n", c->linethick);
  678. X  }
  679. X  
  680. X  show_axis(a, nsp, g)
  681. --- 100,137 ----
  682. X    spaces(nsp); printf("linetype ");
  683. X    if (c->linetype == '0')  printf("none ");
  684. X    else if (c->linetype == 's') printf("solid ");
  685. !   else if (c->linetype == '.') printf("dotted ");
  686. X    else if (c->linetype == '-') printf("dashed ");
  687. +   else if (c->linetype == 'l') printf("longdash ");
  688. +   else if (c->linetype == 'd') printf("dotdash ");
  689. +   else if (c->linetype == 'D') printf("dotdotdash ");
  690. +   else if (c->linetype == '2') printf("dotdotdashdash ");
  691. +   else if (c->linetype == 'g') {
  692. +     printf("general\n");
  693. +     spaces(nsp+2);
  694. +     printf("glines "); 
  695. +     i = 0;
  696. +     for (fl = first(c->gen_linetype); fl != nil(c->gen_linetype); 
  697. +                                       fl = next(fl)) {
  698. +       if (i == 6) {
  699. +         printf("\n");
  700. +         spaces(nsp + 9);
  701. +         i = 0;
  702. +       }
  703. +       printf("%f ", fl->f);
  704. +       i++;
  705. +     }
  706. +     printf("\n");
  707. +     spaces(nsp);
  708. +   }
  709. X    printf("linethickness %f\n", c->linethick);
  710. +   spaces(nsp); 
  711. +   printf("gray %f ", c->gray);
  712. +   if(!c->clip) printf("no"); printf("clip ");
  713. +   if(!c->rarrows) printf("no"); printf("rarrows ");
  714. +   if(!c->larrows) printf("no"); printf("larrows ");
  715. +   printf("asize %f %f\n", ptodist(c->asize[0], g->x_axis), 
  716. +                           ptodist(c->asize[1], g->y_axis));
  717. X  }
  718. X  
  719. X  show_axis(a, nsp, g)
  720. ***************
  721. *** 135,141 ****
  722. --- 165,175 ----
  723. X    spaces(nsp); 
  724. X    printf("%sdraw_hash_marks\n", (a->draw_hash_marks) ? "" : "no_");
  725. X    spaces(nsp); 
  726. +   printf("%sgrid_lines\n", (a->grid_lines) ? "" : "no_");
  727. +   spaces(nsp); 
  728. X    printf("%sdraw_axis_label\n", (a->draw_axis_label) ? "" : "no_");
  729. +   spaces(nsp); 
  730. +   printf("gray %f\n", a->gray);
  731. X    spaces(nsp);
  732. X  
  733. X    printf("(* The real settings for generating auto_hash_labels:\n");
  734. ***************
  735. *** 202,207 ****
  736. --- 236,243 ----
  737. X                         ptoin(g->x_translate), ptoin(g->y_translate));
  738. X    spaces(nsp); printf("xaxis\n"); show_axis(g->x_axis, nsp+2, g);
  739. X    spaces(nsp); printf("yaxis\n"); show_axis(g->y_axis, nsp+2, g);
  740. +   spaces(nsp); if(!g->clip) printf("no"); printf("clip ");
  741. +                if(!g->border) printf("no"); printf("border\n");
  742. X    for (c = first(g->curves); c != nil(g->curves); c = next(c)) {
  743. X      spaces(nsp);
  744. X      printf("curve %d\n", c->num);
  745. ***************
  746. *** 224,235 ****
  747. X  show_graphs(gs)
  748. X  Graphs gs;
  749. X  {
  750. X    Graph g;
  751. X  
  752. !   printf("X %f Y %f\n", ptoin(gs->width), ptoin(gs->height));
  753. !   for (g = first(gs->g); g != nil(gs->g); g = next(g)) {
  754. !     printf("graph %d\n", g->num);
  755. !     show_graph(g, 2);
  756. X    }
  757. X  }
  758. X  
  759. --- 260,282 ----
  760. X  show_graphs(gs)
  761. X  Graphs gs;
  762. X  {
  763. +   Graphs the_g;
  764. X    Graph g;
  765. +   char started;
  766. +   int i;
  767. X  
  768. !   started = 0;
  769. !   for (the_g = first(gs); the_g != nil(gs); the_g = next(the_g)) {
  770. !     if (started) printf("\nnewpage\n");
  771. !     started = 1;
  772. !     printf("X %f Y %f\n", ptoin(the_g->width), ptoin(the_g->height));
  773. !     printf("bbox"); 
  774. !     for (i = 0; i < 4; i++) printf(" %f", the_g->bb[i]);
  775. !     printf("\n");
  776. !     for (g = first(the_g->g); g != nil(the_g->g); g = next(g)) {
  777. !       printf("graph %d\n", g->num);
  778. !       show_graph(g, 2);
  779. !     }
  780. X    }
  781. X  }
  782. X  
  783. *** ../work/token.c    Tue Oct  8 17:36:41 1991
  784. --- token.c    Tue Oct  8 16:55:18 1991
  785. ***************
  786. *** 1,7 ****
  787. X  /* 
  788. X   * $Source: /n/fs/vd/jsp/src/jgraph/RCS/token.c,v $
  789. !  * $Revision: 5.0 $
  790. !  * $Date: 91/05/02 14:45:23 $
  791. X   * $Author: jsp $
  792. X   */
  793. X  
  794. --- 1,7 ----
  795. X  /* 
  796. X   * $Source: /n/fs/vd/jsp/src/jgraph/RCS/token.c,v $
  797. !  * $Revision: 6.0 $
  798. !  * $Date: 91/10/08 16:54:00 $
  799. X   * $Author: jsp $
  800. X   */
  801. X  
  802. ***************
  803. *** 82,88 ****
  804. X    return oldchar;
  805. X  }
  806. X  
  807. ! int ungettokenchar()
  808. X  {
  809. X    oldcharvalid = 1;
  810. X    if (oldchar == '\n') line--;
  811. --- 82,88 ----
  812. X    return oldchar;
  813. X  }
  814. X  
  815. ! ungettokenchar()
  816. X  {
  817. X    oldcharvalid = 1;
  818. X    if (oldchar == '\n') line--;
  819. ***************
  820. *** 209,215 ****
  821. X            push_iostack(0);
  822. X          }
  823. X        } else if (strcmp(INPUT, "shell") == 0) {
  824. -         char *s, fn[30];
  825. X  #ifdef VMS 
  826. X          fprintf(stderr, "No shell option on VMS, sorry.\n");
  827. X          exit(1);
  828. --- 209,214 ----
  829. SHAR_EOF
  830. echo 'File patch.6 is complete' &&
  831. chmod 0664 patch.6 ||
  832. echo 'restore of patch.6 failed'
  833. Wc_c="`wc -c < 'patch.6'`"
  834. test 78625 -eq "$Wc_c" ||
  835.     echo 'patch.6: original size 78625, current size' "$Wc_c"
  836. rm -f _shar_wnt_.tmp
  837. fi
  838. rm -f _shar_seq_.tmp
  839. echo You have unpacked the last part
  840. exit 0
  841. exit 0 # Just in case...
  842. -- 
  843. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  844. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  845. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  846. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  847.