xref: /dports/biology/viennarna/ViennaRNA-2.4.18/src/bin/RNALalifold_cmdl.c

/*
  File autogenerated by gengetopt version 2.23
  generated with the following command:
  /usr/bin/gengetopt -i RNALalifold.ggo --file-name=RNALalifold_cmdl --include-getopt --default-optional --unamed-opts --func-name=RNALalifold_cmdline_parser --arg-struct-name=RNALalifold_args_info

  The developers of gengetopt consider the fixed text that goes in all
  gengetopt output files to be in the public domain:
  we make no copyright claims on it.
*/

/* If we use autoconf.  */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef FIX_UNUSED
#define FIX_UNUSED(X) (void) (X) /* avoid warnings for unused params */
#endif


#include "RNALalifold_cmdl.h"

const char *RNALalifold_args_info_purpose = "calculate locally stable secondary structures for a set of aligned RNAs";

const char *RNALalifold_args_info_usage = "Usage: RNALalifold [options] <file1.aln>";

const char *RNALalifold_args_info_versiontext = "";

const char *RNALalifold_args_info_description = "reads aligned RNA sequences from stdin or file.aln and calculates locally\nstable RNA secondary structure with a maximal base pair span. For a sequence of\nlength n and a base pair span of L the algorithm uses only O(n+L*L) memory and\nO(n*L*L) CPU time. Thus it is practical to \"scan\" very large genomes for\nshort RNA\n structures.\n";

const char *RNALalifold_args_info_detailed_help[] = {
  "  -h, --help                    Print help and exit",
  "      --detailed-help           Print help, including all details and hidden\n                                  options, and exit",
  "      --full-help               Print help, including hidden options, and exit",
  "  -V, --version                 Print version and exit",
  "\nGeneral Options:",
  "  Command line options which alter the general behavior of this program\n\n",
  "  -v, --verbose                 Be verbose.\n\n                                    (default=off)",
  "  -q, --quiet                   Be quiet.\n                                    (default=off)",
  "  This option can be used to minimize the output of additional information and\n  non-severe warnings which otherwise might spam stdout/stderr.\n\n",
  "      --noconv                  Do not automatically substitute nucleotide\n                                  \"T\" with \"U\"\n\n                                    (default=off)",
  "  -f, --input-format=C|S|F|M    File format of the input multiple sequence\n                                  alignment (MSA).\n",
  "  If this parameter is set, the input is considered to be in a particular file\n  format. Otherwise, the program tries to determine the file format\n  automatically, if an input file was provided in the set of parameters. In\n  case the input MSA is provided in interactive mode, or from a terminal (TTY),\n  the programs default is to assume CLUSTALW format.\n  Currently, the following formats are available: ClustalW (C), Stockholm 1.0\n  (S), FASTA/Pearson (F), and MAF (M).\n\n",
  "      --csv                     Create comma separated output (csv)\n\n                                    (default=off)",
  "      --aln[=prefix]            Produce output alignments and secondary\n                                  structure plots for each hit found.\n",
  "  This option tells the program to produce, for each hit, a colored and\n  structure annotated (sub)alignment and secondary structure plot in PostScript\n  format. It also adds the subalignment hit into a multi-Stockholm formatted\n  file \"RNALalifold_results.stk\". The postscript output file names are\n  \"aln_start_end.eps\" and \"ss_start_end.eps\". All files will be created in\n  the current directory. The optional argument string can be used to set a\n  specific prefix that is used to name the output files. The file names then\n  become \"prefix_aln_start_end.eps\", \"prefix_ss_start_end.eps\", and\n  \"prefix.stk\". Note: Any special characters in the prefix will be replaced\n  by the filename delimiter, hence there is no way to pass an entire directory\n  path through this option yet. (See also the \"--filename-delim\" parameter)\n\n",
  "      --aln-EPS[=prefix]        Produce colored and structure annotated\n                                  subalignment for each hit\n",
  "  The default file name used for the output is \"aln_start_end.eps\" where\n  \"start\" and \"end\" denote the first and last column of the subalignment\n  relative to the input (1-based). Users may change the filename to\n  \"prefix_aln_start_end.eps\" by specifying the prefix as optional argument.\n  Files will be create in the current directory. Note: Any special characters\n  in the prefix will be replaced by the filename delimiter, hence there is no\n  way to pass an entire directory path through this option yet. (See also the\n  \"--filename-delim\" parameter)\n\n",
  "      --aln-EPS-cols=INT        Number of columns in colored EPS alignment\n                                  output.\n                                    (default=`60')",
  "  A value less than 1 indicates that the output should not be wrapped at all.\n\n",
  "      --aln-EPS-ss[=prefix]     Produce colored consensus secondary structure\n                                  plots in PostScript format\n",
  "  The default file name used for the output is \"ss_start_end.eps\" where\n  \"start\" and \"end\" denote the first and last column of the subalignment\n  relative to the input (1-based). Users may change the filename to\n  \"prefix_ss_start_end.eps\" by specifying the prefix as optional argument.\n  Files will be create in the current directory. Note: Any special characters\n  in the prefix will be replaced by the filename delimiter, hence there is no\n  way to pass an entire directory path through this option yet. (See also the\n  \"--filename-delim\" parameter)\n\n",
  "      --aln-stk[=prefix]        Add hits to a multi-Stockholm formatted output\n                                  file.\n                                    (default=`RNALalifold_results')",
  "  The default file name used for the output is \"RNALalifold_results.stk\".\n  Users may change the filename to \"prefix.stk\" by specifying the prefix as\n  optional argument. The file will be create in the current directory if it\n  does not already exist. In case the file already exists, output will be\n  appended to it. Note: Any special characters in the prefix will be replaced\n  by the filename delimiter, hence there is no way to pass an entire directory\n  path through this option yet. (See also the \"--filename-delim\" parameter)\n\n",
  "      --auto-id                 Automatically generate an ID for each\n                                  alignment.\n                                    (default=off)",
  "  The default mode of RNALalifold is to automatically determine an ID from the\n  input alignment if the input file format allows to do that. Alignment IDs\n  are, for instance, usually given in Stockholm 1.0 formatted input. If this\n  flag is active, RNALalifold ignores any IDs retrieved from the input and\n  automatically generates an ID for each alignment.\n\n",
  "      --id-prefix=prefix        Prefix for automatically generated IDs (as used\n                                  in output file names)\n\n                                    (default=`alignment')",
  "  If this parameter is set, each alignment will be prefixed with the provided\n  string. Hence, the output files will obey the following naming scheme:\n  \"prefix_xxxx_ss.ps\" (secondary structure plot), \"prefix_xxxx_dp.ps\"\n  (dot-plot), \"prefix_xxxx_aln.ps\" (annotated alignment), etc. where xxxx is\n  the alignment number beginning with the second alignment in the input. Use\n  this setting in conjunction with the --continuous-ids flag to assign IDs\n  beginning with the first input alignment.\n\n",
  "      --id-delim=delimiter      Change the delimiter between prefix and\n                                  increasing number for automatically generated\n                                  IDs (as used in output file names)\n\n                                    (default=`_')",
  "  This parameter can be used to change the default delimiter \"_\" between\n   the prefix string and the increasing number for automatically generated ID.\n\n",
  "      --id-digits=INT           Specify the number of digits of the counter in\n                                  automatically generated alignment IDs.\n                                    (default=`4')",
  "  When alignments IDs are automatically generated, they receive an increasing\n  number, starting with 1. This number will always be left-padded by leading\n  zeros, such that the number takes up a certain width. Using this parameter,\n  the width can be specified to the users need. We allow numbers in the range\n  [1:18].\n\n",
  "      --id-start=LONG           Specify the first number in automatically\n                                  generated alignment IDs.\n                                    (default=`1')",
  "  When alignment IDs are automatically generated, they receive an increasing\n  number, usually starting with 1. Using this parameter, the first number can\n  be specified to the users requirements. Note: negative numbers are not\n  allowed.\n  Note: Setting this parameter implies continuous alignment IDs, i.e. it\n  activates the --continuous-ids flag.\n\n",
  "      --filename-delim=delimiter\n                                Change the delimiting character that is used\n                                  for sanitized filenames\n\n                                    (default=`ID-delimiter')",
  "  This parameter can be used to change the delimiting character used while\n  sanitizing filenames, i.e. replacing invalid characters. Note, that the\n  default delimiter ALWAYS is the first character of the \"ID delimiter\" as\n  supplied through the --id-delim option. If the delimiter is a whitespace\n  character or empty, invalid characters will be simply removed rather than\n  substituted. Currently, we regard the following characters as illegal for use\n  in filenames: backslash '\', slash '/', question mark '?', percent sign '%',\n  asterisk '*', colon ':', pipe symbol '|', double quote '\"', triangular\n  brackets '<' and '>'.\n\n",
  "      --split-contributions     Split the free energy contributions into\n                                  separate parts\n                                    (default=off)",
  "  By default, only the total energy contribution for each hit is returned.\n  Using this option, this contribution is split into individual parts, i.e. the\n  Nearest Neighbor model energy, the covariance pseudo energy, and if\n  applicable, a remaining pseudo energy derived from special constraints, such\n  as probing signals like SHAPE.\n\n",
  "\nStructure Constraints:",
  "  Command line options to interact with the structure constraints feature of\n  this program\n\n",
  "      --shape=file1,file2       Use SHAPE reactivity data to guide structure\n                                  predictions\n",
  "  Multiple shapefiles for the individual sequences in the alignment may be\n  specified  as a comma separated list. An optional association of particular\n  shape files to a specific  sequence in the alignment can be expressed by\n  prepending the sequence number to the filename,  e.g.\n  \"5=seq5.shape,3=seq3.shape\" will assign the reactivity values from file\n  seq5.shape to  the fifth sequence in the alignment, and the values from file\n  seq3.shape to sequence 3. If  no assignment is specified, the reactivity\n  values are assigned to corresponding sequences in  the order they are given.\n\n",
  "      --shapeMethod=D[mX][bY]   Specify the method how to convert SHAPE\n                                  reactivity data to pseudo energy\n                                  contributions\n                                    (default=`D')",
  "  Currently, the only data conversion method available is that of to Deigan et\n  al 2009.  This method is the default and is recognized by a capital 'D' in\n  the provided parameter, i.e.:  --shapeMethod=\"D\" is the default setting.\n  The slope 'm' and the intercept 'b' can be set to a  non-default value if\n  necessary. Otherwise m=1.8 and b=-0.6 as stated in the paper mentionen\n  before.  To alter these parameters, e.g. m=1.9 and b=-0.7, use a  parameter\n  string like this: --shapeMethod=\"Dm1.9b-0.7\". You may also provide only one\n  of the two  parameters like: --shapeMethod=\"Dm1.9\" or\n  --shapeMethod=\"Db-0.7\".\n\n",
  "\nAlgorithms:",
  "  Select additional algorithms which should be included in the calculations.\n  The Minimum free energy (MFE) and a structure representative are calculated\n  in any case.\n\n",
  "  -L, --maxBPspan=INT           Set the maximum allowed separation of a base\n                                  pair to span. I.e. no pairs (i,j) with\n                                  j-i>span will be allowed.\n\n                                    (default=`70')",
  "      --threshold=DOUBLE        Energy threshold in kcal/mol per nucleotide\n                                  above which secondary structure hits are\n                                  omitted in the output.\n\n                                    (default=`-0.1')",
  "      --mis                     Output \"most informative sequence\" instead of\n                                  simple consensus: For each column of the\n                                  alignment output the set of nucleotides with\n                                  frequency greater than average in IUPAC\n                                  notation.\n\n                                    (default=off)",
  "  -g, --gquad                   Incoorporate G-Quadruplex formation into the\n                                  structure prediction algorithm\n\n                                    (default=off)",
  "\nModel Details:",
  "  -T, --temp=DOUBLE             Rescale energy parameters to a temperature of\n                                  temp C. Default is 37C.\n\n",
  "  -4, --noTetra                 Do not include special tabulated stabilizing\n                                  energies for tri-, tetra- and hexaloop\n                                  hairpins. Mostly for testing.\n\n                                    (default=off)",
  "  -d, --dangles=INT             How to treat \"dangling end\" energies for\n                                  bases adjacent to helices in free ends and\n                                  multi-loops\n                                    (default=`2')",
  "  \n  With -d1 only unpaired bases can participate in at most one dangling end.\n  With -d2 this check is ignored, dangling energies will be added for the bases\n  adjacent to a helix on both sides in any case; this is the default for mfe\n  and partition function folding (-p).\n  The option -d0 ignores dangling ends altogether (mostly for debugging).\n  With -d3 mfe folding will allow coaxial stacking of adjacent helices in\n  multi-loops. At the moment the implementation will not allow coaxial stacking\n  of the two interior pairs in a loop of degree 3 and works only for mfe\n  folding.\n\n  Note that with -d1 and -d3 only the MFE computations will be using this\n  setting while partition function uses -d2 setting, i.e. dangling ends will be\n  treated differently.\n\n",
  "      --noLP                    Produce structures without lonely pairs\n                                  (helices of length 1).\n                                    (default=off)",
  "  For partition function folding this only disallows pairs that can only occur\n  isolated. Other pairs may still occasionally occur as helices of length 1.\n\n",
  "      --noGU                    Do not allow GU pairs\n\n                                    (default=off)",
  "      --noClosingGU             Do not allow GU pairs at the end of helices\n\n                                    (default=off)",
  "  -P, --paramFile=paramfile     Read energy parameters from paramfile, instead\n                                  of using the default parameter set.\n",
  "  Different sets of energy parameters for RNA and DNA should accompany your\n  distribution.\n  See the RNAlib documentation for details on the file format. When passing the\n  placeholder file name \"DNA\", DNA parameters are loaded without the need to\n  actually specify any input file.\n\n",
  "      --nsp=STRING              Allow other pairs in addition to the usual\n                                  AU,GC,and GU pairs.\n",
  "  Its argument is a comma separated list of additionally allowed pairs. If the\n  first character is a \"-\" then AB will imply that AB and BA are allowed\n  pairs.\n  e.g. RNAfold -nsp -GA  will allow GA and AG pairs. Nonstandard pairs are\n  given 0 stacking energy.\n\n",
  "  -e, --energyModel=INT         Rarely used option to fold sequences from the\n                                  artificial ABCD... alphabet, where A pairs B,\n                                  C-D etc.  Use the energy parameters for GC\n                                  (-e 1) or AU (-e 2) pairs.\n\n",
  "      --cfactor=DOUBLE          Set the weight of the covariance term in the\n                                  energy function\n\n                                    (default=`1.0')",
  "      --nfactor=DOUBLE          Set the penalty for non-compatible sequences in\n                                  the covariance term of the energy function\n\n                                    (default=`1.0')",
  "  -R, --ribosum_file=ribosumfile\n                                use specified Ribosum Matrix instead of normal\n                                  energy model. Matrixes to use should be 6x6\n                                  matrices, the order of the terms is AU, CG,\n                                  GC, GU, UA, UG.\n\n",
  "  -r, --ribosum_scoring         use ribosum scoring matrix. The matrix is\n                                  chosen according to the minimal and maximal\n                                  pairwise identities of the sequences in the\n                                  file.\n\n                                    (default=off)",
  "\nIf in doubt our program is right, nature is at fault.\nComments should be sent to rna@tbi.univie.ac.at.\n\n",
    0
};
static void
init_full_help_array(void)
{
  RNALalifold_args_info_full_help[0] = RNALalifold_args_info_detailed_help[0];
  RNALalifold_args_info_full_help[1] = RNALalifold_args_info_detailed_help[1];
  RNALalifold_args_info_full_help[2] = RNALalifold_args_info_detailed_help[2];
  RNALalifold_args_info_full_help[3] = RNALalifold_args_info_detailed_help[3];
  RNALalifold_args_info_full_help[4] = RNALalifold_args_info_detailed_help[4];
  RNALalifold_args_info_full_help[5] = RNALalifold_args_info_detailed_help[5];
  RNALalifold_args_info_full_help[6] = RNALalifold_args_info_detailed_help[6];
  RNALalifold_args_info_full_help[7] = RNALalifold_args_info_detailed_help[7];
  RNALalifold_args_info_full_help[8] = RNALalifold_args_info_detailed_help[9];
  RNALalifold_args_info_full_help[9] = RNALalifold_args_info_detailed_help[10];
  RNALalifold_args_info_full_help[10] = RNALalifold_args_info_detailed_help[12];
  RNALalifold_args_info_full_help[11] = RNALalifold_args_info_detailed_help[13];
  RNALalifold_args_info_full_help[12] = RNALalifold_args_info_detailed_help[15];
  RNALalifold_args_info_full_help[13] = RNALalifold_args_info_detailed_help[17];
  RNALalifold_args_info_full_help[14] = RNALalifold_args_info_detailed_help[19];
  RNALalifold_args_info_full_help[15] = RNALalifold_args_info_detailed_help[21];
  RNALalifold_args_info_full_help[16] = RNALalifold_args_info_detailed_help[23];
  RNALalifold_args_info_full_help[17] = RNALalifold_args_info_detailed_help[25];
  RNALalifold_args_info_full_help[18] = RNALalifold_args_info_detailed_help[27];
  RNALalifold_args_info_full_help[19] = RNALalifold_args_info_detailed_help[29];
  RNALalifold_args_info_full_help[20] = RNALalifold_args_info_detailed_help[31];
  RNALalifold_args_info_full_help[21] = RNALalifold_args_info_detailed_help[33];
  RNALalifold_args_info_full_help[22] = RNALalifold_args_info_detailed_help[35];
  RNALalifold_args_info_full_help[23] = RNALalifold_args_info_detailed_help[37];
  RNALalifold_args_info_full_help[24] = RNALalifold_args_info_detailed_help[38];
  RNALalifold_args_info_full_help[25] = RNALalifold_args_info_detailed_help[39];
  RNALalifold_args_info_full_help[26] = RNALalifold_args_info_detailed_help[41];
  RNALalifold_args_info_full_help[27] = RNALalifold_args_info_detailed_help[43];
  RNALalifold_args_info_full_help[28] = RNALalifold_args_info_detailed_help[44];
  RNALalifold_args_info_full_help[29] = RNALalifold_args_info_detailed_help[45];
  RNALalifold_args_info_full_help[30] = RNALalifold_args_info_detailed_help[46];
  RNALalifold_args_info_full_help[31] = RNALalifold_args_info_detailed_help[47];
  RNALalifold_args_info_full_help[32] = RNALalifold_args_info_detailed_help[48];
  RNALalifold_args_info_full_help[33] = RNALalifold_args_info_detailed_help[49];
  RNALalifold_args_info_full_help[34] = RNALalifold_args_info_detailed_help[50];
  RNALalifold_args_info_full_help[35] = RNALalifold_args_info_detailed_help[51];
  RNALalifold_args_info_full_help[36] = RNALalifold_args_info_detailed_help[52];
  RNALalifold_args_info_full_help[37] = RNALalifold_args_info_detailed_help[54];
  RNALalifold_args_info_full_help[38] = RNALalifold_args_info_detailed_help[56];
  RNALalifold_args_info_full_help[39] = RNALalifold_args_info_detailed_help[57];
  RNALalifold_args_info_full_help[40] = RNALalifold_args_info_detailed_help[58];
  RNALalifold_args_info_full_help[41] = RNALalifold_args_info_detailed_help[60];
  RNALalifold_args_info_full_help[42] = RNALalifold_args_info_detailed_help[62];
  RNALalifold_args_info_full_help[43] = RNALalifold_args_info_detailed_help[63];
  RNALalifold_args_info_full_help[44] = RNALalifold_args_info_detailed_help[64];
  RNALalifold_args_info_full_help[45] = RNALalifold_args_info_detailed_help[65];
  RNALalifold_args_info_full_help[46] = RNALalifold_args_info_detailed_help[66];
  RNALalifold_args_info_full_help[47] = RNALalifold_args_info_detailed_help[67];
  RNALalifold_args_info_full_help[48] = 0;

}

