JHHM

dedit

a tool for Teeworlds demo file shenanigens
git clone https://jhhm.no/repos/dedit.git

dedit/src/args.c

get raw file: args.c

1/* This file is part of dedit - a tool for editing Teeworlds/DDNet demo files
2   Copyright (C) 2024, 2026 JHHM
3
4   Dedit is free software: you can redistribute it and/or modify
5   it under the terms of the GNU General Public License as published by
6   the Free Software Foundation, either version 3 of the License, or
7   (at your option) any later version.
8
9   Dedit is distributed in the hope that it will be useful,
10   but WITHOUT ANY WARRANTY; without even the implied warranty of
11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12   GNU General Public License for more details.
13
14   You should have received a copy of the GNU General Public License
15   along with dedit.  If not, see <https://www.gnu.org/licenses/>. */
16
17#define _POSIX_C_SOURCE 200112L
18
19#include "args.h"
20
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24
25typedef struct parg
26{
27    argtype type;
28    char *flag;
29    char *full;
30    int numopt;
31    char *desc[2];
32    void (*runarg)(struct arg *);
33} parg;
34
35int argerr = 0;
36char *errflag = NULL;
37
38char *inf = NULL;
39char *usg = NULL;
40
41int PARGC = 0;
42int pargscap = 2;
43parg *PARGS = NULL;
44
45int ARGC = 0;
46int argscap = 2;
47arg *ARGS;
48
49void setinfo(char *info)
50{
51    inf = info;
52}
53
54void setusage(char *usage)
55{
56    usg = usage;
57}
58
59int addparg(argtype type, char *flag, char *full, int numopt, char *desc1, char *desc2, void (*runarg)(struct arg *))
60{
61    if (!PARGS)
62        PARGS = (parg *)malloc(pargscap * sizeof(parg));
63    else
64    {
65        pargscap *= 2;
66        PARGS = (parg *)realloc(PARGS, pargscap * sizeof(parg));
67    }
68    PARGS[PARGC].type = type;
69    PARGS[PARGC].flag = flag;
70    PARGS[PARGC].full = full;
71    PARGS[PARGC].numopt = numopt;
72    PARGS[PARGC].desc[0] = desc1;
73    PARGS[PARGC].desc[1] = desc2;
74    PARGS[PARGC].runarg = runarg;
75    PARGC++;
76
77    return 1;
78}
79
80int addarg(char *value, char *desc, void (*runarg)(struct arg *))
81{
82    if (!value || !desc)
83        return 0;
84    addparg(ARGUMENT, NULL, NULL, 0, value, desc, runarg);
85    return 1;
86}
87
88int addopt(char *flag, char *full, int numopt, char *value, char *desc, void (*runarg)(struct arg *))
89{
90    if (!flag || !desc)
91        return 0;
92    addparg(OPTION, flag, full, numopt, value, desc, runarg);
93    return 1;
94}
95
96int checkarg(char *str, parg *par)
97{
98    if (par->flag && strcmp(str, par->flag) == 0)
99        return 1;
100
101    if (par->full && strcmp(str, par->full) == 0)
102        return 1;
103
104    return 0;
105}
106
107int parseargs(int argc, char *args[])
108{
109    ARGS = (arg *)malloc(argscap * sizeof(arg));
110
111    char inctype[] = {0, 0, 0};
112    for (int i = 0; i < PARGC; i++)
113        inctype[PARGS[i].type]++;
114
115    int argumentc = 0;
116
117    for (int i = 1; i < argc; i++)
118    {
119        char *a = args[i];
120        char isopt = 0;
121        for (int y = 0; y < PARGC; y++)
122        {
123            parg *pa = &PARGS[y];
124            if (checkarg(a, pa))
125            {
126                if (i + pa->numopt >= argc)
127                {
128                    argerr = 1;
129                    errflag = pa->flag;
130                    return 0;
131                }
132                isopt = 1;
133                if (argscap >= ARGC)
134                {
135                    argscap *= 2;
136                    ARGS = (arg *)realloc(ARGS, argscap * sizeof(arg));
137                }
138                ARGS[ARGC].type = pa->type;
139                ARGS[ARGC].flag = pa->flag;
140                ARGS[ARGC].numopt = pa->numopt;
141                ARGS[ARGC].runarg = pa->runarg;
142                ARGS[ARGC].opts = (char **)malloc(pa->numopt * sizeof(char *));
143
144                for (int j = 0; j < pa->numopt; j++)
145                    ARGS[ARGC].opts[j] = args[i + j + 1];
146
147                i += pa->numopt;
148                ARGC++;
149            }
150        }
151        if (isopt)
152            continue;
153
154        if (argumentc < inctype[ARGUMENT])
155        {
156            ARGS[ARGC].type = ARGUMENT;
157            for (int y = 0, x = argumentc; y < PARGC; y++)
158            {
159                if (PARGS[y].type == ARGUMENT)
160                {
161                    if (x != 0)
162                        x--;
163                    else
164                    {
165                        ARGS[ARGC].numopt = 1;
166                        ARGS[ARGC].flag = "NONE";
167                        ARGS[ARGC].runarg = PARGS[y].runarg;
168                        ARGS[ARGC].opts = (char **)malloc(sizeof(char *));
169                        ARGS[ARGC].opts[0] = a;
170                        argumentc++;
171                        ARGC++;
172                    }
173                }
174            }
175        }
176        else
177        {
178            if (a[0] != '-')
179            {
180                argerr = 2;
181                errflag = NULL;
182            }
183            else
184            {
185                argerr = 3;
186                errflag = args[i];
187            }
188            return 0;
189        }
190    }
191    return 1;
192}
193
194void freeargs(void)
195{
196    for (int i = 0; i < ARGC; i++)
197    {
198        if (ARGS[i].opts)
199            free(ARGS[i].opts);
200    }
201    if (ARGS)
202        free(ARGS);
203    if (PARGS)
204        free(PARGS);
205}
206
207void runargs(void)
208{
209    for (int i = 0; i < ARGC; i++)
210    {
211        if (ARGS[i].runarg)
212            ARGS[i].runarg(&ARGS[i]);
213    }
214}
215
216arg *getarg(int pos)
217{
218    for (int i = 0; i < ARGC; i++)
219        if (ARGS[i].type == ARGUMENT)
220        {
221            if (pos == 0)
222                return &ARGS[i];
223            pos--;
224        }
225    return NULL;
226}
227
228arg *getopt(char *flag, int pos)
229{
230    for (int i = 0; i < ARGC; i++)
231        if (ARGS[i].type == OPTION && strcmp(flag, ARGS[i].flag) == 0)
232        {
233            if (pos == 0)
234                return &ARGS[i];
235            pos--;
236        }
237    return NULL;
238}
239
240void printhelp(void)
241{
242    char inctype[ARGTYPELEN] = {0, 0, 0};
243    int maxflag[ARGTYPELEN] = {0, 0, 0};
244    int maxfull[ARGTYPELEN] = {0, 0, 0};
245    int maxdesc0[ARGTYPELEN] = {0, 0, 0};
246    int maxdesc1[ARGTYPELEN] = {0, 0, 0};
247
248    for (int i = 0; i < PARGC; i++)
249    {
250        parg *pa = &PARGS[i];
251        int type = pa->type;
252
253        inctype[type]++;
254        if (pa->flag)
255            maxflag[type] = ((size_t)maxflag[type] > strlen(pa->flag) ? maxflag[type] : (int)strlen(pa->flag));
256        if (pa->full)
257            maxfull[type] = ((size_t)maxfull[type] > strlen(pa->full) ? maxfull[type] : (int)strlen(pa->full));
258        if (pa->desc[0])
259            maxdesc0[type] = ((size_t)maxdesc0[type] > strlen(pa->desc[0]) ? maxdesc0[type] : (int)strlen(pa->desc[0]));
260        if (pa->desc[1])
261            maxdesc1[type] = ((size_t)maxdesc1[type] > strlen(pa->desc[1]) ? maxdesc1[type] : (int)strlen(pa->desc[1]));
262    }
263    if (inf)
264        printf("%s\n\n", inf);
265
266    if (usg)
267        printf("Usage: %s\n", usg);
268
269    if (inctype[ARGUMENT])
270    {
271        printf("\nArgument%c:\n", (inctype[ARGUMENT] < 2) ? '\0' : 's');
272        for (int i = 0; i < PARGC; i++)
273        {
274            parg *pa = &PARGS[i];
275            if (pa->type == ARGUMENT)
276                printf("  %s %s\n", pa->desc[0], pa->desc[1]);
277        }
278    }
279
280    if (inctype[OPTION])
281    {
282        printf("\nOption%c:\n", (inctype[OPTION] < 2) ? '\0' : 's');
283        for (int i = 0; i < PARGC; i++)
284        {
285            parg *pa = &PARGS[i];
286            if (pa->type == OPTION)
287                printf("  %*s, %-*s %-*s  %s\n", maxflag[OPTION], pa->flag, maxfull[OPTION], pa->full, maxdesc0[OPTION],
288                       (pa->desc[0]) ? pa->desc[0] : "", pa->desc[1]);
289        }
290    }
291}
292
293void paerror(char *str)
294{
295    char *errstr;
296    switch (argerr)
297    {
298    case 0:
299        errstr = "No error";
300        break;
301    case 1:
302        errstr = "Missing input for option flag";
303        break;
304    case 2:
305        errstr = "Too many positional arguments";
306        break;
307    case 3:
308        errstr = "Unknown flag";
309        break;
310    default:
311        errstr = "Unknown error";
312        break;
313    }
314    if (errflag)
315        fprintf(stderr, "%s %s '%s'\n", str, errstr, errflag);
316    else
317        fprintf(stderr, "%s %s\n", str, errstr);
318}