uemf.h文件注释
/*
* uemf.h -- GoAhead Micro Embedded Management Framework Header
*
* Copyright (c) GoAhead Software Inc., 1995-2010. All Rights Reserved.
*
* See the file "license.txt" for usage and redistribution license requirements
*
*/
#ifndef _h_UEMF
#define _h_UEMF 1
/******************************** Description *********************************/
/*
* GoAhead Web Server header. This defines the Web public APIs
*/
/******************************* Per O/S Includes *****************************/
//定义了每种支持的操作系统下对应包含的系统头文件
#ifdef WIN
XXXXXXXXXXXX
#endif /* WIN */
#ifdef CE
XXXXXXXXXXXX
#endif /* CE */
#ifdef NW
XXXXXXXXXXXX
#endif /* NW */
#ifdef SCOV5
XXXXXXXXXXXX
#endif /* SCOV5 */
#ifdef UNIX
XXXXXXXXXXXX
#endif /* UNIX */
#ifdef LINUX
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <time.h>
#include <fcntl.h>
#include <errno.h>
#endif /* LINUX */
#ifdef LYNX
XXXXXXXXXXXXX
#endif /* LYNX */
#ifdef MACOSX
XXXXXXXXXXXXX
#endif /* MACOSX */
#ifdef UW
XXXXXXXXXXXXX
#endif /* UW */
#ifdef VXWORKS
XXXXXXXXXXXXX
#endif /* VXWORKS */
#ifdef sparc
XXXXXXXXXXXXX
#endif /* sparc */
#ifdef SOLARIS
XXXXXXXXXXXXX
#endif /* SOLARIS */
#ifdef QNX4
XXXXXXXXXXXXX
#endif /* QNX4 */
#ifdef ECOS
XXXXXXXXXXXXX
#endif /* ECOS */
/********************************** Includes **********************************/
#include <ctype.h>
#include <stdarg.h>
#include <string.h>
#ifndef WEBS
#include "messages.h"
#endif /* ! WEBS */
/******************************* Per O/S Defines *****************************/
//每个支持的操作系统下对应的宏定义
#ifdef UW
XXXXXXXXXXXXXXXXXXXXXX
#endif /* UW */
#if (defined (SCOV5) || defined (VXWORKS) || defined (LINUX) || defined (LYNX) || defined (MACOSX))
#ifndef O_BINARY
#define O_BINARY 0
#endif /* O_BINARY */
#define SOCKET_ERROR -1
#endif /* SCOV5 || VXWORKS || LINUX || LYNX || MACOSX */
#if (defined (WIN) || defined (CE))
XXXXXXXXXXXXXXXXXXXXXXXX
#endif /* WIN || CE */
#if (defined (LINUX) && !defined (_STRUCT_TIMEVAL))
struct timeval
{
time_t tv_sec; /* Seconds. */
time_t tv_usec; /* Microseconds. */
};
#define _STRUCT_TIMEVAL 1
#endif /* LINUX && ! _STRUCT_TIMEVAL */
#ifdef ECOS
XXXXXXXXXXXXXXXXXXXX
#endif /* ECOS */
#ifdef QNX4
XXXXXXXXXXXXXXXXXXXXX
#endif /* QNX4 */
#ifdef MACOSX
XXXXXXXXXXXXXXXXXXXX
#endif
#ifdef NW
XXXXXXXXXXXXXXXXXXXX
#endif /* NW */
/********************************** Unicode ***********************************/
/*
* Constants and limits. Also FNAMESIZE and PATHSIZE are currently defined
* in param.h to be 128 and 512
*/
//常量和系统的一些大小限制
#define TRACE_MAX (4096 - 48)
#define VALUE_MAX_STRING (4096 - 48)
#define SYM_MAX (512)
#define XML_MAX 4096 /* Maximum size for tags/tokens */
#define BUF_MAX 4096 /* General sanity check for bufs */
//sanity check 完整性检查，合理性检查
#ifndef LINE_MAX
#define LINE_MAX 2048 /* General sanity check for a single line */
#endif /* LINE_MAX */
#define FMT_STATIC_MAX 256 /* Maximum for fmtStatic calls */
#if (defined (LITTLEFOOT) || defined (WEBS))
#define LF_BUF_MAX (510)
#define LF_PATHSIZE LF_BUF_MAX
#else
#define LF_BUF_MAX BUF_MAX
#define LF_PATHSIZE PATHSIZE
#define UPPATHSIZE PATHSIZE
#endif /* LITTLEFOOT || WEBS */
//关于字符串编码的一些宏定义
#ifndef CHAR_T_DEFINED
#define CHAR_T_DEFINED 1
#ifdef UNICODE
/*
* To convert strings to UNICODE. We have a level of indirection so things
* like T(__FILE__) will expand properly.
*/
//将字符串转换为UNICODE编码方式。我们有正确的重定向，所以宏T（__FILE__）能被//正确的扩充。
#define T(x) __TXT(x)
#define __TXT(s) L ## s
typedef unsigned short char_t;//UNICODE编码是一个字符占两个字节。
typedef unsigned short uchar_t;
/*
* Text size of buffer macro. A buffer bytes will hold (size / char size)
* characters.
*/
#define TSZ(x) (sizeof(x) / sizeof(char_t))
//TSZ(X)返回一个缓冲区中能存放多少个字符
/*
* How many ASCII bytes are required to represent this UNICODE string?
*/
#define TASTRL(x) ((wcslen(x) + 1) * sizeof(char_t))
#else
#define T(s) s
typedef char char_t;
#define TSZ(x) (sizeof(x))
#define TASTRL(x) (strlen(x) + 1)
#ifdef WIN
///////////////////////////////////////////////////////////////////
#endif /* WIN */
#endif /* UNICODE */
#endif /* ! CHAR_T_DEFINED */
/*
* "Boolean" constants
*/
//布尔值的定义
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
/*
* GoAhead Copyright.
*/
//版权信息的字符串常量宏定义
#define GOAHEAD_COPYRIGHT \
T("Copyright (c) GoAhead Software Inc., 1995-2010. All Rights Reserved.")
/*
* The following include has to be after the unicode defines. By putting it
* here, many modules in various parts of the tree are cleaner.
*/
#if (defined (LITTLEFOOT) && defined (INMEM))
#include "lf/inmem.h"
#endif /* LITTLEFOOT && INMEM */
/*
* Type for unicode systems
*/
//按是否采用UNICODE编码对一些函数进行重命名
#ifdef UNICODE
#define gmain wmain
#define gasctime _wasctime
#define gsprintf swprintf
#define gprintf wprintf
#define gfprintf fwprintf
#define gsscanf swscanf
#define gvsprintf vswprintf
#define gstrcpy wcscpy
#define gstrncpy wcsncpy
#define gstrncat wcsncat
#define gstrlen wcslen
#define gstrcat wcscat
#define gstrcmp wcscmp
#define gstrncmp wcsncmp
#define gstricmp wcsicmp
#define gstrchr wcschr
#define gstrrchr wcsrchr
#define gstrtok wcstok
#define gstrnset wcsnset
#define gstrrchr wcsrchr
#define gstrspn wcsspn
#define gstrcspn wcscspn
#define gstrstr wcsstr
#define gstrtol wcstol
#define gfopen _wfopen
#define gopen _wopen
#define gclose close
#define gcreat _wcreat
#define gfgets fgetws
#define gfputs fputws
#define gfscanf fwscanf
#define ggets _getws
#define glseek lseek
#define gunlink _wunlink
#define gread read
#define grename _wrename
#define gwrite write
#define gtmpnam _wtmpnam
#define gtempnam _wtempnam
#define gfindfirst _wfindfirst
#define gfinddata_t _wfinddata_t
#define gfindnext _wfindnext
#define gfindclose _findclose
#define gstat _wstat
#define gaccess _waccess
#define gchmod _wchmod
typedef struct _stat gstat_t;
#define gmkdir _wmkdir
#define gchdir _wchdir
#define grmdir _wrmdir
#define ggetcwd _wgetcwd
#define gtolower towlower
#define gtoupper towupper
#ifdef CE
///////////////////////////////////////////////////////////////
#endif /* if CE */
#define gisalnum iswalnum
#define gisalpha iswalpha
#define gatoi(s) wcstol(s, NULL, 10)
#define gctime _wctime
#define ggetenv _wgetenv
#define gexecvp _wexecvp
#else /* ! UNICODE */
#ifdef VXWORKS
//////////////////////////////////////////////////////////////
#endif /* ! VXWORKS */
#ifdef VXWORKS
#endif /* VXWORKS */
#endif /* ! UNICODE */
#ifdef WIN32
///////////////////////////////////////////////////////////////
#endif
/*
* Include inmem.h here because it redefines many of the file access fucntions.
* Otherwise there would be lots more #if-#elif-#else-#endif ugliness.
*/
#ifdef INMEM
#include "lf/inmem.h"
#endif
/********************************** Defines ***********************************/
#ifndef FNAMESIZE
#define FNAMESIZE 254 /* Max length of file names */
#endif /* FNAMESIZE */
#define E_MAX_ERROR 4096
#define URL_MAX 4096
#define E_MAX_REQUEST 2048 /* Request safeguard max */
/*
* Error types//错误类型常量定义
*/
#define E_ASSERT 0x1 /* Assertion error */
#define E_LOG 0x2 /* Log error to log file */
#define E_USER 0x3 /* Error that must be displayed */
#define E_L T(__FILE__), __LINE__
#define E_ARGS_DEC char_t *file, int line//在balloc.c中经常出现
#define E_ARGS file, line
#if (defined (ASSERT) || defined (ASSERT_CE))
#define a_assert(C) if (C) ; else error(E_L, E_ASSERT, T("%s"), T(#C))
#else
#define a_assert(C) if (1) ; else
#endif /* ASSERT || ASSERT_CE */
#define elementsof(X) sizeof(X) / sizeof(X[0])
/******************************************************************************/
/* VALUE */
/******************************************************************************/
/*
* These values are not prefixed so as to aid code readability
*/
typedef enum {
undefined = 0,
byteint = 1,
shortint = 2,
integer = 3,
hex = 4,
percent = 5,
octal = 6,
big = 7,
flag = 8,
floating = 9,
string = 10,
bytes = 11,
symbol = 12,
errmsg = 13
} vtype_t;
#ifndef __NO_PACK
#pragma pack(2)
#endif /* _NO_PACK */
typedef struct {
union {
char flag;
char byteint;
short shortint;
char percent;
long integer;
long hex;
long octal;
long big[2];
#ifdef FLOATING_POINT_SUPPORT
double floating;
#endif /* FLOATING_POINT_SUPPORT */
char_t *string;
char *bytes;
char_t *errmsg;
void *symbol;
} value;
vtype_t type;
unsigned int valid : 8;
unsigned int allocated : 8; /* String was balloced */
} value_t;
#ifndef __NO_PACK
#pragma pack()
#endif /* __NO_PACK */
/*
* Allocation flags
*/
#define VALUE_ALLOCATE 0x1
#define value_numeric(t) (t >= byteint && t <= big)
#define value_str(t) (t >= string && t <= bytes)
#define value_ok(t) (t > undefined && t <= symbol)
#define VALUE_VALID { {0}, integer, 1 }
#define VALUE_INVALID { {0}, undefined, 0 }
//ringq_t数据结构的解析相见ringq.c文件解析
/*****************************************************************************/
/*
* A ring queue allows maximum utilization of memory for data storage and is
* ideal for input/output buffering. This module provides a highly effecient
* implementation and a vehicle for dynamic strings.
*
* WARNING: This is a public implementation and callers have full access to
* the queue structure and pointers. Change this module very carefully.
*
* This module follows the open/close model.
*
* Operation of a ringq where rq is a pointer to a ringq :
*
* rq->buflen contains the size of the buffer.
* rq->buf will point to the start of the buffer.
* rq->servp will point to the first (un-consumed) data byte.
* rq->endp will point to the next free location to which new data is added
* rq->endbuf will point to one past the end of the buffer.
*
* Eg. If the ringq contains the data "abcdef", it might look like :
*
* +-------------------------------------------------------------------+
* | | | | | | | | a | b | c | d | e | f | | | | |
* +-------------------------------------------------------------------+
* ^ ^ ^ ^
* | | | |
* rq->buf rq->servp rq->endp rq->enduf
*
* The queue is empty when servp == endp. This means that the queue will hold
* at most rq->buflen -1 bytes. It is the fillers responsibility to ensure
* the ringq is never filled such that servp == endp.
*
* It is the fillers responsibility to "wrap" the endp back to point to
* rq->buf when the pointer steps past the end. Correspondingly it is the
* consumers responsibility to "wrap" the servp when it steps to rq->endbuf.
* The ringqPutc and ringqGetc routines will do this automatically.
*/
/*
* Ring queue buffer structure
*/
typedef struct {
unsigned char *buf; /* Holding buffer for data */
unsigned char *servp; /* Pointer to start of data */
unsigned char *endp; /* Pointer to end of data */
unsigned char *endbuf; /* Pointer to end of buffer */
int buflen; /* Length of ring queue */
int maxsize; /* Maximum size */
int increment; /* Growth increment */
} ringq_t;
/*
//与内存块分配相关的宏定义
* Block allocation (balloc) definitions
*/
#ifdef B_STATS
#ifndef B_L
#define B_L T(__FILE__), __LINE__
#define B_ARGS_DEC char_t *file, int line//在balloc.c文件中经常出现
#define B_ARGS file, line
#endif /* B_L */
#endif /* B_STATS */
/*
* Block classes are: 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192,
* 16384, 32768, 65536
//2的4-16次方，请求分配的内存块小于16的则按16算
*/
typedef struct {
union {
void *next; /* Pointer to next in q */
int size; /* Actual requested size */
} u;
int flags; /* Per block allocation flags */
} bType;
#define B_SHIFT 4 /* Convert size to class */
//在请求内存块时，是以2的4次方为界限的，小于2的四次方都按2的4次方算
#define B_ROUND ((1 << (B_SHIFT)) - 1)
//B_ROUD在这里为0b1000
#define B_MAX_CLASS 13 /* Maximum class number + 1 */
#define B_MALLOCED 0x80000000 /* Block was malloced */
#define B_DEFAULT_MEM (64 * 1024) /* Default memory allocation */
#define B_MAX_FILES (512) /* Maximum number of files */
#define B_FILL_CHAR (0x77) /* Fill byte for buffers */
#define B_FILL_WORD (0x77777777) /* Fill word for buffers */
#define B_MAX_BLOCKS (64 * 1024) /* Maximum allocated blocks */
/*
* Flags. The integrity value is used as an arbitrary value to fill the flags.
*/
#define B_INTEGRITY 0x8124000 /* Integrity value */
#define B_INTEGRITY_MASK 0xFFFF000 /* Integrity mask */
#define B_USE_MALLOC 0x1 /* Okay to use malloc if required */
#define B_USER_BUF 0x2 /* User supplied buffer for mem */
/*
* The symbol table record for each symbol entry
//每个符号项的符号表记录
*/
typedef struct sym_t {
struct sym_t *forw; /* Pointer to next hash list */
value_t name; /* Name of symbol */
value_t content; /* Value of symbol */
int arg; /* Parameter value */
} sym_t;
typedef int sym_fd_t; /* Returned by symOpen */
//symOpen函数的返回值是sym_fd_t类型，该类型实际就是int
/*
* Script engines
*/
#define EMF_SCRIPT_JSCRIPT 0 /* javascript */
#define EMF_SCRIPT_TCL 1 /* tcl */
#define EMF_SCRIPT_EJSCRIPT 2 /* Ejscript */
#define EMF_SCRIPT_MAX 3
#if !defined(HAVE_MAXINT)
#define MAXINT INT_MAX
#endif
#define BITSPERBYTE 8
//BITS(type)返回type所占的二进制位数
#define BITS(type) (BITSPERBYTE * (int) sizeof(type))
#define STRSPACE T("\t \n\r\t")
//比较数值大小的宏
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif /* max */
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif /* min */
/******************************************************************************/
/* CRON */
//CRON:定时服务任务
/******************************************************************************/
typedef struct {
char_t *minute;
char_t *hour;
char_t *day;
char_t *month;
char_t *dayofweek;
} cron_t;
extern long cronUntil(cron_t *cp, int period, time_t testTime);
extern int cronAlloc(cron_t *cp, char_t *str);
extern int cronFree(cron_t *cp);
/******************************************************************************/
/* SOCKET */
/******************************************************************************/
/*
* Socket flags //Socket标志定义
*/
#if ((defined (WIN) || defined (CE)) && defined (WEBS) && !defined(WIN32))
/////////////////////////////////////WinSock相关
#endif /* (WIN || CE) && WEBS) */
#define SOCKET_EOF 0x1 /* Seen end of file */
#define SOCKET_CONNECTING 0x2 /* Connect in progress */
#define SOCKET_BROADCAST 0x4 /* Broadcast mode */
#define SOCKET_PENDING 0x8 /* Message pending on this socket */
#define SOCKET_FLUSHING 0x10 /* Background flushing */
#define SOCKET_DATAGRAM 0x20 /* Use datagrams */
#define SOCKET_ASYNC 0x40 /* Use async connect */
#define SOCKET_BLOCK 0x80 /* Use blocking I/O */
#define SOCKET_LISTENING 0x100 /* Socket is server listener */
#define SOCKET_CLOSING 0x200 /* Socket is closing */
#define SOCKET_CONNRESET 0x400 /* Socket connection was reset */
#define SOCKET_MYOWNBUFFERS 0x800 /* Not using inBuf/outBuf ringq */
#define SOCKET_PORT_MAX 0xffff /*
/*
* Socket error values//Socket错误定义
*/
#define SOCKET_WOULDBLOCK 1 /* Socket would block on I/O */
#define SOCKET_RESET 2 /* Socket has been reset */
#define SOCKET_NETDOWN 3 /* Network is down */
#define SOCKET_AGAIN 4 /* Issue the request again */
#define SOCKET_INTR 5 /* Call was interrupted */
#define SOCKET_INVAL 6 /* Invalid */
/*
* Handler event masks
*/
#define SOCKET_READABLE 0x2 /* Make socket readable */
#define SOCKET_WRITABLE 0x4 /* Make socket writable */
#define SOCKET_EXCEPTION 0x8 /* Interested in exceptions */
#define EMF_SOCKET_MESSAGE (WM_USER+13)
#define WEBS_MAX_REQUEST 2048 /* Request safeguard max */
#ifdef LITTLEFOOT
#define SOCKET_BUFSIZ 510 /* Underlying buffer size */
#else
#define SOCKET_BUFSIZ 1024 /* Underlying buffer size */
#endif /* LITTLEFOOT */
typedef void (*socketHandler_t)(int sid, int mask, void* data);
//socketHandler_t 是一个指向函数的指针，这个被指向的函数接受三个参数，分别为//sid,mask,data,返回值为空
typedef int (*socketAccept_t)(int sid, char *ipaddr, int port,
int listenSid);
//同上，socketAccept_t也是一个函数指针
//socket_t结构定义
typedef struct {
char host[64]; /* Host name */
ringq_t inBuf; /* Input ring queue */
ringq_t outBuf; /* Output ring queue */
ringq_t lineBuf; /* Line ring queue */
socketAccept_t accept; /* Accept handler */
socketHandler_t handler; /* User I/O handler */
void *handler_data; /* User handler data */
int handlerMask; /* Handler events of interest */
int sid; /* Index into socket[] */
int port; /* Port to listen on */
int flags; /* Current state flags */
int sock; /* Actual socket handle */
int fileHandle; /* ID of the file handler */
int interestEvents; /* Mask of events to watch for */
int currentEvents; /* Mask of ready events (FD_xx) */
int selectEvents; /* Events being selected */
int saveMask; /* saved Mask for socketFlush */
int error; /* Last error */
} socket_t;
/********************************* Prototypes *********************************/
/*
//一些外部函数原型声明
* Balloc module
*
*/
extern void bclose();
extern int bopen(void *buf, int bufsize, int flags);
/*
* Define NO_BALLOC to turn off our balloc module altogether
* #define NO_BALLOC 1
//NO_BALLOC常量是malloc模块的开关，为1时关闭balloc模块，为0时启用balloc模块
*/
//如果定义了常量NO_BALLOC，则关闭balloc模块，所有balloc模块的操作都重定向为对//C库里的对内存操作的函数
#ifdef NO_BALLOC
#define balloc(B_ARGS, num) malloc(num)
#define bfree(B_ARGS, p) free(p)
#define bfreeSafe(B_ARGS, p) \
if (p) { free(p); } else
#define brealloc(B_ARGS, p, num) realloc(p, num)
extern char_t *bstrdupNoBalloc(char_t *s);
extern char *bstrdupANoBalloc(char *s);
#define bstrdup(B_ARGS, s) bstrdupNoBalloc(s)
#define bstrdupA(B_ARGS, s) bstrdupANoBalloc(s)
#define gstrdup(B_ARGS, s) bstrdupNoBalloc(s)
#else /* BALLOC */
#ifndef B_STATS
#define balloc(B_ARGS, num) balloc(num)
#define bfree(B_ARGS, p) bfree(p)
#define bfreeSafe(B_ARGS, p) bfreeSafe(p)
#define brealloc(B_ARGS, p, size) brealloc(p, size)
#define bstrdup(B_ARGS, p) bstrdup(p)
#ifdef UNICODE
#define bstrdupA(B_ARGS, p) bstrdupA(p)
#else /* UNICODE */
#define bstrdupA bstrdup
#endif /* UNICODE */
#endif /* B_STATS */
#define gstrdup bstrdup
extern void *balloc(B_ARGS_DEC, int size);
extern void bfree(B_ARGS_DEC, void *mp);
extern void bfreeSafe(B_ARGS_DEC, void *mp);
extern void *brealloc(B_ARGS_DEC, void *buf, int newsize);
extern char_t *bstrdup(B_ARGS_DEC, char_t *s);
#ifdef UNICODE
extern char *bstrdupA(B_ARGS_DEC, char *s);
#else /* UNICODE */
#define bstrdupA bstrdup
#endif /* UNICODE */
#endif /* BALLOC */
extern void bstats(int handle, void (*writefn)(int handle, char_t *fmt, ...));
//bstats是一个函数，该函数接受2个参数，返回void。其中第二个参数是一个函数指针。
/*
* Flags. The integrity value is used as an arbitrary value to fill the flags.
*/
#define B_USE_MALLOC 0x1 /* Okay to use malloc if required */
#define B_USER_BUF 0x2 /* User supplied buffer for mem */
#ifndef LINUX
XXXXXXXXXXXXXX
#endif /* !LINUX */
typedef void (emfSchedProc)(void *data, int id);
extern int emfSchedCallback(int delay, emfSchedProc *proc, void *arg);
extern void emfUnschedCallback(int id);
extern void emfReschedCallback(int id, int delay);
extern void emfSchedProcess();
extern int emfInstGet();
extern void emfInstSet(int inst);
extern void error(E_ARGS_DEC, int flags, char_t *fmt, ...);
extern void (*errorSetHandler(void (*function)(int etype, char_t *msg))) \
(int etype, char_t *msg);
#ifdef B_STATS
#define hAlloc(x) HALLOC(B_L, x)
#define hAllocEntry(x, y, z) HALLOCENTRY(B_L, x, y, z)
extern int HALLOC(B_ARGS_DEC, void ***map);
extern int HALLOCENTRY(B_ARGS_DEC, void ***list, int *max, int size);
#else
extern int hAlloc(void ***map);
extern int hAllocEntry(void ***list, int *max, int size);
#endif /* B_STATS */
extern int hFree(void ***map, int handle);
extern int ringqOpen(ringq_t *rq, int increment, int maxsize);
extern void ringqClose(ringq_t *rq);
extern int ringqLen(ringq_t *rq);
extern int ringqPutc(ringq_t *rq, char_t c);
extern int ringqInsertc(ringq_t *rq, char_t c);
extern int ringqPutStr(ringq_t *rq, char_t *str);
extern int ringqGetc(ringq_t *rq);
extern int fmtValloc(char_t **s, int n, char_t *fmt, va_list arg);
extern int fmtAlloc(char_t **s, int n, char_t *fmt, ...);
extern int fmtStatic(char_t *s, int n, char_t *fmt, ...);
#ifdef UNICODE
extern int ringqPutcA(ringq_t *rq, char c);
extern int ringqInsertcA(ringq_t *rq, char c);
extern int ringqPutStrA(ringq_t *rq, char *str);
extern int ringqGetcA(ringq_t *rq);
#else
#define ringqPutcA ringqPutc
#define ringqInsertcA ringqInsertc
#define ringqPutStrA ringqPutStr
#define ringqGetcA ringqGetc
#endif /* UNICODE */
extern int ringqPutBlk(ringq_t *rq, unsigned char *buf, int len);
extern int ringqPutBlkMax(ringq_t *rq);
extern void ringqPutBlkAdj(ringq_t *rq, int size);
extern int ringqGetBlk(ringq_t *rq, unsigned char *buf, int len);
extern int ringqGetBlkMax(ringq_t *rq);
extern void ringqGetBlkAdj(ringq_t *rq, int size);
extern void ringqFlush(ringq_t *rq);
extern void ringqAddNull(ringq_t *rq);
extern int scriptSetVar(int engine, char_t *var, char_t *value);
extern int scriptEval(int engine, char_t *cmd, char_t **rslt, void* chan);
extern void socketClose();
extern void socketCloseConnection(int sid);
extern void socketCreateHandler(int sid, int mask, socketHandler_t
handler, void* arg);
extern void socketDeleteHandler(int sid);
extern int socketEof(int sid);
extern int socketCanWrite(int sid);
extern void socketSetBufferSize(int sid, int in, int line, int out);
extern int socketFlush(int sid);
extern int socketGets(int sid, char_t **buf);
extern int socketGetPort(int sid);
extern int socketInputBuffered(int sid);
extern int socketOpen();
extern int socketOpenConnection(char *host, int port,
socketAccept_t accept, int flags);
extern void socketProcess(int hid);
extern int socketRead(int sid, char *buf, int len);
extern int socketReady(int hid);
extern int socketWrite(int sid, char *buf, int len);
extern int socketWriteString(int sid, char_t *buf);
extern int socketSelect(int hid, int timeout);
extern int socketGetHandle(int sid);
extern int socketSetBlock(int sid, int flags);
extern int socketGetBlock(int sid);
extern int socketAlloc(char *host, int port, socketAccept_t accept,
int flags);
extern void socketFree(int sid);
extern int socketGetError();
extern socket_t *socketPtr(int sid);
extern int socketWaitForEvent(socket_t *sp, int events, int *errCode);
extern void socketRegisterInterest(socket_t *sp, int handlerMask);
extern int socketGetInput(int sid, char *buf, int toRead, int *errCode);
extern char_t *strlower(char_t *string);
extern char_t *strupper(char_t *string);
extern char_t *stritoa(int n, char_t *string, int width);
extern sym_fd_t symOpen(int hash_size);
extern void symClose(sym_fd_t sd);
extern sym_t *symLookup(sym_fd_t sd, char_t *name);
extern sym_t *symEnter(sym_fd_t sd, char_t *name, value_t v, int arg);
extern int symDelete(sym_fd_t sd, char_t *name);
extern void symWalk(sym_fd_t sd, void (*fn)(sym_t *symp));
extern sym_t *symFirst(sym_fd_t sd);
extern sym_t *symNext(sym_fd_t sd);
extern int symSubOpen();
extern void symSubClose();
extern void trace(int lev, char_t *fmt, ...);
extern void traceRaw(char_t *buf);
extern void (*traceSetHandler(void (*function)(int level, char_t *buf)))
(int level, char_t *buf);
extern value_t valueInteger(long value);
extern value_t valueString(char_t *value, int flags);
extern value_t valueErrmsg(char_t *value);
extern void valueFree(value_t *v);
extern int vxchdir(char *dirname);
extern unsigned int hextoi(char_t *hexstring);
extern unsigned int gstrtoi(char_t *s);
extern time_t timeMsec();
extern char_t *ascToUni(char_t *ubuf, char *str, int nBytes);
extern char *uniToAsc(char *buf, char_t *ustr, int nBytes);
extern char_t *ballocAscToUni(char *cp, int alen);
extern char *ballocUniToAsc(char_t *unip, int ulen);
extern char_t *basicGetHost();
extern char_t *basicGetAddress();
extern char_t *basicGetProduct();
extern void basicSetHost(char_t *host);
extern void basicSetAddress(char_t *addr);
extern int harnessOpen(char_t **argv);
extern void harnessClose(int status);
extern void harnessTesting(char_t *msg, ...);
extern void harnessPassed();
extern void harnessFailed(int line);
extern int harnessLevel();
#endif /* _h_UEMF */
/******************************************************************************/