const char *RNALalifold_args_info_full_help[49];

static void
init_help_array(void)
{
  RNALalifold_args_info_help[0] = RNALalifold_args_info_detailed_help[0];
  RNALalifold_args_info_help[1] = RNALalifold_args_info_detailed_help[1];
  RNALalifold_args_info_help[2] = RNALalifold_args_info_detailed_help[2];
  RNALalifold_args_info_help[3] = RNALalifold_args_info_detailed_help[3];
  RNALalifold_args_info_help[4] = RNALalifold_args_info_detailed_help[4];
  RNALalifold_args_info_help[5] = RNALalifold_args_info_detailed_help[5];
  RNALalifold_args_info_help[6] = RNALalifold_args_info_detailed_help[6];
  RNALalifold_args_info_help[7] = RNALalifold_args_info_detailed_help[7];
  RNALalifold_args_info_help[8] = RNALalifold_args_info_detailed_help[9];
  RNALalifold_args_info_help[9] = RNALalifold_args_info_detailed_help[10];
  RNALalifold_args_info_help[10] = RNALalifold_args_info_detailed_help[12];
  RNALalifold_args_info_help[11] = RNALalifold_args_info_detailed_help[13];
  RNALalifold_args_info_help[12] = RNALalifold_args_info_detailed_help[15];
  RNALalifold_args_info_help[13] = RNALalifold_args_info_detailed_help[19];
  RNALalifold_args_info_help[14] = RNALalifold_args_info_detailed_help[21];
  RNALalifold_args_info_help[15] = RNALalifold_args_info_detailed_help[23];
  RNALalifold_args_info_help[16] = RNALalifold_args_info_detailed_help[25];
  RNALalifold_args_info_help[17] = RNALalifold_args_info_detailed_help[35];
  RNALalifold_args_info_help[18] = RNALalifold_args_info_detailed_help[37];
  RNALalifold_args_info_help[19] = RNALalifold_args_info_detailed_help[38];
  RNALalifold_args_info_help[20] = RNALalifold_args_info_detailed_help[39];
  RNALalifold_args_info_help[21] = RNALalifold_args_info_detailed_help[41];
  RNALalifold_args_info_help[22] = RNALalifold_args_info_detailed_help[43];
  RNALalifold_args_info_help[23] = RNALalifold_args_info_detailed_help[44];
  RNALalifold_args_info_help[24] = RNALalifold_args_info_detailed_help[45];
  RNALalifold_args_info_help[25] = RNALalifold_args_info_detailed_help[46];
  RNALalifold_args_info_help[26] = RNALalifold_args_info_detailed_help[47];
  RNALalifold_args_info_help[27] = RNALalifold_args_info_detailed_help[48];
  RNALalifold_args_info_help[28] = RNALalifold_args_info_detailed_help[49];
  RNALalifold_args_info_help[29] = RNALalifold_args_info_detailed_help[50];
  RNALalifold_args_info_help[30] = RNALalifold_args_info_detailed_help[51];
  RNALalifold_args_info_help[31] = RNALalifold_args_info_detailed_help[52];
  RNALalifold_args_info_help[32] = RNALalifold_args_info_detailed_help[54];
  RNALalifold_args_info_help[33] = RNALalifold_args_info_detailed_help[56];
  RNALalifold_args_info_help[34] = RNALalifold_args_info_detailed_help[57];
  RNALalifold_args_info_help[35] = RNALalifold_args_info_detailed_help[58];
  RNALalifold_args_info_help[36] = RNALalifold_args_info_detailed_help[63];
  RNALalifold_args_info_help[37] = RNALalifold_args_info_detailed_help[64];
  RNALalifold_args_info_help[38] = RNALalifold_args_info_detailed_help[65];
  RNALalifold_args_info_help[39] = RNALalifold_args_info_detailed_help[66];
  RNALalifold_args_info_help[40] = RNALalifold_args_info_detailed_help[67];
  RNALalifold_args_info_help[41] = 0;

}

const char *RNALalifold_args_info_help[42];

typedef enum {ARG_NO
  , ARG_FLAG
  , ARG_STRING
  , ARG_INT
  , ARG_LONG
  , ARG_DOUBLE
} RNALalifold_cmdline_parser_arg_type;

static
void clear_given (struct RNALalifold_args_info *args_info);
static
void clear_args (struct RNALalifold_args_info *args_info);

static int
RNALalifold_cmdline_parser_internal (int argc, char **argv, struct RNALalifold_args_info *args_info,
                        struct RNALalifold_cmdline_parser_params *params, const char *additional_error);

static int
RNALalifold_cmdline_parser_required2 (struct RNALalifold_args_info *args_info, const char *prog_name, const char *additional_error);

static char *
gengetopt_strdup (const char *s);

