[转载]用source insight打造个简单的C编辑器
文章作者：雪域冰芒[NBO]1>安装source insight 3.5
2>在linux机子/你开发所用的机子上运行mk_h.sh用以生成ansi c的函数帮助,mk_h.sh的内容如下:
#!/bin/sh
man -k [a-z]|grep '(3)'|grep ^[^A-Z]|grep -v _|awk '{ print $1 }'|grep -v ^dap >
__cfun__
man -k [a-z]|grep '(2)'|grep ^[^A-Z]|grep -v _|awk '{ print $1 }'|grep -v ^dap >
>__cfun__
wc -l __cfun__
#man strcpy |col -b|awk 'BEGIN {FLAG="A"} {if ((FLAG=="A" ) && ($1 ~/^SYNOPSIS/
)) FLAG="B"; if ( FLAG=="B") print $0;if ( $1 ~/^DESCRIPTION/) exit }'
echo "">ANSICfun.h
CFUN="OO"
while [ $CFUN ]
do
read CFUN
echo "Now do with $CFUN ... ..."
man $CFUN |col -b|awk 'BEGIN {FLAG="A";FLAG2="C"} {if ((FLAG=="A" ) && (
$1 ~/^SYNOPSIS/ )) FLAG="B"; if ( FLAG=="B") print $0;if ( $1 ~/^DESCRIPTION/) e
xit }'|awk '{ if ($1 ~/^int *|^void *|^char *|^unsigned *|^long *|^double *|^flo
at */ ) FLAG2="D";if ($NF ~/);/ && FLAG2=="D" ) {print $0 ; FLAG2="E"}; if ( FLA
G2=="D" && $NF !~/);/) {printf "%s",$0;FLAG2="K"}; if ( FLAG2=="K" && $NF ~/);/
) {print $0;FLAG2="C"} }' >>ANSICfun.h
done <__cfun__
sort ANSICfun.h >__TMP__
uniq __TMP__ |tr -s ' ' >ANSICfun.h
rm -f __cfun__
rm -f __TMP__
echo "All complete!!!!!!!!!!!!!"
3>将上面shell生成的ANSICfun.h拷贝到windows目录,比如C:comm_H下
4>在source insinght菜单中以此选:options-->preferences-->symbol lookups-->create common project
5>根据提示,建立headers include类型的common project,将ANSICfun.h包含进新建的工程
6>将项目中用到的头文件包含包含到新工程
7>选择project -->synchronize files
8>关闭新建工程
9>点view,确定context window处于选中状态
9>新建立个c文件,输入任意一个C函数,在context window中将提示该函数的详细参数
10>在options的custom commands中定义一个批处理文件,让执行telnet到主机,然后make即可(曾经这么用,现在还是喜欢直接telnet过去make)
11>调试直接用debug/dbx/gdb或Ctools的调试功能
12>对了,远程文件存取用samba,速度感觉比ftp快,而且多人开发时,别人修改了source code,你的source insight可以立即提示更新
13>c关键字高亮,利用下面shell生成,拷贝__cfun__到你的windows中,利用source insight的document setting 选c language,选keyword ,然后import即可
#!/bin/sh
man -k [a-z]|grep '(3)'|grep ^[^A-Z]|grep -v _|awk '{ print $1 }'|grep -v ^dap >
__cfun__
man -k [a-z]|grep '(2)'|grep ^[^A-Z]|grep -v _|awk '{ print $1 }'|grep -v ^dap >
>__cfun__
sort __cfun__|uniq >__tmp__
mv __tmp__ __cfun__
如果要添加关键字到ultraedit,则在上面shell尾部添加:
for AW in a b c d e f g h i j k l m n o p q r s t u v w x y z
do
grep ^${AW} __cfun__|awk '{printf "%s ",$1}'
echo ""
done
然后重定向各文件,将其合并到utrledit的keyword文件中,不再罗嗦
13>能记得起来的就那么多,附上ANSICfun.h和__fun__ 给需要的朋友
ANSICfun.h
[code] int flags);
char *catgets(nl_catd catalog, int set_number, int message_number, const char *message);
char * readline (const char *prompt);
char * bindtextdomain (const char * domainname, const char * dirname);
char * dcgettext (const char * domainname, const char * msgid, int category);
char * dcngettext (const char * domainname, unsigned long int n, int category);
char * dgettext (const char * domainname, const char * msgid);
char * dngettext (const char * domainname, unsigned long int n);
char * gettext (const char * msgid);
char * ngettext (const char * msgid, const char * msgid_plural, unsigned long int n);
char * textdomain (const char * domainname);
char *ERR_error_string(unsigned long e, char *buf);
char *asctime(const struct tm *tm);
char *asctime_r(const struct tm *tm, char *buf);
char *crypt(const char *key, const char *salt);
char *ctermid(char *s);
char *ctime(const time_t *timep);
char *ctime_r(const time_t *timep, char *buf);
char *cuserid(char *string);
char *ecvt(double number, int ndigits, int *decpt, int *sign);
char *errbuf, size_t errbuf_size);
char *fcvt(double number, int ndigits, int *decpt, int *sign);
char *fgets(char *s, int size, FILE *stream);
char *gcvt(double number, size_t ndigit, char *buf);
char *get_current_dir_name(void);
char *getcwd(char *buf, size_t size);
char *getenv(const char *name);
char *getlogin(void);
char *getpass( const char * prompt );
char *gets(char *s);
char *getusershell(void);
char *getwd(char *buf);
char *hasmntopt(const struct mntent *mnt, const char *opt);
char *hesiod_to_bind(void *context, const char *name, void hesiod_end(void *context) int hcreate(size_t nel);
char *index(const char *s, int c);
char *initstate(unsigned int seed, char *state, size_t n);
char *l64a(long value);
char *list, size_t size);
char *mkdtemp(char *template);
char *name; int number; int stayopen; char *name; int number; int stayopen; char *name; int number; int stayopen; int getrpcport(host, prognum, versnum, proto) char *host; int prognum, versnum, proto; int fgetc(FILE *stream);
char *out; void void void void void void void void int fd; int sock; int sock; int sock; void void void int const char *cmd, int *fd2p);
char *pcre_version(void);
char *pm_read_unknown_size(FILE * fp, long *nread);
char *qecvt(long double number, int ndigits, int *decpt, int *sign);
char *qfcvt(long double number, int ndigits, int *decpt, int *sign);
char *qgcvt(long double number, int ndigit, char *buf);
char *realpath(const char *path, char *resolved_path);
char *rindex(const char *s, int c);
char *setlocale(int category, const char *locale);
char *setstate(char *state);
char *stpcpy(char *dest, const char *src);
char *stpncpy(char *dest, const char *src, size_t n);
char *strcat(char *dest, const char *src);
char *strchr(const char *s, int c);
char *strcpy(char *dest, const char *src);
char *strdup(const char *s);
char *strdupa(const char *s);
char *strerror(int errnum);
char *strfry(char *string);
char *strncat(char *dest, const char *src, size_t n);
char *strncpy(char *dest, const char *src, size_t n);
char *strndup(const char *s, size_t n);
char *strndupa(const char *s, size_t n);
char *strpbrk(const char *s, const char *accept);
char *strptime(const char *s, const char *format, struct tm *tm);
char *strrchr(const char *s, int c);
char *strsep(char **stringp, const char *delim);
char *strsignal(int sig);
char *strstr(const char *haystack, const char *needle);
char *tempnam(const char *dir, const char *pfx);
char *tmpnam(char *s);
char *ttyname(int desc);
char errbuf[PCAP_ERRBUF_SIZE]; int promisc, int to_ms, char *errbuf) int pcap_setnonblock(pcap_t *p, int nonblock, char *errbuf);
double acos(double x);
double acosh(double x);
double asin(double x);
double asinh(double x);
double atan(double x);
double atan2(double y, double x);
double atanh(double x);
double atof(const char *nptr);
double cbrt(double x);
double ceil(double x);
double copysign(double x, double y);
double cos(double x);
double cosh(double x);
double difftime(time_t time1, time_t time0);
double drand48(void);
double drem(double x, double y);
double erand48(unsigned short xsubi[3]);
double erf(double x);
double erfc(double x);
double exp(double x);
double expm1(double x);
double fabs(double x);
double floor(double x);
double fmod(double x, double y);
double frexp(double x, int *exp);
double gamma (double x);
double hypot(double x, double y);
double j0(double x);
double j1(double x);
double jn(int n, double x);
double ldexp(double x, int exp);
double lgamma(double x);
double lgamma_r(double x, int *signp);
double log(double x);
double log10(double x);
double log1p(double x);
double modf(double x, double *iptr);
double nan(const char *tagp);
double nearbyint(double x);
double nextafter(double x, double y);
double nexttoward(double x, long double y);
double pow(double x, double y);
double rint(double x);
double round(double x);
double sinh(double x);
double sqrt(double x);
double strtod(const char *nptr, char **endptr);
double tan(double x);
double tanh(double x);
double tgamma(double x);
double trunc(double x);
double y0(double x);
double y1(double x);
double yn(int n, double x);
float png_get_pixel_aspect_ratio (png_structp png_ptr, png_infop info_ptr);
float ceilf(float x);
float copysignf(float x, float y);
float fabsf(float x);
float floorf(float x);
float gammaf (float x);
float j0f(float x);
float j1f(float x);
float jnf(int n, float x);
float lgammaf(float x);
float lgammaf_r(float x, int *signp);
float nanf(const char *tagp);
float nearbyintf(float x);
float nextafterf(float x, float y);
float nexttowardf(float x, long double y);
float rintf(float x);
float roundf(float x);
float strtof(const char *nptr, char **endptr);
float tgammaf(float x);
float truncf(float x);
float y0f(float x);
float y1f(float x);
float ynf(int n, float x);
int const char *cmd, int *fd2p);
int const char *luser);
int mpool_close (MPOOL *mp);
int mpool_put (MPOOL *mp, void *pgaddr, u_int flags);
int mpool_sync (MPOOL *mp);
int fts_close(FTS *ftsp);
int fts_set(FTS *ftsp, FTSENT *f, int options);
int getloadavg(double loadavg[], int nelem);
int rresvport(int *port);
int syscall(int number, ...);
int *hsearch_r(ENTRY item, ACTION action, ENTRY **ret, struct hsearch_data *tab);
int pselect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask);
int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen);
int execle(const char *path, const char *arg , ..., char * const envp[]);
int execve(const char *filename, char *const argv [], char *const envp[]);
int ftw(const char *dir, int (*fn)(const char *file, const struct stat *sb, int flag), int depth);
int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen);
int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen);
int openpty(int *amaster, int *aslave, char *name, struct termios *termp, struct winsize * winp);
int png_sig_cmp (png_bytep sig, png_size_t start, png_size_t num_to_check);
int recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
int sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);
int setitimer(int which, const struct itimerval *value, struct itimer- val *ovalue);
int setitimer(int which, const struct itimerval *value, struct itimer-val *ovalue);
int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec timeout);
int (*compar)(const FTSENT **, const FTSENT **));
int ERR_GET_FUNC(unsigned long e);
int ERR_GET_LIB(unsigned long e);
int ERR_GET_REASON(unsigned long e);
int ERR_get_next_error_library(void);
int NLMSG_ALIGN(size_t len);
int NLMSG_LENGTH(size_t len);
int NLMSG_OK(struct nlmsghdr *nlh, int len);
int NLMSG_PAYLOAD(struct nlmsghdr *nlh, int len);
int NLMSG_SPACE(size_t len);
int RTA_OK(struct rtattr *rta, int rtabuflen);
int abs(int j);
int acct(const char *filename);
int addmntent(FILE *filep, const struct mntent *mnt);
int adjtimex(struct timex *buf);
int alphasort(const void *a, const void *b);
int asprintf(char **strp, const char *fmt, ...);
int atexit(void (*function)(void));
int atoi(const char *nptr);
int bcmp(const void *s1, const void *s2, size_t n);
int bdflush(int func, long *address);
int bdflush(int func, long data);
int bindresvport(sd, sin) int sd;
int brk(void *end_data_segment);
int cacheflush(char *addr, int nbytes, int cache);
int capget(cap_user_header_t header, cap_user_data_t data);
int capset(cap_user_header_t header, const cap_user_data_t data);
int catclose(nl_catd catalog);
int cfmakeraw(struct termios *termios_p);
int cfsetispeed(struct termios *termios_p, speed_t speed);
int cfsetospeed(struct termios *termios_p, speed_t speed);
int chdir(const char *path);
int chmod(const char *path, mode_t mode);
int chown(const char *path, uid_t owner, gid_t group);
int clearenv(void);
int clone(int (*fn)(void *), void *child_stack, int flags, void *arg);
int closedir(DIR *dir);
int creat(const char *pathname, mode_t mode);
int daemon(int nochdir, int noclose);
int dirfd(DIR *dir);
int dlclose(void *handle);
int dprintf(int fd, const char *format, ...);
int dup(int oldfd);
int dup2(int oldfd, int newfd);
int dysize(int year);
int endmntent(FILE *filep);
int endttyent(void);
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int fchdir(int fd);
int fchmod(int fildes, mode_t mode);
int fchown(int fd, uid_t owner, gid_t group);
int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd, struct flock *lock);
int fdatasync(int fd);
int fegetround(void);
int feholdexcept(fenv_t *envp);
int feof(FILE *stream);
int ferror(FILE *stream);
int fesetround(int rounding_mode);
int fetestexcept(int excepts);
int ffs(int i);
int fgetc(FILE *stream);
int fgetpos(FILE *stream, fpos_t *pos);
int fileno(FILE *stream);
int finite(double value);
int flock(int fd, int operation);
int fnmatch(const char *pattern, const char *string, int flags);
int format);
int fprintf(FILE *stream, const char *format, ...);
int fpurge(FILE *stream);
int fputc(int c, FILE *stream);
int fputs(const char *s, FILE *stream);
int fputws(const wchar_t *ws, FILE *stream);
int fremovexattr (int filedes, const char *name);
int fscanf(FILE *stream, const char *format, ...);
int fseek(FILE *stream, long offset, int whence);
int fseeko(FILE *stream, off_t offset, int whence);
int fsetpos(FILE *stream, fpos_t *pos);
int fsetxattr (int filedes, const char *name, const void *value, size_t size, int flags);
int fstat(int filedes, struct stat *buf);
int fstatfs(int fd, struct statfs *buf);
int fsync(int fd);
int ftime(struct timeb *tp);
int ftruncate(int fd, off_t length);
int ftrylockfile(FILE *filehandle);
int fwide(FILE *stream, int mode);
int fwprintf(FILE *stream, const wchar_t *format, ...);
int getaddrinfo(const char *node, const char *service, struct addrinfo **res);
int getc(FILE *stream);
int getchar(void);
int getcontext(ucontext_t *ucp);
int getdents(unsigned int fd, struct dirent *dirp, unsigned int count);
int getdtablesize(void);
int getgroups(int size, gid_t list[]);
int gethostbyname2_r (const char *name, int af, struct hostent **result, int *h_errnop);
int gethostbyname_r (const char *name, struct hostent **result, int *h_errnop);
int gethostname(char *name, size_t len);
int getitimer(int which, struct itimerval *value);
int getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags);
int getpagesize(void);
int getpeername(int s, struct sockaddr *name, socklen_t *namelen);
int getpriority(int which, int who);
int getpw(uid_t uid, char *buf);
int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
int getsockname(int s, struct sockaddr *name, socklen_t *namelen);
int gettimeofday(struct timeval *tv, struct timezone *tz);
int getw(FILE *stream);
int glob(const char *pattern, int flags, int errfunc(const char *epath, int eerrno), glob_t *pglob);
int gsignal(signum);
int hcreate(size_t nel);
int hcreate_r(size_t nel, struct hsearch_data *tab);
int hesiod_init(void **context) char **hesiod_resolve(void *context, const char *name, void hesiod_free_list(void *context, char **list);
int idle(void);
int initgroups(const char *user, gid_t group);
int ioctl(int d, int request, ...);
int ioperm(unsigned long from, unsigned long num, int turn_on);
int iopl(int level);
int ipc(unsigned int call, int first, int second, int third, void *ptr, long fifth);
int isalnum(int c);
int isalpha(int c);
int isascii(int c);
int isatty(int desc);
int isblank(int c);
int iscntrl(int c);
int isdigit(int c);
int isgraph(int c);
int isinf(double value);
int islower(int c);
int isnan(double value);
int isprint(int c);
int ispunct(int c);
int isspace(int c);
int isupper(int c);
int iswalnum(wint_t wc);
int iswalpha(wint_t wc);
int iswblank(wint_t wc);
int iswcntrl(wint_t wc);
int iswctype(wint_t wc, wctype_t desc);
int iswdigit(wint_t wc);
int iswgraph(wint_t wc);
int iswlower(wint_t wc);
int iswprint(wint_t wc);
int iswpunct(wint_t wc);
int iswspace(wint_t wc);
int iswupper(wint_t wc);
int iswxdigit(wint_t wc);
int isxdigit(int c);
int killpg(int pgrp, int sig);
int klogctl(int type, char *bufp, int len);
int lchown(const char *path, uid_t owner, gid_t group);
int len, int type);
int listen(int s, int backlog);
int login_tty(int fd);
int lremovexattr (const char *path, const char *name);
int lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags);
int lstat(const char *file_name, struct stat *buf);
int mblen(const char *s, size_t n);
int mbsinit(const mbstate_t *ps);
int mbtowc(wchar_t *pwc, const char *s, size_t n);
int memcmp(const void *s1, const void *s2, size_t n);
int mincore(void *start, size_t length, unsigned char *vec);
int mkstemp(char *template);
int mlock(const void *addr, size_t len);
int mlockall(int flags);
int mprotect(const void *addr, size_t len, int prot);
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
int msgget(key_t key, int msgflg);
int msgsnd(int msqid, struct msgbuf *msgp, size_t msgsz, int msgflg);
int msync(const void *start, size_t length, int flags);
int munlock(const void *addr, size_t len);
int munlockall(void);
int munmap(void *start, size_t length);
int nanosleep(const struct timespec *req, struct timespec *rem);
int nftw(const char *dir, int (*fn)(const char *file, const struct stat *sb, int flag, struct FTW *s), int depth, int flags);
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
int pause(void);
int pcap_datalink(pcap_t *p) int pcap_snapshot(pcap_t *p) int pcap_is_swapped(pcap_t *p) int pcap_major_version(pcap_t *p) int pcap_minor_version(pcap_t *p) int pcap_stats(pcap_t *p, struct pcap_stat *ps) int pcap_fileno(pcap_t *p) void pcap_perror(pcap_t *p, char *prefix) char *pcap_geterr(pcap_t *p) char *pcap_strerror(int error) void pcap_close(pcap_t *p) void pcap_dump_close(pcap_dumper_t *p) int pclose(FILE *stream);
int pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf) void pcap_freealldevs(pcap_if_t *) char *pcap_lookupdev(char *errbuf) int pcap_lookupnet(char *device, bpf_u_int32 *netp, int pcap_dispatch(pcap_t *p, int cnt, int pcap_loop(pcap_t *p, int cnt, void pcap_dump(u_char *user, struct pcap_pkthdr *h, int pcap_compile(pcap_t *p, struct bpf_program *fp, char *str, int optimize, bpf_u_int32 netmask) int pcap_setfilter(pcap_t *p, struct bpf_program *fp) void pcap_freecode(struct bpf_program *);
int pcap_getnonblock(pcap_t *p, char *errbuf);
int pclose(FILE *stream);
int pcre_copy_substring(const char *subject, int *ovector, int stringcount, int stringnumber, char *buffer, int buffersize);
int pcre_exec(const pcre *code, const pcre_extra *extra, int options, int *ovector, int ovecsize);
int pcre_fullinfo(const pcre *code, const pcre_extra *extra, int what, void *where);
int pcre_get_substring(const char *subject, int *ovector, int stringcount, int stringnumber, const char **stringptr);
int pcre_get_substring_list(const char *subject, int *ovector, int stringcount, const char ***listptr);
int pcre_info(const pcre *code, int *optptr, int *firstcharptr);
int personality(unsigned long persona);
int pipe(int filedes[2]);
int pm_bitstomaxval(int bits);
int pm_keymatch(char * str, char * keyword, int minchars);
int pm_maxvaltobits(int maxval);
int pm_readbiglong(FILE *in, long *lP);
int pm_readbigshort(FILE *in, short *sP);
int pm_readlittlelong(FILE *in, long *lP);
int pm_readlittleshort(FILE *in, short *sP);
int pm_writebiglong(FILE *out, long l);
int pm_writebigshort(FILE *out, short s);
int pm_writelittlelong(FILE *out, long l);
int pm_writelittleshort(FILE *out, short s);
int png_check_sig (png_bytep sig, int num);
int png_debug(int level, png_const_charp message);
int png_debug1(int level, png_const_charp message, p1);
int png_debug2(int level, png_const_charp message, p1, p2);
int png_handle_as_unknown (png_structp png_ptr, png_bytep chunk_name);
int png_mmx_support (void);
int png_set_interlace_handling (png_structp png_ptr);
int poll(struct pollfd *ufds, unsigned int nfds, int timeout);
int poptAddAlias(poptContext con, struct poptAlias alias, int flags);
int poptDupArgv(int argc, const char ** argv, int * argcPtr, const char *** argvPtr);
int poptGetNextOpt(poptContext con);
int poptParseArgvString(char * s, int * argcPtr, const char *** argvPtr);
int poptReadConfigFile(poptContext con, char * fn);
int poptReadDefaultConfig(poptContext con, int flags);
int poptStuffArgs(poptContext con, const char ** argv);
int prctl(int option, unsigned long arg2, unsigned long arg3 , unsigned long arg4, unsigned long arg5);
int printf(const char *format, ...);
int profil(u_short *buf, size_t bufsiz, size_t offset, u_int scale);
int putc(int c, FILE *stream);
int putchar(int c);
int putenv(char *string);
int putpwent(const struct passwd *p, FILE *stream);
int puts(const char *s);
int putw(int w, FILE *stream);
int raise(int sig);
int readdir(unsigned int fd, struct dirent *dirp, unsigned int count);
int recv(int s, void *buf, size_t len, int flags);
int recvmsg(int s, struct msghdr *msg, int flags);
int regcomp(regex_t *preg, const char *pattern, int cflags);
int regcomp(regex_t *preg, const char *regex, int cflags);
int regexec(const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
int regexec(regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
int remove(const char *pathname);
int removexattr (const char *path, const char *name);
int scandir(const char *dir, struct dirent ***namelist, int(*select)(const struct dirent *), int(*compar)(const struct dirent **, const struct dirent **));
int scanf(const char *format, ...);
int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
int semctl(int semid, int semnum, int cmd, ...);
int semget(key_t key, int nsems, int semflg);
int semop(int semid, struct sembuf *sops, unsigned nsops);
int send(int s, const void *msg, size_t len, int flags);
int sendmsg(int s, const struct msghdr *msg, int flags);
int sensors_chip_name_has_wildcards(sensors_chip_name chip);
int sensors_do_chip_sets(sensors_chip_name name);
int sensors_get_feature(sensors_chip_name name, int feature, double *result);
int sensors_get_label(sensors_chip_name name, int feature, char **result);
int sensors_match_chip(sensors_chip_name chip1, sensors_chip_name chip2);
int sensors_parse_chip_name(const char *orig_name, sensors_chip_name *res);
int sensors_set_feature(sensors_chip_name name, int feature, double value);
int setcontext(const ucontext_t *ucp);
int setegid(gid_t egid);
int setenv(const char *name, const char *value, int overwrite);
int seteuid(uid_t euid);
int setfsent(void);
int setfsgid(uid_t fsgid);
int setfsuid(uid_t fsuid);
int setgid(gid_t gid);
int setgroups(size_t size, const gid_t *list);
int sethostid(long hostid);
int sethostname(const char *name, size_t len);
int setjmp(jmp_buf env);
int setlogmask(int mask);
int setpgid(pid_t pid, pid_t pgid);
int setpgrp(void);
int setpriority(int which, int who, int prio);
int setregid(gid_t rgid, gid_t egid);
int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
int setresuid(uid_t ruid, uid_t euid, uid_t suid);
int setreuid(uid_t ruid, uid_t euid);
int setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen);
int setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen);
int settimeofday(const struct timeval *tv , const struct timezone *tz);
int setttyent(void);
int setuid(uid_t uid);
int setup(void);
int setvbuf(FILE *stream, char *buf, int mode , size_t size);
int setxattr (const char *path, const char *name, const void *value, size_t size, int flags);
int setxattr (const char *path, const char *name,const void *value, size_t size, int flags);
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
int shmdt(const void *shmaddr);
int shmget(key_t key, int size, int shmflg);
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
int sigaddset(sigset_t *set, int signum);
int sigaltstack(const stack_t *ss, stack_t *oss);
int sigblock(int mask);
int sigdelset(sigset_t *set, int signum);
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int siggetmask(void);
int siginterrupt(int sig, int flag);
int sigismember(const sigset_t *set, int signum);
int sigmask(int signum);
int signbit (X);
int sigpause(int sigmask);
int sigpending(sigset_t *set);
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
int sigqueue(pid_t pid, int sig, const union sigval value);
int sigreturn(unsigned long __unused);
int sigsetjmp(sigjmp_buf env, int savesigs);
int sigsetmask(int mask);
int sigsuspend(const sigset_t *mask);
int sigvec(int sig, struct sigvec *vec, struct sigvec *ovec);
int sigwaitinfo(const sigset_t *set, siginfo_t *info);
int size int len int format int plainformat int height int width int depth int bytes_per_sample char tuple_type[256]; } void ppm_init( int *argcP, char *argv[] );
int size);
int snprintf(char *str, size_t size, const char *format, ...);
int socket(int domain, int type, int protocol);
int socketcall(int call, unsigned long *args);
int socketpair(int d, int type, int protocol, int sv[2]);
int sprintf(char *str, const char *format, ...);
int sscanf(const char *str, const char *format, ...);
int stat(const char *file_name, struct stat *buf);
int statfs(const char *path, struct statfs *buf);
int stime(time_t *t);
int strcasecmp(const char *s1, const char *s2);
int strcmp(const char *s1, const char *s2);
int strcoll(const char *s1, const char *s2);
int strerror_r(int errnum, char *buf, size_t n);
int strncasecmp(const char *s1, const char *s2, size_t n);
int strncmp(const char *s1, const char *s2, size_t n);
int strverscmp(const char *s1, const char *s2);
int swapcontext (ucontext_t *oucp, ucontext_t *ucp);
int swprintf(wchar_t *wcs, size_t maxlen, const wchar_t *format, ...);
int symlink(const char *oldpath, const char *newpath);
int sysfs(int option);
int sysfs(int option, const char *fsname);
int sysfs(int option, unsigned int fs_index, char *buf);
int syslog(int type, char *bufp, int len);
int system(const char *string);
int tcdrain(int fd);
int tcflow(int fd, int action);
int tcflush(int fd, int queue_selector);
int tcgetattr(int fd, struct termios *termios_p);
int tcsendbreak(int fd, int duration);
int tcsetattr(int fd, int optional_actions, struct termios *termios_p);
int tcsetpgrp(int fd, pid_t pgrpid);
int toascii(int c);
int truncate(const char *path, off_t length);
int ttyname_r(int desc, char *buf, size_t buflen);
int ttyslot(void);
int tux (unsigned int action, user_req_t * req);
int ungetc(int c, FILE *stream);
int uselib(const char *library);
int ustat(dev_t dev, struct ustat *ubuf);
int utime(const char *filename, struct utimbuf *buf);
int utimes(char *filename, struct timeval *tvp);
int vasprintf(char **strp, const char *fmt, va_list ap);
int vdprintf(int fd, const char *format, va_list ap);
int versionsort(const void *a, const void *b);
int vfprintf(FILE *stream, const char *format, va_list ap);
int vfscanf(FILE *stream, const char *format, va_list ap);
int vfwprintf(FILE *stream, const wchar_t *format, va_list args);
int vhangup(void);
int vm86(unsigned long fn, struct vm86plus_struct *v86);
int vm86old(struct vm86_struct *info);
int vprintf(const char *format, va_list ap);
int vscanf(const char *format, va_list ap);
int vsnprintf(char *str, size_t size, const char *format, va_list ap);
int vsprintf(char *str, const char *format, va_list ap);
int vsscanf(const char *str, const char *format, va_list ap);
int vswprintf(wchar_t *wcs, size_t maxlen, const wchar_t *format, va_list args);
int vwprintf(const wchar_t *format, va_list args);
int wcscasecmp(const wchar_t *s1, const wchar_t *s2);
int wcscmp(const wchar_t *s1, const wchar_t *s2);
int wcsncasecmp(const wchar_t *s1, const wchar_t *s2, size_t n);
int wcsncmp(const wchar_t *s1, const wchar_t *s2, size_t n);
int wcswidth(const wchar_t *s, size_t n);
int wctob(wint_t c);
int wctomb(char *s, wchar_t wc);
int wcwidth(wchar_t c);
int wmemcmp(const wchar_t *s1, const wchar_t *s2, size_t n);
int wprintf(const wchar_t *format, ...);
intmax_t imaxabs(intmax_t j);
long ptrace(enum __ptrace_request request, pid_t pid, void *addr, void *data);
long a64l(char *str64);
long atol(const char *nptr);
long double ceill(long double x);
long double copysignl(long double x, long double y);
long double fabsl(long double x);
long double floorl(long double x);
long double gammal (long double x);
long double j0l(long double x);
long double j1l(long double x);
long double jnl(int n, long double x);
long double lgammal(long double x);
long double lgammal_r(long double x, int *signp);
long double nanl(const char *tagp);
long double nearbyintl(long double x);
long double nextafterl(long double x, long double y);
long double nexttowardl(long double x, long double y);
long double rintl(long double x);
long double roundl(long double x);
long double strtold(const char *nptr, char **endptr);
long double tgammal(long double x);
long double truncl(long double x);
long double y0l(long double x);
long double y1l(long double x);
long double ynl(int n, long double x);
long fpathconf(int filedes, int name);
long ftell(FILE *stream);
long gethostid(void);
long int strtol(const char *nptr, char **endptr, int base);
long int jrand48(unsigned short xsubi[3]);
long int labs(long int j);
long int lrand48(void);
long int lrint(double x);
long int lrintf(float x);
long int lrintl(long double x);
long int lround(double x);
long int lroundf(float x);
long int lroundl(long double x);
long int mrand48(void);
long int nrand48(unsigned short xsubi[3]);
long int random(void);
long long atoll(const char *nptr);
long long atoq(const char *nptr);
long long int strtoll(const char *nptr, char **endptr, int base);
long long int llabs(long long int j);
long long int llrint(double x);
long long int llrintf(float x);
long long int llrintl(long double x);
long long int llround(double x);
long long int llroundf(float x);
long long int llroundl(long double x);
long pathconf(char *path, int name);
long quotactl(int cmd, char *special, qid_t id, caddr_t addr) int readdir(unsigned int fd, struct dirent *dirp, unsigned int count);
long sysconf(int name);
unsigned int pm_lcm(unsigned int x, unsigned int y, unsigned int z, unsigned int limit);
unsigned int RTA_LENGTH(unsigned int length);
unsigned int RTA_PAYLOAD(struct rtattr *rta);
unsigned int RTA_SPACE(unsigned int length);
unsigned int alarm(unsigned int seconds);
unsigned int pm_tell(FILE * fileP);
unsigned long ERR_PACK(int lib, int func, int reason);
unsigned long ERR_get_error(void);
unsigned long ERR_get_error_line(const char **file, int *line);
unsigned long ERR_get_error_line_data(const char **file, int *line, const char **data, int *flags);
unsigned long ERR_peek_error(void);
unsigned long ERR_peek_error_line(const char **file, int *line);
unsigned long ERR_peek_error_line_data(const char **file, int *line, const char **data, int *flags);
unsigned long int strtoul(const char *nptr, char **endptr, int base);
unsigned long long int strtoull(const char *nptr, char **endptr, int base);
unsigned short *seed48(unsigned short seed16v[3]);
void void (*pgout)(void *, pgno_t, void *), void *pgcookie);
void png_set_read_user_transform_fn (png_structp png_ptr, png_user_transform_ptr read_user_transform_fn);
void png_set_write_user_transform_fn (png_structp png_ptr, png_user_transform_ptr write_user_transform_fn);
void char *host; int uid, gid, len, *aup.gids; char *host; char *in, *out; char *in, *out; char *out; char *in, *out; char *host; char *proto; char *info; char *out; void void char *s; void char *s; char * char *s; char * char * char *s; int *sockp; int *sockp; intervals of wait time until a response is received or until the int *sockp; unsigned int sendsize; unsigned int recosize; intervals of wait time until a response is received or until the void char *in, *out; char *(*procname) () ; int svc_fds; char *in; char *in; int rdfds; interface is obsoleted by svc_getreqset(). void (*dispatch) ();
void err(int eval, const char *fmt, ...);
void errx(int eval, const char *fmt, ...);
void verr(int eval, const char *fmt, va_list args);
void verrx(int eval, const char *fmt, va_list args);
void vwarn(const char *fmt, va_list args);
void vwarnx(const char *fmt, va_list args);
void warn(const char *fmt, ...);
void warnx(const char *fmt, ...);
void png_destroy_info_struct (png_structp png_ptr, png_infopp info_ptr_ptr);
void png_set_sBIT (png_structp png_ptr, png_infop info_ptr, png_color_8p sig_bit);
void png_set_sPLT (png_structp png_ptr, png_infop info_ptr, png_spalette_p splt_ptr, int num_spalettes);
void png_process_data (png_structp png_ptr, png_infop info_ptr, png_bytep buffer, png_size_t buffer_size);
void png_read_destroy (png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr);
void png_set_bKGD (png_structp png_ptr, png_infop info_ptr, png_color_16p background);
void png_set_cHRM_fixed (png_structp png_ptr, png_infop info_ptr, png_uint_32 blue_x, png_uint_32 blue_y);
void png_set_compression_mem_level (png_structp png_ptr, int mem_level);
void png_set_error_fn (png_structp png_ptr, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn);
void png_set_filter_heuristics (png_structp png_ptr, int heuris- filter_costs);
void png_set_gAMA_fixed (png_structp png_ptr, png_infop info_ptr, png_uint_32 file_gamma);
void png_set_hIST (png_structp png_ptr, png_infop info_ptr, png_uint_16p hist);
void png_set_keep_unknown_chunks (png_structp png_ptr, int keep, png_bytep chunk_list, int num_chunks);
void png_set_read_user_chunk_fn (png_structp png_ptr, png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn);
void png_set_sRGB_gAMA_and_cHRM (png_structp png_ptr, png_infop info_ptr, int intent);
void png_set_write_fn (png_structp png_ptr, png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn);
void png_write_chunk (png_structp png_ptr, png_bytep chunk_name, png_bytep data, png_size_t length);
void png_write_info_before_PLTE (png_structp png_ptr, png_infop info_ptr);
void pnm_checkpam( struct pam *pamP, const enum pm_check_type check_type, enum pm_check_code *retvalP);
void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);
void * mremap(void *old_address, size_t old_size , size_t new_size, unsigned long flags);
void __fpurge(FILE *stream);
void pgm_readpgminit( FILE *fp, int *colsP, int *rowsP, gray *maxvalP, int *formatP );
void pgm_writepgm( FILE *fp, gray **grays, int cols, int rows, gray maxval, int forceplain );
void pgm_writepgmrow( FILE *fp, gray *grayrow, int cols, gray maxval, int forceplain );
void png_convert_from_struct_tm (png_timep ptime, struct tm FAR * ttime);
void png_destroy_read_struct (png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr);
void png_destroy_write_struct (png_structpp png_ptr_ptr, png_infopp info_ptr_ptr);
void png_progressive_combine_row (png_structp png_ptr, png_bytep old_row, png_bytep new_row);
void png_read_png (png_structp png_ptr, png_infop info_ptr, int trans- forms, png_voidp params);
void png_read_rows (png_structp png_ptr, png_bytepp row, png_bytepp display_row, png_uint_32 num_rows);
void png_set_background (png_structp png_ptr, png_color_16p back- ground_gamma);
void png_set_cHRM (png_structp png_ptr, png_infop info_ptr, double double green_y, double blue_x, double blue_y);
void png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size);
void png_set_compression_window_bits (png_structp png_ptr, int win- dow_bits);
void png_set_dither (png_structp png_ptr, png_colorp palette, int full_dither);
void png_set_filler (png_structp png_ptr, png_uint_32 filler, int flags);
void png_set_gamma (png_structp png_ptr, double screen_gamma, double default_file_gamma);
void png_set_iCCP (png_structp png_ptr, png_infop info_ptr, png_charp name, int compression_type, png_charp profile, png_uint_32 proflen);
void png_set_pCAL (png_structp png_ptr, png_infop info_ptr, png_charp units, png_charpp params);
void png_set_rgb_to_gray_fixed (png_structp png_ptr, int error_action png_fixed_point red, png_fixed_point green);
void png_set_sRGB (png_structp png_ptr, png_infop info_ptr, int intent);
void png_set_tIME (png_structp png_ptr, png_infop info_ptr, png_timep mod_time);
void png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr, int chunk, int location);
void png_set_user_transform_info (png_structp png_ptr, png_voidp nels);
void png_write_chunk_data (png_structp png_ptr, png_bytep data, png_size_t length);
void png_write_chunk_start (png_structp png_ptr, png_bytep chunk_name, png_uint_32 length);
void pnm_promoteformatrow( xel **xels, int cols, xelval maxval, int format, xelval newmaxval, int newformat);
void pnm_readpnminit( FILE *fp, int *colsP, int *rowsP, xelval *max- valP, int *formatP );
void pnm_writepnmrow( FILE *fp, xel *xelrow, int cols, xelval maxval, int forceplain );
void ppm_readppminit( FILE *fp, int *colsP, int *rowsP, pixval *max- valP, int *formatP );
void ppm_writeppmrow( FILE *fp, pixel *pixelrow, int cols, pixval max- val, int forceplain );
void (*pcre_free)(void *);
void * mpool_get (MPOOL *mp, pgno_t pgno, u_int flags);
void * mpool_new (MPOOL *mp, pgno_t *pgnoaddr);
void * mmap2(void *start, size_t length, int prot, int flags, int fd, off_t pgoffset);
void *(*pcre_malloc)(size_t);
void *NLMSG_DATA(struct nlmsghdr *nlh);
void *RTA_DATA(struct rtattr *rta);
void *alloca(size_t size);
void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
void *calloc(size_t nmemb, size_t size);
void *dlopen(const char *filename, int flag);
void *dlsym(void *handle, char *symbol);
void *iov_base; /* Starting address */
void *iov_base; /* Starting address */ int recv(int s, void *buf, size_t len, int flags);
void *iov_base; /* Starting address */ void *calloc(size_t nmemb, size_t size);
void *lfind(const void *key, const void *base, size_t *nmemb, size_t size, int(*compar)(const void *, const void *));
void *lsearch(const void *key, void *base, size_t *nmemb, size_t size, int(*compar)(const void *, const void *));
void *malloc(size_t size);
void *memccpy(void *dest, const void *src, int c, size_t n);
void *memchr(const void *s, int c, size_t n);
void *memcpy(void *dest, const void *src, size_t n);
void *memfrob(void *s, size_t n);
void *memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen);
void *memmove(void *dest, const void *src, size_t n);
void *memrchr(const void *s, int c, size_t n);
void *memset(void *s, int c, size_t n);
void *realloc(void *ptr, size_t size);
void *sbrk(ptrdiff_t increment);
void *shmat(int shmid, const void *shmaddr, int shmflg);
void *tdelete(const void *key, void **rootp, int(*compar)(const void *, const void *));
void *tfind(const void *key, const void **rootp, int(*compar)(const void *, const void *));
void *tsearch(const void *key, void **rootp, int(*compar)(const void *, const void *));
void *value, size_t size);
void ERR_add_error_data(int num, ...);
void ERR_clear_error(void);
void ERR_free_strings(void);
void ERR_load_crypto_strings(void);
void ERR_load_strings(int lib,ERR_STRING_DATA str[]);
void ERR_print_errors(BIO *bp);
void ERR_print_errors_fp(FILE *fp);
void ERR_put_error(int lib, int func, int reason, const char *file, int line);
void ERR_remove_state(unsigned long pid);
void PPM_ASSIGN( pixel p, pixval red, pixval grn, pixval blu) int PPM_EQUAL( pixel p, pixel q) void PPM_DEPTH( pixel newp, pixel p, pixval oldmaxval, pixval newmax- float PPM_LUMIN( pixel p) float PPM_CHROM_R( pixel p) float PPM_CHROM_B( pixel p) char * ppm_colorname( pixel *colorP, pixval maxval, int hexok) int sensors_init(FILE *input);
void abort(void);
void assert(scalar expression);
void bcopy(const void *src, void *dest, size_t n);
void bit** pbm_readpbm(FILE * fp, int *colsP, int *rowsP);
void bzero(void *s, size_t n);
void clearerr(FILE *stream);
void closelog(void);
void endfsent(void);
void endgrent(void);
void endhostent(void);
void endprotoent(void);
void endpwent(void);
void endusershell(void);
void endutent(void);
void feclearexcept(int excepts);
void fegetenv(fenv_t *envp);
void fegetexceptflag(fexcept_t *flagp, int excepts);
void feraiseexcept(int excepts);
void fesetenv(const fenv_t *envp);
void fesetexceptflag(const fexcept_t *flagp, int excepts);
void feupdateenv(const fenv_t *envp);
void flockfile(FILE *filehandle);
void free(void *ptr);
void freeaddrinfo(struct addrinfo *res);
void funlockfile(FILE *filehandle);
void globfree(glob_t *pglob);
void hdestroy(void);
void hdestroy_r(struct hsearch_data *tab);
void herror(const char *s);
void insque(struct qelem *elem, struct qelem *prev);
void lcong48(unsigned short param[7]);
void longjmp(jmp_buf env, int val);
void makecontext(ucontext_t *ucp, void *func(), int argc, ...);
void mtrace(void);
void muntrace(void);
void openlog(const char *ident, int option, int facility);
void pbm_check( FILE * file, const enum pm_check_type check_type, const int format, const int cols, const int rows, enum pm_check_code * const retval);
void pbm_nextimage( FILE *file, int * const eofP);
void pbm_readpbminit(FILE * fp, int *colsP, int *rowsP, int *formatP);
void pbm_readpbmrow(FILE * fp, bit *bitrow, int cols, int format);
void pbm_readpbmrow_packed(FILE * fp, unsigned char * const packed_bits, const int cols, const int format);
void pbm_writepbm(FILE * fp, bit **bits, int cols, int rows, int force- plain);
void pbm_writepbminit(FILE * fp, int cols, int rows, int forceplain);
void pbm_writepbmrow(FILE * fp, bit *bitrow, int cols, int forceplain);
void pbm_writepbmrow_packed(FILE * fp, unsigned char * const packed_bits, const int cols, const int force- plain);
void pcre_free_substring(const char *stringptr);
void pcre_free_substring_list(const char **stringptr);
void pgm_check( FILE * file, const enum pm_check_type check_type, const int format, const int cols, const int rows, const int maxval, enum pm_check_code * const retval);
void pgm_freearray( gray **grays, introws );
void pgm_freerow( gray *grayrow);
void pgm_init( int *argcP, char *argv[] );
void pgm_nextimage( FILE *file, int * const eofP);
void pgm_readpgmrow( FILE *fp, gray *grayrow, int cols, gray maxval, int format );
void pgm_writepgm( FILE *fp, gray ** grays, int cols, int rows, gray maxval, int forceplain );
void pgm_writepgminit( FILE * fp , int cols, int rows, gray maxval, int forceplain );
void pm_error(char * fmt, ... );
void pm_message(char * fmt, ... );
void pm_perror(char * fmt, ... );
void pm_seek(FILE * fileP, unsigned long filepos);
void pm_usage(char * usage);
void png_chunk_error (png_structp png_ptr, png_const_charp error);
void png_chunk_warning (png_structp png_ptr, png_const_charp message);
void png_convert_from_time_t (png_timep ptime, time_t ttime);
void png_error (png_structp png_ptr, png_const_charp error);
void png_free (png_structp png_ptr, png_voidp ptr);
void png_free_chunk_list (png_structp png_ptr);
void png_free_data (png_structp png_ptr, png_infop info_ptr, int num);
void png_free_default(png_structp png_ptr, png_voidp ptr);
void png_init_io (png_structp png_ptr, FILE *fp);
void png_read_end (png_structp png_ptr, png_infop info_ptr);
void png_read_image (png_structp png_ptr, png_bytepp image);
void png_read_info (png_structp png_ptr, png_infop info_ptr);
void png_read_row (png_structp png_ptr, png_bytep row, png_bytep dis- play_row);
void png_read_update_info (png_structp png_ptr, png_infop info_ptr);
void png_set_IHDR (png_structp png_ptr, png_infop info_ptr, png_uint_32 lace_type, int compression_type, int filter_type);
void png_set_PLTE (png_structp png_ptr, png_infop info_ptr, png_colorp palette, int num_palette);
void png_set_bgr (png_structp png_ptr);
void png_set_compression_level (png_structp png_ptr, int level);
void png_set_compression_method (png_structp png_ptr, int method);
void png_set_compression_strategy (png_structp png_ptr, int strategy);
void png_set_crc_action (png_structp png_ptr, int crit_action, int ancil_action);
void png_set_expand (png_structp png_ptr);
void png_set_filter (png_structp png_ptr, int method, int filters);
void png_set_flush (png_structp png_ptr, int nrows);
void png_set_gAMA (png_structp png_ptr, png_infop info_ptr, double file_gamma);
void png_set_gray_1_2_4_to_8(png_structp png_ptr);
void png_set_gray_to_rgb (png_structp png_ptr);
void png_set_invalid (png_structp png_ptr, png_infop info_ptr, int mask);
void png_set_invert_alpha (png_structp png_ptr);
void png_set_invert_mono (png_structp png_ptr);
void png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_mal- loc_ptr malloc_fn, png_free_ptr free_fn);
void png_set_oFFs (png_structp png_ptr, png_infop info_ptr, png_uint_32 offset_x, png_uint_32 offset_y, int unit_type);
void png_set_pHYs (png_structp png_ptr, png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type);
void png_set_packing (png_structp png_ptr);
void png_set_packswap (png_structp png_ptr);
void png_set_palette_to_rgb(png_structp png_ptr);
void png_set_progressive_read_fn (png_structp png_ptr, png_voidp pro- row_fn, png_progressive_end_ptr end_fn);
void png_set_read_fn (png_structp png_ptr, png_voidp io_ptr, png_rw_ptr read_data_fn);
void png_set_read_status_fn (png_structp png_ptr, png_read_status_ptr read_row_fn);
void png_set_rgb_to_gray (png_structp png_ptr, int error_action, double red, double green);
void png_set_rows (png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers);
void png_set_sCAL (png_structp png_ptr, png_infop info_ptr, png_charp unit, double width, double height);
void png_set_shift (png_structp png_ptr, png_color_8p true_bits);
void png_set_sig_bytes (png_structp png_ptr, int num_bytes);
void png_set_strip_16 (png_structp png_ptr);
void png_set_strip_alpha (png_structp png_ptr);
void png_set_strip_error_numbers (png_structp png_ptr, png_uint_32 strip_mode);
void png_set_swap (png_structp png_ptr);
void png_set_swap_alpha (png_structp png_ptr);
void png_set_tRNS (png_structp png_ptr, png_infop info_ptr, png_bytep trans, int num_trans, png_color_16p trans_values);
void png_set_tRNS_to_alpha(png_structp png_ptr);
void png_set_text (png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, int num_text);
void png_set_write_status_fn (png_structp png_ptr, png_write_status_ptr write_row_fn);
void png_start_read_image (png_structp png_ptr);
void png_warning (png_structp png_ptr, png_const_charp message);
void png_write_chunk_end (png_structp png_ptr);
void png_write_destroy (png_structp png_ptr);
void png_write_end (png_structp png_ptr, png_infop info_ptr);
void png_write_flush (png_structp png_ptr);
void png_write_image (png_structp png_ptr, png_bytepp image);
void png_write_info (png_structp png_ptr, png_infop info_ptr);
void png_write_png (png_structp png_ptr, png_infop info_ptr, int trans- forms, png_voidp params);
void png_write_row (png_structp png_ptr, png_bytep row);
void png_write_rows (png_structp png_ptr, png_bytepp row, png_uint_32 num_rows);
void png_zfree (voidpf png_ptr, voidpf ptr);
void pnm_YCbCrtuple( tupletuple, double *YP, double *CrP, double *CbP);
void pnm_check( FILE * file, const enum pm_check_type check_type, const int format, const int cols, const int rows, const xelval maxval, enum pm_check_code *retvalP);
void pnm_freearray( xel **xels, int rows);
void pnm_freepamarray( tuple **tuplearray, struct pam *pamP);
void pnm_freepamrow( tuple *tuplerow);
void pnm_freepamtuple( tuple tuple );
void pnm_freerow( xel *xelrow);
void pnm_init( int *argcP, char *argv[] );
void pnm_invertxel( xel *x, xelval maxval, int format);
void pnm_nextimage( FILE *file, int * const eofP);
void pnm_promoteformatrow( xel *xelrow, int cols, xelval maxval, int format, xelval newmaxval, int newformat);
void pnm_readpaminit( FILE *file, struct pam *pamP, int size);
void pnm_readpamrow( struct pam *pamP, tuple *tuplerow);
void pnm_readpnmrow( FILE *fp, xel *xelrow, int cols, xelval maxval, int format );
void pnm_writepam( struct pam *pamP, const tuple * const *tuplearray);
void pnm_writepaminit( struct pam *pamP);
void pnm_writepamrow( struct pam *pamP, const tuple *tuplerow);
void pnm_writepnm( FILE *fp, xel ** xels, int cols, int rows, xelval maxval, int forceplain );
void pnm_writepnminit( FILE * fp , int cols, int rows, xelval maxval, int forceplain);
void poptFreeContext(poptContext con);
void poptResetContext(poptContext con);
void ppm_check( FILE * file, const enum pm_check_type check_type, const int format, const int cols, const int rows, const int maxval, enum pm_check_code * const retval);
void ppm_freearray( pixel **pixels, int rows );
void ppm_freerow( pixel *pixelrow);
void ppm_nextimage( FILE *file, int * const eofP);
void ppm_readppmrow( FILE *fp, pixel *pixelrow, int cols, pixval max- val, int format );
void ppm_writeppm( FILE *fp, pixel ** pixels, int cols, int rows, pix- val maxval, int forceplain );
void ppm_writeppm( FILE *fp, pixel **pixels, int cols, int rows, pixval maxval, int forceplain );
void ppm_writeppminit( FILE * fp , int cols, int rows, pixval maxval, int forceplain );
void psignal(int sig, const char *s);
void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
void regfree(regex_t *preg);
void remque(struct qelem *elem);
void rewind(FILE *stream);
void rewinddir(DIR *dir);
void seekdir(DIR *dir, off_t offset);
void sensors_cleanup(void);
void setbuf(FILE *stream, char *buf);
void setbuffer(FILE *stream, char *buf, size_tsize);
void setgrent(void);
void sethostent(int stayopen);
void setlinebuf(FILE *stream);
void setprotoent(int stayopen);
void setpwent(void);
void setusershell(void);
void setutent(void);
void siglongjmp(sigjmp_buf env, int val);
void srand48(long int seedval);
void srandom(unsigned int seed);
void swab(const void *from, void *to, ssize_t n);
void syslog(int priority, const char *format, ...);
void tdestroy (void *root, void (*free_node)(void *nodep));
void twalk(const void *root, void(*action)(const void *nodep, const int depth));
void tzset (void);
void unsetenv(const char *name);
void utmpname(const char *file);
void va_copy(va_list dest, va_list src);
void va_end(va_list ap);
void va_start(va_list ap, last);
void vsyslog(int priority, const char *format, va_list ap);
voidp png_memcpy (png_voidp s1, png_voidp s2, png_size_t size);
voidp png_memset (png_voidp s1, int value, png_size_t size);
voidpf png_zalloc (voidpf png_ptr, uInt items, uInt size);[/code]
__cfun__
[code]a64l
abort
abs
accept
access
acct
acos
acosh
addmntent
adjtimex
alarm
alloca
alphasort
asctime
asin
asinh
asprintf
assert
atan
atan2
atanh
atexit
atof
atoi
atol
atoll
atoq
basename
bcmp
bcopy
bdflush
bind
bindresvport
bindtextdomain
break
brk
bsearch
btowc
btree
bzero
cacheflush
calloc
capget
capset
catclose
catgets
catopen
cbrt
ceil
ceilf
ceill
cfgetispeed
cfgetospeed
cfmakeraw
cfsetispeed
cfsetospeed
chdir
chmod
chown
chroot
clearenv
clearerr
clock
clone
close
closedir
closelog
confstr
connect
copysign
copysignf
copysignl
cos
cosh
creat
crypt
ctermid
ctime
cups-config
cuserid
daemon
daylight
dbopen
dcgettext
dcngettext
dgettext
difftime
dirfd
dirname
div
dlclose
dlerror
dlopen
dlsym
dngettext
dprintf
drand48
drem
dup
dup2
dysize
ecvt
encrypt
endfsent
endgrent
endhostent
endmntent
endprotoent
endpwent
endttyent
endusershell
endutent
erand48
erf
erfc
err
errno
errx
execl
execle
execlp
execv
execve
execvp
exit
exp
expm1
fabs
fabsf
fabsl
fchdir
fchmod
fchown
fclose
fcloseall
fcntl
fcvt
fdatasync
fdopen
feclearexcept
fegetenv
fegetexceptflag
fegetround
feholdexcept
feof
feraiseexcept
ferror
fesetenv
fesetexceptflag
fesetround
fetestexcept
feupdateenv
fflush
ffs
fgetc
fgetgrent
fgetpos
fgetpwent
fgets
fgetwc
fgetws
fgetxattr
fileno
finite
flistxattr
flock
flockfile
floor
floorf
floorl
fmod
fnmatch
fontconfig
fopen
fork
forkpty
fpathconf
fprintf
fpurge
fputc
fputs
fputwc
fputws
fread
free
fremovexattr
freopen
frexp
fscanf
fseek
fseeko
fsetpos
fsetxattr
fstat
fstatfs
fsync
ftell
ftello
ftime
ftok
ftruncate
ftrylockfile
fts
ftw
funlockfile
fwide
fwprintf
fwrite
gamma
gcvt
getaddrinfo
getc
getchar
getcontext
getcwd
getdate()
getdelim
getdents
getdirentries
getdomainname
getdtablesize
getegid
getenv
geteuid
getfsent
getfsfile
getfsspec
getgid
getgrent
getgrgid
getgrnam
getgroups
gethostbyaddr
gethostbyname
gethostid
gethostname
getitimer
getline
getloadavg
getlogin
getmntent
getnameinfo
getopt
getpagesize
getpass
getpeername
getpgid
getpgrp
getpid
getppid
getpriority
getprotobyname
getprotobynumber
getprotoent
getpw
getpwent
getpwnam
getpwuid
getresgid
getresuid
getrlimit
getrpcbyname
getrpcbynumber
getrpcent
getrpcport
getrusage
gets
getsid
getsockname
getsockopt
gettext
gettimeofday
getttyent
getttynam
getuid
getumask
getusershell
getutent
getutid
getutline
getw
getwc
getwchar
getwd
getxattr
glob
globfree
gmtime
gsignal
gtty
hash
hasmntopt
hcreate
hdestroy
herror
hesiod
history
hsearch
hstrerror
htonl
htons
hypot
iconv
idle
imaxabs
inb
index
initgroups
initstate
inl
insb
insl
insque
insw
intro
inw
ioctl
ioperm
iopl
ipc
iruserok
isalnum
isalpha
isascii
isatty
isblank
iscntrl
isdigit
isgraph
isinf
islower
isnan
isprint
ispunct
isspace
isupper
iswalnum
iswalpha
iswblank
iswcntrl
iswctype
iswdigit
iswgraph
iswlower
iswprint
iswpunct
iswspace
iswupper
iswxdigit
isxdigit
j0
j0f
j0l
j1
j1f
j1l
jn
jnf
jnl
jrand48
kill
killpg
l64a
labs
lchown
lcong48
ldap
ldexp
ldiv
lfind
lgamma
lgetxattr
libcurl
libcurl-multi
liblockdev
libpbm
libpgm
libpng
libpnm
libppm
libsensors
libuuid
libxml
link
listen
listxattr
llabs
llistxattr
llrint
llrintf
llrintl
llround
llroundf
llroundl
localeconv
localtime
lock
lockdev
lockf
log
log10
log1p
logger
logwtmp
longjmp
lrand48
lremovexattr
lrint
lrintf
lrintl
lround
lroundf
lroundl
lsearch
lseek
lsetxattr
lstat
madvise
makecontext
malloc
mblen
mbrlen
mbrtowc
mbsinit
mbsnrtowcs
mbsrtowcs
mbstowcs
mbtowc
memccpy
memchr
memcmp
memcpy
memfrob
memmem
memmove
memrchr
memset
mincore
mkdir
mkdtemp
mkfifo
mknod
mkstemp
mktemp
mktime
mlock
mlockall
mmap
mmap2
modf
mount
mpool
mprotect
mpx
mrand48
mremap
msgctl
msgget
msgop
msync
mtrace
munlock
munlockall
munmap
muntrace
nan
nanf
nanl
nanosleep
nearbyint
nearbyintf
nearbyintl
netlink
nextafter
nexttoward
nfsservctl
nftw
ngettext
nice
none
nrand48
ntohl
ntohs
oldfstat
oldlstat
oldolduname
oldstat
olduname
open
opendir
openlog
openpty
outb
outl
outsb
outsl
outsw
outw
pathconf
pause
pcap
pclose
pcre
pcreposix
perror
personality
phys
pipe
poll
popen
popt
pow
prctl
pread
printf
prof
profil
pselect
psignal
ptrace
putc
putchar
putenv
putpwent
puts
pututline
putw
putwchar
pwrite
qecvt
qfcvt
qgcvt
qsort
quotactl
raise
rand
random
rcmd
read
readdir
readline
readlink
readv
realloc
realpath
reboot
recno
recv
recvfrom
recvmsg
regcomp
regerror
regexec
regfree
remove
removexattr
remque
rename
rewind
rewinddir
rindex
rint
rintf
rintl
rmdir
round
roundf
roundl
rpc
rquota
rresvport
rtnetlink
ruserok
sbrk
scandir
scanf
seed48
seekdir
select
semctl
semget
semop
send
sendfile
sendmsg
sendto
setbuf
setbuffer
setcontext
setdomainname
setegid
setenv
seteuid
setfsent
setfsgid
setfsuid
setgid
setgrent
setgroups
sethostent
sethostid
sethostname
setitimer
setjmp
setlinebuf
setlocale
setlogmask
setmntent
setpgid
setpgrp
setpriority
setprotoent
setpwent
setregid
setresgid
setresuid
setreuid
setrlimit
setsid
setsockopt
setstate
settimeofday
setttyent
setuid
setup
setusershell
setutent
setvbuf
setxattr
shadow
shmctl
shmget
shmop
shutdown
sigaction
sigaddset
sigaltstack
sigblock
sigdelset
sigemptyset
sigfillset
siggetmask
siginterrupt
sigismember
siglongjmp
sigmask
signal
signbit
sigpause
sigpending
sigprocmask
sigqueue
sigreturn
sigsetjmp
sigsetmask
sigsuspend
sigtimedwait
sigvec
sigwaitinfo
sinh
sleep
snprintf
socket
socketcall
socketpair
sprintf
sqrt
srand
srand48
srandom
sscanf
ssignal
stat
statfs
stdarg
stderr
stdin
stdio
stdout
stime
stpcpy
stpncpy
strcasecmp
strcat
strchr
strcmp
strcoll
strcpy
strcspn
strdup
strdupa
strerror
strfmon
strfry
strftime
strlen
strncasecmp
strncat
strncmp
strncpy
strndup
strndupa
strnlen
strpbrk
strptime
strrchr
strsep
strsignal
strspn
strstr
strtod
strtof
strtok
strtol
strtold
strtoll
strtoq
strtoul
strtoull
strtouq
strverscmp
strxfrm
stty
swab
swapcontext
swapoff
swapon
swprintf
symlink
sync
syscall
sysconf
sysctl
sysfs
sysinfo
syslog
system
tan
tanh
tcdrain
tcflow
tcflush
tcgetattr
tcgetpgrp
tcsendbreak
tcsetattr
tcsetpgrp
tdelete
telldir
tempnam
termios
textdomain
tfind
tgamma
tgammaf
tgammal
time
timegm
timelocal
times
timezone
tmpfile
tmpnam
toascii
tolower
toupper
towctrans
towlower
towupper
trunc
truncate
truncf
truncl
tsearch
ttyname
ttyslot
tux
twalk
tzname
tzset
ulimit
umask
umount
uname
ungetc
ungetwc
unlink
updwtmp
uselib
usleep
ustat
utime
utimes
utmpname
vasprintf
vdprintf
verr
verrx
versionsort
vfork
vfprintf
vfscanf
vfwprintf
vhangup
vm86
vm86old
vprintf
vscanf
vsnprintf
vsprintf
vsscanf
vswprintf
vwarn
vwarnx,
vwprintf
wait
wait3
wait4
waitpid
warn
warnx
wcpcpy
wcpncpy
wcrtomb
wcscasecmp
wcscat
wcschr
wcscmp
wcscpy
wcscspn
wcsdup
wcslen
wcsncasecmp
wcsncat
wcsncmp
wcsncpy
wcsnlen
wcsnrtombs
wcspbrk
wcsrchr
wcsrtombs
wcsspn
wcsstr
wcstok
wcstombs
wcswidth
wctob
wctomb
wctrans
wctype
wcwidth
wmemchr
wmemcmp
wmemcpy
wmemmove
wmemset
wprintf
write
writev
xdr
y0
y0f
y0l
y1
y1f
y1l
yn
ynf
ynl
zlib[/code]
页:
[1]