GRASS GIS 7 Programmer's Manual
Command Line Parsing


This section describes a standard mechanism for command line parsing in GRASS. The system is usually referred as parser, G_parser() or g.parser (because of the related g.parser module). Use of the provided set of functions will standardize GRASS modules that expect command line arguments, creating a family of GRASS modules that is easy for users to learn.

The standardization is important because as soon as a GRASS user familiarizes himself with the general form of command line input as defined by the parser, it will greatly simplify the necessity of remembering or at least guessing the required command line arguments for any GRASS command. It is strongly recommended, almost mandatory, that GRASS programmers use this set of functions for all command line parsing. With their use, the programmer is freed from the burden of generating user interface code for every command. The parser will limit the programmer to a pre-defined look and feel, but limiting the interface is well worth the shortened user learning curve. Moreover, system enables to generate module interface descriptions which can be used by GUI to generate a graphical interface for a module.

There are also standard options and flags which ensures even better standardization of names, values and descriptions.


The GRASS parser is a collection of functions and structures that are defined in the GRASS gis.h header file. These structures and functions allow the programmer to define the options and flags that make up the valid command line input of a GRASS command.

The parser functions behave in one of three ways:

  • If no command line arguments are entered by the user, the parser searches for a completely interactive version of the command. If the interactive version is found, control is passed over to this version.

  • If command line arguments are entered but they are a subset of the options and flags that the programmer has defined as required arguments, three things happen. The parser will pass an error message to the user indicating which required options and/or flags were missing from the command line, the parser will then display a complete usage message for that command, and finally the parser cancels execution of the command.

  • If all necessary options and flags are entered on the command line by the user, the parser executes the command with the given options and flags.
Python modules uses the same system but instead of functions and structures, comments in files are used to define options and flags.

Parser interface

The parser functions described below use two structures as defined in the GRASS gis.h header file.

This is a basic list of members of the Option and Flag structures. A comprehensive description of all elements of these two structures and their possible values can be found in Complete_Structure_Members_Description.

Option structure

The basic usage of the Option structure is as follows. You create a pointer to the Option structure.

struct Option *opt;

And then you call G_define_option() function which allocates memory for the Option structure and returns a pointer to it.

Then you set the structure members, basic members are:

  • key - Option name that user will use
  • description - Option description that is shown to the user
  • type - Variable type of the user's answer to the option
  • required - If this option is required on the command line?

For full list of members see Option structure documentation.

Flag structure

The basic usage of the Flag structure is as follows. You create a pointer to the Flag structure.

struct Flag *flag;

And then you call G_define_flag() function which allocates memory for the Flag structure and returns a pointer to it.

flag = G_define_flag()

Then you set the structure members, basic members are:

  • key - Single letter used for flag name
  • description - Flag description that is shown to the user

For full list of members see Flag structure documentation.

Running Parser

To process and check the command line parameters of you module, you need to call G_parser() function.

The command line parameters argv and the number of parameters argc from the main() routine are should be passed directly to G_parser() function. G_parser() function accepts the command line input entered by the user, and parses this input according to the input options and/or flags that were defined by the programmer.

G_parser() returns 0 if successful. If not successful, a usage statement is displayed that describes the expected and/or required options and flags and a non-zero value is returned.

Additional checks of command line parameters

When a G_parser() function is not sufficient to check all the details about the options and flags and their combinations, programmer has to add additional checks which are needed. If these checks are not successful programmer can call G_usage() function.

Calls to G_usage() allow the programmer to print the usage message at any time. This will explain the allowed and required command line input to the user. This description is given according to the programmer's definitions for options and flags. This function becomes useful when the user enters options and/or flags on the command line that are syntactically valid to the parser, but functionally invalid for the command (e.g. an invalid file name).

For example, the parser logic doesn't directly support grouping options. If two options be specified together or not at all, the parser must be told that these options are not required and the programmer must check that if one is specified the other must be as well. If this additional check fails, then G_parser() will succeed, but the programmer can then call G_usage() to print the standard usage message and print additional information about how the two options work together.