static
void clear_given (struct RNALalifold_args_info *args_info)
{
  args_info->help_given = 0 ;
  args_info->detailed_help_given = 0 ;
  args_info->full_help_given = 0 ;
  args_info->version_given = 0 ;
  args_info->verbose_given = 0 ;
  args_info->quiet_given = 0 ;
  args_info->noconv_given = 0 ;
  args_info->input_format_given = 0 ;
  args_info->csv_given = 0 ;
  args_info->aln_given = 0 ;
  args_info->aln_EPS_given = 0 ;
  args_info->aln_EPS_cols_given = 0 ;
  args_info->aln_EPS_ss_given = 0 ;
  args_info->aln_stk_given = 0 ;
  args_info->auto_id_given = 0 ;
  args_info->id_prefix_given = 0 ;
  args_info->id_delim_given = 0 ;
  args_info->id_digits_given = 0 ;
  args_info->id_start_given = 0 ;
  args_info->filename_delim_given = 0 ;
  args_info->split_contributions_given = 0 ;
  args_info->shape_given = 0 ;
  args_info->shapeMethod_given = 0 ;
  args_info->maxBPspan_given = 0 ;
  args_info->threshold_given = 0 ;
  args_info->mis_given = 0 ;
  args_info->gquad_given = 0 ;
  args_info->temp_given = 0 ;
  args_info->noTetra_given = 0 ;
  args_info->dangles_given = 0 ;
  args_info->noLP_given = 0 ;
  args_info->noGU_given = 0 ;
  args_info->noClosingGU_given = 0 ;
  args_info->paramFile_given = 0 ;
  args_info->nsp_given = 0 ;
  args_info->energyModel_given = 0 ;
  args_info->cfactor_given = 0 ;
  args_info->nfactor_given = 0 ;
  args_info->ribosum_file_given = 0 ;
  args_info->ribosum_scoring_given = 0 ;
}

static
void clear_args (struct RNALalifold_args_info *args_info)
{
  FIX_UNUSED (args_info);
  args_info->verbose_flag = 0;
  args_info->quiet_flag = 0;
  args_info->noconv_flag = 0;
  args_info->input_format_arg = NULL;
  args_info->input_format_orig = NULL;
  args_info->csv_flag = 0;
  args_info->aln_arg = NULL;
  args_info->aln_orig = NULL;
  args_info->aln_EPS_arg = NULL;
  args_info->aln_EPS_orig = NULL;
  args_info->aln_EPS_cols_arg = 60;
  args_info->aln_EPS_cols_orig = NULL;
  args_info->aln_EPS_ss_arg = NULL;
  args_info->aln_EPS_ss_orig = NULL;
  args_info->aln_stk_arg = gengetopt_strdup ("RNALalifold_results");
  args_info->aln_stk_orig = NULL;
  args_info->auto_id_flag = 0;
  args_info->id_prefix_arg = gengetopt_strdup ("alignment");
  args_info->id_prefix_orig = NULL;
  args_info->id_delim_arg = gengetopt_strdup ("_");
  args_info->id_delim_orig = NULL;
  args_info->id_digits_arg = 4;
  args_info->id_digits_orig = NULL;
  args_info->id_start_arg = 1;
  args_info->id_start_orig = NULL;
  args_info->filename_delim_arg = gengetopt_strdup ("ID-delimiter");
  args_info->filename_delim_orig = NULL;
  args_info->split_contributions_flag = 0;
  args_info->shape_arg = NULL;
  args_info->shape_orig = NULL;
  args_info->shapeMethod_arg = gengetopt_strdup ("D");
  args_info->shapeMethod_orig = NULL;
  args_info->maxBPspan_arg = 70;
  args_info->maxBPspan_orig = NULL;
  args_info->threshold_arg = -0.1;
  args_info->threshold_orig = NULL;
  args_info->mis_flag = 0;
  args_info->gquad_flag = 0;
  args_info->temp_orig = NULL;
  args_info->noTetra_flag = 0;
  args_info->dangles_arg = 2;
  args_info->dangles_orig = NULL;
  args_info->noLP_flag = 0;
  args_info->noGU_flag = 0;
  args_info->noClosingGU_flag = 0;
  args_info->paramFile_arg = NULL;
  args_info->paramFile_orig = NULL;
  args_info->nsp_arg = NULL;
  args_info->nsp_orig = NULL;
  args_info->energyModel_orig = NULL;
  args_info->cfactor_arg = 1.0;
  args_info->cfactor_orig = NULL;
  args_info->nfactor_arg = 1.0;
  args_info->nfactor_orig = NULL;
  args_info->ribosum_file_arg = NULL;
  args_info->ribosum_file_orig = NULL;
  args_info->ribosum_scoring_flag = 0;

}

static
void init_args_info(struct RNALalifold_args_info *args_info)
{
  init_full_help_array();
  init_help_array();
  args_info->help_help = RNALalifold_args_info_detailed_help[0] ;
  args_info->detailed_help_help = RNALalifold_args_info_detailed_help[1] ;
  args_info->full_help_help = RNALalifold_args_info_detailed_help[2] ;
  args_info->version_help = RNALalifold_args_info_detailed_help[3] ;
  args_info->verbose_help = RNALalifold_args_info_detailed_help[6] ;
  args_info->quiet_help = RNALalifold_args_info_detailed_help[7] ;
  args_info->noconv_help = RNALalifold_args_info_detailed_help[9] ;
  args_info->input_format_help = RNALalifold_args_info_detailed_help[10] ;
  args_info->csv_help = RNALalifold_args_info_detailed_help[12] ;
  args_info->aln_help = RNALalifold_args_info_detailed_help[13] ;
  args_info->aln_EPS_help = RNALalifold_args_info_detailed_help[15] ;
  args_info->aln_EPS_cols_help = RNALalifold_args_info_detailed_help[17] ;
  args_info->aln_EPS_ss_help = RNALalifold_args_info_detailed_help[19] ;
  args_info->aln_stk_help = RNALalifold_args_info_detailed_help[21] ;
  args_info->auto_id_help = RNALalifold_args_info_detailed_help[23] ;
  args_info->id_prefix_help = RNALalifold_args_info_detailed_help[25] ;
  args_info->id_delim_help = RNALalifold_args_info_detailed_help[27] ;
  args_info->id_digits_help = RNALalifold_args_info_detailed_help[29] ;
  args_info->id_start_help = RNALalifold_args_info_detailed_help[31] ;
  args_info->filename_delim_help = RNALalifold_args_info_detailed_help[33] ;
  args_info->split_contributions_help = RNALalifold_args_info_detailed_help[35] ;
  args_info->shape_help = RNALalifold_args_info_detailed_help[39] ;
  args_info->shape_min = 1;
  args_info->shape_max = 0;
  args_info->shapeMethod_help = RNALalifold_args_info_detailed_help[41] ;
  args_info->maxBPspan_help = RNALalifold_args_info_detailed_help[45] ;
  args_info->threshold_help = RNALalifold_args_info_detailed_help[46] ;
  args_info->mis_help = RNALalifold_args_info_detailed_help[47] ;
  args_info->gquad_help = RNALalifold_args_info_detailed_help[48] ;
  args_info->temp_help = RNALalifold_args_info_detailed_help[50] ;
  args_info->noTetra_help = RNALalifold_args_info_detailed_help[51] ;
  args_info->dangles_help = RNALalifold_args_info_detailed_help[52] ;
  args_info->noLP_help = RNALalifold_args_info_detailed_help[54] ;
  args_info->noGU_help = RNALalifold_args_info_detailed_help[56] ;
  args_info->noClosingGU_help = RNALalifold_args_info_detailed_help[57] ;
  args_info->paramFile_help = RNALalifold_args_info_detailed_help[58] ;
  args_info->nsp_help = RNALalifold_args_info_detailed_help[60] ;
  args_info->energyModel_help = RNALalifold_args_info_detailed_help[62] ;
  args_info->cfactor_help = RNALalifold_args_info_detailed_help[63] ;
  args_info->nfactor_help = RNALalifold_args_info_detailed_help[64] ;
  args_info->ribosum_file_help = RNALalifold_args_info_detailed_help[65] ;
  args_info->ribosum_scoring_help = RNALalifold_args_info_detailed_help[66] ;

}

void
RNALalifold_cmdline_parser_print_version (void)
{
  printf ("%s %s\n",
     (strlen(RNALALIFOLD_CMDLINE_PARSER_PACKAGE_NAME) ? RNALALIFOLD_CMDLINE_PARSER_PACKAGE_NAME : RNALALIFOLD_CMDLINE_PARSER_PACKAGE),
     RNALALIFOLD_CMDLINE_PARSER_VERSION);

  if (strlen(RNALalifold_args_info_versiontext) > 0)
    printf("\n%s\n", RNALalifold_args_info_versiontext);
}

static void print_help_common(void)
{
	size_t len_purpose = strlen(RNALalifold_args_info_purpose);
	size_t len_usage = strlen(RNALalifold_args_info_usage);

	if (len_usage > 0) {
		printf("%s\n", RNALalifold_args_info_usage);
	}
	if (len_purpose > 0) {
		printf("%s\n", RNALalifold_args_info_purpose);
	}

	if (len_usage || len_purpose) {
		printf("\n");
	}

	if (strlen(RNALalifold_args_info_description) > 0) {
		printf("%s\n\n", RNALalifold_args_info_description);
	}
}

void
RNALalifold_cmdline_parser_print_help (void)
{
  int i = 0;
  print_help_common();
  while (RNALalifold_args_info_help[i])
    printf("%s\n", RNALalifold_args_info_help[i++]);
}

void
RNALalifold_cmdline_parser_print_full_help (void)
{
  int i = 0;
  print_help_common();
  while (RNALalifold_args_info_full_help[i])
    printf("%s\n", RNALalifold_args_info_full_help[i++]);
}

void
RNALalifold_cmdline_parser_print_detailed_help (void)
{
  int i = 0;
  print_help_common();
  while (RNALalifold_args_info_detailed_help[i])
    printf("%s\n", RNALalifold_args_info_detailed_help[i++]);
}

void
RNALalifold_cmdline_parser_init (struct RNALalifold_args_info *args_info)
{
  clear_given (args_info);
  clear_args (args_info);
  init_args_info (args_info);

  args_info->inputs = 0;
  args_info->inputs_num = 0;
}

void
RNALalifold_cmdline_parser_params_init(struct RNALalifold_cmdline_parser_params *params)
{
  if (params)
    {
      params->override = 0;
      params->initialize = 1;
      params->check_required = 1;
      params->check_ambiguity = 0;
      params->print_errors = 1;
    }
}

struct RNALalifold_cmdline_parser_params *
RNALalifold_cmdline_parser_params_create(void)
{
  struct RNALalifold_cmdline_parser_params *params =
    (struct RNALalifold_cmdline_parser_params *)malloc(sizeof(struct RNALalifold_cmdline_parser_params));
  RNALalifold_cmdline_parser_params_init(params);
  return params;
}

static void
free_string_field (char **s)
{
  if (*s)
    {
      free (*s);
      *s = 0;
    }
}

/** @brief generic value variable */
union generic_value {
    int int_arg;
    long long_arg;
    double double_arg;
    char *string_arg;
    const char *default_string_arg;
};

/** @brief holds temporary values for multiple options */
struct generic_list
{
  union generic_value arg;
  char *orig;
  struct generic_list *next;
};

/**
 * @brief add a node at the head of the list
 */
static void add_node(struct generic_list **list) {
  struct generic_list *new_node = (struct generic_list *) malloc (sizeof (struct generic_list));
  new_node->next = *list;
  *list = new_node;
  new_node->arg.string_arg = 0;
  new_node->orig = 0;
}


static void
free_multiple_string_field(unsigned int len, char ***arg, char ***orig)
{
  unsigned int i;
  if (*arg) {
    for (i = 0; i < len; ++i)
      {
        free_string_field(&((*arg)[i]));
        free_string_field(&((*orig)[i]));
      }
    free_string_field(&((*arg)[0])); /* free default string */

    free (*arg);
    *arg = 0;
    free (*orig);
    *orig = 0;
  }
}

static void
RNALalifold_cmdline_parser_release (struct RNALalifold_args_info *args_info)
{
  unsigned int i;
  free_string_field (&(args_info->input_format_arg));
  free_string_field (&(args_info->input_format_orig));
  free_string_field (&(args_info->aln_arg));
  free_string_field (&(args_info->aln_orig));
  free_string_field (&(args_info->aln_EPS_arg));
  free_string_field (&(args_info->aln_EPS_orig));
  free_string_field (&(args_info->aln_EPS_cols_orig));
  free_string_field (&(args_info->aln_EPS_ss_arg));
  free_string_field (&(args_info->aln_EPS_ss_orig));
  free_string_field (&(args_info->aln_stk_arg));
  free_string_field (&(args_info->aln_stk_orig));
  free_string_field (&(args_info->id_prefix_arg));
  free_string_field (&(args_info->id_prefix_orig));
  free_string_field (&(args_info->id_delim_arg));
  free_string_field (&(args_info->id_delim_orig));
  free_string_field (&(args_info->id_digits_orig));
  free_string_field (&(args_info->id_start_orig));
  free_string_field (&(args_info->filename_delim_arg));
  free_string_field (&(args_info->filename_delim_orig));
  free_multiple_string_field (args_info->shape_given, &(args_info->shape_arg), &(args_info->shape_orig));
  free_string_field (&(args_info->shapeMethod_arg));
  free_string_field (&(args_info->shapeMethod_orig));
  free_string_field (&(args_info->maxBPspan_orig));
  free_string_field (&(args_info->threshold_orig));
  free_string_field (&(args_info->temp_orig));
  free_string_field (&(args_info->dangles_orig));
  free_string_field (&(args_info->paramFile_arg));
  free_string_field (&(args_info->paramFile_orig));
  free_string_field (&(args_info->nsp_arg));
  free_string_field (&(args_info->nsp_orig));
  free_string_field (&(args_info->energyModel_orig));
  free_string_field (&(args_info->cfactor_orig));
  free_string_field (&(args_info->nfactor_orig));
  free_string_field (&(args_info->ribosum_file_arg));
  free_string_field (&(args_info->ribosum_file_orig));


  for (i = 0; i < args_info->inputs_num; ++i)
    free (args_info->inputs [i]);

  if (args_info->inputs_num)
    free (args_info->inputs);

  clear_given (args_info);
}


