cryptutils

// util/optget.h, version 1.6.2

// optget source file from libutil

// Copyright (C) 2020, Jakob Wakeling

// MIT Licence

#include "error.h"

#include "optget.h"

#include <stddef.h>

#include <stdio.h>

#include <string.h>

#define cur av[opt->ind]

const struct opt OPTGET_INIT = { 1, 0, 1, 0, NULL, NULL, NULL, NULL };

static inline void permute(char **av, int i, int n);

int optget(struct opt *opt, char *av[], int flags) {

	if (flags & 1) {

		for (; cur && (cur[0] != '-' || cur[1] == 0); ++opt->ind, ++opt->nop);

		if (!cur) { opt->ind -= opt->nop; opt->nop = 0; return -1; }

	}

	else if (!cur || (cur[0] != '-' || cur[1] == 0)) { return -1; }

	int optind = opt->ind, optret;

	if (cur[1] == '-') {

		if (cur[2] == 0) { if (opt->nop) {

				permute(av, opt->ind++, opt->nop);

				opt->ind -= opt->nop; opt->nop = 0;

			} else { ++opt->ind; } return -1;

		}

		int optend, lop; optret = '?'; opt->opt = 0; opt->lop = cur;

		if (!opt->lops) { goto nol; }

		for (optend = 2; cur[optend] != '=' && cur[optend] != 0; ++optend);

		for (lop = 0; opt->lops[lop].str; ++lop) {

			if (strncmp(&cur[2], opt->lops[lop].str, (size_t)optend - 2) == 0) {

				if (!opt->lops[lop].str[optend - 2]) {

					optret = opt->opt = opt->lops[lop].val; break;

				}

			}

		}

		if (opt->lops[lop].arg > ARG_NUL) {

			if (cur[optend]) { opt->arg = &cur[optend + 1]; }

			else if (av[opt->ind + 1]) { opt->arg = av[++opt->ind]; }

			else {

				if (opt->lops[lop].arg == ARG_REQ) { optret = ':'; }

				opt->arg = NULL;

			}

		}

		else { opt->arg = NULL; }

nol:	opt->pos = 0;

	}

	else {

		optret = opt->opt = cur[opt->pos++]; opt->lop = NULL;

		const char *optchr = strchr(opt->str, opt->opt);

		if (!optchr) { optret = '?'; }

		else if (optchr[1] == ':') {

			if (cur[opt->pos]) { opt->arg = &cur[opt->pos]; }

			else if (av[opt->ind + 1]) { opt->arg = av[++opt->ind]; }

			else { opt->arg = NULL; optret = ':'; }

			opt->pos = 0;

		}

		else { opt->arg = NULL; }

	}

	if (!opt->pos || !cur[opt->pos]) {

		++opt->ind; opt->pos = 1;

		if (opt->nop) for (; optind < opt->ind; ++optind) {

			permute(av, optind, opt->nop);

		}

	}

	if (optret == '?' && opt->str[0] != ':') {

		if (opt->opt) { warn("%c: invalid option", opt->opt); }

		else if (opt->lop) { warn("%s: invalid option", opt->lop); }

	}

	if (optret == ':' && opt->str[0] != ':') {

		if (opt->opt) { warn("%c: option requires argument", opt->opt); }

		else if (opt->lop) { warn("%s: option requires argument", opt->lop); }

	}

	return optret;

}

static inline void permute(char **av, int i, int n) {

	char *a = av[i]; memmove(&av[i - n + 1], &av[i - n], n * sizeof (av));

	av[i - n] = a; return;

}