Displaying multiple answers default values

Providing multiple default values (answers) for option with allows multiple values is possible using:

char *def[] = {"One", "Two", "Last", NULL};
opt->multiple = YES;
opt->answers = def;

The programmer may not forget last NULL value.

New in GRASS 5.

Disabling interactive mode

This is mainly historical feature which enables to disable interactive prompting in command line.

When a user calls a command with no arguments on the command line, the parser will enter its own standardized interactive session in which all flags and options are presented to the user for input. A call to G_disable_interactive() disables the parser's interactive prompting.

Parser Programming Examples

The use of the parser in the programming process is demonstrated here. Both a basic step by step example and full code example are presented.

Step by Step Use of the Parser

These are the four basic steps to follow to implement the use of the GRASS parser in a GRASS command:

Allocate memory for Flags and Options

Options and flags are pointers to structures (Option and Flag structures) allocated through the parser functions G_define_option() and G_define_flag() as described in Parser interface.

#include <grass/gis.h>; /* The standard GRASS include file */
/* ... */
struct Option *opt; /* Establish an Option pointer for each option */
struct Flag *flag; /* Establish a Flag pointer for each option */
opt = G_define_option(); /* Request a pointer to memory for each option */
flag = G_define_flag(); /* Request a pointer to memory for each flag */

Define members of Flag and Option structures

The programmer should define the characteristics of each option and flag desired as outlined by the following example:

opt->key = "option"; /* The name of this option is "option". */
opt->description = _("Option test"); /* The option description is "Option test" */
opt->type = TYPE_STRING; /* The data type of the answer to the option */
opt->required = YES; /* This option *is* required from the user */
flag->key = "t"; /* Single letter name for flag */
flag->description = _("Flag test"); /* The flag description is "Flag test" */
There are more options defined in Complete Structure Members Table. You should for sure explore label member, options member and multiple member.

Call the parser

int main(int argc, char *argv[]); /* command line args passed into main() */
/* ... options and flags definitions */
if (G_parser(argc, argv)) /* Returns 0 if successful, non-zero otherwise */
/* ... additional checks */
/* ... module code */

Extracting information from the parser structures

The following lines will extract the information form option and flag and print it to the standard output.

fprintf(stdout, "For the option "%s" you chose: <%s>\n", opt->description, opt->answer);
fprintf(stdout, "The flag "-%s" is %s set.\n", flag->key, flag->answer ? "" : "not");

Running the example program

Once such a module has been compiled (see Compiling and Installing GRASS Modules), execution will result in the following user interface scenarios. Lines that begin with '$' (dollar sign) imply user entered commands on the command line.

$ r.mysample --help

This is a standard user call for basic help information on the module. The command line options (in this case, –help) are sent to the parser via G_parser(). The parser recognizes the –help command line option and returns a list of options and/or flags that are applicable for the specific command. Note how the programmer provided option and flag information is captured in the output.

r.mysample [-t] option=name

-t Flag test

option Option test

Now the following command is executed:

# r.mysample -t

This command line does not contain the required option. Note that the output provides this information along with the standard usage message (as already shown above):

Required parameter <option> not set (Option test).


r.mysample [-t] option=name

-t Flag test

option Option test

The following commands are correct and equivalent:

$ r.mysample option=Hello -t
$ r.mysample -t option=Hello

The parser provides no error messages and the module executes normally:

For the option "Option test" you chose: Hello
The flag "-t" is set.

Full Module Example

The following code demonstrates some of the basic capabilities of the parser. To compile this code, create this Makefile and run the make command (see Compiling and Installing GRASS Modules).


PGM = r.mysample


include $(MODULE_TOPDIR)/include/Make/Module.make

default: cmd

