From 8b00d6d1b96a0117b0ebfe18da3c93b6d4300441 Mon Sep 17 00:00:00 2001 From: eddyem Date: Thu, 1 Feb 2018 16:51:33 +0300 Subject: [PATCH] Add MMPP_control --- MMPP_control/MMPP_control.c.tags | 3500 ++++++++++++++++++++++++++++++ MMPP_control/Makefile | 43 + MMPP_control/Readme | 1 + MMPP_control/cmdlnopts.c | 93 + MMPP_control/cmdlnopts.h | 52 + MMPP_control/main.c | 163 ++ MMPP_control/mmppco.geanypro | 32 + MMPP_control/parseargs.c | 497 +++++ MMPP_control/parseargs.h | 124 ++ MMPP_control/tty_procs.c | 390 ++++ MMPP_control/tty_procs.h | 33 + MMPP_control/usefull_macros.c | 372 ++++ MMPP_control/usefull_macros.h | 141 ++ 13 files changed, 5441 insertions(+) create mode 100644 MMPP_control/MMPP_control.c.tags create mode 100644 MMPP_control/Makefile create mode 100644 MMPP_control/Readme create mode 100644 MMPP_control/cmdlnopts.c create mode 100644 MMPP_control/cmdlnopts.h create mode 100644 MMPP_control/main.c create mode 100644 MMPP_control/mmppco.geanypro create mode 100644 MMPP_control/parseargs.c create mode 100644 MMPP_control/parseargs.h create mode 100644 MMPP_control/tty_procs.c create mode 100644 MMPP_control/tty_procs.h create mode 100644 MMPP_control/usefull_macros.c create mode 100644 MMPP_control/usefull_macros.h diff --git a/MMPP_control/MMPP_control.c.tags b/MMPP_control/MMPP_control.c.tags new file mode 100644 index 0000000..77f283f --- /dev/null +++ b/MMPP_control/MMPP_control.c.tags @@ -0,0 +1,3500 @@ +# format=tagmanager +ACCESSPERMSÌ65536Ö0 +AIO_PRIO_DELTA_MAXÌ65536Ö0 +ALLOCÌ131072Í(type,var,size)Ö0 +ALLPERMSÌ65536Ö0 +APTRÌ131072Í(x)Ö0 +ARG_MAXÌ65536Ö0 +ASTRINGÌ131072Í(MACRO)Ö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 +BUFSIZÌ65536Ö0 +BUS_ADRALNÌ65536Ö0 +BUS_ADRERRÌ65536Ö0 +BUS_MCEERR_AOÌ65536Ö0 +BUS_MCEERR_ARÌ65536Ö0 +BUS_OBJERRÌ65536Ö0 +BYTE_ORDERÌ65536Ö0 +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 +CHAR_WIDTHÌ65536Ö0 +CIBAUDÌ65536Ö0 +CINTRÌ65536Ö0 +CKILLÌ65536Ö0 +CLD_CONTINUEDÌ65536Ö0 +CLD_DUMPEDÌ65536Ö0 +CLD_EXITEDÌ65536Ö0 +CLD_KILLEDÌ65536Ö0 +CLD_STOPPEDÌ65536Ö0 +CLD_TRAPPEDÌ65536Ö0 +CLNEXTÌ65536Ö0 +CLOCALÌ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 +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 +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_INSERT_RANGEÌ65536Ö0 +FALLOC_FL_KEEP_SIZEÌ65536Ö0 +FALLOC_FL_NO_HIDE_STALEÌ65536Ö0 +FALLOC_FL_PUNCH_HOLEÌ65536Ö0 +FALLOC_FL_UNSHARE_RANGEÌ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 +FPE_FLTDIVÌ65536Ö0 +FPE_FLTINVÌ65536Ö0 +FPE_FLTOVFÌ65536Ö0 +FPE_FLTRESÌ65536Ö0 +FPE_FLTSUBÌ65536Ö0 +FPE_FLTUNDÌ65536Ö0 +FPE_INTDIVÌ65536Ö0 +FPE_INTOVFÌ65536Ö0 +FP_ILOGB0Ì65536Ö0 +FP_ILOGBNANÌ65536Ö0 +FP_INFINITEÌ65536Ö0 +FP_INT_DOWNWARDÌ65536Ö0 +FP_INT_TONEARESTÌ65536Ö0 +FP_INT_TONEARESTFROMZEROÌ65536Ö0 +FP_INT_TOWARDZEROÌ65536Ö0 +FP_INT_UPWARDÌ65536Ö0 +FP_LLOGB0Ì65536Ö0 +FP_LLOGBNANÌ65536Ö0 +FP_NANÌ65536Ö0 +FP_NORMALÌ65536Ö0 +FP_SUBNORMALÌ65536Ö0 +FP_XSTATE_MAGIC1Ì65536Ö0 +FP_XSTATE_MAGIC2Ì65536Ö0 +FP_XSTATE_MAGIC2_SIZEÌ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 +GdefaultÌ32768Ö0Ïglob_pars const +HOST_NAME_MAXÌ65536Ö0 +HUGEÌ65536Ö0 +HUGE_VALÌ65536Ö0 +HUGE_VALFÌ65536Ö0 +HUGE_VALLÌ65536Ö0 +HUGE_VAL_F128Ì65536Ö0 +HUPCLÌ65536Ö0 +ICANONÌ65536Ö0 +ICRNLÌ65536Ö0 +IEXTENÌ65536Ö0 +IGNBRKÌ65536Ö0 +IGNCRÌ65536Ö0 +IGNPARÌ65536Ö0 +ILL_BADSTKÌ65536Ö0 +ILL_COPROCÌ65536Ö0 +ILL_ILLADRÌ65536Ö0 +ILL_ILLOPCÌ65536Ö0 +ILL_ILLOPNÌ65536Ö0 +ILL_ILLTRPÌ65536Ö0 +ILL_PRVOPCÌ65536Ö0 +ILL_PRVREGÌ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 +INT16_WIDTHÌ65536Ö0 +INT32_CÌ131072Í(c)Ö0 +INT32_MAXÌ65536Ö0 +INT32_MINÌ65536Ö0 +INT32_WIDTHÌ65536Ö0 +INT64_CÌ131072Í(c)Ö0 +INT64_MAXÌ65536Ö0 +INT64_MINÌ65536Ö0 +INT64_WIDTHÌ65536Ö0 +INT8_CÌ131072Í(c)Ö0 +INT8_MAXÌ65536Ö0 +INT8_MINÌ65536Ö0 +INT8_WIDTHÌ65536Ö0 +INTMAX_CÌ131072Í(c)Ö0 +INTMAX_MAXÌ65536Ö0 +INTMAX_MINÌ65536Ö0 +INTMAX_WIDTHÌ65536Ö0 +INTPTR_MAXÌ65536Ö0 +INTPTR_MINÌ65536Ö0 +INTPTR_WIDTHÌ65536Ö0 +INT_FAST16_MAXÌ65536Ö0 +INT_FAST16_MINÌ65536Ö0 +INT_FAST16_WIDTHÌ65536Ö0 +INT_FAST32_MAXÌ65536Ö0 +INT_FAST32_MINÌ65536Ö0 +INT_FAST32_WIDTHÌ65536Ö0 +INT_FAST64_MAXÌ65536Ö0 +INT_FAST64_MINÌ65536Ö0 +INT_FAST64_WIDTHÌ65536Ö0 +INT_FAST8_MAXÌ65536Ö0 +INT_FAST8_MINÌ65536Ö0 +INT_FAST8_WIDTHÌ65536Ö0 +INT_LEAST16_MAXÌ65536Ö0 +INT_LEAST16_MINÌ65536Ö0 +INT_LEAST16_WIDTHÌ65536Ö0 +INT_LEAST32_MAXÌ65536Ö0 +INT_LEAST32_MINÌ65536Ö0 +INT_LEAST32_WIDTHÌ65536Ö0 +INT_LEAST64_MAXÌ65536Ö0 +INT_LEAST64_MINÌ65536Ö0 +INT_LEAST64_WIDTHÌ65536Ö0 +INT_LEAST8_MAXÌ65536Ö0 +INT_LEAST8_MINÌ65536Ö0 +INT_LEAST8_WIDTHÌ65536Ö0 +INT_MAXÌ65536Ö0 +INT_MINÌ65536Ö0 +INT_WIDTHÌ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 +LLONG_WIDTHÌ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 +LONG_WIDTHÌ65536Ö0 +LT_OBJDIRÌ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_FREEÌ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 +MINSIGSTKSZÌ65536Ö0 +MQ_PRIO_MAXÌ65536Ö0 +MREMAP_FIXEDÌ65536Ö0 +MREMAP_MAYMOVEÌ65536Ö0 +MSGÌ16Í(const char *s1, const char *s2)Ö0Ïvoid +MS_ASYNCÌ65536Ö0 +MS_INVALIDATEÌ65536Ö0 +MS_SYNCÌ65536Ö0 +MULT_PARÌ4Îanon_enum_3Ö0 +M_1_PIÌ65536Ö0 +M_1_PIf128Ì65536Ö0 +M_1_PIlÌ65536Ö0 +M_2_PIÌ65536Ö0 +M_2_PIf128Ì65536Ö0 +M_2_PIlÌ65536Ö0 +M_2_SQRTPIÌ65536Ö0 +M_2_SQRTPIf128Ì65536Ö0 +M_2_SQRTPIlÌ65536Ö0 +M_EÌ65536Ö0 +M_Ef128Ì65536Ö0 +M_ElÌ65536Ö0 +M_LN10Ì65536Ö0 +M_LN10f128Ì65536Ö0 +M_LN10lÌ65536Ö0 +M_LN2Ì65536Ö0 +M_LN2f128Ì65536Ö0 +M_LN2lÌ65536Ö0 +M_LOG10EÌ65536Ö0 +M_LOG10Ef128Ì65536Ö0 +M_LOG10ElÌ65536Ö0 +M_LOG2EÌ65536Ö0 +M_LOG2Ef128Ì65536Ö0 +M_LOG2ElÌ65536Ö0 +M_PIÌ65536Ö0 +M_PI_2Ì65536Ö0 +M_PI_2f128Ì65536Ö0 +M_PI_2lÌ65536Ö0 +M_PI_4Ì65536Ö0 +M_PI_4f128Ì65536Ö0 +M_PI_4lÌ65536Ö0 +M_PIf128Ì65536Ö0 +M_PIlÌ65536Ö0 +M_SQRT1_2Ì65536Ö0 +M_SQRT1_2f128Ì65536Ö0 +M_SQRT1_2lÌ65536Ö0 +M_SQRT2Ì65536Ö0 +M_SQRT2f128Ì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_3Ö0 +NFDBITSÌ65536Ö0 +NGREGÌ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_3Ö0 +NR_OPENÌ65536Ö0 +NSIGÌ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_3Ö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 +POLL_ERRÌ65536Ö0 +POLL_HUPÌ65536Ö0 +POLL_INÌ65536Ö0 +POLL_MSGÌ65536Ö0 +POLL_OUTÌ65536Ö0 +POLL_PRIÌ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 +PTRDIFF_WIDTHÌ65536Ö0 +P_tmpdirÌ65536Ö0 +RAND_MAXÌ65536Ö0 +REDÌ65536Ö0 +REG_CR2Ì65536Ö0 +REG_CSGSFSÌ65536Ö0 +REG_EFLÌ65536Ö0 +REG_ERRÌ65536Ö0 +REG_OLDMASKÌ65536Ö0 +REG_R10Ì65536Ö0 +REG_R11Ì65536Ö0 +REG_R12Ì65536Ö0 +REG_R13Ì65536Ö0 +REG_R14Ì65536Ö0 +REG_R15Ì65536Ö0 +REG_R8Ì65536Ö0 +REG_R9Ì65536Ö0 +REG_RAXÌ65536Ö0 +REG_RBPÌ65536Ö0 +REG_RBXÌ65536Ö0 +REG_RCXÌ65536Ö0 +REG_RDIÌ65536Ö0 +REG_RDXÌ65536Ö0 +REG_RIPÌ65536Ö0 +REG_RSIÌ65536Ö0 +REG_RSPÌ65536Ö0 +REG_TRAPNOÌ65536Ö0 +RE_DUP_MAXÌ65536Ö0 +RTSIG_MAXÌ65536Ö0 +R_OKÌ65536Ö0 +SA_INTERRUPTÌ65536Ö0 +SA_NOCLDSTOPÌ65536Ö0 +SA_NOCLDWAITÌ65536Ö0 +SA_NODEFERÌ65536Ö0 +SA_NOMASKÌ65536Ö0 +SA_ONESHOTÌ65536Ö0 +SA_ONSTACKÌ65536Ö0 +SA_RESETHANDÌ65536Ö0 +SA_RESTARTÌ65536Ö0 +SA_SIGINFOÌ65536Ö0 +SA_STACKÌ65536Ö0 +SCHAR_MAXÌ65536Ö0 +SCHAR_MINÌ65536Ö0 +SCHAR_WIDTHÌ65536Ö0 +SEEK_CURÌ65536Ö0 +SEEK_DATAÌ65536Ö0 +SEEK_ENDÌ65536Ö0 +SEEK_HOLEÌ65536Ö0 +SEEK_SETÌ65536Ö0 +SEGV_ACCERRÌ65536Ö0 +SEGV_MAPERRÌ65536Ö0 +SEM_VALUE_MAXÌ65536Ö0 +SHRT_MAXÌ65536Ö0 +SHRT_MINÌ65536Ö0 +SHRT_WIDTHÌ65536Ö0 +SIGABRTÌ65536Ö0 +SIGALRMÌ65536Ö0 +SIGBUSÌ65536Ö0 +SIGCHLDÌ65536Ö0 +SIGCLDÌ65536Ö0 +SIGCONTÌ65536Ö0 +SIGEV_NONEÌ65536Ö0 +SIGEV_SIGNALÌ65536Ö0 +SIGEV_THREADÌ65536Ö0 +SIGEV_THREAD_IDÌ65536Ö0 +SIGFPEÌ65536Ö0 +SIGHUPÌ65536Ö0 +SIGILLÌ65536Ö0 +SIGINTÌ65536Ö0 +SIGIOÌ65536Ö0 +SIGIOTÌ65536Ö0 +SIGKILLÌ65536Ö0 +SIGPIPEÌ65536Ö0 +SIGPOLLÌ65536Ö0 +SIGPROFÌ65536Ö0 +SIGPWRÌ65536Ö0 +SIGQUITÌ65536Ö0 +SIGRTMAXÌ65536Ö0 +SIGRTMINÌ65536Ö0 +SIGSEGVÌ65536Ö0 +SIGSTKFLTÌ65536Ö0 +SIGSTKSZÌ65536Ö0 +SIGSTOPÌ65536Ö0 +SIGSYSÌ65536Ö0 +SIGTERMÌ65536Ö0 +SIGTRAPÌ65536Ö0 +SIGTSTPÌ65536Ö0 +SIGTTINÌ65536Ö0 +SIGTTOUÌ65536Ö0 +SIGURGÌ65536Ö0 +SIGUSR1Ì65536Ö0 +SIGUSR2Ì65536Ö0 +SIGVTALRMÌ65536Ö0 +SIGWINCHÌ65536Ö0 +SIGXCPUÌ65536Ö0 +SIGXFSZÌ65536Ö0 +SIG_ATOMIC_MAXÌ65536Ö0 +SIG_ATOMIC_MINÌ65536Ö0 +SIG_ATOMIC_WIDTHÌ65536Ö0 +SIG_BLOCKÌ65536Ö0 +SIG_DFLÌ65536Ö0 +SIG_ERRÌ65536Ö0 +SIG_HOLDÌ65536Ö0 +SIG_IGNÌ65536Ö0 +SIG_SETMASKÌ65536Ö0 +SIG_UNBLOCKÌ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 +SIZE_WIDTHÌ65536Ö0 +SI_ASYNCIOÌ65536Ö0 +SI_ASYNCNLÌ65536Ö0 +SI_KERNELÌ65536Ö0 +SI_MESGQÌ65536Ö0 +SI_QUEUEÌ65536Ö0 +SI_SIGIOÌ65536Ö0 +SI_TIMERÌ65536Ö0 +SI_TKILLÌ65536Ö0 +SI_USERÌ65536Ö0 +SNANÌ65536Ö0 +SNANFÌ65536Ö0 +SNANF128Ì65536Ö0 +SNANLÌ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 +SS_DISABLEÌ65536Ö0 +SS_ONSTACKÌ65536Ö0 +STDC_HEADERSÌ65536Ö0 +STDERR_FILENOÌ65536Ö0 +STDIN_FILENOÌ65536Ö0 +STDOUT_FILENOÌ65536Ö0 +STRINGÌ131072Í(MACRO)Ö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 +TBUFLENÌ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 +TIOCGPTPEERÌ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 +TRAP_BRKPTÌ65536Ö0 +TRAP_TRACEÌ65536Ö0 +TRUEÌ65536Ö0 +TTYDEF_CFLAGÌ65536Ö0 +TTYDEF_IFLAGÌ65536Ö0 +TTYDEF_LFLAGÌ65536Ö0 +TTYDEF_OFLAGÌ65536Ö0 +TTYDEF_SPEEDÌ65536Ö0 +TTYTIMEOUTÌ65536Ö0 +TTY_NAME_MAXÌ65536Ö0 +UCHAR_MAXÌ65536Ö0 +UCHAR_WIDTHÌ65536Ö0 +UINT16_CÌ131072Í(c)Ö0 +UINT16_MAXÌ65536Ö0 +UINT16_WIDTHÌ65536Ö0 +UINT32_CÌ131072Í(c)Ö0 +UINT32_MAXÌ65536Ö0 +UINT32_WIDTHÌ65536Ö0 +UINT64_CÌ131072Í(c)Ö0 +UINT64_MAXÌ65536Ö0 +UINT64_WIDTHÌ65536Ö0 +UINT8_CÌ131072Í(c)Ö0 +UINT8_MAXÌ65536Ö0 +UINT8_WIDTHÌ65536Ö0 +UINTMAX_CÌ131072Í(c)Ö0 +UINTMAX_MAXÌ65536Ö0 +UINTMAX_WIDTHÌ65536Ö0 +UINTPTR_MAXÌ65536Ö0 +UINTPTR_WIDTHÌ65536Ö0 +UINT_FAST16_MAXÌ65536Ö0 +UINT_FAST16_WIDTHÌ65536Ö0 +UINT_FAST32_MAXÌ65536Ö0 +UINT_FAST32_WIDTHÌ65536Ö0 +UINT_FAST64_MAXÌ65536Ö0 +UINT_FAST64_WIDTHÌ65536Ö0 +UINT_FAST8_MAXÌ65536Ö0 +UINT_FAST8_WIDTHÌ65536Ö0 +UINT_LEAST16_MAXÌ65536Ö0 +UINT_LEAST16_WIDTHÌ65536Ö0 +UINT_LEAST32_MAXÌ65536Ö0 +UINT_LEAST32_WIDTHÌ65536Ö0 +UINT_LEAST64_MAXÌ65536Ö0 +UINT_LEAST64_WIDTHÌ65536Ö0 +UINT_LEAST8_MAXÌ65536Ö0 +UINT_LEAST8_WIDTHÌ65536Ö0 +UINT_MAXÌ65536Ö0 +UINT_WIDTHÌ65536Ö0 +ULLONG_MAXÌ65536Ö0 +ULLONG_WIDTHÌ65536Ö0 +ULONG_LONG_MAXÌ65536Ö0 +ULONG_MAXÌ65536Ö0 +ULONG_WIDTHÌ65536Ö0 +UNDERFLOWÌ65536Ö0 +USHRT_MAXÌ65536Ö0 +USHRT_WIDTHÌ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 +WCHAR_WIDTHÌ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 +WINT_WIDTHÌ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_ERRNO_HÌ65536Ö0 +_BITS_FLOATN_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_ARCH_HÌ65536Ö0 +_BITS_PTHREADTYPES_COMMON_HÌ65536Ö0 +_BITS_SIGCONTEXT_HÌ65536Ö0 +_BITS_SIGEVENT_CONSTS_HÌ65536Ö0 +_BITS_SIGINFO_ARCH_HÌ65536Ö0 +_BITS_SIGINFO_CONSTS_ARCH_HÌ65536Ö0 +_BITS_SIGINFO_CONSTS_HÌ65536Ö0 +_BITS_SIGNUM_GENERIC_HÌ65536Ö0 +_BITS_SIGNUM_HÌ65536Ö0 +_BITS_SIGSTACK_HÌ65536Ö0 +_BITS_SIGTHREAD_HÌ65536Ö0 +_BITS_SS_FLAGS_HÌ65536Ö0 +_BITS_STAT_HÌ65536Ö0 +_BITS_STDINT_INTN_HÌ65536Ö0 +_BITS_STDINT_UINTN_HÌ65536Ö0 +_BITS_STDIO_LIM_HÌ65536Ö0 +_BITS_STRING_FORTIFIED_HÌ65536Ö0 +_BITS_TYPESIZES_HÌ65536Ö0 +_BITS_TYPES_HÌ65536Ö0 +_BITS_TYPES_LOCALE_T_HÌ65536Ö0 +_BITS_TYPES___LOCALE_T_HÌ65536Ö0 +_BITS_UINTN_IDENTITY_HÌ65536Ö0 +_BITS_UIO_LIM_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 +_CPP_TYPE_TRAITS_HÌ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 +_EXT_TYPE_TRAITSÌ65536Ö0 +_ExitÌ65536Ö0 +_FALLOC_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_CORE_HÌ65536Ö0 +_GETOPT_EXT_HÌ65536Ö0 +_GETOPT_HÌ65536Ö0 +_GETOPT_POSIX_HÌ65536Ö0 +_GLIBCXX11_USE_C99_COMPLEXÌ65536Ö0 +_GLIBCXX11_USE_C99_MATHÌ65536Ö0 +_GLIBCXX11_USE_C99_STDIOÌ65536Ö0 +_GLIBCXX11_USE_C99_STDLIBÌ65536Ö0 +_GLIBCXX11_USE_C99_WCHARÌ65536Ö0 +_GLIBCXX14_CONSTEXPRÌ65536Ö0 +_GLIBCXX98_USE_C99_COMPLEXÌ65536Ö0 +_GLIBCXX98_USE_C99_MATHÌ65536Ö0 +_GLIBCXX98_USE_C99_STDIOÌ65536Ö0 +_GLIBCXX98_USE_C99_STDLIBÌ65536Ö0 +_GLIBCXX98_USE_C99_WCHARÌ65536Ö0 +_GLIBCXX_ABI_TAG_CXX11Ì65536Ö0 +_GLIBCXX_ATOMIC_BUILTINSÌ65536Ö0 +_GLIBCXX_BEGIN_EXTERN_CÌ65536Ö0 +_GLIBCXX_BEGIN_NAMESPACE_ALGOÌ65536Ö0 +_GLIBCXX_BEGIN_NAMESPACE_CONTAINERÌ65536Ö0 +_GLIBCXX_BEGIN_NAMESPACE_CXX11Ì65536Ö0 +_GLIBCXX_BEGIN_NAMESPACE_LDBLÌ65536Ö0 +_GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11Ì65536Ö0 +_GLIBCXX_BEGIN_NAMESPACE_VERSIONÌ65536Ö0 +_GLIBCXX_CMATHÌ65536Ö0 +_GLIBCXX_CONSTÌ65536Ö0 +_GLIBCXX_CONSTEXPRÌ65536Ö0 +_GLIBCXX_CPU_DEFINESÌ65536Ö0 +_GLIBCXX_CSTDLIBÌ65536Ö0 +_GLIBCXX_CXX_CONFIG_HÌ65536Ö0 +_GLIBCXX_DEFAULT_ABI_TAGÌ65536Ö0 +_GLIBCXX_DEPRECATEDÌ65536Ö0 +_GLIBCXX_END_EXTERN_CÌ65536Ö0 +_GLIBCXX_END_NAMESPACE_ALGOÌ65536Ö0 +_GLIBCXX_END_NAMESPACE_CONTAINERÌ65536Ö0 +_GLIBCXX_END_NAMESPACE_CXX11Ì65536Ö0 +_GLIBCXX_END_NAMESPACE_LDBLÌ65536Ö0 +_GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11Ì65536Ö0 +_GLIBCXX_END_NAMESPACE_VERSIONÌ65536Ö0 +_GLIBCXX_EXTERN_TEMPLATEÌ65536Ö0 +_GLIBCXX_FAST_MATHÌ65536Ö0 +_GLIBCXX_FULLY_DYNAMIC_STRINGÌ65536Ö0 +_GLIBCXX_HAS_GTHREADSÌ65536Ö0 +_GLIBCXX_HAVE_ACOSFÌ65536Ö0 +_GLIBCXX_HAVE_ACOSLÌ65536Ö0 +_GLIBCXX_HAVE_ASINFÌ65536Ö0 +_GLIBCXX_HAVE_ASINLÌ65536Ö0 +_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVEÌ65536Ö0 +_GLIBCXX_HAVE_ATAN2FÌ65536Ö0 +_GLIBCXX_HAVE_ATAN2LÌ65536Ö0 +_GLIBCXX_HAVE_ATANFÌ65536Ö0 +_GLIBCXX_HAVE_ATANLÌ65536Ö0 +_GLIBCXX_HAVE_ATTRIBUTE_VISIBILITYÌ65536Ö0 +_GLIBCXX_HAVE_AT_QUICK_EXITÌ65536Ö0 +_GLIBCXX_HAVE_CEILFÌ65536Ö0 +_GLIBCXX_HAVE_CEILLÌ65536Ö0 +_GLIBCXX_HAVE_COMPLEX_HÌ65536Ö0 +_GLIBCXX_HAVE_COSFÌ65536Ö0 +_GLIBCXX_HAVE_COSHFÌ65536Ö0 +_GLIBCXX_HAVE_COSHLÌ65536Ö0 +_GLIBCXX_HAVE_COSLÌ65536Ö0 +_GLIBCXX_HAVE_DIRENT_HÌ65536Ö0 +_GLIBCXX_HAVE_DLFCN_HÌ65536Ö0 +_GLIBCXX_HAVE_EBADMSGÌ65536Ö0 +_GLIBCXX_HAVE_ECANCELEDÌ65536Ö0 +_GLIBCXX_HAVE_ECHILDÌ65536Ö0 +_GLIBCXX_HAVE_EIDRMÌ65536Ö0 +_GLIBCXX_HAVE_ENDIAN_HÌ65536Ö0 +_GLIBCXX_HAVE_ENODATAÌ65536Ö0 +_GLIBCXX_HAVE_ENOLINKÌ65536Ö0 +_GLIBCXX_HAVE_ENOSPCÌ65536Ö0 +_GLIBCXX_HAVE_ENOSRÌ65536Ö0 +_GLIBCXX_HAVE_ENOSTRÌ65536Ö0 +_GLIBCXX_HAVE_ENOTRECOVERABLEÌ65536Ö0 +_GLIBCXX_HAVE_ENOTSUPÌ65536Ö0 +_GLIBCXX_HAVE_EOVERFLOWÌ65536Ö0 +_GLIBCXX_HAVE_EOWNERDEADÌ65536Ö0 +_GLIBCXX_HAVE_EPERMÌ65536Ö0 +_GLIBCXX_HAVE_EPROTOÌ65536Ö0 +_GLIBCXX_HAVE_ETIMEÌ65536Ö0 +_GLIBCXX_HAVE_ETIMEDOUTÌ65536Ö0 +_GLIBCXX_HAVE_ETXTBSYÌ65536Ö0 +_GLIBCXX_HAVE_EWOULDBLOCKÌ65536Ö0 +_GLIBCXX_HAVE_EXECINFO_HÌ65536Ö0 +_GLIBCXX_HAVE_EXPFÌ65536Ö0 +_GLIBCXX_HAVE_EXPLÌ65536Ö0 +_GLIBCXX_HAVE_FABSFÌ65536Ö0 +_GLIBCXX_HAVE_FABSLÌ65536Ö0 +_GLIBCXX_HAVE_FCNTL_HÌ65536Ö0 +_GLIBCXX_HAVE_FENV_HÌ65536Ö0 +_GLIBCXX_HAVE_FINITEÌ65536Ö0 +_GLIBCXX_HAVE_FINITEFÌ65536Ö0 +_GLIBCXX_HAVE_FINITELÌ65536Ö0 +_GLIBCXX_HAVE_FLOAT_HÌ65536Ö0 +_GLIBCXX_HAVE_FLOORFÌ65536Ö0 +_GLIBCXX_HAVE_FLOORLÌ65536Ö0 +_GLIBCXX_HAVE_FMODFÌ65536Ö0 +_GLIBCXX_HAVE_FMODLÌ65536Ö0 +_GLIBCXX_HAVE_FREXPFÌ65536Ö0 +_GLIBCXX_HAVE_FREXPLÌ65536Ö0 +_GLIBCXX_HAVE_GETIPINFOÌ65536Ö0 +_GLIBCXX_HAVE_GETSÌ65536Ö0 +_GLIBCXX_HAVE_HYPOTÌ65536Ö0 +_GLIBCXX_HAVE_HYPOTFÌ65536Ö0 +_GLIBCXX_HAVE_HYPOTLÌ65536Ö0 +_GLIBCXX_HAVE_ICONVÌ65536Ö0 +_GLIBCXX_HAVE_INT64_TÌ65536Ö0 +_GLIBCXX_HAVE_INT64_T_LONGÌ65536Ö0 +_GLIBCXX_HAVE_INTTYPES_HÌ65536Ö0 +_GLIBCXX_HAVE_ISINFFÌ65536Ö0 +_GLIBCXX_HAVE_ISINFLÌ65536Ö0 +_GLIBCXX_HAVE_ISNANFÌ65536Ö0 +_GLIBCXX_HAVE_ISNANLÌ65536Ö0 +_GLIBCXX_HAVE_ISWBLANKÌ65536Ö0 +_GLIBCXX_HAVE_LC_MESSAGESÌ65536Ö0 +_GLIBCXX_HAVE_LDEXPFÌ65536Ö0 +_GLIBCXX_HAVE_LDEXPLÌ65536Ö0 +_GLIBCXX_HAVE_LIBINTL_HÌ65536Ö0 +_GLIBCXX_HAVE_LIMIT_ASÌ65536Ö0 +_GLIBCXX_HAVE_LIMIT_DATAÌ65536Ö0 +_GLIBCXX_HAVE_LIMIT_FSIZEÌ65536Ö0 +_GLIBCXX_HAVE_LIMIT_RSSÌ65536Ö0 +_GLIBCXX_HAVE_LIMIT_VMEMÌ65536Ö0 +_GLIBCXX_HAVE_LINUX_FUTEXÌ65536Ö0 +_GLIBCXX_HAVE_LOCALE_HÌ65536Ö0 +_GLIBCXX_HAVE_LOG10FÌ65536Ö0 +_GLIBCXX_HAVE_LOG10LÌ65536Ö0 +_GLIBCXX_HAVE_LOGFÌ65536Ö0 +_GLIBCXX_HAVE_LOGLÌ65536Ö0 +_GLIBCXX_HAVE_MBSTATE_TÌ65536Ö0 +_GLIBCXX_HAVE_MEMORY_HÌ65536Ö0 +_GLIBCXX_HAVE_MODFÌ65536Ö0 +_GLIBCXX_HAVE_MODFFÌ65536Ö0 +_GLIBCXX_HAVE_MODFLÌ65536Ö0 +_GLIBCXX_HAVE_POLLÌ65536Ö0 +_GLIBCXX_HAVE_POWFÌ65536Ö0 +_GLIBCXX_HAVE_POWLÌ65536Ö0 +_GLIBCXX_HAVE_QUICK_EXITÌ65536Ö0 +_GLIBCXX_HAVE_SETENVÌ65536Ö0 +_GLIBCXX_HAVE_SINCOSÌ65536Ö0 +_GLIBCXX_HAVE_SINCOSFÌ65536Ö0 +_GLIBCXX_HAVE_SINCOSLÌ65536Ö0 +_GLIBCXX_HAVE_SINFÌ65536Ö0 +_GLIBCXX_HAVE_SINHFÌ65536Ö0 +_GLIBCXX_HAVE_SINHLÌ65536Ö0 +_GLIBCXX_HAVE_SINLÌ65536Ö0 +_GLIBCXX_HAVE_SQRTFÌ65536Ö0 +_GLIBCXX_HAVE_SQRTLÌ65536Ö0 +_GLIBCXX_HAVE_STDALIGN_HÌ65536Ö0 +_GLIBCXX_HAVE_STDBOOL_HÌ65536Ö0 +_GLIBCXX_HAVE_STDINT_HÌ65536Ö0 +_GLIBCXX_HAVE_STDLIB_HÌ65536Ö0 +_GLIBCXX_HAVE_STRERROR_LÌ65536Ö0 +_GLIBCXX_HAVE_STRERROR_RÌ65536Ö0 +_GLIBCXX_HAVE_STRINGS_HÌ65536Ö0 +_GLIBCXX_HAVE_STRING_HÌ65536Ö0 +_GLIBCXX_HAVE_STRTOFÌ65536Ö0 +_GLIBCXX_HAVE_STRTOLDÌ65536Ö0 +_GLIBCXX_HAVE_STRUCT_DIRENT_D_TYPEÌ65536Ö0 +_GLIBCXX_HAVE_STRXFRM_LÌ65536Ö0 +_GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORTÌ65536Ö0 +_GLIBCXX_HAVE_SYS_IOCTL_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_IPC_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_PARAM_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_RESOURCE_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_SEM_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_STATVFS_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_STAT_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_SYSINFO_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_TIME_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_TYPES_HÌ65536Ö0 +_GLIBCXX_HAVE_SYS_UIO_HÌ65536Ö0 +_GLIBCXX_HAVE_S_ISREGÌ65536Ö0 +_GLIBCXX_HAVE_TANFÌ65536Ö0 +_GLIBCXX_HAVE_TANHFÌ65536Ö0 +_GLIBCXX_HAVE_TANHLÌ65536Ö0 +_GLIBCXX_HAVE_TANLÌ65536Ö0 +_GLIBCXX_HAVE_TGMATH_HÌ65536Ö0 +_GLIBCXX_HAVE_TLSÌ65536Ö0 +_GLIBCXX_HAVE_UCHAR_HÌ65536Ö0 +_GLIBCXX_HAVE_UNISTD_HÌ65536Ö0 +_GLIBCXX_HAVE_UTIME_HÌ65536Ö0 +_GLIBCXX_HAVE_VFWSCANFÌ65536Ö0 +_GLIBCXX_HAVE_VSWSCANFÌ65536Ö0 +_GLIBCXX_HAVE_VWSCANFÌ65536Ö0 +_GLIBCXX_HAVE_WCHAR_HÌ65536Ö0 +_GLIBCXX_HAVE_WCSTOFÌ65536Ö0 +_GLIBCXX_HAVE_WCTYPE_HÌ65536Ö0 +_GLIBCXX_HAVE_WRITEVÌ65536Ö0 +_GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPLÌ65536Ö0 +_GLIBCXX_HOSTEDÌ65536Ö0 +_GLIBCXX_ICONV_CONSTÌ65536Ö0 +_GLIBCXX_INCLUDE_NEXT_C_HEADERSÌ65536Ö0 +_GLIBCXX_INLINE_VERSIONÌ65536Ö0 +_GLIBCXX_LONG_DOUBLE_COMPATÌ65536Ö0 +_GLIBCXX_MANGLE_SIZE_TÌ65536Ö0 +_GLIBCXX_MATH_HÌ65536Ö0 +_GLIBCXX_NAMESPACE_CXX11Ì65536Ö0 +_GLIBCXX_NAMESPACE_LDBLÌ65536Ö0 +_GLIBCXX_NAMESPACE_LDBL_OR_CXX11Ì65536Ö0 +_GLIBCXX_NOEXCEPTÌ65536Ö0 +_GLIBCXX_NOEXCEPT_IFÌ131072Í(_COND)Ö0 +_GLIBCXX_NORETURNÌ65536Ö0 +_GLIBCXX_NOTHROWÌ65536Ö0 +_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMICÌ65536Ö0 +_GLIBCXX_OS_DEFINESÌ65536Ö0 +_GLIBCXX_PACKAGE_BUGREPORTÌ65536Ö0 +_GLIBCXX_PACKAGE_NAMEÌ65536Ö0 +_GLIBCXX_PACKAGE_STRINGÌ65536Ö0 +_GLIBCXX_PACKAGE_TARNAMEÌ65536Ö0 +_GLIBCXX_PACKAGE_URLÌ65536Ö0 +_GLIBCXX_PACKAGE__GLIBCXX_VERSIONÌ65536Ö0 +_GLIBCXX_PSEUDO_VISIBILITYÌ131072Í(V)Ö0 +_GLIBCXX_PUREÌ65536Ö0 +_GLIBCXX_RES_LIMITSÌ65536Ö0 +_GLIBCXX_STDIO_EOFÌ65536Ö0 +_GLIBCXX_STDIO_SEEK_CURÌ65536Ö0 +_GLIBCXX_STDIO_SEEK_ENDÌ65536Ö0 +_GLIBCXX_STDLIB_HÌ65536Ö0 +_GLIBCXX_STD_AÌ65536Ö0 +_GLIBCXX_STD_CÌ65536Ö0 +_GLIBCXX_SYMVERÌ65536Ö0 +_GLIBCXX_SYMVER_GNUÌ65536Ö0 +_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTERÌ131072Í(A)Ö0 +_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFOREÌ131072Í(A)Ö0 +_GLIBCXX_THROWÌ131072Í(_EXC)Ö0 +_GLIBCXX_THROW_OR_ABORTÌ131072Í(_EXC)Ö0 +_GLIBCXX_TXN_SAFEÌ65536Ö0 +_GLIBCXX_TXN_SAFE_DYNÌ65536Ö0 +_GLIBCXX_USE_ALLOCATOR_NEWÌ65536Ö0 +_GLIBCXX_USE_C11_UCHAR_CXX11Ì65536Ö0 +_GLIBCXX_USE_C99Ì65536Ö0 +_GLIBCXX_USE_C99_COMPLEXÌ65536Ö0 +_GLIBCXX_USE_C99_COMPLEX_TR1Ì65536Ö0 +_GLIBCXX_USE_C99_CTYPE_TR1Ì65536Ö0 +_GLIBCXX_USE_C99_FENV_TR1Ì65536Ö0 +_GLIBCXX_USE_C99_INTTYPES_TR1Ì65536Ö0 +_GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1Ì65536Ö0 +_GLIBCXX_USE_C99_MATHÌ65536Ö0 +_GLIBCXX_USE_C99_MATH_TR1Ì65536Ö0 +_GLIBCXX_USE_C99_STDINT_TR1Ì65536Ö0 +_GLIBCXX_USE_C99_STDIOÌ65536Ö0 +_GLIBCXX_USE_C99_STDLIBÌ65536Ö0 +_GLIBCXX_USE_C99_WCHARÌ65536Ö0 +_GLIBCXX_USE_CLOCK_MONOTONICÌ65536Ö0 +_GLIBCXX_USE_CLOCK_REALTIMEÌ65536Ö0 +_GLIBCXX_USE_CONSTEXPRÌ65536Ö0 +_GLIBCXX_USE_CXX11_ABIÌ65536Ö0 +_GLIBCXX_USE_DECIMAL_FLOATÌ65536Ö0 +_GLIBCXX_USE_DEPRECATEDÌ65536Ö0 +_GLIBCXX_USE_DUAL_ABIÌ65536Ö0 +_GLIBCXX_USE_FCHMODÌ65536Ö0 +_GLIBCXX_USE_FCHMODATÌ65536Ö0 +_GLIBCXX_USE_FLOAT128Ì65536Ö0 +_GLIBCXX_USE_GETTIMEOFDAYÌ65536Ö0 +_GLIBCXX_USE_GET_NPROCSÌ65536Ö0 +_GLIBCXX_USE_INT128Ì65536Ö0 +_GLIBCXX_USE_LFSÌ65536Ö0 +_GLIBCXX_USE_LONG_LONGÌ65536Ö0 +_GLIBCXX_USE_NANOSLEEPÌ65536Ö0 +_GLIBCXX_USE_NLSÌ65536Ö0 +_GLIBCXX_USE_NOEXCEPTÌ65536Ö0 +_GLIBCXX_USE_PTHREAD_RWLOCK_TÌ65536Ö0 +_GLIBCXX_USE_RANDOM_TR1Ì65536Ö0 +_GLIBCXX_USE_REALPATHÌ65536Ö0 +_GLIBCXX_USE_SCHED_YIELDÌ65536Ö0 +_GLIBCXX_USE_SC_NPROCESSORS_ONLNÌ65536Ö0 +_GLIBCXX_USE_SENDFILEÌ65536Ö0 +_GLIBCXX_USE_ST_MTIMÌ65536Ö0 +_GLIBCXX_USE_TMPNAMÌ65536Ö0 +_GLIBCXX_USE_UTIMENSATÌ65536Ö0 +_GLIBCXX_USE_WCHAR_TÌ65536Ö0 +_GLIBCXX_USE_WEAK_REFÌ65536Ö0 +_GLIBCXX_VERBOSEÌ65536Ö0 +_GLIBCXX_VISIBILITYÌ131072Í(V)Ö0 +_GLIBCXX_WEAK_DEFINITIONÌ65536Ö0 +_GLIBCXX_X86_RDRANDÌ65536Ö0 +_GNU_SOURCEÌ65536Ö0 +_GTHREAD_USE_MUTEX_TIMEDLOCKÌ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_need_lockÌ131072Í(_fp)Ö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 +_MKNOD_VERÌ65536Ö0 +_MKNOD_VER_LINUXÌ65536Ö0 +_Mdouble_Ì65536Ö0 +_Mfloat128_Ì65536Ö0 +_Mfloat_Ì65536Ö0 +_Mlong_double_Ì65536Ö0 +_NSIGÌ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 +_SIGNAL_HÌ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 +_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_TIME_HÌ65536Ö0 +_SYS_TTYDEFAULTS_H_Ì65536Ö0 +_SYS_TYPES_HÌ65536Ö0 +_SYS_UCONTEXT_HÌ65536Ö0 +_TERMIOS_HÌ65536Ö0 +_THREAD_SHARED_TYPES_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 +_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 +__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 +__CFLOAT128Ì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_STRINGS_H_PROTOÌ65536Ö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_cosf128Ì65536Ö0 +__DECL_SIMD_coslÌ65536Ö0 +__DECL_SIMD_expÌ65536Ö0 +__DECL_SIMD_expfÌ65536Ö0 +__DECL_SIMD_expf128Ì65536Ö0 +__DECL_SIMD_explÌ65536Ö0 +__DECL_SIMD_logÌ65536Ö0 +__DECL_SIMD_logfÌ65536Ö0 +__DECL_SIMD_logf128Ì65536Ö0 +__DECL_SIMD_loglÌ65536Ö0 +__DECL_SIMD_powÌ65536Ö0 +__DECL_SIMD_powfÌ65536Ö0 +__DECL_SIMD_powf128Ì65536Ö0 +__DECL_SIMD_powlÌ65536Ö0 +__DECL_SIMD_sinÌ65536Ö0 +__DECL_SIMD_sincosÌ65536Ö0 +__DECL_SIMD_sincosfÌ65536Ö0 +__DECL_SIMD_sincosf128Ì65536Ö0 +__DECL_SIMD_sincoslÌ65536Ö0 +__DECL_SIMD_sinfÌ65536Ö0 +__DECL_SIMD_sinf128Ì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 +__EXCEPTIONSÌ65536Ö0 +__FDS_BITSÌ131072Í(set)Ö0 +__FD_CLRÌ131072Í(d,set)Ö0 +__FD_ELTÌ65536Ö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 +__FP_LOGB0_IS_MINÌ65536Ö0 +__FP_LOGBNAN_IS_MINÌ65536Ö0 +__FP_LONG_MAXÌ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_ASM_FLAG_OUTPUTS__Ì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 +__GLIBCXX__Ì65536Ö0 +__GLIBC_FLT_EVAL_METHODÌ65536Ö0 +__GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATIONÌ65536Ö0 +__GLIBC_MINOR__Ì65536Ö0 +__GLIBC_PREREQÌ131072Í(maj,min)Ö0 +__GLIBC_USEÌ131072Í(F)Ö0 +__GLIBC_USE_DEPRECATED_GETSÌ65536Ö0 +__GLIBC_USE_IEC_60559_BFP_EXTÌ65536Ö0 +__GLIBC_USE_IEC_60559_FUNCS_EXTÌ65536Ö0 +__GLIBC_USE_IEC_60559_TYPES_EXTÌ65536Ö0 +__GLIBC_USE_LIB_EXT2Ì65536Ö0 +__GLIBC__Ì65536Ö0 +__GNUC_MINOR__Ì65536Ö0 +__GNUC_PATCHLEVEL__Ì65536Ö0 +__GNUC_PREREQÌ131072Í(maj,min)Ö0 +__GNUC_STDC_INLINE__Ì65536Ö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_EXPERIMENTAL_CXX0X__Ì65536Ö0 +__GXX_RTTIÌ65536Ö0 +__GXX_WEAK__Ì65536Ö0 +__HAVE_COLUMNÌ65536Ö0 +__HAVE_DISTINCT_FLOAT128Ì65536Ö0 +__HAVE_FLOAT128Ì65536Ö0 +__HAVE_GENERIC_SELECTIONÌ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_NÌ65536Ö0 +__INT_NÌ131072Í(TYPE)Ö0 +__INT_WCHAR_T_HÌ65536Ö0 +__IOV_MAXÌ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 +__LOCK_ALIGNMENTÌ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_DECLARING_FLOATNÌ65536Ö0 +__MATH_EVAL_FMT2Ì131072Í(x,y)Ö0 +__MATH_INLINEÌ65536Ö0 +__MATH_PRECNAMEÌ65536Ö0 +__MATH_PRECNAMEÌ131072Í(name,r)Ö0 +__MATH_TGÌ131072Í(TG_ARG,FUNC,ARGS)Ö0 +__MAX_BAUDÌ65536Ö0 +__MMX__Ì65536Ö0 +__MODE_T_TYPEÌ65536Ö0 +__NÌ131072Í(msgid)Ö0 +__NFDBITSÌ65536Ö0 +__NGREGÌ65536Ö0 +__NLINK_T_TYPEÌ65536Ö0 +__NO_CTYPEÌ65536Ö0 +__NTHÌ131072Í(fct)Ö0 +__NTHNLÌ131072Í(fct)Ö0 +__OFF64_T_TYPEÌ65536Ö0 +__OFF_T_MATCHES_OFF64_TÌ65536Ö0 +__OFF_T_TYPEÌ65536Ö0 +__ONCE_ALIGNMENTÌ65536Ö0 +__OPEN_NEEDS_MODEÌ131072Í(oflag)Ö0 +__OPTIMIZE__Ì65536Ö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 +__PIC__Ì65536Ö0 +__PID_T_TYPEÌ65536Ö0 +__PIE__Ì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_COMPAT_PADDING_ENDÌ65536Ö0 +__PTHREAD_COMPAT_PADDING_MIDÌ65536Ö0 +__PTHREAD_MUTEX_HAVE_PREVÌ65536Ö0 +__PTHREAD_MUTEX_LOCK_ELISIONÌ65536Ö0 +__PTHREAD_MUTEX_NUSERS_AFTER_KINDÌ65536Ö0 +__PTHREAD_MUTEX_USE_UNIONÌ65536Ö0 +__PTHREAD_RWLOCK_ELISION_EXTRAÌ65536Ö0 +__PTHREAD_RWLOCK_INT_FLAGS_SHAREDÌ65536Ö0 +__PTHREAD_SPINSÌ65536Ö0 +__PTHREAD_SPINS_DATAÌ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_MATCHES_RLIM64_TÌ65536Ö0 +__RLIM_T_TYPEÌ65536Ö0 +__S16_TYPEÌ65536Ö0 +__S32_TYPEÌ65536Ö0 +__S64_TYPEÌ65536Ö0 +__SCHAR_MAX__Ì65536Ö0 +__SEG_FSÌ65536Ö0 +__SEG_GSÌ65536Ö0 +__SHRT_MAX__Ì65536Ö0 +__SIGEV_MAX_SIZEÌ65536Ö0 +__SIGEV_PAD_SIZEÌ65536Ö0 +__SIGRTMAXÌ65536Ö0 +__SIGRTMINÌ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 +__SI_ALIGNMENTÌ65536Ö0 +__SI_ASYNCIO_AFTER_SIGIOÌ65536Ö0 +__SI_BAND_TYPEÌ65536Ö0 +__SI_CLOCK_TÌ65536Ö0 +__SI_ERRNO_THEN_CODEÌ65536Ö0 +__SI_HAVE_SIGSYSÌ65536Ö0 +__SI_MAX_SIZEÌ65536Ö0 +__SI_PAD_SIZEÌ65536Ö0 +__SI_SIGFAULT_ADDLÌ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_CONSTANT_MACROSÌ65536Ö0 +__STDC_HOSTED__Ì65536Ö0 +__STDC_IEC_559_COMPLEX__Ì65536Ö0 +__STDC_IEC_559__Ì65536Ö0 +__STDC_ISO_10646__Ì65536Ö0 +__STDC_LIMIT_MACROSÌ65536Ö0 +__STDC_NO_THREADS__Ì65536Ö0 +__STDC_UTF_16__Ì65536Ö0 +__STDC_UTF_32__Ì65536Ö0 +__STDC__Ì65536Ö0 +__STDIO_INLINEÌ65536Ö0 +__STDLIB_MB_LEN_MAXÌ65536Ö0 +__STD_TYPEÌ65536Ö0 +__STRINGÌ131072Í(x)Ö0 +__STRINGS_FORTIFIEDÌ65536Ö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 +__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_EXTERN_INLINESÌ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_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 +__UWORD_TYPEÌ65536Ö0 +__VERSION__Ì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 +____sigset_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_deprecated_msg__Ì131072Í(msg)Ö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 +__blkcnt64_tÌ4096Ö0Ïlong int +__blkcnt_tÌ4096Ö0Ïlong int +__blkcnt_t_definedÌ65536Ö0 +__blksize_tÌ4096Ö0Ïlong int +__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 +__builtin_copysignf128Ì65536Ö0 +__builtin_fabsf128Ì65536Ö0 +__builtin_huge_valf128Ì131072Í()Ö0 +__builtin_inff128Ì131072Í()Ö0 +__builtin_nanf128Ì131072Í(x)Ö0 +__builtin_nansf128Ì131072Í(x)Ö0 +__caddr_tÌ4096Ö0Ïchar * +__clock_tÌ4096Ö0Ïlong int +__clock_t_definedÌ65536Ö0 +__clockid_tÌ4096Ö0Ïint +__clockid_t_definedÌ65536Ö0 +__code_model_small__Ì65536Ö0 +__cplusplusÌ65536Ö0 +__cpp_aggregate_nsdmiÌ65536Ö0 +__cpp_alias_templatesÌ65536Ö0 +__cpp_attributesÌ65536Ö0 +__cpp_binary_literalsÌ65536Ö0 +__cpp_constexprÌ65536Ö0 +__cpp_decltypeÌ65536Ö0 +__cpp_decltype_autoÌ65536Ö0 +__cpp_delegating_constructorsÌ65536Ö0 +__cpp_digit_separatorsÌ65536Ö0 +__cpp_exceptionsÌ65536Ö0 +__cpp_generic_lambdasÌ65536Ö0 +__cpp_hex_floatÌ65536Ö0 +__cpp_inheriting_constructorsÌ65536Ö0 +__cpp_init_capturesÌ65536Ö0 +__cpp_initializer_listsÌ65536Ö0 +__cpp_lambdasÌ65536Ö0 +__cpp_nsdmiÌ65536Ö0 +__cpp_range_based_forÌ65536Ö0 +__cpp_raw_stringsÌ65536Ö0 +__cpp_ref_qualifiersÌ65536Ö0 +__cpp_return_type_deductionÌ65536Ö0 +__cpp_rttiÌ65536Ö0 +__cpp_runtime_arraysÌ65536Ö0 +__cpp_rvalue_referenceÌ65536Ö0 +__cpp_rvalue_referencesÌ65536Ö0 +__cpp_sized_deallocationÌ65536Ö0 +__cpp_static_assertÌ65536Ö0 +__cpp_unicode_charactersÌ65536Ö0 +__cpp_unicode_literalsÌ65536Ö0 +__cpp_user_defined_literalsÌ65536Ö0 +__cpp_variable_templatesÌ65536Ö0 +__cpp_variadic_templatesÌ65536Ö0 +__ctxÌ65536Ö0 +__ctxÌ131072Í(fld)Ö0 +__daddr_tÌ4096Ö0Ïint +__daddr_t_definedÌ65536Ö0 +__dev_tÌ4096Ö0Ïunsigned long int +__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 +__f128Ì131072Í(x)Ö0 +__flexarrÌ65536Ö0 +__fortify_functionÌ65536Ö0 +__fsblkcnt64_tÌ4096Ö0Ïunsigned long int +__fsblkcnt_tÌ4096Ö0Ïunsigned long int +__fsblkcnt_t_definedÌ65536Ö0 +__fsfilcnt64_tÌ4096Ö0Ïunsigned long int +__fsfilcnt_tÌ4096Ö0Ïunsigned long int +__fsfilcnt_t_definedÌ65536Ö0 +__fsid_tÌ4096Ö0Ïanon_struct_0 +__fsword_tÌ4096Ö0Ïlong int +__getopt_argv_constÌ65536Ö0 +__gid_tÌ4096Ö0Ïunsigned int +__gid_t_definedÌ65536Ö0 +__glibc_c99_flexarr_availableÌ65536Ö0 +__glibc_clang_has_extensionÌ131072Í(ext)Ö0 +__glibc_clang_prereqÌ131072Í(maj,min)Ö0 +__glibc_likelyÌ131072Í(cond)Ö0 +__glibc_macro_warningÌ131072Í(message)Ö0 +__glibc_macro_warning1Ì131072Í(message)Ö0 +__glibc_unlikelyÌ131072Í(cond)Ö0 +__glibcxx_assertÌ131072Í(_Condition)Ö0 +__gnu_linux__Ì65536Ö0 +__has_includeÌ131072Í(STR)Ö0 +__has_include_nextÌ131072Í(STR)Ö0 +__have_pthread_attr_tÌ65536Ö0 +__id_tÌ4096Ö0Ïunsigned int +__id_t_definedÌ65536Ö0 +__ino64_tÌ4096Ö0Ïunsigned long int +__ino64_t_definedÌ65536Ö0 +__ino_tÌ4096Ö0Ïunsigned long int +__ino_t_definedÌ65536Ö0 +__int16_tÌ4096Ö0Ïsigned short int +__int32_tÌ4096Ö0Ïsigned int +__int64_tÌ4096Ö0Ïsigned long int +__int8_tÌ4096Ö0Ïsigned char +__intmax_tÌ4096Ö0Ïlong int +__intptr_tÌ4096Ö0Ïlong int +__intptr_t_definedÌ65536Ö0 +__iovec_definedÌ65536Ö0 +__isasciiÌ131072Í(c)Ö0 +__iscanonicalÌ131072Í(x)Ö0 +__iscanonicalfÌ131072Í(x)Ö0 +__iscanonicalf128Ì131072Í(x)Ö0 +__isctype_fÌ131072Í(type)Ö0 +__isctype_lÌ131072Í(c,type,locale)Ö0 +__k8Ì65536Ö0 +__k8__Ì65536Ö0 +__key_tÌ4096Ö0Ïint +__key_t_definedÌ65536Ö0 +__ldiv_t_definedÌ65536Ö0 +__linuxÌ65536Ö0 +__linux__Ì65536Ö0 +__lldiv_t_definedÌ65536Ö0 +__loff_tÌ4096Ö0Ï__off64_t +__long_double_tÌ65536Ö0 +__mode_tÌ4096Ö0Ïunsigned int +__mode_t_definedÌ65536Ö0 +__need_NULLÌ65536Ö0 +__need___va_listÌ65536Ö0 +__need_size_tÌ65536Ö0 +__need_wchar_tÌ65536Ö0 +__nlink_tÌ4096Ö0Ïunsigned long int +__nlink_t_definedÌ65536Ö0 +__nonnullÌ131072Í(params)Ö0 +__off64_tÌ4096Ö0Ïlong int +__off64_t_definedÌ65536Ö0 +__off_tÌ4096Ö0Ïlong int +__off_t_definedÌ65536Ö0 +__pic__Ì65536Ö0 +__pid_tÌ4096Ö0Ïint +__pid_t_definedÌ65536Ö0 +__pie__Ì65536Ö0 +__prognameÌ32768Ö0Ïconst char * +__ptr_tÌ65536Ö0 +__qaddr_tÌ4096Ö0Ï__quad_t * +__quad_tÌ4096Ö0Ïlong int +__restrict_arrÌ65536Ö0 +__rlim64_tÌ4096Ö0Ïunsigned long int +__rlim_tÌ4096Ö0Ïunsigned long int +__sig_atomic_tÌ4096Ö0Ïint +__sig_atomic_t_definedÌ65536Ö0 +__sigevent_t_definedÌ65536Ö0 +__siginfo_t_definedÌ65536Ö0 +__sigset_t_definedÌ65536Ö0 +__sigstack_definedÌ65536Ö0 +__sigval_t_definedÌ65536Ö0 +__size_tÌ65536Ö0 +__size_t__Ì65536Ö0 +__socklen_tÌ4096Ö0Ïunsigned int +__socklen_t_definedÌ65536Ö0 +__ssize_tÌ4096Ö0Ïlong int +__ssize_t_definedÌ65536Ö0 +__stack_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Ì4096Ö0Ïlong int +__suseconds_t_definedÌ65536Ö0 +__syscall_slong_tÌ4096Ö0Ïlong int +__syscall_ulong_tÌ4096Ö0Ïunsigned long int +__time_tÌ4096Ö0Ïlong int +__time_t_definedÌ65536Ö0 +__timer_tÌ4096Ö0Ïvoid * +__timer_t_definedÌ65536Ö0 +__timespec_definedÌ65536Ö0 +__timeval_definedÌ65536Ö0 +__toasciiÌ131072Í(c)Ö0 +__tobodyÌ131072Í(c,f,a,args)Ö0 +__u_charÌ4096Ö0Ïunsigned char +__u_char_definedÌ65536Ö0 +__u_intÌ4096Ö0Ïunsigned int +__u_intN_tÌ131072Í(N,MODE)Ö0 +__u_longÌ4096Ö0Ïunsigned long int +__u_quad_tÌ4096Ö0Ïunsigned long int +__u_shortÌ4096Ö0Ïunsigned short int +__uid_tÌ4096Ö0Ïunsigned int +__uid_t_definedÌ65536Ö0 +__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 +__uintmax_tÌ4096Ö0Ïunsigned long int +__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Ì4096Ö0Ïunsigned int +__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 +__valÌ64Îanon_struct_0Ö0Ïint +__warnattrÌ131072Í(msg)Ö0 +__warndeclÌ131072Í(name,msg)Ö0 +__wchar_t__Ì65536Ö0 +__wurÌ65536Ö0 +__x86_64Ì65536Ö0 +__x86_64__Ì65536Ö0 +abortÌ64ÎstdÖ0Ïusing +abortÌ65536Ö0 +absÌ64ÎstdÖ0Ïusing +absÌ65536Ö0 +absmoveÌ64Îanon_struct_6Ö0Ïint +acosÌ64ÎstdÖ0Ïusing +acosÌ65536Ö0 +acoshÌ64ÎstdÖ0Ïusing +acoshÌ65536Ö0 +acoshfÌ65536Ö0 +acoshlÌ65536Ö0 +allocaÌ65536Ö0 +allocaÌ131072Í(size)Ö0 +anon_enum_2Ì2Ö0 +anon_enum_3Ì2Ö0 +anon_struct_0Ì2048Ö0 +anon_struct_1Ì2048Ö0 +anon_struct_4Ì2048Ö0 +anon_struct_5Ì2048Ö0 +anon_struct_6Ì2048Ö0 +arg_doubleÌ4Îanon_enum_2Ö0 +arg_floatÌ4Îanon_enum_2Ö0 +arg_functionÌ4Îanon_enum_2Ö0 +arg_intÌ4Îanon_enum_2Ö0 +arg_longlongÌ4Îanon_enum_2Ö0 +arg_noneÌ4Îanon_enum_2Ö0 +arg_stringÌ4Îanon_enum_2Ö0 +argfnÌ4096Ö0Ïtypedef bool +argptrÌ64Îanon_struct_4Ö0Ïvoid * +argptrÌ64Îanon_struct_5Ö0Ïvoid * +argsortÌ16Í(const void *a1, const void *a2)Ö0Ïint +argtypeÌ4096Ö0Ïanon_enum_2 +asinÌ64ÎstdÖ0Ïusing +asinÌ65536Ö0 +asinhÌ64ÎstdÖ0Ïusing +asinhÌ65536Ö0 +asinhfÌ65536Ö0 +asinhlÌ65536Ö0 +assertÌ65536Ö0 +assertÌ131072Í(expr)Ö0 +assert_perrorÌ65536Ö0 +assert_perrorÌ131072Í(errnum)Ö0 +at_quick_exitÌ64ÎstdÖ0Ïusing +at_quick_exitÌ65536Ö0 +atanÌ64ÎstdÖ0Ïusing +atanÌ65536Ö0 +atan2Ì64ÎstdÖ0Ïusing +atan2Ì65536Ö0 +atanhÌ64ÎstdÖ0Ïusing +atanhÌ65536Ö0 +atanhfÌ65536Ö0 +atanhlÌ65536Ö0 +atexitÌ64ÎstdÖ0Ïusing +atexitÌ65536Ö0 +atofÌ64ÎstdÖ0Ïusing +atofÌ65536Ö0 +atoiÌ64ÎstdÖ0Ïusing +atoiÌ65536Ö0 +atolÌ64ÎstdÖ0Ïusing +atolÌ65536Ö0 +atollÌ65536Ö0 +be16tohÌ131072Í(x)Ö0 +be32tohÌ131072Í(x)Ö0 +be64tohÌ131072Í(x)Ö0 +blkcnt_tÌ4096Ö0Ï__blkcnt_t +blksize_tÌ4096Ö0Ï__blksize_t +bsearchÌ64ÎstdÖ0Ïusing +bsearchÌ65536Ö0 +bufÌ16384Ö0Ïchar +bufoÌ16384Ö0Ïchar +callocÌ64ÎstdÖ0Ïusing +callocÌ65536Ö0 +cbrtÌ64ÎstdÖ0Ïusing +cbrtÌ65536Ö0 +cbrtfÌ65536Ö0 +cbrtlÌ65536Ö0 +ceilÌ64ÎstdÖ0Ïusing +ceilÌ65536Ö0 +change_helpstringÌ16Í(char *s)Ö0Ïvoid +change_helpstringÌ1024Í(char *s)Ö0Ïvoid +cmdlnoptsÌ16384Ö0Ïmyoption +comdevÌ64Îanon_struct_6Ö0Ïchar * +comfdÌ16384Ö0Ïint +console_changedÌ16384Ö0Ïint +convangleÌ16Í(double val)Ö0Ïdouble +copysignÌ64ÎstdÖ0Ïusing +copysignÌ65536Ö0 +copysignfÌ65536Ö0 +copysignlÌ65536Ö0 +cosÌ64ÎstdÖ0Ïusing +cosÌ65536Ö0 +coshÌ64ÎstdÖ0Ïusing +coshÌ65536Ö0 +cpy2bufÌ16Í(char *string)Ö0Ïsize_t +dataÌ64Îanon_struct_1Ö0Ïchar * +dev_tÌ4096Ö0Ï__dev_t +divÌ64ÎstdÖ0Ïusing +divÌ65536Ö0 +div_tÌ64ÎstdÖ0Ïusing +dontwaitÌ64Îanon_struct_6Ö0Ïint +dtimeÌ16Í()Ö0Ïdouble +dtimeÌ1024Í()Ö0Ïdouble +end_optionÌ65536Ö0 +end_suboptionÌ65536Ö0 +endswitchesÌ16384Ö0Ïint +erfÌ64ÎstdÖ0Ïusing +erfÌ65536Ö0 +erfcÌ64ÎstdÖ0Ïusing +erfcÌ65536Ö0 +erfcfÌ65536Ö0 +erfclÌ65536Ö0 +erffÌ65536Ö0 +erflÌ65536Ö0 +errnoÌ65536Ö0 +exitÌ64ÎstdÖ0Ïusing +exitÌ65536Ö0 +expÌ64ÎstdÖ0Ïusing +expÌ65536Ö0 +exp2Ì64ÎstdÖ0Ïusing +exp2Ì65536Ö0 +exp2fÌ65536Ö0 +exp2lÌ65536Ö0 +expm1Ì64ÎstdÖ0Ïusing +expm1Ì65536Ö0 +expm1fÌ65536Ö0 +expm1lÌ65536Ö0 +fabsÌ64ÎstdÖ0Ïusing +fabsÌ65536Ö0 +fdimÌ64ÎstdÖ0Ïusing +fdimÌ65536Ö0 +fdimfÌ65536Ö0 +fdimlÌ65536Ö0 +flagÌ64Îanon_struct_4Ö0Ïint * +floorÌ64ÎstdÖ0Ïusing +floorÌ65536Ö0 +fmaÌ64ÎstdÖ0Ïusing +fmaÌ65536Ö0 +fmafÌ65536Ö0 +fmalÌ65536Ö0 +fmaxÌ64ÎstdÖ0Ïusing +fmaxÌ65536Ö0 +fmaxfÌ65536Ö0 +fmaxlÌ65536Ö0 +fminÌ64ÎstdÖ0Ïusing +fminÌ65536Ö0 +fminfÌ65536Ö0 +fminlÌ65536Ö0 +fmodÌ64ÎstdÖ0Ïusing +fmodÌ65536Ö0 +fpclassifyÌ64ÎstdÖ0Ïusing +fpclassifyÌ65536Ö0 +fpclassifyÌ131072Í(x)Ö0 +fread_unlockedÌ65536Ö0 +freeÌ64ÎstdÖ0Ïusing +freeÌ65536Ö0 +frexpÌ64ÎstdÖ0Ïusing +frexpÌ65536Ö0 +g_pr_Ì16Í(const char *fmt, ...)Ö0Ïint +get_aptrÌ16Í(void *paptr, argtype type)Ö0Ïvoid * +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 +getenvÌ64ÎstdÖ0Ïusing +getenvÌ65536Ö0 +getstatusÌ64Îanon_struct_6Ö0Ïint +gid_tÌ4096Ö0Ï__gid_t +globErrÌ16384Ö0Ïint +globErrÌ32768Ö0Ïint +glob_parsÌ4096Ö0Ïanon_struct_6 +greenÌ1024Í(const char *fmt, ...)Ö0Ïint +handshakeÌ16Í()Ö0Ïvoid +handshakeÌ1024Í()Ö0Ïvoid +has_argÌ64Îanon_struct_4Ö0Ïhasarg +has_argÌ64Îanon_struct_5Ö0Ïhasarg +hasargÌ4096Ö0Ïanon_enum_3 +helpÌ64Îanon_struct_4Ö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 +hypotÌ64ÎstdÖ0Ïusing +hypotÌ65536Ö0 +hypotfÌ65536Ö0 +hypotlÌ65536Ö0 +ilogbÌ64ÎstdÖ0Ïusing +ilogbÌ65536Ö0 +ilogbfÌ65536Ö0 +ilogblÌ65536Ö0 +initial_setupÌ16Í()Ö0Ïvoid +initial_setupÌ1024Í()Ö0Ïvoid +ino_tÌ4096Ö0Ï__ino_t +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Ï__intmax_t +iseqsigÌ131072Í(x,y)Ö0 +isfiniteÌ64ÎstdÖ0Ïusing +isfiniteÌ65536Ö0 +isfiniteÌ131072Í(x)Ö0 +isgreaterÌ64ÎstdÖ0Ïusing +isgreaterÌ65536Ö0 +isgreaterÌ131072Í(x,y)Ö0 +isgreaterequalÌ64ÎstdÖ0Ïusing +isgreaterequalÌ65536Ö0 +isgreaterequalÌ131072Í(x,y)Ö0 +isinfÌ64ÎstdÖ0Ïusing +isinfÌ65536Ö0 +isinfÌ131072Í(x)Ö0 +islessÌ64ÎstdÖ0Ïusing +islessÌ65536Ö0 +islessÌ131072Í(x,y)Ö0 +islessequalÌ64ÎstdÖ0Ïusing +islessequalÌ65536Ö0 +islessequalÌ131072Í(x,y)Ö0 +islessgreaterÌ64ÎstdÖ0Ïusing +islessgreaterÌ65536Ö0 +islessgreaterÌ131072Í(x,y)Ö0 +isnanÌ64ÎstdÖ0Ïusing +isnanÌ65536Ö0 +isnanÌ131072Í(x)Ö0 +isnormalÌ64ÎstdÖ0Ïusing +isnormalÌ65536Ö0 +isnormalÌ131072Í(x)Ö0 +issubnormalÌ131072Í(x)Ö0 +isunorderedÌ64ÎstdÖ0Ïusing +isunorderedÌ65536Ö0 +isunorderedÌ131072Í(u,v)Ö0 +keyvalÌ16Í(char *key)Ö0Ïchar * +l1stepsÌ64Îanon_struct_6Ö0Ïint +l2stepsÌ64Îanon_struct_6Ö0Ïint +labsÌ64ÎstdÖ0Ïusing +labsÌ65536Ö0 +ldexpÌ64ÎstdÖ0Ïusing +ldexpÌ65536Ö0 +ldivÌ64ÎstdÖ0Ïusing +ldivÌ65536Ö0 +ldiv_tÌ64ÎstdÖ0Ïusing +le16tohÌ131072Í(x)Ö0 +le32tohÌ131072Í(x)Ö0 +le64tohÌ131072Í(x)Ö0 +lenÌ64Îanon_struct_1Ö0Ïsize_t +lgammaÌ64ÎstdÖ0Ïusing +lgammaÌ65536Ö0 +lgammafÌ65536Ö0 +lgammalÌ65536Ö0 +linuxÌ65536Ö0 +llabsÌ65536Ö0 +lldivÌ65536Ö0 +llrintÌ64ÎstdÖ0Ïusing +llrintÌ65536Ö0 +llrintfÌ65536Ö0 +llrintlÌ65536Ö0 +llroundÌ64ÎstdÖ0Ïusing +llroundÌ65536Ö0 +llroundfÌ65536Ö0 +llroundlÌ65536Ö0 +logÌ64ÎstdÖ0Ïusing +logÌ65536Ö0 +log10Ì64ÎstdÖ0Ïusing +log10Ì65536Ö0 +log1pÌ64ÎstdÖ0Ïusing +log1pÌ65536Ö0 +log1pfÌ65536Ö0 +log1plÌ65536Ö0 +log2Ì64ÎstdÖ0Ïusing +log2Ì65536Ö0 +log2fÌ65536Ö0 +log2lÌ65536Ö0 +logbÌ64ÎstdÖ0Ïusing +logbÌ65536Ö0 +logbfÌ65536Ö0 +logblÌ65536Ö0 +lrintÌ64ÎstdÖ0Ïusing +lrintÌ65536Ö0 +lrintfÌ65536Ö0 +lrintlÌ65536Ö0 +lroundÌ64ÎstdÖ0Ïusing +lroundÌ65536Ö0 +lroundfÌ65536Ö0 +lroundlÌ65536Ö0 +mainÌ16Í(int argc, char **argv)Ö0Ïint +mallocÌ64ÎstdÖ0Ïusing +mallocÌ65536Ö0 +math_errhandlingÌ65536Ö0 +maxÌ65536Ö0 +mblenÌ64ÎstdÖ0Ïusing +mblenÌ65536Ö0 +mbstowcsÌ64ÎstdÖ0Ïusing +mbstowcsÌ65536Ö0 +mbtowcÌ64ÎstdÖ0Ïusing +mbtowcÌ65536Ö0 +minÌ65536Ö0 +mmapbufÌ4096Ö0Ïanon_struct_1 +mode_tÌ4096Ö0Ï__mode_t +modfÌ64ÎstdÖ0Ïusing +modfÌ65536Ö0 +mot_geteswÌ16Í(int mcu, int motor)Ö0Ïint +mot_geteswÌ1024Í(int mcu, int motor)Ö0Ïint +mot_getposÌ16Í(int mcu, int motor)Ö0Ïint +mot_getposÌ1024Í(int mcu, int motor)Ö0Ïint +motposÌ16384Ö0Ïint +movemotorÌ16Í(int mcu, int motnum, int steps, const char *name)Ö0Ïint +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_4 +mysuboptionÌ4096Ö0Ïanon_struct_5 +nameÌ64Îanon_struct_4Ö0Ïconst char * +nameÌ64Îanon_struct_5Ö0Ïconst char * +nanÌ65536Ö0 +nanfÌ65536Ö0 +nanlÌ65536Ö0 +nearbyintÌ64ÎstdÖ0Ïusing +nearbyintÌ65536Ö0 +nearbyintfÌ65536Ö0 +nearbyintlÌ65536Ö0 +newtÌ16384Ö0Ïtermios +nextafterÌ64ÎstdÖ0Ïusing +nextafterÌ65536Ö0 +nextafterfÌ65536Ö0 +nextafterlÌ65536Ö0 +nexttowardÌ64ÎstdÖ0Ïusing +nexttowardÌ65536Ö0 +nexttowardfÌ65536Ö0 +nexttowardlÌ65536Ö0 +nlink_tÌ4096Ö0Ï__nlink_t +no_argumentÌ65536Ö0 +off_tÌ4096Ö0Ï__off_t +oldtÌ16384Ö0Ïtermios +oldttyÌ16384Ö0Ïtermio +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 +parsemotansÌ16Í(int ans, const char *prefix)Ö0Ïint +parsestatusÌ16Í(char *cmd)Ö0Ïint +powÌ64ÎstdÖ0Ïusing +powÌ65536Ö0 +putcÌ131072Í(_ch,_fp)Ö0 +qsortÌ64ÎstdÖ0Ïusing +qsortÌ65536Ö0 +quick_exitÌ64ÎstdÖ0Ïusing +quick_exitÌ65536Ö0 +quietÌ16384Ö0Ïint +quietÌ32768Ö0Ïint +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 +randÌ64ÎstdÖ0Ïusing +randÌ65536Ö0 +read_consoleÌ16Í()Ö0Ïint +read_consoleÌ1024Í()Ö0Ïint +read_ttyÌ16Í(char *buff, size_t length)Ö0Ïsize_t +read_ttyÌ1024Í(char *buff, size_t length)Ö0Ïsize_t +reallocÌ64ÎstdÖ0Ïusing +reallocÌ65536Ö0 +redÌ1024Í(const char *fmt, ...)Ö0Ïint +remainderÌ64ÎstdÖ0Ïusing +remainderÌ65536Ö0 +remainderfÌ65536Ö0 +remainderlÌ65536Ö0 +remquoÌ64ÎstdÖ0Ïusing +remquoÌ65536Ö0 +remquofÌ65536Ö0 +remquolÌ65536Ö0 +required_argumentÌ65536Ö0 +resetÌ16384Ö0Ïint +restore_consoleÌ16Í()Ö0Ïvoid +restore_consoleÌ1024Í()Ö0Ïvoid +restore_ttyÌ16Í()Ö0Ïvoid +restore_ttyÌ1024Í()Ö0Ïvoid +rintÌ64ÎstdÖ0Ïusing +rintÌ65536Ö0 +rintfÌ65536Ö0 +rintlÌ65536Ö0 +rot1angleÌ64Îanon_struct_6Ö0Ïdouble +rot2angleÌ64Îanon_struct_6Ö0Ïdouble +roundÌ64ÎstdÖ0Ïusing +roundÌ65536Ö0 +roundfÌ65536Ö0 +roundlÌ65536Ö0 +s_WARNÌ16Í(const char *fmt, ...)Ö0Ïint +sa_handlerÌ65536Ö0 +sa_sigactionÌ65536Ö0 +scalblnÌ64ÎstdÖ0Ïusing +scalblnÌ65536Ö0 +scalblnfÌ65536Ö0 +scalblnlÌ65536Ö0 +scalbnÌ64ÎstdÖ0Ïusing +scalbnÌ65536Ö0 +scalbnfÌ65536Ö0 +scalbnlÌ65536Ö0 +sendrawÌ64Îanon_struct_6Ö0Ïchar * +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 +showtempÌ64Îanon_struct_6Ö0Ïint +si_addrÌ65536Ö0 +si_addr_lsbÌ65536Ö0 +si_archÌ65536Ö0 +si_bandÌ65536Ö0 +si_call_addrÌ65536Ö0 +si_fdÌ65536Ö0 +si_intÌ65536Ö0 +si_lowerÌ65536Ö0 +si_overrunÌ65536Ö0 +si_pidÌ65536Ö0 +si_pkeyÌ65536Ö0 +si_ptrÌ65536Ö0 +si_statusÌ65536Ö0 +si_stimeÌ65536Ö0 +si_syscallÌ65536Ö0 +si_timeridÌ65536Ö0 +si_uidÌ65536Ö0 +si_upperÌ65536Ö0 +si_utimeÌ65536Ö0 +si_valueÌ65536Ö0 +sigev_notify_attributesÌ65536Ö0 +sigev_notify_functionÌ65536Ö0 +sigmaskÌ131072Í(sig)Ö0 +signalsÌ16Í(int signo)Ö0Ïvoid +signalsÌ1024Í(int sig)Ö0Ïvoid +signbitÌ64ÎstdÖ0Ïusing +signbitÌ65536Ö0 +signbitÌ131072Í(x)Ö0 +sinÌ64ÎstdÖ0Ïusing +sinÌ65536Ö0 +sinhÌ64ÎstdÖ0Ïusing +sinhÌ65536Ö0 +sqrtÌ64ÎstdÖ0Ïusing +sqrtÌ65536Ö0 +srandÌ64ÎstdÖ0Ïusing +srandÌ65536Ö0 +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 +stopallÌ64Îanon_struct_6Ö0Ïint +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 +strtodÌ64ÎstdÖ0Ïusing +strtodÌ65536Ö0 +strtofÌ65536Ö0 +strtolÌ64ÎstdÖ0Ïusing +strtolÌ65536Ö0 +strtoldÌ65536Ö0 +strtollÌ65536Ö0 +strtoulÌ64ÎstdÖ0Ïusing +strtoulÌ65536Ö0 +strtoullÌ65536Ö0 +systemÌ64ÎstdÖ0Ïusing +systemÌ65536Ö0 +tanÌ64ÎstdÖ0Ïusing +tanÌ65536Ö0 +tanhÌ64ÎstdÖ0Ïusing +tanhÌ65536Ö0 +tgammaÌ64ÎstdÖ0Ïusing +tgammaÌ65536Ö0 +tgammafÌ65536Ö0 +tgammalÌ65536Ö0 +time_tÌ4096Ö0Ï__time_t +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 +timespecÌ2048Ö0 +truncÌ64ÎstdÖ0Ïusing +truncÌ65536Ö0 +truncfÌ65536Ö0 +trunclÌ65536Ö0 +ttyÌ16384Ö0Ïtermio +tty_getÌ16Í()Ö0Ïchar * +tty_getstatusÌ16Í()Ö0Ïvoid +tty_getstatusÌ1024Í()Ö0Ïvoid +tty_initÌ16Í(char *comdev)Ö0Ïvoid +tty_initÌ1024Í(char *comdev)Ö0Ïvoid +tty_sendcmdÌ16Í(char *cmd)Ö0Ïint +tty_sendcmdÌ1024Í(char *cmd)Ö0Ïint +tty_sendrawÌ16Í(char *string)Ö0Ïchar * +tty_sendrawÌ1024Í(char *string)Ö0Ïchar * +tty_showtempÌ16Í()Ö0Ïvoid +tty_showtempÌ1024Í()Ö0Ïvoid +tty_waitÌ16Í()Ö0Ïvoid +tty_waitÌ1024Í()Ö0Ïvoid +ttysendÌ16Í(char *cmd)Ö0Ïint +tv_nsecÌ64ÎtimespecÖ0Ï__syscall_slong_t +tv_secÌ64ÎtimespecÖ0Ï__time_t +typeÌ64Îanon_struct_4Ö0Ïargtype +typeÌ64Îanon_struct_5Ö0Ïargtype +uid_tÌ4096Ö0Ï__uid_t +uint16_tÌ4096Ö0Ï__uint16_t +uint32_tÌ4096Ö0Ï__uint32_t +uint64_tÌ4096Ö0Ï__uint64_t +uint8_tÌ4096Ö0Ï__uint8_t +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Ï__uintmax_t +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_4Ö0Ïint +waitoldÌ64Îanon_struct_6Ö0Ïint +wcstombsÌ64ÎstdÖ0Ïusing +wcstombsÌ65536Ö0 +wctombÌ64ÎstdÖ0Ïusing +wctombÌ65536Ö0 +write_ttyÌ16Í(char *buff, size_t length)Ö0Ïint +write_ttyÌ1024Í(char *buff, size_t length)Ö0Ïint diff --git a/MMPP_control/Makefile b/MMPP_control/Makefile new file mode 100644 index 0000000..45b0a02 --- /dev/null +++ b/MMPP_control/Makefile @@ -0,0 +1,43 @@ +# run `make DEF=...` to add extra defines +PROGRAM := MMPP_control +LDFLAGS := -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--discard-all +SRCS := $(wildcard *.c) +DEFINES := $(DEF) -DBAUD_RATE=B115200 -D_GNU_SOURCE -D_XOPEN_SOURCE=1111 +#DEFINES += -DEBUG +OBJDIR := mk +CFLAGS += -O2 -Wall -Werror -Wextra -Wno-trampolines -std=gnu99 +OBJS := $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.o)) +DEPS := $(OBJS:.o=.d) +CC = gcc +#CXX = g++ + + +all : $(OBJDIR) $(PROGRAM) + +$(PROGRAM) : $(OBJS) + @echo -e "\t\tLD $(PROGRAM)" + $(CC) $(LDFLAGS) $(OBJS) -o $(PROGRAM) + +$(OBJDIR): + mkdir $(OBJDIR) + +ifneq ($(MAKECMDGOALS),clean) +-include $(DEPS) +endif + +$(OBJDIR)/%.o: %.c + @echo -e "\t\tCC $<" + $(CC) -MD -c $(LDFLAGS) $(CFLAGS) $(DEFINES) -o $@ $< + +clean: + @echo -e "\t\tCLEAN" + @rm -f $(OBJS) $(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/MMPP_control/Readme b/MMPP_control/Readme new file mode 100644 index 0000000..874aff6 --- /dev/null +++ b/MMPP_control/Readme @@ -0,0 +1 @@ +Simple CLI control tool allowing bash scripting \ No newline at end of file diff --git a/MMPP_control/cmdlnopts.c b/MMPP_control/cmdlnopts.c new file mode 100644 index 0000000..bc852ad --- /dev/null +++ b/MMPP_control/cmdlnopts.c @@ -0,0 +1,93 @@ +/* + * 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 +#include "cmdlnopts.h" +#include "usefull_macros.h" + +/* + * here are global parameters initialisation + */ +static int help; +static glob_pars G; + +int quiet = 0; // less messages @ stdout + +// DEFAULTS +// default global parameters +glob_pars const Gdefault = { + .showtemp = 0 + ,.comdev = "/dev/ttyUSB0" + ,.rot1angle = -1000. + ,.rot2angle = -1000. + ,.l1steps = INT_MAX + ,.l2steps = INT_MAX +}; + +/* + * Define command line options by filling structure: + * name has_arg flag val type argptr help +*/ +myoption cmdlnopts[] = { + {"help", NO_ARGS, NULL, 'h', arg_none, APTR(&help), N_("show this help")}, + {"quiet", NO_ARGS, NULL, 'q', arg_none, APTR(&quiet), N_("don't show anything @screen from stdout")}, + {"temp", NO_ARGS, NULL, 't', arg_none, APTR(&G.showtemp), N_("show temperature of both MCU")}, + {"comdev", NEED_ARG, NULL, 'd', arg_string, APTR(&G.comdev), N_("terminal device filename")}, + {"sendraw", NEED_ARG, NULL, 'a', arg_string, APTR(&G.sendraw), N_("send RAW string to port and read the answer")}, + {"rot1", NEED_ARG, NULL, 'R', arg_double, APTR(&G.rot1angle), N_("rotate polaroid to given angle")}, + {"rot2", NEED_ARG, NULL, 'r', arg_double, APTR(&G.rot2angle), N_("rotate lambda/4 to given angle")}, + {"status", NO_ARGS, NULL, 's', arg_none, APTR(&G.getstatus), N_("get device status")}, + {"wait", NO_ARGS, NULL, 'w', arg_none, APTR(&G.waitold), N_("wait while all moving ends")}, + {"async", NO_ARGS, NULL, 'y', arg_none, APTR(&G.dontwait), N_("asyncronous moving - don't wait")}, + {"lin1", NEED_ARG, NULL, 'L', arg_int, APTR(&G.l1steps), N_("move linear stage 1 (polaroid) to N steps")}, + {"lin2", NEED_ARG, NULL, 'l', arg_int, APTR(&G.l2steps), N_("move linear stage 2 (L/4) to N steps")}, + {"absmove", NO_ARGS, NULL, 'A', arg_none, APTR(&G.absmove), N_("absolute move (without this flag moving is relative)")}, + {"stop", NO_ARGS, NULL, 'S', arg_none, APTR(&G.stopall), N_("stop any moving")}, + 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){ + void *ptr; + ptr = memcpy(&G, &Gdefault, sizeof(G)); assert(ptr); + // format of help: "Usage: progname [args]\n" + // parse arguments + parseargs(&argc, &argv, cmdlnopts); + if(help) showhelp(-1, cmdlnopts); + if(argc > 0){ + WARNX("%d unused parameters:\n", argc); + for(int i = 0; i < argc; ++i) + printf("\t%4d: %s\n", i+1, argv[i]); + } + return &G; +} + diff --git a/MMPP_control/cmdlnopts.h b/MMPP_control/cmdlnopts.h new file mode 100644 index 0000000..ed6019b --- /dev/null +++ b/MMPP_control/cmdlnopts.h @@ -0,0 +1,52 @@ +/* + * 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 showtemp; // show temperatures of both MCU + char *comdev; // TTY device + char *sendraw; // send RAW string + double rot1angle; // rotator 1 angle + double rot2angle; // rotator 2 angle + int getstatus; // get both MCU status + int waitold; // wait for previous moving ends + int dontwait; // don't wait for moving end + int l1steps; // move linear stage 1 (polaroid) for N steps + int l2steps; // move linear stage 2 (L/4) for N steps + int absmove; // absolute move (to given position from zero-esw) + int stopall; // stop all moving +} glob_pars; + + +// default & global parameters +extern glob_pars const Gdefault; +extern int quiet; + +glob_pars *parse_args(int argc, char **argv); +#endif // __CMDLNOPTS_H__ diff --git a/MMPP_control/main.c b/MMPP_control/main.c new file mode 100644 index 0000000..221c960 --- /dev/null +++ b/MMPP_control/main.c @@ -0,0 +1,163 @@ +/* + * geany_encoding=koi8-r + * main.c + * + * Copyright 2018 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 "cmdlnopts.h" +#include "tty_procs.h" +#include "signal.h" + +static glob_pars *G; + +void signals(int signo){ + restore_console(); + restore_tty(); + exit(signo); +} + +static void MSG(const char *s1, const char *s2){ + DBG("%s: %s", s1, s2); + if(quiet) return; + if(s1) green("%s: ", s1); + if(s2) printf("%s\n", s2); +} + +static double convangle(double val){ + int X = val / 360.; + val -= 360. * (double)X; + return val; +} + +/** + * @return 1 if motor start moving else return 0 + */ +static int parsemotans(int ans, const char *prefix){ + if(ans == 0) return 1; + else if(ans == -1) WARNX(_("%s moving error!"), prefix); + else if(ans == 1) WARNX(_("%s is on end-switch and can't move further"), prefix); + else if(ans == 2) WARNX(_("Can't move %s: bad steps amount or still moving"), prefix); + return 0; +} + +/** + * move motor + * @return waitforstop value + */ +int movemotor(int mcu, int motnum, int steps, const char *name){ + char buf[32]; + int curpos = mot_getpos(mcu, motnum); + if(curpos == INT_MIN){ + WARNX(_("Can't get current %s position"), name); + return 0; + } + if(curpos < 0){ // need to init + // check if we are on zero endswitch + int esw = mot_getesw(mcu, motnum); + if(esw == 0){ // move a little + sprintf(buf, "%dM%dM100", mcu, motnum); + tty_sendcmd(buf); + tty_wait(); + } + sprintf(buf, "%dM%dM-40000", mcu, motnum); + if(tty_sendcmd(buf)){ + WARNX(_("Can't initialize %s"), name); + return 0; + } + tty_wait(); // wait for initialisation ends + handshake(); + curpos = mot_getpos(mcu, motnum); + if(curpos){ + WARNX(_("Can't return to zero")); + return 0; + } + } + if(G->absmove){ + if(steps < 0){ + if(motnum == 1){ + steps += (mcu == 1) ? 36000 : 28800; // convert rotator angle to positive + }else{ + WARNX(_("Can't move to negative position")); + return 0; + } + } + steps -= curpos; + } + if(steps == 0){ + MSG(name, "already at position"); + return 0; + } + DBG("try to move motor%d of mcu %d for %d steps", motnum, mcu, steps); + snprintf(buf, 32, "%dM%dM%d", mcu, motnum, steps); + int ans = tty_sendcmd(buf); + return parsemotans(ans, name); +} + +int main(int argc, char **argv){ +// char cmd[32]; + int waitforstop = 0; + signal(SIGTERM, signals); // kill (-15) + signal(SIGINT, signals); // ctrl+C + signal(SIGQUIT, SIG_IGN); // ctrl+\ . + signal(SIGTSTP, SIG_IGN); // ctrl+Z + setbuf(stdout, NULL); + initial_setup(); + G = parse_args(argc, argv); + setup_con(); // no echo + tty_init(G->comdev); + handshake(); // test connection & get all positions + if(G->showtemp){ + tty_showtemp(); + } + if(G->stopall){ // stop everything before analyze other commands + tty_sendcmd("1M0S"); + tty_sendcmd("1M1S"); + tty_sendcmd("2M0S"); + tty_sendcmd("2M1S"); + } + if(G->sendraw){ + MSG(_("Send raw string"), G->sendraw); + char *got = tty_sendraw(G->sendraw); + if(got){ + if(!quiet) green("Receive:\n"); + printf("%s", got); + }else WARNX(_("Nothing received")); + } + if(G->rot1angle > -999.){ + double angle = convangle(G->rot1angle); + int steps = (int)(100. * angle); + waitforstop = movemotor(1, 1, steps, "polaroid"); + } + if(G->rot2angle > -999.){ + double angle = convangle(G->rot2angle); + int steps = (int)(80. * angle); + waitforstop = movemotor(2, 1, steps, "lambda/4"); + } + if(G->l1steps != INT_MAX){ + waitforstop = movemotor(1, 0, G->l1steps, "polaroid stage"); + } + if(G->l2steps != INT_MAX){ + waitforstop = movemotor(2, 0, G->l2steps, "lambda/4 stage"); + } + if((waitforstop && !G->dontwait) || G->waitold) tty_wait(); + if(G->getstatus) tty_getstatus(); + signals(0); +} diff --git a/MMPP_control/mmppco.geanypro b/MMPP_control/mmppco.geanypro new file mode 100644 index 0000000..e69be0a --- /dev/null +++ b/MMPP_control/mmppco.geanypro @@ -0,0 +1,32 @@ +[editor] +line_wrapping=false +line_break_column=100 +auto_continue_multiline=true + +[file_prefs] +final_new_line=true +ensure_convert_new_lines=true +strip_trailing_spaces=true +replace_tabs=true + +[indentation] +indent_width=4 +indent_type=0 +indent_hard_tab_width=4 +detect_indent=false +detect_indent_width=false +indent_mode=3 + +[project] +name=MMPP control +base_path=/tmp/1/Docs/MMPP_control/ + +[long line marker] +long_line_behaviour=1 +long_line_column=100 + +[files] +current_page=0 + +[VTE] +last_dir=/home/eddy diff --git a/MMPP_control/parseargs.c b/MMPP_control/parseargs.c new file mode 100644 index 0000000..b235752 --- /dev/null +++ b/MMPP_control/parseargs.c @@ -0,0 +1,497 @@ +/* geany_encoding=koi8-r + * 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 && s1 && s2){ // both have short arg + return (s1 - s2); + }else if((f1 != NULL || !s1) && (f2 != NULL || !s2)){ // both don't have short arg - sort by long + return strcmp(l1, l2); + }else{ // only one have short arg -- return it + if(f2 || !s2) 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/MMPP_control/parseargs.h b/MMPP_control/parseargs.h new file mode 100644 index 0000000..a0ac099 --- /dev/null +++ b/MMPP_control/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/MMPP_control/tty_procs.c b/MMPP_control/tty_procs.c new file mode 100644 index 0000000..86f83a6 --- /dev/null +++ b/MMPP_control/tty_procs.c @@ -0,0 +1,390 @@ +/* + * geany_encoding=koi8-r + * tty_procs.c + * + * Copyright 2018 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 "tty_procs.h" +#include "cmdlnopts.h" // for `verbose` +#include "usefull_macros.h" + +// tty Rx static buffer +#define TBUFLEN (1024) +// read timeout (in seconds) +#define TTYTIMEOUT (0.05) + +// two buffers for data +static char buf[TBUFLEN+1]; +static char bufo[TBUFLEN+1]; + +static int motpos[3][2]; // motor's positions, 1 - number of mcu, 2 - number of motor +static int reset[3]; // reset occured +static int endswitches[3][2]; // ESW of motors: 0 - zero esw, 1 - limit esw, -1 - clear + +/** + * read data from TTY + * WARNING! Not thread-safe!!! + * @return static buffer with data read or NULL + */ +static char *tty_get(){ + char *ptr = buf; + size_t L = 0, l = TBUFLEN; +// double t0 = dtime(); +// while(dtime() - t0 < TTYTIMEOUT){ + while(1){ + size_t r = read_tty(ptr, l); + if(!r) break; + /*if(r) t0 = dtime(); + else{ + DBG("Nothing"); + continue; + }*/ + ptr[r] = 0; + DBG("next portion: %s", ptr); + L += r; l -= r; ptr += r; + } + if(L) return buf; + return NULL; +} + +/** + * copy given string to `buf` & add '\n' if need + * @return 0 if failed + */ +static size_t cpy2buf(char *string){ + size_t l = strlen(string); + if(l > TBUFLEN){ + WARNX(_("String too long! Nothing would be send.")); + return 0; + } + strcpy(buf, string); + if(buf[l-1] != '\n'){ + DBG("add \\n"); + buf[l++] = '\n'; + buf[l] = 0; + } + return l; +} + +/** + * Send given string command to port + * @return 0 if failed + */ +static int ttysend(char *cmd){ + size_t l = cpy2buf(cmd); + if(!l) return 0; + if(write_tty(buf, l)) return 0; + return 1; +} + +/** + * send RAW string to port device + * @param string - string to send + * @return string received or NULL in case of error + */ +char* tty_sendraw(char *string){ + DBG("sendraw %s", string); + if(!ttysend(string)) return NULL; + return tty_get(); +} + +/** + * Send given motor string command to port with answer analysis + * @return: + * -1 if failed + * 0 if started moving + * 1 if on endswitch and can't move further + * 2 if other error occured + */ +int tty_sendcmd(char *cmd){ + if(!ttysend(cmd)) return -1; + char *got = tty_get(); + if(!got) return -1; + if(strcmp(got, "ALL OK\n") == 0) return 0; + if(strcmp(got, "OnEndSwitch\n") == 0) return 1; + return 2; +} + +#if 0 +MOTOR0=SLEEP +POS0=43 +ESW00=RLSD +ESW01=HALL +MOTOR1=MOVE +STEPSLEFT1=6921 +POS1=3238 +ESW10=HALL +ESW11=RLSD +#endif + +/** + * return static buffer - value of `key` + * NOT THREAD SAFE! + */ +static char *keyval(char *key){ + //DBG("search %s in\n%s", key, buf); + static char buff[32]; + char *got = strstr(buf, key); + if(!got) return NULL; + got = strchr(got, '='); + if(!got) return NULL; + ++got; + char *el = strchr(got, '\n'); + if(!el) return NULL; + size_t L = el - got; + if(L > 31 || L == 0 || !*got) return NULL; + strncpy(buff, got, L); + buff[L] = 0; + return buff; +} + +/** + * parse status with given command `cmd` + * @return: + * 1 if one of motors still moving + * 0 if both are stopped + * -1 if failed + */ +static int parsestatus(char *cmd){ + if(!cmd) return 0; + if(!tty_sendraw(cmd)) return -1; + char buff[32], stat[2][5], left[2][7], pos[2][7]; + int mvng = 0; + for(int i = 0; i < 2; ++i){ + sprintf(buff, "POS%d", i); + char *val = keyval(buff); + if(!val) return -1; + strncpy(pos[i], val, 7); + sprintf(buff, "MOTOR%d", i); + val = keyval(buff); + if(!val) return -1; + if(strcmp(val, "SLEEP") == 0){ + strcpy(stat[i], "STOP"); + strcpy(left[i], "0"); + continue; + }else if(strcmp(val, "UNKNOWN")){ + strcpy(stat[i], "MOVE"); + mvng = 1; + sprintf(buff, "STEPSLEFT%d", i); + val = keyval(buff); + if(!val) return -1; + strncpy(left[i], val, 7); + }else return -1; + } + snprintf(bufo, TBUFLEN, "%4s %6s %6s - %4s %6s %6s", + stat[0], left[0], pos[0], stat[1], left[1], pos[1]); + if(mvng){ + return 1; + } else return 0; +} + +/** + * Wait for all motors stop with current data indication + */ +void tty_wait(){ + FNAME(); + int failcount = 0, chk1 = 1, chk2 = 1; + if(!quiet) + green("Pol: M0ST M0LEFT M0POS - M1ST M1LEFT M1POS || L/4: M0ST M0LEFT M0POS - M1ST M1LEFT M1POS \n"); + while(failcount < 5 && (chk1 || chk2)){ // 5 tries + chk1 = parsestatus("1GS"); + if(!quiet){ + printf("Pol: "); + if(chk1 == -1){ + chk1 = 1; + ++failcount; + printf("%39s", "failed"); + }else printf("%s", bufo); + } + chk2 = parsestatus("2GS"); + if(!quiet){ + printf(" || L/4: "); + if(chk2 == -1){ + chk2 = 1; + ++failcount; + printf("%39s", "failed"); + }else printf("%s", bufo); + printf(" \r"); + } + //usleep(100000); + } + if(!quiet) printf("\n\n"); + if(failcount > 4) WARNX(_("Can't get status answer!")); +} + +void tty_getstatus(){ + FNAME(); + int chk1, chk2; + char buff[TBUFLEN+1]; + if(!quiet) + green("Pol: M0ST M0LEFT M0POS - M1ST M1LEFT M1POS || L/4: M0ST M0LEFT M0POS - M1ST M1LEFT M1POS \n"); + chk1 = parsestatus("1GS"); + printf("Pol: "); + if(chk1 == -1){ + printf("%39s", "failed"); + }else printf("%s", bufo); + char *val = keyval("ESW00"); + if(!val) val = " "; + sprintf(buff, "%5s ", val); + val = keyval("ESW01"); + if(!val) val = " "; + sprintf(&buff[6], "%5s ", val); + val = keyval("ESW10"); + if(!val) val = " "; + sprintf(&buff[12], "%5s ", val); + val = keyval("ESW11"); + if(!val) val = " "; + sprintf(&buff[18], "%5s ", val); + chk2 = parsestatus("2GS"); + printf(" || L/4: "); + if(chk2 == -1){ + printf("%39s", "failed"); + }else printf("%s", bufo); + printf("\n"); + sprintf(&buff[24], "|| "); + val = keyval("ESW00"); + DBG("ESW00=%s", val); + if(!val) val = " "; + sprintf(&buff[27], "%5s ", val); + val = keyval("ESW01"); + if(!val) val = " "; + sprintf(&buff[33], "%5s ", val); + val = keyval("ESW10"); + if(!val) val = " "; + sprintf(&buff[39], "%5s ", val); + val = keyval("ESW11"); + if(!val) val = " "; + sprintf(&buff[45], "%5s ", val); + // end-switches + if(!quiet) green("ESW00 ESW01 ESW10 ESW11 || ESW00 ESW01 ESW10 ESW11\n"); + printf("%s\n", buff); + for(int i = 1; i < 3; ++i){ + if(reset[i]) printf("RESET%d=1\n", i); + } +} + + +/** + * Show temperature of both MCU + */ +void tty_showtemp(){ + char *val, buff[] = "xGT\n"; + for(int i = 1; i < 3; ++i){ + buff[0] = '0' + i; + if(tty_sendraw(buff)){ + val = keyval("TEMP"); + if(val){ + double t; + if(str2double(&t, val)){ + green("MCU%d temperature: %g degC\n", i, t/10.); + } + } + } + } +} + +/** + * get current motor position (if move or error return INT_MIN) + * + */ +int mot_getpos(int mcu, int motor){ + if(mcu < 1 || mcu > 2){ + WARNX(_("Bad MCU number")); + return INT_MIN; + } + if(motor < 0 || motor > 1){ + WARNX(_("Bad motor number")); + return INT_MIN; + } + return motpos[mcu][motor]; +} + +/** + * get motor endswitches status + * + */ +int mot_getesw(int mcu, int motor){ + if(mcu < 1 || mcu > 2){ + WARNX(_("Bad MCU number")); + return -1; + } + if(motor < 0 || motor > 1){ + WARNX(_("Bad motor number")); + return -1; + } + return endswitches[mcu][motor]; +} + +/** + * test connection (1,2 -> ALIVE) + * and get positions + */ +void handshake(){ + char buff[32], *val; + int mcu, motor; + for(mcu = 1; mcu < 3; ++ mcu){ + // check if MCU alive + sprintf(buff, "%d", mcu); + int notresp = 0; + if(!tty_sendraw(buff)) notresp = 1; + else if(strcmp(buf, "ALIVE\n")) notresp = 1; + if(notresp){ + WARNX(_("MCU %d not response!"), mcu); + continue; + } + sprintf(buff, "%dGS", mcu); + if(tty_sendraw(buff)){ + // check reboot states + if(strstr(buf, "RESET")){ + reset[mcu] = 1; + WARNX(_("MCU %d had reset state!"), mcu); + }else + reset[mcu] = 0; + for(motor = 0; motor < 2; ++motor){ + sprintf(buff, "MOTOR%d", motor); + val = keyval(buff); + if(!val || strcmp(val, "SLEEP")){ + motpos[mcu][motor] = INT_MIN; + continue; + } + sprintf(buff, "POS%d", motor); + val = keyval(buff); + DBG("----%s=%s", buff, val); + motpos[mcu][motor] = val ? atoi(val) : INT_MIN; + DBG("MOTPOS[%d][%d] = %d", mcu, motor, motpos[mcu][motor]); + // end-switches + sprintf(buff, "ESW%d0", motor); + val = keyval(buff); + if(!val || strcmp(val, "HALL")){ + sprintf(buff, "ESW%d1", motor); + val = keyval(buff); + if(!val || strcmp(val, "HALL")){ + endswitches[mcu][motor] = -1; + }else + endswitches[mcu][motor] = 1; + }else endswitches[mcu][motor] = 0; + DBG("ENDSWITCHES[%d][%d] = %d", mcu, motor, endswitches[mcu][motor]); + } + }else{ + motpos[mcu][0] = INT_MIN; + motpos[mcu][1] = INT_MIN; + } + } +} diff --git a/MMPP_control/tty_procs.h b/MMPP_control/tty_procs.h new file mode 100644 index 0000000..6a6986d --- /dev/null +++ b/MMPP_control/tty_procs.h @@ -0,0 +1,33 @@ +/* + * geany_encoding=koi8-r + * tty_procs.h + * + * Copyright 2018 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 + +char* tty_sendraw(char *string); +void tty_wait(); +int tty_sendcmd(char *cmd); +void tty_showtemp(); +void tty_getstatus(); +void handshake(); +int mot_getpos(int mcu, int motor); +int mot_getesw(int mcu, int motor); diff --git a/MMPP_control/usefull_macros.c b/MMPP_control/usefull_macros.c new file mode 100644 index 0000000..a7b9cce --- /dev/null +++ b/MMPP_control/usefull_macros.c @@ -0,0 +1,372 @@ +/* + * 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" + WARN(_("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: +void tty_init(char *comdev){ + DBG("\nOpen port %s with baudrate %s", comdev, STRING(BAUD_RATE)); + //if ((comfd = open(comdev, O_RDWR|O_NOCTTY|O_NONBLOCK)) < 0){ + if ((comfd = open(comdev, O_RDWR|O_NOCTTY)) < 0){ + WARN("Can't use port %s\n",comdev); + 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 = ICANON; // ~(ICANON | ECHO | ECHOE | ISIG) + tty.c_oflag = 0; + tty.c_cflag = BAUD_RATE|CS8|CREAD|CLOCAL; // 9.6k, 8N1, RW, ignore line ctrl + tty.c_cc[VMIN] = 0; // non-canonical mode with + tty.c_cc[VTIME] = 1; // polling read with max 0.1s pause + if(ioctl(comfd,TCSETA,&tty) < 0){ + /// "îÅ ÍÏÇÕ ÕÓÔÁÎÏ×ÉÔØ ÎÁÓÔÒÏÊËÉ" + WARN(_("Can't set settings")); + signals(0); + } + DBG(" OK\n"); +} +/** + * Read data from TTY + * @param buff (o) - buffer for data read + * @param length - buffer len + * @return amount of bytes read + */ +size_t read_tty(char *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 max + retval = select(comfd + 1, &rfds, NULL, NULL, &tv); + if (!retval) return 0; + if(FD_ISSET(comfd, &rfds)){ + if((L = read(comfd, buff, length)) < 1){ + WARNX(_("Terminal disconnected!")); + return 0; + } + } + return (size_t)L; +} + +int write_tty(char *buff, size_t length){ + ssize_t L = write(comfd, buff, length); + if((size_t)L != length){ + DBG("L = %zd, len=%zd", 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/MMPP_control/usefull_macros.h b/MMPP_control/usefull_macros.h new file mode 100644 index 0000000..e5cf42b --- /dev/null +++ b/MMPP_control/usefull_macros.h @@ -0,0 +1,141 @@ +/* + * 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__)) + +#define ASTRING(MACRO) #MACRO +#define STRING(MACRO) ASTRING(MACRO) + +/* + * 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() fprintf(stderr, "\n%s (%s, line %d)\n", __func__, __FILE__, __LINE__) + #define DBG(...) do{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); +size_t read_tty(char *buff, size_t length); +int write_tty(char *buff, size_t length); + +int str2double(double *num, const char *str); + +#endif // __USEFULL_MACROS_H__