static void
write_into_file(FILE *outfile, const char *opt, const char *arg, const char *values[])
{
  FIX_UNUSED (values);
  if (arg) {
    fprintf(outfile, "%s=\"%s\"\n", opt, arg);
  } else {
    fprintf(outfile, "%s\n", opt);
  }
}

static void
write_multiple_into_file(FILE *outfile, int len, const char *opt, char **arg, const char *values[])
{
  int i;

  for (i = 0; i < len; ++i)
    write_into_file(outfile, opt, (arg ? arg[i] : 0), values);
}

int
RNALalifold_cmdline_parser_dump(FILE *outfile, struct RNALalifold_args_info *args_info)
{
  int i = 0;

  if (!outfile)
    {
      fprintf (stderr, "%s: cannot dump options to stream\n", RNALALIFOLD_CMDLINE_PARSER_PACKAGE);
      return EXIT_FAILURE;
    }

  if (args_info->help_given)
    write_into_file(outfile, "help", 0, 0 );
  if (args_info->detailed_help_given)
    write_into_file(outfile, "detailed-help", 0, 0 );
  if (args_info->full_help_given)
    write_into_file(outfile, "full-help", 0, 0 );
  if (args_info->version_given)
    write_into_file(outfile, "version", 0, 0 );
  if (args_info->verbose_given)
    write_into_file(outfile, "verbose", 0, 0 );
  if (args_info->quiet_given)
    write_into_file(outfile, "quiet", 0, 0 );
  if (args_info->noconv_given)
    write_into_file(outfile, "noconv", 0, 0 );
  if (args_info->input_format_given)
    write_into_file(outfile, "input-format", args_info->input_format_orig, 0);
  if (args_info->csv_given)
    write_into_file(outfile, "csv", 0, 0 );
  if (args_info->aln_given)
    write_into_file(outfile, "aln", args_info->aln_orig, 0);
  if (args_info->aln_EPS_given)
    write_into_file(outfile, "aln-EPS", args_info->aln_EPS_orig, 0);
  if (args_info->aln_EPS_cols_given)
    write_into_file(outfile, "aln-EPS-cols", args_info->aln_EPS_cols_orig, 0);
  if (args_info->aln_EPS_ss_given)
    write_into_file(outfile, "aln-EPS-ss", args_info->aln_EPS_ss_orig, 0);
  if (args_info->aln_stk_given)
    write_into_file(outfile, "aln-stk", args_info->aln_stk_orig, 0);
  if (args_info->auto_id_given)
    write_into_file(outfile, "auto-id", 0, 0 );
  if (args_info->id_prefix_given)
    write_into_file(outfile, "id-prefix", args_info->id_prefix_orig, 0);
  if (args_info->id_delim_given)
    write_into_file(outfile, "id-delim", args_info->id_delim_orig, 0);
  if (args_info->id_digits_given)
    write_into_file(outfile, "id-digits", args_info->id_digits_orig, 0);
  if (args_info->id_start_given)
    write_into_file(outfile, "id-start", args_info->id_start_orig, 0);
  if (args_info->filename_delim_given)
    write_into_file(outfile, "filename-delim", args_info->filename_delim_orig, 0);
  if (args_info->split_contributions_given)
    write_into_file(outfile, "split-contributions", 0, 0 );
  write_multiple_into_file(outfile, args_info->shape_given, "shape", args_info->shape_orig, 0);
  if (args_info->shapeMethod_given)
    write_into_file(outfile, "shapeMethod", args_info->shapeMethod_orig, 0);
  if (args_info->maxBPspan_given)
    write_into_file(outfile, "maxBPspan", args_info->maxBPspan_orig, 0);
  if (args_info->threshold_given)
    write_into_file(outfile, "threshold", args_info->threshold_orig, 0);
  if (args_info->mis_given)
    write_into_file(outfile, "mis", 0, 0 );
  if (args_info->gquad_given)
    write_into_file(outfile, "gquad", 0, 0 );
  if (args_info->temp_given)
    write_into_file(outfile, "temp", args_info->temp_orig, 0);
  if (args_info->noTetra_given)
    write_into_file(outfile, "noTetra", 0, 0 );
  if (args_info->dangles_given)
    write_into_file(outfile, "dangles", args_info->dangles_orig, 0);
  if (args_info->noLP_given)
    write_into_file(outfile, "noLP", 0, 0 );
  if (args_info->noGU_given)
    write_into_file(outfile, "noGU", 0, 0 );
  if (args_info->noClosingGU_given)
    write_into_file(outfile, "noClosingGU", 0, 0 );
  if (args_info->paramFile_given)
    write_into_file(outfile, "paramFile", args_info->paramFile_orig, 0);
  if (args_info->nsp_given)
    write_into_file(outfile, "nsp", args_info->nsp_orig, 0);
  if (args_info->energyModel_given)
    write_into_file(outfile, "energyModel", args_info->energyModel_orig, 0);
  if (args_info->cfactor_given)
    write_into_file(outfile, "cfactor", args_info->cfactor_orig, 0);
  if (args_info->nfactor_given)
    write_into_file(outfile, "nfactor", args_info->nfactor_orig, 0);
  if (args_info->ribosum_file_given)
    write_into_file(outfile, "ribosum_file", args_info->ribosum_file_orig, 0);
  if (args_info->ribosum_scoring_given)
    write_into_file(outfile, "ribosum_scoring", 0, 0 );


  i = EXIT_SUCCESS;
  return i;
}

int
RNALalifold_cmdline_parser_file_save(const char *filename, struct RNALalifold_args_info *args_info)
{
  FILE *outfile;
  int i = 0;

  outfile = fopen(filename, "w");

  if (!outfile)
    {
      fprintf (stderr, "%s: cannot open file for writing: %s\n", RNALALIFOLD_CMDLINE_PARSER_PACKAGE, filename);
      return EXIT_FAILURE;
    }

  i = RNALalifold_cmdline_parser_dump(outfile, args_info);
  fclose (outfile);

  return i;
}

void
RNALalifold_cmdline_parser_free (struct RNALalifold_args_info *args_info)
{
  RNALalifold_cmdline_parser_release (args_info);
}

/** @brief replacement of strdup, which is not standard */
char *
gengetopt_strdup (const char *s)
{
  char *result = 0;
  if (!s)
    return result;

  result = (char*)malloc(strlen(s) + 1);
  if (result == (char*)0)
    return (char*)0;
  strcpy(result, s);
  return result;
}

static char *
get_multiple_arg_token(const char *arg)
{
  const char *tok;
  char *ret;
  size_t len, num_of_escape, i, j;

  if (!arg)
    return 0;

  tok = strchr (arg, ',');
  num_of_escape = 0;

  /* make sure it is not escaped */
  while (tok)
    {
      if (*(tok-1) == '\\')
        {
          /* find the next one */
          tok = strchr (tok+1, ',');
          ++num_of_escape;
        }
      else
        break;
    }

  if (tok)
    len = (size_t)(tok - arg + 1);
  else
    len = strlen (arg) + 1;

  len -= num_of_escape;

  ret = (char *) malloc (len);

  i = 0;
  j = 0;
  while (arg[i] && (j < len-1))
    {
      if (arg[i] == '\\' &&
	  arg[ i + 1 ] &&
	  arg[ i + 1 ] == ',')
        ++i;

      ret[j++] = arg[i++];
    }

  ret[len-1] = '\0';

  return ret;
}

static const char *
get_multiple_arg_token_next(const char *arg)
{
  const char *tok;

  if (!arg)
    return 0;

  tok = strchr (arg, ',');

  /* make sure it is not escaped */
  while (tok)
    {
      if (*(tok-1) == '\\')
        {
          /* find the next one */
          tok = strchr (tok+1, ',');
        }
      else
        break;
    }

  if (! tok || strlen(tok) == 1)
    return 0;

  return tok+1;
}

static int
check_multiple_option_occurrences(const char *prog_name, unsigned int option_given, unsigned int min, unsigned int max, const char *option_desc);

int
check_multiple_option_occurrences(const char *prog_name, unsigned int option_given, unsigned int min, unsigned int max, const char *option_desc)
{
  int error_occurred = 0;

  if (option_given && (min > 0 || max > 0))
    {
      if (min > 0 && max > 0)
        {
          if (min == max)
            {
              /* specific occurrences */
              if (option_given != (unsigned int) min)
                {
                  fprintf (stderr, "%s: %s option occurrences must be %d\n",
                    prog_name, option_desc, min);
                  error_occurred = 1;
                }
            }
          else if (option_given < (unsigned int) min
                || option_given > (unsigned int) max)
            {
              /* range occurrences */
              fprintf (stderr, "%s: %s option occurrences must be between %d and %d\n",
                prog_name, option_desc, min, max);
              error_occurred = 1;
            }
        }
      else if (min > 0)
        {
          /* at least check */
          if (option_given < min)
            {
              fprintf (stderr, "%s: %s option occurrences must be at least %d\n",
                prog_name, option_desc, min);
              error_occurred = 1;
            }
        }
      else if (max > 0)
        {
          /* at most check */
          if (option_given > max)
            {
              fprintf (stderr, "%s: %s option occurrences must be at most %d\n",
                prog_name, option_desc, max);
              error_occurred = 1;
            }
        }
    }

  return error_occurred;
}
int
RNALalifold_cmdline_parser (int argc, char **argv, struct RNALalifold_args_info *args_info)
{
  return RNALalifold_cmdline_parser2 (argc, argv, args_info, 0, 1, 1);
}

int
RNALalifold_cmdline_parser_ext (int argc, char **argv, struct RNALalifold_args_info *args_info,
                   struct RNALalifold_cmdline_parser_params *params)
{
  int result;
  result = RNALalifold_cmdline_parser_internal (argc, argv, args_info, params, 0);

  if (result == EXIT_FAILURE)
    {
      RNALalifold_cmdline_parser_free (args_info);
      exit (EXIT_FAILURE);
    }

  return result;
}

int
RNALalifold_cmdline_parser2 (int argc, char **argv, struct RNALalifold_args_info *args_info, int override, int initialize, int check_required)
{
  int result;
  struct RNALalifold_cmdline_parser_params params;

  params.override = override;
  params.initialize = initialize;
  params.check_required = check_required;
  params.check_ambiguity = 0;
  params.print_errors = 1;

  result = RNALalifold_cmdline_parser_internal (argc, argv, args_info, &params, 0);

  if (result == EXIT_FAILURE)
    {
      RNALalifold_cmdline_parser_free (args_info);
      exit (EXIT_FAILURE);
    }

  return result;
}

int
RNALalifold_cmdline_parser_required (struct RNALalifold_args_info *args_info, const char *prog_name)
{
  int result = EXIT_SUCCESS;

  if (RNALalifold_cmdline_parser_required2(args_info, prog_name, 0) > 0)
    result = EXIT_FAILURE;

  if (result == EXIT_FAILURE)
    {
      RNALalifold_cmdline_parser_free (args_info);
      exit (EXIT_FAILURE);
    }

  return result;
}

int
RNALalifold_cmdline_parser_required2 (struct RNALalifold_args_info *args_info, const char *prog_name, const char *additional_error)
{
  int error_occurred = 0;
  FIX_UNUSED (additional_error);

  /* checks for required options */
  if (check_multiple_option_occurrences(prog_name, args_info->shape_given, args_info->shape_min, args_info->shape_max, "'--shape'"))
     error_occurred = 1;


  /* checks for dependences among options */
  if (args_info->shapeMethod_given && ! args_info->shape_given)
    {
      fprintf (stderr, "%s: '--shapeMethod' option depends on option 'shape'%s\n", prog_name, (additional_error ? additional_error : ""));
      error_occurred = 1;
    }

  return error_occurred;
}