The sample C code follows (the usual name of the file with the main function is main.c. You might experiment with this code to familiarize yourself with the parser.

This example includes some of the advanced structure members described in Complete Structure Members Table.
#include <stdlib.h>
#include <string.h>
#include <grass/gis.h>
#include <grass/glocale.h>
int main(int argc, char *argv[])
struct Option *opt, *coor;
struct Flag *flag;
double X, Y;
int n;
opt = G_define_option();
opt->key = "debug";
opt->type = TYPE_STRING;
opt->required = NO;
opt->answer = "0";
opt->description = _("Debug level");
coor = G_define_option();
coor->key = "coordinate";
coor->key_desc = "x,y";
coor->type = TYPE_STRING;
coor->required = YES;
coor->multiple = YES;
coor->description = _("One or more coordinate(s)");
/* Note that coor->answer is not given a default value. */
flag = G_define_flag();
flag->key = 'v';
flag->description = _("Verbose execution");
/* Note that flag->answer is not given a default value. */
if (G_parser(argc, argv))
G_message("For the option <%s> you chose: <%s>",
opt->description, opt->answer);
G_message("The flag <%s> is: %s set", flag->key,
flag->answer ? "" : "not");
G_message("You specified the following coordinates:");
for (n=0; coor->answers[n] != NULL; n+=2) {
G_scan_easting(coor->answers[n], &X , G_projection());
G_scan_northing(coor->answers[n+1], &Y , G_projection());
fprintf(stdout, "%.15g,%.15g", X, Y);
This example defines option for coordinates in its own way to demonstrate usage of particular parser features. However, it must be noted that there is standardized option G_OPT_M_COORDS which should be used for coordinates.

Complete Structure Members Table

struct Flag

structure member C type required default description and example
key char YES none Key char used on command line
flag->key = 'f' ;
Description char * YES none String describing flag meaning
flag->description = _("run in fast mode") ;
answer char NO NULL Default and parser-returned flag states.

struct Option

structure member C type required default description and example
key char * YES none Key word used on command line.
opt->key = "map" ;
type int YES none Option type:
opt->type = TYPE_STRING ;
Description char * YES none String describing option along with gettext macro for internationalization opt->description = _("Map name") ;
answer char * NO NULL Default and parser-returned answer to an option.
opt->answer = "defaultmap" ;
key_desc char * NO NULL Single word describing the key. Commas in this string denote to the parser that several comma-separated arguments are expected from the user as one answer. For example, if a pair of coordinates is desired, this element might be defined as follows.
opt->key_desc = "x,y" ;
structure member C type required default description and example
multiple int NO NO Indicates whether the user can provide multiple answers or not. YES and NO are defined in "gis.h" and should be used (NO is the default.) Multiple is used in conjunction with the answers structure member below. opt->multiple = NO ;
answers NO NULL Multiple parser-returned answers to an option. N/A
required int NO NO Indicates whether user MUST provide the option on the command line. YES and NO are defined in "gis.h" and should be used (NO is the default.) opt->required = YES ;
options char * NO NULL Approved values or range of values.
opt->options = "red,blue,white" ;
For integers and doubles, the following format is available:
opt->options = "0-1000" ;
gisprompt char * NO NULL Interactive prompt guidance. There are three comma separated parts to this argument which guide the use of the standard GRASS file name prompting routines.
opt->gisprompt = "old,cell,raster" ;
checker char *() NO NULL Routine to check the answer to an option
m opt->checker = my_routine() ;

Description of Complex Structure Members

What follows are explanations of possibly confusing structure members. It is intended to clarify and supplement the structures table above.

Answer member of the Flag and Option structures

The answer structure member serves two functions for GRASS commands that use the parser.

(1) To set the default answer to an option:

If a default state is desired for a programmer-defined option, the programmer may define the Option structure member "answer" before calling G_parser() in his module. After the G_parser() call, the answer member will hold this preset default value if the user did not enter an option that has the default answer member value.

(2) To obtain the command-line answer to an option or flag:

After a call to G_parser(), the answer member will contain one of two values:

  • (a) If the user provided an option, and answered this option on the command line, the default value of the answer member (as described above) is replaced by the user's input.
  • (b) If the user provided an option, but did not answer this option on the command line, the default is not used. The user may use the default answer to an option by withholding mention of the option on the command line. But if the user enters an option without an answer, the default answer member value will be replaced and set to a NULL value by G_parser().

As an example, please review the use of answer members in the structures implemented in Full_Module_Example.

Multiple and Answers Members

The functionality of the answers structure member is reliant on the programmer's definition of the multiple structure member. If the multiple member is set to NO, the answer member is used to obtain the answer to an option as described above.

If the multiple structure member is set to YES, the programmer has told G_parser() to capture multiple answers. Multiple answers are separated by commas on the command line after an option.

Note: G_parser() does not recognize any character other than a comma to delimit multiple answers.

After the programmer has set up an option to receive multiple answers, these the answers are stored in the answers member of the Option structure. The answers member is an array that contains each individual user-entered answer. The elements of this array are the type specified by the programmer using the type member. The answers array contains however many comma-delimited answers the user entered, followed (terminated) by a NULL array element.

For example, here is a sample definition of an Option using multiple and answers structure members:

opt->key ="option";
opt->description = _("option example");
opt->required = NO;
opt->multiple = YES;

The above definition would ask the user for multiple integer answers to the option. If in response to a routine that contained the above code, the user entered "option=1,3,8,15" on the command line, the answers array would contain the following values:

answers[0] == 1
answers[1] == 3
answers[2] == 8
answers[3] == 15
answers[4] == NULL

key_desc Member

The key_desc structure member is used to define the format of a single command line answer to an option. A programmer may wish to ask for one answer to an option, but this answer may not be a single argument of a type set by the type structure member. If the programmer wants the user to enter a coordinate, for example, the programmer might define an Option as follows:

opt->key ="coordinate";
opt->description = _("Specified Coordinate");
opt->required = NO;
opt->key_desc = "x,y"
opt->multiple = NO;

The answer to this option would not be stored in the answer member, but in the answers member. If the user entered "coordinate=112,225" on the command line in response to a routine that contains the above option definition, the answers array would have the following values after the call to G_parser():

answers[0] == 112
answers[1] == 225
answers[2] == NULL

Note that "coordinate=112" would not be valid, as it does not contain both components of an answer as defined by the key_desc structure member.

If the multiple structure member were set to YES instead of NO in the example above, the answers are stored sequentially in the answers member. For example, if the user wanted to enter the coordinates (112,225), (142,155), and (43,201), his response on the command line would be "coordinate=112,225,142,155,43,201". Note that G_parser() recognizes only a comma for both the key_desc member, and for multiple answers.

The answers array would have the following values after a call to G_parser():

answers[0] == 112 answers[1] == 225
answers[2] == 142 answers[3] == 155
answers[4] == 43 answers[5] == 201
answers[6] == NULL

Note. In this case as well, neither "coordinate=112" nor "coordinate=112,225,142" would be valid command line arguments, as they do not contain even pairs of coordinates. Each answer's format (as described by the key_desc member) must be fulfilled completely.

The overall function of the key_desc and multiple structure members is very similar. The key_desc member is used to specify the number of required components of a single option answer (e.g. a multi-valued coordinate.) The multiple member tells G_parser() to ask the user for multiple instances of the compound answer as defined by the format in the key_desc structure member.

Another function of the key_desc structure member is to explain to the user the type of information expected as an answer. The coordinate example is explained above.

The usage message that is displayed by G_parser() in case of an error, or by G_usage() on programmer demand, is shown below. The Option "option" for the command a.out does not have its key_desc structure member defined.


a.out option=name

The use of "name" is a G_parser() standard. If the programmer defines the key_desc structure member before a call to G_parser(), the value of the key_desc member replaces "name". Thus, if the key_desc member is set to "x,y" as was used in an example above, the following usage message would be displayed:


a.out option=x,y

The key_desc structure member can be used by the programmer to clarify the usage message as well as specify single or multiple required components of a single option answer.

gisprompt Member

The gisprompt Option structure item requires a bit more description. The three comma-separated (no spaces allowed) sub-arguments are defined as follows:

  • First argument: "old" results in a call to the GRASS library subroutine G_open_old(), "new" to G_open_new(), otherwise "any" or "mapset".
    • If any option has "new" as the first component, the –o (overwrite) flag will be listed in the module's interface (–help output, manual page, GUI dialog, etc).
    • If an option which has "new" as the first component is given, the parser checks whether the entity (map, etc.) already exists.
  • Second argument: This is identical to the "element" argument in the above subroutine calls. It specifies a directory inside the mapset that may contain the user's response. In other words the second field is used to determine where to look for the file (i.e. if the option has "new,cell,...", it will look in the "cell" directory). The second field should be the name of one of the standard subdirectories of the mapset, as listed in $GISBASE/etc/element_list.
  • Third argument: Identical to the "prompt" argument in the above subroutine calls. This is a string presented to the user that describes the type of data element being requested.

Here are two examples:

"new,cell,raster"   G_open_new("cell", "map")
"old,vector,vector" G_open_old("vector", "map")

The gisprompt values are passed to any GUI code, both self-contained dialogs generated by the parser for the –ui option, and stand-alone GUIs (wxGUI) which use the –xml-description flags to obtain a machine-readable description of the module's interface. How the GUI interprets this is up to the GUI.

Standard options

There are standard options which ensures consistency in names and values of options. There are also standard flags which does the same.

Options are defined by the G_define_standard_option() function and flags are defined by the function G_define_standard_flag(). Both the options and flags are defined dynamically, so to get see the values of all members you need to open the file parser_standard_options.c.

The function G_define_standard_option() accepts one value of an STD_OPT enum defined in the file gis.h. When the G_define_standard_option() function calls the G_define_option() function, so there is no need to call it separately. The same applies also for standard flags which uses the G_define_standard_flag() function and STD_OPT enum.

Besides name and value standard options also defines label, description allowed values, their descriptions etc. The similar applies for the flags, too. After defining a standard option or flag you can still change individual parameters to exactly fit your needs.

Command line parsing FAQ

Can the user mix options and flags?

Yes. Options and flags can be given in any order.

In what order does the parser present options and flags?

Flags and options are presented by the usage message in the order that the programmer defines them using calls to G_define_option() and G_define_flag().

Is a user required to use full option names?

No. Users are required to type in only as many characters of an option name as is necessary to make the option choice unambiguous. If, for example, there are two options, "input=" and "output=", the following would be valid command line arguments:

# command i=map1 o=map2

# command in=map1 out=map2
Are options standardized at all?

Yes. There are a few conventions. Options which identify a single input map are usually "map=", not "raster=" or "vector=". In the case of an input and output map the convention is: "input=xx output=yy". By passing the '–help' flag to existing GRASS commands, it is likely that you will find other conventions. The desire is to make it as easy as possible for the user to remember (or guess correctly) what the command line syntax is for a given command.

To ensure maximal consistency, the most common options such as the options named above are defined as standard options and are available through G_define_standard_option() function. For flags you can use G_define_standard_flag() function.

How does a programmer query for coordinates?

There is standardized option G_OPT_M_COORDS which should be used for coordinates.

See the source code for the GRASS commands r.drain or r.cost for examples.

How does a programmer define that the option is a set of values?

For any user input that requires a set of arguments (like a pair of map coordinates) the programmer specifies the number of arguments in the key_desc member of the Option structure. For example, if opt->key_desc was set to "x,y", the parser will require that the user enter a pair of arguments separated only by a comma.

There is standardized option G_OPT_M_COORDS which should be used for coordinates.
How is automatic prompting turned off?

GRASS 4.0 introduced a new method for driving GRASS interactive and non-interactive modules as described in Compiling_and_Installing_GRASS_Programs. Here is a short overview.

For most modules a user runs a front-end module out of the GRASS bin directory which in turn looks for the existence of interactive and non-interactive versions of the module. If an interactive version exists and the user provided no command line arguments, then that version is executed.

In such a situation, the parser's default interaction will never be seen by the user. A programmer using the parser is able to avoid the front-end's default search for a fully interactive version of the command by placing a call to G_disable_interactive() before calling G_parser() (see Parser interface for details).