modification of cmdlnopts

getopt/cmdlnopts/Makefile

@@ -0,0 +1,22 @@
+PROGRAM = myopt_example
+LDFLAGS = -lm
+SRCS = $(wildcard *.c)
+CC = gcc
+DEFINES = -D_XOPEN_SOURCE=1111
+CXX = gcc
+CFLAGS = -Wall -Werror -Wextra $(DEFINES)
+OBJS = $(SRCS:.c=.o)
+all : $(PROGRAM)
+$(PROGRAM) : $(OBJS)
+	$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -o $(PROGRAM)
+
+# some addition dependencies
+# %.o: %.c
+#        $(CC) $(LDFLAGS) $(CFLAGS) $< -o $@
+#$(SRCS) : %.c : %.h $(INDEPENDENT_HEADERS)
+#        @touch $@
+
+clean:
+	/bin/rm -f *.o *~
+depend:
+	$(CXX) -MM $(CXX.SRCS)

getopt/cmdlnopts/cmdlnopts.c

@@ -0,0 +1,264 @@
+/*
+ * cmdlnopts.c - the only function that parce cmdln args and returns glob parameters
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <math.h>
+#include "cmdlnopts.h"
+
+#define RAD 57.2957795130823
+#define D2R(x) ((x) / RAD)
+#define R2D(x) ((x) * RAD)
+
+/*
+ * here are global parameters initialisation
+ */
+int help;
+glob_pars  G;
+mirPar     M;
+
+int rewrite_ifexists = 0, // rewrite existing files == 0 or 1
+	verbose = 0; // each -v increments this value, e.g. -vvv sets it to 3
+//            DEFAULTS
+// default global parameters
+glob_pars const Gdefault = {
+	NULL,	// size of initial array of surface deviations
+	100,	// size of interpolated S0
+	1000,	// resulting image size
+	10000,	// amount of photons falled to one pixel of S1 by one iteration
+	0,		// add to mask random numbers
+	NULL,	// amplitude of added random noice
+	NULL,	// mirror
+	0,		// rest num
+	NULL,	// rest pars
+	NULL,	// str
+	NULL	// filter
+};
+//default mirror parameters
+mirPar const Mdefault = {
+	6.,		// diameter
+	24.024,	// focus
+	0.,		// inclination from Z axe (radians)
+	0.			// azimuth of inclination (radians)
+};
+
+// here are functions & definitions for complex parameters (with suboptions etc)
+bool get_mir_par(void *arg);
+const char MirPar[] = "set mirror parameters, arg=[diam=num:foc=num:Zincl=ang:Aincl=ang]\n" \
+		"\t\t\tALL DEGREES ARE IN FORMAT [+-][DDd][MMm][SS.S] like -10m13.4 !\n" \
+		"\t\tdiam  - diameter of mirror\n" \
+		"\t\tfoc   - mirror focus ratio\n" \
+		"\t\tZincl - inclination from Z axe\n" \
+		"\t\tAincl - azimuth of inclination";
+
+const char FilPar[] = "set filter parameters, arg=[type=type:xsz=num:ysz=num]\n" \
+		"\t\ttype     - filter type(med, lap, lg)\n" \
+		"\t\txsz,ysz  - area size (default is 3x3)";
+
+/*
+ * Define command line options by filling structure:
+ *	name	has_arg	flag	val		type		argptr			help
+*/
+myoption cmdlnopts[] = {
+	// set 1 to param despite of its repeating number:
+	{"help",	NO_ARGS,	NULL,	'h',	arg_int,	APTR(&help),		"show this help"},
+	// simple integer parameter with obligatory arg:
+	{"int-size",NEED_ARG,	NULL,	'i',	arg_int,	APTR(&G.S_interp),	"size of interpolated array of surface deviations"},
+	{"image-size",NEED_ARG,NULL,	'I',	arg_int,	APTR(&G.S_image),	"resulting image size"},
+	{"N-photons",NEED_ARG,NULL,	'N',	arg_int,	APTR(&G.N_phot), 	"amount of photons falled to one pixel of matrix by one iteration"},
+	// parameter with suboptions parsed directly in parceargs
+	{"mir-parameters",NEED_ARG,NULL,'M',	arg_function,APTR(&get_mir_par),MirPar},
+	// another variant of setting parameter without argument
+	{"add-noice",NO_ARGS,	&G.randMask,1,	arg_none,	NULL,				"add random noice to mirror surface deviations"},
+	{"force",	 NO_ARGS,	&rewrite_ifexists,1,arg_none,NULL,				"rewrite output file if exists"},
+	// incremented parameter without args (any -v will increment value of "verbose")
+	{"verbose",	NO_ARGS,	NULL,	'v',	arg_none,	APTR(&verbose),		"verbose level (each -v increase it)"},
+	// integer parameter which can occur several times:
+	{"dev-size",MULT_PAR,	NULL,	'd',	arg_int,	APTR(&G.S_dev),		"size of initial array of surface deviations"},
+	// double array
+	{"noice-amp",MULT_PAR,	NULL,	'a',	arg_double,	APTR(&G.randAmp),	"amplitude of random noice (default: 1e-8)"},
+	// string array
+	{"str",		MULT_PAR,	NULL,	's',	arg_string,	APTR(&G.str),		"some string parameters (may meets many times)"},
+	// suboptions array that will be parsed outside (the same as string array):
+	{"filter",	MULT_PAR,	NULL,	'f',	arg_string,	APTR(&G.filter),	FilPar},
+	end_option
+};
+
+
+// suboptions structure for get_mirpars
+// in array last MUST BE {0,0,0}
+typedef struct{
+	double *val;	// pointer to result
+	char *par;		// parameter name (CASE-INSENSITIVE!)
+	bool isdegr;	// == TRUE if parameter is an angle in format "[+-][DDd][MMm][SS.S]"
+} suboptions;
+
+/**
+ * Safely convert data from string to double
+ *
+ * @param num (o) - double number read from string
+ * @param str (i) - input string
+ * @return TRUE if success
+ */
+bool myatod(double *num, const char *str){
+	double res;
+	char *endptr;
+	assert(str);
+	res = strtod(str, &endptr);
+	if(endptr == str || *str == '\0' || *endptr != '\0'){
+		printf("Wrong double number format!");
+		return FALSE;
+	}
+	*num = res;
+	return TRUE;
+}
+
+/**
+ * Convert string "[+-][DDd][MMm][SS.S]" into radians
+ *
+ * @param ang (o) - angle in radians or exit with help message
+ * @param str (i) - string with angle
+ * @return TRUE if OK
+ */
+bool get_radians(double *ret, char *str){
+	double val = 0., ftmp, sign = 1.;
+	char *ptr;
+	assert(str);
+	switch(*str){ // check sign
+		case '-':
+			sign = -1.;
+		case '+':
+			str++;
+	}
+	if((ptr = strchr(str, 'd'))){ // found DDD.DDd
+		*ptr = 0; if(!myatod(&ftmp, str)) return FALSE;
+		ftmp = fabs(ftmp);
+		if(ftmp > 360.){
+			printf("Degrees should be less than 360");
+			return FALSE;
+		}
+		val += ftmp;
+		str = ptr + 1;
+	}
+	if((ptr = strchr(str, 'm'))){ // found DDD.DDm
+		*ptr = 0; if(!myatod(&ftmp, str)) return FALSE;
+		ftmp = fabs(ftmp);
+		val += ftmp / 60.;
+		str = ptr + 1;
+	}
+	if(strlen(str)){ // there is something more
+		if(!myatod(&ftmp, str)) return FALSE;
+		ftmp = fabs(ftmp);
+		val += ftmp / 3600.;
+	}
+	*ret = D2R(val * sign); // convert degrees to radians
+	return TRUE;
+}
+
+/**
+ * Parse string of suboptions (--option=name1=var1:name2=var2... or -O name1=var1,name2=var2...)
+ * Suboptions could be divided by colon or comma
+ *
+ * !!NAMES OF SUBOPTIONS ARE CASE-UNSENSITIVE!!!
+ *
+ * @param arg (i)    - string with description
+ * @param V (io)     - pointer to suboptions array (result will be stored in sopts->val)
+ * @return TRUE if success
+ */
+bool get_mirpars(void *arg, suboptions *V){
+	char *tok, *val, *par;
+	int i;
+	tok = strtok(arg, ":,");
+	do{
+		if((val = strchr(tok, '=')) == NULL){ // wrong format
+			printf("Wrong format: no value for keyword");
+			return FALSE;
+		}
+		*val++ = '\0';
+		par = tok;
+		for(i = 0; V[i].val; i++){
+			if(strcasecmp(par, V[i].par) == 0){ // found parameter
+				if(V[i].isdegr){ // DMS
+					if(!get_radians(V[i].val, val)) // wrong angle
+						return FALSE;
+				}else{ // simple double
+					if(!myatod(V[i].val, val)) // wrong number
+						return FALSE;
+				}
+				break;
+			}
+		}
+		if(!V[i].val){ // nothing found - wrong format
+			printf("Bad keyword!");
+			return FALSE;
+		}
+	}while((tok = strtok(NULL, ":,")));
+	return TRUE;
+}
+
+/**
+ * functions of subargs parcing can looks as this
+ */
+/**
+ * Parse string of mirror parameters (--mir-diam=...)
+ *
+ * @param arg (i) - string with description
+ * @return TRUE if success
+ */
+bool get_mir_par(void *arg){
+	suboptions V[] = { // array of mirror parameters and string keys for cmdln pars
+		{&M.D,		"diam",		FALSE},
+		{&M.F,		"foc",		FALSE},
+		{&M.Zincl,	"zincl",	TRUE},
+		{&M.Aincl,	"aincl",	TRUE},
+		{0,0,0}
+	};
+	return get_mirpars(arg, V);
+}
+
+/**
+ * Parce command line options and return dynamically allocated structure
+ * 		to global parameters
+ * @param argc - copy of argc from main
+ * @param argv - copy of argv from main
+ * @return allocated structure with global parameters
+ */
+glob_pars *parce_args(int argc, char **argv){
+	int i;
+	void *ptr;
+	ptr = memcpy(&G, &Gdefault, sizeof(G)); assert(ptr);
+	ptr = memcpy(&M, &Mdefault, sizeof(M)); assert(ptr);
+	G.Mirror = &M;
+	// format of help: "Usage: progname [args]\n"
+	change_helpstring("Usage: %s [args]\n\n\tWhere args are:\n");
+	// parse arguments
+	parceargs(&argc, &argv, cmdlnopts);
+	if(help) showhelp(-1, cmdlnopts);
+	if(argc > 0){
+		G.rest_pars_num = argc;
+		G.rest_pars = calloc(argc, sizeof(char*));
+		for (i = 0; i < argc; i++)
+			G.rest_pars[i] = strdup(argv[i]);
+	}
+	return &G;
+}
+