/*
 * Extracted from the glibc source tree, version 2.3.6
 *
 * Licensed under the GPL as per the whole glibc source tree.
 *
 * This file was modified so that getopt_long can be called
 * many times without risking previous memory to be spoiled.
 *
 * Modified by Andre Noll and Lorenzo Bettini for use in
 * GNU gengetopt generated files.
 *
 */

/*
 * we must include anything we need since this file is not thought to be
 * inserted in a file already using getopt.h
 *
 * Lorenzo
 */

struct option
{
  const char *name;
  /* has_arg can't be an enum because some compilers complain about
     type mismatches in all the code that assumes it is an int.  */
  int has_arg;
  int *flag;
  int val;
};

/* This version of `getopt' appears to the caller like standard Unix `getopt'
   but it behaves differently for the user, since it allows the user
   to intersperse the options with the other arguments.

   As `getopt' works, it permutes the elements of ARGV so that,
   when it is done, all the options precede everything else.  Thus
   all application programs are extended to handle flexible argument order.
*/
/*
   If the field `flag' is not NULL, it points to a variable that is set
   to the value given in the field `val' when the option is found, but
   left unchanged if the option is not found.

   To have a long-named option do something other than set an `int' to
   a compiled-in constant, such as set a value from `custom_optarg', set the
   option's `flag' field to zero and its `val' field to a nonzero
   value (the equivalent single-letter option character, if there is
   one).  For long options that have a zero `flag' field, `getopt'
   returns the contents of the `val' field.  */

/* Names for the values of the `has_arg' field of `struct option'.  */
#ifndef no_argument
#define no_argument		0
#endif

#ifndef required_argument
#define required_argument	1
#endif

#ifndef optional_argument
#define optional_argument	2
#endif

struct custom_getopt_data {
	/*
	 * These have exactly the same meaning as the corresponding global variables,
	 * except that they are used for the reentrant versions of getopt.
	 */
	int custom_optind;
	int custom_opterr;
	int custom_optopt;
	char *custom_optarg;

	/* True if the internal members have been initialized.  */
	int initialized;

	/*
	 * The next char to be scanned in the option-element in which the last option
	 * character we returned was found.  This allows us to pick up the scan where
	 * we left off.  If this is zero, or a null string, it means resume the scan by
	 * advancing to the next ARGV-element.
	 */
	char *nextchar;

	/*
	 * Describe the part of ARGV that contains non-options that have been skipped.
	 * `first_nonopt' is the index in ARGV of the first of them; `last_nonopt' is
	 * the index after the last of them.
	 */
	int first_nonopt;
	int last_nonopt;
};

/*
 * the variables optarg, optind, opterr and optopt are renamed with
 * the custom_ prefix so that they don't interfere with getopt ones.
 *
 * Moreover they're static so they are visible only from within the
 * file where this very file will be included.
 */

/*
 * For communication from `custom_getopt' to the caller.  When `custom_getopt' finds an
 * option that takes an argument, the argument value is returned here.
 */
static char *custom_optarg;

/*
 * Index in ARGV of the next element to be scanned.  This is used for
 * communication to and from the caller and for communication between
 * successive calls to `custom_getopt'.
 *
 * On entry to `custom_getopt', 1 means this is the first call; initialize.
 *
 * When `custom_getopt' returns -1, this is the index of the first of the non-option
 * elements that the caller should itself scan.
 *
 * Otherwise, `custom_optind' communicates from one call to the next how much of ARGV
 * has been scanned so far.
 *
 * 1003.2 says this must be 1 before any call.
 */
static int custom_optind = 1;

/*
 * Callers store zero here to inhibit the error message for unrecognized
 * options.
 */
static int custom_opterr = 1;

/*
 * Set to an option character which was unrecognized.  This must be initialized
 * on some systems to avoid linking in the system's own getopt implementation.
 */
static int custom_optopt = '?';

/*
 * Exchange two adjacent subsequences of ARGV.  One subsequence is elements
 * [first_nonopt,last_nonopt) which contains all the non-options that have been
 * skipped so far.  The other is elements [last_nonopt,custom_optind), which contains
 * all the options processed since those non-options were skipped.
 * `first_nonopt' and `last_nonopt' are relocated so that they describe the new
 * indices of the non-options in ARGV after they are moved.
 */
static void exchange(char **argv, struct custom_getopt_data *d)
{
	int bottom = d->first_nonopt;
	int middle = d->last_nonopt;
	int top = d->custom_optind;
	char *tem;

	/*
	 * Exchange the shorter segment with the far end of the longer segment.
	 * That puts the shorter segment into the right place.  It leaves the
	 * longer segment in the right place overall, but it consists of two
	 * parts that need to be swapped next.
	 */
	while (top > middle && middle > bottom) {
		if (top - middle > middle - bottom) {
			/* Bottom segment is the short one.  */
			int len = middle - bottom;
			int i;

			/* Swap it with the top part of the top segment.  */
			for (i = 0; i < len; i++) {
				tem = argv[bottom + i];
				argv[bottom + i] =
					argv[top - (middle - bottom) + i];
				argv[top - (middle - bottom) + i] = tem;
			}
			/* Exclude the moved bottom segment from further swapping.  */
			top -= len;
		} else {
			/* Top segment is the short one.  */
			int len = top - middle;
			int i;

			/* Swap it with the bottom part of the bottom segment.  */
			for (i = 0; i < len; i++) {
				tem = argv[bottom + i];
				argv[bottom + i] = argv[middle + i];
				argv[middle + i] = tem;
			}
			/* Exclude the moved top segment from further swapping.  */
			bottom += len;
		}
	}
	/* Update records for the slots the non-options now occupy.  */
	d->first_nonopt += (d->custom_optind - d->last_nonopt);
	d->last_nonopt = d->custom_optind;
}

/* Initialize the internal data when the first call is made.  */
static void custom_getopt_initialize(struct custom_getopt_data *d)
{
	/*
	 * Start processing options with ARGV-element 1 (since ARGV-element 0
	 * is the program name); the sequence of previously skipped non-option
	 * ARGV-elements is empty.
	 */
	d->first_nonopt = d->last_nonopt = d->custom_optind;
	d->nextchar = NULL;
	d->initialized = 1;
}

#define NONOPTION_P (argv[d->custom_optind][0] != '-' || argv[d->custom_optind][1] == '\0')

/* return: zero: continue, nonzero: return given value to user */
static int shuffle_argv(int argc, char *const *argv,const struct option *longopts,
	struct custom_getopt_data *d)
{
	/*
	 * Give FIRST_NONOPT & LAST_NONOPT rational values if CUSTOM_OPTIND has been
	 * moved back by the user (who may also have changed the arguments).
	 */
	if (d->last_nonopt > d->custom_optind)
		d->last_nonopt = d->custom_optind;
	if (d->first_nonopt > d->custom_optind)
		d->first_nonopt = d->custom_optind;
	/*
	 * If we have just processed some options following some
	 * non-options, exchange them so that the options come first.
	 */
	if (d->first_nonopt != d->last_nonopt &&
			d->last_nonopt != d->custom_optind)
		exchange((char **) argv, d);
	else if (d->last_nonopt != d->custom_optind)
		d->first_nonopt = d->custom_optind;
	/*
	 * Skip any additional non-options and extend the range of
	 * non-options previously skipped.
	 */
	while (d->custom_optind < argc && NONOPTION_P)
		d->custom_optind++;
	d->last_nonopt = d->custom_optind;
	/*
	 * The special ARGV-element `--' means premature end of options.  Skip
	 * it like a null option, then exchange with previous non-options as if
	 * it were an option, then skip everything else like a non-option.
	 */
	if (d->custom_optind != argc && !strcmp(argv[d->custom_optind], "--")) {
		d->custom_optind++;
		if (d->first_nonopt != d->last_nonopt
				&& d->last_nonopt != d->custom_optind)
			exchange((char **) argv, d);
		else if (d->first_nonopt == d->last_nonopt)
			d->first_nonopt = d->custom_optind;
		d->last_nonopt = argc;
		d->custom_optind = argc;
	}
	/*
	 * If we have done all the ARGV-elements, stop the scan and back over
	 * any non-options that we skipped and permuted.
	 */
	if (d->custom_optind == argc) {
		/*
		 * Set the next-arg-index to point at the non-options that we
		 * previously skipped, so the caller will digest them.
		 */
		if (d->first_nonopt != d->last_nonopt)
			d->custom_optind = d->first_nonopt;
		return -1;
	}
	/*
	 * If we have come to a non-option and did not permute it, either stop
	 * the scan or describe it to the caller and pass it by.
	 */
	if (NONOPTION_P) {
		d->custom_optarg = argv[d->custom_optind++];
		return 1;
	}
	/*
	 * We have found another option-ARGV-element. Skip the initial
	 * punctuation.
	 */
	d->nextchar = (argv[d->custom_optind] + 1 + (longopts != NULL && argv[d->custom_optind][1] == '-'));
	return 0;
}

/*
 * Check whether the ARGV-element is a long option.
 *
 * If there's a long option "fubar" and the ARGV-element is "-fu", consider
 * that an abbreviation of the long option, just like "--fu", and not "-f" with
 * arg "u".
 *
 * This distinction seems to be the most useful approach.
 *
 */
static int check_long_opt(int argc, char *const *argv, const char *optstring,
		const struct option *longopts, int *longind,
		int print_errors, struct custom_getopt_data *d)
{
	char *nameend;
	const struct option *p;
	const struct option *pfound = NULL;
	int exact = 0;
	int ambig = 0;
	int indfound = -1;
	int option_index;

	for (nameend = d->nextchar; *nameend && *nameend != '='; nameend++)
		/* Do nothing.  */ ;

	/* Test all long options for either exact match or abbreviated matches */
	for (p = longopts, option_index = 0; p->name; p++, option_index++)
		if (!strncmp(p->name, d->nextchar, nameend - d->nextchar)) {
			if ((unsigned int) (nameend - d->nextchar)
					== (unsigned int) strlen(p->name)) {
				/* Exact match found.  */
				pfound = p;
				indfound = option_index;
				exact = 1;
				break;
			} else if (pfound == NULL) {
				/* First nonexact match found.  */
				pfound = p;
				indfound = option_index;
			} else if (pfound->has_arg != p->has_arg
					|| pfound->flag != p->flag
					|| pfound->val != p->val)
				/* Second or later nonexact match found.  */
				ambig = 1;
		}
	if (ambig && !exact) {
		if (print_errors) {
			fprintf(stderr,
				"%s: option `%s' is ambiguous\n",
				argv[0], argv[d->custom_optind]);
		}
		d->nextchar += strlen(d->nextchar);
		d->custom_optind++;
		d->custom_optopt = 0;
		return '?';
	}
	if (pfound) {
		option_index = indfound;
		d->custom_optind++;
		if (*nameend) {
			if (pfound->has_arg != no_argument)
				d->custom_optarg = nameend + 1;
			else {
				if (print_errors) {
					if (argv[d->custom_optind - 1][1] == '-') {
						/* --option */
						fprintf(stderr, "%s: option `--%s' doesn't allow an argument\n",
							argv[0], pfound->name);
					} else {
						/* +option or -option */
						fprintf(stderr, "%s: option `%c%s' doesn't allow an argument\n",
							argv[0], argv[d->custom_optind - 1][0], pfound->name);
					}

				}
				d->nextchar += strlen(d->nextchar);
				d->custom_optopt = pfound->val;
				return '?';
			}
		} else if (pfound->has_arg == required_argument) {
			if (d->custom_optind < argc)
				d->custom_optarg = argv[d->custom_optind++];
			else {
				if (print_errors) {
					fprintf(stderr,
						"%s: option `%s' requires an argument\n",
						argv[0],
						argv[d->custom_optind - 1]);
				}
				d->nextchar += strlen(d->nextchar);
				d->custom_optopt = pfound->val;
				return optstring[0] == ':' ? ':' : '?';
			}
		}
		d->nextchar += strlen(d->nextchar);
		if (longind != NULL)
			*longind = option_index;
		if (pfound->flag) {
			*(pfound->flag) = pfound->val;
			return 0;
		}
		return pfound->val;
	}
	/*
	 * Can't find it as a long option.  If this is not getopt_long_only, or
	 * the option starts with '--' or is not a valid short option, then
	 * it's an error.  Otherwise interpret it as a short option.
	 */
	if (print_errors) {
		if (argv[d->custom_optind][1] == '-') {
			/* --option */
			fprintf(stderr,
				"%s: unrecognized option `--%s'\n",
				argv[0], d->nextchar);
		} else {
			/* +option or -option */
			fprintf(stderr,
				"%s: unrecognized option `%c%s'\n",
				argv[0], argv[d->custom_optind][0],
				d->nextchar);
		}
	}
	d->nextchar = (char *) "";
	d->custom_optind++;
	d->custom_optopt = 0;
	return '?';
}

