PLplot 5.15.0
Loading...
Searching...
No Matches
plargs.c
Go to the documentation of this file.
1// Maurice LeBrun mjl@dino.ph.utexas.edu
2// Institute for Fusion Studies University of Texas at Austin
3//
4// Copyright (C) 1993-2005 Maurice LeBrun
5// Copyright (C) 1995 Rady Shouman
6// Copyright (C) 1998-2000 Geoffrey Furnish
7// Copyright (C) 2000-2019 Alan W. Irwin
8// Copyright (C) 2001 Joao Cardoso
9// Copyright (C) 2004-2011 Andrew Ross
10// Copyright (C) 2004-2005 Rafael Laboissiere
11// Copyright (C) 2007 Andrew Roach
12// Copyright (C) 2008-2009 Werner Smekal
13// Copyright (C) 2009-2011 Hazen Babcock
14// Copyright (C) 2009-2010 Hezekiah M. Carty
15// Copyright (C) 2015 Jim Dishaw
16// Copyright (C) 2017 Phil Rosenberg
17//
18// This file is part of PLplot.
19//
20// PLplot is free software; you can redistribute it and/or modify
21// it under the terms of the GNU Library General Public License as published
22// by the Free Software Foundation; either version 2 of the License, or
23// (at your option) any later version.
24//
25// PLplot is distributed in the hope that it will be useful,
26// but WITHOUT ANY WARRANTY; without even the implied warranty of
27// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28// GNU Library General Public License for more details.
29//
30// You should have received a copy of the GNU Library General Public License
31// along with PLplot; if not, write to the Free Software
32// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
33//
34// Some parts of this code were derived from "xterm.c" and "ParseCmd.c" of
35// the X-windows Version 11 distribution. The copyright notice is
36// reproduced here:
37//
38// Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
39// and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
40//
41// All Rights Reserved
42//
43// The full permission notice is given in the PLplot documentation.
44//
45//--------------------------------------------------------------------------
46//
107
108#include "plplotP.h"
109#include <ctype.h>
110#include <errno.h>
111
112#ifdef HAVE_CRT_EXTERNS_H
113//
114// This include file has the declaration for _NSGetArgc(). See below.
115//
116#include <crt_externs.h>
117#endif
118
119// Support functions
120
121static int ParseOpt( int *, char ***, int *, char ***, PLOptionTable * );
122static int ProcessOpt( char *, PLOptionTable *, int *, char ***, int * );
123static int GetOptarg( char **, int *, char ***, int * );
124static void Help( void );
125static void Syntax( void );
126
127// Option handlers
128
129static int opt_a( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
131static int opt_bg( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
133static int opt_bufmax( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
134static int opt_cmap0( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
135static int opt_cmap1( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
136static int opt_db( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
137static int opt_debug( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
138static int opt_dev( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
140static int opt_dpi( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
143static int opt_fam( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
144static int opt_fbeg( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
145static int opt_fflen( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
146static int opt_finc( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
148static int opt_fsiz( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
149static int opt_geo( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
150static int opt_h( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
151static int opt_hack( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
152static int opt_jx( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
153static int opt_jy( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
155static int opt_mar( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
156static int opt_mfi( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
157static int opt_mfo( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
158static int opt_ncol0( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
159static int opt_ncol1( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
161static int opt_np( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
162static int opt_o( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
163static int opt_ori( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
167static int opt_px( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
168static int opt_py( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
171static int opt_v( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
173static int opt_width( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
174static int opt_wplt( PLCHAR_VECTOR, PLCHAR_VECTOR, void * );
175
176// Global variables
177
178static PLCHAR_VECTOR program = NULL;
179static PLCHAR_VECTOR usage = NULL;
180
181static int mode_full;
182static int mode_quiet;
183static int mode_nodelete;
184static int mode_showall;
185static int mode_noprogram;
186static int mode_nodash;
187static int mode_skip;
188
189// Temporary buffer used for parsing
190
191#define OPTMAX 1024
192static char opttmp[OPTMAX];
193
194//--------------------------------------------------------------------------
244//--------------------------------------------------------------------------
245
247 {
248 "showall", // Turns on invisible options
249 NULL,
250 NULL,
253 "-showall",
254 "Turns on invisible options"
255 },
256 {
257 "h", // Help
258 opt_h,
259 NULL,
260 NULL,
262 "-h",
263 "Print out this message"
264 },
265 {
266 "v", // Version
267 opt_v,
268 NULL,
269 NULL,
271 "-v",
272 "Print out the PLplot library version number"
273 },
274 {
275 "verbose", // Be more verbose than usual
277 NULL,
278 NULL,
280 "-verbose",
281 "Be more verbose than usual"
282 },
283 {
284 "debug", // Print debugging info
285 opt_debug,
286 NULL,
287 NULL,
289 "-debug",
290 "Print debugging info (implies -verbose)"
291 },
292 {
293 "hack", // Enable driver-specific hack(s)
294 opt_hack,
295 NULL,
296 NULL,
298 "-hack",
299 "Enable driver-specific hack(s)"
300 },
301 {
302 "dev", // Output device
303 opt_dev,
304 NULL,
305 NULL,
307 "-dev name",
308 "Output device name"
309 },
310 {
311 "o", // Output filename
312 opt_o,
313 NULL,
314 NULL,
316 "-o name",
317 "Output filename"
318 },
319 {
320 "display", // X server
321 opt_o,
322 NULL,
323 NULL,
325 "-display name",
326 "X server to contact"
327 },
328 {
329 "px", // Plots per page in x
330 opt_px,
331 NULL,
332 NULL,
334 "-px number",
335 "Plots per page in x"
336 },
337 {
338 "py", // Plots per page in y
339 opt_py,
340 NULL,
341 NULL,
343 "-py number",
344 "Plots per page in y"
345 },
346 {
347 "geometry", // Geometry
348 opt_geo,
349 NULL,
350 NULL,
352 "-geometry geom",
353 "Window size/position specified as in X, e.g., 400x300, 400x300-100+200, +100-200, etc."
354 },
355 {
356 "geo", // Geometry (alias)
357 opt_geo,
358 NULL,
359 NULL,
361 "-geo geom",
362 "Window size/position specified as in X, e.g., 400x300, 400x300-100+200, +100-200, etc."
363 },
364 {
365 "wplt", // Plot window
366 opt_wplt,
367 NULL,
368 NULL,
370 "-wplt xl,yl,xr,yr",
371 "Relative coordinates [0-1] of window into plot"
372 },
373 {
374 "mar", // Margin
375 opt_mar,
376 NULL,
377 NULL,
379 "-mar margin",
380 "Margin space in relative coordinates (0 to 0.5, def 0)"
381 },
382 {
383 "a", // Aspect ratio
384 opt_a,
385 NULL,
386 NULL,
388 "-a aspect",
389 "Page aspect ratio (def: same as output device)"
390 },
391 {
392 "jx", // Justification in x
393 opt_jx,
394 NULL,
395 NULL,
397 "-jx justx",
398 "Page justification in x (-0.5 to 0.5, def 0)"
399 },
400 {
401 "jy", // Justification in y
402 opt_jy,
403 NULL,
404 NULL,
406 "-jy justy",
407 "Page justification in y (-0.5 to 0.5, def 0)"
408 },
409 {
410 "ori", // Orientation
411 opt_ori,
412 NULL,
413 NULL,
415 "-ori orient",
416 "Plot orientation (0,1,2,3=landscape,portrait,seascape,upside-down)"
417 },
418 {
419 "freeaspect", // floating aspect ratio
421 NULL,
422 NULL,
424 "-freeaspect",
425 "Allow aspect ratio to adjust to orientation swaps"
426 },
427 {
428 "portrait", // floating aspect ratio
430 NULL,
431 NULL,
433 "-portrait",
434 "Sets portrait mode (both orientation and aspect ratio)"
435 },
436 {
437 "width", // Pen width
438 opt_width,
439 NULL,
440 NULL,
442 "-width width",
443 "Sets pen width (0 <= width)"
444 },
445 {
446 "bg", // Background color
447 opt_bg,
448 NULL,
449 NULL,
451 "-bg color",
452 "Background color (e.g., FF0000=opaque red, 0000FF_0.1=blue with alpha of 0.1)"
453 },
454 {
455 "ncol0", // Allocated colors in cmap 0
456 opt_ncol0,
457 NULL,
458 NULL,
460 "-ncol0 n",
461 "Number of colors to allocate in cmap 0 (upper bound)"
462 },
463 {
464 "ncol1", // Allocated colors in cmap 1
465 opt_ncol1,
466 NULL,
467 NULL,
469 "-ncol1 n",
470 "Number of colors to allocate in cmap 1 (upper bound)"
471 },
472 {
473 "fam", // Familying on switch
474 opt_fam,
475 NULL,
476 NULL,
478 "-fam",
479 "Create a family of output files"
480 },
481 {
482 "fsiz", // Family file size
483 opt_fsiz,
484 NULL,
485 NULL,
487 "-fsiz size[kKmMgG]",
488 "Output family file size (e.g. -fsiz 0.5G, def MB)"
489 },
490 {
491 "fbeg", // Family starting member
492 opt_fbeg,
493 NULL,
494 NULL,
496 "-fbeg number",
497 "First family member number on output"
498 },
499 {
500 "finc", // Family member increment
501 opt_finc,
502 NULL,
503 NULL,
505 "-finc number",
506 "Increment between family members"
507 },
508 {
509 "fflen", // Family member min field width
510 opt_fflen,
511 NULL,
512 NULL,
514 "-fflen length",
515 "Family member number minimum field width"
516 },
517 {
518 "nopixmap", // Do not use pixmaps
520 NULL,
521 NULL,
523 "-nopixmap",
524 "Don't use pixmaps in X-based drivers"
525 },
526 {
527 "db", // Double buffering on switch
528 opt_db,
529 NULL,
530 NULL,
532 "-db",
533 "Double buffer X window output"
534 },
535 {
536 "np", // Page pause off switch
537 opt_np,
538 NULL,
539 NULL,
541 "-np",
542 "No pause between pages"
543 },
544 {
545 "bufmax", // # bytes sent before flushing output
547 NULL,
548 NULL,
550 "-bufmax",
551 "bytes sent before flushing output"
552 },
553 {
554 "server_name", // Main window name of server
556 NULL,
557 NULL,
559 "-server_name name",
560 "Main window name of PLplot server (tk driver)"
561 },
562 {
563 "plserver", // PLplot server name
565 NULL,
566 NULL,
568 "-plserver name",
569 "Invoked name of PLplot server (tk driver)"
570 },
571 {
572 "plwindow", // PLplot container window name
574 NULL,
575 NULL,
577 "-plwindow name",
578 "Name of PLplot container window (tk driver)"
579 },
580 {
581 "auto_path", // Additional directory(s) to autoload
583 NULL,
584 NULL,
586 "-auto_path dir",
587 "Additional directory(s) to autoload (tk driver)"
588 },
589 {
590 "tk_file", // -file option for plserver
592 NULL,
593 NULL,
595 "-tk_file file",
596 "file for plserver (tk driver)"
597 },
598 {
599 "dpi", // Dots per inch
600 opt_dpi,
601 NULL,
602 NULL,
604 "-dpi dpi",
605 "Resolution, in dots per inch (e.g. -dpi 360x360)"
606 },
607 {
608 "compression", // compression
610 NULL,
611 NULL,
613 "-compression num",
614 "Sets compression level in supporting devices"
615 },
616 {
617 "cmap0",
618 opt_cmap0,
619 NULL,
620 NULL,
622 "-cmap0 file name",
623 "Initializes color table 0 from a cmap0.pal format file in one of standard PLplot paths."
624 },
625 {
626 "cmap1",
627 opt_cmap1,
628 NULL,
629 NULL,
631 "-cmap1 file name",
632 "Initializes color table 1 from a cmap1.pal format file in one of standard PLplot paths."
633 },
634 {
635 "locale",
637 NULL,
638 NULL,
640 "-locale",
641 "Use locale environment (e.g., LC_ALL, LC_NUMERIC, or LANG) to set LC_NUMERIC locale (which affects decimal point separator)."
642 },
643 {
644 "eofill",
646 NULL,
647 NULL,
649 "-eofill",
650 "For the case where the boundary of the filled region is self-intersecting, use the even-odd fill rule rather than the default nonzero fill rule."
651 },
652 {
653 "drvopt", // Driver specific options
655 NULL,
656 NULL,
658 "-drvopt option[=value][,option[=value]]*",
659 "Driver specific options"
660 },
661 {
662 "mfo", // Metafile output option
663 opt_mfo,
664 NULL,
665 NULL,
667 "-mfo PLplot metafile name",
668 "Write the plot to the specified PLplot metafile"
669 },
670 {
671 "mfi", // Metafile output option
672 opt_mfi,
673 NULL,
674 NULL,
676 "-mfi PLplot metafile name",
677 "Read the specified PLplot metafile"
678 },
679 {
680 NULL, // option
681 NULL, // handler
682 NULL, // client data
683 NULL, // address of variable to set
684 0, // mode flag
685 NULL, // short syntax
686 NULL
687 } // long syntax
688};
689
691 "All parameters must be white-space delimited. Some options are driver",
692 "dependent. Please see the PLplot reference document for more detail.",
693 NULL
694};
695
696//--------------------------------------------------------------------------
710//--------------------------------------------------------------------------
711
712typedef struct
713{
716 const char **notes;
718
721 "PLplot options",
723};
724
725#define PL_MAX_OPT_TABLES 10
727 {
729 "PLplot options",
731 }
732};
733
734// The structure that hold the driver specific command line options
735
736typedef struct DrvOptCmd
737{
738 char *option;
739 char *value;
742
743// the variable where opt_drvopt() stores the driver specific command line options
744static DrvOptCmd drv_opt = { NULL, NULL, NULL };
745
746static int tables = 1;
747
748PLINT
750{
751 int mode = 0, argc = 2, status;
752 char *argv[3];
753
754 argv[0] = (char *) opt;
755 argv[1] = (char *) opt_arg;
756 argv[2] = NULL;
757 mode =
762
763 status = plparseopts( &argc, argv, mode );
764 if ( status )
765 {
766 fprintf( stderr, "plsetopt: Unrecognized option %s\n", opt );
767 }
768 return status;
769}
770
771//--------------------------------------------------------------------------
772// plMergeOpts()
773//
780//--------------------------------------------------------------------------
781
782PLINT
784{
785 PLOptionTable *tab;
786
787 pllib_init();
788
789// Check to make sure option table has been terminated correctly
790
791 for ( tab = (PLOptionTable *) options; tab->opt; tab++ )
792 ;
793
794// We've reached the last table entry. All the subentries must be NULL or 0
795
796 if ( ( tab->handler != NULL ) ||
797 ( tab->client_data != NULL ) ||
798 ( tab->var != NULL ) ||
799 ( tab->mode != 0 ) ||
800 ( tab->syntax != NULL ) ||
801 ( tab->desc != NULL ) )
802 {
803 plabort( "plMergeOpts: input table improperly terminated" );
804 return 1;
805 }
806
807// No room for more tables
808
809 if ( tables++ >= PL_MAX_OPT_TABLES )
810 {
811 plabort( "plMergeOpts: max tables limit exceeded, table not merged" );
812 return 1;
813 }
814
817 ploption_info[tables - 1].notes = notes;
818
819 return 0;
820}
821
822//--------------------------------------------------------------------------
823// plClearOpts()
824//
827//--------------------------------------------------------------------------
828
829void
831{
832 tables = 0;
833}
834
835//--------------------------------------------------------------------------
836// plResetOpts()
837//
840//--------------------------------------------------------------------------
841
842void
844{
846 tables = 1;
847}
848
849//--------------------------------------------------------------------------
850// plparseopts()
851//
862//--------------------------------------------------------------------------
863
864PLINT
865c_plparseopts( int *p_argc, char **argv, PLINT mode )
866{
867 char **argsave, **argend;
868 int i, myargc, myargcsave, status = 0;
869
870
871// Initialize
872
873 mode_full = mode & PL_PARSE_FULL;
874 mode_quiet = mode & PL_PARSE_QUIET;
879 mode_skip = mode & PL_PARSE_SKIP;
880
881 myargc = ( *p_argc );
882 argend = argv + myargc;
883
884// If program name is first argument, save and advance
885
886 if ( !mode_noprogram )
887 {
888 // Just in case plparseopts has been called previously (e.g., with PL_PARSE_NODELETE).
889 if ( plsc->program )
890 free_mem( plsc->program );
891
892 // If plparseopts is not called again, this is freed in plend1.
893 plsc->program = plstrdup( argv[0] );
894 program = (PLCHAR_VECTOR) plsc->program;
895 --myargc; ++argv;
896 }
897 if ( myargc == 0 )
898 return 0;
899
900 // Process the command line
901
902 // Special hack to deal with -debug option before
903 // pllib_init() is called.
904 argsave = argv;
905 myargcsave = myargc;
906 for (; myargc > 0; --myargc, ++argv )
907 {
908 // Allow for "holes" in argv list
909 if ( *argv == NULL || *argv[0] == '\0' )
910 continue;
911
912 if ( ( !mode_nodash && !strcmp( *argv, "-debug" ) ) || ( mode_nodash && !strcmp( *argv, "debug" ) ) )
913 {
914 //fprintf(stderr, "Found debug option in argv\n");
915 // Loop over all options tables, starting with the last
916 for ( i = tables - 1; i >= 0; i-- )
917 {
918 // Check option table for option
919
920 status = ParseOpt( &myargc, &argv, p_argc, &argsave,
922
923 if ( !status )
924 break;
925 }
926 break;
927 }
928 }
929 // Restore pointers to condition before the above loop
930 // Although array length and content stored in those pointers
931 // is likely changed.
932 myargc = myargcsave;
933 argv = argsave;
934
935 pllib_init();
936
937 argsave = argv;
938 for (; myargc > 0; --myargc, ++argv )
939 {
940 // Allow for "holes" in argv list
941 if ( *argv == NULL || *argv[0] == '\0' )
942 continue;
943
944 // Loop over all options tables, starting with the last
945 for ( i = tables - 1; i >= 0; i-- )
946 {
947 // Check option table for option
948
949 status = ParseOpt( &myargc, &argv, p_argc, &argsave,
951
952 if ( !status )
953 break;
954 }
955
956 // Handle error return as specified by the mode flag
957
958 if ( status == -1 )
959 {
960 // No match. Keep going if mode_skip is set, otherwise abort if
961 // fully parsing, else return without error.
962
963 status = 0;
964
965 if ( mode_skip )
966 {
967 if ( !mode_nodelete )
968 *argsave++ = *argv;
969 continue;
970 }
971 if ( !mode_quiet && mode_full )
972 {
973 fprintf( stderr, "\nBad command line option \"%s\"\n", argv[0] );
974 plOptUsage();
975 }
976 if ( mode_full )
977 exit( 1 );
978
979 break;
980 }
981 else if ( status == 1 )
982 {
983 // Illegal or badly formed
984
985 if ( !mode_quiet )
986 {
987 fprintf( stderr, "\nBad command line option \"%s\"\n", argv[0] );
988 plOptUsage();
989 }
990 if ( mode_full )
991 exit( 1 );
992
993 break;
994 }
995 else if ( status == 2 )
996 {
997 // Informational option encountered (-h or -v)
998
999 exit( 0 );
1000 }
1001 }
1002
1003// Compress and NULL-terminate argv
1004
1005 if ( !mode_nodelete )
1006 {
1007 for ( i = 0; i < myargc; i++ )
1008 *argsave++ = *argv++;
1009
1010 if ( argsave < argend )
1011 {
1012 *argsave = NULL;
1013#ifdef HAVE_NSGETARGC
1014 //
1015 // Modify the global argc variable to match the shortened argv.
1016 // The global argc and argv must be kept consistent so that future
1017 // users of them (e.g. libraries loaded later with a device driver)
1018 // will not try to dereference the null pointer at the end of the
1019 // shortened argv array.
1020 //
1021 *_NSGetArgc() = *p_argc;
1022#endif
1023 }
1024 }
1025
1026 return status;
1027}
1028
1029//--------------------------------------------------------------------------
1030// ParseOpt()
1031//
1042//--------------------------------------------------------------------------
1043
1044static int
1045ParseOpt( int *p_myargc, char ***p_argv, int *p_argc, char ***p_argsave,
1046 PLOptionTable *option_table )
1047{
1048 PLOptionTable *tab;
1049 char *opt;
1050
1051// Only handle actual flags and their arguments
1052
1053 if ( mode_nodash || ( *p_argv )[0][0] == '-' )
1054 {
1055 opt = ( *p_argv )[0];
1056 if ( *opt == '-' )
1057 opt++;
1058
1059 for ( tab = option_table; tab->opt; tab++ )
1060 {
1061 // Skip if option not enabled
1062
1063 if ( tab->mode & PL_OPT_DISABLED )
1064 continue;
1065
1066 // Try to match it
1067
1068 if ( *opt == *tab->opt && !strcmp( opt, tab->opt ) )
1069 {
1070 // Option matched, so remove from argv list if applicable.
1071
1072 if ( !mode_nodelete )
1073 {
1074 if ( tab->mode & PL_OPT_NODELETE )
1075 ( *( *p_argsave )++ ) = ( **p_argv );
1076 else
1077 --( *p_argc );
1078 }
1079
1080 // Process option (and argument if applicable)
1081
1082 return ( ProcessOpt( opt, tab, p_myargc, p_argv, p_argc ) );
1083 }
1084 }
1085 }
1086
1087 return -1;
1088}
1089
1090//--------------------------------------------------------------------------
1091// ProcessOpt()
1092//
1102//--------------------------------------------------------------------------
1103
1104static int
1105ProcessOpt( char * opt, PLOptionTable *tab, int *p_myargc, char ***p_argv,
1106 int *p_argc )
1107{
1108 int need_arg, res;
1109 char *opt_arg = NULL;
1110
1111// Get option argument if necessary
1112
1114
1115 if ( tab->mode & need_arg )
1116 {
1117 if ( GetOptarg( &opt_arg, p_myargc, p_argv, p_argc ) )
1118 return 1;
1119 }
1120
1121// Process argument
1122
1123 switch ( tab->mode & 0xFF00 )
1124 {
1125 case PL_OPT_FUNC:
1126
1127 // Call function handler to do the job
1128
1129 if ( tab->handler == NULL )
1130 {
1131 fprintf( stderr,
1132 "ProcessOpt: no handler specified for option %s\n",
1133 tab->opt );
1134 return 1;
1135 }
1136
1137 if ( mode_nodelete && opt_arg )
1138 {
1139 // Make a copy, since handler may mung opt_arg with strtok()
1140 char *copy =
1141 (char *) malloc( (size_t) ( 1 + strlen( opt_arg ) ) * sizeof ( char ) );
1142 if ( copy == NULL )
1143 {
1144 plabort( "ProcessOpt: out of memory" );
1145 return 1;
1146 }
1147 strcpy( copy, opt_arg );
1148 res = ( ( *tab->handler )( opt, copy, tab->client_data ) );
1149 free( (void *) copy );
1150 return res;
1151 }
1152 else
1153 {
1154 return ( ( *tab->handler )( opt, opt_arg, tab->client_data ) );
1155 }
1156
1157 case PL_OPT_BOOL:
1158
1159 // Set *var as a boolean
1160
1161 if ( tab->var == NULL )
1162 {
1163 fprintf( stderr,
1164 "ProcessOpt: no variable specified for option %s\n",
1165 tab->opt );
1166 return 1;
1167 }
1168 *(int *) tab->var = 1;
1169 break;
1170
1171 case PL_OPT_INT:
1172
1173 // Set *var as an int
1174
1175 if ( tab->var == NULL )
1176 {
1177 fprintf( stderr,
1178 "ProcessOpt: no variable specified for option %s\n",
1179 tab->opt );
1180 return 1;
1181 }
1182 *(int *) tab->var = atoi( opt_arg );
1183 break;
1184
1185 case PL_OPT_FLOAT:
1186
1187 // Set *var as a float
1188
1189 if ( tab->var == NULL )
1190 {
1191 fprintf( stderr,
1192 "ProcessOpt: no variable specified for option %s\n",
1193 tab->opt );
1194 return 1;
1195 }
1196 *(PLFLT *) tab->var = atof( opt_arg );
1197 break;
1198
1199 case PL_OPT_STRING:
1200
1201 // Set var (can be NULL initially) to point to opt_arg string
1202
1203 *(char **) tab->var = opt_arg;
1204 break;
1205
1206 default:
1207
1208 // Somebody messed up..
1209
1210 fprintf( stderr,
1211 "ProcessOpt: invalid processing mode for option %s\n",
1212 tab->opt );
1213 return 1;
1214 }
1215 return 0;
1216}
1217
1218//--------------------------------------------------------------------------
1219// GetOptarg()
1220//
1231//--------------------------------------------------------------------------
1232
1233static int
1234GetOptarg( char **popt_arg, int *p_myargc, char ***p_argv, int *p_argc )
1235{
1236 int result = 0;
1237
1238 --( *p_myargc );
1239
1240 if ( ( *p_myargc ) <= 0 ) // oops, no more arguments
1241 result = 1;
1242
1243 if ( !result )
1244 {
1245 ( *p_argv )++;
1246 // Skip -bg argument checking since, for example, "-ffffff" is
1247 // valid but would be considered invalid by the crude test at
1248 // the end of the if. Instead, -bg always consumes the next
1249 // argument (which exists according to the test above) in any
1250 // form, and that argument is checked for validity by the
1251 // opt_bg routine.
1252 if ( strstr( ( ( *p_argv ) - 1 )[0], "-bg" ) != ( ( *p_argv ) - 1 )[0] && ( *p_argv )[0][0] == '-' && isalpha( ( *p_argv )[0][1] ) )
1253 {
1254 ( *p_argv )--; // oops, next arg is a flag
1255 result = 1;
1256 }
1257 }
1258
1259 if ( !result ) // yeah, the user got it right
1260 {
1261 if ( !mode_nodelete )
1262 ( *p_argc )--;
1263 *popt_arg = ( *p_argv )[0];
1264 }
1265 else
1266 {
1267 if ( !mode_quiet )
1268 {
1269 fprintf( stderr, "Argument missing for %s option.\n", ( *p_argv )[0] );
1270 plOptUsage();
1271 }
1272 }
1273 return result;
1274}
1275
1276//--------------------------------------------------------------------------
1277// plSetUsage()
1278//
1284//--------------------------------------------------------------------------
1285
1286void
1287plSetUsage( PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string )
1288{
1289 if ( program_string != NULL )
1290 program = program_string;
1291
1292 if ( usage_string != NULL )
1293 usage = usage_string;
1294}
1295
1296//--------------------------------------------------------------------------
1297// plOptUsage()
1298//
1301//--------------------------------------------------------------------------
1302
1303void
1305{
1306 if ( usage == NULL )
1307 fprintf( stderr, "\nUsage:\n %s [options]\n", program );
1308 else
1309 fputs( usage, stderr );
1310
1311 Syntax();
1312
1313 fprintf( stderr, "\n\nType %s -h for a full description.\n\n",
1314 program );
1315}
1316
1317//--------------------------------------------------------------------------
1318// Syntax()
1319//
1322//--------------------------------------------------------------------------
1323
1324static void
1325Syntax( void )
1326{
1327 PLOptionTable *tab;
1328 int i, col, len;
1329
1330// Loop over all options tables
1331
1332 for ( i = tables - 1; i >= 0; i-- )
1333 {
1334 // Introducer
1335
1336 if ( ploption_info[i].name )
1337 fprintf( stderr, "\n%s:", ploption_info[i].name );
1338 else
1339 fputs( "\nUser options:", stderr );
1340
1341 // Print syntax for each option
1342
1343 col = 80;
1344 for ( tab = ploption_info[i].options; tab->opt; tab++ )
1345 {
1346 if ( tab->mode & PL_OPT_DISABLED )
1347 continue;
1348
1349 if ( !mode_showall && ( tab->mode & PL_OPT_INVISIBLE ) )
1350 continue;
1351
1352 if ( tab->syntax == NULL )
1353 continue;
1354
1355 len = 3 + (int) strlen( tab->syntax ); // space [ string ]
1356 if ( col + len > 79 )
1357 {
1358 fprintf( stderr, "\n " ); // 3 spaces
1359 col = 3;
1360 }
1361 fprintf( stderr, " [%s]", tab->syntax );
1362 col += len;
1363 }
1364 fprintf( stderr, "\n" );
1365 }
1366}
1367
1368//--------------------------------------------------------------------------
1369// Help()
1370//
1373//--------------------------------------------------------------------------
1374
1375static void
1376Help( void )
1377{
1378 PLOptionTable *tab;
1379 const char **note;
1380 int i;
1381 FILE *outfile = stderr;
1382
1383#ifdef HAVE_POPEN
1384 FILE *pager = NULL;
1385 if ( getenv( "PAGER" ) != NULL )
1386 pager = (FILE *) popen( "$PAGER", "w" );
1387 if ( pager == NULL )
1388 pager = (FILE *) popen( "more", "w" );
1389 if ( pager != NULL )
1390 outfile = pager;
1391#endif
1392
1393// Usage line
1394
1395 if ( usage == NULL )
1396 fprintf( outfile, "\nUsage:\n %s [options]\n", program );
1397 else
1398 fputs( usage, outfile );
1399
1400// Loop over all options tables
1401
1402 for ( i = tables - 1; i >= 0; i-- )
1403 {
1404 // Introducer
1405
1406 if ( ploption_info[i].name )
1407 fprintf( outfile, "\n%s:\n", ploption_info[i].name );
1408 else
1409 fputs( "\nUser options:\n", outfile );
1410
1411 // Print description for each option
1412
1413 for ( tab = ploption_info[i].options; tab->opt; tab++ )
1414 {
1415 if ( tab->mode & PL_OPT_DISABLED )
1416 continue;
1417
1418 if ( !mode_showall && ( tab->mode & PL_OPT_INVISIBLE ) )
1419 continue;
1420
1421 if ( tab->desc == NULL )
1422 continue;
1423
1424 if ( tab->mode & PL_OPT_INVISIBLE )
1425 fprintf( outfile, " * %-20s %s\n", tab->syntax, tab->desc );
1426 else
1427 fprintf( outfile, " %-20s %s\n", tab->syntax, tab->desc );
1428 }
1429
1430 // Usage notes
1431
1432 if ( ploption_info[i].notes )
1433 {
1434 putc( '\n', outfile );
1435 for ( note = ploption_info[i].notes; *note; note++ )
1436 {
1437 fputs( *note, outfile );
1438 putc( '\n', outfile );
1439 }
1440 }
1441 }
1442
1443#ifdef HAVE_POPEN
1444 if ( pager != NULL )
1445 pclose( pager );
1446#endif
1447}
1448
1449//--------------------------------------------------------------------------
1450// plParseDrvOpts
1451//
1458//--------------------------------------------------------------------------
1459
1460int
1462{
1463 DrvOptCmd *drvp;
1464 DrvOpt *t;
1465 int fl;
1466 char msg[80];
1467 memset( msg, '\0', sizeof ( msg ) );
1468
1469 if ( !drv_opt.option )
1470 return 1;
1471
1472 drvp = &drv_opt;
1473 do
1474 {
1475 t = acc_opt; fl = 0;
1476 while ( t->opt )
1477 {
1478 if ( strcmp( drvp->option, t->opt ) == 0 )
1479 {
1480 fl = 1;
1481 switch ( t->type )
1482 {
1483 case DRV_STR:
1484 *(char **) ( t->var_ptr ) = ( drvp->value );
1485#ifdef DEBUG
1486 fprintf( stderr, "plParseDrvOpts: %s %s\n", t->opt, *(char **) t->var_ptr );
1487#endif
1488 break;
1489
1490 case DRV_INT:
1491 if ( sscanf( drvp->value, "%d", (int *) t->var_ptr ) != 1 )
1492 {
1493 snprintf( msg, sizeof ( msg ) - 1, "Incorrect argument to '%s' option", drvp->option );
1494 plexit( msg );
1495 }
1496#ifdef DEBUG
1497 fprintf( stderr, "plParseDrvOpts: %s %d\n", t->opt, *(int *) t->var_ptr );
1498#endif
1499 break;
1500
1501 case DRV_FLT:
1502 if ( sscanf( drvp->value, "%f", (float *) t->var_ptr ) != 1 )
1503 {
1504 snprintf( msg, sizeof ( msg ) - 1, "Incorrect argument to '%s' option", drvp->option );
1505 plexit( msg );
1506 }
1507#ifdef DEBUG
1508 fprintf( stderr, "plParseDrvOpts: %s %f\n", t->opt, *(float *) t->var_ptr );
1509#endif
1510 break;
1511 }
1512 }
1513 t++;
1514 }
1515
1516 if ( !fl )
1517 {
1518 snprintf( msg, sizeof ( msg ) - 1, "Option '%s' not recognized.\n\nRecognized options for this driver are:\n", drvp->option );
1519 plwarn( msg );
1520 plHelpDrvOpts( acc_opt );
1521 plexit( "" );
1522 }
1523 }
1524 while ( ( drvp = drvp->next ) )
1525 ;
1526
1527 return 0;
1528}
1529
1530//--------------------------------------------------------------------------
1531// plHelpDrvOpts
1532//
1537//--------------------------------------------------------------------------
1538
1539void
1541{
1542 DrvOpt *t;
1543
1544 t = acc_opt;
1545 while ( t->opt )
1546 {
1547 fprintf( stderr, "%s:\t%s\n", t->opt, t->hlp_msg );
1548 t++;
1549 }
1550}
1551
1552//--------------------------------------------------------------------------
1553// tidyDrvOpts
1554//
1557//--------------------------------------------------------------------------
1558
1559void
1561{
1562 DrvOptCmd *drvp, *drvpl;
1563
1564 drvp = &drv_opt;
1565 do
1566 {
1567 drvpl = drvp;
1568 drvp = drvpl->next;
1569
1570 free( drvpl->option );
1571 free( drvpl->value );
1572 // Free additional DrvOptCmd variables -
1573 // first entry in list is a static global variable
1574 if ( drvpl != &drv_opt )
1575 free( drvpl );
1576 } while ( drvp != NULL );
1577
1578 // initialize drv_opt if it's used again
1579 drv_opt.option = NULL;
1580 drv_opt.value = NULL;
1581 drv_opt.next = NULL;
1582}
1583
1584
1585//--------------------------------------------------------------------------
1586// Option handlers
1587//--------------------------------------------------------------------------
1588
1589//--------------------------------------------------------------------------
1590// opt_h()
1591//
1601//--------------------------------------------------------------------------
1602
1603static int
1604opt_h( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
1605{
1606 if ( !mode_quiet )
1607 Help();
1608
1609 return 2;
1610}
1611
1612//--------------------------------------------------------------------------
1613// opt_v()
1614//
1624//--------------------------------------------------------------------------
1625
1626static int
1627opt_v( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
1628{
1629 if ( !mode_quiet )
1630 fprintf( stderr, "PLplot library version: %s\n", PLPLOT_VERSION );
1631
1632 return 2;
1633}
1634
1635//--------------------------------------------------------------------------
1636// opt_verbose()
1637//
1647//--------------------------------------------------------------------------
1648
1649static int
1650opt_verbose( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
1651{
1652 plsc->verbose = 1;
1653 return 0;
1654}
1655
1656//--------------------------------------------------------------------------
1657// opt_debug()
1658//
1668//--------------------------------------------------------------------------
1669
1670static int
1671opt_debug( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
1672{
1673 plsc->debug = 1;
1674 plsc->verbose = 1;
1675 return 0;
1676}
1677
1678//--------------------------------------------------------------------------
1679// opt_hack()
1680//
1690//--------------------------------------------------------------------------
1691
1692static int
1693opt_hack( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
1694{
1695 plsc->hack = 1;
1696 return 0;
1697}
1698
1699//--------------------------------------------------------------------------
1700// opt_dev()
1701//
1711//--------------------------------------------------------------------------
1712
1713static int
1714opt_dev( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
1715{
1716 plsdev( opt_arg );
1717 return 0;
1718}
1719
1720//--------------------------------------------------------------------------
1721// opt_o()
1722//
1732//--------------------------------------------------------------------------
1733
1734static int
1735opt_o( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
1736{
1737 plsfnam( opt_arg );
1738 return 0;
1739}
1740
1741//--------------------------------------------------------------------------
1742// opt_mar()
1743//
1753//--------------------------------------------------------------------------
1754
1755static int
1756opt_mar( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
1757{
1758 plsdidev( atof( opt_arg ), PL_NOTSET, PL_NOTSET, PL_NOTSET );
1759 return 0;
1760}
1761
1762//--------------------------------------------------------------------------
1763// opt_a()
1764//
1774//--------------------------------------------------------------------------
1775
1776static int
1777opt_a( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
1778{
1779 plsdidev( PL_NOTSET, atof( opt_arg ), PL_NOTSET, PL_NOTSET );
1780 return 0;
1781}
1782
1783//--------------------------------------------------------------------------
1784// opt_jx()
1785//
1795//--------------------------------------------------------------------------
1796
1797static int
1798opt_jx( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
1799{
1800 plsdidev( PL_NOTSET, PL_NOTSET, atof( opt_arg ), PL_NOTSET );
1801 return 0;
1802}
1803
1804//--------------------------------------------------------------------------
1805// opt_jy()
1806//
1816//--------------------------------------------------------------------------
1817
1818static int
1819opt_jy( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
1820{
1821 plsdidev( PL_NOTSET, PL_NOTSET, PL_NOTSET, atof( opt_arg ) );
1822 return 0;
1823}
1824
1825//--------------------------------------------------------------------------
1826// opt_ori()
1827//
1837//--------------------------------------------------------------------------
1838
1839static int
1840opt_ori( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
1841{
1842 plsdiori( atof( opt_arg ) );
1843 return 0;
1844}
1845
1846//--------------------------------------------------------------------------
1847// opt_freeaspect()
1848//
1858//--------------------------------------------------------------------------
1859
1860static int
1861opt_freeaspect( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
1862{
1863 plsc->freeaspect = 1;
1864 return 0;
1865}
1866
1867//--------------------------------------------------------------------------
1868// opt_portrait()
1869//
1893//--------------------------------------------------------------------------
1894
1895static int
1896opt_portrait( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
1897{
1898 plsc->portrait = 1;
1899 return 0;
1900}
1901
1902//--------------------------------------------------------------------------
1903// opt_width()
1904//
1914//--------------------------------------------------------------------------
1915
1916static int
1917opt_width( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
1918{
1919 double width;
1920
1921 width = atof( opt_arg );
1922 if ( width < 0. )
1923 {
1924 fprintf( stderr, "?invalid width\n" );
1925 return 1;
1926 }
1927 else
1928 {
1929 plwidth( width );
1930 plsc->widthlock = 1;
1931 }
1932 return 0;
1933}
1934
1935//--------------------------------------------------------------------------
1936// opt_bg()
1937//
1952//--------------------------------------------------------------------------
1953
1954static int
1955opt_bg( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
1956{
1957 PLCHAR_VECTOR rgb;
1958 char *color_field, *color_field_wp, *color_field_wp_alt, *alpha_field;
1959 char *endptr;
1960 long bgcolor;
1961 PLINT r, g, b;
1962 PLFLT a;
1963 int save_errno;
1964
1965 // Strip off leading "#" (TK-ism) if present.
1966
1967 if ( *opt_arg == '#' )
1968 rgb = opt_arg + 1;
1969 else
1970 rgb = opt_arg;
1971
1972 strncpy( opttmp, rgb, OPTMAX - 1 );
1973 opttmp[OPTMAX - 1] = '\0';
1974
1975 //fprintf( stderr, "-bg option = %s\n", opttmp );
1976 color_field = opttmp;
1977 alpha_field = strchr( opttmp, '_' );
1978 if ( alpha_field != NULL )
1979 {
1980 // null-terminate color_field at the position of the delimiter.
1981 *alpha_field = '\0';
1982 // point alpha_field at the position one beyond the delimiter.
1983 alpha_field++;
1984 }
1985 else
1986 {
1987 // If no delimiter, then assume opaque.
1988 alpha_field = "MAX_PLFLT_ALPHA";
1989 }
1990
1991 //fprintf( stderr, "color_field = %s\n", color_field );
1992 //fprintf( stderr, "alpha_field = %s\n", alpha_field );
1993
1994 // Parse color_field
1995 errno = 0; // To distinguish success/failure after call
1996 bgcolor = strtol( color_field, &endptr, 16 );
1997 save_errno = errno;
1998
1999 // Check for various possible errors
2000
2001 if ( ( errno == ERANGE && ( bgcolor == LONG_MIN || bgcolor == LONG_MAX ) ) || ( errno != 0 && bgcolor == 0 ) )
2002 {
2003 plwarn( "opt_bg: parsing of color_field as hex to a long caused integer overflow so use (warning) red" );
2004 fprintf( stderr, "%s\n", "Further information relevant to this warning:" );
2005 errno = save_errno;
2006 perror( "opt_bg strtol issue" );
2007 fprintf( stderr, "color_field = %s\n", color_field );
2008 color_field = "ff0000";
2009 fprintf( stderr, "derived color_field = %s\n", color_field );
2010 bgcolor = strtol( color_field, &endptr, 16 );
2011 fprintf( stderr, "derived bgcolor = %#lx\n", bgcolor );
2012 }
2013 else if ( endptr == color_field )
2014 {
2015 plwarn( "opt_bg: color_field could not be parsed as hex to a long so use (warning) red" );
2016 fprintf( stderr, "%s\n", "Further information relevant to this warning:" );
2017 fprintf( stderr, "color_field = %s\n", color_field );
2018 color_field = "ff0000";
2019 fprintf( stderr, "derived color_field = %s\n", color_field );
2020 bgcolor = strtol( color_field, &endptr, 16 );
2021 fprintf( stderr, "derived bgcolor = %#lx\n", bgcolor );
2022 }
2023 else if ( *endptr != '\0' )
2024 {
2025 plwarn( "opt_bg: color_field could be parsed as hex to a long but there was trailing garbage which was ignored" );
2026 fprintf( stderr, "%s\n", "Further information relevant to this warning:" );
2027 fprintf( stderr, "color_field = %s\n", color_field );
2028 // Trim trailing garbage off of color_field.
2029 *endptr = '\0';
2030 fprintf( stderr, "derived color_field = %s\n", color_field );
2031 fprintf( stderr, "derived bgcolor = %#lx\n", bgcolor );
2032 }
2033
2034 // If bgcolor has 3 digits, each is "doubled" (i.e. ABC becomes AABBCC).
2035
2036 // Find color_field without prefix where that prefix consists of optional whitespace followed
2037 // by optional sign followed by optional 0x or 0X.
2038 color_field_wp = color_field;
2039 while ( isspace( (unsigned char) *color_field_wp ) )
2040 color_field_wp++;
2041 if ( ( color_field_wp_alt = strstr( color_field_wp, "+" ) ) == color_field_wp ||
2042 ( color_field_wp_alt = strstr( color_field_wp, "-" ) ) == color_field_wp )
2043 color_field_wp += 1;
2044 if ( ( color_field_wp_alt = strstr( color_field_wp, "0x" ) ) == color_field_wp ||
2045 ( color_field_wp_alt = strstr( color_field_wp, "0X" ) ) == color_field_wp )
2046 color_field_wp += 2;
2047
2048 switch ( strlen( color_field_wp ) )
2049 {
2050 case 3:
2051 r = (PLINT) ( ( bgcolor & 0xF00 ) >> 8 );
2052 g = (PLINT) ( ( bgcolor & 0x0F0 ) >> 4 );
2053 b = (PLINT) ( bgcolor & 0x00F );
2054
2055 r = r | ( r << 4 );
2056 g = g | ( g << 4 ); // doubling
2057 b = b | ( b << 4 );
2058 break;
2059
2060 case 6:
2061 r = (PLINT) ( ( bgcolor & 0xFF0000 ) >> 16 );
2062 g = (PLINT) ( ( bgcolor & 0x00FF00 ) >> 8 );
2063 b = (PLINT) ( bgcolor & 0x0000FF );
2064 break;
2065
2066 default:
2067 plwarn( "opt_bg: color_field without prefix is not of the correct form. Therefore use (warning) red" );
2068 fprintf( stderr, "%s\n", "Further information relevant to this warning:" );
2069 fprintf( stderr, "color_field = %s\n", color_field );
2070 fprintf( stderr, "%s\n", "The correct form of color_field without prefix is exactly 3 or 6 hex digits" );
2071 fprintf( stderr, "color_field without prefix = %s\n", color_field_wp );
2072 r = MAX_PLINT_RGB;
2073 g = 0;
2074 b = 0;
2075 fprintf( stderr, "derived r, g, b = %d, %d, %d\n", r, g, b );
2076 }
2077
2078 // Parse alpha_field using strtod and checking for all potential issues.
2079 errno = 0; // To distinguish success/failure after call
2080 a = (PLFLT) strtod( alpha_field, &endptr );
2081 save_errno = errno;
2082
2083 // Check for various possible errors
2084
2085 if ( errno == ERANGE && ( a == HUGE_VAL || a == -HUGE_VAL ) )
2086 {
2087 plwarn( "opt_bg: parsing of alpha_field to a double caused floating overflow so use opaque" );
2088 fprintf( stderr, "%s\n", "Further information relevant to this warning:" );
2089 errno = save_errno;
2090 perror( "opt_bg strtod issue" );
2091 fprintf( stderr, "alpha_field = %s\n", alpha_field );
2092 a = MAX_PLFLT_ALPHA;
2093 fprintf( stderr, "derived alpha value = %e\n", a );
2094 }
2095 else if ( endptr == alpha_field )
2096 {
2097 plwarn( "opt_bg: alpha_field could not be parsed to a double so use opaque" );
2098 fprintf( stderr, "%s\n", "Further information relevant to this warning:" );
2099 fprintf( stderr, "alpha_field = %s\n", alpha_field );
2100 a = MAX_PLFLT_ALPHA;
2101 fprintf( stderr, "derived alpha value = %e\n", a );
2102 }
2103 else if ( *endptr != '\0' )
2104 {
2105 plwarn( "opt_bg: alpha_field could be parsed to a double but there was trailing garbage which was ignored" );
2106 fprintf( stderr, "%s\n", "Further information relevant to this warning:" );
2107 fprintf( stderr, "alpha_field = %s\n", alpha_field );
2108 fprintf( stderr, "derived alpha value = %e\n", a );
2109 }
2110
2111 //fprintf( stderr, "r, g, b, alpha = %d, %d, %d, %e\n", r, g, b, a );
2112 plscolbga( r, g, b, a );
2113
2114 return 0;
2115}
2116
2117//--------------------------------------------------------------------------
2118// opt_ncol0()
2119//
2129//--------------------------------------------------------------------------
2130
2131static int
2132opt_ncol0( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2133{
2134 plsc->ncol0 = atoi( opt_arg );
2135 return 0;
2136}
2137
2138//--------------------------------------------------------------------------
2139// opt_ncol1()
2140//
2150//--------------------------------------------------------------------------
2151
2152static int
2153opt_ncol1( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2154{
2155 plsc->ncol1 = atoi( opt_arg );
2156 return 0;
2157}
2158
2159//--------------------------------------------------------------------------
2160// opt_wplt()
2161//
2171//--------------------------------------------------------------------------
2172
2173static int
2174opt_wplt( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2175{
2176 char *field;
2177 PLFLT xl, yl, xr, yr;
2178
2179 strncpy( opttmp, opt_arg, OPTMAX - 1 );
2180 opttmp[OPTMAX - 1] = '\0';
2181
2182 if ( ( field = strtok( opttmp, "," ) ) == NULL )
2183 return 1;
2184
2185 xl = atof( field );
2186
2187 if ( ( field = strtok( NULL, "," ) ) == NULL )
2188 return 1;
2189
2190 yl = atof( field );
2191
2192 if ( ( field = strtok( NULL, "," ) ) == NULL )
2193 return 1;
2194
2195 xr = atof( field );
2196
2197 if ( ( field = strtok( NULL, "," ) ) == NULL )
2198 return 1;
2199
2200 yr = atof( field );
2201
2202 plsdiplt( xl, yl, xr, yr );
2203 return 0;
2204}
2205
2206//--------------------------------------------------------------------------
2207// opt_drvopt()
2208//
2218//--------------------------------------------------------------------------
2219
2220static int
2221opt_drvopt( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2222{
2223 char t, *tt, *option, *value;
2224 int fl = 0;
2225 DrvOptCmd *drvp;
2226
2227 option = (char *) malloc( (size_t) ( 1 + strlen( opt_arg ) ) * sizeof ( char ) );
2228 if ( option == NULL )
2229 plexit( "opt_drvopt: Out of memory!?" );
2230
2231 value = (char *) malloc( (size_t) ( 1 + strlen( opt_arg ) ) * sizeof ( char ) );
2232 if ( value == NULL )
2233 plexit( "opt_drvopt: Out of memory!?" );
2234
2235 drvp = &drv_opt;
2236 *option = *value = '\0';
2237 tt = option;
2238 while ( ( t = *opt_arg++ ) )
2239 {
2240 switch ( t )
2241 {
2242 case ',':
2243 if ( fl )
2244 fl = 0;
2245 else
2246 {
2247 value[0] = '1';
2248 value[1] = '\0';
2249 }
2250
2251 *tt = '\0'; tt = option;
2252 drvp->option = plstrdup( option ); // it should not be release, because of familying
2253 drvp->value = plstrdup( value ); // don't release
2254 drvp->next = (DrvOptCmd *) malloc( sizeof ( DrvOptCmd ) ); // don't release
2255 if ( drvp->next == NULL )
2256 plexit( "opt_drvopt: Out of memory!?\n" );
2257
2258 drvp = drvp->next;
2259 break;
2260
2261 case '=':
2262 fl = 1;
2263 *tt = '\0'; tt = value;
2264 break;
2265
2266 default:
2267 *tt++ = t;
2268 }
2269 }
2270
2271 *tt = '\0';
2272 if ( !fl )
2273 {
2274 value[0] = '1';
2275 value[1] = '\0';
2276 }
2277
2278 drvp->option = plstrdup( option ); // don't release
2279 drvp->value = plstrdup( value ); // don't release
2280 drvp->next = NULL;
2281
2282#ifdef DEBUG
2283 fprintf( stderr, "\nopt_drvopt: -drvopt parsed options:\n" );
2284 drvp = &drv_opt;
2285 do
2286 fprintf( stderr, "%s %s\n", drvp->option, drvp->value );
2287 while ( drvp = drvp->next );
2288 fprintf( stderr, "\n" );
2289#endif
2290
2291 free( option ); free( value );
2292
2293 return 0;
2294}
2295
2296//--------------------------------------------------------------------------
2297// opt_fam()
2298//
2308//--------------------------------------------------------------------------
2309
2310static int
2311opt_fam( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
2312{
2313 plsfam( 1, -1, -1 );
2314 return 0;
2315}
2316
2317//--------------------------------------------------------------------------
2318// opt_fsiz()
2319//
2338//--------------------------------------------------------------------------
2339
2340static int
2341opt_fsiz( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2342{
2343 PLINT bytemax;
2344 size_t len = strlen( opt_arg );
2345 char lastchar = opt_arg[len - 1];
2346 PLFLT multiplier = 1.0e6;
2347 char *spec = (char *) malloc( len + 1 );
2348
2349 if ( spec == NULL )
2350 plexit( "opt_fsiz: Insufficient memory" );
2351
2352// Interpret optional suffix
2353
2354 switch ( lastchar )
2355 {
2356 case 'k':
2357 case 'K':
2358 multiplier = 1.0e3; len--;
2359 break;
2360 case 'm':
2361 case 'M':
2362 multiplier = 1.0e6; len--;
2363 break;
2364 case 'g':
2365 case 'G':
2366 multiplier = 1.0e9; len--;
2367 break;
2368 }
2369 strncpy( spec, opt_arg, len );
2370 spec[len] = '\0';
2371
2372 bytemax = (PLINT) ( multiplier * atof( spec ) );
2373 if ( bytemax <= 0 )
2374 {
2375 fprintf( stderr, "?invalid file size %d. 2.14G is the maximum.\n", bytemax );
2376 return 1;
2377 }
2378 plsfam( 1, -1, bytemax );
2379
2380 free( spec );
2381 return 0;
2382}
2383
2384//--------------------------------------------------------------------------
2385// opt_fbeg()
2386//
2396//--------------------------------------------------------------------------
2397
2398static int
2399opt_fbeg( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2400{
2401 plsc->member = atoi( opt_arg );
2402
2403 return 0;
2404}
2405
2406//--------------------------------------------------------------------------
2407// opt_finc()
2408//
2418//--------------------------------------------------------------------------
2419
2420static int
2421opt_finc( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2422{
2423 plsc->finc = atoi( opt_arg );
2424
2425 return 0;
2426}
2427
2428//--------------------------------------------------------------------------
2429// opt_fflen()
2430//
2440//--------------------------------------------------------------------------
2441
2442static int
2443opt_fflen( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2444{
2445 plsc->fflen = atoi( opt_arg );
2446
2447 return 0;
2448}
2449
2450//--------------------------------------------------------------------------
2451// opt_np()
2452//
2462//--------------------------------------------------------------------------
2463
2464static int
2465opt_np( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
2466{
2467 plspause( 0 );
2468 return 0;
2469}
2470
2471//--------------------------------------------------------------------------
2472// opt_nopixmap()
2473//
2483//--------------------------------------------------------------------------
2484
2485static int
2486opt_nopixmap( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
2487{
2488 plsc->nopixmap = 1;
2489 return 0;
2490}
2491
2492//--------------------------------------------------------------------------
2493// opt_db()
2494//
2504//--------------------------------------------------------------------------
2505
2506static int
2507opt_db( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
2508{
2509 plsc->db = 1;
2510 return 0;
2511}
2512
2513//--------------------------------------------------------------------------
2514// opt_bufmax()
2515//
2525//--------------------------------------------------------------------------
2526
2527static int
2528opt_bufmax( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2529{
2530 plsc->bufmax = atoi( opt_arg );
2531 return 0;
2532}
2533
2534//--------------------------------------------------------------------------
2535// opt_server_name()
2536//
2546//--------------------------------------------------------------------------
2547
2548static int
2549opt_server_name( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2550{
2551 plsc->server_name = plstrdup( opt_arg );
2552 return 0;
2553}
2554
2555//--------------------------------------------------------------------------
2556// opt_plserver()
2557//
2567//--------------------------------------------------------------------------
2568
2569static int
2570opt_plserver( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2571{
2572 plsc->plserver = plstrdup( opt_arg );
2573 return 0;
2574}
2575
2576//--------------------------------------------------------------------------
2577// opt_plwindow()
2578//
2588//--------------------------------------------------------------------------
2589
2590static int
2591opt_plwindow( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2592{
2593 if ( ( plsc->plwindow = (char *) malloc( (size_t) ( 1 + strlen( opt_arg ) ) * sizeof ( char ) ) ) == NULL )
2594 {
2595 plexit( "opt_plwindow: Insufficient memory" );
2596 }
2597 strcpy( plsc->plwindow, opt_arg );
2598 return 0;
2599}
2600
2601//--------------------------------------------------------------------------
2602// opt_auto_path()
2603//
2613//--------------------------------------------------------------------------
2614
2615static int
2616opt_auto_path( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2617{
2618 plsc->auto_path = plstrdup( opt_arg );
2619 return 0;
2620}
2621
2622//--------------------------------------------------------------------------
2623// opt_px()
2624//
2634//--------------------------------------------------------------------------
2635
2636static int
2637opt_px( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2638{
2639 plssub( atoi( opt_arg ), -1 );
2640 return 0;
2641}
2642
2643//--------------------------------------------------------------------------
2644// opt_py()
2645//
2655//--------------------------------------------------------------------------
2656
2657static int
2658opt_py( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2659{
2660 plssub( -1, atoi( opt_arg ) );
2661 return 0;
2662}
2663
2664//--------------------------------------------------------------------------
2665// opt_geo()
2666//
2680//--------------------------------------------------------------------------
2681
2682static int
2683opt_geo( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2684{
2685 int numargs;
2686 PLFLT xdpi = 0., ydpi = 0.;
2687 PLINT xwid, ywid, xoff, yoff;
2688
2689// The TK driver uses the geometry string directly
2690
2691 if ( ( plsc->geometry = (char *) malloc( (size_t) ( 1 + strlen( opt_arg ) ) * sizeof ( char ) ) ) == NULL )
2692 {
2693 plexit( "opt_geo: Insufficient memory" );
2694 }
2695
2696 strcpy( plsc->geometry, opt_arg );
2697
2698 numargs = sscanf( opt_arg, "%dx%d%d%d", &xwid, &ywid, &xoff, &yoff );
2699 if ( numargs == 2 )
2700 {
2701 xoff = 0;
2702 yoff = 0;
2703 if ( xwid == 0 )
2704 fprintf( stderr, "?invalid xwid in -geometry %s\n", opt_arg );
2705 if ( ywid == 0 )
2706 fprintf( stderr, "?invalid ywid in -geometry %s\n", opt_arg );
2707 if ( xwid < 0 )
2708 {
2709 fprintf( stderr, "?invalid xwid in -geometry %s\n", opt_arg );
2710 return 1;
2711 }
2712 if ( ywid < 0 )
2713 {
2714 fprintf( stderr, "?invalid ywid in -geometry %s\n", opt_arg );
2715 return 1;
2716 }
2717 }
2718 else if ( numargs == 4 )
2719 {
2720 if ( xwid == 0 )
2721 fprintf( stderr, "?invalid xwid in -geometry %s\n", opt_arg );
2722 if ( ywid == 0 )
2723 fprintf( stderr, "?invalid ywid in -geometry %s\n", opt_arg );
2724 if ( xwid < 0 )
2725 {
2726 fprintf( stderr, "?invalid xwid in -geometry %s\n", opt_arg );
2727 return 1;
2728 }
2729 if ( ywid < 0 )
2730 {
2731 fprintf( stderr, "?invalid ywid in -geometry %s\n", opt_arg );
2732 return 1;
2733 }
2734 if ( abs( xoff ) == 0 )
2735 fprintf( stderr, "?invalid xoff in -geometry %s\n", opt_arg );
2736 if ( abs( yoff ) == 0 )
2737 fprintf( stderr, "?invalid yoff in -geometry %s\n", opt_arg );
2738 }
2739 else
2740 {
2741 numargs = sscanf( opt_arg, "%d%d", &xoff, &yoff );
2742 if ( numargs == 2 )
2743 {
2744 xwid = 0;
2745 ywid = 0;
2746 if ( abs( xoff ) == 0 )
2747 fprintf( stderr, "?invalid xoff in -geometry %s\n", opt_arg );
2748 if ( abs( yoff ) == 0 )
2749 fprintf( stderr, "?invalid yoff in -geometry %s\n", opt_arg );
2750 }
2751 else
2752 {
2753 fprintf( stderr, "?invalid -geometry %s\n", opt_arg );
2754 return 1;
2755 }
2756 }
2757 //fprintf( stderr, "xwid, ywid, xoff, yoff = %d, %d, %d, %d\n", xwid, ywid, xoff, yoff );
2758 plspage( xdpi, ydpi, xwid, ywid, xoff, yoff );
2759 return 0;
2760}
2761
2762//--------------------------------------------------------------------------
2763// opt_tk_file()
2764//
2773//--------------------------------------------------------------------------
2774
2775static int
2776opt_tk_file( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2777{
2778 if ( ( plsc->tk_file = (char *) malloc( (size_t) ( 1 + strlen( opt_arg ) ) * sizeof ( char ) ) ) == NULL )
2779 {
2780 plexit( "opt_tk_file: Insufficient memory" );
2781 }
2782
2783 strcpy( plsc->tk_file, opt_arg );
2784 return 0;
2785}
2786
2787//--------------------------------------------------------------------------
2788// opt_dpi()
2789//
2803//--------------------------------------------------------------------------
2804
2805static int
2806opt_dpi( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2807{
2808 char *field;
2809 PLFLT xdpi = 0., ydpi = 0.;
2810 PLINT xwid = 0, ywid = 0, xoff = 0, yoff = 0;
2811
2812 strncpy( opttmp, opt_arg, OPTMAX - 1 );
2813 opttmp[OPTMAX - 1] = '\0';
2814 if ( strchr( opttmp, 'x' ) )
2815 {
2816 field = strtok( opttmp, "x" );
2817 xdpi = atof( field );
2818 if ( xdpi == 0 )
2819 fprintf( stderr, "?invalid xdpi\n" );
2820
2821 if ( ( field = strtok( NULL, " " ) ) == NULL )
2822 return 1;
2823
2824 ydpi = atof( field );
2825 if ( ydpi == 0 )
2826 fprintf( stderr, "?invalid ydpi\n" );
2827 }
2828 else
2829 {
2830 xdpi = atof( opttmp );
2831 ydpi = xdpi;
2832 if ( xdpi == 0 )
2833 return 1;
2834 }
2835
2836 plspage( xdpi, ydpi, xwid, ywid, xoff, yoff );
2837 return 0;
2838}
2839
2840//--------------------------------------------------------------------------
2841// opt_dev_compression()
2842//
2851//--------------------------------------------------------------------------
2852
2853static int
2854opt_dev_compression( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2855{
2856 PLINT comp = 0;
2857
2858 comp = atoi( opt_arg );
2859 if ( comp == 0 )
2860 {
2861 fprintf( stderr, "?invalid compression\n" );
2862 return 1;
2863 }
2864 plscompression( comp );
2865
2866 return 0;
2867}
2868
2869//--------------------------------------------------------------------------
2870// opt_cmap0()
2871//
2880//--------------------------------------------------------------------------
2881
2882static int
2883opt_cmap0( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2884{
2885 plspal0( opt_arg );
2886 return 0;
2887}
2888
2889//--------------------------------------------------------------------------
2890// opt_cmap1()
2891//
2900//--------------------------------------------------------------------------
2901
2902static int
2903opt_cmap1( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2904{
2905 plspal1( opt_arg, TRUE );
2906 return 0;
2907}
2908
2909//--------------------------------------------------------------------------
2910// opt_locale()
2911//
2920//--------------------------------------------------------------------------
2921
2922static int
2923opt_locale( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
2924{
2925 char *locale;
2926 if ( ( locale = setlocale( LC_NUMERIC, "" ) ) )
2927 {
2928 printf( "LC_NUMERIC locale set to \"%s\"\n", locale );
2929 }
2930 else
2931 {
2932 plwarn( "Could not use invalid environment (e.g., LC_ALL, LC_NUMERIC, or LANG) to set LC_NUMERIC locale. Falling back to LC_NUMERIC \"C\" locale instead.\n" );
2933 if ( !( locale = setlocale( LC_NUMERIC, "C" ) ) )
2934 {
2935 plexit( "Your platform is seriously broken. Not even a \"C\" locale could be set." );
2936 }
2937 }
2938 return 0;
2939}
2940
2941//--------------------------------------------------------------------------
2942// opt_eofill()
2943//
2954//--------------------------------------------------------------------------
2955
2956static int
2957opt_eofill( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR PL_UNUSED( opt_arg ), void * PL_UNUSED( client_data ) )
2958{
2959 plsc->dev_eofill = 1;
2960 if ( plsc->level > 0 )
2962 return 0;
2963}
2964
2965//--------------------------------------------------------------------------
2966// opt_mfo()
2967//
2976//--------------------------------------------------------------------------
2977
2978static int
2979opt_mfo( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
2980{
2981 if ( ( plsc->mf_outfile = (char *) malloc( (size_t) ( 1 + strlen( opt_arg ) ) * sizeof ( char ) ) ) == NULL )
2982 {
2983 plexit( "opt_mfo: Insufficient memory" );
2984 }
2985
2986 strcpy( plsc->mf_outfile, opt_arg );
2987 return 0;
2988}
2989
2990//--------------------------------------------------------------------------
2991// opt_mfi()
2992//
3001//--------------------------------------------------------------------------
3002
3003static int
3004opt_mfi( PLCHAR_VECTOR PL_UNUSED( opt ), PLCHAR_VECTOR opt_arg, void * PL_UNUSED( client_data ) )
3005{
3006 if ( ( plsc->mf_infile = (char *) malloc( (size_t) ( 1 + strlen( opt_arg ) ) * sizeof ( char ) ) ) == NULL )
3007 {
3008 plexit( "opt_mfi: Insufficient memory" );
3009 }
3010
3011 strcpy( plsc->mf_infile, opt_arg );
3012 return 0;
3013}
#define PLPLOT_VERSION
Definition plConfig.h:54
static int opt_eofill(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int mode_nodelete
Definition plargs.c:183
int plParseDrvOpts(DrvOpt *acc_opt)
Definition plargs.c:1461
static char opttmp[OPTMAX]
Definition plargs.c:192
static int opt_locale(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static void Syntax(void)
Definition plargs.c:1325
static int opt_plwindow(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_tk_file(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static PLCHAR_VECTOR program
Definition plargs.c:178
static int opt_ncol0(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
void plOptUsage(void)
Definition plargs.c:1304
static int mode_skip
Definition plargs.c:187
static int opt_bg(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_a(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
PLOptionInfo ploption_info[PL_MAX_OPT_TABLES]
Definition plargs.c:726
static int opt_server_name(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static PLCHAR_VECTOR plplot_notes[]
Definition plargs.c:690
PLOptionInfo ploption_info_default
Definition plargs.c:719
static int opt_finc(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int GetOptarg(char **, int *, char ***, int *)
Definition plargs.c:1234
static int opt_o(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_dev_compression(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_nopixmap(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_v(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
PLINT c_plsetopt(PLCHAR_VECTOR opt, PLCHAR_VECTOR opt_arg)
Definition plargs.c:749
static int opt_h(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_drvopt(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_jx(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_width(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_ncol1(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_geo(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_fam(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_db(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_wplt(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
PLINT c_plparseopts(int *p_argc, char **argv, PLINT mode)
Definition plargs.c:865
static int mode_noprogram
Definition plargs.c:185
static int opt_verbose(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static PLCHAR_VECTOR usage
Definition plargs.c:179
static int mode_full
Definition plargs.c:181
static int opt_freeaspect(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static void Help(void)
Definition plargs.c:1376
static int tables
Definition plargs.c:746
PLINT plMergeOpts(PLOptionTable *options, PLCHAR_VECTOR name, PLCHAR_VECTOR *notes)
Definition plargs.c:783
static int opt_mfo(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
void plHelpDrvOpts(DrvOpt *acc_opt)
Definition plargs.c:1540
static int opt_mar(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
void plClearOpts(void)
Definition plargs.c:830
static int opt_fbeg(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int mode_showall
Definition plargs.c:184
static int mode_quiet
Definition plargs.c:182
static int opt_bufmax(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static PLOptionTable ploption_table[]
Definition plargs.c:246
struct DrvOptCmd DrvOptCmd
static int opt_ori(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_np(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int mode_nodash
Definition plargs.c:186
static int opt_fflen(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int ProcessOpt(char *, PLOptionTable *, int *, char ***, int *)
Definition plargs.c:1105
static int ParseOpt(int *, char ***, int *, char ***, PLOptionTable *)
Definition plargs.c:1045
static int opt_jy(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
#define OPTMAX
Definition plargs.c:191
static int opt_cmap0(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_px(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_plserver(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
void plP_FreeDrvOpts()
Definition plargs.c:1560
static int opt_dev(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_dpi(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
void plResetOpts(void)
Definition plargs.c:843
static DrvOptCmd drv_opt
Definition plargs.c:744
static int opt_py(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_cmap1(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition plargs.c:1287
static int opt_auto_path(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
#define PL_MAX_OPT_TABLES
Definition plargs.c:725
static int opt_portrait(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_mfi(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_fsiz(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_debug(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
static int opt_hack(PLCHAR_VECTOR, PLCHAR_VECTOR, void *)
void pllib_init()
Definition plcore.c:2262
void plP_state(PLINT op)
Definition plcore.c:256
void plwarn(PLCHAR_VECTOR errormsg)
Definition plctrl.c:1863
static PLFLT value(double n1, double n2, double hue)
Definition plctrl.c:1219
void plexit(PLCHAR_VECTOR errormsg)
Definition plctrl.c:1958
char PLDLLIMPEXP * plstrdup(PLCHAR_VECTOR src)
Definition plctrl.c:2985
void plabort(PLCHAR_VECTOR errormsg)
Definition plctrl.c:1894
#define PLSTATE_EOFILL
Definition plplotP.h:370
@ DRV_FLT
Definition plplotP.h:758
@ DRV_INT
Definition plplotP.h:758
@ DRV_STR
Definition plplotP.h:758
#define TRUE
Definition plplotP.h:176
#define HUGE_VAL
Definition plplotP.h:274
#define free_mem(a)
Definition plplotP.h:182
#define PL_PARSE_SHOWALL
Definition plplot.h:363
#define plsfam
Definition plplot.h:816
#define PL_PARSE_FULL
Definition plplot.h:359
#define MAX_PLINT_RGB
Definition plplot.h:536
#define PL_PARSE_SKIP
Definition plplot.h:367
float PLFLT
Definition plplot.h:163
#define PL_NOTSET
Definition plplot.h:468
#define PL_OPT_NODELETE
Definition plplot.h:343
const char * PLCHAR_VECTOR
Definition plplot.h:243
#define plspal1
Definition plplot.h:833
#define plspause
Definition plplot.h:834
#define PL_OPT_FUNC
Definition plplot.h:349
#define plspal0
Definition plplot.h:832
#define plwidth
Definition plplot.h:863
#define MAX_PLFLT_ALPHA
Definition plplot.h:542
#define plsdev
Definition plplot.h:806
#define plscolbga
Definition plplot.h:803
#define PL_UNUSED(x)
Definition plplot.h:138
#define PL_OPT_ARG
Definition plplot.h:342
#define plparseopts
Definition plplot.h:778
#define plsdiori
Definition plplot.h:809
#define PL_OPT_INT
Definition plplot.h:351
#define PL_PARSE_NODELETE
Definition plplot.h:361
#define plspage
Definition plplot.h:831
#define PL_PARSE_QUIET
Definition plplot.h:360
#define PL_OPT_BOOL
Definition plplot.h:350
#define plscompression
Definition plplot.h:805
#define PL_OPT_INVISIBLE
Definition plplot.h:344
#define PL_OPT_DISABLED
Definition plplot.h:345
#define plsdiplt
Definition plplot.h:810
#define PL_OPT_STRING
Definition plplot.h:353
int PLINT
Definition plplot.h:181
#define plsdidev
Definition plplot.h:807
#define plsfnam
Definition plplot.h:818
#define PL_PARSE_NODASH
Definition plplot.h:366
#define PL_OPT_FLOAT
Definition plplot.h:352
#define PL_PARSE_NOPROGRAM
Definition plplot.h:365
#define plssub
Definition plplot.h:836
static int argc
Definition qt.cpp:48
static char ** argv
Definition qt.cpp:49
char * value
Definition plargs.c:739
struct DrvOptCmd * next
Definition plargs.c:740
char * option
Definition plargs.c:738
PLCHAR_VECTOR opt
Definition plplotP.h:750
PLINT type
Definition plplotP.h:751
PLCHAR_VECTOR hlp_msg
Definition plplotP.h:753
void * var_ptr
Definition plplotP.h:752
const char ** notes
Definition plargs.c:716
PLOptionTable * options
Definition plargs.c:714
PLCHAR_VECTOR name
Definition plargs.c:715
int(* handler)(PLCHAR_VECTOR, PLCHAR_VECTOR, PLPointer)
Definition plplot.h:398
PLCHAR_VECTOR desc
Definition plplot.h:403
PLCHAR_VECTOR opt
Definition plplot.h:397
PLCHAR_VECTOR syntax
Definition plplot.h:402
PLPointer client_data
Definition plplot.h:399
PLPointer var
Definition plplot.h:400
static PLOptionTable options[]
Definition tclMain.c:108
static const char * name
Definition tkMain.c:135