diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..f159e29 --- /dev/null +++ b/Makefile @@ -0,0 +1,47 @@ +PROGRAM = sbig340 +LDFLAGS = +#-fdata-sections -ffunction-sections -Wl,--gc-sections +SRCS = $(wildcard *.c) +DEFINES = $(DEF) -D_XOPEN_SOURCE=1111 -DEBUG +OBJDIR = mk +CFLAGS = -Wall -Werror -Wextra -Wno-trampolines -std=gnu99 +OBJS = $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.o)) +DEPS = $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.d)) +CC = gcc + +all : $(PROGRAM) + +$(PROGRAM) : $(OBJS) + @echo -e "\t\tLD $(PROGRAM)" + $(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) -o $(PROGRAM) + +$(OBJDIR): + mkdir $(OBJDIR) + +$(OBJS): $(OBJDIR) $(DEPS) + +$(OBJDIR)/%.d: %.c $(OBJDIR) + $(CC) -MM -MG $< | sed -e 's,^\([^:]*\)\.o[ ]*:,$(@D)/\1.o $(@D)/\1.d:,' >$@ + +ifneq ($(MAKECMDGOALS),clean) +-include $(DEPS) +endif + +$(OBJDIR)/%.o: %.c + @echo -e "\t\tCC $<" + $(CC) -c $(CFLAGS) $(DEFINES) -o $@ $< + +clean: + @echo -e "\t\tCLEAN" + @rm -f $(OBJS) + @rm -f $(DEPS) + @rmdir $(OBJDIR) 2>/dev/null || true + +xclean: clean + @rm -f $(PROGRAM) + +gentags: + CFLAGS="$(CFLAGS) $(DEFINES)" geany -g $(PROGRAM).c.tags *[hc] 2>/dev/null + +.PHONY: gentags clean xclean + diff --git a/cmdlnopts.c b/cmdlnopts.c new file mode 100644 index 0000000..e019c28 --- /dev/null +++ b/cmdlnopts.c @@ -0,0 +1,86 @@ +/* + * cmdlnopts.c - the only function that parse cmdln args and returns glob parameters + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 +#include +#include +#include +#include +#include "cmdlnopts.h" +#include "usefull_macros.h" + +/* + * here are global parameters initialisation + */ +int help; +glob_pars G; + +int rewrite_ifexists = 0, // rewrite existing files == 0 or 1 + verbose = 0; // each -v increments this value, e.g. -vvv sets it to 3 +#define DEFAULT_COMDEV "/dev/ttyUSB0" +// DEFAULTS +// default global parameters +glob_pars const Gdefault = { + .daemon = 0, + .terminal = 0, + .device = DEFAULT_COMDEV, + .rest_pars_num = 0, + .rest_pars = NULL +}; + +/* + * Define command line options by filling structure: + * name has_arg flag val type argptr help +*/ +myoption cmdlnopts[] = { + // set 1 to param despite of its repeating number: + {"help", NO_ARGS, NULL, 'h', arg_int, APTR(&help), _("show this help")}, + {"daemon", NO_ARGS, NULL, 'd', arg_int, APTR(&G.daemon), _("run as daemon")}, + {"terminal",NO_ARGS, NULL, 't', arg_int, APTR(&G.terminal), _("run as terminal")}, + {"device", NEED_ARG, NULL, 'i', arg_string, APTR(&G.device), _("serial device name (default: " DEFAULT_COMDEV ")")}, + // simple integer parameter with obligatory arg: + end_option +}; + +/** + * Parse 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 *parse_args(int argc, char **argv){ + int i; + void *ptr; + ptr = memcpy(&G, &Gdefault, sizeof(G)); assert(ptr); + // format of help: "Usage: progname [args]\n" + change_helpstring("Usage: %s [args]\n\n\tWhere args are:\n"); + // parse arguments + parseargs(&argc, &argv, cmdlnopts); + if(help) showhelp(-1, cmdlnopts); + if(argc > 0){ + G.rest_pars_num = argc; + G.rest_pars = calloc(argc, sizeof(char*)); + for (i = 0; i < argc; i++) + G.rest_pars[i] = strdup(argv[i]); + } + return &G; +} + diff --git a/cmdlnopts.h b/cmdlnopts.h new file mode 100644 index 0000000..2fde25b --- /dev/null +++ b/cmdlnopts.h @@ -0,0 +1,44 @@ +/* + * cmdlnopts.h - comand line options for parceargs + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 "parseargs.h" + +/* + * here are some typedef's for global data + */ +typedef struct{ + int daemon; // to daemonize + int terminal; // run as terminal (send/receive) + char *device; // serial device name + int rest_pars_num; // number of rest parameters + char** rest_pars; // the rest parameters: array of char* +} glob_pars; + + +// default & global parameters +extern int rewrite_ifexists, verbose; + +glob_pars *parse_args(int argc, char **argv); +#endif // __CMDLNOPTS_H__ diff --git a/main.c b/main.c new file mode 100644 index 0000000..2337452 --- /dev/null +++ b/main.c @@ -0,0 +1,47 @@ +/* + * main.c + * + * Copyright 2017 Edward V. Emelianov + * + * 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 "usefull_macros.h" +#include "term.h" +#include "cmdlnopts.h" + +void signals(int signo){ + restore_console(); + restore_tty(); + exit(signo); +} + +int main(int argc, char **argv){ + initial_setup(); + glob_pars *G = parse_args(argc, argv); + if(G->daemon && G->terminal){ + WARNX(_("Options --daemon and --terminal can't be together!")); + return 1; + } + if(!try_connect(G->device)){ + WARNX(_("Check power and connection: device not answer!")); + return 1; + } + if(G->daemon || G->terminal){ + red(_("All other commandline options rejected!\n")); + if(G->terminal) run_terminal(); // non-echo terminal mode + if(G->daemon) daemonize(); + } +} diff --git a/parseargs.c b/parseargs.c new file mode 100644 index 0000000..62c3808 --- /dev/null +++ b/parseargs.c @@ -0,0 +1,497 @@ +/* + * parseargs.c - parsing command line arguments & print help + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 // printf +#include // getopt_long +#include // calloc, exit, strtoll +#include // assert +#include // strdup, strchr, strlen +#include // strcasecmp +#include // INT_MAX & so on +#include // gettext +#include // isalpha +#include "parseargs.h" +#include "usefull_macros.h" + +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 + }; + if(pcount > 1 || pcount != scount){ // amount of pcount and/or scount wrong + /// "îÅÐÒÁ×ÉÌØÎÙÊ ÆÏÒÍÁÔ ÓÔÒÏËÉ ÐÏÍÏÝÉ" + ERRX(_("Wrong helpstring!")); + } + helpstring = s; +} + +/** + * 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 + */ +static 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){ + /// "ãÅÌÏÅ ×ÎÅ ÄÏÐÕÓÔÉÍÏÇÏ ÄÉÁÐÁÚÏÎÁ" + WARNX(_("Integer out of range")); + 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?) +static 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 + */ +static 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; +} + +/** + * reallocate new value in array of multiple repeating arguments + * @arg paptr - address of pointer to array (**void) + * @arg type - its type (for realloc) + * @return pointer to new (next) value + */ +void *get_aptr(void *paptr, argtype type){ + int i = 1; + void **aptr = *((void***)paptr); + if(aptr){ // there's something in array + void **p = aptr; + while(*p++) ++i; + } + size_t sz = 0; + switch(type){ + default: + case arg_none: + /// "îÅ ÍÏÇÕ ÉÓÐÏÌØÚÏ×ÁÔØ ÎÅÓËÏÌØËÏ ÐÁÒÁÍÅÔÒÏ× ÂÅÚ ÁÒÇÕÍÅÎÔÏ×!" + ERRX("Can't use multiple args with arg_none!"); + break; + case arg_int: + sz = sizeof(int); + break; + case arg_longlong: + sz = sizeof(long long); + break; + case arg_double: + sz = sizeof(double); + break; + case arg_float: + sz = sizeof(float); + break; + case arg_string: + sz = 0; + break; + /* case arg_function: + sz = sizeof(argfn *); + break;*/ + } + aptr = realloc(aptr, (i + 1) * sizeof(void*)); + *((void***)paptr) = aptr; + aptr[i] = NULL; + if(sz){ + aptr[i - 1] = malloc(sz); + }else + aptr[i - 1] = &aptr[i - 1]; + return aptr[i - 1]; +} + + +/** + * Parse 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 parseargs(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; + // in debug mode check the parameters are not repeated +#ifdef EBUG + char **longlist = MALLOC(char*, optsize); + char *shortlist = MALLOC(char, optsize); +#endif + // fill short/long parameters and make a simple checking + for(i = 0; i < optsize; i++, loptr++, opts++){ + // check + assert(opts->name); // check name +#ifdef EBUG + longlist[i] = strdup(opts->name); +#endif + 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 < MULT_PAR) ? opts->has_arg : 1; + loptr->flag = opts->flag; + loptr->val = opts->val; + // fill short options if they are: + if(!opts->flag && opts->val){ +#ifdef EBUG + shortlist[i] = (char) opts->val; +#endif + *soptr++ = opts->val; + if(loptr->has_arg) // add ':' if option has required argument + *soptr++ = ':'; + if(loptr->has_arg == 2) // add '::' if option has optional argument + *soptr++ = ':'; + } + } + // sort all lists & check for repeating +#ifdef EBUG + int cmpstringp(const void *p1, const void *p2){ + return strcmp(* (char * const *) p1, * (char * const *) p2); + } + int cmpcharp(const void *p1, const void *p2){ + return (int)(*(char * const)p1 - *(char *const)p2); + } + qsort(longlist, optsize, sizeof(char *), cmpstringp); + qsort(shortlist,optsize, sizeof(char), cmpcharp); + char *prevl = longlist[0], prevshrt = shortlist[0]; + for(i = 1; i < optsize; ++i){ + if(longlist[i]){ + if(prevl){ + if(strcmp(prevl, longlist[i]) == 0) ERRX("double long arguments: --%s", prevl); + } + prevl = longlist[i]; + } + if(shortlist[i]){ + if(prevshrt){ + if(prevshrt == shortlist[i]) ERRX("double short arguments: -%c", prevshrt); + } + prevshrt = shortlist[i]; + } + } +#endif + // 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 == NEED_ARG || options[optind].has_arg == MULT_PAR) + showhelp(optind, options); // need argument + } + else{ + if(opt == 0 || oindex > 0) optind = oindex; + else optind = get_optind(opt, options); + } + opts = &options[optind]; + if(opt == 0 && opts->has_arg == NO_ARGS) continue; // only long option changing integer flag + // now check option + if(opts->has_arg == NEED_ARG || opts->has_arg == MULT_PAR) + if(!optarg) showhelp(optind, options); // need argument + void *aptr; + if(opts->has_arg == MULT_PAR){ + aptr = get_aptr(opts->argptr, opts->type); + }else + aptr = opts->argptr; + 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: + if(opts->argptr) *((int*)aptr) += 1; // increment value + break; + case arg_int: + result = myatoll(aptr, optarg, arg_int); + break; + case arg_longlong: + result = myatoll(aptr, optarg, arg_longlong); + break; + case arg_double: + result = myatod(aptr, optarg, arg_double); + break; + case arg_float: + result = myatod(aptr, optarg, arg_float); + break; + case arg_string: + result = (*((void**)aptr) = (void*)strdup(optarg)); + break; + case arg_function: + result = ((argfn)aptr)(optarg); + break; + } + if(!result){ + showhelp(optind, options); + } + } + *argc -= optind; + *argv += optind; +} + +/** + * compare function for qsort + * first - sort by short options; second - sort arguments without sort opts (by long options) + */ +static int argsort(const void *a1, const void *a2){ + const myoption *o1 = (myoption*)a1, *o2 = (myoption*)a2; + const char *l1 = o1->name, *l2 = o2->name; + int s1 = o1->val, s2 = o2->val; + int *f1 = o1->flag, *f2 = o2->flag; + // check if both options has short arg + if(f1 == NULL && f2 == NULL){ // both have short arg + return (s1 - s2); + }else if(f1 != NULL && f2 != NULL){ // both don't have short arg - sort by long + return strcmp(l1, l2); + }else{ // only one have short arg -- return it + if(f2) return -1; // a1 have short - it is 'lesser' + else return 1; + } +} + +/** + * 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){ + 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", _(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; + // count amount of options + int N; for(N = 0; opts->name; ++N, ++opts); + if(N == 0) exit(-2); + // Now print all help (sorted) + opts = options; + qsort(opts, N, sizeof(myoption), argsort); + do{ + int p = sprintf(buf, " "); // a little indent + if(!opts->flag && 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, _(opts->help)); // write options & at least 2 spaces after + ++opts; + }while(--N); + printf("\n\n"); + exit(-1); +} + +/** + * get suboptions from parameter string + * @param str - parameter string + * @param opt - pointer to suboptions structure + * @return TRUE if all OK + */ +bool get_suboption(char *str, mysuboption *opt){ + int findsubopt(char *par, mysuboption *so){ + int idx = 0; + if(!par) return -1; + while(so[idx].name){ + if(strcasecmp(par, so[idx].name) == 0) return idx; + ++idx; + } + return -1; // badarg + } + bool opt_setarg(mysuboption *so, int idx, char *val){ + mysuboption *soptr = &so[idx]; + bool result = FALSE; + void *aptr = soptr->argptr; + switch(soptr->type){ + default: + case arg_none: + if(soptr->argptr) *((int*)aptr) += 1; // increment value + result = TRUE; + break; + case arg_int: + result = myatoll(aptr, val, arg_int); + break; + case arg_longlong: + result = myatoll(aptr, val, arg_longlong); + break; + case arg_double: + result = myatod(aptr, val, arg_double); + break; + case arg_float: + result = myatod(aptr, val, arg_float); + break; + case arg_string: + result = (*((void**)aptr) = (void*)strdup(val)); + break; + case arg_function: + result = ((argfn)aptr)(val); + break; + } + return result; + } + char *tok; + bool ret = FALSE; + char *tmpbuf; + tok = strtok_r(str, ":,", &tmpbuf); + do{ + char *val = strchr(tok, '='); + int noarg = 0; + if(val == NULL){ // no args + val = "1"; + noarg = 1; + }else{ + *val++ = '\0'; + if(!*val || *val == ':' || *val == ','){ // no argument - delimeter after = + val = "1"; noarg = 1; + } + } + int idx = findsubopt(tok, opt); + if(idx < 0){ + /// "îÅÐÒÁ×ÉÌØÎÙÊ ÐÁÒÁÍÅÔÒ: %s" + WARNX(_("Wrong parameter: %s"), tok); + goto returning; + } + if(noarg && opt[idx].has_arg == NEED_ARG){ + /// "%s: ÎÅÏÂÈÏÄÉÍ ÁÒÇÕÍÅÎÔ!" + WARNX(_("%s: argument needed!"), tok); + goto returning; + } + if(!opt_setarg(opt, idx, val)){ + /// "îÅÐÒÁ×ÉÌØÎÙÊ ÁÒÇÕÍÅÎÔ \"%s\" ÐÁÒÁÍÅÔÒÁ \"%s\"" + WARNX(_("Wrong argument \"%s\" of parameter \"%s\""), val, tok); + goto returning; + } + }while((tok = strtok_r(NULL, ":,", &tmpbuf))); + ret = TRUE; +returning: + return ret; +} diff --git a/parseargs.h b/parseargs.h new file mode 100644 index 0000000..a0ac099 --- /dev/null +++ b/parseargs.h @@ -0,0 +1,124 @@ +/* + * parseargs.h - headers for parsing command line arguments + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 __PARSEARGS_H__ +#define __PARSEARGS_H__ + +#include // bool +#include + +#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); + +/* + * 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}; + * ..(parse 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 // parse_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 "parseargs.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 enum{ + NO_ARGS = 0, // first three are the same as in getopt_long + NEED_ARG = 1, + OPT_ARG = 2, + MULT_PAR +} hasarg; + +typedef struct{ + // these are from struct option: + const char *name; // long option's name + hasarg has_arg; // 0 - no args, 1 - nesessary arg, 2 - optionally arg, 4 - need arg & key can repeat (args are stored in null-terminated array) + 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)` + const char *help; // help string which would be shown in function `showhelp` or NULL +} myoption; + +/* + * Suboptions structure, almost the same like myoption + * used in parse_subopts() + */ +typedef struct{ + const char *name; + hasarg has_arg; + argtype type; + void *argptr; +} mysuboption; + +// last string of array (all zeros) +#define end_option {0,0,0,0,0,0,0} +#define end_suboption {0,0,0,0} + +extern const char *__progname; + +void showhelp(int oindex, myoption *options); +void parseargs(int *argc, char ***argv, myoption *options); +void change_helpstring(char *s); +bool get_suboption(char *str, mysuboption *opt); + +#endif // __PARSEARGS_H__ diff --git a/sbig340.c.tags b/sbig340.c.tags new file mode 100644 index 0000000..cc9dc30 --- /dev/null +++ b/sbig340.c.tags @@ -0,0 +1,2546 @@ +# format=tagmanager +ACCESSPERMSÌ65536Ö0 +AIO_PRIO_DELTA_MAXÌ65536Ö0 +ALLOCÌ131072Í(type,var,size)Ö0 +ALLPERMSÌ65536Ö0 +ANS_COMM_TESTÌ65536Ö0 +APTRÌ131072Í(x)Ö0 +ARG_MAXÌ65536Ö0 +AT_EACCESSÌ65536Ö0 +AT_EMPTY_PATHÌ65536Ö0 +AT_FDCWDÌ65536Ö0 +AT_NO_AUTOMOUNTÌ65536Ö0 +AT_REMOVEDIRÌ65536Ö0 +AT_SYMLINK_FOLLOWÌ65536Ö0 +AT_SYMLINK_NOFOLLOWÌ65536Ö0 +B0Ì65536Ö0 +B1000000Ì65536Ö0 +B110Ì65536Ö0 +B115200Ì65536Ö0 +B1152000Ì65536Ö0 +B1200Ì65536Ö0 +B134Ì65536Ö0 +B150Ì65536Ö0 +B1500000Ì65536Ö0 +B1800Ì65536Ö0 +B19200Ì65536Ö0 +B200Ì65536Ö0 +B2000000Ì65536Ö0 +B230400Ì65536Ö0 +B2400Ì65536Ö0 +B2500000Ì65536Ö0 +B300Ì65536Ö0 +B3000000Ì65536Ö0 +B3500000Ì65536Ö0 +B38400Ì65536Ö0 +B4000000Ì65536Ö0 +B460800Ì65536Ö0 +B4800Ì65536Ö0 +B50Ì65536Ö0 +B500000Ì65536Ö0 +B57600Ì65536Ö0 +B576000Ì65536Ö0 +B600Ì65536Ö0 +B75Ì65536Ö0 +B921600Ì65536Ö0 +B9600Ì65536Ö0 +BAUD_RATEÌ65536Ö0 +BC_BASE_MAXÌ65536Ö0 +BC_DIM_MAXÌ65536Ö0 +BC_SCALE_MAXÌ65536Ö0 +BC_STRING_MAXÌ65536Ö0 +BIG_ENDIANÌ65536Ö0 +BRKINTÌ65536Ö0 +BS0Ì65536Ö0 +BS1Ì65536Ö0 +BSDLYÌ65536Ö0 +BUFLENÌ65536Ö0 +BUFSIZÌ65536Ö0 +BYTE_ORDERÌ65536Ö0 +BspeedsÌ16384Ö0Ïtcflag_t +CBAUDÌ65536Ö0 +CBAUDEXÌ65536Ö0 +CBRKÌ65536Ö0 +CCEQÌ131072Í(val,c)Ö0 +CDISCARDÌ65536Ö0 +CDSUSPÌ65536Ö0 +CEOFÌ65536Ö0 +CEOLÌ65536Ö0 +CEOTÌ65536Ö0 +CERASEÌ65536Ö0 +CFLUSHÌ65536Ö0 +CHARCLASS_NAME_MAXÌ65536Ö0 +CHAR_BITÌ65536Ö0 +CHAR_MAXÌ65536Ö0 +CHAR_MINÌ65536Ö0 +CIBAUDÌ65536Ö0 +CINTRÌ65536Ö0 +CKILLÌ65536Ö0 +CLNEXTÌ65536Ö0 +CLOCALÌ65536Ö0 +CMD_COMM_TESTÌ65536Ö0 +CMINÌ65536Ö0 +CMSPARÌ65536Ö0 +COLL_WEIGHTS_MAXÌ65536Ö0 +CQUITÌ65536Ö0 +CR0Ì65536Ö0 +CR1Ì65536Ö0 +CR2Ì65536Ö0 +CR3Ì65536Ö0 +CRDLYÌ65536Ö0 +CREADÌ65536Ö0 +CREPRINTÌ65536Ö0 +CRPRNTÌ65536Ö0 +CRTSCTSÌ65536Ö0 +CS5Ì65536Ö0 +CS6Ì65536Ö0 +CS7Ì65536Ö0 +CS8Ì65536Ö0 +CSIZEÌ65536Ö0 +CSTARTÌ65536Ö0 +CSTATUSÌ65536Ö0 +CSTOPÌ65536Ö0 +CSTOPBÌ65536Ö0 +CSUSPÌ65536Ö0 +CTIMEÌ65536Ö0 +CTRLÌ131072Í(x)Ö0 +CWERASEÌ65536Ö0 +DBGÌ131072Í(...)Ö0 +DBL_EPSILONÌ65536Ö0 +DEFAULT_COMDEVÌ65536Ö0 +DEFFILEMODEÌ65536Ö0 +DELAYTIMER_MAXÌ65536Ö0 +DN_ACCESSÌ65536Ö0 +DN_ATTRIBÌ65536Ö0 +DN_CREATEÌ65536Ö0 +DN_DELETEÌ65536Ö0 +DN_MODIFYÌ65536Ö0 +DN_MULTISHOTÌ65536Ö0 +DN_RENAMEÌ65536Ö0 +DOMAINÌ65536Ö0 +E2BIGÌ65536Ö0 +EACCESÌ65536Ö0 +EADDRINUSEÌ65536Ö0 +EADDRNOTAVAILÌ65536Ö0 +EADVÌ65536Ö0 +EAFNOSUPPORTÌ65536Ö0 +EAGAINÌ65536Ö0 +EALREADYÌ65536Ö0 +EBADEÌ65536Ö0 +EBADFÌ65536Ö0 +EBADFDÌ65536Ö0 +EBADMSGÌ65536Ö0 +EBADRÌ65536Ö0 +EBADRQCÌ65536Ö0 +EBADSLTÌ65536Ö0 +EBFONTÌ65536Ö0 +EBUGÌ65536Ö0 +EBUSYÌ65536Ö0 +ECANCELEDÌ65536Ö0 +ECHILDÌ65536Ö0 +ECHOÌ65536Ö0 +ECHOCTLÌ65536Ö0 +ECHOEÌ65536Ö0 +ECHOKÌ65536Ö0 +ECHOKEÌ65536Ö0 +ECHONLÌ65536Ö0 +ECHOPRTÌ65536Ö0 +ECHRNGÌ65536Ö0 +ECOMMÌ65536Ö0 +ECONNABORTEDÌ65536Ö0 +ECONNREFUSEDÌ65536Ö0 +ECONNRESETÌ65536Ö0 +EDEADLKÌ65536Ö0 +EDEADLOCKÌ65536Ö0 +EDESTADDRREQÌ65536Ö0 +EDOMÌ65536Ö0 +EDOTDOTÌ65536Ö0 +EDQUOTÌ65536Ö0 +EEXISTÌ65536Ö0 +EFAULTÌ65536Ö0 +EFBIGÌ65536Ö0 +EHOSTDOWNÌ65536Ö0 +EHOSTUNREACHÌ65536Ö0 +EHWPOISONÌ65536Ö0 +EIDRMÌ65536Ö0 +EILSEQÌ65536Ö0 +EINPROGRESSÌ65536Ö0 +EINTRÌ65536Ö0 +EINVALÌ65536Ö0 +EIOÌ65536Ö0 +EISCONNÌ65536Ö0 +EISDIRÌ65536Ö0 +EISNAMÌ65536Ö0 +EKEYEXPIREDÌ65536Ö0 +EKEYREJECTEDÌ65536Ö0 +EKEYREVOKEDÌ65536Ö0 +EL2HLTÌ65536Ö0 +EL2NSYNCÌ65536Ö0 +EL3HLTÌ65536Ö0 +EL3RSTÌ65536Ö0 +ELIBACCÌ65536Ö0 +ELIBBADÌ65536Ö0 +ELIBEXECÌ65536Ö0 +ELIBMAXÌ65536Ö0 +ELIBSCNÌ65536Ö0 +ELNRNGÌ65536Ö0 +ELOOPÌ65536Ö0 +EMEDIUMTYPEÌ65536Ö0 +EMFILEÌ65536Ö0 +EMLINKÌ65536Ö0 +EMSGSIZEÌ65536Ö0 +EMULTIHOPÌ65536Ö0 +ENAMETOOLONGÌ65536Ö0 +ENAVAILÌ65536Ö0 +ENETDOWNÌ65536Ö0 +ENETRESETÌ65536Ö0 +ENETUNREACHÌ65536Ö0 +ENFILEÌ65536Ö0 +ENOANOÌ65536Ö0 +ENOBUFSÌ65536Ö0 +ENOCSIÌ65536Ö0 +ENODATAÌ65536Ö0 +ENODEVÌ65536Ö0 +ENOENTÌ65536Ö0 +ENOEXECÌ65536Ö0 +ENOKEYÌ65536Ö0 +ENOLCKÌ65536Ö0 +ENOLINKÌ65536Ö0 +ENOMEDIUMÌ65536Ö0 +ENOMEMÌ65536Ö0 +ENOMSGÌ65536Ö0 +ENONETÌ65536Ö0 +ENOPKGÌ65536Ö0 +ENOPROTOOPTÌ65536Ö0 +ENOSPCÌ65536Ö0 +ENOSRÌ65536Ö0 +ENOSTRÌ65536Ö0 +ENOSYSÌ65536Ö0 +ENOTBLKÌ65536Ö0 +ENOTCONNÌ65536Ö0 +ENOTDIRÌ65536Ö0 +ENOTEMPTYÌ65536Ö0 +ENOTNAMÌ65536Ö0 +ENOTRECOVERABLEÌ65536Ö0 +ENOTSOCKÌ65536Ö0 +ENOTSUPÌ65536Ö0 +ENOTTYÌ65536Ö0 +ENOTUNIQÌ65536Ö0 +ENXIOÌ65536Ö0 +EOFÌ65536Ö0 +EOPNOTSUPPÌ65536Ö0 +EOVERFLOWÌ65536Ö0 +EOWNERDEADÌ65536Ö0 +EPERMÌ65536Ö0 +EPFNOSUPPORTÌ65536Ö0 +EPIPEÌ65536Ö0 +EPROTOÌ65536Ö0 +EPROTONOSUPPORTÌ65536Ö0 +EPROTOTYPEÌ65536Ö0 +ERANGEÌ65536Ö0 +EREMCHGÌ65536Ö0 +EREMOTEÌ65536Ö0 +EREMOTEIOÌ65536Ö0 +ERESTARTÌ65536Ö0 +ERFKILLÌ65536Ö0 +EROFSÌ65536Ö0 +ERRÌ131072Í(...)Ö0 +ERRXÌ131072Í(...)Ö0 +ESHUTDOWNÌ65536Ö0 +ESOCKTNOSUPPORTÌ65536Ö0 +ESPIPEÌ65536Ö0 +ESRCHÌ65536Ö0 +ESRMNTÌ65536Ö0 +ESTALEÌ65536Ö0 +ESTRPIPEÌ65536Ö0 +ETIMEÌ65536Ö0 +ETIMEDOUTÌ65536Ö0 +ETOOMANYREFSÌ65536Ö0 +ETXTBSYÌ65536Ö0 +EUCLEANÌ65536Ö0 +EUNATCHÌ65536Ö0 +EUSERSÌ65536Ö0 +EWOULDBLOCKÌ65536Ö0 +EXDEVÌ65536Ö0 +EXFULLÌ65536Ö0 +EXIT_FAILUREÌ65536Ö0 +EXIT_SUCCESSÌ65536Ö0 +EXPR_NEST_MAXÌ65536Ö0 +EXTAÌ65536Ö0 +EXTBÌ65536Ö0 +EXTPROCÌ65536Ö0 +FALLOC_FL_COLLAPSE_RANGEÌ65536Ö0 +FALLOC_FL_KEEP_SIZEÌ65536Ö0 +FALLOC_FL_PUNCH_HOLEÌ65536Ö0 +FALLOC_FL_ZERO_RANGEÌ65536Ö0 +FALSEÌ65536Ö0 +FAPPENDÌ65536Ö0 +FASYNCÌ65536Ö0 +FD_CLOEXECÌ65536Ö0 +FD_CLRÌ131072Í(fd,fdsetp)Ö0 +FD_ISSETÌ131072Í(fd,fdsetp)Ö0 +FD_SETÌ131072Í(fd,fdsetp)Ö0 +FD_SETSIZEÌ65536Ö0 +FD_ZEROÌ131072Í(fdsetp)Ö0 +FF0Ì65536Ö0 +FF1Ì65536Ö0 +FFDLYÌ65536Ö0 +FFSYNCÌ65536Ö0 +FILENAME_MAXÌ65536Ö0 +FIOASYNCÌ65536Ö0 +FIOCLEXÌ65536Ö0 +FIONBIOÌ65536Ö0 +FIONCLEXÌ65536Ö0 +FIONREADÌ65536Ö0 +FIOQSIZEÌ65536Ö0 +FLUSHOÌ65536Ö0 +FNAMEÌ131072Í()Ö0 +FNDELAYÌ65536Ö0 +FNONBLOCKÌ65536Ö0 +FOPEN_MAXÌ65536Ö0 +FP_ILOGB0Ì65536Ö0 +FP_ILOGBNANÌ65536Ö0 +FP_INFINITEÌ65536Ö0 +FP_NANÌ65536Ö0 +FP_NORMALÌ65536Ö0 +FP_SUBNORMALÌ65536Ö0 +FP_ZEROÌ65536Ö0 +FREEÌ131072Í(ptr)Ö0 +F_DUPFDÌ65536Ö0 +F_DUPFD_CLOEXECÌ65536Ö0 +F_EXLCKÌ65536Ö0 +F_GETFDÌ65536Ö0 +F_GETFLÌ65536Ö0 +F_GETLEASEÌ65536Ö0 +F_GETLKÌ65536Ö0 +F_GETLK64Ì65536Ö0 +F_GETOWNÌ65536Ö0 +F_GETOWN_EXÌ65536Ö0 +F_GETPIPE_SZÌ65536Ö0 +F_GETSIGÌ65536Ö0 +F_LOCKÌ65536Ö0 +F_NOTIFYÌ65536Ö0 +F_OFD_GETLKÌ65536Ö0 +F_OFD_SETLKÌ65536Ö0 +F_OFD_SETLKWÌ65536Ö0 +F_OKÌ65536Ö0 +F_RDLCKÌ65536Ö0 +F_SETFDÌ65536Ö0 +F_SETFLÌ65536Ö0 +F_SETLEASEÌ65536Ö0 +F_SETLKÌ65536Ö0 +F_SETLK64Ì65536Ö0 +F_SETLKWÌ65536Ö0 +F_SETLKW64Ì65536Ö0 +F_SETOWNÌ65536Ö0 +F_SETOWN_EXÌ65536Ö0 +F_SETPIPE_SZÌ65536Ö0 +F_SETSIGÌ65536Ö0 +F_SHLCKÌ65536Ö0 +F_TESTÌ65536Ö0 +F_TLOCKÌ65536Ö0 +F_ULOCKÌ65536Ö0 +F_UNLCKÌ65536Ö0 +F_WRLCKÌ65536Ö0 +GÌ16384Ö0Ïglob_pars +GREENÌ65536Ö0 +GdefaultÌ16384Ö0Ïglob_pars const +HOST_NAME_MAXÌ65536Ö0 +HUGEÌ65536Ö0 +HUGE_VALÌ65536Ö0 +HUGE_VALFÌ65536Ö0 +HUGE_VALLÌ65536Ö0 +HUPCLÌ65536Ö0 +ICANONÌ65536Ö0 +ICRNLÌ65536Ö0 +IEXTENÌ65536Ö0 +IGNBRKÌ65536Ö0 +IGNCRÌ65536Ö0 +IGNPARÌ65536Ö0 +IMAXBELÌ65536Ö0 +INFINITYÌ65536Ö0 +INLCRÌ65536Ö0 +INPCKÌ65536Ö0 +INT16_CÌ131072Í(c)Ö0 +INT16_MAXÌ65536Ö0 +INT16_MINÌ65536Ö0 +INT32_CÌ131072Í(c)Ö0 +INT32_MAXÌ65536Ö0 +INT32_MINÌ65536Ö0 +INT64_CÌ131072Í(c)Ö0 +INT64_MAXÌ65536Ö0 +INT64_MINÌ65536Ö0 +INT8_CÌ131072Í(c)Ö0 +INT8_MAXÌ65536Ö0 +INT8_MINÌ65536Ö0 +INTMAX_CÌ131072Í(c)Ö0 +INTMAX_MAXÌ65536Ö0 +INTMAX_MINÌ65536Ö0 +INTPTR_MAXÌ65536Ö0 +INTPTR_MINÌ65536Ö0 +INT_FAST16_MAXÌ65536Ö0 +INT_FAST16_MINÌ65536Ö0 +INT_FAST32_MAXÌ65536Ö0 +INT_FAST32_MINÌ65536Ö0 +INT_FAST64_MAXÌ65536Ö0 +INT_FAST64_MINÌ65536Ö0 +INT_FAST8_MAXÌ65536Ö0 +INT_FAST8_MINÌ65536Ö0 +INT_LEAST16_MAXÌ65536Ö0 +INT_LEAST16_MINÌ65536Ö0 +INT_LEAST32_MAXÌ65536Ö0 +INT_LEAST32_MINÌ65536Ö0 +INT_LEAST64_MAXÌ65536Ö0 +INT_LEAST64_MINÌ65536Ö0 +INT_LEAST8_MAXÌ65536Ö0 +INT_LEAST8_MINÌ65536Ö0 +INT_MAXÌ65536Ö0 +INT_MINÌ65536Ö0 +IOCSIZE_MASKÌ65536Ö0 +IOCSIZE_SHIFTÌ65536Ö0 +IOC_INÌ65536Ö0 +IOC_INOUTÌ65536Ö0 +IOC_OUTÌ65536Ö0 +IOV_MAXÌ65536Ö0 +ISIGÌ65536Ö0 +ISTRIPÌ65536Ö0 +ITIMER_PROFÌ65536Ö0 +ITIMER_REALÌ65536Ö0 +ITIMER_VIRTUALÌ65536Ö0 +IUCLCÌ65536Ö0 +IUTF8Ì65536Ö0 +IXANYÌ65536Ö0 +IXOFFÌ65536Ö0 +IXONÌ65536Ö0 +LC_ADDRESSÌ65536Ö0 +LC_ADDRESS_MASKÌ65536Ö0 +LC_ALLÌ65536Ö0 +LC_ALL_MASKÌ65536Ö0 +LC_COLLATEÌ65536Ö0 +LC_COLLATE_MASKÌ65536Ö0 +LC_CTYPEÌ65536Ö0 +LC_CTYPE_MASKÌ65536Ö0 +LC_GLOBAL_LOCALEÌ65536Ö0 +LC_IDENTIFICATIONÌ65536Ö0 +LC_IDENTIFICATION_MASKÌ65536Ö0 +LC_MEASUREMENTÌ65536Ö0 +LC_MEASUREMENT_MASKÌ65536Ö0 +LC_MESSAGESÌ65536Ö0 +LC_MESSAGES_MASKÌ65536Ö0 +LC_MONETARYÌ65536Ö0 +LC_MONETARY_MASKÌ65536Ö0 +LC_NAMEÌ65536Ö0 +LC_NAME_MASKÌ65536Ö0 +LC_NUMERICÌ65536Ö0 +LC_NUMERIC_MASKÌ65536Ö0 +LC_PAPERÌ65536Ö0 +LC_PAPER_MASKÌ65536Ö0 +LC_TELEPHONEÌ65536Ö0 +LC_TELEPHONE_MASKÌ65536Ö0 +LC_TIMEÌ65536Ö0 +LC_TIME_MASKÌ65536Ö0 +LINE_MAXÌ65536Ö0 +LINK_MAXÌ65536Ö0 +LITTLE_ENDIANÌ65536Ö0 +LLONG_MAXÌ65536Ö0 +LLONG_MINÌ65536Ö0 +LOCK_EXÌ65536Ö0 +LOCK_MANDÌ65536Ö0 +LOCK_NBÌ65536Ö0 +LOCK_READÌ65536Ö0 +LOCK_RWÌ65536Ö0 +LOCK_SHÌ65536Ö0 +LOCK_UNÌ65536Ö0 +LOCK_WRITEÌ65536Ö0 +LOGIN_NAME_MAXÌ65536Ö0 +LONG_BITÌ65536Ö0 +LONG_LONG_MAXÌ65536Ö0 +LONG_LONG_MINÌ65536Ö0 +LONG_MAXÌ65536Ö0 +LONG_MINÌ65536Ö0 +L_INCRÌ65536Ö0 +L_SETÌ65536Ö0 +L_XTNDÌ65536Ö0 +L_ctermidÌ65536Ö0 +L_cuseridÌ65536Ö0 +L_tmpnamÌ65536Ö0 +MADV_DODUMPÌ65536Ö0 +MADV_DOFORKÌ65536Ö0 +MADV_DONTDUMPÌ65536Ö0 +MADV_DONTFORKÌ65536Ö0 +MADV_DONTNEEDÌ65536Ö0 +MADV_HUGEPAGEÌ65536Ö0 +MADV_HWPOISONÌ65536Ö0 +MADV_MERGEABLEÌ65536Ö0 +MADV_NOHUGEPAGEÌ65536Ö0 +MADV_NORMALÌ65536Ö0 +MADV_RANDOMÌ65536Ö0 +MADV_REMOVEÌ65536Ö0 +MADV_SEQUENTIALÌ65536Ö0 +MADV_UNMERGEABLEÌ65536Ö0 +MADV_WILLNEEDÌ65536Ö0 +MALLOCÌ131072Í(type,size)Ö0 +MAP_32BITÌ65536Ö0 +MAP_ANONÌ65536Ö0 +MAP_ANONYMOUSÌ65536Ö0 +MAP_DENYWRITEÌ65536Ö0 +MAP_EXECUTABLEÌ65536Ö0 +MAP_FAILEDÌ65536Ö0 +MAP_FILEÌ65536Ö0 +MAP_FIXEDÌ65536Ö0 +MAP_GROWSDOWNÌ65536Ö0 +MAP_HUGETLBÌ65536Ö0 +MAP_HUGE_MASKÌ65536Ö0 +MAP_HUGE_SHIFTÌ65536Ö0 +MAP_LOCKEDÌ65536Ö0 +MAP_NONBLOCKÌ65536Ö0 +MAP_NORESERVEÌ65536Ö0 +MAP_POPULATEÌ65536Ö0 +MAP_PRIVATEÌ65536Ö0 +MAP_SHAREDÌ65536Ö0 +MAP_STACKÌ65536Ö0 +MAP_TYPEÌ65536Ö0 +MATH_ERREXCEPTÌ65536Ö0 +MATH_ERRNOÌ65536Ö0 +MAX_CANONÌ65536Ö0 +MAX_HANDLE_SZÌ65536Ö0 +MAX_INPUTÌ65536Ö0 +MB_CUR_MAXÌ65536Ö0 +MB_LEN_MAXÌ65536Ö0 +MCL_CURRENTÌ65536Ö0 +MCL_FUTUREÌ65536Ö0 +MCL_ONFAULTÌ65536Ö0 +MQ_PRIO_MAXÌ65536Ö0 +MREMAP_FIXEDÌ65536Ö0 +MREMAP_MAYMOVEÌ65536Ö0 +MS_ASYNCÌ65536Ö0 +MS_INVALIDATEÌ65536Ö0 +MS_SYNCÌ65536Ö0 +MULT_PARÌ4Îanon_enum_1Ö0 +M_1_PIÌ65536Ö0 +M_1_PIlÌ65536Ö0 +M_2_PIÌ65536Ö0 +M_2_PIlÌ65536Ö0 +M_2_SQRTPIÌ65536Ö0 +M_2_SQRTPIlÌ65536Ö0 +M_EÌ65536Ö0 +M_ElÌ65536Ö0 +M_LN10Ì65536Ö0 +M_LN10lÌ65536Ö0 +M_LN2Ì65536Ö0 +M_LN2lÌ65536Ö0 +M_LOG10EÌ65536Ö0 +M_LOG10ElÌ65536Ö0 +M_LOG2EÌ65536Ö0 +M_LOG2ElÌ65536Ö0 +M_PIÌ65536Ö0 +M_PI_2Ì65536Ö0 +M_PI_2lÌ65536Ö0 +M_PI_4Ì65536Ö0 +M_PI_4lÌ65536Ö0 +M_PIlÌ65536Ö0 +M_SQRT1_2Ì65536Ö0 +M_SQRT1_2lÌ65536Ö0 +M_SQRT2Ì65536Ö0 +M_SQRT2lÌ65536Ö0 +My_mmapÌ16Í(char *filename)Ö0Ïmmapbuf * +My_mmapÌ1024Í(char *filename)Ö0Ïmmapbuf * +My_munmapÌ16Í(mmapbuf *b)Ö0Ïvoid +My_munmapÌ1024Í(mmapbuf *b)Ö0Ïvoid +NAME_MAXÌ65536Ö0 +NANÌ65536Ö0 +NCCÌ65536Ö0 +NCCSÌ65536Ö0 +NEED_ARGÌ4Îanon_enum_1Ö0 +NFDBITSÌ65536Ö0 +NGROUPS_MAXÌ65536Ö0 +NL0Ì65536Ö0 +NL1Ì65536Ö0 +NLDLYÌ65536Ö0 +NL_ARGMAXÌ65536Ö0 +NL_LANGMAXÌ65536Ö0 +NL_MSGMAXÌ65536Ö0 +NL_NMAXÌ65536Ö0 +NL_SETMAXÌ65536Ö0 +NL_TEXTMAXÌ65536Ö0 +NOFLSHÌ65536Ö0 +NO_ARGSÌ4Îanon_enum_1Ö0 +NR_OPENÌ65536Ö0 +NULLÌ65536Ö0 +NZEROÌ65536Ö0 +N_Ì131072Í(String)Ö0 +N_6PACKÌ65536Ö0 +N_AX25Ì65536Ö0 +N_HCIÌ65536Ö0 +N_HDLCÌ65536Ö0 +N_IRDAÌ65536Ö0 +N_MASCÌ65536Ö0 +N_MOUSEÌ65536Ö0 +N_PPPÌ65536Ö0 +N_PROFIBUS_FDLÌ65536Ö0 +N_R3964Ì65536Ö0 +N_SLIPÌ65536Ö0 +N_SMSBLOCKÌ65536Ö0 +N_STRIPÌ65536Ö0 +N_SYNC_PPPÌ65536Ö0 +N_TTYÌ65536Ö0 +N_X25Ì65536Ö0 +OCRNLÌ65536Ö0 +OFDELÌ65536Ö0 +OFILLÌ65536Ö0 +OLCUCÌ65536Ö0 +OLDCOLORÌ65536Ö0 +ONLCRÌ65536Ö0 +ONLRETÌ65536Ö0 +ONOCRÌ65536Ö0 +OPEN_MAXÌ65536Ö0 +OPOSTÌ65536Ö0 +OPT_ARGÌ4Îanon_enum_1Ö0 +OVERFLOWÌ65536Ö0 +O_ACCMODEÌ65536Ö0 +O_APPENDÌ65536Ö0 +O_ASYNCÌ65536Ö0 +O_CLOEXECÌ65536Ö0 +O_CREATÌ65536Ö0 +O_DIRECTÌ65536Ö0 +O_DIRECTORYÌ65536Ö0 +O_DSYNCÌ65536Ö0 +O_EXCLÌ65536Ö0 +O_FSYNCÌ65536Ö0 +O_LARGEFILEÌ65536Ö0 +O_NDELAYÌ65536Ö0 +O_NOATIMEÌ65536Ö0 +O_NOCTTYÌ65536Ö0 +O_NOFOLLOWÌ65536Ö0 +O_NONBLOCKÌ65536Ö0 +O_PATHÌ65536Ö0 +O_RDONLYÌ65536Ö0 +O_RDWRÌ65536Ö0 +O_RSYNCÌ65536Ö0 +O_SYNCÌ65536Ö0 +O_TMPFILEÌ65536Ö0 +O_TRUNCÌ65536Ö0 +O_WRONLYÌ65536Ö0 +PARENBÌ65536Ö0 +PARMRKÌ65536Ö0 +PARODDÌ65536Ö0 +PATH_MAXÌ65536Ö0 +PDP_ENDIANÌ65536Ö0 +PENDINÌ65536Ö0 +PIPE_BUFÌ65536Ö0 +PLOSSÌ65536Ö0 +POSIX_FADV_DONTNEEDÌ65536Ö0 +POSIX_FADV_NOREUSEÌ65536Ö0 +POSIX_FADV_NORMALÌ65536Ö0 +POSIX_FADV_RANDOMÌ65536Ö0 +POSIX_FADV_SEQUENTIALÌ65536Ö0 +POSIX_FADV_WILLNEEDÌ65536Ö0 +POSIX_MADV_DONTNEEDÌ65536Ö0 +POSIX_MADV_NORMALÌ65536Ö0 +POSIX_MADV_RANDOMÌ65536Ö0 +POSIX_MADV_SEQUENTIALÌ65536Ö0 +POSIX_MADV_WILLNEEDÌ65536Ö0 +PROT_EXECÌ65536Ö0 +PROT_GROWSDOWNÌ65536Ö0 +PROT_GROWSUPÌ65536Ö0 +PROT_NONEÌ65536Ö0 +PROT_READÌ65536Ö0 +PROT_WRITEÌ65536Ö0 +PTHREAD_DESTRUCTOR_ITERATIONSÌ65536Ö0 +PTHREAD_KEYS_MAXÌ65536Ö0 +PTHREAD_STACK_MINÌ65536Ö0 +PTHREAD_THREADS_MAXÌ65536Ö0 +PTRDIFF_MAXÌ65536Ö0 +PTRDIFF_MINÌ65536Ö0 +P_tmpdirÌ65536Ö0 +RAND_MAXÌ65536Ö0 +REDÌ65536Ö0 +RE_DUP_MAXÌ65536Ö0 +RTSIG_MAXÌ65536Ö0 +R_OKÌ65536Ö0 +SCHAR_MAXÌ65536Ö0 +SCHAR_MINÌ65536Ö0 +SEEK_CURÌ65536Ö0 +SEEK_DATAÌ65536Ö0 +SEEK_ENDÌ65536Ö0 +SEEK_HOLEÌ65536Ö0 +SEEK_SETÌ65536Ö0 +SEM_VALUE_MAXÌ65536Ö0 +SHRT_MAXÌ65536Ö0 +SHRT_MINÌ65536Ö0 +SIG_ATOMIC_MAXÌ65536Ö0 +SIG_ATOMIC_MINÌ65536Ö0 +SINGÌ65536Ö0 +SIOCADDDLCIÌ65536Ö0 +SIOCADDMULTIÌ65536Ö0 +SIOCADDRTÌ65536Ö0 +SIOCDARPÌ65536Ö0 +SIOCDELDLCIÌ65536Ö0 +SIOCDELMULTIÌ65536Ö0 +SIOCDELRTÌ65536Ö0 +SIOCDEVPRIVATEÌ65536Ö0 +SIOCDIFADDRÌ65536Ö0 +SIOCDRARPÌ65536Ö0 +SIOCGARPÌ65536Ö0 +SIOCGIFADDRÌ65536Ö0 +SIOCGIFBRÌ65536Ö0 +SIOCGIFBRDADDRÌ65536Ö0 +SIOCGIFCONFÌ65536Ö0 +SIOCGIFCOUNTÌ65536Ö0 +SIOCGIFDSTADDRÌ65536Ö0 +SIOCGIFENCAPÌ65536Ö0 +SIOCGIFFLAGSÌ65536Ö0 +SIOCGIFHWADDRÌ65536Ö0 +SIOCGIFINDEXÌ65536Ö0 +SIOCGIFMAPÌ65536Ö0 +SIOCGIFMEMÌ65536Ö0 +SIOCGIFMETRICÌ65536Ö0 +SIOCGIFMTUÌ65536Ö0 +SIOCGIFNAMEÌ65536Ö0 +SIOCGIFNETMASKÌ65536Ö0 +SIOCGIFPFLAGSÌ65536Ö0 +SIOCGIFSLAVEÌ65536Ö0 +SIOCGIFTXQLENÌ65536Ö0 +SIOCGRARPÌ65536Ö0 +SIOCPROTOPRIVATEÌ65536Ö0 +SIOCRTMSGÌ65536Ö0 +SIOCSARPÌ65536Ö0 +SIOCSIFADDRÌ65536Ö0 +SIOCSIFBRÌ65536Ö0 +SIOCSIFBRDADDRÌ65536Ö0 +SIOCSIFDSTADDRÌ65536Ö0 +SIOCSIFENCAPÌ65536Ö0 +SIOCSIFFLAGSÌ65536Ö0 +SIOCSIFHWADDRÌ65536Ö0 +SIOCSIFHWBROADCASTÌ65536Ö0 +SIOCSIFLINKÌ65536Ö0 +SIOCSIFMAPÌ65536Ö0 +SIOCSIFMEMÌ65536Ö0 +SIOCSIFMETRICÌ65536Ö0 +SIOCSIFMTUÌ65536Ö0 +SIOCSIFNAMEÌ65536Ö0 +SIOCSIFNETMASKÌ65536Ö0 +SIOCSIFPFLAGSÌ65536Ö0 +SIOCSIFSLAVEÌ65536Ö0 +SIOCSIFTXQLENÌ65536Ö0 +SIOCSRARPÌ65536Ö0 +SIOGIFINDEXÌ65536Ö0 +SIZE_MAXÌ65536Ö0 +SPLICE_F_GIFTÌ65536Ö0 +SPLICE_F_MOREÌ65536Ö0 +SPLICE_F_MOVEÌ65536Ö0 +SPLICE_F_NONBLOCKÌ65536Ö0 +SSIZE_MAXÌ65536Ö0 +STDERR_FILENOÌ65536Ö0 +STDIN_FILENOÌ65536Ö0 +STDOUT_FILENOÌ65536Ö0 +SYNC_FILE_RANGE_WAIT_AFTERÌ65536Ö0 +SYNC_FILE_RANGE_WAIT_BEFOREÌ65536Ö0 +SYNC_FILE_RANGE_WRITEÌ65536Ö0 +S_BLKSIZEÌ65536Ö0 +S_IEXECÌ65536Ö0 +S_IFBLKÌ65536Ö0 +S_IFCHRÌ65536Ö0 +S_IFDIRÌ65536Ö0 +S_IFIFOÌ65536Ö0 +S_IFLNKÌ65536Ö0 +S_IFMTÌ65536Ö0 +S_IFREGÌ65536Ö0 +S_IFSOCKÌ65536Ö0 +S_IREADÌ65536Ö0 +S_IRGRPÌ65536Ö0 +S_IROTHÌ65536Ö0 +S_IRUSRÌ65536Ö0 +S_IRWXGÌ65536Ö0 +S_IRWXOÌ65536Ö0 +S_IRWXUÌ65536Ö0 +S_ISBLKÌ131072Í(mode)Ö0 +S_ISCHRÌ131072Í(mode)Ö0 +S_ISDIRÌ131072Í(mode)Ö0 +S_ISFIFOÌ131072Í(mode)Ö0 +S_ISGIDÌ65536Ö0 +S_ISLNKÌ131072Í(mode)Ö0 +S_ISREGÌ131072Í(mode)Ö0 +S_ISSOCKÌ131072Í(mode)Ö0 +S_ISUIDÌ65536Ö0 +S_ISVTXÌ65536Ö0 +S_IWGRPÌ65536Ö0 +S_IWOTHÌ65536Ö0 +S_IWRITEÌ65536Ö0 +S_IWUSRÌ65536Ö0 +S_IXGRPÌ65536Ö0 +S_IXOTHÌ65536Ö0 +S_IXUSRÌ65536Ö0 +S_TYPEISMQÌ131072Í(buf)Ö0 +S_TYPEISSEMÌ131072Í(buf)Ö0 +S_TYPEISSHMÌ131072Í(buf)Ö0 +TAB0Ì65536Ö0 +TAB1Ì65536Ö0 +TAB2Ì65536Ö0 +TAB3Ì65536Ö0 +TABDLYÌ65536Ö0 +TCFLSHÌ65536Ö0 +TCGETAÌ65536Ö0 +TCGETSÌ65536Ö0 +TCGETS2Ì65536Ö0 +TCGETXÌ65536Ö0 +TCIFLUSHÌ65536Ö0 +TCIOFFÌ65536Ö0 +TCIOFLUSHÌ65536Ö0 +TCIONÌ65536Ö0 +TCOFLUSHÌ65536Ö0 +TCOOFFÌ65536Ö0 +TCOONÌ65536Ö0 +TCSADRAINÌ65536Ö0 +TCSAFLUSHÌ65536Ö0 +TCSANOWÌ65536Ö0 +TCSBRKÌ65536Ö0 +TCSBRKPÌ65536Ö0 +TCSETAÌ65536Ö0 +TCSETAFÌ65536Ö0 +TCSETAWÌ65536Ö0 +TCSETSÌ65536Ö0 +TCSETS2Ì65536Ö0 +TCSETSFÌ65536Ö0 +TCSETSF2Ì65536Ö0 +TCSETSWÌ65536Ö0 +TCSETSW2Ì65536Ö0 +TCSETXÌ65536Ö0 +TCSETXFÌ65536Ö0 +TCSETXWÌ65536Ö0 +TCXONCÌ65536Ö0 +TEMP_FAILURE_RETRYÌ131072Í(expression)Ö0 +TIMESPEC_TO_TIMEVALÌ131072Í(tv,ts)Ö0 +TIMEVAL_TO_TIMESPECÌ131072Í(tv,ts)Ö0 +TIOCCBRKÌ65536Ö0 +TIOCCONSÌ65536Ö0 +TIOCEXCLÌ65536Ö0 +TIOCGDEVÌ65536Ö0 +TIOCGETDÌ65536Ö0 +TIOCGEXCLÌ65536Ö0 +TIOCGICOUNTÌ65536Ö0 +TIOCGLCKTRMIOSÌ65536Ö0 +TIOCGPGRPÌ65536Ö0 +TIOCGPKTÌ65536Ö0 +TIOCGPTLCKÌ65536Ö0 +TIOCGPTNÌ65536Ö0 +TIOCGRS485Ì65536Ö0 +TIOCGSERIALÌ65536Ö0 +TIOCGSIDÌ65536Ö0 +TIOCGSOFTCARÌ65536Ö0 +TIOCGWINSZÌ65536Ö0 +TIOCINQÌ65536Ö0 +TIOCLINUXÌ65536Ö0 +TIOCMBICÌ65536Ö0 +TIOCMBISÌ65536Ö0 +TIOCMGETÌ65536Ö0 +TIOCMIWAITÌ65536Ö0 +TIOCMSETÌ65536Ö0 +TIOCM_CARÌ65536Ö0 +TIOCM_CDÌ65536Ö0 +TIOCM_CTSÌ65536Ö0 +TIOCM_DSRÌ65536Ö0 +TIOCM_DTRÌ65536Ö0 +TIOCM_LEÌ65536Ö0 +TIOCM_RIÌ65536Ö0 +TIOCM_RNGÌ65536Ö0 +TIOCM_RTSÌ65536Ö0 +TIOCM_SRÌ65536Ö0 +TIOCM_STÌ65536Ö0 +TIOCNOTTYÌ65536Ö0 +TIOCNXCLÌ65536Ö0 +TIOCOUTQÌ65536Ö0 +TIOCPKTÌ65536Ö0 +TIOCPKT_DATAÌ65536Ö0 +TIOCPKT_DOSTOPÌ65536Ö0 +TIOCPKT_FLUSHREADÌ65536Ö0 +TIOCPKT_FLUSHWRITEÌ65536Ö0 +TIOCPKT_IOCTLÌ65536Ö0 +TIOCPKT_NOSTOPÌ65536Ö0 +TIOCPKT_STARTÌ65536Ö0 +TIOCPKT_STOPÌ65536Ö0 +TIOCSBRKÌ65536Ö0 +TIOCSCTTYÌ65536Ö0 +TIOCSERCONFIGÌ65536Ö0 +TIOCSERGETLSRÌ65536Ö0 +TIOCSERGETMULTIÌ65536Ö0 +TIOCSERGSTRUCTÌ65536Ö0 +TIOCSERGWILDÌ65536Ö0 +TIOCSERSETMULTIÌ65536Ö0 +TIOCSERSWILDÌ65536Ö0 +TIOCSER_TEMTÌ65536Ö0 +TIOCSETDÌ65536Ö0 +TIOCSIGÌ65536Ö0 +TIOCSLCKTRMIOSÌ65536Ö0 +TIOCSPGRPÌ65536Ö0 +TIOCSPTLCKÌ65536Ö0 +TIOCSRS485Ì65536Ö0 +TIOCSSERIALÌ65536Ö0 +TIOCSSOFTCARÌ65536Ö0 +TIOCSTIÌ65536Ö0 +TIOCSWINSZÌ65536Ö0 +TIOCVHANGUPÌ65536Ö0 +TLOSSÌ65536Ö0 +TMP_MAXÌ65536Ö0 +TOSTOPÌ65536Ö0 +TRANS_BADCHSUMÌ4Îanon_enum_5Ö0 +TRANS_SUCCEEDÌ4Îanon_enum_5Ö0 +TRANS_TIMEOUTÌ4Îanon_enum_5Ö0 +TRUEÌ65536Ö0 +TTYDEF_CFLAGÌ65536Ö0 +TTYDEF_IFLAGÌ65536Ö0 +TTYDEF_LFLAGÌ65536Ö0 +TTYDEF_OFLAGÌ65536Ö0 +TTYDEF_SPEEDÌ65536Ö0 +TTY_NAME_MAXÌ65536Ö0 +UCHAR_MAXÌ65536Ö0 +UINT16_CÌ131072Í(c)Ö0 +UINT16_MAXÌ65536Ö0 +UINT32_CÌ131072Í(c)Ö0 +UINT32_MAXÌ65536Ö0 +UINT64_CÌ131072Í(c)Ö0 +UINT64_MAXÌ65536Ö0 +UINT8_CÌ131072Í(c)Ö0 +UINT8_MAXÌ65536Ö0 +UINTMAX_CÌ131072Í(c)Ö0 +UINTMAX_MAXÌ65536Ö0 +UINTPTR_MAXÌ65536Ö0 +UINT_FAST16_MAXÌ65536Ö0 +UINT_FAST32_MAXÌ65536Ö0 +UINT_FAST64_MAXÌ65536Ö0 +UINT_FAST8_MAXÌ65536Ö0 +UINT_LEAST16_MAXÌ65536Ö0 +UINT_LEAST32_MAXÌ65536Ö0 +UINT_LEAST64_MAXÌ65536Ö0 +UINT_LEAST8_MAXÌ65536Ö0 +UINT_MAXÌ65536Ö0 +UIO_MAXIOVÌ65536Ö0 +ULLONG_MAXÌ65536Ö0 +ULONG_LONG_MAXÌ65536Ö0 +ULONG_MAXÌ65536Ö0 +UNDERFLOWÌ65536Ö0 +USHRT_MAXÌ65536Ö0 +UTIME_NOWÌ65536Ö0 +UTIME_OMITÌ65536Ö0 +VDISCARDÌ65536Ö0 +VEOFÌ65536Ö0 +VEOLÌ65536Ö0 +VEOL2Ì65536Ö0 +VERASEÌ65536Ö0 +VINTRÌ65536Ö0 +VKILLÌ65536Ö0 +VLNEXTÌ65536Ö0 +VMINÌ65536Ö0 +VQUITÌ65536Ö0 +VREPRINTÌ65536Ö0 +VSTARTÌ65536Ö0 +VSTOPÌ65536Ö0 +VSUSPÌ65536Ö0 +VSWTCÌ65536Ö0 +VT0Ì65536Ö0 +VT1Ì65536Ö0 +VTDLYÌ65536Ö0 +VTIMEÌ65536Ö0 +VWERASEÌ65536Ö0 +WARNÌ131072Í(...)Ö0 +WARNXÌ131072Í(...)Ö0 +WCHAR_MAXÌ65536Ö0 +WCHAR_MINÌ65536Ö0 +WCONTINUEDÌ65536Ö0 +WEXITEDÌ65536Ö0 +WEXITSTATUSÌ131072Í(status)Ö0 +WIFCONTINUEDÌ131072Í(status)Ö0 +WIFEXITEDÌ131072Í(status)Ö0 +WIFSIGNALEDÌ131072Í(status)Ö0 +WIFSTOPPEDÌ131072Í(status)Ö0 +WINT_MAXÌ65536Ö0 +WINT_MINÌ65536Ö0 +WNOHANGÌ65536Ö0 +WNOWAITÌ65536Ö0 +WORD_BITÌ65536Ö0 +WSTOPPEDÌ65536Ö0 +WSTOPSIGÌ131072Í(status)Ö0 +WTERMSIGÌ131072Í(status)Ö0 +WUNTRACEDÌ65536Ö0 +W_OKÌ65536Ö0 +XATTR_LIST_MAXÌ65536Ö0 +XATTR_NAME_MAXÌ65536Ö0 +XATTR_SIZE_MAXÌ65536Ö0 +XCASEÌ65536Ö0 +XTABSÌ65536Ö0 +X_OKÌ65536Ö0 +X_TLOSSÌ65536Ö0 +_Ì131072Í(String)Ö0 +_ALLOCA_HÌ65536Ö0 +_ANSI_STDARG_H_Ì65536Ö0 +_ASM_GENERIC_ERRNO_BASE_HÌ65536Ö0 +_ASM_GENERIC_ERRNO_HÌ65536Ö0 +_ASM_GENERIC_IOCTL_HÌ65536Ö0 +_ASSERT_HÌ65536Ö0 +_ATFILE_SOURCEÌ65536Ö0 +_BITS_BYTESWAP_HÌ65536Ö0 +_BITS_LIBM_SIMD_DECL_STUBS_HÌ65536Ö0 +_BITS_LOCALE_HÌ65536Ö0 +_BITS_POSIX1_LIM_HÌ65536Ö0 +_BITS_POSIX2_LIM_HÌ65536Ö0 +_BITS_POSIX_OPT_HÌ65536Ö0 +_BITS_PTHREADTYPES_HÌ65536Ö0 +_BITS_STAT_HÌ65536Ö0 +_BITS_TYPESIZES_HÌ65536Ö0 +_BITS_TYPES_HÌ65536Ö0 +_BITS_UIO_HÌ65536Ö0 +_BITS_WCHAR_HÌ65536Ö0 +_BSD_SIZE_T_Ì65536Ö0 +_BSD_SIZE_T_DEFINED_Ì65536Ö0 +_BSD_WCHAR_T_Ì65536Ö0 +_BoolÌ65536Ö0 +_CS_GNU_LIBC_VERSIONÌ65536Ö0 +_CS_GNU_LIBPTHREAD_VERSIONÌ65536Ö0 +_CS_LFS64_CFLAGSÌ65536Ö0 +_CS_LFS64_LDFLAGSÌ65536Ö0 +_CS_LFS64_LIBSÌ65536Ö0 +_CS_LFS64_LINTFLAGSÌ65536Ö0 +_CS_LFS_CFLAGSÌ65536Ö0 +_CS_LFS_LDFLAGSÌ65536Ö0 +_CS_LFS_LIBSÌ65536Ö0 +_CS_LFS_LINTFLAGSÌ65536Ö0 +_CS_PATHÌ65536Ö0 +_CS_POSIX_V5_WIDTH_RESTRICTED_ENVSÌ65536Ö0 +_CS_POSIX_V6_ILP32_OFF32_CFLAGSÌ65536Ö0 +_CS_POSIX_V6_ILP32_OFF32_LDFLAGSÌ65536Ö0 +_CS_POSIX_V6_ILP32_OFF32_LIBSÌ65536Ö0 +_CS_POSIX_V6_ILP32_OFF32_LINTFLAGSÌ65536Ö0 +_CS_POSIX_V6_ILP32_OFFBIG_CFLAGSÌ65536Ö0 +_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGSÌ65536Ö0 +_CS_POSIX_V6_ILP32_OFFBIG_LIBSÌ65536Ö0 +_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGSÌ65536Ö0 +_CS_POSIX_V6_LP64_OFF64_CFLAGSÌ65536Ö0 +_CS_POSIX_V6_LP64_OFF64_LDFLAGSÌ65536Ö0 +_CS_POSIX_V6_LP64_OFF64_LIBSÌ65536Ö0 +_CS_POSIX_V6_LP64_OFF64_LINTFLAGSÌ65536Ö0 +_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGSÌ65536Ö0 +_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGSÌ65536Ö0 +_CS_POSIX_V6_LPBIG_OFFBIG_LIBSÌ65536Ö0 +_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGSÌ65536Ö0 +_CS_POSIX_V6_WIDTH_RESTRICTED_ENVSÌ65536Ö0 +_CS_POSIX_V7_ILP32_OFF32_CFLAGSÌ65536Ö0 +_CS_POSIX_V7_ILP32_OFF32_LDFLAGSÌ65536Ö0 +_CS_POSIX_V7_ILP32_OFF32_LIBSÌ65536Ö0 +_CS_POSIX_V7_ILP32_OFF32_LINTFLAGSÌ65536Ö0 +_CS_POSIX_V7_ILP32_OFFBIG_CFLAGSÌ65536Ö0 +_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGSÌ65536Ö0 +_CS_POSIX_V7_ILP32_OFFBIG_LIBSÌ65536Ö0 +_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGSÌ65536Ö0 +_CS_POSIX_V7_LP64_OFF64_CFLAGSÌ65536Ö0 +_CS_POSIX_V7_LP64_OFF64_LDFLAGSÌ65536Ö0 +_CS_POSIX_V7_LP64_OFF64_LIBSÌ65536Ö0 +_CS_POSIX_V7_LP64_OFF64_LINTFLAGSÌ65536Ö0 +_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGSÌ65536Ö0 +_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGSÌ65536Ö0 +_CS_POSIX_V7_LPBIG_OFFBIG_LIBSÌ65536Ö0 +_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGSÌ65536Ö0 +_CS_POSIX_V7_WIDTH_RESTRICTED_ENVSÌ65536Ö0 +_CS_V5_WIDTH_RESTRICTED_ENVSÌ65536Ö0 +_CS_V6_ENVÌ65536Ö0 +_CS_V6_WIDTH_RESTRICTED_ENVSÌ65536Ö0 +_CS_V7_ENVÌ65536Ö0 +_CS_V7_WIDTH_RESTRICTED_ENVSÌ65536Ö0 +_CS_XBS5_ILP32_OFF32_CFLAGSÌ65536Ö0 +_CS_XBS5_ILP32_OFF32_LDFLAGSÌ65536Ö0 +_CS_XBS5_ILP32_OFF32_LIBSÌ65536Ö0 +_CS_XBS5_ILP32_OFF32_LINTFLAGSÌ65536Ö0 +_CS_XBS5_ILP32_OFFBIG_CFLAGSÌ65536Ö0 +_CS_XBS5_ILP32_OFFBIG_LDFLAGSÌ65536Ö0 +_CS_XBS5_ILP32_OFFBIG_LIBSÌ65536Ö0 +_CS_XBS5_ILP32_OFFBIG_LINTFLAGSÌ65536Ö0 +_CS_XBS5_LP64_OFF64_CFLAGSÌ65536Ö0 +_CS_XBS5_LP64_OFF64_LDFLAGSÌ65536Ö0 +_CS_XBS5_LP64_OFF64_LIBSÌ65536Ö0 +_CS_XBS5_LP64_OFF64_LINTFLAGSÌ65536Ö0 +_CS_XBS5_LPBIG_OFFBIG_CFLAGSÌ65536Ö0 +_CS_XBS5_LPBIG_OFFBIG_LDFLAGSÌ65536Ö0 +_CS_XBS5_LPBIG_OFFBIG_LIBSÌ65536Ö0 +_CS_XBS5_LPBIG_OFFBIG_LINTFLAGSÌ65536Ö0 +_CTYPE_HÌ65536Ö0 +_DEFAULT_SOURCEÌ65536Ö0 +_ENDIAN_HÌ65536Ö0 +_ERRNO_HÌ65536Ö0 +_ERR_HÌ65536Ö0 +_FCNTL_HÌ65536Ö0 +_FEATURES_HÌ65536Ö0 +_FORTIFY_SOURCEÌ65536Ö0 +_GCC_LIMITS_H_Ì65536Ö0 +_GCC_NEXT_LIMITS_HÌ65536Ö0 +_GCC_SIZE_TÌ65536Ö0 +_GCC_WCHAR_TÌ65536Ö0 +_GCC_WRAP_STDINT_HÌ65536Ö0 +_GETOPT_HÌ65536Ö0 +_GNU_SOURCEÌ65536Ö0 +_G_BUFSIZÌ65536Ö0 +_G_HAVE_MMAPÌ65536Ö0 +_G_HAVE_MREMAPÌ65536Ö0 +_G_HAVE_ST_BLKSIZEÌ65536Ö0 +_G_IO_IO_FILE_VERSIONÌ65536Ö0 +_G_config_hÌ65536Ö0 +_G_va_listÌ65536Ö0 +_HAVE_STRUCT_TERMIOS_C_ISPEEDÌ65536Ö0 +_HAVE_STRUCT_TERMIOS_C_OSPEEDÌ65536Ö0 +_IOÌ131072Í(type,nr)Ö0 +_IOCÌ131072Í(dir,type,nr,size)Ö0 +_IOC_DIRÌ131072Í(nr)Ö0 +_IOC_DIRBITSÌ65536Ö0 +_IOC_DIRMASKÌ65536Ö0 +_IOC_DIRSHIFTÌ65536Ö0 +_IOC_NONEÌ65536Ö0 +_IOC_NRÌ131072Í(nr)Ö0 +_IOC_NRBITSÌ65536Ö0 +_IOC_NRMASKÌ65536Ö0 +_IOC_NRSHIFTÌ65536Ö0 +_IOC_READÌ65536Ö0 +_IOC_SIZEÌ131072Í(nr)Ö0 +_IOC_SIZEBITSÌ65536Ö0 +_IOC_SIZEMASKÌ65536Ö0 +_IOC_SIZESHIFTÌ65536Ö0 +_IOC_TYPEÌ131072Í(nr)Ö0 +_IOC_TYPEBITSÌ65536Ö0 +_IOC_TYPECHECKÌ131072Í(t)Ö0 +_IOC_TYPEMASKÌ65536Ö0 +_IOC_TYPESHIFTÌ65536Ö0 +_IOC_WRITEÌ65536Ö0 +_IOFBFÌ65536Ö0 +_IOLBFÌ65536Ö0 +_IONBFÌ65536Ö0 +_IORÌ131072Í(type,nr,size)Ö0 +_IOR_BADÌ131072Í(type,nr,size)Ö0 +_IOS_APPENDÌ65536Ö0 +_IOS_ATENDÌ65536Ö0 +_IOS_BINÌ65536Ö0 +_IOS_INPUTÌ65536Ö0 +_IOS_NOCREATEÌ65536Ö0 +_IOS_NOREPLACEÌ65536Ö0 +_IOS_OUTPUTÌ65536Ö0 +_IOS_TRUNCÌ65536Ö0 +_IOT_termiosÌ65536Ö0 +_IOWÌ131072Í(type,nr,size)Ö0 +_IOWRÌ131072Í(type,nr,size)Ö0 +_IOWR_BADÌ131072Í(type,nr,size)Ö0 +_IOW_BADÌ131072Í(type,nr,size)Ö0 +_IO_BAD_SEENÌ65536Ö0 +_IO_BEÌ131072Í(expr,res)Ö0 +_IO_BOOLALPHAÌ65536Ö0 +_IO_BUFSIZÌ65536Ö0 +_IO_CURRENTLY_PUTTINGÌ65536Ö0 +_IO_DECÌ65536Ö0 +_IO_DELETE_DONT_CLOSEÌ65536Ö0 +_IO_DONT_CLOSEÌ65536Ö0 +_IO_EOF_SEENÌ65536Ö0 +_IO_ERR_SEENÌ65536Ö0 +_IO_FIXEDÌ65536Ö0 +_IO_FLAGS2_MMAPÌ65536Ö0 +_IO_FLAGS2_NOTCANCELÌ65536Ö0 +_IO_FLAGS2_USER_WBUFÌ65536Ö0 +_IO_HAVE_ST_BLKSIZEÌ65536Ö0 +_IO_HEXÌ65536Ö0 +_IO_INTERNALÌ65536Ö0 +_IO_IN_BACKUPÌ65536Ö0 +_IO_IS_APPENDINGÌ65536Ö0 +_IO_IS_FILEBUFÌ65536Ö0 +_IO_LEFTÌ65536Ö0 +_IO_LINE_BUFÌ65536Ö0 +_IO_LINKEDÌ65536Ö0 +_IO_MAGICÌ65536Ö0 +_IO_MAGIC_MASKÌ65536Ö0 +_IO_NO_READSÌ65536Ö0 +_IO_NO_WRITESÌ65536Ö0 +_IO_OCTÌ65536Ö0 +_IO_PENDING_OUTPUT_COUNTÌ131072Í(_fp)Ö0 +_IO_RIGHTÌ65536Ö0 +_IO_SCIENTIFICÌ65536Ö0 +_IO_SHOWBASEÌ65536Ö0 +_IO_SHOWPOINTÌ65536Ö0 +_IO_SHOWPOSÌ65536Ö0 +_IO_SKIPWSÌ65536Ö0 +_IO_STDIOÌ65536Ö0 +_IO_STDIO_HÌ65536Ö0 +_IO_TIED_PUT_GETÌ65536Ö0 +_IO_UNBUFFEREDÌ65536Ö0 +_IO_UNIFIED_JUMPTABLESÌ65536Ö0 +_IO_UNITBUFÌ65536Ö0 +_IO_UPPERCASEÌ65536Ö0 +_IO_USER_BUFÌ65536Ö0 +_IO_USER_LOCKÌ65536Ö0 +_IO_cleanup_region_endÌ131072Í(_Doit)Ö0 +_IO_cleanup_region_startÌ131072Í(_fct,_fp)Ö0 +_IO_feof_unlockedÌ131072Í(__fp)Ö0 +_IO_ferror_unlockedÌ131072Í(__fp)Ö0 +_IO_file_flagsÌ65536Ö0 +_IO_flockfileÌ131072Í(_fp)Ö0 +_IO_fpos64_tÌ65536Ö0 +_IO_fpos_tÌ65536Ö0 +_IO_ftrylockfileÌ131072Í(_fp)Ö0 +_IO_funlockfileÌ131072Í(_fp)Ö0 +_IO_getc_unlockedÌ131072Í(_fp)Ö0 +_IO_iconv_tÌ65536Ö0 +_IO_off64_tÌ65536Ö0 +_IO_off_tÌ65536Ö0 +_IO_peekcÌ131072Í(_fp)Ö0 +_IO_peekc_unlockedÌ131072Í(_fp)Ö0 +_IO_pid_tÌ65536Ö0 +_IO_putc_unlockedÌ131072Í(_ch,_fp)Ö0 +_IO_size_tÌ65536Ö0 +_IO_ssize_tÌ65536Ö0 +_IO_stderrÌ65536Ö0 +_IO_stdinÌ65536Ö0 +_IO_stdoutÌ65536Ö0 +_IO_uid_tÌ65536Ö0 +_IO_va_listÌ65536Ö0 +_IO_wint_tÌ65536Ö0 +_ISOC11_SOURCEÌ65536Ö0 +_ISOC95_SOURCEÌ65536Ö0 +_ISOC99_SOURCEÌ65536Ö0 +_ISbitÌ131072Í(bit)Ö0 +_LARGEFILE64_SOURCEÌ65536Ö0 +_LARGEFILE_SOURCEÌ65536Ö0 +_LFS64_ASYNCHRONOUS_IOÌ65536Ö0 +_LFS64_LARGEFILEÌ65536Ö0 +_LFS64_STDIOÌ65536Ö0 +_LFS_ASYNCHRONOUS_IOÌ65536Ö0 +_LFS_LARGEFILEÌ65536Ö0 +_LIBC_LIMITS_H_Ì65536Ö0 +_LIBINTL_HÌ65536Ö0 +_LIMITS_H___Ì65536Ö0 +_LINUX_IOCTL_HÌ65536Ö0 +_LINUX_LIMITS_HÌ65536Ö0 +_LOCALE_HÌ65536Ö0 +_LP64Ì65536Ö0 +_MATH_HÌ65536Ö0 +_MATH_H_MATHDEFÌ65536Ö0 +_MKNOD_VERÌ65536Ö0 +_MKNOD_VER_LINUXÌ65536Ö0 +_Mdouble_Ì65536Ö0 +_Mdouble_BEGIN_NAMESPACEÌ65536Ö0 +_Mdouble_END_NAMESPACEÌ65536Ö0 +_Mfloat_Ì65536Ö0 +_Mlong_double_Ì65536Ö0 +_OLD_STDIO_MAGICÌ65536Ö0 +_PC_2_SYMLINKSÌ65536Ö0 +_PC_ALLOC_SIZE_MINÌ65536Ö0 +_PC_ASYNC_IOÌ65536Ö0 +_PC_CHOWN_RESTRICTEDÌ65536Ö0 +_PC_FILESIZEBITSÌ65536Ö0 +_PC_LINK_MAXÌ65536Ö0 +_PC_MAX_CANONÌ65536Ö0 +_PC_MAX_INPUTÌ65536Ö0 +_PC_NAME_MAXÌ65536Ö0 +_PC_NO_TRUNCÌ65536Ö0 +_PC_PATH_MAXÌ65536Ö0 +_PC_PIPE_BUFÌ65536Ö0 +_PC_PRIO_IOÌ65536Ö0 +_PC_REC_INCR_XFER_SIZEÌ65536Ö0 +_PC_REC_MAX_XFER_SIZEÌ65536Ö0 +_PC_REC_MIN_XFER_SIZEÌ65536Ö0 +_PC_REC_XFER_ALIGNÌ65536Ö0 +_PC_SOCK_MAXBUFÌ65536Ö0 +_PC_SYMLINK_MAXÌ65536Ö0 +_PC_SYNC_IOÌ65536Ö0 +_PC_VDISABLEÌ65536Ö0 +_POSIX2_BC_BASE_MAXÌ65536Ö0 +_POSIX2_BC_DIM_MAXÌ65536Ö0 +_POSIX2_BC_SCALE_MAXÌ65536Ö0 +_POSIX2_BC_STRING_MAXÌ65536Ö0 +_POSIX2_CHARCLASS_NAME_MAXÌ65536Ö0 +_POSIX2_CHAR_TERMÌ65536Ö0 +_POSIX2_COLL_WEIGHTS_MAXÌ65536Ö0 +_POSIX2_C_BINDÌ65536Ö0 +_POSIX2_C_DEVÌ65536Ö0 +_POSIX2_C_VERSIONÌ65536Ö0 +_POSIX2_EXPR_NEST_MAXÌ65536Ö0 +_POSIX2_LINE_MAXÌ65536Ö0 +_POSIX2_LOCALEDEFÌ65536Ö0 +_POSIX2_RE_DUP_MAXÌ65536Ö0 +_POSIX2_SW_DEVÌ65536Ö0 +_POSIX2_VERSIONÌ65536Ö0 +_POSIX_ADVISORY_INFOÌ65536Ö0 +_POSIX_AIO_LISTIO_MAXÌ65536Ö0 +_POSIX_AIO_MAXÌ65536Ö0 +_POSIX_ARG_MAXÌ65536Ö0 +_POSIX_ASYNCHRONOUS_IOÌ65536Ö0 +_POSIX_ASYNC_IOÌ65536Ö0 +_POSIX_BARRIERSÌ65536Ö0 +_POSIX_CHILD_MAXÌ65536Ö0 +_POSIX_CHOWN_RESTRICTEDÌ65536Ö0 +_POSIX_CLOCKRES_MINÌ65536Ö0 +_POSIX_CLOCK_SELECTIONÌ65536Ö0 +_POSIX_CPUTIMEÌ65536Ö0 +_POSIX_C_SOURCEÌ65536Ö0 +_POSIX_DELAYTIMER_MAXÌ65536Ö0 +_POSIX_FD_SETSIZEÌ65536Ö0 +_POSIX_FSYNCÌ65536Ö0 +_POSIX_HIWATÌ65536Ö0 +_POSIX_HOST_NAME_MAXÌ65536Ö0 +_POSIX_IPV6Ì65536Ö0 +_POSIX_JOB_CONTROLÌ65536Ö0 +_POSIX_LINK_MAXÌ65536Ö0 +_POSIX_LOGIN_NAME_MAXÌ65536Ö0 +_POSIX_MAPPED_FILESÌ65536Ö0 +_POSIX_MAX_CANONÌ65536Ö0 +_POSIX_MAX_INPUTÌ65536Ö0 +_POSIX_MEMLOCKÌ65536Ö0 +_POSIX_MEMLOCK_RANGEÌ65536Ö0 +_POSIX_MEMORY_PROTECTIONÌ65536Ö0 +_POSIX_MESSAGE_PASSINGÌ65536Ö0 +_POSIX_MONOTONIC_CLOCKÌ65536Ö0 +_POSIX_MQ_OPEN_MAXÌ65536Ö0 +_POSIX_MQ_PRIO_MAXÌ65536Ö0 +_POSIX_NAME_MAXÌ65536Ö0 +_POSIX_NGROUPS_MAXÌ65536Ö0 +_POSIX_NO_TRUNCÌ65536Ö0 +_POSIX_OPEN_MAXÌ65536Ö0 +_POSIX_PATH_MAXÌ65536Ö0 +_POSIX_PIPE_BUFÌ65536Ö0 +_POSIX_PRIORITIZED_IOÌ65536Ö0 +_POSIX_PRIORITY_SCHEDULINGÌ65536Ö0 +_POSIX_QLIMITÌ65536Ö0 +_POSIX_RAW_SOCKETSÌ65536Ö0 +_POSIX_READER_WRITER_LOCKSÌ65536Ö0 +_POSIX_REALTIME_SIGNALSÌ65536Ö0 +_POSIX_REENTRANT_FUNCTIONSÌ65536Ö0 +_POSIX_REGEXPÌ65536Ö0 +_POSIX_RE_DUP_MAXÌ65536Ö0 +_POSIX_RTSIG_MAXÌ65536Ö0 +_POSIX_SAVED_IDSÌ65536Ö0 +_POSIX_SEMAPHORESÌ65536Ö0 +_POSIX_SEM_NSEMS_MAXÌ65536Ö0 +_POSIX_SEM_VALUE_MAXÌ65536Ö0 +_POSIX_SHARED_MEMORY_OBJECTSÌ65536Ö0 +_POSIX_SHELLÌ65536Ö0 +_POSIX_SIGQUEUE_MAXÌ65536Ö0 +_POSIX_SOURCEÌ65536Ö0 +_POSIX_SPAWNÌ65536Ö0 +_POSIX_SPIN_LOCKSÌ65536Ö0 +_POSIX_SPORADIC_SERVERÌ65536Ö0 +_POSIX_SSIZE_MAXÌ65536Ö0 +_POSIX_STREAM_MAXÌ65536Ö0 +_POSIX_SYMLINK_MAXÌ65536Ö0 +_POSIX_SYMLOOP_MAXÌ65536Ö0 +_POSIX_SYNCHRONIZED_IOÌ65536Ö0 +_POSIX_THREADSÌ65536Ö0 +_POSIX_THREAD_ATTR_STACKADDRÌ65536Ö0 +_POSIX_THREAD_ATTR_STACKSIZEÌ65536Ö0 +_POSIX_THREAD_CPUTIMEÌ65536Ö0 +_POSIX_THREAD_DESTRUCTOR_ITERATIONSÌ65536Ö0 +_POSIX_THREAD_KEYS_MAXÌ65536Ö0 +_POSIX_THREAD_PRIORITY_SCHEDULINGÌ65536Ö0 +_POSIX_THREAD_PRIO_INHERITÌ65536Ö0 +_POSIX_THREAD_PRIO_PROTECTÌ65536Ö0 +_POSIX_THREAD_PROCESS_SHAREDÌ65536Ö0 +_POSIX_THREAD_ROBUST_PRIO_INHERITÌ65536Ö0 +_POSIX_THREAD_ROBUST_PRIO_PROTECTÌ65536Ö0 +_POSIX_THREAD_SAFE_FUNCTIONSÌ65536Ö0 +_POSIX_THREAD_SPORADIC_SERVERÌ65536Ö0 +_POSIX_THREAD_THREADS_MAXÌ65536Ö0 +_POSIX_TIMEOUTSÌ65536Ö0 +_POSIX_TIMERSÌ65536Ö0 +_POSIX_TIMER_MAXÌ65536Ö0 +_POSIX_TRACEÌ65536Ö0 +_POSIX_TRACE_EVENT_FILTERÌ65536Ö0 +_POSIX_TRACE_INHERITÌ65536Ö0 +_POSIX_TRACE_LOGÌ65536Ö0 +_POSIX_TTY_NAME_MAXÌ65536Ö0 +_POSIX_TYPED_MEMORY_OBJECTSÌ65536Ö0 +_POSIX_TZNAME_MAXÌ65536Ö0 +_POSIX_UIO_MAXIOVÌ65536Ö0 +_POSIX_V6_LP64_OFF64Ì65536Ö0 +_POSIX_V6_LPBIG_OFFBIGÌ65536Ö0 +_POSIX_V7_LP64_OFF64Ì65536Ö0 +_POSIX_V7_LPBIG_OFFBIGÌ65536Ö0 +_POSIX_VDISABLEÌ65536Ö0 +_POSIX_VERSIONÌ65536Ö0 +_SC_2_CHAR_TERMÌ65536Ö0 +_SC_2_C_BINDÌ65536Ö0 +_SC_2_C_DEVÌ65536Ö0 +_SC_2_C_VERSIONÌ65536Ö0 +_SC_2_FORT_DEVÌ65536Ö0 +_SC_2_FORT_RUNÌ65536Ö0 +_SC_2_LOCALEDEFÌ65536Ö0 +_SC_2_PBSÌ65536Ö0 +_SC_2_PBS_ACCOUNTINGÌ65536Ö0 +_SC_2_PBS_CHECKPOINTÌ65536Ö0 +_SC_2_PBS_LOCATEÌ65536Ö0 +_SC_2_PBS_MESSAGEÌ65536Ö0 +_SC_2_PBS_TRACKÌ65536Ö0 +_SC_2_SW_DEVÌ65536Ö0 +_SC_2_UPEÌ65536Ö0 +_SC_2_VERSIONÌ65536Ö0 +_SC_ADVISORY_INFOÌ65536Ö0 +_SC_AIO_LISTIO_MAXÌ65536Ö0 +_SC_AIO_MAXÌ65536Ö0 +_SC_AIO_PRIO_DELTA_MAXÌ65536Ö0 +_SC_ARG_MAXÌ65536Ö0 +_SC_ASYNCHRONOUS_IOÌ65536Ö0 +_SC_ATEXIT_MAXÌ65536Ö0 +_SC_AVPHYS_PAGESÌ65536Ö0 +_SC_BARRIERSÌ65536Ö0 +_SC_BASEÌ65536Ö0 +_SC_BC_BASE_MAXÌ65536Ö0 +_SC_BC_DIM_MAXÌ65536Ö0 +_SC_BC_SCALE_MAXÌ65536Ö0 +_SC_BC_STRING_MAXÌ65536Ö0 +_SC_CHARCLASS_NAME_MAXÌ65536Ö0 +_SC_CHAR_BITÌ65536Ö0 +_SC_CHAR_MAXÌ65536Ö0 +_SC_CHAR_MINÌ65536Ö0 +_SC_CHILD_MAXÌ65536Ö0 +_SC_CLK_TCKÌ65536Ö0 +_SC_CLOCK_SELECTIONÌ65536Ö0 +_SC_COLL_WEIGHTS_MAXÌ65536Ö0 +_SC_CPUTIMEÌ65536Ö0 +_SC_C_LANG_SUPPORTÌ65536Ö0 +_SC_C_LANG_SUPPORT_RÌ65536Ö0 +_SC_DELAYTIMER_MAXÌ65536Ö0 +_SC_DEVICE_IOÌ65536Ö0 +_SC_DEVICE_SPECIFICÌ65536Ö0 +_SC_DEVICE_SPECIFIC_RÌ65536Ö0 +_SC_EQUIV_CLASS_MAXÌ65536Ö0 +_SC_EXPR_NEST_MAXÌ65536Ö0 +_SC_FD_MGMTÌ65536Ö0 +_SC_FIFOÌ65536Ö0 +_SC_FILE_ATTRIBUTESÌ65536Ö0 +_SC_FILE_LOCKINGÌ65536Ö0 +_SC_FILE_SYSTEMÌ65536Ö0 +_SC_FSYNCÌ65536Ö0 +_SC_GETGR_R_SIZE_MAXÌ65536Ö0 +_SC_GETPW_R_SIZE_MAXÌ65536Ö0 +_SC_HOST_NAME_MAXÌ65536Ö0 +_SC_INT_MAXÌ65536Ö0 +_SC_INT_MINÌ65536Ö0 +_SC_IOV_MAXÌ65536Ö0 +_SC_IPV6Ì65536Ö0 +_SC_JOB_CONTROLÌ65536Ö0 +_SC_LEVEL1_DCACHE_ASSOCÌ65536Ö0 +_SC_LEVEL1_DCACHE_LINESIZEÌ65536Ö0 +_SC_LEVEL1_DCACHE_SIZEÌ65536Ö0 +_SC_LEVEL1_ICACHE_ASSOCÌ65536Ö0 +_SC_LEVEL1_ICACHE_LINESIZEÌ65536Ö0 +_SC_LEVEL1_ICACHE_SIZEÌ65536Ö0 +_SC_LEVEL2_CACHE_ASSOCÌ65536Ö0 +_SC_LEVEL2_CACHE_LINESIZEÌ65536Ö0 +_SC_LEVEL2_CACHE_SIZEÌ65536Ö0 +_SC_LEVEL3_CACHE_ASSOCÌ65536Ö0 +_SC_LEVEL3_CACHE_LINESIZEÌ65536Ö0 +_SC_LEVEL3_CACHE_SIZEÌ65536Ö0 +_SC_LEVEL4_CACHE_ASSOCÌ65536Ö0 +_SC_LEVEL4_CACHE_LINESIZEÌ65536Ö0 +_SC_LEVEL4_CACHE_SIZEÌ65536Ö0 +_SC_LINE_MAXÌ65536Ö0 +_SC_LOGIN_NAME_MAXÌ65536Ö0 +_SC_LONG_BITÌ65536Ö0 +_SC_MAPPED_FILESÌ65536Ö0 +_SC_MB_LEN_MAXÌ65536Ö0 +_SC_MEMLOCKÌ65536Ö0 +_SC_MEMLOCK_RANGEÌ65536Ö0 +_SC_MEMORY_PROTECTIONÌ65536Ö0 +_SC_MESSAGE_PASSINGÌ65536Ö0 +_SC_MONOTONIC_CLOCKÌ65536Ö0 +_SC_MQ_OPEN_MAXÌ65536Ö0 +_SC_MQ_PRIO_MAXÌ65536Ö0 +_SC_MULTI_PROCESSÌ65536Ö0 +_SC_NETWORKINGÌ65536Ö0 +_SC_NGROUPS_MAXÌ65536Ö0 +_SC_NL_ARGMAXÌ65536Ö0 +_SC_NL_LANGMAXÌ65536Ö0 +_SC_NL_MSGMAXÌ65536Ö0 +_SC_NL_NMAXÌ65536Ö0 +_SC_NL_SETMAXÌ65536Ö0 +_SC_NL_TEXTMAXÌ65536Ö0 +_SC_NPROCESSORS_CONFÌ65536Ö0 +_SC_NPROCESSORS_ONLNÌ65536Ö0 +_SC_NZEROÌ65536Ö0 +_SC_OPEN_MAXÌ65536Ö0 +_SC_PAGESIZEÌ65536Ö0 +_SC_PAGE_SIZEÌ65536Ö0 +_SC_PASS_MAXÌ65536Ö0 +_SC_PHYS_PAGESÌ65536Ö0 +_SC_PIIÌ65536Ö0 +_SC_PII_INTERNETÌ65536Ö0 +_SC_PII_INTERNET_DGRAMÌ65536Ö0 +_SC_PII_INTERNET_STREAMÌ65536Ö0 +_SC_PII_OSIÌ65536Ö0 +_SC_PII_OSI_CLTSÌ65536Ö0 +_SC_PII_OSI_COTSÌ65536Ö0 +_SC_PII_OSI_MÌ65536Ö0 +_SC_PII_SOCKETÌ65536Ö0 +_SC_PII_XTIÌ65536Ö0 +_SC_PIPEÌ65536Ö0 +_SC_POLLÌ65536Ö0 +_SC_PRIORITIZED_IOÌ65536Ö0 +_SC_PRIORITY_SCHEDULINGÌ65536Ö0 +_SC_RAW_SOCKETSÌ65536Ö0 +_SC_READER_WRITER_LOCKSÌ65536Ö0 +_SC_REALTIME_SIGNALSÌ65536Ö0 +_SC_REGEXPÌ65536Ö0 +_SC_REGEX_VERSIONÌ65536Ö0 +_SC_RE_DUP_MAXÌ65536Ö0 +_SC_RTSIG_MAXÌ65536Ö0 +_SC_SAVED_IDSÌ65536Ö0 +_SC_SCHAR_MAXÌ65536Ö0 +_SC_SCHAR_MINÌ65536Ö0 +_SC_SELECTÌ65536Ö0 +_SC_SEMAPHORESÌ65536Ö0 +_SC_SEM_NSEMS_MAXÌ65536Ö0 +_SC_SEM_VALUE_MAXÌ65536Ö0 +_SC_SHARED_MEMORY_OBJECTSÌ65536Ö0 +_SC_SHELLÌ65536Ö0 +_SC_SHRT_MAXÌ65536Ö0 +_SC_SHRT_MINÌ65536Ö0 +_SC_SIGNALSÌ65536Ö0 +_SC_SIGQUEUE_MAXÌ65536Ö0 +_SC_SINGLE_PROCESSÌ65536Ö0 +_SC_SPAWNÌ65536Ö0 +_SC_SPIN_LOCKSÌ65536Ö0 +_SC_SPORADIC_SERVERÌ65536Ö0 +_SC_SSIZE_MAXÌ65536Ö0 +_SC_SS_REPL_MAXÌ65536Ö0 +_SC_STREAMSÌ65536Ö0 +_SC_STREAM_MAXÌ65536Ö0 +_SC_SYMLOOP_MAXÌ65536Ö0 +_SC_SYNCHRONIZED_IOÌ65536Ö0 +_SC_SYSTEM_DATABASEÌ65536Ö0 +_SC_SYSTEM_DATABASE_RÌ65536Ö0 +_SC_THREADSÌ65536Ö0 +_SC_THREAD_ATTR_STACKADDRÌ65536Ö0 +_SC_THREAD_ATTR_STACKSIZEÌ65536Ö0 +_SC_THREAD_CPUTIMEÌ65536Ö0 +_SC_THREAD_DESTRUCTOR_ITERATIONSÌ65536Ö0 +_SC_THREAD_KEYS_MAXÌ65536Ö0 +_SC_THREAD_PRIORITY_SCHEDULINGÌ65536Ö0 +_SC_THREAD_PRIO_INHERITÌ65536Ö0 +_SC_THREAD_PRIO_PROTECTÌ65536Ö0 +_SC_THREAD_PROCESS_SHAREDÌ65536Ö0 +_SC_THREAD_ROBUST_PRIO_INHERITÌ65536Ö0 +_SC_THREAD_ROBUST_PRIO_PROTECTÌ65536Ö0 +_SC_THREAD_SAFE_FUNCTIONSÌ65536Ö0 +_SC_THREAD_SPORADIC_SERVERÌ65536Ö0 +_SC_THREAD_STACK_MINÌ65536Ö0 +_SC_THREAD_THREADS_MAXÌ65536Ö0 +_SC_TIMEOUTSÌ65536Ö0 +_SC_TIMERSÌ65536Ö0 +_SC_TIMER_MAXÌ65536Ö0 +_SC_TRACEÌ65536Ö0 +_SC_TRACE_EVENT_FILTERÌ65536Ö0 +_SC_TRACE_EVENT_NAME_MAXÌ65536Ö0 +_SC_TRACE_INHERITÌ65536Ö0 +_SC_TRACE_LOGÌ65536Ö0 +_SC_TRACE_NAME_MAXÌ65536Ö0 +_SC_TRACE_SYS_MAXÌ65536Ö0 +_SC_TRACE_USER_EVENT_MAXÌ65536Ö0 +_SC_TTY_NAME_MAXÌ65536Ö0 +_SC_TYPED_MEMORY_OBJECTSÌ65536Ö0 +_SC_TZNAME_MAXÌ65536Ö0 +_SC_T_IOV_MAXÌ65536Ö0 +_SC_UCHAR_MAXÌ65536Ö0 +_SC_UINT_MAXÌ65536Ö0 +_SC_UIO_MAXIOVÌ65536Ö0 +_SC_ULONG_MAXÌ65536Ö0 +_SC_USER_GROUPSÌ65536Ö0 +_SC_USER_GROUPS_RÌ65536Ö0 +_SC_USHRT_MAXÌ65536Ö0 +_SC_V6_ILP32_OFF32Ì65536Ö0 +_SC_V6_ILP32_OFFBIGÌ65536Ö0 +_SC_V6_LP64_OFF64Ì65536Ö0 +_SC_V6_LPBIG_OFFBIGÌ65536Ö0 +_SC_V7_ILP32_OFF32Ì65536Ö0 +_SC_V7_ILP32_OFFBIGÌ65536Ö0 +_SC_V7_LP64_OFF64Ì65536Ö0 +_SC_V7_LPBIG_OFFBIGÌ65536Ö0 +_SC_VERSIONÌ65536Ö0 +_SC_WORD_BITÌ65536Ö0 +_SC_XBS5_ILP32_OFF32Ì65536Ö0 +_SC_XBS5_ILP32_OFFBIGÌ65536Ö0 +_SC_XBS5_LP64_OFF64Ì65536Ö0 +_SC_XBS5_LPBIG_OFFBIGÌ65536Ö0 +_SC_XOPEN_CRYPTÌ65536Ö0 +_SC_XOPEN_ENH_I18NÌ65536Ö0 +_SC_XOPEN_LEGACYÌ65536Ö0 +_SC_XOPEN_REALTIMEÌ65536Ö0 +_SC_XOPEN_REALTIME_THREADSÌ65536Ö0 +_SC_XOPEN_SHMÌ65536Ö0 +_SC_XOPEN_STREAMSÌ65536Ö0 +_SC_XOPEN_UNIXÌ65536Ö0 +_SC_XOPEN_VERSIONÌ65536Ö0 +_SC_XOPEN_XCU_VERSIONÌ65536Ö0 +_SC_XOPEN_XPG2Ì65536Ö0 +_SC_XOPEN_XPG3Ì65536Ö0 +_SC_XOPEN_XPG4Ì65536Ö0 +_SIGSET_H_typesÌ65536Ö0 +_SIGSET_NWORDSÌ65536Ö0 +_SIZET_Ì65536Ö0 +_SIZE_TÌ65536Ö0 +_SIZE_T_Ì65536Ö0 +_SIZE_T_DECLAREDÌ65536Ö0 +_SIZE_T_DEFINEDÌ65536Ö0 +_SIZE_T_DEFINED_Ì65536Ö0 +_STATBUF_ST_BLKSIZEÌ65536Ö0 +_STATBUF_ST_NSECÌ65536Ö0 +_STATBUF_ST_RDEVÌ65536Ö0 +_STAT_VERÌ65536Ö0 +_STAT_VER_KERNELÌ65536Ö0 +_STAT_VER_LINUXÌ65536Ö0 +_STDARG_HÌ65536Ö0 +_STDBOOL_HÌ65536Ö0 +_STDC_PREDEF_HÌ65536Ö0 +_STDINT_HÌ65536Ö0 +_STDIO_HÌ65536Ö0 +_STDIO_USES_IOSTREAMÌ65536Ö0 +_STDLIB_HÌ65536Ö0 +_STRINGS_HÌ65536Ö0 +_STRING_HÌ65536Ö0 +_STRUCT_TIMEVALÌ65536Ö0 +_SYS_CDEFS_HÌ65536Ö0 +_SYS_IOCTL_HÌ65536Ö0 +_SYS_MMAN_HÌ65536Ö0 +_SYS_SELECT_HÌ65536Ö0 +_SYS_SIZE_T_HÌ65536Ö0 +_SYS_STAT_HÌ65536Ö0 +_SYS_SYSMACROS_HÌ65536Ö0 +_SYS_TIME_HÌ65536Ö0 +_SYS_TTYDEFAULTS_H_Ì65536Ö0 +_SYS_TYPES_HÌ65536Ö0 +_TERMIOS_HÌ65536Ö0 +_T_SIZEÌ65536Ö0 +_T_SIZE_Ì65536Ö0 +_T_WCHARÌ65536Ö0 +_T_WCHAR_Ì65536Ö0 +_UNISTD_HÌ65536Ö0 +_U_Ì65536Ö0 +_VA_LISTÌ65536Ö0 +_VA_LIST_Ì65536Ö0 +_VA_LIST_DEFINEDÌ65536Ö0 +_VA_LIST_T_HÌ65536Ö0 +_WARNÌ1024Í(const char *fmt, ...)Ö0Ïint +_WCHAR_TÌ65536Ö0 +_WCHAR_T_Ì65536Ö0 +_WCHAR_T_DECLAREDÌ65536Ö0 +_WCHAR_T_DEFINEDÌ65536Ö0 +_WCHAR_T_DEFINED_Ì65536Ö0 +_WCHAR_T_HÌ65536Ö0 +_XBS5_LP64_OFF64Ì65536Ö0 +_XBS5_LPBIG_OFFBIGÌ65536Ö0 +_XLOCALE_HÌ65536Ö0 +_XOPEN_CRYPTÌ65536Ö0 +_XOPEN_ENH_I18NÌ65536Ö0 +_XOPEN_IOV_MAXÌ65536Ö0 +_XOPEN_LEGACYÌ65536Ö0 +_XOPEN_LIM_HÌ65536Ö0 +_XOPEN_REALTIMEÌ65536Ö0 +_XOPEN_REALTIME_THREADSÌ65536Ö0 +_XOPEN_SHMÌ65536Ö0 +_XOPEN_SOURCEÌ65536Ö0 +_XOPEN_SOURCE_EXTENDEDÌ65536Ö0 +_XOPEN_UNIXÌ65536Ö0 +_XOPEN_VERSIONÌ65536Ö0 +_XOPEN_XCU_VERSIONÌ65536Ö0 +_XOPEN_XPG2Ì65536Ö0 +_XOPEN_XPG3Ì65536Ö0 +_XOPEN_XPG4Ì65536Ö0 +__ASMNAMEÌ131072Í(cname)Ö0 +__ASMNAME2Ì131072Í(prefix,cname)Ö0 +__ASM_GENERIC_IOCTLS_HÌ65536Ö0 +__ASSERT_FUNCTIONÌ65536Ö0 +__ASSERT_VOID_CASTÌ65536Ö0 +__ATOMIC_ACQUIREÌ65536Ö0 +__ATOMIC_ACQ_RELÌ65536Ö0 +__ATOMIC_CONSUMEÌ65536Ö0 +__ATOMIC_HLE_ACQUIREÌ65536Ö0 +__ATOMIC_HLE_RELEASEÌ65536Ö0 +__ATOMIC_RELAXEDÌ65536Ö0 +__ATOMIC_RELEASEÌ65536Ö0 +__ATOMIC_SEQ_CSTÌ65536Ö0 +__BEGIN_DECLSÌ65536Ö0 +__BEGIN_NAMESPACE_C99Ì65536Ö0 +__BEGIN_NAMESPACE_STDÌ65536Ö0 +__BIGGEST_ALIGNMENT__Ì65536Ö0 +__BIG_ENDIANÌ65536Ö0 +__BIT_TYPES_DEFINED__Ì65536Ö0 +__BLKCNT64_T_TYPEÌ65536Ö0 +__BLKCNT_T_TYPEÌ65536Ö0 +__BLKSIZE_T_TYPEÌ65536Ö0 +__BYTE_ORDERÌ65536Ö0 +__BYTE_ORDER__Ì65536Ö0 +__CHAR16_TYPE__Ì65536Ö0 +__CHAR32_TYPE__Ì65536Ö0 +__CHAR_BIT__Ì65536Ö0 +__CLOCKID_T_TYPEÌ65536Ö0 +__CLOCK_T_TYPEÌ65536Ö0 +__CMDLNOPTS_H__Ì65536Ö0 +__COMPAR_FN_TÌ65536Ö0 +__CONCATÌ131072Í(x,y)Ö0 +__CORRECT_ISO_CPP_STRING_H_PROTOÌ65536Ö0 +__CPU_MASK_TYPEÌ65536Ö0 +__DADDR_T_TYPEÌ65536Ö0 +__DBL_DECIMAL_DIG__Ì65536Ö0 +__DBL_DENORM_MIN__Ì65536Ö0 +__DBL_DIG__Ì65536Ö0 +__DBL_EPSILON__Ì65536Ö0 +__DBL_HAS_DENORM__Ì65536Ö0 +__DBL_HAS_INFINITY__Ì65536Ö0 +__DBL_HAS_QUIET_NAN__Ì65536Ö0 +__DBL_MANT_DIG__Ì65536Ö0 +__DBL_MAX_10_EXP__Ì65536Ö0 +__DBL_MAX_EXP__Ì65536Ö0 +__DBL_MAX__Ì65536Ö0 +__DBL_MIN_10_EXP__Ì65536Ö0 +__DBL_MIN_EXP__Ì65536Ö0 +__DBL_MIN__Ì65536Ö0 +__DEC128_EPSILON__Ì65536Ö0 +__DEC128_MANT_DIG__Ì65536Ö0 +__DEC128_MAX_EXP__Ì65536Ö0 +__DEC128_MAX__Ì65536Ö0 +__DEC128_MIN_EXP__Ì65536Ö0 +__DEC128_MIN__Ì65536Ö0 +__DEC128_SUBNORMAL_MIN__Ì65536Ö0 +__DEC32_EPSILON__Ì65536Ö0 +__DEC32_MANT_DIG__Ì65536Ö0 +__DEC32_MAX_EXP__Ì65536Ö0 +__DEC32_MAX__Ì65536Ö0 +__DEC32_MIN_EXP__Ì65536Ö0 +__DEC32_MIN__Ì65536Ö0 +__DEC32_SUBNORMAL_MIN__Ì65536Ö0 +__DEC64_EPSILON__Ì65536Ö0 +__DEC64_MANT_DIG__Ì65536Ö0 +__DEC64_MAX_EXP__Ì65536Ö0 +__DEC64_MAX__Ì65536Ö0 +__DEC64_MIN_EXP__Ì65536Ö0 +__DEC64_MIN__Ì65536Ö0 +__DEC64_SUBNORMAL_MIN__Ì65536Ö0 +__DECIMAL_BID_FORMAT__Ì65536Ö0 +__DECIMAL_DIG__Ì65536Ö0 +__DECL_SIMD_cosÌ65536Ö0 +__DECL_SIMD_cosfÌ65536Ö0 +__DECL_SIMD_coslÌ65536Ö0 +__DECL_SIMD_expÌ65536Ö0 +__DECL_SIMD_expfÌ65536Ö0 +__DECL_SIMD_explÌ65536Ö0 +__DECL_SIMD_logÌ65536Ö0 +__DECL_SIMD_logfÌ65536Ö0 +__DECL_SIMD_loglÌ65536Ö0 +__DECL_SIMD_powÌ65536Ö0 +__DECL_SIMD_powfÌ65536Ö0 +__DECL_SIMD_powlÌ65536Ö0 +__DECL_SIMD_sinÌ65536Ö0 +__DECL_SIMD_sincosÌ65536Ö0 +__DECL_SIMD_sincosfÌ65536Ö0 +__DECL_SIMD_sincoslÌ65536Ö0 +__DECL_SIMD_sinfÌ65536Ö0 +__DECL_SIMD_sinlÌ65536Ö0 +__DEC_EVAL_METHOD__Ì65536Ö0 +__DEPRECATEDÌ65536Ö0 +__DEV_T_TYPEÌ65536Ö0 +__ELF__Ì65536Ö0 +__END_DECLSÌ65536Ö0 +__END_NAMESPACE_C99Ì65536Ö0 +__END_NAMESPACE_STDÌ65536Ö0 +__EXCEPTIONSÌ65536Ö0 +__FDS_BITSÌ131072Í(set)Ö0 +__FD_CLRÌ131072Í(d,set)Ö0 +__FD_ELTÌ131072Í(d)Ö0 +__FD_ISSETÌ131072Í(d,set)Ö0 +__FD_MASKÌ131072Í(d)Ö0 +__FD_SETÌ131072Í(d,set)Ö0 +__FD_SETSIZEÌ65536Ö0 +__FD_ZEROÌ131072Í(fdsp)Ö0 +__FD_ZERO_STOSÌ65536Ö0 +__FILE_definedÌ65536Ö0 +__FINITE_MATH_ONLY__Ì65536Ö0 +__FLOAT_WORD_ORDERÌ65536Ö0 +__FLOAT_WORD_ORDER__Ì65536Ö0 +__FLT_DECIMAL_DIG__Ì65536Ö0 +__FLT_DENORM_MIN__Ì65536Ö0 +__FLT_DIG__Ì65536Ö0 +__FLT_EPSILON__Ì65536Ö0 +__FLT_EVAL_METHOD__Ì65536Ö0 +__FLT_HAS_DENORM__Ì65536Ö0 +__FLT_HAS_INFINITY__Ì65536Ö0 +__FLT_HAS_QUIET_NAN__Ì65536Ö0 +__FLT_MANT_DIG__Ì65536Ö0 +__FLT_MAX_10_EXP__Ì65536Ö0 +__FLT_MAX_EXP__Ì65536Ö0 +__FLT_MAX__Ì65536Ö0 +__FLT_MIN_10_EXP__Ì65536Ö0 +__FLT_MIN_EXP__Ì65536Ö0 +__FLT_MIN__Ì65536Ö0 +__FLT_RADIX__Ì65536Ö0 +__FSBLKCNT64_T_TYPEÌ65536Ö0 +__FSBLKCNT_T_TYPEÌ65536Ö0 +__FSFILCNT64_T_TYPEÌ65536Ö0 +__FSFILCNT_T_TYPEÌ65536Ö0 +__FSID_T_TYPEÌ65536Ö0 +__FSWORD_T_TYPEÌ65536Ö0 +__FXSR__Ì65536Ö0 +__F_GETOWNÌ65536Ö0 +__F_GETOWN_EXÌ65536Ö0 +__F_GETSIGÌ65536Ö0 +__F_SETOWNÌ65536Ö0 +__F_SETOWN_EXÌ65536Ö0 +__F_SETSIGÌ65536Ö0 +__GCC_ATOMIC_BOOL_LOCK_FREEÌ65536Ö0 +__GCC_ATOMIC_CHAR16_T_LOCK_FREEÌ65536Ö0 +__GCC_ATOMIC_CHAR32_T_LOCK_FREEÌ65536Ö0 +__GCC_ATOMIC_CHAR_LOCK_FREEÌ65536Ö0 +__GCC_ATOMIC_INT_LOCK_FREEÌ65536Ö0 +__GCC_ATOMIC_LLONG_LOCK_FREEÌ65536Ö0 +__GCC_ATOMIC_LONG_LOCK_FREEÌ65536Ö0 +__GCC_ATOMIC_POINTER_LOCK_FREEÌ65536Ö0 +__GCC_ATOMIC_SHORT_LOCK_FREEÌ65536Ö0 +__GCC_ATOMIC_TEST_AND_SET_TRUEVALÌ65536Ö0 +__GCC_ATOMIC_WCHAR_T_LOCK_FREEÌ65536Ö0 +__GCC_HAVE_DWARF2_CFI_ASMÌ65536Ö0 +__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1Ì65536Ö0 +__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2Ì65536Ö0 +__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4Ì65536Ö0 +__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8Ì65536Ö0 +__GCC_IEC_559Ì65536Ö0 +__GCC_IEC_559_COMPLEXÌ65536Ö0 +__GID_T_TYPEÌ65536Ö0 +__GLIBCXX_BITSIZE_INT_N_0Ì65536Ö0 +__GLIBCXX_TYPE_INT_N_0Ì65536Ö0 +__GLIBC_MINOR__Ì65536Ö0 +__GLIBC_PREREQÌ131072Í(maj,min)Ö0 +__GLIBC__Ì65536Ö0 +__GNUC_GNU_INLINE__Ì65536Ö0 +__GNUC_MINOR__Ì65536Ö0 +__GNUC_PATCHLEVEL__Ì65536Ö0 +__GNUC_PREREQÌ131072Í(maj,min)Ö0 +__GNUC_VA_LISTÌ65536Ö0 +__GNUC__Ì65536Ö0 +__GNUG__Ì65536Ö0 +__GNU_GETTEXT_SUPPORTED_REVISIONÌ131072Í(major)Ö0 +__GNU_LIBRARY__Ì65536Ö0 +__GXX_ABI_VERSIONÌ65536Ö0 +__GXX_RTTIÌ65536Ö0 +__GXX_WEAK__Ì65536Ö0 +__HAVE_COLUMNÌ65536Ö0 +__ID_T_TYPEÌ65536Ö0 +__ILP32_OFF32_CFLAGSÌ65536Ö0 +__ILP32_OFF32_LDFLAGSÌ65536Ö0 +__ILP32_OFFBIG_CFLAGSÌ65536Ö0 +__ILP32_OFFBIG_LDFLAGSÌ65536Ö0 +__INO64_T_TYPEÌ65536Ö0 +__INO_T_MATCHES_INO64_TÌ65536Ö0 +__INO_T_TYPEÌ65536Ö0 +__INT16_CÌ131072Í(c)Ö0 +__INT16_MAX__Ì65536Ö0 +__INT16_TYPE__Ì65536Ö0 +__INT32_CÌ131072Í(c)Ö0 +__INT32_MAX__Ì65536Ö0 +__INT32_TYPE__Ì65536Ö0 +__INT64_CÌ131072Í(c)Ö0 +__INT64_MAX__Ì65536Ö0 +__INT64_TYPE__Ì65536Ö0 +__INT8_CÌ131072Í(c)Ö0 +__INT8_MAX__Ì65536Ö0 +__INT8_TYPE__Ì65536Ö0 +__INTMAX_CÌ131072Í(c)Ö0 +__INTMAX_MAX__Ì65536Ö0 +__INTMAX_TYPE__Ì65536Ö0 +__INTPTR_MAX__Ì65536Ö0 +__INTPTR_TYPE__Ì65536Ö0 +__INT_FAST16_MAX__Ì65536Ö0 +__INT_FAST16_TYPE__Ì65536Ö0 +__INT_FAST32_MAX__Ì65536Ö0 +__INT_FAST32_TYPE__Ì65536Ö0 +__INT_FAST64_MAX__Ì65536Ö0 +__INT_FAST64_TYPE__Ì65536Ö0 +__INT_FAST8_MAX__Ì65536Ö0 +__INT_FAST8_TYPE__Ì65536Ö0 +__INT_LEAST16_MAX__Ì65536Ö0 +__INT_LEAST16_TYPE__Ì65536Ö0 +__INT_LEAST32_MAX__Ì65536Ö0 +__INT_LEAST32_TYPE__Ì65536Ö0 +__INT_LEAST64_MAX__Ì65536Ö0 +__INT_LEAST64_TYPE__Ì65536Ö0 +__INT_LEAST8_MAX__Ì65536Ö0 +__INT_LEAST8_TYPE__Ì65536Ö0 +__INT_MAX__Ì65536Ö0 +__INT_WCHAR_T_HÌ65536Ö0 +__KERNEL_STRICT_NAMESÌ65536Ö0 +__KEY_T_TYPEÌ65536Ö0 +__LC_ADDRESSÌ65536Ö0 +__LC_ALLÌ65536Ö0 +__LC_COLLATEÌ65536Ö0 +__LC_CTYPEÌ65536Ö0 +__LC_IDENTIFICATIONÌ65536Ö0 +__LC_MEASUREMENTÌ65536Ö0 +__LC_MESSAGESÌ65536Ö0 +__LC_MONETARYÌ65536Ö0 +__LC_NAMEÌ65536Ö0 +__LC_NUMERICÌ65536Ö0 +__LC_PAPERÌ65536Ö0 +__LC_TELEPHONEÌ65536Ö0 +__LC_TIMEÌ65536Ö0 +__LDBL_DENORM_MIN__Ì65536Ö0 +__LDBL_DIG__Ì65536Ö0 +__LDBL_EPSILON__Ì65536Ö0 +__LDBL_HAS_DENORM__Ì65536Ö0 +__LDBL_HAS_INFINITY__Ì65536Ö0 +__LDBL_HAS_QUIET_NAN__Ì65536Ö0 +__LDBL_MANT_DIG__Ì65536Ö0 +__LDBL_MAX_10_EXP__Ì65536Ö0 +__LDBL_MAX_EXP__Ì65536Ö0 +__LDBL_MAX__Ì65536Ö0 +__LDBL_MIN_10_EXP__Ì65536Ö0 +__LDBL_MIN_EXP__Ì65536Ö0 +__LDBL_MIN__Ì65536Ö0 +__LDBL_REDIRÌ131072Í(name,proto)Ö0 +__LDBL_REDIR1Ì131072Í(name,proto,alias)Ö0 +__LDBL_REDIR1_NTHÌ131072Í(name,proto,alias)Ö0 +__LDBL_REDIR_DECLÌ131072Í(name)Ö0 +__LDBL_REDIR_NTHÌ131072Í(name,proto)Ö0 +__LEAFÌ65536Ö0 +__LEAF_ATTRÌ65536Ö0 +__LITTLE_ENDIANÌ65536Ö0 +__LONG_LONG_MAX__Ì65536Ö0 +__LONG_LONG_PAIRÌ131072Í(HI,LO)Ö0 +__LONG_MAX__Ì65536Ö0 +__LP64_OFF64_CFLAGSÌ65536Ö0 +__LP64_OFF64_LDFLAGSÌ65536Ö0 +__LP64__Ì65536Ö0 +__MATHCALLÌ65536Ö0 +__MATHCALLÌ131072Í(function,suffix,args)Ö0 +__MATHCALLXÌ131072Í(function,suffix,args,attrib)Ö0 +__MATHCALL_VECÌ131072Í(function,suffix,args)Ö0 +__MATHDECLÌ65536Ö0 +__MATHDECLÌ131072Í(type,function,suffix,args)Ö0 +__MATHDECLXÌ131072Í(type,function,suffix,args,attrib)Ö0 +__MATHDECL_1Ì65536Ö0 +__MATHDECL_1Ì131072Í(type,function,suffix,args)Ö0 +__MATHDECL_VECÌ131072Í(type,function,suffix,args)Ö0 +__MATH_DECLARE_LDOUBLEÌ65536Ö0 +__MATH_DECLARING_DOUBLEÌ65536Ö0 +__MATH_PRECNAMEÌ65536Ö0 +__MATH_PRECNAMEÌ131072Í(name,r)Ö0 +__MAX_BAUDÌ65536Ö0 +__MMX__Ì65536Ö0 +__MODE_T_TYPEÌ65536Ö0 +__NFDBITSÌ65536Ö0 +__NLINK_T_TYPEÌ65536Ö0 +__NO_INLINE__Ì65536Ö0 +__NTHÌ131072Í(fct)Ö0 +__OFF64_T_TYPEÌ65536Ö0 +__OFF_T_MATCHES_OFF64_TÌ65536Ö0 +__OFF_T_TYPEÌ65536Ö0 +__OPEN_NEEDS_MODEÌ131072Í(oflag)Ö0 +__ORDER_BIG_ENDIAN__Ì65536Ö0 +__ORDER_LITTLE_ENDIAN__Ì65536Ö0 +__ORDER_PDP_ENDIAN__Ì65536Ö0 +__O_CLOEXECÌ65536Ö0 +__O_DIRECTÌ65536Ö0 +__O_DIRECTORYÌ65536Ö0 +__O_DSYNCÌ65536Ö0 +__O_LARGEFILEÌ65536Ö0 +__O_NOATIMEÌ65536Ö0 +__O_NOFOLLOWÌ65536Ö0 +__O_PATHÌ65536Ö0 +__O_TMPFILEÌ65536Ö0 +__PÌ65536Ö0 +__PÌ131072Í(args)Ö0 +__PARSEARGS_H__Ì65536Ö0 +__PDP_ENDIANÌ65536Ö0 +__PID_T_TYPEÌ65536Ö0 +__PMTÌ65536Ö0 +__PMTÌ131072Í(args)Ö0 +__POSIX2_THIS_VERSIONÌ65536Ö0 +__POSIX_FADV_DONTNEEDÌ65536Ö0 +__POSIX_FADV_NOREUSEÌ65536Ö0 +__PRAGMA_REDEFINE_EXTNAMEÌ65536Ö0 +__PTHREAD_MUTEX_HAVE_PREVÌ65536Ö0 +__PTHREAD_RWLOCK_ELISION_EXTRAÌ65536Ö0 +__PTHREAD_RWLOCK_INT_FLAGS_SHAREDÌ65536Ö0 +__PTHREAD_SPINSÌ65536Ö0 +__PTRDIFF_MAX__Ì65536Ö0 +__PTRDIFF_TYPE__Ì65536Ö0 +__REDIRECTÌ131072Í(name,proto,alias)Ö0 +__REDIRECT_LDBLÌ131072Í(name,proto,alias)Ö0 +__REDIRECT_NTHÌ131072Í(name,proto,alias)Ö0 +__REDIRECT_NTHNLÌ131072Í(name,proto,alias)Ö0 +__REDIRECT_NTH_LDBLÌ131072Í(name,proto,alias)Ö0 +__REGISTER_PREFIX__Ì65536Ö0 +__RLIM64_T_TYPEÌ65536Ö0 +__RLIM_T_TYPEÌ65536Ö0 +__S16_TYPEÌ65536Ö0 +__S32_TYPEÌ65536Ö0 +__S64_TYPEÌ65536Ö0 +__SCHAR_MAX__Ì65536Ö0 +__SHRT_MAX__Ì65536Ö0 +__SIG_ATOMIC_MAX__Ì65536Ö0 +__SIG_ATOMIC_MIN__Ì65536Ö0 +__SIG_ATOMIC_TYPE__Ì65536Ö0 +__SIMD_DECLÌ131072Í(function)Ö0 +__SIZEOF_DOUBLE__Ì65536Ö0 +__SIZEOF_FLOAT128__Ì65536Ö0 +__SIZEOF_FLOAT80__Ì65536Ö0 +__SIZEOF_FLOAT__Ì65536Ö0 +__SIZEOF_INT128__Ì65536Ö0 +__SIZEOF_INT__Ì65536Ö0 +__SIZEOF_LONG_DOUBLE__Ì65536Ö0 +__SIZEOF_LONG_LONG__Ì65536Ö0 +__SIZEOF_LONG__Ì65536Ö0 +__SIZEOF_POINTER__Ì65536Ö0 +__SIZEOF_PTHREAD_ATTR_TÌ65536Ö0 +__SIZEOF_PTHREAD_BARRIERATTR_TÌ65536Ö0 +__SIZEOF_PTHREAD_BARRIER_TÌ65536Ö0 +__SIZEOF_PTHREAD_CONDATTR_TÌ65536Ö0 +__SIZEOF_PTHREAD_COND_TÌ65536Ö0 +__SIZEOF_PTHREAD_MUTEXATTR_TÌ65536Ö0 +__SIZEOF_PTHREAD_MUTEX_TÌ65536Ö0 +__SIZEOF_PTHREAD_RWLOCKATTR_TÌ65536Ö0 +__SIZEOF_PTHREAD_RWLOCK_TÌ65536Ö0 +__SIZEOF_PTRDIFF_T__Ì65536Ö0 +__SIZEOF_SHORT__Ì65536Ö0 +__SIZEOF_SIZE_T__Ì65536Ö0 +__SIZEOF_WCHAR_T__Ì65536Ö0 +__SIZEOF_WINT_T__Ì65536Ö0 +__SIZE_MAX__Ì65536Ö0 +__SIZE_TÌ65536Ö0 +__SIZE_TYPE__Ì65536Ö0 +__SIZE_T__Ì65536Ö0 +__SLONG32_TYPEÌ65536Ö0 +__SLONGWORD_TYPEÌ65536Ö0 +__SQUAD_TYPEÌ65536Ö0 +__SSE2_MATH__Ì65536Ö0 +__SSE2__Ì65536Ö0 +__SSE_MATH__Ì65536Ö0 +__SSE__Ì65536Ö0 +__SSIZE_T_TYPEÌ65536Ö0 +__SSP_STRONG__Ì65536Ö0 +__STDC_HOSTED__Ì65536Ö0 +__STDC_IEC_559_COMPLEX__Ì65536Ö0 +__STDC_IEC_559__Ì65536Ö0 +__STDC_ISO_10646__Ì65536Ö0 +__STDC_NO_THREADS__Ì65536Ö0 +__STDC__Ì65536Ö0 +__STD_TYPEÌ65536Ö0 +__STRINGÌ131072Í(x)Ö0 +__SUSECONDS_T_TYPEÌ65536Ö0 +__SWORD_TYPEÌ65536Ö0 +__SYSCALL_SLONG_TYPEÌ65536Ö0 +__SYSCALL_ULONG_TYPEÌ65536Ö0 +__SYSCALL_WORDSIZEÌ65536Ö0 +__S_IEXECÌ65536Ö0 +__S_IFBLKÌ65536Ö0 +__S_IFCHRÌ65536Ö0 +__S_IFDIRÌ65536Ö0 +__S_IFIFOÌ65536Ö0 +__S_IFLNKÌ65536Ö0 +__S_IFMTÌ65536Ö0 +__S_IFREGÌ65536Ö0 +__S_IFSOCKÌ65536Ö0 +__S_IREADÌ65536Ö0 +__S_ISGIDÌ65536Ö0 +__S_ISTYPEÌ131072Í(mode,mask)Ö0 +__S_ISUIDÌ65536Ö0 +__S_ISVTXÌ65536Ö0 +__S_IWRITEÌ65536Ö0 +__S_TYPEISMQÌ131072Í(buf)Ö0 +__S_TYPEISSEMÌ131072Í(buf)Ö0 +__S_TYPEISSHMÌ131072Í(buf)Ö0 +__TERM_H__Ì65536Ö0 +__THROWÌ65536Ö0 +__THROWNLÌ65536Ö0 +__TIMER_T_TYPEÌ65536Ö0 +__TIME_T_TYPEÌ65536Ö0 +__U16_TYPEÌ65536Ö0 +__U32_TYPEÌ65536Ö0 +__U64_TYPEÌ65536Ö0 +__UID_T_TYPEÌ65536Ö0 +__UINT16_CÌ131072Í(c)Ö0 +__UINT16_MAX__Ì65536Ö0 +__UINT16_TYPE__Ì65536Ö0 +__UINT32_CÌ131072Í(c)Ö0 +__UINT32_MAX__Ì65536Ö0 +__UINT32_TYPE__Ì65536Ö0 +__UINT64_CÌ131072Í(c)Ö0 +__UINT64_MAX__Ì65536Ö0 +__UINT64_TYPE__Ì65536Ö0 +__UINT8_CÌ131072Í(c)Ö0 +__UINT8_MAX__Ì65536Ö0 +__UINT8_TYPE__Ì65536Ö0 +__UINTMAX_CÌ131072Í(c)Ö0 +__UINTMAX_MAX__Ì65536Ö0 +__UINTMAX_TYPE__Ì65536Ö0 +__UINTPTR_MAX__Ì65536Ö0 +__UINTPTR_TYPE__Ì65536Ö0 +__UINT_FAST16_MAX__Ì65536Ö0 +__UINT_FAST16_TYPE__Ì65536Ö0 +__UINT_FAST32_MAX__Ì65536Ö0 +__UINT_FAST32_TYPE__Ì65536Ö0 +__UINT_FAST64_MAX__Ì65536Ö0 +__UINT_FAST64_TYPE__Ì65536Ö0 +__UINT_FAST8_MAX__Ì65536Ö0 +__UINT_FAST8_TYPE__Ì65536Ö0 +__UINT_LEAST16_MAX__Ì65536Ö0 +__UINT_LEAST16_TYPE__Ì65536Ö0 +__UINT_LEAST32_MAX__Ì65536Ö0 +__UINT_LEAST32_TYPE__Ì65536Ö0 +__UINT_LEAST64_MAX__Ì65536Ö0 +__UINT_LEAST64_TYPE__Ì65536Ö0 +__UINT_LEAST8_MAX__Ì65536Ö0 +__UINT_LEAST8_TYPE__Ì65536Ö0 +__ULONG32_TYPEÌ65536Ö0 +__ULONGWORD_TYPEÌ65536Ö0 +__UQUAD_TYPEÌ65536Ö0 +__USECONDS_T_TYPEÌ65536Ö0 +__USEFULL_MACROS_H__Ì65536Ö0 +__USER_LABEL_PREFIX__Ì65536Ö0 +__USE_ATFILEÌ65536Ö0 +__USE_FILE_OFFSET64Ì65536Ö0 +__USE_FORTIFY_LEVELÌ65536Ö0 +__USE_GNUÌ65536Ö0 +__USE_GNU_GETTEXTÌ65536Ö0 +__USE_ISOC11Ì65536Ö0 +__USE_ISOC95Ì65536Ö0 +__USE_ISOC99Ì65536Ö0 +__USE_ISOCXX11Ì65536Ö0 +__USE_LARGEFILEÌ65536Ö0 +__USE_LARGEFILE64Ì65536Ö0 +__USE_MISCÌ65536Ö0 +__USE_POSIXÌ65536Ö0 +__USE_POSIX199309Ì65536Ö0 +__USE_POSIX199506Ì65536Ö0 +__USE_POSIX2Ì65536Ö0 +__USE_REENTRANTÌ65536Ö0 +__USE_UNIX98Ì65536Ö0 +__USE_XOPENÌ65536Ö0 +__USE_XOPEN2KÌ65536Ö0 +__USE_XOPEN2K8Ì65536Ö0 +__USE_XOPEN2K8XSIÌ65536Ö0 +__USE_XOPEN2KXSIÌ65536Ö0 +__USE_XOPEN_EXTENDEDÌ65536Ö0 +__USING_NAMESPACE_C99Ì131072Í(name)Ö0 +__USING_NAMESPACE_STDÌ131072Í(name)Ö0 +__UWORD_TYPEÌ65536Ö0 +__VERSION__Ì65536Ö0 +__WAIT_INTÌ131072Í(status)Ö0 +__WAIT_STATUSÌ65536Ö0 +__WAIT_STATUS_DEFNÌ65536Ö0 +__WALLÌ65536Ö0 +__WCHAR_MAXÌ65536Ö0 +__WCHAR_MAX__Ì65536Ö0 +__WCHAR_MINÌ65536Ö0 +__WCHAR_MIN__Ì65536Ö0 +__WCHAR_TÌ65536Ö0 +__WCHAR_TYPE__Ì65536Ö0 +__WCHAR_T__Ì65536Ö0 +__WCLONEÌ65536Ö0 +__WCOREDUMPÌ131072Í(status)Ö0 +__WCOREFLAGÌ65536Ö0 +__WEXITSTATUSÌ131072Í(status)Ö0 +__WIFCONTINUEDÌ131072Í(status)Ö0 +__WIFEXITEDÌ131072Í(status)Ö0 +__WIFSIGNALEDÌ131072Í(status)Ö0 +__WIFSTOPPEDÌ131072Í(status)Ö0 +__WINT_MAX__Ì65536Ö0 +__WINT_MIN__Ì65536Ö0 +__WINT_TYPE__Ì65536Ö0 +__WNOTHREADÌ65536Ö0 +__WORDSIZEÌ65536Ö0 +__WORDSIZE_TIME64_COMPAT32Ì65536Ö0 +__WSTOPSIGÌ131072Í(status)Ö0 +__WTERMSIGÌ131072Í(status)Ö0 +__W_CONTINUEDÌ65536Ö0 +__W_EXITCODEÌ131072Í(ret,sig)Ö0 +__W_STOPCODEÌ131072Í(sig)Ö0 +____FILE_definedÌ65536Ö0 +____mbstate_t_definedÌ65536Ö0 +___int_size_t_hÌ65536Ö0 +___int_wchar_t_hÌ65536Ö0 +__always_inlineÌ65536Ö0 +__amd64Ì65536Ö0 +__amd64__Ì65536Ö0 +__attribute_alloc_size__Ì131072Í(params)Ö0 +__attribute_artificial__Ì65536Ö0 +__attribute_const__Ì65536Ö0 +__attribute_deprecated__Ì65536Ö0 +__attribute_format_arg__Ì131072Í(x)Ö0 +__attribute_format_strfmon__Ì131072Í(a,b)Ö0 +__attribute_malloc__Ì65536Ö0 +__attribute_noinline__Ì65536Ö0 +__attribute_pure__Ì65536Ö0 +__attribute_used__Ì65536Ö0 +__attribute_warn_unused_result__Ì65536Ö0 +__blkcnt_t_definedÌ65536Ö0 +__blksize_t_definedÌ65536Ö0 +__bool_true_false_are_definedÌ65536Ö0 +__bosÌ131072Í(ptr)Ö0 +__bos0Ì131072Í(ptr)Ö0 +__bswap_16Ì131072Í(x)Ö0 +__bswap_constant_16Ì131072Í(x)Ö0 +__bswap_constant_32Ì131072Í(x)Ö0 +__bswap_constant_64Ì131072Í(x)Ö0 +__clock_t_definedÌ65536Ö0 +__clockid_t_definedÌ65536Ö0 +__clockid_time_tÌ65536Ö0 +__code_model_small__Ì65536Ö0 +__cplusplusÌ65536Ö0 +__cpp_binary_literalsÌ65536Ö0 +__cpp_exceptionsÌ65536Ö0 +__cpp_rttiÌ65536Ö0 +__cpp_runtime_arraysÌ65536Ö0 +__daddr_t_definedÌ65536Ö0 +__dev_t_definedÌ65536Ö0 +__error_t_definedÌ65536Ö0 +__errordeclÌ131072Í(name,msg)Ö0 +__exctypeÌ131072Í(name)Ö0 +__exctype_lÌ131072Í(name)Ö0 +__extern_always_inlineÌ65536Ö0 +__extern_inlineÌ65536Ö0 +__flexarrÌ65536Ö0 +__fortify_functionÌ65536Ö0 +__fsblkcnt_t_definedÌ65536Ö0 +__fsfilcnt_t_definedÌ65536Ö0 +__gid_t_definedÌ65536Ö0 +__glibc_likelyÌ131072Í(cond)Ö0 +__glibc_unlikelyÌ131072Í(cond)Ö0 +__gnu_linux__Ì65536Ö0 +__has_includeÌ131072Í(STR)Ö0 +__has_include_nextÌ131072Í(STR)Ö0 +__have_pthread_attr_tÌ65536Ö0 +__id_t_definedÌ65536Ö0 +__ino64_t_definedÌ65536Ö0 +__ino_t_definedÌ65536Ö0 +__int8_t_definedÌ65536Ö0 +__intN_tÌ131072Í(N,MODE)Ö0 +__intptr_t_definedÌ65536Ö0 +__isalnum_lÌ131072Í(c,l)Ö0 +__isalpha_lÌ131072Í(c,l)Ö0 +__isasciiÌ131072Í(c)Ö0 +__isascii_lÌ131072Í(c,l)Ö0 +__isblank_lÌ131072Í(c,l)Ö0 +__iscntrl_lÌ131072Í(c,l)Ö0 +__isctype_lÌ131072Í(c,type,locale)Ö0 +__isdigit_lÌ131072Í(c,l)Ö0 +__isgraph_lÌ131072Í(c,l)Ö0 +__islower_lÌ131072Í(c,l)Ö0 +__isprint_lÌ131072Í(c,l)Ö0 +__ispunct_lÌ131072Í(c,l)Ö0 +__isspace_lÌ131072Í(c,l)Ö0 +__isupper_lÌ131072Í(c,l)Ö0 +__isxdigit_lÌ131072Í(c,l)Ö0 +__k8Ì65536Ö0 +__k8__Ì65536Ö0 +__key_t_definedÌ65536Ö0 +__ldiv_t_definedÌ65536Ö0 +__linuxÌ65536Ö0 +__linux__Ì65536Ö0 +__lldiv_t_definedÌ65536Ö0 +__long_double_tÌ65536Ö0 +__malloc_and_calloc_definedÌ65536Ö0 +__mode_t_definedÌ65536Ö0 +__need_EmathÌ65536Ö0 +__need_FILEÌ65536Ö0 +__need_IOV_MAXÌ65536Ö0 +__need_NULLÌ65536Ö0 +__need___FILEÌ65536Ö0 +__need___va_listÌ65536Ö0 +__need_clock_tÌ65536Ö0 +__need_clockid_tÌ65536Ö0 +__need_error_tÌ65536Ö0 +__need_getoptÌ65536Ö0 +__need_malloc_and_callocÌ65536Ö0 +__need_mbstate_tÌ65536Ö0 +__need_size_tÌ65536Ö0 +__need_time_tÌ65536Ö0 +__need_timer_tÌ65536Ö0 +__need_timespecÌ65536Ö0 +__need_timevalÌ65536Ö0 +__need_wchar_tÌ65536Ö0 +__need_wint_tÌ65536Ö0 +__nlink_t_definedÌ65536Ö0 +__nonnullÌ131072Í(params)Ö0 +__off64_t_definedÌ65536Ö0 +__off_t_definedÌ65536Ö0 +__pid_t_definedÌ65536Ö0 +__prognameÌ32768Ö0Ïconst char * +__ptr_tÌ65536Ö0 +__restrict_arrÌ65536Ö0 +__sigset_t_definedÌ65536Ö0 +__size_tÌ65536Ö0 +__size_t__Ì65536Ö0 +__socklen_t_definedÌ65536Ö0 +__ssize_t_definedÌ65536Ö0 +__stub___compat_bdflushÌ65536Ö0 +__stub_chflagsÌ65536Ö0 +__stub_fattachÌ65536Ö0 +__stub_fchflagsÌ65536Ö0 +__stub_fdetachÌ65536Ö0 +__stub_getmsgÌ65536Ö0 +__stub_gttyÌ65536Ö0 +__stub_lchmodÌ65536Ö0 +__stub_putmsgÌ65536Ö0 +__stub_revokeÌ65536Ö0 +__stub_setloginÌ65536Ö0 +__stub_sigreturnÌ65536Ö0 +__stub_sstkÌ65536Ö0 +__stub_sttyÌ65536Ö0 +__suseconds_t_definedÌ65536Ö0 +__time_t_definedÌ65536Ö0 +__timer_t_definedÌ65536Ö0 +__timespec_definedÌ65536Ö0 +__toasciiÌ131072Í(c)Ö0 +__toascii_lÌ131072Í(c,l)Ö0 +__tobodyÌ131072Í(c,f,a,args)Ö0 +__u_char_definedÌ65536Ö0 +__u_intN_tÌ131072Í(N,MODE)Ö0 +__uid_t_definedÌ65536Ö0 +__uint32_t_definedÌ65536Ö0 +__undef_ARG_MAXÌ65536Ö0 +__undef_LINK_MAXÌ65536Ö0 +__undef_NR_OPENÌ65536Ö0 +__undef_OPEN_MAXÌ65536Ö0 +__unixÌ65536Ö0 +__unix__Ì65536Ö0 +__useconds_t_definedÌ65536Ö0 +__va_arg_packÌ131072Í()Ö0 +__va_arg_pack_lenÌ131072Í()Ö0 +__va_copyÌ131072Í(d,s)Ö0 +__va_list__Ì65536Ö0 +__warnattrÌ131072Í(msg)Ö0 +__warndeclÌ131072Í(name,msg)Ö0 +__wchar_t__Ì65536Ö0 +__wurÌ65536Ö0 +__x86_64Ì65536Ö0 +__x86_64__Ì65536Ö0 +_tolowerÌ131072Í(c)Ö0 +_toupperÌ131072Í(c)Ö0 +allocaÌ65536Ö0 +allocaÌ131072Í(size)Ö0 +anon_enum_0Ì2Ö0 +anon_enum_1Ì2Ö0 +anon_enum_5Ì2Ö0 +anon_struct_2Ì2048Ö0 +anon_struct_3Ì2048Ö0 +anon_struct_4Ì2048Ö0 +anon_struct_6Ì2048Ö0 +arg_doubleÌ4Îanon_enum_0Ö0 +arg_floatÌ4Îanon_enum_0Ö0 +arg_functionÌ4Îanon_enum_0Ö0 +arg_intÌ4Îanon_enum_0Ö0 +arg_longlongÌ4Îanon_enum_0Ö0 +arg_noneÌ4Îanon_enum_0Ö0 +arg_stringÌ4Îanon_enum_0Ö0 +argfnÌ4096Ö0Ïtypedef bool +argptrÌ64Îanon_struct_2Ö0Ïvoid * +argptrÌ64Îanon_struct_3Ö0Ïvoid * +argsortÌ16Í(const void *a1, const void *a2)Ö0Ïint +argtypeÌ4096Ö0Ïanon_enum_0 +assertÌ65536Ö0 +assertÌ131072Í(expr)Ö0 +assert_perrorÌ65536Ö0 +assert_perrorÌ131072Í(errnum)Ö0 +be16tohÌ131072Í(x)Ö0 +be32tohÌ131072Í(x)Ö0 +be64tohÌ131072Í(x)Ö0 +boolÌ65536Ö0 +change_helpstringÌ16Í(char *s)Ö0Ïvoid +change_helpstringÌ1024Í(char *s)Ö0Ïvoid +cmdlnoptsÌ16384Ö0Ïmyoption +comfdÌ16384Ö0Ïint +console_changedÌ16384Ö0Ïint +curspdÌ16384Ö0Ïint +daemonÌ64Îanon_struct_6Ö0Ïint +daemonizeÌ16Í()Ö0Ïvoid +daemonizeÌ1024Í()Ö0Ïvoid +dataÌ64Îanon_struct_4Ö0Ïchar * +deviceÌ64Îanon_struct_6Ö0Ïchar * +dtimeÌ16Í()Ö0Ïdouble +dtimeÌ1024Í()Ö0Ïdouble +end_optionÌ65536Ö0 +end_suboptionÌ65536Ö0 +errnoÌ65536Ö0 +error_tÌ4096Ö0Ïint +falseÌ65536Ö0 +flagÌ64Îanon_struct_2Ö0Ïint * +fpclassifyÌ131072Í(x)Ö0 +g_pr_Ì16Í(const char *fmt, ...)Ö0Ïint +get_aptrÌ16Í(void *paptr, argtype type)Ö0Ïvoid * +get_curspeedÌ16Í()Ö0Ïint +get_curspeedÌ1024Í()Ö0Ïint +get_optindÌ16Í(int opt, myoption *options)Ö0Ïint +get_suboptionÌ16Í(char *str, mysuboption *opt)Ö0Ïbool +get_suboptionÌ1024Í(char *str, mysuboption *opt)Ö0Ïbool +getcÌ131072Í(_fp)Ö0 +globErrÌ16384Ö0Ïint +globErrÌ32768Ö0Ïint +glob_parsÌ4096Ö0Ïanon_struct_6 +greenÌ1024Í(const char *fmt, ...)Ö0Ïint +has_argÌ64Îanon_struct_2Ö0Ïhasarg +has_argÌ64Îanon_struct_3Ö0Ïhasarg +hasargÌ4096Ö0Ïanon_enum_1 +helpÌ64Îanon_struct_2Ö0Ïconst char * +helpÌ16384Ö0Ïint +helpstringÌ16384Ö0Ïchar * +htobe16Ì131072Í(x)Ö0 +htobe32Ì131072Í(x)Ö0 +htobe64Ì131072Í(x)Ö0 +htole16Ì131072Í(x)Ö0 +htole32Ì131072Í(x)Ö0 +htole64Ì131072Í(x)Ö0 +initial_setupÌ16Í()Ö0Ïvoid +initial_setupÌ1024Í()Ö0Ïvoid +int_fast16_tÌ4096Ö0Ïlong int +int_fast32_tÌ4096Ö0Ïlong int +int_fast64_tÌ4096Ö0Ïlong int +int_fast8_tÌ4096Ö0Ïsigned char +int_least16_tÌ4096Ö0Ïshort int +int_least32_tÌ4096Ö0Ïint +int_least64_tÌ4096Ö0Ïlong int +int_least8_tÌ4096Ö0Ïsigned char +intmax_tÌ4096Ö0Ïlong int +isalnum_lÌ131072Í(c,l)Ö0 +isalpha_lÌ131072Í(c,l)Ö0 +isasciiÌ131072Í(c)Ö0 +isascii_lÌ131072Í(c,l)Ö0 +isblank_lÌ131072Í(c,l)Ö0 +iscntrl_lÌ131072Í(c,l)Ö0 +isdigit_lÌ131072Í(c,l)Ö0 +isfiniteÌ131072Í(x)Ö0 +isgraph_lÌ131072Í(c,l)Ö0 +isgreaterÌ131072Í(x,y)Ö0 +isgreaterequalÌ131072Í(x,y)Ö0 +isinfÌ131072Í(x)Ö0 +islessÌ131072Í(x,y)Ö0 +islessequalÌ131072Í(x,y)Ö0 +islessgreaterÌ131072Í(x,y)Ö0 +islower_lÌ131072Í(c,l)Ö0 +isnanÌ131072Í(x)Ö0 +isnormalÌ131072Í(x)Ö0 +isprint_lÌ131072Í(c,l)Ö0 +ispunct_lÌ131072Í(c,l)Ö0 +issignalingÌ131072Í(x)Ö0 +isspace_lÌ131072Í(c,l)Ö0 +isunorderedÌ131072Í(u,v)Ö0 +isupper_lÌ131072Í(c,l)Ö0 +isxdigit_lÌ131072Í(c,l)Ö0 +last_chksumÌ16384Ö0Ïuint8_t +le16tohÌ131072Í(x)Ö0 +le32tohÌ131072Í(x)Ö0 +le64tohÌ131072Í(x)Ö0 +lenÌ64Îanon_struct_4Ö0Ïsize_t +linuxÌ65536Ö0 +mainÌ16Í(int argc, char **argv)Ö0Ïint +majorÌ131072Í(dev)Ö0 +makedevÌ131072Í(maj,min)Ö0 +math_errhandlingÌ65536Ö0 +minorÌ131072Í(dev)Ö0 +mmapbufÌ4096Ö0Ïanon_struct_4 +my_allocÌ16Í(size_t N, size_t S)Ö0Ïvoid * +my_allocÌ1024Í(size_t N, size_t S)Ö0Ïvoid * +myatodÌ16Í(void *num, const char *str, argtype t)Ö0Ïbool +myatollÌ16Í(void *num, char *str, argtype t)Ö0Ïbool +mygetcharÌ16Í()Ö0Ïint +mygetcharÌ1024Í()Ö0Ïint +myoptionÌ4096Ö0Ïanon_struct_2 +mysuboptionÌ4096Ö0Ïanon_struct_3 +nameÌ64Îanon_struct_2Ö0Ïconst char * +nameÌ64Îanon_struct_3Ö0Ïconst char * +newtÌ16384Ö0Ïtermios +no_argumentÌ65536Ö0 +oldtÌ16384Ö0Ïtermios +oldttyÌ16384Ö0Ïtermio +open_serialÌ1024Í(char *dev)Ö0Ïint +optional_argumentÌ65536Ö0 +parse_argsÌ16Í(int argc, char **argv)Ö0Ïglob_pars * +parse_argsÌ1024Í(int argc, char **argv)Ö0Ïglob_pars * +parseargsÌ16Í(int *argc, char ***argv, myoption *options)Ö0Ïvoid +parseargsÌ1024Í(int *argc, char ***argv, myoption *options)Ö0Ïvoid +putcÌ131072Í(_ch,_fp)Ö0 +r_WARNÌ16Í(const char *fmt, ...)Ö0Ïint +r_pr_Ì16Í(const char *fmt, ...)Ö0Ïint +r_pr_nottyÌ16Í(const char *fmt, ...)Ö0Ïint +read_consoleÌ16Í()Ö0Ïint +read_consoleÌ1024Í()Ö0Ïint +read_ttyÌ16Í(uint8_t *buff, size_t length)Ö0Ïsize_t +read_ttyÌ1024Í(uint8_t *buff, size_t length)Ö0Ïsize_t +redÌ1024Í(const char *fmt, ...)Ö0Ïint +required_argumentÌ65536Ö0 +rest_parsÌ64Îanon_struct_6Ö0Ïchar * * +rest_pars_numÌ64Îanon_struct_6Ö0Ïint +restore_consoleÌ16Í()Ö0Ïvoid +restore_consoleÌ1024Í()Ö0Ïvoid +restore_ttyÌ16Í()Ö0Ïvoid +restore_ttyÌ1024Í()Ö0Ïvoid +rewrite_ifexistsÌ16384Ö0Ïint +rewrite_ifexistsÌ32768Ö0Ïint +run_terminalÌ16Í()Ö0Ïvoid +run_terminalÌ1024Í()Ö0Ïvoid +s_WARNÌ16Í(const char *fmt, ...)Ö0Ïint +send_cmdÌ16Í(uint8_t cmd)Ö0Ïint +send_dataÌ16Í(uint8_t *buf)Ö0Ïint +setup_conÌ16Í()Ö0Ïvoid +setup_conÌ1024Í()Ö0Ïvoid +showhelpÌ16Í(int oindex, myoption *options)Ö0Ïvoid +showhelpÌ1024Í(int oindex, myoption *options)Ö0Ïvoid +signalsÌ16Í(int signo)Ö0Ïvoid +signalsÌ1024Í(int sig)Ö0Ïvoid +signbitÌ131072Í(x)Ö0 +speedsÌ16384Ö0Ïint +speedssizeÌ16384Ö0Ïconst int +st_atimeÌ65536Ö0 +st_ctimeÌ65536Ö0 +st_mtimeÌ65536Ö0 +starsÌ16384Ö0Ïconst char +stderrÌ65536Ö0 +stdinÌ65536Ö0 +stdoutÌ65536Ö0 +str2doubleÌ16Í(double *num, const char *str)Ö0Ïint +str2doubleÌ1024Í(double *num, const char *str)Ö0Ïint +strdupaÌ131072Í(s)Ö0 +strndupaÌ131072Í(s,n)Ö0 +terminalÌ64Îanon_struct_6Ö0Ïint +timeraddÌ131072Í(a,b,result)Ö0 +timerclearÌ131072Í(tvp)Ö0 +timercmpÌ131072Í(a,b,CMP)Ö0 +timerissetÌ131072Í(tvp)Ö0 +timersubÌ131072Í(a,b,result)Ö0 +toasciiÌ131072Í(c)Ö0 +toascii_lÌ131072Í(c,l)Ö0 +trans_statusÌ4096Ö0Ïanon_enum_5 +trueÌ65536Ö0 +try_connectÌ16Í(char *device)Ö0Ïint +try_connectÌ1024Í(char *device)Ö0Ïint +ttyÌ16384Ö0Ïtermio +tty_initÌ16Í(char *comdev, tcflag_t speed)Ö0Ïvoid +tty_initÌ1024Í(char *comdev, tcflag_t speed)Ö0Ïvoid +typeÌ64Îanon_struct_2Ö0Ïargtype +typeÌ64Îanon_struct_3Ö0Ïargtype +uint16_tÌ4096Ö0Ïunsigned short int +uint32_tÌ4096Ö0Ïunsigned int +uint64_tÌ4096Ö0Ïunsigned long int +uint8_tÌ4096Ö0Ïunsigned char +uint_fast16_tÌ4096Ö0Ïunsigned long int +uint_fast32_tÌ4096Ö0Ïunsigned long int +uint_fast64_tÌ4096Ö0Ïunsigned long int +uint_fast8_tÌ4096Ö0Ïunsigned char +uint_least16_tÌ4096Ö0Ïunsigned short int +uint_least32_tÌ4096Ö0Ïunsigned int +uint_least64_tÌ4096Ö0Ïunsigned long int +uint_least8_tÌ4096Ö0Ïunsigned char +uintmax_tÌ4096Ö0Ïunsigned long int +uintptr_tÌ4096Ö0Ïunsigned long int +unixÌ65536Ö0 +va_argÌ131072Í(v,l)Ö0 +va_copyÌ131072Í(d,s)Ö0 +va_endÌ131072Í(v)Ö0 +va_startÌ131072Í(v,l)Ö0 +valÌ64Îanon_struct_2Ö0Ïint +verboseÌ16384Ö0Ïint +verboseÌ32768Ö0Ïint +w_coredumpÌ65536Ö0 +w_retcodeÌ65536Ö0 +w_stopsigÌ65536Ö0 +w_stopvalÌ65536Ö0 +w_termsigÌ65536Ö0 +wait4answerÌ16Í(uint8_t **rdata, int *rdlen)Ö0Ïtrans_status +wait_checksumÌ16Í()Ö0Ïtrans_status +write_ttyÌ16Í(uint8_t *buff, size_t length)Ö0Ïint +write_ttyÌ1024Í(uint8_t *buff, size_t length)Ö0Ïint diff --git a/term.c b/term.c new file mode 100644 index 0000000..856f9a5 --- /dev/null +++ b/term.c @@ -0,0 +1,192 @@ +/* + * client.c - simple terminal client + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 "usefull_macros.h" +#include "term.h" +/* +#include // tcsetattr +#include // tcsetattr, close, read, write +#include // ioctl +#include // printf, getchar, fopen, perror +#include // exit +#include // read +#include // read +#include // signal +#include // time +#include // memcpy +#include // int types +#include // gettimeofday +*/ +#define BUFLEN 1024 + +tcflag_t Bspeeds[] = { + B9600, + B19200, + B38400, + B57600, + B115200, + B230400, + B460800 +}; +static const int speedssize = (int)sizeof(Bspeeds)/sizeof(Bspeeds[0]); +static int curspd = -1; +int speeds[] = { + 9600, + 19200, + 38400, + 57600, + 115200, + 230400, + 460800 +}; + +/** + * Return -1 if not connected or value of current speed in bps + */ +int get_curspeed(){ + if(curspd < 0) return -1; + return speeds[curspd]; +} + +/** + * Send command by serial port, return 0 if all OK + */ +static uint8_t last_chksum = 0; +int send_data(uint8_t *buf){ + if(!*buf) return 1; + uint8_t chksum = 0, *ptr = buf; + int l; + for(l = 0; *ptr; ++l) + chksum ^= ~(*ptr++) & 0x7f; + DBG("send: %s%c", buf, (char)chksum); + if(write_tty(buf, l)) return 1; + if(write_tty(&chksum, 1)) return 1; + last_chksum = chksum; + return 0; +} +int send_cmd(uint8_t cmd){ + uint8_t s[2]; + s[0] = cmd; + s[1] = ~(cmd) & 0x7f; + if(write_tty(s, 2)) return 1; + last_chksum = s[1]; + return 0; +} + +/** + * Wait for answer with checksum + */ +trans_status wait_checksum(){ + double d0 = dtime(); + uint8_t chr; + do{ + if(read_tty(&chr, 1)) break; + }while(dtime() - d0 < 0.1); + if(dtime() - d0 >= 0.1) return TRANS_TIMEOUT; + if(chr != last_chksum) return TRANS_BADCHSUM; + return TRANS_SUCCEED; +} + + +/** + * wait for answer (not more than 0.1s) + * @param rdata (o) - readed data + * @param rdlen (o) - its length (static array - THREAD UNSAFE) + * @return transaction status + */ +trans_status wait4answer(uint8_t **rdata, int *rdlen){ + *rdlen = 0; + static uint8_t buf[128]; + int L = 0; + trans_status st = wait_checksum(); + if(st != TRANS_SUCCEED) return st; + double d0 = dtime(); + do{ + if((L = read_tty(buf, sizeof(buf)))) break; + }while(dtime() - d0 < 0.1); + if(!L) return TRANS_TIMEOUT; + *rdata = buf; + *rdlen = L; + return TRANS_SUCCEED; +} + +/** + * Try to connect to `device` at different speeds + * @return connection speed if success or 0 + */ +int try_connect(char *device){ + if(!device) return 0; + green(_("Connecting to %s... "), device); + for(curspd = 0; curspd < speedssize; ++curspd){ + tty_init(device, Bspeeds[curspd]); + DBG("Try speed %d", speeds[curspd]); + int ctr; + for(ctr = 0; ctr < 10; ++ctr){ // 10 tries to send data + if(send_cmd(CMD_COMM_TEST)) continue; + else break; + } + if(ctr == 10) continue; // error sending data + uint8_t *rd; + int l; + // OK, now check an answer + if(TRANS_SUCCEED != wait4answer(&rd, &l) || l != 1 || *rd != ANS_COMM_TEST) continue; + DBG("Got it!"); + green(_("Connection established at B%d.\n"), speeds[curspd]); + return speeds[curspd]; + } + green(_("No connection!")); + return 0; +} + +/** + * run terminal emulation: send user's commands with checksum and show answers + */ +void run_terminal(){ + green(_("Work in terminal mode without echo\n")); + int rb; + uint8_t buf[BUFLEN]; + size_t L; + setup_con(); + while(1){ + if((L = read_tty(buf, BUFLEN))){ + printf(_("Get data: ")); + uint8_t *ptr = buf; + while(L--){ + uint8_t c = *ptr++; + printf("0x%02x", c); + if(c > 31) printf("(%c)", (char)c); + printf(" "); + } + printf("\n"); + } + if((rb = read_console())){ + printf("Send command: %c ... ", (char)rb); + send_cmd((uint8_t)rb); + if(TRANS_SUCCEED != wait_checksum()) printf(_("Error.\n")); + else printf(_("Done.\n")); + } + } +} + +/** + * Run as daemon + */ +void daemonize(){ +} diff --git a/term.h b/term.h new file mode 100644 index 0000000..17ad829 --- /dev/null +++ b/term.h @@ -0,0 +1,46 @@ +/* + * term.h - functions to work with serial terminal + * + * Copyright 2017 Edward V. Emelianov + * + * 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 __TERM_H__ +#define __TERM_H__ + +// communication errors + +typedef enum{ + TRANS_SUCCEED = 0, // no errors + TRANS_BADCHSUM, // wrong checksum + TRANS_TIMEOUT // no data for 0.1s +} trans_status; + +/******************************** Commands definition ********************************/ +// communications test +#define CMD_COMM_TEST 'E' + +/******************************** Answers definition ********************************/ +#define ANS_COMM_TEST 'O' + +void run_terminal(); +void daemonize(); +int open_serial(char *dev); +int get_curspeed(); +int try_connect(char *device); + +#endif // __TERM_H__ diff --git a/usefull_macros.c b/usefull_macros.c new file mode 100644 index 0000000..f93a183 --- /dev/null +++ b/usefull_macros.c @@ -0,0 +1,369 @@ +/* + * usefull_macros.h - a set of usefull functions: memory, color etc + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 "usefull_macros.h" + +/** + * function for different purposes that need to know time intervals + * @return double value: time in seconds + */ +double dtime(){ + double t; + struct timeval tv; + gettimeofday(&tv, NULL); + t = tv.tv_sec + ((double)tv.tv_usec)/1e6; + return t; +} + +/******************************************************************************\ + * Coloured terminal +\******************************************************************************/ +int globErr = 0; // errno for WARN/ERR + +// pointers to coloured output printf +int (*red)(const char *fmt, ...); +int (*green)(const char *fmt, ...); +int (*_WARN)(const char *fmt, ...); + +/* + * format red / green messages + * name: r_pr_, g_pr_ + * @param fmt ... - printf-like format + * @return number of printed symbols + */ +int r_pr_(const char *fmt, ...){ + va_list ar; int i; + printf(RED); + va_start(ar, fmt); + i = vprintf(fmt, ar); + va_end(ar); + printf(OLDCOLOR); + return i; +} +int g_pr_(const char *fmt, ...){ + va_list ar; int i; + printf(GREEN); + va_start(ar, fmt); + i = vprintf(fmt, ar); + va_end(ar); + printf(OLDCOLOR); + return i; +} +/* + * print red error/warning messages (if output is a tty) + * @param fmt ... - printf-like format + * @return number of printed symbols + */ +int r_WARN(const char *fmt, ...){ + va_list ar; int i = 1; + fprintf(stderr, RED); + va_start(ar, fmt); + if(globErr){ + errno = globErr; + vwarn(fmt, ar); + errno = 0; + }else + i = vfprintf(stderr, fmt, ar); + va_end(ar); + i++; + fprintf(stderr, OLDCOLOR "\n"); + return i; +} + +static const char stars[] = "****************************************"; +/* + * notty variants of coloured printf + * name: s_WARN, r_pr_notty + * @param fmt ... - printf-like format + * @return number of printed symbols + */ +int s_WARN(const char *fmt, ...){ + va_list ar; int i; + i = fprintf(stderr, "\n%s\n", stars); + va_start(ar, fmt); + if(globErr){ + errno = globErr; + vwarn(fmt, ar); + errno = 0; + }else + i = +vfprintf(stderr, fmt, ar); + va_end(ar); + i += fprintf(stderr, "\n%s\n", stars); + i += fprintf(stderr, "\n"); + return i; +} +int r_pr_notty(const char *fmt, ...){ + va_list ar; int i; + i = printf("\n%s\n", stars); + va_start(ar, fmt); + i += vprintf(fmt, ar); + va_end(ar); + i += printf("\n%s\n", stars); + return i; +} + +/** + * Run this function in the beginning of main() to setup locale & coloured output + */ +void initial_setup(){ + // setup coloured output + if(isatty(STDOUT_FILENO)){ // make color output in tty + red = r_pr_; green = g_pr_; + }else{ // no colors in case of pipe + red = r_pr_notty; green = printf; + } + if(isatty(STDERR_FILENO)) _WARN = r_WARN; + else _WARN = s_WARN; + // Setup locale + setlocale(LC_ALL, ""); + setlocale(LC_NUMERIC, "C"); +#if defined GETTEXT_PACKAGE && defined LOCALEDIR + bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR); + textdomain(GETTEXT_PACKAGE); +#endif +} + +/******************************************************************************\ + * Memory +\******************************************************************************/ +/* + * safe memory allocation for macro ALLOC + * @param N - number of elements to allocate + * @param S - size of single element (typically sizeof) + * @return pointer to allocated memory area + */ +void *my_alloc(size_t N, size_t S){ + void *p = calloc(N, S); + if(!p) ERR("malloc"); + //assert(p); + return p; +} + +/** + * Mmap file to a memory area + * + * @param filename (i) - name of file to mmap + * @return stuct with mmap'ed file or die + */ +mmapbuf *My_mmap(char *filename){ + int fd; + char *ptr; + size_t Mlen; + struct stat statbuf; + /// "îÅ ÚÁÄÁÎÏ ÉÍÑ ÆÁÊÌÁ!" + if(!filename){ + WARNX(_("No filename given!")); + return NULL; + } + if((fd = open(filename, O_RDONLY)) < 0){ + /// "îÅ ÍÏÇÕ ÏÔËÒÙÔØ %s ÄÌÑ ÞÔÅÎÉÑ" + WARN(_("Can't open %s for reading"), filename); + return NULL; + } + if(fstat (fd, &statbuf) < 0){ + /// "îÅ ÍÏÇÕ ×ÙÐÏÌÎÉÔØ stat %s" + WARN(_("Can't stat %s"), filename); + close(fd); + return NULL; + } + Mlen = statbuf.st_size; + if((ptr = mmap (0, Mlen, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED){ + /// "ïÛÉÂËÁ mmap" + WARN(_("Mmap error for input")); + close(fd); + return NULL; + } + /// "îÅ ÍÏÇÕ ÚÁËÒÙÔØ mmap'ÎÕÔÙÊ ÆÁÊÌ" + if(close(fd)) WARN(_("Can't close mmap'ed file")); + mmapbuf *ret = MALLOC(mmapbuf, 1); + ret->data = ptr; + ret->len = Mlen; + return ret; +} + +void My_munmap(mmapbuf *b){ + if(munmap(b->data, b->len)){ + /// "îÅ ÍÏÇÕ munmap" + ERR(_("Can't munmap")); + } + FREE(b); +} + + +/******************************************************************************\ + * Terminal in no-echo mode +\******************************************************************************/ +static struct termios oldt, newt; // terminal flags +static int console_changed = 0; +// run on exit: +void restore_console(){ + if(console_changed) + tcsetattr(STDIN_FILENO, TCSANOW, &oldt); // return terminal to previous state + console_changed = 0; +} + +// initial setup: +void setup_con(){ + if(console_changed) return; + tcgetattr(STDIN_FILENO, &oldt); + newt = oldt; + newt.c_lflag &= ~(ICANON | ECHO); + if(tcsetattr(STDIN_FILENO, TCSANOW, &newt) < 0){ + /// "îÅ ÍÏÇÕ ÎÁÓÔÒÏÉÔØ ËÏÎÓÏÌØ" + WARN(_("Can't setup console")); + tcsetattr(STDIN_FILENO, TCSANOW, &oldt); + signals(0); //quit? + } + console_changed = 1; +} + +/** + * Read character from console without echo + * @return char readed + */ +int read_console(){ + int rb; + struct timeval tv; + int retval; + fd_set rfds; + FD_ZERO(&rfds); + FD_SET(STDIN_FILENO, &rfds); + tv.tv_sec = 0; tv.tv_usec = 10000; + retval = select(1, &rfds, NULL, NULL, &tv); + if(!retval) rb = 0; + else { + if(FD_ISSET(STDIN_FILENO, &rfds)) rb = getchar(); + else rb = 0; + } + return rb; +} + +/** + * getchar() without echo + * wait until at least one character pressed + * @return character readed + */ +int mygetchar(){ // getchar() without need of pressing ENTER + int ret; + do ret = read_console(); + while(ret == 0); + return ret; +} + + +/******************************************************************************\ + * TTY with select() +\******************************************************************************/ +static struct termio oldtty, tty; // TTY flags +static int comfd = -1; // TTY fd + +// run on exit: +void restore_tty(){ + if(comfd == -1) return; + ioctl(comfd, TCSANOW, &oldtty ); // return TTY to previous state + close(comfd); + comfd = -1; +} + +#ifndef BAUD_RATE +#define BAUD_RATE B9600 +#endif +// init: (speed = B9600 etc) +void tty_init(char *comdev, tcflag_t speed){ + DBG("Open port..."); + if ((comfd = open(comdev,O_RDWR|O_NOCTTY|O_NONBLOCK)) < 0){ + WARN("Can't use port %s\n",comdev); + ioctl(comfd, TCSANOW, &oldtty); // return TTY to previous state + close(comfd); + signals(0); // quit? + } + DBG("OK\nGet current settings..."); + if(ioctl(comfd,TCGETA,&oldtty) < 0){ // Get settings + /// "îÅ ÍÏÇÕ ÐÏÌÕÞÉÔØ ÎÁÓÔÒÏÊËÉ" + WARN(_("Can't get settings")); + signals(0); + } + tty = oldtty; + tty.c_lflag = 0; // ~(ICANON | ECHO | ECHOE | ISIG) + tty.c_oflag = 0; + tty.c_cflag = speed|CS8|CREAD|CLOCAL; // 9.6k, 8N1, RW, ignore line ctrl + tty.c_cc[VMIN] = 0; // non-canonical mode + tty.c_cc[VTIME] = 5; + if(ioctl(comfd,TCSETA,&tty) < 0){ + /// "îÅ ÍÏÇÕ ÕÓÔÁÎÏ×ÉÔØ ÎÁÓÔÒÏÊËÉ" + WARN(_("Can't set settings")); + signals(0); + } + DBG("OK"); +} +/** + * Read data from TTY + * @param buff (o) - buffer for data read + * @param length - buffer len + * @return amount of readed bytes + */ +size_t read_tty(uint8_t *buff, size_t length){ + ssize_t L = 0; + fd_set rfds; + struct timeval tv; + int retval; + FD_ZERO(&rfds); + FD_SET(comfd, &rfds); + tv.tv_sec = 0; tv.tv_usec = 50000; // wait for 50ms + retval = select(comfd + 1, &rfds, NULL, NULL, &tv); + if (!retval) return 0; + if(FD_ISSET(comfd, &rfds)){ + if((L = read(comfd, buff, length)) < 1) return 0; + } + return (size_t)L; +} + +int write_tty(uint8_t *buff, size_t length){ + ssize_t L = write(comfd, buff, length); + if((size_t)L != length){ + /// "ïÛÉÂËÁ ÚÁÐÉÓÉ!" + WARN("Write error!"); + return 1; + } + return 0; +} + + +/** + * Safely convert data from string to double + * + * @param num (o) - double number read from string + * @param str (i) - input string + * @return 1 if success, 0 if fails + */ +int str2double(double *num, const char *str){ + double res; + char *endptr; + if(!str) return 0; + res = strtod(str, &endptr); + if(endptr == str || *str == '\0' || *endptr != '\0'){ + /// "îÅÐÒÁ×ÉÌØÎÙÊ ÆÏÒÍÁÔ ÞÉÓÌÁ double!" + WARNX("Wrong double number format!"); + return FALSE; + } + if(num) *num = res; // you may run it like myatod(NULL, str) to test wether str is double number + return TRUE; +} diff --git a/usefull_macros.h b/usefull_macros.h new file mode 100644 index 0000000..c9c47e2 --- /dev/null +++ b/usefull_macros.h @@ -0,0 +1,140 @@ +/* + * usefull_macros.h - a set of usefull macros: memory, color etc + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 __USEFULL_MACROS_H__ +#define __USEFULL_MACROS_H__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if defined GETTEXT_PACKAGE && defined LOCALEDIR +/* + * GETTEXT + */ +#include +#define _(String) gettext(String) +#define gettext_noop(String) String +#define N_(String) gettext_noop(String) +#else +#define _(String) (String) +#define N_(String) (String) +#endif +#include +#include +#include +#include +#include +#include + + +// unused arguments with -Wall -Werror +#define _U_ __attribute__((__unused__)) + +/* + * Coloured messages output + */ +#define RED "\033[1;31;40m" +#define GREEN "\033[1;32;40m" +#define OLDCOLOR "\033[0;0;0m" + +#ifndef FALSE +#define FALSE (0) +#endif + +#ifndef TRUE +#define TRUE (1) +#endif + +/* + * ERROR/WARNING messages + */ +extern int globErr; +extern void signals(int sig); +#define ERR(...) do{globErr=errno; _WARN(__VA_ARGS__); signals(9);}while(0) +#define ERRX(...) do{globErr=0; _WARN(__VA_ARGS__); signals(9);}while(0) +#define WARN(...) do{globErr=errno; _WARN(__VA_ARGS__);}while(0) +#define WARNX(...) do{globErr=0; _WARN(__VA_ARGS__);}while(0) + +/* + * print function name, debug messages + * debug mode, -DEBUG + */ +#ifdef EBUG + #define FNAME() do{ fprintf(stderr, OLDCOLOR); \ + fprintf(stderr, "\n%s (%s, line %d)\n", __func__, __FILE__, __LINE__);} while(0) + #define DBG(...) do{ fprintf(stderr, OLDCOLOR); \ + fprintf(stderr, "%s (%s, line %d): ", __func__, __FILE__, __LINE__); \ + fprintf(stderr, __VA_ARGS__); \ + fprintf(stderr, "\n");} while(0) +#else + #define FNAME() do{}while(0) + #define DBG(...) do{}while(0) +#endif //EBUG + +/* + * Memory allocation + */ +#define ALLOC(type, var, size) type * var = ((type *)my_alloc(size, sizeof(type))) +#define MALLOC(type, size) ((type *)my_alloc(size, sizeof(type))) +#define FREE(ptr) do{if(ptr){free(ptr); ptr = NULL;}}while(0) + +#ifndef DBL_EPSILON +#define DBL_EPSILON (2.2204460492503131e-16) +#endif + +double dtime(); + +// functions for color output in tty & no-color in pipes +extern int (*red)(const char *fmt, ...); +extern int (*_WARN)(const char *fmt, ...); +extern int (*green)(const char *fmt, ...); +void * my_alloc(size_t N, size_t S); +void initial_setup(); + +// mmap file +typedef struct{ + char *data; + size_t len; +} mmapbuf; +mmapbuf *My_mmap(char *filename); +void My_munmap(mmapbuf *b); + +void restore_console(); +void setup_con(); +int read_console(); +int mygetchar(); + +void restore_tty(); +void tty_init(char *comdev, tcflag_t speed); +size_t read_tty(uint8_t *buff, size_t length); +int write_tty(uint8_t *buff, size_t length); + +int str2double(double *num, const char *str); + +#endif // __USEFULL_MACROS_H__