static int check_short_opt(int argc, char *const *argv, const char *optstring,
		int print_errors, struct custom_getopt_data *d)
{
	char c = *d->nextchar++;
	const char *temp = strchr(optstring, c);

	/* Increment `custom_optind' when we start to process its last character.  */
	if (*d->nextchar == '\0')
		++d->custom_optind;
	if (!temp || c == ':') {
		if (print_errors)
			fprintf(stderr, "%s: invalid option -- %c\n", argv[0], c);

		d->custom_optopt = c;
		return '?';
	}
	if (temp[1] == ':') {
		if (temp[2] == ':') {
			/* This is an option that accepts an argument optionally.  */
			if (*d->nextchar != '\0') {
				d->custom_optarg = d->nextchar;
				d->custom_optind++;
			} else
				d->custom_optarg = NULL;
			d->nextchar = NULL;
		} else {
			/* This is an option that requires an argument.  */
			if (*d->nextchar != '\0') {
				d->custom_optarg = d->nextchar;
				/*
				 * If we end this ARGV-element by taking the
				 * rest as an arg, we must advance to the next
				 * element now.
				 */
				d->custom_optind++;
			} else if (d->custom_optind == argc) {
				if (print_errors) {
					fprintf(stderr,
						"%s: option requires an argument -- %c\n",
						argv[0], c);
				}
				d->custom_optopt = c;
				if (optstring[0] == ':')
					c = ':';
				else
					c = '?';
			} else
				/*
				 * We already incremented `custom_optind' once;
				 * increment it again when taking next ARGV-elt
				 * as argument.
				 */
				d->custom_optarg = argv[d->custom_optind++];
			d->nextchar = NULL;
		}
	}
	return c;
}

/*
 * Scan elements of ARGV for option characters given in OPTSTRING.
 *
 * If an element of ARGV starts with '-', and is not exactly "-" or "--",
 * then it is an option element.  The characters of this element
 * (aside from the initial '-') are option characters.  If `getopt'
 * is called repeatedly, it returns successively each of the option characters
 * from each of the option elements.
 *
 * If `getopt' finds another option character, it returns that character,
 * updating `custom_optind' and `nextchar' so that the next call to `getopt' can
 * resume the scan with the following option character or ARGV-element.
 *
 * If there are no more option characters, `getopt' returns -1.
 * Then `custom_optind' is the index in ARGV of the first ARGV-element
 * that is not an option.  (The ARGV-elements have been permuted
 * so that those that are not options now come last.)
 *
 * OPTSTRING is a string containing the legitimate option characters.
 * If an option character is seen that is not listed in OPTSTRING,
 * return '?' after printing an error message.  If you set `custom_opterr' to
 * zero, the error message is suppressed but we still return '?'.
 *
 * If a char in OPTSTRING is followed by a colon, that means it wants an arg,
 * so the following text in the same ARGV-element, or the text of the following
 * ARGV-element, is returned in `custom_optarg'.  Two colons mean an option that
 * wants an optional arg; if there is text in the current ARGV-element,
 * it is returned in `custom_optarg', otherwise `custom_optarg' is set to zero.
 *
 * If OPTSTRING starts with `-' or `+', it requests different methods of
 * handling the non-option ARGV-elements.
 * See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
 *
 * Long-named options begin with `--' instead of `-'.
 * Their names may be abbreviated as long as the abbreviation is unique
 * or is an exact match for some defined option.  If they have an
 * argument, it follows the option name in the same ARGV-element, separated
 * from the option name by a `=', or else the in next ARGV-element.
 * When `getopt' finds a long-named option, it returns 0 if that option's
 * `flag' field is nonzero, the value of the option's `val' field
 * if the `flag' field is zero.
 *
 * The elements of ARGV aren't really const, because we permute them.
 * But we pretend they're const in the prototype to be compatible
 * with other systems.
 *
 * LONGOPTS is a vector of `struct option' terminated by an
 * element containing a name which is zero.
 *
 * LONGIND returns the index in LONGOPT of the long-named option found.
 * It is only valid when a long-named option has been found by the most
 * recent call.
 *
 * Return the option character from OPTS just read.  Return -1 when there are
 * no more options.  For unrecognized options, or options missing arguments,
 * `custom_optopt' is set to the option letter, and '?' is returned.
 *
 * The OPTS string is a list of characters which are recognized option letters,
 * optionally followed by colons, specifying that that letter takes an
 * argument, to be placed in `custom_optarg'.
 *
 * If a letter in OPTS is followed by two colons, its argument is optional.
 * This behavior is specific to the GNU `getopt'.
 *
 * The argument `--' causes premature termination of argument scanning,
 * explicitly telling `getopt' that there are no more options.  If OPTS begins
 * with `--', then non-option arguments are treated as arguments to the option
 * '\0'.  This behavior is specific to the GNU `getopt'.
 */

static int getopt_internal_r(int argc, char *const *argv, const char *optstring,
		const struct option *longopts, int *longind,
		struct custom_getopt_data *d)
{
	int ret, print_errors = d->custom_opterr;

	if (optstring[0] == ':')
		print_errors = 0;
	if (argc < 1)
		return -1;
	d->custom_optarg = NULL;

	/*
	 * This is a big difference with GNU getopt, since optind == 0
	 * means initialization while here 1 means first call.
	 */
	if (d->custom_optind == 0 || !d->initialized) {
		if (d->custom_optind == 0)
			d->custom_optind = 1;	/* Don't scan ARGV[0], the program name.  */
		custom_getopt_initialize(d);
	}
	if (d->nextchar == NULL || *d->nextchar == '\0') {
		ret = shuffle_argv(argc, argv, longopts, d);
		if (ret)
			return ret;
	}
	if (longopts && (argv[d->custom_optind][1] == '-' ))
		return check_long_opt(argc, argv, optstring, longopts,
			longind, print_errors, d);
	return check_short_opt(argc, argv, optstring, print_errors, d);
}

static int custom_getopt_internal(int argc, char *const *argv, const char *optstring,
	const struct option *longopts, int *longind)
{
	int result;
	/* Keep a global copy of all internal members of d */
	static struct custom_getopt_data d;

	d.custom_optind = custom_optind;
	d.custom_opterr = custom_opterr;
	result = getopt_internal_r(argc, argv, optstring, longopts,
		longind, &d);
	custom_optind = d.custom_optind;
	custom_optarg = d.custom_optarg;
	custom_optopt = d.custom_optopt;
	return result;
}

static int custom_getopt_long (int argc, char *const *argv, const char *options,
	const struct option *long_options, int *opt_index)
{
	return custom_getopt_internal(argc, argv, options, long_options,
		opt_index);
}


static char *package_name = 0;

/**
 * @brief updates an option
 * @param field the generic pointer to the field to update
 * @param orig_field the pointer to the orig field
 * @param field_given the pointer to the number of occurrence of this option
 * @param prev_given the pointer to the number of occurrence already seen
 * @param value the argument for this option (if null no arg was specified)
 * @param possible_values the possible values for this option (if specified)
 * @param default_value the default value (in case the option only accepts fixed values)
 * @param arg_type the type of this option
 * @param check_ambiguity @see RNALalifold_cmdline_parser_params.check_ambiguity
 * @param override @see RNALalifold_cmdline_parser_params.override
 * @param no_free whether to free a possible previous value
 * @param multiple_option whether this is a multiple option
 * @param long_opt the corresponding long option
 * @param short_opt the corresponding short option (or '-' if none)
 * @param additional_error possible further error specification
 */
static
int update_arg(void *field, char **orig_field,
               unsigned int *field_given, unsigned int *prev_given,
               char *value, const char *possible_values[],
               const char *default_value,
               RNALalifold_cmdline_parser_arg_type arg_type,
               int check_ambiguity, int override,
               int no_free, int multiple_option,
               const char *long_opt, char short_opt,
               const char *additional_error)
{
  char *stop_char = 0;
  const char *val = value;
  int found;
  char **string_field;
  FIX_UNUSED (field);

  stop_char = 0;
  found = 0;

  if (!multiple_option && prev_given && (*prev_given || (check_ambiguity && *field_given)))
    {
      if (short_opt != '-')
        fprintf (stderr, "%s: `--%s' (`-%c') option given more than once%s\n",
               package_name, long_opt, short_opt,
               (additional_error ? additional_error : ""));
      else
        fprintf (stderr, "%s: `--%s' option given more than once%s\n",
               package_name, long_opt,
               (additional_error ? additional_error : ""));
      return 1; /* failure */
    }

  FIX_UNUSED (default_value);

  if (field_given && *field_given && ! override)
    return 0;
  if (prev_given)
    (*prev_given)++;
  if (field_given)
    (*field_given)++;
  if (possible_values)
    val = possible_values[found];

  switch(arg_type) {
  case ARG_FLAG:
    *((int *)field) = !*((int *)field);
    break;
  case ARG_INT:
    if (val) *((int *)field) = strtol (val, &stop_char, 0);
    break;
  case ARG_LONG:
    if (val) *((long *)field) = (long)strtol (val, &stop_char, 0);
    break;
  case ARG_DOUBLE:
    if (val) *((double *)field) = strtod (val, &stop_char);
    break;
  case ARG_STRING:
    if (val) {
      string_field = (char **)field;
      if (!no_free && *string_field)
        free (*string_field); /* free previous string */
      *string_field = gengetopt_strdup (val);
    }
    break;
  default:
    break;
  };

  /* check numeric conversion */
  switch(arg_type) {
  case ARG_INT:
  case ARG_LONG:
  case ARG_DOUBLE:
    if (val && !(stop_char && *stop_char == '\0')) {
      fprintf(stderr, "%s: invalid numeric value: %s\n", package_name, val);
      return 1; /* failure */
    }
    break;
  default:
    ;
  };

  /* store the original value */
  switch(arg_type) {
  case ARG_NO:
  case ARG_FLAG:
    break;
  default:
    if (value && orig_field) {
      if (no_free) {
        *orig_field = value;
      } else {
        if (*orig_field)
          free (*orig_field); /* free previous string */
        *orig_field = gengetopt_strdup (value);
      }
    }
  };

  return 0; /* OK */
}

/**
 * @brief store information about a multiple option in a temporary list
 * @param list where to (temporarily) store multiple options
 */
static
int update_multiple_arg_temp(struct generic_list **list,
               unsigned int *prev_given, const char *val,
               const char *possible_values[], const char *default_value,
               RNALalifold_cmdline_parser_arg_type arg_type,
               const char *long_opt, char short_opt,
               const char *additional_error)
{
  /* store single arguments */
  char *multi_token;
  const char *multi_next;

  if (arg_type == ARG_NO) {
    (*prev_given)++;
    return 0; /* OK */
  }

  multi_token = get_multiple_arg_token(val);
  multi_next = get_multiple_arg_token_next (val);

  while (1)
    {
      add_node (list);
      if (update_arg((void *)&((*list)->arg), &((*list)->orig), 0,
          prev_given, multi_token, possible_values, default_value,
          arg_type, 0, 1, 1, 1, long_opt, short_opt, additional_error)) {
        if (multi_token) free(multi_token);
        return 1; /* failure */
      }

      if (multi_next)
        {
          multi_token = get_multiple_arg_token(multi_next);
          multi_next = get_multiple_arg_token_next (multi_next);
        }
      else
        break;
    }

  return 0; /* OK */
}

/**
 * @brief free the passed list (including possible string argument)
 */
static
void free_list(struct generic_list *list, short string_arg)
{
  if (list) {
    struct generic_list *tmp;
    while (list)
      {
        tmp = list;
        if (string_arg && list->arg.string_arg)
          free (list->arg.string_arg);
        if (list->orig)
          free (list->orig);
        list = list->next;
        free (tmp);
      }
  }
}

/**
 * @brief updates a multiple option starting from the passed list
 */
static
void update_multiple_arg(void *field, char ***orig_field,
               unsigned int field_given, unsigned int prev_given, union generic_value *default_value,
               RNALalifold_cmdline_parser_arg_type arg_type,
               struct generic_list *list)
{
  int i;
  struct generic_list *tmp;

