From 6c767296d53804145924383eb9500250126ec2e2 Mon Sep 17 00:00:00 2001 From: eddyem Date: Thu, 26 Jan 2017 18:37:16 +0300 Subject: [PATCH] initial commit - pre-alpha version --- Makefile | 47 + cmdlnopts.c | 86 ++ cmdlnopts.h | 44 + main.c | 47 + parseargs.c | 497 +++++++++ parseargs.h | 124 +++ sbig340.c.tags | 2546 ++++++++++++++++++++++++++++++++++++++++++++++ term.c | 192 ++++ term.h | 46 + usefull_macros.c | 369 +++++++ usefull_macros.h | 140 +++ 11 files changed, 4138 insertions(+) create mode 100644 Makefile create mode 100644 cmdlnopts.c create mode 100644 cmdlnopts.h create mode 100644 main.c create mode 100644 parseargs.c create mode 100644 parseargs.h create mode 100644 sbig340.c.tags create mode 100644 term.c create mode 100644 term.h create mode 100644 usefull_macros.c create mode 100644 usefull_macros.h 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__