getopt/cmdlnopts/cmdlnopts.h

@@ -0,0 +1,61 @@
+/*
+ * cmdlnopts.h - comand line options for parceargs
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#pragma once
+#ifndef __CMDLNOPTS_H__
+#define __CMDLNOPTS_H__
+
+#include "parceargs.h"
+
+/*
+ * here are some typedef's for global data
+ */
+// parameters of mirror
+typedef struct{
+	double D;     // diameter
+	double F;     // focus
+	double Zincl; // inclination from Z axe (radians)
+	double Aincl; // azimuth of inclination (radians)
+} mirPar;
+
+typedef struct{
+	int **S_dev;	// size of initial array of surface deviations
+	int S_interp;	// size of interpolated S0
+	int S_image;	// resulting image size
+	int N_phot;		// amount of photons falled to one pixel of S1 by one iteration
+	int randMask;	// add to mask random numbers
+	double **randAmp;// amplitude of added random noice
+	mirPar *Mirror;	// mirror parameters
+	int rest_pars_num;// number of rest parameters
+	char** rest_pars;// the rest parameters: array of char*
+	char **str;		// string parameters
+	char **filter;	// some filter options
+} glob_pars;
+
+
+// default & global parameters
+extern glob_pars const Gdefault;
+extern mirPar const Mdefault;
+extern int rewrite_ifexists, verbose;
+
+glob_pars *parce_args(int argc, char **argv);
+
+#endif // __CMDLNOPTS_H__

