diff --git a/ase/include/ase/utl/getopt.h b/ase/include/ase/utl/getopt.h
index 77e465eb..748ef234 100644
--- a/ase/include/ase/utl/getopt.h
+++ b/ase/include/ase/utl/getopt.h
@@ -1,5 +1,5 @@
 /*
- * $Id: getopt.h 284 2008-07-22 14:22:24Z baconevi $
+ * $Id: getopt.h 285 2008-07-23 03:59:57Z baconevi $
  *
  * {License}
  */
@@ -24,7 +24,7 @@ struct ase_opt_t
 {
 	/* input */
 	const ase_char_t* str;
-	ase_opt_long_t* opt_long;
+//	ase_opt_long_t* opt_long;
 
 	/* output */
 	ase_cint_t opt;  /* character checked for validity */
diff --git a/ase/lib/utl/getopt.c b/ase/lib/utl/getopt.c
index c06cde15..8551766f 100644
--- a/ase/lib/utl/getopt.c
+++ b/ase/lib/utl/getopt.c
@@ -1,5 +1,5 @@
 /*
- * $Id: getopt.c 284 2008-07-22 14:22:24Z baconevi $
+ * $Id: getopt.c 285 2008-07-23 03:59:57Z baconevi $
  * 
  * {License}
  */
@@ -49,83 +49,191 @@
 #define BADARG  ASE_T(':')
 #define EMSG    ASE_T("")
 
-#define optstr   opt->str
-#define optarg   opt->arg
-#define optind   opt->ind
-#define optopt   opt->opt
-#define place    opt->cur
-
+#if 0
 ase_cint_t ase_getopt (int argc, ase_char_t* const* argv, ase_opt_t* opt)
 {
 	ase_char_t* oli; /* option letter list index */
 
-	if (place == ASE_NULL) 
+	if (opt->cur == ASE_NULL) 
 	{
-		place = EMSG;
-		optind = 1;
+		opt->cur = EMSG;
+		opt->ind = 1;
 	}
 
-	if (*place == ASE_T('\0')) 
+	if (*opt->cur == ASE_T('\0')) 
 	{              
 		/* update scanning pointer */
-		if (optind >= argc || *(place = argv[optind]) != ASE_T('-')) 
+		if (opt->ind >= argc || *(opt->cur = argv[opt->ind]) != ASE_T('-')) 
 		{
-			place = EMSG;
+			opt->cur = EMSG;
 			return ASE_CHAR_EOF;
 		}
 
-		if (place[1] != ASE_T('\0') && *++place == ASE_T('-'))
+		if (opt->cur[1] != ASE_T('\0') && *++opt->cur == ASE_T('-'))
 		{      
 			/* found "--" */
-			++optind;
-			place = EMSG;
+			++opt->ind;
+			opt->cur = EMSG;
 			return ASE_CHAR_EOF;
 		}
 	}   /* option letter okay? */
 
-	if ((optopt = *place++) == ASE_T(':') ||
-	    (oli = ase_strchr(optstr, optopt)) == ASE_NULL) 
+	if ((opt->opt = *opt->cur++) == ASE_T(':') ||
+	    (oli = ase_strchr(opt->str, opt->opt)) == ASE_NULL) 
 	{
 		/*
 		 * if the user didn't specify '-' as an option,
 		 * assume it means EOF.
 		 */
-		if (optopt == (int)'-') return ASE_CHAR_EOF;
-		if (*place == ASE_T('\0')) ++optind;
+		if (opt->opt == (int)'-') return ASE_CHAR_EOF;
+		if (*opt->cur == ASE_T('\0')) ++opt->ind;
 		return BADCH;
 	}
 
 	if (*++oli != ASE_T(':')) 
 	{
 		/* don't need argument */
-		optarg = ASE_NULL;
-		if (*place == ASE_T('\0')) ++optind;
+		opt->arg = ASE_NULL;
+		if (*opt->cur == ASE_T('\0')) ++opt->ind;
 	}
 	else 
 	{                                  
 		/* need an argument */
 
-		if (*place != ASE_T('\0')) 
+		if (*opt->cur != ASE_T('\0')) 
 		{
 			/* no white space */
-			optarg = place;
+			opt->arg = opt->cur;
 		}
-		else if (argc <= ++optind) 
+		else if (argc <= ++opt->ind) 
 		{
 			/* no arg */
-			place = EMSG;
-			/*if (*optstr == ASE_T(':'))*/ return BADARG;
+			opt->cur = EMSG;
+			/*if (*opt->str == ASE_T(':'))*/ return BADARG;
 			/*return BADCH;*/
 		}
 		else
 		{                            
 			/* white space */
-			optarg = argv[optind];
+			opt->arg = argv[opt->ind];
 		}
 
-		place = EMSG;
-		++optind;
+		opt->cur = EMSG;
+		++opt->ind;
 	}
 
-	return optopt;  /* dump back option letter */
+	return opt->opt;  /* dump back option letter */
 }
+#endif
+
+/* Code based on Unununium project (http://unununium.org/) */
+
+ase_cint_t ase_getopt_long (int argc, ase_char_t* const* argv, ase_opt_t* opt)
+{
+	static int lastidx,lastofs;
+	ase_char_t* tmp;
+
+	if (opt->ind == 0) opt->ind = 1;
+
+again:
+	if (opt->ind > argc || !argv[opt->ind] ||
+	    *argv[opt->ind] != ASE_T('-') || argv[opt->ind][1] == AES_T('\0')) return -1;
+
+	if (argv[opt->ind][1] == ASE_T('-') && argv[opt->ind][2]==ASE_T('\0')) 
+	{
+		++opt->ind;
+		return -1;
+	}
+
+	if (argv[opt->ind][1] == ASE_T('-')) 
+	{	
+		ase_char_t* arg = argv[opt->ind] + 2;
+		const struct option* o;
+
+		/* TODO: rewrite it.. */
+		char* max=strchr(arg,'=');
+		if (max == ASE_NULL) max = arg + strlen(arg);
+
+		for (o=longopts; o->name; ++o) 
+		{
+			if (!strncmp (o->name, arg, max - arg)) 
+			{
+				/* match */
+				if (longindex) *longindex=o-longopts;
+				if (o->has_arg>0) 
+				{
+					if (*max == '=') opt->arg=max+1;
+					else 
+					{
+						opt->arg=argv[opt->ind+1];
+						if (!opt->arg && o->has_arg==1) 
+						{	/* no argument there */
+							if (*optstring==':') return ':';
+							write(2,"argument required: `",20);
+							write(2,arg,(size_t)(max-arg));
+							write(2,"'.\n",3);
+							++opt->ind;
+							return '?';
+						}
+						++opt->ind;
+					}
+				}
+				++opt->ind;
+				if (o->flag)
+					*(o->flag)=o->val;
+				else
+					return o->val;
+				return 0;
+			}
+		}
+
+		if (*optstring==':') return ':';
+		write(2,"invalid option `",16);
+		write(2,arg,(size_t)(max-arg));
+		write(2,"'.\n",3);
+		++opt->ind;
+		return '?';
+	}
+	if (lastidx!=opt->ind) {
+		lastidx=opt->ind; lastofs=0;
+	}
+
+	optopt=argv[opt->ind][lastofs+1];
+	if ((tmp=strchr(optstring,optopt))) {
+		if (*tmp==0) 
+		{	/* apparently, we looked for \0, i.e. end of argument */
+			++opt->ind;
+			goto again;
+		}
+		if (tmp[1]==':') 
+		{	/* argument expected */
+			if (tmp[2]==':' || argv[opt->ind][lastofs+2]) {	/* "-foo", return "oo" as opt->arg */
+				if (!*(opt->arg=argv[opt->ind]+lastofs+2)) opt->arg=0;
+				goto found;
+			}
+			opt->arg=argv[opt->ind+1];
+			if (!opt->arg) {	/* missing argument */
+				++opt->ind;
+				if (*optstring==':') return ':';
+				getopterror(1);
+				return ':';
+			}
+			++opt->ind;
+		} 
+		else 
+		{
+			++lastofs;
+			return optopt;
+		}
+found:
+		++opt->ind;
+		return optopt;
+	} 
+	else 
+	{	/* not found */
+		getopterror(0);
+		++opt->ind;
+		return '?';
+	}
+}
+