  if (prev_given && list) {
    *orig_field = (char **) realloc (*orig_field, (field_given + prev_given) * sizeof (char *));

    switch(arg_type) {
    case ARG_INT:
      *((int **)field) = (int *)realloc (*((int **)field), (field_given + prev_given) * sizeof (int)); break;
    case ARG_LONG:
      *((long **)field) = (long *)realloc (*((long **)field), (field_given + prev_given) * sizeof (long)); break;
    case ARG_DOUBLE:
      *((double **)field) = (double *)realloc (*((double **)field), (field_given + prev_given) * sizeof (double)); break;
    case ARG_STRING:
      *((char ***)field) = (char **)realloc (*((char ***)field), (field_given + prev_given) * sizeof (char *)); break;
    default:
      break;
    };

    for (i = (prev_given - 1); i >= 0; --i)
      {
        tmp = list;

        switch(arg_type) {
        case ARG_INT:
          (*((int **)field))[i + field_given] = tmp->arg.int_arg; break;
        case ARG_LONG:
          (*((long **)field))[i + field_given] = tmp->arg.long_arg; break;
        case ARG_DOUBLE:
          (*((double **)field))[i + field_given] = tmp->arg.double_arg; break;
        case ARG_STRING:
          (*((char ***)field))[i + field_given] = tmp->arg.string_arg; break;
        default:
          break;
        }
        (*orig_field) [i + field_given] = list->orig;
        list = list->next;
        free (tmp);
      }
  } else { /* set the default value */
    if (default_value && ! field_given) {
      switch(arg_type) {
      case ARG_INT:
        if (! *((int **)field)) {
          *((int **)field) = (int *)malloc (sizeof (int));
          (*((int **)field))[0] = default_value->int_arg;
        }
        break;
      case ARG_LONG:
        if (! *((long **)field)) {
          *((long **)field) = (long *)malloc (sizeof (long));
          (*((long **)field))[0] = default_value->long_arg;
        }
        break;
      case ARG_DOUBLE:
        if (! *((double **)field)) {
          *((double **)field) = (double *)malloc (sizeof (double));
          (*((double **)field))[0] = default_value->double_arg;
        }
        break;
      case ARG_STRING:
        if (! *((char ***)field)) {
          *((char ***)field) = (char **)malloc (sizeof (char *));
          (*((char ***)field))[0] = gengetopt_strdup(default_value->string_arg);
        }
        break;
      default: break;
      }
      if (!(*orig_field)) {
        *orig_field = (char **) malloc (sizeof (char *));
        (*orig_field)[0] = 0;
      }
    }
  }
}

int
RNALalifold_cmdline_parser_internal (
  int argc, char **argv, struct RNALalifold_args_info *args_info,
                        struct RNALalifold_cmdline_parser_params *params, const char *additional_error)
{
  int c;	/* Character of the parsed option.  */

  struct generic_list * shape_list = NULL;
  int error_occurred = 0;
  struct RNALalifold_args_info local_args_info;

  int override;
  int initialize;
  int check_required;
  int check_ambiguity;

  char *optarg;
  int optind;
  int opterr;
  int optopt;

  package_name = argv[0];

  /* TODO: Why is this here? It is not used anywhere. */
  override = params->override;
  FIX_UNUSED(override);

  initialize = params->initialize;
  check_required = params->check_required;

  /* TODO: Why is this here? It is not used anywhere. */
  check_ambiguity = params->check_ambiguity;
  FIX_UNUSED(check_ambiguity);

  if (initialize)
    RNALalifold_cmdline_parser_init (args_info);

  RNALalifold_cmdline_parser_init (&local_args_info);

  optarg = 0;
  optind = 0;
  opterr = params->print_errors;
  optopt = '?';