getopt/cmdlnopts/main.c

@@ -0,0 +1,107 @@
+/*
+ * main.c
+ *
+ * Copyright 2015 Edward V. Emelianov <eddy@sao.ru, edward.emelianoff@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include <stdio.h>
+#include "cmdlnopts.h"
+
+typedef struct{
+	char *filtertype;
+	int xsize;
+	int ysize;
+} filterpars;
+
+
+void parce_filter(char *pars){
+	filterpars params = { 0, 3, 3};
+	mysuboption filteropts[] = {
+		{"type", NEED_ARG, arg_string, &params.filtertype},
+		{"xsz",  NEED_ARG, arg_int, &params.xsize},
+		{"ysz",  NEED_ARG, arg_int, &params.ysize},
+		end_suboption
+	};
+	if(!get_suboption(pars, filteropts)){
+		printf("\tbad params\n");
+	}else{
+		printf("\tfiltertype = %s, sizes: %dx%d\n", params.filtertype, params.xsize, params.ysize);
+	}
+}
+
+int main(int argc, char **argv){
+	glob_pars *G = NULL; // default parameters see in cmdlnopts.c
+	mirPar *M = NULL;    // default mirror parameters
+	G = parce_args(argc, argv);
+	M = G->Mirror;
+	printf("Globals:\n");
+	if(!G->S_dev){
+		printf("S_dev = 8 (default)\n");
+	}else{
+		int i = 0, **vals = G->S_dev;
+		while(*vals){
+			printf("S_dev[%d]: %d\n", i++, **vals++);
+		}
+	}
+	if(!G->randAmp){
+		printf("randAmp = 1e-8 (default)\n");
+	}else{
+		int i = 0;
+		double **a = G->randAmp;
+		while(*a){
+			printf("randAmp[%d]: %g\n", i++, **a++);
+		}
+	}
+	if(G->str){
+		printf("meet str args:\n");
+		int i = 0;
+		char **strs = G->str;
+		if(!*strs) printf("fucn!\n");
+		while(*strs)
+			printf("str[%d] = %s\n", i++, *strs++);
+	}
+	printf("S_interp = %d\n", G->S_interp);
+	printf("S_image = %d\n", G->S_image);
+	printf("N_phot = %d\n", G->N_phot);
+	printf("randMask = %d\n", G->randMask);
+	printf("Mirror =\n");
+	printf("\tD = %g\n", M->D);
+	printf("\tF = %g\n", M->F);
+	printf("\tZincl = %g\n", M->Zincl);
+	printf("\tAincl = %g\n", M->Aincl);
+	printf("rewrite_ifexists = %d\n", rewrite_ifexists);
+	printf("verbose = %d\n", verbose);
+	if(G->rest_pars_num){
+		int i;
+		printf("There's also %d free parameters:\n", G->rest_pars_num);
+		for(i = 0; i < G->rest_pars_num; ++i)
+			printf("\t%4d: %s\n", i, G->rest_pars[i]);
+	}
+	if(G->filter){
+		printf("filter parameters:\n");
+		char **fpars = G->filter;
+		int i = 0;
+		while(*fpars){
+			printf("%d:\n", i++);
+			parce_filter(*fpars);
+			++fpars;
+		}
+	}
+	return 0;
+}
+

getopt/cmdlnopts/parceargs.c

@@ -0,0 +1,434 @@
+/*
+ * parceargs.c - parcing command line arguments & print help
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include <stdio.h>	// printf
+#include <getopt.h>	// getopt_long
+#include <stdlib.h>	// calloc, exit, strtoll
+#include <assert.h>	// assert
+#include <string.h> // strdup, strchr, strlen
+#include <strings.h>// strcasecmp
+#include <limits.h> // INT_MAX & so on
+#include <libintl.h>// gettext
+#include <ctype.h>	// isalpha
+#include "parceargs.h"
+
+// macro to print help messages
+#ifndef PRNT
+	#define PRNT(x) gettext(x)
+#endif
+
+char *helpstring = "%s\n";
+
+/**
+ * Change standard help header
+ * MAY consist ONE "%s" for progname
+ * @param str (i) - new format
+ */
+void change_helpstring(char *s){
+	int pcount = 0, scount = 0;
+	char *str = s;
+	// check `helpstring` and set it to default in case of error
+	for(; pcount < 2; str += 2){
+		if(!(str = strchr(str, '%'))) break;
+		if(str[1] != '%') pcount++; // increment '%' counter if it isn't "%%"
+		else{
+			str += 2; // pass next '%'
+			continue;
+		}
+		if(str[1] == 's') scount++; // increment "%s" counter
+	};
+	if(pcount > 1 || pcount != scount){ // amount of pcount and/or scount wrong
+		fprintf(stderr, "Wrong helpstring!\n");
+		exit(-1);
+	}
+	helpstring = s;
+}
+
+/**
+ * Carefull atoll/atoi
+ * @param num (o) - returning value (or NULL if you wish only check number) - allocated by user
+ * @param str (i) - string with number must not be NULL
+ * @param t   (i) - T_INT for integer or T_LLONG for long long (if argtype would be wided, may add more)
+ * @return TRUE if conversion sone without errors, FALSE otherwise
+ */
+static bool myatoll(void *num, char *str, argtype t){
+	long long tmp, *llptr;
+	int *iptr;
+	char *endptr;
+	assert(str);
+	assert(num);
+	tmp = strtoll(str, &endptr, 0);
+	if(endptr == str || *str == '\0' || *endptr != '\0')
+		return FALSE;
+	switch(t){
+		case arg_longlong:
+			llptr = (long long*) num;
+			*llptr = tmp;
+		break;
+		case arg_int:
+		default:
+			if(tmp < INT_MIN || tmp > INT_MAX){
+				fprintf(stderr, "Integer out of range\n");
+				return FALSE;
+			}
+			iptr = (int*)num;
+			*iptr = (int)tmp;
+	}
+	return TRUE;
+}
+
+// the same as myatoll but for double
+// There's no NAN & INF checking here (what if they would be needed?)
+static bool myatod(void *num, const char *str, argtype t){
+	double tmp, *dptr;
+	float *fptr;
+	char *endptr;
+	assert(str);
+	tmp = strtod(str, &endptr);
+	if(endptr == str || *str == '\0' || *endptr != '\0')
+		return FALSE;
+	switch(t){
+		case arg_double:
+			dptr = (double *) num;
+			*dptr = tmp;
+		break;
+		case arg_float:
+		default:
+			fptr = (float *) num;
+			*fptr = (float)tmp;
+		break;
+	}
+	return TRUE;
+}
+
+/**
+ * Get index of current option in array options
+ * @param opt (i) - returning val of getopt_long
+ * @param options (i) - array of options
+ * @return index in array
+ */
+static int get_optind(int opt, myoption *options){
+	int oind;
+	myoption *opts = options;
+	assert(opts);
+	for(oind = 0; opts->name && opts->val != opt; oind++, opts++);
+	if(!opts->name || opts->val != opt) // no such parameter
+	showhelp(-1, options);
+	return oind;
+}
+
+/**
+ * reallocate new value in array of multiple repeating arguments
+ * @arg paptr - address of pointer to array (**void)
+ * @arg type - its type (for realloc)
+ * @return pointer to new (next) value
+ */
+void *get_aptr(void *paptr, argtype type){
+	int i = 1;
+	void **aptr = *((void***)paptr);
+	if(aptr){ // there's something in array
+		void **p = aptr;
+		while(*p++) ++i;
+	}
+	size_t sz;
+	switch(type){
+		default:
+		case arg_none:
+			fprintf(stderr, "Can't use multiple args with arg_none!\n");
+			exit(-1);
+		break;
+		case arg_int:
+			sz = sizeof(int);
+		break;
+		case arg_longlong:
+			sz = sizeof(long long);
+		break;
+		case arg_double:
+			sz = sizeof(double);
+		break;
+		case arg_float:
+			sz = sizeof(float);
+		break;
+		case arg_string:
+			sz = 0;
+		break;
+	/*	case arg_function:
+			sz = sizeof(argfn *);
+		break;*/
+	}
+	aptr = realloc(aptr, (i + 1) * sizeof(void*));
+	*((void***)paptr) = aptr;
+	aptr[i] = NULL;
+	if(sz){
+		aptr[i - 1] = malloc(sz);
+	}else
+		aptr[i - 1] = &aptr[i - 1];
+	return aptr[i - 1];
+}
+
+
+/**
+ * Parce command line arguments
+ * ! If arg is string, then value will be strdup'ed!
+ *
+ * @param argc (io) - address of argc of main(), return value of argc stay after `getopt`
+ * @param argv (io) - address of argv of main(), return pointer to argv stay after `getopt`
+ * BE CAREFUL! if you wanna use full argc & argv, save their original values before
+ * 		calling this function
+ * @param options (i) - array of `myoption` for arguments parcing
+ *
+ * @exit: in case of error this function show help & make `exit(-1)`
+  */
+void parceargs(int *argc, char ***argv, myoption *options){
+	char *short_options, *soptr;
+	struct option *long_options, *loptr;
+	size_t optsize, i;
+	myoption *opts = options;
+	// check whether there is at least one options
+	assert(opts);
+	assert(opts[0].name);
+	// first we count how much values are in opts
+	for(optsize = 0; opts->name; optsize++, opts++);
+	// now we can allocate memory
+	short_options = calloc(optsize * 3 + 1, 1); // multiply by three for '::' in case of args in opts
+	long_options = calloc(optsize + 1, sizeof(struct option));
+	opts = options; loptr = long_options; soptr = short_options;
+	// fill short/long parameters and make a simple checking
+	for(i = 0; i < optsize; i++, loptr++, opts++){
+		// check
+		assert(opts->name); // check name
+		if(opts->has_arg){
+			assert(opts->type != arg_none); // check error with arg type
+			assert(opts->argptr);  // check pointer
+		}
+		if(opts->type != arg_none) // if there is a flag without arg, check its pointer
+			assert(opts->argptr);
+		// fill long_options
+		// don't do memcmp: what if there would be different alignment?
+		loptr->name		= opts->name;
+		loptr->has_arg	= (opts->has_arg < MULT_PAR) ? opts->has_arg : 1;
+		loptr->flag		= opts->flag;
+		loptr->val		= opts->val;
+		// fill short options if they are:
+		if(!opts->flag){
+			*soptr++ = opts->val;
+			if(loptr->has_arg) // add ':' if option has required argument
+				*soptr++ = ':';
+			if(loptr->has_arg == 2) // add '::' if option has optional argument
+				*soptr++ = ':';
+		}
+	}
+	// now we have both long_options & short_options and can parse `getopt_long`
+	while(1){
+		int opt;
+		int oindex = 0, optind = 0; // oindex - number of option in argv, optind - number in options[]
+		if((opt = getopt_long(*argc, *argv, short_options, long_options, &oindex)) == -1) break;
+		if(opt == '?'){
+			opt = optopt;
+			optind = get_optind(opt, options);
+			if(options[optind].has_arg == NEED_ARG || options[optind].has_arg == MULT_PAR)
+				showhelp(optind, options); // need argument
+		}
+		else{
+			if(opt == 0 || oindex > 0) optind = oindex;
+			else optind = get_optind(opt, options);
+		}
+		opts = &options[optind];
+		if(opt == 0 && opts->has_arg == NO_ARGS) continue; // only long option changing integer flag
+		// now check option
+		if(opts->has_arg == NEED_ARG || opts->has_arg == MULT_PAR)
+			if(!optarg) showhelp(optind, options); // need argument
+		void *aptr;
+		if(opts->has_arg == MULT_PAR){
+			aptr = get_aptr(opts->argptr, opts->type);
+		}else
+			aptr = opts->argptr;
+		bool result = TRUE;
+		// even if there is no argument, but argptr != NULL, think that optarg = "1"
+		if(!optarg) optarg = "1";
+		switch(opts->type){
+			default:
+			case arg_none:
+				if(opts->argptr) *((int*)aptr) += 1; // increment value
+			break;
+			case arg_int:
+				result = myatoll(aptr, optarg, arg_int);
+			break;
+			case arg_longlong:
+				result = myatoll(aptr, optarg, arg_longlong);
+			break;
+			case arg_double:
+				result = myatod(aptr, optarg, arg_double);
+			break;
+			case arg_float:
+				result = myatod(aptr, optarg, arg_float);
+			break;
+			case arg_string:
+				result = (*((void**)aptr) = (void*)strdup(optarg));
+			break;
+			case arg_function:
+				result = ((argfn)aptr)(optarg);
+			break;
+		}
+		if(!result){
+			showhelp(optind, options);
+		}
+	}
+	*argc -= optind;
+	*argv += optind;
+}
+
+/**
+ * Show help information based on myoption->help values
+ * @param oindex (i)  - if non-negative, show only help by myoption[oindex].help
+ * @param options (i) - array of `myoption`
+ *
+ * @exit:  run `exit(-1)` !!!
+ */
+void showhelp(int oindex, myoption *options){
+	// ATTENTION: string `help` prints through macro PRNT(), bu default it is gettext,
+	// but you can redefine it before `#include "parceargs.h"`
+	int max_opt_len = 0; // max len of options substring - for right indentation
+	const int bufsz = 255;
+	char buf[bufsz+1];
+	myoption *opts = options;
+	assert(opts);
+	assert(opts[0].name); // check whether there is at least one options
+	if(oindex > -1){ // print only one message
+		opts = &options[oindex];
+		printf("  ");
+		if(!opts->flag && isalpha(opts->val)) printf("-%c, ", opts->val);
+		printf("--%s", opts->name);
+		if(opts->has_arg == 1) printf("=arg");
+		else if(opts->has_arg == 2) printf("[=arg]");
+		printf("  %s\n", PRNT(opts->help));
+		exit(-1);
+	}
+	// header, by default is just "progname\n"
+	printf("\n");
+	if(strstr(helpstring, "%s")) // print progname
+		printf(helpstring, __progname);
+	else // only text
+		printf("%s", helpstring);
+	printf("\n");
+	// count max_opt_len
+	do{
+		int L = strlen(opts->name);
+		if(max_opt_len < L) max_opt_len = L;
+	}while((++opts)->name);
+	max_opt_len += 14; // format: '-S , --long[=arg]' - get addition 13 symbols
+	opts = options;
+	// Now print all help
+	do{
+		int p = sprintf(buf, "  "); // a little indent
+		if(!opts->flag && isalpha(opts->val)) // .val is short argument
+			p += snprintf(buf+p, bufsz-p, "-%c, ", opts->val);
+		p += snprintf(buf+p, bufsz-p, "--%s", opts->name);
+		if(opts->has_arg == 1) // required argument
+			p += snprintf(buf+p, bufsz-p, "=arg");
+		else if(opts->has_arg == 2) // optional argument
+			p += snprintf(buf+p, bufsz-p, "[=arg]");
+		assert(p < max_opt_len); // there would be magic if p >= max_opt_len
+		printf("%-*s%s\n", max_opt_len+1, buf, PRNT(opts->help)); // write options & at least 2 spaces after
+	}while((++opts)->name);
+	printf("\n\n");
+	exit(-1);
+}
+
+/**
+ * get suboptions from parameter string
+ * @param str - parameter string
+ * @param opt - pointer to suboptions structure
+ * @return TRUE if all OK
+ */
+bool get_suboption(char *str, mysuboption *opt){
+	int findsubopt(char *par, mysuboption *so){
+		int idx = 0;
+		while(so[idx].name){
+			if(strcasecmp(par, so[idx].name) == 0) return idx;
+			++idx;
+		}
+		return -1; // badarg
+	}
+	bool opt_setarg(mysuboption *so, int idx, char *val){
+		mysuboption *soptr = &so[idx];
+		bool result = FALSE;
+		void *aptr = soptr->argptr;
+		switch(soptr->type){
+			default:
+			case arg_none:
+				if(soptr->argptr) *((int*)aptr) += 1; // increment value
+			break;
+			case arg_int:
+				result = myatoll(aptr, val, arg_int);
+			break;
+			case arg_longlong:
+				result = myatoll(aptr, val, arg_longlong);
+			break;
+			case arg_double:
+				result = myatod(aptr, val, arg_double);
+			break;
+			case arg_float:
+				result = myatod(aptr, val, arg_float);
+			break;
+			case arg_string:
+				result = (*((void**)aptr) = (void*)strdup(val));
+			break;
+			case arg_function:
+				result = ((argfn)aptr)(val);
+			break;
+		}
+		return result;
+	}
+	char *tok, *val;
+	bool ret = FALSE;
+	char *tmpbuf;
+	tok = strtok_r(str, ":,", &tmpbuf);
+	do{
+		val = strchr(tok, '=');
+		int noarg = 0;
+		if(val == NULL){ // no args
+			val = "1";
+			noarg = 1;
+		}else{
+			*val++ = '\0';
+			if(!*val || *val == ':' || *val == ','){ // no argument - delimeter after =
+				val = "1"; noarg = 1;
+			}
+		}
+		int idx = findsubopt(tok, opt);
+		if(idx < 0){
+			printf("Wrong parameter: %s", tok);
+			goto returning;
+		}
+		if(noarg && opt[idx].has_arg == NEED_ARG){
+			printf("%s: argument needed!\n", tok);
+			goto returning;
+		}
+		if(!opt_setarg(opt, idx, val)){
+			printf("Wrong argument \"%s\" of parameter \"%s\"\n", val, tok);
+			goto returning;
+		}
+	}while((tok = strtok_r(NULL, ":,", &tmpbuf)));
+	ret = TRUE;
+returning:
+	return ret;
+}

