first commit

getopt/README

@@ -0,0 +1,9 @@
+1. Functions for simplify control of complex parameters
+cmdlnopts.c - example of use
+parceargs.c - main functions
+parceargs.h - their header
+
+2. Functions for regular getopt_long
+getopt.c  - snippet file
+getopt.h  - its header
+

getopt/cmdlnopts.c

@@ -0,0 +1,123 @@
+/*
+ * 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 "cmdlnopts.h"
+
+/*
+ * here are global parameters initialisation
+ */
+
+/*
+ * Define command line options by filling structure:
+ *	name	has_arg	flag	val		type		argptr			help
+*/
+myoption cmdlnopts[] = {
+	{"help",	0,	NULL,	'h',	arg_int,	APTR(&help),		N_("show this help")},
+	// ...
+	end_option
+};
+
+
+/**
+ * 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_suboptions(void *arg, suboptions *V){
+	char *tok, *val, *par;
+	int i;
+	tok = strtok(arg, ":,");
+	do{
+		if((val = strchr(tok, '=')) == NULL){ // wrong format
+			WARNX(_("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;
+					DBG("Angle: %g rad\n", *(V[i].val));
+				}else{ // simple float
+					if(!myatof(V[i].val, val)) // wrong number
+						return FALSE;
+					DBG("Float val: %g\n", *(V[i].val));
+				}
+				break;
+			}
+		}
+		if(!V[i].val){ // nothing found - wrong format
+			WARNX(_("Bad keyword!"));
+			return FALSE;
+		}
+	}while((tok = strtok(NULL, ":,")));
+	return TRUE;
+}
+
+/**
+ * functions of subargs parcing can looks as this
+ */
+bool get_mir_par(void *arg, int N _U_){
+	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},
+		{&M.objA,	"aobj",		TRUE},
+		{&M.objZ,	"zobj",		TRUE},
+		{&M.foc,	"ccd",		FALSE},
+		{0,0,0}
+	};
+	return get_suboptions(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){
+		printf("\nIgnore argument[s]:\n");
+		for (i = 0; i < argc; i++)
+			printf("\t%s\n", argv[i]);
+	}
+	return &G;
+}
+

getopt/cmdlnopts.h

@@ -0,0 +1,36 @@
+/*
+ * 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
+ */
+
+typedef SomeType glob_pars;
+
+glob_pars *parce_args(int argc, char **argv);
+
+#endif // __CMDLNOPTS_H__

getopt/getopt.c

@@ -0,0 +1,128 @@
+/*
+ * getopt.c - simple functions for getopt_long
+ * provide functions
+ * 		usage      - to show help message & exit
+ *		parse_args - to parce argv & fill global flags
+ *
+ * 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 <getopt.h>
+#include <stdarg.h>
+
+
+/*
+ * here are global variables and global data structures initialisation, like
+ * int val = 10; // default value
+ */
+
+/*
+ * HERE A PART of main.c:
+ *
+	setlocale(LC_ALL, "");
+	setlocale(LC_NUMERIC, "C");
+	bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
+	textdomain(GETTEXT_PACKAGE);
+	parse_args(argc, argv); // <- set all flags
+ *
+ * ITS HEADER:
+#ifndef GETTEXT_PACKAGE // should be defined by make
+#define GETTEXT_PACKAGE "progname"
+#endif
+#ifndef LOCALEDIR // should be defined by make
+#define LOCALEDIR "/path/to/locale"
+#endif
+ */
+
+void usage(char *fmt, ...){
+	va_list ap;
+	va_start(ap, fmt);
+	printf("\n");
+	if (fmt != NULL){
+		vprintf(fmt, ap);
+		printf("\n\n");
+	}
+	va_end(ap);
+	// "éÓÐÏÌØÚÏ×ÁÎÉÅ:\t%s [ÏÐÃÉÉ] [ÐÒÅÆÉËÓ ×ÙÈÏÄÎÙÈ ÆÁÊÌÏ×]\n"
+	printf(_("Usage:\t%s [options] [output files prefix]\n"),
+		__progname);
+	// "\tïÐÃÉÉ:\n"
+	printf(_("\tOptions:\n"));
+	printf("\t-A,\t--author=author\t\t%s\n",
+		// "Á×ÔÏÒ ÐÒÏÇÒÁÍÍÙ"
+		_("program author"));
+	// and so on
+	exit(1);
+}
+
+void parse_args(int argc, char **argv){
+	int i;
+	char short_options[] = "A"; // all short equivalents
+	struct option long_options[] = {
+/*		{ name, has_arg, flag, val }, where:
+ * name - name of long parameter
+ * has_arg = 0 - no argument, 1 - need argument, 2 - unnesessary argument
+ * flag = NULL to return val, pointer to int - to set it
+ * 		value of val (function returns 0)
+ * val -  getopt_long return value or value, flag setting to
+ * !!! last string - for zeros !!!
+ */
+		{"author",		1,	0,	'A'},
+		// and so on
+		{ 0, 0, 0, 0 }
+	};
+	if(argc == 1){
+		// "îÅ ××ÅÄÅÎÏ ÎÉËÁËÉÈ ÐÁÒÁÍÅÔÒÏ×"
+		usage(_("Any parameters are absent"));
+	}
+	while(1){
+		int opt;
+		if((opt = getopt_long(argc, argv, short_options,
+			long_options, NULL)) == -1) break;
+		switch(opt){
+		case 0: // only long option
+			// do something?
+		break;
+		case 'A':
+			author = strdup(optarg);
+			// "á×ÔÏÒ ÐÒÏÇÒÁÍÍÙ: %s"
+			//info(_("Program author: %s"), author);
+			break;
+		// ...
+		default:
+		usage(NULL);
+		}
+	}
+	argc -= optind;
+	argv += optind;
+	if(argc == 0){
+		// there's no free parameters
+	}else{
+		/* there was free parameter
+		 * for example, filename
+		outfile = argv[0];
+		argc--;
+		argv++;
+		*/
+	}
+	if(argc > 0){
+		// "éÇÎÏÒÉÒÕÀ ÁÒÇÕÍÅÎÔ[Ù]:\n"
+		printf(_("Ignore argument[s]:\n"));
+		for (i = 0; i < argc; i++)
+			warnx("%s ", argv[i]);
+	}
+}