  while (1)
    {
      int option_index = 0;

      static struct option long_options[] = {
        { "help",	0, NULL, 'h' },
        { "detailed-help",	0, NULL, 0 },
        { "full-help",	0, NULL, 0 },
        { "version",	0, NULL, 'V' },
        { "verbose",	0, NULL, 'v' },
        { "quiet",	0, NULL, 'q' },
        { "noconv",	0, NULL, 0 },
        { "input-format",	1, NULL, 'f' },
        { "csv",	0, NULL, 0 },
        { "aln",	2, NULL, 0 },
        { "aln-EPS",	2, NULL, 0 },
        { "aln-EPS-cols",	1, NULL, 0 },
        { "aln-EPS-ss",	2, NULL, 0 },
        { "aln-stk",	2, NULL, 0 },
        { "auto-id",	0, NULL, 0 },
        { "id-prefix",	1, NULL, 0 },
        { "id-delim",	1, NULL, 0 },
        { "id-digits",	1, NULL, 0 },
        { "id-start",	1, NULL, 0 },
        { "filename-delim",	1, NULL, 0 },
        { "split-contributions",	0, NULL, 0 },
        { "shape",	1, NULL, 0 },
        { "shapeMethod",	1, NULL, 0 },
        { "maxBPspan",	1, NULL, 'L' },
        { "threshold",	1, NULL, 0 },
        { "mis",	0, NULL, 0 },
        { "gquad",	0, NULL, 'g' },
        { "temp",	1, NULL, 'T' },
        { "noTetra",	0, NULL, '4' },
        { "dangles",	1, NULL, 'd' },
        { "noLP",	0, NULL, 0 },
        { "noGU",	0, NULL, 0 },
        { "noClosingGU",	0, NULL, 0 },
        { "paramFile",	1, NULL, 'P' },
        { "nsp",	1, NULL, 0 },
        { "energyModel",	1, NULL, 'e' },
        { "cfactor",	1, NULL, 0 },
        { "nfactor",	1, NULL, 0 },
        { "ribosum_file",	1, NULL, 'R' },
        { "ribosum_scoring",	0, NULL, 'r' },
        { 0,  0, 0, 0 }
      };

      custom_optarg = optarg;
      custom_optind = optind;
      custom_opterr = opterr;
      custom_optopt = optopt;

      c = custom_getopt_long (argc, argv, "hVvqf:L:gT:4d:P:e:R:r", long_options, &option_index);

      optarg = custom_optarg;
      optind = custom_optind;
      opterr = custom_opterr;
      optopt = custom_optopt;

      if (c == -1) break;	/* Exit from `while (1)' loop.  */

      switch (c)
        {
        case 'h':	/* Print help and exit.  */
          RNALalifold_cmdline_parser_print_help ();
          RNALalifold_cmdline_parser_free (&local_args_info);
          exit (EXIT_SUCCESS);

        case 'V':	/* Print version and exit.  */
          RNALalifold_cmdline_parser_print_version ();
          RNALalifold_cmdline_parser_free (&local_args_info);
          exit (EXIT_SUCCESS);

        case 'v':	/* Be verbose.

.  */


          if (update_arg((void *)&(args_info->verbose_flag), 0, &(args_info->verbose_given),
              &(local_args_info.verbose_given), optarg, 0, 0, ARG_FLAG,
              check_ambiguity, override, 1, 0, "verbose", 'v',
              additional_error))
            goto failure;

          break;
        case 'q':	/* Be quiet.
.  */


          if (update_arg((void *)&(args_info->quiet_flag), 0, &(args_info->quiet_given),
              &(local_args_info.quiet_given), optarg, 0, 0, ARG_FLAG,
              check_ambiguity, override, 1, 0, "quiet", 'q',
              additional_error))
            goto failure;

          break;
        case 'f':	/* File format of the input multiple sequence alignment (MSA).
.  */


          if (update_arg( (void *)&(args_info->input_format_arg),
               &(args_info->input_format_orig), &(args_info->input_format_given),
              &(local_args_info.input_format_given), optarg, 0, 0, ARG_STRING,
              check_ambiguity, override, 0, 0,
              "input-format", 'f',
              additional_error))
            goto failure;

          break;
        case 'L':	/* Set the maximum allowed separation of a base pair to span. I.e. no pairs (i,j) with j-i>span will be allowed.

.  */


          if (update_arg( (void *)&(args_info->maxBPspan_arg),
               &(args_info->maxBPspan_orig), &(args_info->maxBPspan_given),
              &(local_args_info.maxBPspan_given), optarg, 0, "70", ARG_INT,
              check_ambiguity, override, 0, 0,
              "maxBPspan", 'L',
              additional_error))
            goto failure;

          break;
        case 'g':	/* Incoorporate G-Quadruplex formation into the structure prediction algorithm

.  */


          if (update_arg((void *)&(args_info->gquad_flag), 0, &(args_info->gquad_given),
              &(local_args_info.gquad_given), optarg, 0, 0, ARG_FLAG,
              check_ambiguity, override, 1, 0, "gquad", 'g',
              additional_error))
            goto failure;

          break;
        case 'T':	/* Rescale energy parameters to a temperature of temp C. Default is 37C.

.  */


          if (update_arg( (void *)&(args_info->temp_arg),
               &(args_info->temp_orig), &(args_info->temp_given),
              &(local_args_info.temp_given), optarg, 0, 0, ARG_DOUBLE,
              check_ambiguity, override, 0, 0,
              "temp", 'T',
              additional_error))
            goto failure;

          break;
        case '4':	/* Do not include special tabulated stabilizing energies for tri-, tetra- and hexaloop hairpins. Mostly for testing.

.  */


          if (update_arg((void *)&(args_info->noTetra_flag), 0, &(args_info->noTetra_given),
              &(local_args_info.noTetra_given), optarg, 0, 0, ARG_FLAG,
              check_ambiguity, override, 1, 0, "noTetra", '4',
              additional_error))
            goto failure;

          break;
        case 'd':	/* How to treat \"dangling end\" energies for bases adjacent to helices in free ends and multi-loops
.  */


          if (update_arg( (void *)&(args_info->dangles_arg),
               &(args_info->dangles_orig), &(args_info->dangles_given),
              &(local_args_info.dangles_given), optarg, 0, "2", ARG_INT,
              check_ambiguity, override, 0, 0,
              "dangles", 'd',
              additional_error))
            goto failure;

          break;
        case 'P':	/* Read energy parameters from paramfile, instead of using the default parameter set.
.  */


          if (update_arg( (void *)&(args_info->paramFile_arg),
               &(args_info->paramFile_orig), &(args_info->paramFile_given),
              &(local_args_info.paramFile_given), optarg, 0, 0, ARG_STRING,
              check_ambiguity, override, 0, 0,
              "paramFile", 'P',
              additional_error))
            goto failure;

          break;
        case 'e':	/* Rarely used option to fold sequences from the artificial ABCD... alphabet, where A pairs B, C-D etc.  Use the energy parameters for GC (-e 1) or AU (-e 2) pairs.

.  */


          if (update_arg( (void *)&(args_info->energyModel_arg),
               &(args_info->energyModel_orig), &(args_info->energyModel_given),
              &(local_args_info.energyModel_given), optarg, 0, 0, ARG_INT,
              check_ambiguity, override, 0, 0,
              "energyModel", 'e',
              additional_error))
            goto failure;

          break;
        case 'R':	/* use specified Ribosum Matrix instead of normal energy model. Matrixes to use should be 6x6 matrices, the order of the terms is AU, CG, GC, GU, UA, UG.

.  */


          if (update_arg( (void *)&(args_info->ribosum_file_arg),
               &(args_info->ribosum_file_orig), &(args_info->ribosum_file_given),
              &(local_args_info.ribosum_file_given), optarg, 0, 0, ARG_STRING,
              check_ambiguity, override, 0, 0,
              "ribosum_file", 'R',
              additional_error))
            goto failure;

          break;
        case 'r':	/* use ribosum scoring matrix. The matrix is chosen according to the minimal and maximal pairwise identities of the sequences in the file.

.  */


          if (update_arg((void *)&(args_info->ribosum_scoring_flag), 0, &(args_info->ribosum_scoring_given),
              &(local_args_info.ribosum_scoring_given), optarg, 0, 0, ARG_FLAG,
              check_ambiguity, override, 1, 0, "ribosum_scoring", 'r',
              additional_error))
            goto failure;

          break;

        case 0:	/* Long option with no short option */
          if (strcmp (long_options[option_index].name, "detailed-help") == 0) {
            RNALalifold_cmdline_parser_print_detailed_help ();
            RNALalifold_cmdline_parser_free (&local_args_info);
            exit (EXIT_SUCCESS);
          }

          if (strcmp (long_options[option_index].name, "full-help") == 0) {
            RNALalifold_cmdline_parser_print_full_help ();
            RNALalifold_cmdline_parser_free (&local_args_info);
            exit (EXIT_SUCCESS);
          }

          /* Do not automatically substitute nucleotide \"T\" with \"U\"

.  */
          if (strcmp (long_options[option_index].name, "noconv") == 0)
          {


            if (update_arg((void *)&(args_info->noconv_flag), 0, &(args_info->noconv_given),
                &(local_args_info.noconv_given), optarg, 0, 0, ARG_FLAG,
                check_ambiguity, override, 1, 0, "noconv", '-',
                additional_error))
              goto failure;

          }
          /* Create comma separated output (csv)

.  */
          else if (strcmp (long_options[option_index].name, "csv") == 0)
          {


            if (update_arg((void *)&(args_info->csv_flag), 0, &(args_info->csv_given),
                &(local_args_info.csv_given), optarg, 0, 0, ARG_FLAG,
                check_ambiguity, override, 1, 0, "csv", '-',
                additional_error))
              goto failure;

          }
          /* Produce output alignments and secondary structure plots for each hit found.
.  */
          else if (strcmp (long_options[option_index].name, "aln") == 0)
          {


            if (update_arg( (void *)&(args_info->aln_arg),
                 &(args_info->aln_orig), &(args_info->aln_given),
                &(local_args_info.aln_given), optarg, 0, 0, ARG_STRING,
                check_ambiguity, override, 0, 0,
                "aln", '-',
                additional_error))
              goto failure;

          }
          /* Produce colored and structure annotated subalignment for each hit
.  */
          else if (strcmp (long_options[option_index].name, "aln-EPS") == 0)
          {


            if (update_arg( (void *)&(args_info->aln_EPS_arg),
                 &(args_info->aln_EPS_orig), &(args_info->aln_EPS_given),
                &(local_args_info.aln_EPS_given), optarg, 0, 0, ARG_STRING,
                check_ambiguity, override, 0, 0,
                "aln-EPS", '-',
                additional_error))
              goto failure;

          }
          /* Number of columns in colored EPS alignment output.
.  */
          else if (strcmp (long_options[option_index].name, "aln-EPS-cols") == 0)
          {


            if (update_arg( (void *)&(args_info->aln_EPS_cols_arg),
                 &(args_info->aln_EPS_cols_orig), &(args_info->aln_EPS_cols_given),
                &(local_args_info.aln_EPS_cols_given), optarg, 0, "60", ARG_INT,
                check_ambiguity, override, 0, 0,
                "aln-EPS-cols", '-',
                additional_error))
              goto failure;

          }
          /* Produce colored consensus secondary structure plots in PostScript format
.  */
          else if (strcmp (long_options[option_index].name, "aln-EPS-ss") == 0)
          {


            if (update_arg( (void *)&(args_info->aln_EPS_ss_arg),
                 &(args_info->aln_EPS_ss_orig), &(args_info->aln_EPS_ss_given),
                &(local_args_info.aln_EPS_ss_given), optarg, 0, 0, ARG_STRING,
                check_ambiguity, override, 0, 0,
                "aln-EPS-ss", '-',
                additional_error))
              goto failure;

          }
          /* Add hits to a multi-Stockholm formatted output file.
.  */
          else if (strcmp (long_options[option_index].name, "aln-stk") == 0)
          {


            if (update_arg( (void *)&(args_info->aln_stk_arg),
                 &(args_info->aln_stk_orig), &(args_info->aln_stk_given),
                &(local_args_info.aln_stk_given), optarg, 0, "RNALalifold_results", ARG_STRING,
                check_ambiguity, override, 0, 0,
                "aln-stk", '-',
                additional_error))
              goto failure;

          }
          /* Automatically generate an ID for each alignment.
.  */
          else if (strcmp (long_options[option_index].name, "auto-id") == 0)
          {


            if (update_arg((void *)&(args_info->auto_id_flag), 0, &(args_info->auto_id_given),
                &(local_args_info.auto_id_given), optarg, 0, 0, ARG_FLAG,
                check_ambiguity, override, 1, 0, "auto-id", '-',
                additional_error))
              goto failure;

          }
          /* Prefix for automatically generated IDs (as used in output file names)

.  */
          else if (strcmp (long_options[option_index].name, "id-prefix") == 0)
          {


            if (update_arg( (void *)&(args_info->id_prefix_arg),
                 &(args_info->id_prefix_orig), &(args_info->id_prefix_given),
                &(local_args_info.id_prefix_given), optarg, 0, "alignment", ARG_STRING,
                check_ambiguity, override, 0, 0,
                "id-prefix", '-',
                additional_error))
              goto failure;

          }
          /* Change the delimiter between prefix and increasing number for automatically generated IDs (as used in output file names)

.  */
          else if (strcmp (long_options[option_index].name, "id-delim") == 0)
          {


            if (update_arg( (void *)&(args_info->id_delim_arg),
                 &(args_info->id_delim_orig), &(args_info->id_delim_given),
                &(local_args_info.id_delim_given), optarg, 0, "_", ARG_STRING,
                check_ambiguity, override, 0, 0,
                "id-delim", '-',
                additional_error))
              goto failure;

          }
          /* Specify the number of digits of the counter in automatically generated alignment IDs.
.  */
          else if (strcmp (long_options[option_index].name, "id-digits") == 0)
          {


            if (update_arg( (void *)&(args_info->id_digits_arg),
                 &(args_info->id_digits_orig), &(args_info->id_digits_given),
                &(local_args_info.id_digits_given), optarg, 0, "4", ARG_INT,
                check_ambiguity, override, 0, 0,
                "id-digits", '-',
                additional_error))
              goto failure;

          }
          /* Specify the first number in automatically generated alignment IDs.
.  */
          else if (strcmp (long_options[option_index].name, "id-start") == 0)
          {


            if (update_arg( (void *)&(args_info->id_start_arg),
                 &(args_info->id_start_orig), &(args_info->id_start_given),
                &(local_args_info.id_start_given), optarg, 0, "1", ARG_LONG,
                check_ambiguity, override, 0, 0,
                "id-start", '-',
                additional_error))
              goto failure;

          }
          /* Change the delimiting character that is used for sanitized filenames

.  */
          else if (strcmp (long_options[option_index].name, "filename-delim") == 0)
          {


            if (update_arg( (void *)&(args_info->filename_delim_arg),
                 &(args_info->filename_delim_orig), &(args_info->filename_delim_given),
                &(local_args_info.filename_delim_given), optarg, 0, "ID-delimiter", ARG_STRING,
                check_ambiguity, override, 0, 0,
                "filename-delim", '-',
                additional_error))
              goto failure;

          }
          /* Split the free energy contributions into separate parts
.  */
          else if (strcmp (long_options[option_index].name, "split-contributions") == 0)
          {


            if (update_arg((void *)&(args_info->split_contributions_flag), 0, &(args_info->split_contributions_given),
                &(local_args_info.split_contributions_given), optarg, 0, 0, ARG_FLAG,
                check_ambiguity, override, 1, 0, "split-contributions", '-',
                additional_error))
              goto failure;

          }
          /* Use SHAPE reactivity data to guide structure predictions
.  */
          else if (strcmp (long_options[option_index].name, "shape") == 0)
          {

            if (update_multiple_arg_temp(&shape_list,
                &(local_args_info.shape_given), optarg, 0, 0, ARG_STRING,
                "shape", '-',
                additional_error))
              goto failure;

          }
          /* Specify the method how to convert SHAPE reactivity data to pseudo energy contributions
.  */
          else if (strcmp (long_options[option_index].name, "shapeMethod") == 0)
          {


            if (update_arg( (void *)&(args_info->shapeMethod_arg),
                 &(args_info->shapeMethod_orig), &(args_info->shapeMethod_given),
                &(local_args_info.shapeMethod_given), optarg, 0, "D", ARG_STRING,
                check_ambiguity, override, 0, 0,
                "shapeMethod", '-',
                additional_error))
              goto failure;

          }
          /* Energy threshold in kcal/mol per nucleotide above which secondary structure hits are omitted in the output.

.  */
          else if (strcmp (long_options[option_index].name, "threshold") == 0)
          {


            if (update_arg( (void *)&(args_info->threshold_arg),
                 &(args_info->threshold_orig), &(args_info->threshold_given),
                &(local_args_info.threshold_given), optarg, 0, "-0.1", ARG_DOUBLE,
                check_ambiguity, override, 0, 0,
                "threshold", '-',
                additional_error))
              goto failure;

          }
          /* Output \"most informative sequence\" instead of simple consensus: For each column of the alignment output the set of nucleotides with frequency greater than average in IUPAC notation.

.  */
          else if (strcmp (long_options[option_index].name, "mis") == 0)
          {


            if (update_arg((void *)&(args_info->mis_flag), 0, &(args_info->mis_given),
                &(local_args_info.mis_given), optarg, 0, 0, ARG_FLAG,
                check_ambiguity, override, 1, 0, "mis", '-',
                additional_error))
              goto failure;

          }
          /* Produce structures without lonely pairs (helices of length 1).
.  */
          else if (strcmp (long_options[option_index].name, "noLP") == 0)
          {


            if (update_arg((void *)&(args_info->noLP_flag), 0, &(args_info->noLP_given),
                &(local_args_info.noLP_given), optarg, 0, 0, ARG_FLAG,
                check_ambiguity, override, 1, 0, "noLP", '-',
                additional_error))
              goto failure;

          }
          /* Do not allow GU pairs

.  */
          else if (strcmp (long_options[option_index].name, "noGU") == 0)
          {


            if (update_arg((void *)&(args_info->noGU_flag), 0, &(args_info->noGU_given),
                &(local_args_info.noGU_given), optarg, 0, 0, ARG_FLAG,
                check_ambiguity, override, 1, 0, "noGU", '-',
                additional_error))
              goto failure;

          }
          /* Do not allow GU pairs at the end of helices

.  */
          else if (strcmp (long_options[option_index].name, "noClosingGU") == 0)
          {


            if (update_arg((void *)&(args_info->noClosingGU_flag), 0, &(args_info->noClosingGU_given),
                &(local_args_info.noClosingGU_given), optarg, 0, 0, ARG_FLAG,
                check_ambiguity, override, 1, 0, "noClosingGU", '-',
                additional_error))
              goto failure;

          }
          /* Allow other pairs in addition to the usual AU,GC,and GU pairs.
.  */
          else if (strcmp (long_options[option_index].name, "nsp") == 0)
          {


            if (update_arg( (void *)&(args_info->nsp_arg),
                 &(args_info->nsp_orig), &(args_info->nsp_given),
                &(local_args_info.nsp_given), optarg, 0, 0, ARG_STRING,
                check_ambiguity, override, 0, 0,
                "nsp", '-',
                additional_error))
              goto failure;

          }
          /* Set the weight of the covariance term in the energy function

.  */
          else if (strcmp (long_options[option_index].name, "cfactor") == 0)
          {


            if (update_arg( (void *)&(args_info->cfactor_arg),
                 &(args_info->cfactor_orig), &(args_info->cfactor_given),
                &(local_args_info.cfactor_given), optarg, 0, "1.0", ARG_DOUBLE,
                check_ambiguity, override, 0, 0,
                "cfactor", '-',
                additional_error))
              goto failure;

          }
          /* Set the penalty for non-compatible sequences in the covariance term of the energy function

.  */
          else if (strcmp (long_options[option_index].name, "nfactor") == 0)
          {


            if (update_arg( (void *)&(args_info->nfactor_arg),
                 &(args_info->nfactor_orig), &(args_info->nfactor_given),
                &(local_args_info.nfactor_given), optarg, 0, "1.0", ARG_DOUBLE,
                check_ambiguity, override, 0, 0,
                "nfactor", '-',
                additional_error))
              goto failure;

          }

          break;
        case '?':	/* Invalid option.  */
          /* `getopt_long' already printed an error message.  */
          goto failure;

        default:	/* bug: option not considered.  */
          fprintf (stderr, "%s: option unknown: %c%s\n", RNALALIFOLD_CMDLINE_PARSER_PACKAGE, c, (additional_error ? additional_error : ""));
          abort ();
        } /* switch */
    } /* while */


  update_multiple_arg((void *)&(args_info->shape_arg),
    &(args_info->shape_orig), args_info->shape_given,
    local_args_info.shape_given, 0,
    ARG_STRING, shape_list);

  args_info->shape_given += local_args_info.shape_given;
  local_args_info.shape_given = 0;

  if (check_required)
    {
      error_occurred += RNALalifold_cmdline_parser_required2 (args_info, argv[0], additional_error);
    }

  RNALalifold_cmdline_parser_release (&local_args_info);

  if ( error_occurred )
    return (EXIT_FAILURE);

  if (optind < argc)
    {
      int i = 0 ;
      int found_prog_name = 0;
      /* whether program name, i.e., argv[0], is in the remaining args
         (this may happen with some implementations of getopt,
          but surely not with the one included by gengetopt) */


      args_info->inputs_num = argc - optind - found_prog_name;
      args_info->inputs =
        (char **)(malloc ((args_info->inputs_num)*sizeof(char *))) ;
      while (optind < argc)
        args_info->inputs[ i++ ] = gengetopt_strdup (argv[optind++]) ;
    }

  return 0;

failure:
  free_list (shape_list, 1 );

  RNALalifold_cmdline_parser_release (&local_args_info);
  return (EXIT_FAILURE);
}
/* vim: set ft=c noet ts=8 sts=8 sw=8 tw=80 nojs spell : */