getopt/cmdlnopts/parceargs.h

@@ -0,0 +1,124 @@
+/*
+ * parceargs.h - headers for parcing command line arguments
+ *
+ * Copyright 2013 Edward V. Emelianoff <eddy@sao.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#pragma once
+#ifndef __PARCEARGS_H__
+#define __PARCEARGS_H__
+
+#include <stdbool.h>// bool
+#include <stdlib.h>
+
+#ifndef TRUE
+	#define TRUE true
+#endif
+
+#ifndef FALSE
+	#define FALSE false
+#endif
+
+// macro for argptr
+#define APTR(x)   ((void*)x)
+
+// if argptr is a function:
+typedef  bool(*argfn)(void *arg);
+
+/*
+ * type of getopt's argument
+ * WARNING!
+ * My function change value of flags by pointer, so if you want to use another type
+ * make a latter conversion, example:
+ * 		char charg;
+ * 		int iarg;
+ * 		myoption opts[] = {
+ * 		{"value", 1, NULL, 'v', arg_int, &iarg, "char val"}, ..., end_option};
+ * 		..(parce args)..
+ * 		charg = (char) iarg;
+ */
+typedef enum {
+	arg_none = 0,	// no arg
+	arg_int,		// integer
+	arg_longlong,	// long long
+	arg_double,		// double
+	arg_float,		// float
+	arg_string,		// char *
+	arg_function	// parce_args will run function `bool (*fn)(char *optarg, int N)`
+} argtype;
+
+/*
+ * Structure for getopt_long & help
+ * BE CAREFUL: .argptr is pointer to data or pointer to function,
+ * 		conversion depends on .type
+ *
+ * ATTENTION: string `help` prints through macro PRNT(), bu default it is gettext,
+ * but you can redefine it before `#include "parceargs.h"`
+ *
+ * if arg is string, then value wil be strdup'ed like that:
+ * 		char *str;
+ * 		myoption opts[] = {{"string", 1, NULL, 's', arg_string, &str, "string val"}, ..., end_option};
+ *		*(opts[1].str) = strdup(optarg);
+ * in other cases argptr should be address of some variable (or pointer to allocated memory)
+ *
+ * NON-NULL argptr should be written inside macro APTR(argptr) or directly: (void*)argptr
+ *
+ * !!!LAST VALUE OF ARRAY SHOULD BE `end_option` or ZEROS !!!
+ *
+ */
+typedef enum{
+	NO_ARGS  = 0,  // first three are the same as in getopt_long
+	NEED_ARG = 1,
+	OPT_ARG  = 2,
+	MULT_PAR
+} hasarg;
+
+typedef struct{
+	// these are from struct option:
+	const char *name;		// long option's name
+	hasarg      has_arg;	// 0 - no args, 1 - nesessary arg, 2 - optionally arg, 4 - need arg & key can repeat (args are stored in null-terminated array)
+	int        *flag;		// NULL to return val, pointer to int - to set its value of val (function returns 0)
+	int         val;		// short opt name (if flag == NULL) or flag's value
+	// and these are mine:
+	argtype     type;		// type of argument
+	void       *argptr;		// pointer to variable to assign optarg value or function `bool (*fn)(char *optarg, int N)`
+	const char *help;		// help string which would be shown in function `showhelp` or NULL
+} myoption;
+
+/*
+ * Suboptions structure, almost the same like myoption
+ * used in parce_subopts()
+ */
+typedef struct{
+	const char *name;
+	hasarg      has_arg;
+	argtype     type;
+	void       *argptr;
+} mysuboption;
+
+// last string of array (all zeros)
+#define end_option {0,0,0,0,0,0,0}
+#define end_suboption {0,0,0,0}
+
+extern const char *__progname;
+
+void showhelp(int oindex, myoption *options);
+void parceargs(int *argc, char ***argv, myoption *options);
+void change_helpstring(char *s);
+bool get_suboption(char *str, mysuboption *opt);
+
+#endif // __PARCEARGS_H__