Getopt ordering, any? - c

Question

I was doing a little program and realize that I will need that the user input his options in the right order so my program would do his job right, but I thought that this is kind of 'bug' an should be avoided, so I tried to make the program work 'order independent', but that doesn't work, so I decided to find a function that do the optarg parse the options in the order that I choose, but, for my surprise, I COULDN'T FIND ANY, so I decided to write my on getopt ordering function... The question is, there is a specific function for this job? (and I wrote all of this code in vain :( ). If there is a function, please tell me. And, independently if a function exists or not, You guys could take a look at the piece of code that I wrote... Thank you in advance.
Obs.: I want to know if exist a C function for the task.
The code is in https://github.com/paolocarrara/getopt_ordering
But here is it too (two files):
/*file _getopt.h (first file)*/
#include <stdlib.h>
char **ordering (int *, char **, char *);
/*file ordering.c (second file)*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TRUE 1
#define FALSE 0
int get_line_size (char *line) {
return strlen (line);
}
int verify_if_is_option (char *argv) {
if (argv != NULL) {
if (argv[0] == '-')
return TRUE;
else
return FALSE;
}
else
return FALSE;
}
int problem_counter (int argc, char **argv) {
int i;
int number_of_problens;
for (i = 1, number_of_problens = 0; i < argc; i++)
if (verify_if_is_option (argv[i]) == TRUE)
if (get_line_size (argv[i]) > 2)
number_of_problens++;
return number_of_problens;
}
char **malloc_argv (int argc, char **argv, int t_problens) {
char **new;
int i;
new = malloc ((argc+t_problens)*sizeof(char*));
for (i = 0; i < argc; i++)
new[i] = argv[i];
for (; i < argc + t_problens; i++)
new[i] = NULL;
return new;
}
char *get_problematic_line (int argc, char **argv) {
int i;
char *line = NULL;
for (i = 1; i < argc; i++)
if (verify_if_is_option (argv[i]) == TRUE)
if (get_line_size (argv[i]) > 2)
line = argv[i];
return line;
}
char *get_argument (char *line) {
char *argument;
int i;
argument = malloc ((strlen(line)-1)*sizeof(char));
for (i = 2; i < strlen(line); i++)
argument[i-2] = line[i];
argument[i-2] = '\0';
return argument;
}
char **push_down (int argc, char **argv, int i) {
for (; argc > i+1; argc--)
argv[argc-1] = argv[argc-2];
return argv;
}
char **push_one_line_down_from_here (char *line, int argc, char **argv) {
int i;
for (i = 1; i < argc; i++)
if (argv[i] == line){
argv = push_down (argc, argv, i);
i = argc;
}
return argv;
}
char **insert_argument_below_this_line (char *line, char *argument, char **argv) {
int i;
for (i = 1; line != argv[i]; i++);
argv[i+1] = argument;
return argv;
}
void remove_argument_from_problematic_line (char *line) {
line[2] = '\0';
}
char **malloc_and_divide (int *argc, char **argv) {
int t_problens;
char *line;
char *argument;
t_problens = problem_counter (*argc, argv);
argv = malloc_argv (*argc, argv, t_problens);
(*argc) +=t_problens;
for (;t_problens > 0; t_problens--) {
line = get_problematic_line (*argc, argv);
argument = get_argument (line);
argv = push_one_line_down_from_here (line, *argc, argv);
argv = insert_argument_below_this_line (line, argument, argv);
remove_argument_from_problematic_line(line);
}
return argv;
}
char *litteral_to_dinamic (char *literal) {
int i;
char *dinamic = malloc ((strlen(literal)+1)*sizeof(char));
for (i = 0; i < strlen(literal); i++) dinamic[i] = literal[i];
dinamic[i] = '\0';
return dinamic;
}
char get_desired_option (char *optstring) {
char option;
option = optstring[0];
return option;
}
void remove_option_used (char *optstring) {
int i;
for (i = 1; i <= strlen(optstring); i++)
optstring[i-1] = optstring[i];
if (optstring[0] == ':')
remove_option_used (optstring);
}
int is_in_argv (int argc, char **argv, char option) {
int i;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-' && argv[i][1] == option)
return TRUE;
return FALSE;
}
int option_have_argument (char **argv, int position) {
if (argv[position+1][0] == '-')
return TRUE;
else
return FALSE;
}
int both_have_argument (int argc, char **argv, int position, int i) {
if(i < argc-1){
if((argv[position+1][0] != '-') && (argv[i+1][0] != '-'))
return TRUE;
else
return FALSE;
}
else
return FALSE;
}
void change_both_arguments (int argc, char **argv, int position, int i) {
char *aux;
aux = argv[position+1];
argv[position+1] = argv[i+1];
argv[i+1] = aux;
}
int first_have_argument (int argc, char **argv, int position) {
if (position < argc-1)
if (argv[position+1][0] != '-')
return TRUE;
return FALSE;
}
void change_first_argument (int argc, char **argv, int position, int i) {
char *aux;
aux = argv[position+1];
for (position++; position < i; position++)
argv[position] = argv[position+1];
argv[i] = aux;
}
int second_have_argument (int argc, char **argv, int i) {
if (i < argc-1)
if (argv[i+1][0] != '-')
return TRUE;
return FALSE;
}
void change_second_argument (int argc, char **argv, int position, int i) {
char *aux;
int j;
aux = argv[i+1];
for (j=i+1; j > position; j--)
argv[j] = argv[j-1];
argv[position+1] = aux;
}
int verify_arguments (int argc, char **argv, int position, int i) {
if (both_have_argument (argc, argv, position, i) == TRUE) {
change_both_arguments (argc, argv, position, i);
return position+2;
}
else if (first_have_argument (argc, argv, position) == TRUE) {
change_first_argument (argc, argv, position, i);
return position+1;
}
else if (second_have_argument (argc, argv, i) == TRUE) {
change_second_argument (argc, argv, position, i);
return position+2;
}
else
return position+1;
}
int change_option_position (int argc, char **argv, char option, int position) {
int i;
char *aux;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-' && argv[i][1] == option) {
aux = argv[position];
argv[position] = argv[i];
argv[i] = aux;
position = verify_arguments (argc, argv, position, i);
}
return position;
}
char **organize (int argc, char **argv, char *optstring) {
int position = 1;
char option;
optstring = litteral_to_dinamic (optstring);
while (optstring[0] != '\0') {
option = get_desired_option (optstring);
remove_option_used (optstring);
if ((is_in_argv(argc, argv, option)) == TRUE)
position = change_option_position (argc, argv, option, position);
}
return argv;
}
char **ordering (int *argc, char **argv, char *optstring) {
int i;
argv = malloc_and_divide (argc, argv);
argv = organize (*argc, argv, optstring);
return argv;
}

Answer 1

You are correct, there are no functions that will do what you describe. However, why don't you just declare a bitmap and use getopt only to set the values in the bitmap? After that's done, you can then check the bitmap and process the options in whatever order you please. Consider the following example, assuming an arbitrary option 'b' needed to be processed before an arbitrary option 'a'.
#define OPTIONS = "ab"
#define flaga = 0x0001; /* corresponds to a */
#define flagb = 0x0002; /* corresponds to b */
unsigned int flags = 0; /* the bitmap */
char ch = '\0' /* the switch char */
while ((ch = getopt(argc, argv, OPTIONS)) != -1)
{
switch (ch) {
case 'a': /* set flag a */
flags |= flaga;
break;
case 'b':
flags |= flagb;
break;
}
if((flags & flagb) == flagb)
{
//process flag b
}
if((flags & flaga) == flaga)
{
//process flag a
}