From f3552d1404461ab5175f127be05614273694b882 Mon Sep 17 00:00:00 2001 From: Kacper Donat Date: Sat, 27 Oct 2018 19:02:13 +0200 Subject: [PATCH] initial commit --- .gitignore | 1 + Makefile | 17 ++ README.md | 1 + build/skiller-sgk3.pdf | Bin 0 -> 6754 bytes doc/.gitignore | 208 +++++++++++++++++++++ doc/skiller-sgk3.tex | 23 +++ lib/.gitignore | 0 lib/optparse.h | 403 +++++++++++++++++++++++++++++++++++++++++ src/.gitignore | 0 9 files changed, 653 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 README.md create mode 100644 build/skiller-sgk3.pdf create mode 100644 doc/.gitignore create mode 100644 doc/skiller-sgk3.tex create mode 100644 lib/.gitignore create mode 100644 lib/optparse.h create mode 100644 src/.gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..397b4a7 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +*.log diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..b2accb6 --- /dev/null +++ b/Makefile @@ -0,0 +1,17 @@ +CC=gcc +CFLAGS=-Wall -O0 -g +LDFLAGS=-lm +TEX=xelatex +TEXFLAGS=-file-line-error -interaction nonstopmode + +all: doc +doc: doc/skiller-sgk3.pdf + +%.pdf: %.tex + $(TEX) $(TEXFLAGS) -output-directory build $< + +.c.o: + $(CC) $(CFLAGS) -MMD -c ./src/$< -o ./build/$@ + +clean: + rm build/* diff --git a/README.md b/README.md new file mode 100644 index 0000000..460c4bf --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# Sharkoon Skiller SGK3 control diff --git a/build/skiller-sgk3.pdf b/build/skiller-sgk3.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4f79bae9a059d5aa1266d7d30178c24594f6dbe1 GIT binary patch literal 6754 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 TfZGCu1x3IBc6LQ=CBT0HYMR*G literal 0 HcmV?d00001 diff --git a/doc/.gitignore b/doc/.gitignore new file mode 100644 index 0000000..dfef9a4 --- /dev/null +++ b/doc/.gitignore @@ -0,0 +1,208 @@ +## Core latex/pdflatex auxiliary files: +*.aux +*.lof +*.log +*.lot +*.fls +*.out +*.toc +*.fmt +*.fot +*.cb +*.cb2 +.*.lb + +## Intermediate documents: +*.dvi +*.xdv +*-converted-to.* +# these rules might exclude image files for figures etc. +# *.ps +# *.eps +*.pdf + +## Generated if empty string is given at "Please type another file name for output:" +.pdf + +## Bibliography auxiliary files (bibtex/biblatex/biber): +*.bbl +*.bcf +*.blg +*-blx.aux +*-blx.bib +*.run.xml + +## Build tool auxiliary files: +*.fdb_latexmk +*.synctex +*.synctex(busy) +*.synctex.gz +*.synctex.gz(busy) +*.pdfsync + +## Build tool directories for auxiliary files +# latexrun +latex.out/ + +## Auxiliary and intermediate files from other packages: +# algorithms +*.alg +*.loa + +# achemso +acs-*.bib + +# amsthm +*.thm + +# beamer +*.nav +*.pre +*.snm +*.vrb + +# changes +*.soc + +# comment +*.cut + +# cprotect +*.cpt + +# elsarticle (documentclass of Elsevier journals) +*.spl + +# endnotes +*.ent + +# glossaries +*.acn +*.acr +*.glg +*.glo +*.gls +*.glsdefs + +# gnuplottex +*-gnuplottex-* + +# gregoriotex +*.gaux +*.gtex + +# htlatex +*.4ct +*.4tc +*.idv +*.lg +*.trc +*.xref + +# hyperref +*.brf + +# knitr +*-concordance.tex +# TODO Comment the next line if you want to keep your tikz graphics files +*.tikz +*-tikzDictionary + +# listings +*.lol + +# makeidx +*.idx +*.ilg +*.ind +*.ist + +# minitoc +*.maf +*.mlf +*.mlt +*.mtc[0-9]* +*.slf[0-9]* +*.slt[0-9]* +*.stc[0-9]* + +# minted +_minted* +*.pyg + +# morewrites +*.mw + +# nomencl +*.nlg +*.nlo +*.nls + +# pax +*.pax + +# pdfpcnotes +*.pdfpc + +# sagetex +*.sagetex.sage +*.sagetex.py +*.sagetex.scmd + +# scrwfile +*.wrt + +# sympy +*.sout +*.sympy +sympy-plots-for-*.tex/ + +# pdfcomment +*.upa +*.upb + +# pythontex +*.pytxcode +pythontex-files-*/ + +# tcolorbox +*.listing + +# thmtools +*.loe + +# TikZ & PGF +*.dpth +*.md5 +*.auxlock + +# todonotes +*.tdo + +# easy-todo +*.lod + +# xcolor +*.xcp + +# xmpincl +*.xmpi + +# xindy +*.xdy + +# xypic precompiled matrices +*.xyc + +# endfloat +*.ttt +*.fff + +# Latexian +TSWLatexianTemp* + +# expex forward references with \gathertags +*-tags.tex + +# standalone packages +*.sta diff --git a/doc/skiller-sgk3.tex b/doc/skiller-sgk3.tex new file mode 100644 index 0000000..8df389c --- /dev/null +++ b/doc/skiller-sgk3.tex @@ -0,0 +1,23 @@ +\documentclass[]{article} +\usepackage[T1]{fontenc} +\usepackage{listings} +\usepackage{titling} +\usepackage[utf8]{inputenc} +\usepackage[margin=1in]{geometry} +\usepackage{pdfpages} +\usepackage{float} +\usepackage{amssymb} +\usepackage{alltt} +\usepackage{verbatim} +\usepackage{amstext} +\usepackage{tikz} +\usepackage{pgfplots} + +%opening +\title {Sharkoon Skiller MECH SGK3 USB control protocol} +\author {Kacper Donat } + +\begin{document} + {\huge \noindent \textbf{\thetitle} \vspace{5mm}} \\ + {\large \theauthor} \\ +\end{document} diff --git a/lib/.gitignore b/lib/.gitignore new file mode 100644 index 0000000..e69de29 diff --git a/lib/optparse.h b/lib/optparse.h new file mode 100644 index 0000000..3a577a7 --- /dev/null +++ b/lib/optparse.h @@ -0,0 +1,403 @@ +/* Optparse --- portable, reentrant, embeddable, getopt-like option parser + * + * This is free and unencumbered software released into the public domain. + * + * To get the implementation, define OPTPARSE_IMPLEMENTATION. + * Optionally define OPTPARSE_API to control the API's visibility + * and/or linkage (static, __attribute__, __declspec). + * + * The POSIX getopt() option parser has three fatal flaws. These flaws + * are solved by Optparse. + * + * 1) Parser state is stored entirely in global variables, some of + * which are static and inaccessible. This means only one thread can + * use getopt(). It also means it's not possible to recursively parse + * nested sub-arguments while in the middle of argument parsing. + * Optparse fixes this by storing all state on a local struct. + * + * 2) The POSIX standard provides no way to properly reset the parser. + * This means for portable code that getopt() is only good for one + * run, over one argv with one option string. It also means subcommand + * options cannot be processed with getopt(). Most implementations + * provide a method to reset the parser, but it's not portable. + * Optparse provides an optparse_arg() function for stepping over + * subcommands and continuing parsing of options with another option + * string. The Optparse struct itself can be passed around to + * subcommand handlers for additional subcommand option parsing. A + * full reset can be achieved by with an additional optparse_init(). + * + * 3) Error messages are printed to stderr. This can be disabled with + * opterr, but the messages themselves are still inaccessible. + * Optparse solves this by writing an error message in its errmsg + * field. The downside to Optparse is that this error message will + * always be in English rather than the current locale. + * + * Optparse should be familiar with anyone accustomed to getopt(), and + * it could be a nearly drop-in replacement. The option string is the + * same and the fields have the same names as the getopt() global + * variables (optarg, optind, optopt). + * + * Optparse also supports GNU-style long options with optparse_long(). + * The interface is slightly different and simpler than getopt_long(). + * + * By default, argv is permuted as it is parsed, moving non-option + * arguments to the end. This can be disabled by setting the `permute` + * field to 0 after initialization. + */ +#ifndef OPTPARSE_H +#define OPTPARSE_H + +#ifndef OPTPARSE_API +# define OPTPARSE_API +#endif + +struct optparse { + char **argv; + int permute; + int optind; + int optopt; + char *optarg; + char errmsg[64]; + int subopt; +}; + +enum optparse_argtype { + OPTPARSE_NONE, + OPTPARSE_REQUIRED, + OPTPARSE_OPTIONAL +}; + +struct optparse_long { + const char *longname; + int shortname; + enum optparse_argtype argtype; +}; + +/** + * Initializes the parser state. + */ +OPTPARSE_API +void optparse_init(struct optparse *options, char **argv); + +/** + * Read the next option in the argv array. + * @param optstring a getopt()-formatted option string. + * @return the next option character, -1 for done, or '?' for error + * + * Just like getopt(), a character followed by no colons means no + * argument. One colon means the option has a required argument. Two + * colons means the option takes an optional argument. + */ +OPTPARSE_API +int optparse(struct optparse *options, const char *optstring); + +/** + * Handles GNU-style long options in addition to getopt() options. + * This works a lot like GNU's getopt_long(). The last option in + * longopts must be all zeros, marking the end of the array. The + * longindex argument may be NULL. + */ +OPTPARSE_API +int optparse_long(struct optparse *options, + const struct optparse_long *longopts, + int *longindex); + +/** + * Used for stepping over non-option arguments. + * @return the next non-option argument, or NULL for no more arguments + * + * Argument parsing can continue with optparse() after using this + * function. That would be used to parse the options for the + * subcommand returned by optparse_arg(). This function allows you to + * ignore the value of optind. + */ +OPTPARSE_API +char *optparse_arg(struct optparse *options); + +/* Implementation */ +#ifdef OPTPARSE_IMPLEMENTATION + +#define OPTPARSE_MSG_INVALID "invalid option" +#define OPTPARSE_MSG_MISSING "option requires an argument" +#define OPTPARSE_MSG_TOOMANY "option takes no arguments" + +static int +optparse_error(struct optparse *options, const char *msg, const char *data) +{ + unsigned p = 0; + const char *sep = " -- '"; + while (*msg) + options->errmsg[p++] = *msg++; + while (*sep) + options->errmsg[p++] = *sep++; + while (p < sizeof(options->errmsg) - 2 && *data) + options->errmsg[p++] = *data++; + options->errmsg[p++] = '\''; + options->errmsg[p++] = '\0'; + return '?'; +} + +OPTPARSE_API +void +optparse_init(struct optparse *options, char **argv) +{ + options->argv = argv; + options->permute = 1; + options->optind = 1; + options->subopt = 0; + options->optarg = 0; + options->errmsg[0] = '\0'; +} + +static int +optparse_is_dashdash(const char *arg) +{ + return arg != 0 && arg[0] == '-' && arg[1] == '-' && arg[2] == '\0'; +} + +static int +optparse_is_shortopt(const char *arg) +{ + return arg != 0 && arg[0] == '-' && arg[1] != '-' && arg[1] != '\0'; +} + +static int +optparse_is_longopt(const char *arg) +{ + return arg != 0 && arg[0] == '-' && arg[1] == '-' && arg[2] != '\0'; +} + +static void +optparse_permute(struct optparse *options, int index) +{ + char *nonoption = options->argv[index]; + int i; + for (i = index; i < options->optind - 1; i++) + options->argv[i] = options->argv[i + 1]; + options->argv[options->optind - 1] = nonoption; +} + +static int +optparse_argtype(const char *optstring, char c) +{ + int count = OPTPARSE_NONE; + if (c == ':') + return -1; + for (; *optstring && c != *optstring; optstring++); + if (!*optstring) + return -1; + if (optstring[1] == ':') + count += optstring[2] == ':' ? 2 : 1; + return count; +} + +OPTPARSE_API +int +optparse(struct optparse *options, const char *optstring) +{ + int type; + char *next; + char *option = options->argv[options->optind]; + options->errmsg[0] = '\0'; + options->optopt = 0; + options->optarg = 0; + if (option == 0) { + return -1; + } else if (optparse_is_dashdash(option)) { + options->optind++; /* consume "--" */ + return -1; + } else if (!optparse_is_shortopt(option)) { + if (options->permute) { + int index = options->optind++; + int r = optparse(options, optstring); + optparse_permute(options, index); + options->optind--; + return r; + } else { + return -1; + } + } + option += options->subopt + 1; + options->optopt = option[0]; + type = optparse_argtype(optstring, option[0]); + next = options->argv[options->optind + 1]; + switch (type) { + case -1: { + char str[2] = {0, 0}; + str[0] = option[0]; + options->optind++; + return optparse_error(options, OPTPARSE_MSG_INVALID, str); + } + case OPTPARSE_NONE: + if (option[1]) { + options->subopt++; + } else { + options->subopt = 0; + options->optind++; + } + return option[0]; + case OPTPARSE_REQUIRED: + options->subopt = 0; + options->optind++; + if (option[1]) { + options->optarg = option + 1; + } else if (next != 0) { + options->optarg = next; + options->optind++; + } else { + char str[2] = {0, 0}; + str[0] = option[0]; + options->optarg = 0; + return optparse_error(options, OPTPARSE_MSG_MISSING, str); + } + return option[0]; + case OPTPARSE_OPTIONAL: + options->subopt = 0; + options->optind++; + if (option[1]) + options->optarg = option + 1; + else + options->optarg = 0; + return option[0]; + } + return 0; +} + +OPTPARSE_API +char * +optparse_arg(struct optparse *options) +{ + char *option = options->argv[options->optind]; + options->subopt = 0; + if (option != 0) + options->optind++; + return option; +} + +static int +optparse_longopts_end(const struct optparse_long *longopts, int i) +{ + return !longopts[i].longname && !longopts[i].shortname; +} + +static void +optparse_from_long(const struct optparse_long *longopts, char *optstring) +{ + char *p = optstring; + int i; + for (i = 0; !optparse_longopts_end(longopts, i); i++) { + if (longopts[i].shortname) { + int a; + *p++ = longopts[i].shortname; + for (a = 0; a < (int)longopts[i].argtype; a++) + *p++ = ':'; + } + } + *p = '\0'; +} + +/* Unlike strcmp(), handles options containing "=". */ +static int +optparse_longopts_match(const char *longname, const char *option) +{ + const char *a = option, *n = longname; + if (longname == 0) + return 0; + for (; *a && *n && *a != '='; a++, n++) + if (*a != *n) + return 0; + return *n == '\0' && (*a == '\0' || *a == '='); +} + +/* Return the part after "=", or NULL. */ +static char * +optparse_longopts_arg(char *option) +{ + for (; *option && *option != '='; option++); + if (*option == '=') + return option + 1; + else + return 0; +} + +static int +optparse_long_fallback(struct optparse *options, + const struct optparse_long *longopts, + int *longindex) +{ + int result; + char optstring[96 * 3 + 1]; /* 96 ASCII printable characters */ + optparse_from_long(longopts, optstring); + result = optparse(options, optstring); + if (longindex != 0) { + *longindex = -1; + if (result != -1) { + int i; + for (i = 0; !optparse_longopts_end(longopts, i); i++) + if (longopts[i].shortname == options->optopt) + *longindex = i; + } + } + return result; +} + +OPTPARSE_API +int +optparse_long(struct optparse *options, + const struct optparse_long *longopts, + int *longindex) +{ + int i; + char *option = options->argv[options->optind]; + if (option == 0) { + return -1; + } else if (optparse_is_dashdash(option)) { + options->optind++; /* consume "--" */ + return -1; + } else if (optparse_is_shortopt(option)) { + return optparse_long_fallback(options, longopts, longindex); + } else if (!optparse_is_longopt(option)) { + if (options->permute) { + int index = options->optind++; + int r = optparse_long(options, longopts, longindex); + optparse_permute(options, index); + options->optind--; + return r; + } else { + return -1; + } + } + + /* Parse as long option. */ + options->errmsg[0] = '\0'; + options->optopt = 0; + options->optarg = 0; + option += 2; /* skip "--" */ + options->optind++; + for (i = 0; !optparse_longopts_end(longopts, i); i++) { + const char *name = longopts[i].longname; + if (optparse_longopts_match(name, option)) { + char *arg; + if (longindex) + *longindex = i; + options->optopt = longopts[i].shortname; + arg = optparse_longopts_arg(option); + if (longopts[i].argtype == OPTPARSE_NONE && arg != 0) { + return optparse_error(options, OPTPARSE_MSG_TOOMANY, name); + } if (arg != 0) { + options->optarg = arg; + } else if (longopts[i].argtype == OPTPARSE_REQUIRED) { + options->optarg = options->argv[options->optind]; + if (options->optarg == 0) + return optparse_error(options, OPTPARSE_MSG_MISSING, name); + else + options->optind++; + } + return options->optopt; + } + } + return optparse_error(options, OPTPARSE_MSG_INVALID, option); +} + +#endif /* OPTPARSE_IMPLEMENTATION */ +#endif /* OPTPARSE_H */ diff --git a/src/.gitignore b/src/.gitignore new file mode 100644 index 0000000..e69de29