getopt/getopt.h

@@ -0,0 +1,18 @@
+#ifndef __USAGE_H__
+#define __USAGE_H__
+
+#include "takepic.h"
+#include <getopt.h>
+#include <stdarg.h>
+
+/*
+ * here are global variables and global data structures definition, like
+ * int val;
+ * enum{reset = 0, set};
+ */
+
+extern char *__progname;
+void usage(char *fmt, ...);
+void parse_args(int argc, char **argv);
+
+#endif // __USAGE_H__

getopt/parceargs.c

@@ -0,0 +1,316 @@
+/*
+ * 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>	// DBG
+#include <getopt.h>	// getopt_long
+#include <stdlib.h>	// calloc, exit, strtoll
+#include <assert.h>	// assert
+#include <string.h> // strdup, strchr, strlen
+#include <limits.h> // INT_MAX & so on
+#include <libintl.h>// gettext
+#include <ctype.h>	// isalpha
+#include "parceargs.h"
+
+#ifdef EBUG
+	#define DBG(...) printf(__VA_ARGS__)
+#else
+	#define DBG(...)
+#endif
+
+// 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
+	};
+	DBG("pc: %d, sc: %d\n", pcount, scount);
+	if(pcount > 1 || pcount != scount){ // amount of pcount and/or scount wrong
+		fprintf(stderr, "Wrong helpstring!\n");
+		exit(-1);
+	}
+	helpstring = s;
+	DBG("hs: %s\n", helpstring);
+}
+
+/**
+ * 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
+ */
+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?)
+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
+ */
+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;
+}
+
+/**
+ * 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;
+		loptr->flag		= opts->flag;
+		loptr->val		= opts->val;
+		// fill short options if they are:
+		if(!opts->flag){
+			*soptr++ = opts->val;
+			if(opts->has_arg) // add ':' if option has required argument
+				*soptr++ = ':';
+			if(opts->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 == 1) showhelp(optind, options); // need argument
+		}
+		else{
+			if(opt == 0 || oindex > 0) optind = oindex;
+			else optind = get_optind(opt, options);
+		}
+		opts = &options[optind];
+DBG ("\n*******\noption %s (oindex = %d / optind = %d)", options[optind].name, oindex, optind);
+if(optarg) DBG (" with arg %s", optarg);
+DBG ("\n");
+		if(opt == 0 && opts->has_arg == 0) continue; // only long option changing integer flag
+DBG("opt = %c, arg type: ", opt);
+		// now check option
+		if(opts->has_arg == 1) assert(optarg);
+		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:
+DBG("none\n");
+				if(opts->argptr) *((int*)opts->argptr) = 1; // set argptr to 1
+			break;
+			case arg_int:
+DBG("integer\n");
+				result = myatoll(opts->argptr, optarg, arg_int);
+			break;
+			case arg_longlong:
+DBG("long long\n");
+				result = myatoll(opts->argptr, optarg, arg_longlong);
+			break;
+			case arg_double:
+DBG("double\n");
+				result = myatod(opts->argptr, optarg, arg_double);
+			break;
+			case arg_float:
+DBG("double\n");
+				result = myatod(opts->argptr, optarg, arg_float);
+			break;
+			case arg_string:
+DBG("string\n");
+				result = (*((char **)opts->argptr) = strdup(optarg));
+			break;
+			case arg_function:
+DBG("function\n");
+				result = ((argfn)opts->argptr)(optarg, optind);
+			break;
+		}
+		if(!result){
+DBG("OOOPS! Error in result\n");
+			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);
+}

getopt/parceargs.h

@@ -0,0 +1,105 @@
+/*
+ * 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, int N);
+
+/*
+ * 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 struct{
+	// these are from struct option:
+	const char *name;		// long option's name
+	int         has_arg;	// 0 - no args, 1 - nesessary arg, 2 - optionally arg
+	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)`
+	char       *help;		// help string which would be shown in function `showhelp` or NULL
+} myoption;
+
+// last string of array (all zeros)
+#define end_option {0,0,0,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);
+
+#endif // __PARCEARGS_H__