sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-11-09 20:23:51 +03:00
Code Activity

r8400: separate out the mpr code, as it is in the upstream appweb sources

Browse Source
This commit is contained in:
Andrew Tridgell
2005-07-13 00:12:22 +00:00
committed by Gerald (Jerry) Carter
parent 52db7a052b
commit 0e30b6e4cc
7 changed files with 19 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
source/lib/appweb/ejs/ejs.h
View File

@@ -44,8 +44,8 @@
#ifndef _h_EJS
#define _h_EJS 1
#include "miniMpr.h"
#include "var.h"
#include "lib/appweb/mpr/miniMpr.h"
#include "lib/appweb/mpr/var.h"
#ifdef __cplusplus
extern "C" {

512
source/lib/appweb/ejs/miniMpr.c
View File

@@ -1,512 +0,0 @@
/*
* @file miniMpr.cpp
* @brief Mini Mbedthis Portable Runtime (MPR)
* @copy default
*
* Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
*
* This software is distributed under commercial and open source licenses.
* You may use the GPL open source license described below or you may acquire
* a commercial license from Mbedthis Software. You agree to be fully bound
* by the terms of either license. Consult the LICENSE.TXT distributed with
* this software for full details.
*
* This software is open source; 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. See the GNU General Public License for more
* details at: http://www.mbedthis.com/downloads/gplLicense.html
*
* This program is distributed WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* This GPL license does NOT permit incorporating this software into
* proprietary programs. If you are unable to comply with the GPL, you must
* acquire a commercial license to use this software. Commercial licenses
* for this software and support services are available from Mbedthis
* Software at http://www.mbedthis.com
*
* @end
*/
#include "lib/appweb/ejs/miniMpr.h"
/************************************ Code ************************************/
#if !BLD_APPWEB
#if !BLD_GOAHEAD_WEBSERVER
static void *mpr_ctx;
/* set the memory context to be used for all ejs variables */
void mprSetCtx(TALLOC_CTX *ctx)
{
mpr_ctx = ctx;
}
/* return the memory context being used for all ejs variables */
void *mprMemCtx(void)
{
return mpr_ctx;
}
void mprFree(void *ptr)
{
talloc_free(ptr);
}
void *mprMalloc(uint size)
{
return talloc_size(mpr_ctx, size);
}
/******************************************************************************/
void *mprRealloc(void *ptr, uint size)
{
return talloc_realloc_size(mpr_ctx, ptr, size);
}
/******************************************************************************/
char *mprStrdup(const char *str)
{
if (str == 0) {
str = "";
}
return talloc_strdup(mpr_ctx, str);
}
/*****************************************************************************/
int mprAllocSprintf(char **msgbuf, int maxSize, const char *fmt, ...)
{
va_list args;
char *buf;
int count;
va_start(args, fmt);
buf = mprMalloc(maxSize + 1);
count = mtVsprintf(buf, maxSize, fmt, args);
*msgbuf = buf;
va_end(args);
return count;
}
/*****************************************************************************/
int mprAllocVsprintf(char **msgbuf, int maxSize, const char *fmt, va_list args)
{
char *buf;
int count;
buf = mprMalloc(maxSize + 1);
count = mtVsprintf(buf, maxSize, fmt, args);
*msgbuf = buf;
return count;
}
/*****************************************************************************/
/*
* Format a number as a string. FUTURE -- reverse args to be standard.
* ie. mprItoa(char *userBuf, int bufsize, int value);
*/
char *mprItoa(int value, char *buf, int width)
{
char numBuf[16];
char *cp, *dp, *endp;
int negative;
cp = &numBuf[sizeof(numBuf)];
*--cp = '\0';
if (value < 0) {
negative = 1;
value = -value;
width--;
} else {
negative = 0;
}
do {
*--cp = '0' + (value % 10);
value /= 10;
} while (value > 0);
if (negative) {
*--cp = '-';
}
dp = buf;
endp = &buf[width];
while (dp < endp && *cp) {
*dp++ = *cp++;
}
*dp++ = '\0';
return buf;
}
/*****************************************************************************/
void mprLog(int level, const char *fmt, ...)
{
va_list args;
char *buf;
if (DEBUGLVL(level)) {
va_start(args, fmt);
mprAllocVsprintf(&buf, MPR_MAX_STRING, fmt, args);
va_end(args);
DEBUG(level, ("mprLog: %s", buf));
mprFree(buf);
}
}
/*****************************************************************************/
void mprBreakpoint(const char *file, int line, const char *cond)
{
char *buf;
mprAllocSprintf(&buf, MPR_MAX_STRING, "esp exception - ASSERT at %s:%d, %s\n",
file, line, cond);
ejs_exception(buf);
}
#endif /* !BLD_GOAHEAD_WEBSERVER */
/*****************************************************************************/
/*
* Create a general growable array structure
*/
MprArray *mprCreateArray()
{
MprArray *array;
int size;
array = (MprArray*) mprMalloc(sizeof(MprArray));
if (array == 0) {
return 0;
}
memset(array, 0, sizeof(MprArray));
size = MPR_ARRAY_INCR * sizeof(void*);
array->handles = (void**) mprMalloc(size);
if (array->handles == 0) {
mprFree(array);
return 0;
}
memset(array->handles, 0, size);
array->max = MPR_ARRAY_INCR;
array->used = 0;
return array;
}
/*****************************************************************************/
/*
* Dispose of the array. Callers responsibility to dispose of handle entries.
*/
void mprDestroyArray(MprArray *array)
{
mprAssert(array);
mprAssert(array->max >= 0);
mprAssert(array->used >= 0);
mprFree(array->handles);
mprFree(array);
}
/*****************************************************************************/
/*
* Add an item to the array
*/
int mprAddToArray(MprArray *array, void *item)
{
int memsize, idx, len;
mprAssert(array);
mprAssert(array->max >= 0);
mprAssert(array->used >= 0);
if (array->used < array->max) {
idx = array->used++;
mprAssert(idx >= 0 && idx < array->max);
mprAssert(array->handles[idx] == 0);
array->handles[idx] = item;
return idx;
}
for (idx = array->used; idx < array->max; idx++) {
if (array->handles[idx] == 0) {
array->used++;
mprAssert(array->handles[idx] == 0);
array->handles[idx] = item;
return idx;
}
}
len = array->max + MPR_ARRAY_INCR;
memsize = len * sizeof(void*);
array->handles = (void**) mprRealloc((void*) array->handles, memsize);
if (array->handles == NULL) {
return -1;
}
memset(&array->handles[array->max], 0, sizeof(void*) * MPR_ARRAY_INCR);
array->max = len;
array->used++;
mprAssert(idx >= 0 && idx < array->max);
mprAssert(array->handles[idx] == 0);
array->handles[idx] = item;
return idx;
}
/*****************************************************************************/
/*
* Remove from the array
*/
int mprRemoveFromArray(MprArray *array, int idx)
{
mprAssert(array);
mprAssert(array->max > 0);
mprAssert(idx >= 0 && idx < array->max);
mprAssert(array->handles[idx] != 0);
mprAssert(array->used > 0);
array->handles[idx] = 0;
return --array->used;
}
/*****************************************************************************/
/*
* Thread-safe wrapping of strtok. Note "str" is modifed as per strtok()
*/
char *mprStrTok(char *str, const char *delim, char **tok)
{
char *start, *end;
int i;
start = str ? str : *tok;
if (start == 0) {
return 0;
}
i = strspn(start, delim);
start += i;
if (*start == '\0') {
*tok = 0;
return 0;
}
end = strpbrk(start, delim);
if (end) {
*end++ = '\0';
i = strspn(end, delim);
end += i;
}
*tok = end;
return start;
}
/*****************************************************************************/
static int mprCoreStrcat(int alloc, char **destp, int destMax, int existingLen,
const char *delim, const char *src, va_list args)
{
va_list ap;
char *dest, *dp;
const char *str;
int sepLen, addBytes, required;
mprAssert(destp);
mprAssert(destMax > 0);
mprAssert(src);
dest = *destp;
sepLen = (delim) ? strlen(delim) : 0;
#ifdef __va_copy
__va_copy(ap, args);
#else
ap = args;
#endif
addBytes = 0;
str = src;
while (str) {
addBytes += strlen(str) + sepLen;
str = va_arg(ap, const char*);
}
if (existingLen > 0) {
addBytes += sepLen;
}
required = existingLen + addBytes + 1;
if (required >= destMax) {
mprAssert(0);
return MPR_ERR_WONT_FIT;
}
if (alloc) {
if (dest == 0) {
dest = (char*) mprMalloc(required);
} else {
dest = (char*) mprRealloc(dest, required);
}
} else {
dest = (char*) *destp;
}
dp = &dest[existingLen];
if (delim) {
strcpy(dp, delim);
dp += sepLen;
}
if (addBytes > 0) {
#ifdef __va_copy
__va_copy(ap, args);
#else
ap = args;
#endif
str = src;
while (str) {
strcpy(dp, str);
dp += strlen(str);
str = va_arg(ap, char*);
if (delim && str) {
strcpy(dp, delim);
dp += sepLen;
}
}
} else if (dest == 0) {
dest = (char*) mprMalloc(1);
}
*dp = '\0';
*destp = dest;
mprAssert(dp < &dest[required]);
return required - 1;
}
/*****************************************************************************/
int mprReallocStrcat(char **destp, int destMax, int existingLen,
const char *delim, const char *src,...)
{
va_list ap;
int rc;
va_start(ap, src);
rc = mprCoreStrcat(1, destp, destMax, existingLen, delim, src, ap);
va_end(ap);
return rc;
}
/*****************************************************************************/
/*
* Return the directory portion of a pathname into the users buffer.
*/
int mprGetDirName(char *buf, int bufsize, char *path)
{
char *cp;
int dlen;
mprAssert(path);
mprAssert(buf);
mprAssert(bufsize > 0);
cp = strrchr(path, '/');
if (cp == 0) {
#if WIN
cp = strrchr(path, '\\');
if (cp == 0)
#endif
{
buf[0] = '\0';
return 0;
}
}
if (cp == path && cp[1] == '\0') {
strcpy(buf, ".");
return 0;
}
dlen = cp - path;
if (dlen < bufsize) {
if (dlen == 0) {
dlen++;
}
mprMemcpy(buf, bufsize, path, dlen);
buf[dlen] = '\0';
return 0;
}
return MPR_ERR_WONT_FIT;
}
/*****************************************************************************/
int mprStrcpy(char *dest, int destMax, const char *src)
{
int len;
mprAssert(dest);
mprAssert(destMax > 0);
mprAssert(src);
len = strlen(src);
if (len >= destMax && len > 0) {
mprAssert(0);
return MPR_ERR_WONT_FIT;
}
if (len > 0) {
memcpy(dest, src, len);
dest[len] = '\0';
} else {
*dest = '\0';
len = 0;
}
return len;
}
/*****************************************************************************/
int mprMemcpy(char *dest, int destMax, const char *src, int nbytes)
{
mprAssert(dest);
mprAssert(destMax > nbytes);
mprAssert(src);
mprAssert(nbytes > 0);
if (nbytes > destMax) {
mprAssert(0);
return MPR_ERR_WONT_FIT;
}
if (nbytes > 0) {
memcpy(dest, src, nbytes);
return nbytes;
} else {
return 0;
}
}
/*****************************************************************************/
#else
void miniMprDummy() {}
#endif // !BLD_APPWEB && !BLD_GOAHEAD_WEBSERVER
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim:tw=78
* vim600: sw=4 ts=4 fdm=marker
* vim<600: sw=4 ts=4
*/

292
source/lib/appweb/ejs/miniMpr.h
View File

@@ -1,292 +0,0 @@
/*
* @file miniMpr.h
* @brief Mini Mbedthis Portable Runtime (MPR) Environment.
* @copy default
*
* Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
*
* This software is distributed under commercial and open source licenses.
* You may use the GPL open source license described below or you may acquire
* a commercial license from Mbedthis Software. You agree to be fully bound
* by the terms of either license. Consult the LICENSE.TXT distributed with
* this software for full details.
*
* This software is open source; 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. See the GNU General Public License for more
* details at: http://www.mbedthis.com/downloads/gplLicense.html
*
* This program is distributed WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* This GPL license does NOT permit incorporating this software into
* proprietary programs. If you are unable to comply with the GPL, you must
* acquire a commercial license to use this software. Commercial licenses
* for this software and support services are available from Mbedthis
* Software at http://www.mbedthis.com
*
* @end
*/
#ifndef _h_MINI_MPR
#define _h_MINI_MPR 1
/********************************** Includes **********************************/
/*
* Find out about our configuration
*/
#ifndef _INCLUDES_H
#include "includes.h"
#endif
/* allow this library to use strcpy() */
#undef strcpy
#include "config.h"
#if BLD_APPWEB
/*
* If building within AppWeb, use the full MPR
*/
#include "mpr.h"
#else
#include <ctype.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#if !WIN
#include <unistd.h>
#endif
#if CE
#include <io.h>
#include "CE/wincompat.h"
#endif
#if LYNX
#include <unistd.h>
#endif
#if QNX4
#include <dirent.h>
#endif
#include <math.h>
/********************************** Defines ***********************************/
#ifdef __cplusplus
extern "C" {
#endif
#if BLD_FEATURE_SQUEEZE
/*
* Reasonable length of a file path name to use in most cases where you know
* the expected file name and it is certain to be less than this limit.
*/
#define MPR_MAX_FNAME 128
#define MPR_MAX_STRING 512
#define MPR_DEFAULT_HASH_SIZE 23 /* Default size of hash table index */
#define MPR_MAX_HEAP_SIZE (32 * 1024)
#else
#define MPR_MAX_FNAME 256
#define MPR_MAX_STRING 4096
#define MPR_DEFAULT_HASH_SIZE 43 /* Default size of hash table index */
#define MPR_MAX_HEAP_SIZE (64 * 1024)
#endif
/*
* Useful for debugging
*/
#define MPR_L __FILE__, __LINE__
#if BLD_FEATURE_ASSERT
#define mprAssert(C) \
if (C) ; else mprBreakpoint(__FILE__, __LINE__, #C)
#else
#define mprAssert(C) if (1) ; else
#endif
/*
* Standard MPR return and error codes
*/
#define MPR_ERR_BASE (-200) /* Error code */
#define MPR_ERR_GENERAL (MPR_ERR_BASE - 1) /* Error code */
#define MPR_ERR_ABORTED (MPR_ERR_BASE - 2) /* Error code */
#define MPR_ERR_ALREADY_EXISTS (MPR_ERR_BASE - 3) /* Error code */
#define MPR_ERR_BAD_ARGS (MPR_ERR_BASE - 4) /* Error code */
#define MPR_ERR_BAD_FORMAT (MPR_ERR_BASE - 5) /* Error code */
#define MPR_ERR_BAD_HANDLE (MPR_ERR_BASE - 6) /* Error code */
#define MPR_ERR_BAD_STATE (MPR_ERR_BASE - 7) /* Error code */
#define MPR_ERR_BAD_SYNTAX (MPR_ERR_BASE - 8) /* Error code */
#define MPR_ERR_BAD_TYPE (MPR_ERR_BASE - 9) /* Error code */
#define MPR_ERR_BAD_VALUE (MPR_ERR_BASE - 10) /* Error code */
#define MPR_ERR_BUSY (MPR_ERR_BASE - 11) /* Error code */
#define MPR_ERR_CANT_ACCESS (MPR_ERR_BASE - 12) /* Error code */
#define MPR_ERR_CANT_COMPLETE (MPR_ERR_BASE - 13) /* Error code */
#define MPR_ERR_CANT_CREATE (MPR_ERR_BASE - 14) /* Error code */
#define MPR_ERR_CANT_INITIALIZE (MPR_ERR_BASE - 15) /* Error code */
#define MPR_ERR_CANT_OPEN (MPR_ERR_BASE - 16) /* Error code */
#define MPR_ERR_CANT_READ (MPR_ERR_BASE - 17) /* Error code */
#define MPR_ERR_CANT_WRITE (MPR_ERR_BASE - 18) /* Error code */
#define MPR_ERR_DELETED (MPR_ERR_BASE - 19) /* Error code */
#define MPR_ERR_NETWORK (MPR_ERR_BASE - 20) /* Error code */
#define MPR_ERR_NOT_FOUND (MPR_ERR_BASE - 21) /* Error code */
#define MPR_ERR_NOT_INITIALIZED (MPR_ERR_BASE - 22) /* Error code */
#define MPR_ERR_NOT_READY (MPR_ERR_BASE - 23) /* Error code */
#define MPR_ERR_READ_ONLY (MPR_ERR_BASE - 24) /* Error code */
#define MPR_ERR_TIMEOUT (MPR_ERR_BASE - 25) /* Error code */
#define MPR_ERR_TOO_MANY (MPR_ERR_BASE - 26) /* Error code */
#define MPR_ERR_WONT_FIT (MPR_ERR_BASE - 27) /* Error code */
#define MPR_ERR_WOULD_BLOCK (MPR_ERR_BASE - 28) /* Error code */
#define MPR_ERR_CANT_ALLOCATE (MPR_ERR_BASE - 29) /* Error code */
#define MPR_ERR_MAX (MPR_ERR_BASE - 30) /* Error code */
/*
* Standard error severity and trace levels. These are ored with the error
* severities below. The MPR_LOG_MASK is used to extract the trace level
* from a flags word. We expect most apps to run with level 2 trace.
*/
#define MPR_FATAL 0 /* Fatal error. Cant continue. */
#define MPR_ERROR 1 /* Hard error */
#define MPR_WARN 2 /* Soft warning */
#define MPR_CONFIG 2 /* Essential configuration settings */
#define MPR_INFO 3 /* Informational only */
#define MPR_DEBUG 4 /* Debug information */
#define MPR_VERBOSE 9 /* Highest level of trace */
#define MPR_LOG_MASK 0xf /* Level mask */
/*
* Error flags. Specify where the error should be sent to. Note that the
* product.xml setting "headless" will modify how errors are reported.
* Assert errors are trapped when in DEV mode. Otherwise ignored.
*/
#define MPR_TRAP 0x10 /* Assert error -- trap in debugger */
#define MPR_LOG 0x20 /* Log the error in the O/S event log */
#define MPR_USER 0x40 /* Display to the user */
#define MPR_ALERT 0x80 /* Send a management alert */
#define MPR_TRACE 0x100 /* Trace */
/*
* Error format flags
*/
#define MPR_RAW 0x200 /* Raw trace output */
/*
* Error line number information
*/
#define MPR_L __FILE__, __LINE__
typedef char* MprStr;
#ifndef __cplusplus
typedef unsigned char uchar;
typedef int bool;
#endif
/*
* Porters: put other operating system type defines here
*/
#if WIN
typedef unsigned int uint;
typedef __int64 int64;
typedef unsigned __int64 uint64;
#else
#define O_BINARY 0
#ifndef uint
#define uint unsigned
#endif
__extension__ typedef long long int int64;
__extension__ typedef unsigned long long int uint64;
#endif
/*
* Flexible array data type
*/
typedef struct {
int max; /* Size of the handles array */
int used; /* Count of used entries in handles */
void **handles;
} MprArray;
#if BLD_FEATURE_SQUEEZE
#define MPR_ARRAY_INCR 8
#else
#define MPR_ARRAY_INCR 16
#endif
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif
/********************************* Prototypes *********************************/
/*
* If running in the GoAhead WebServer, map some MPR routines to WebServer
* equivalents.
*/
#if BLD_GOAHEAD_WEBSERVER
#include "uemf.h"
#define mprMalloc(size) balloc(B_L, size)
#define mprFree(ptr) bfreeSafe(B_L, ptr)
#define mprRealloc(ptr, size) brealloc(B_L, ptr, size)
#define mprStrdup(ptr) bstrdup(B_L, ptr)
#define mprAllocSprintf fmtAlloc
#define mprAllocVsprintf fmtValloc
#define mprSprintf fmtStatic
#define mprItoa stritoa
#define mprLog trace
#define mprBreakpoint(file, line, cond) \
error(file, line, E_BLD_FEATURE_ASSERT, T("%s"), cond)
#else /* !BLD_GOAHEAD_WEBSERVER */
/* #define mprMalloc malloc */
#define mprSprintf snprintf
#define mtVsprintf vsnprintf
extern void *mprMalloc(uint size);
extern void *mprRealloc(void *ptr, uint size);
extern void mprFree(void *ptr);
extern char *mprStrdup(const char *str);
extern int mprAllocVsprintf(char **msgbuf, int maxSize, const char *fmt,
va_list args) PRINTF_ATTRIBUTE(3,0);
extern int mprAllocSprintf(char **msgbuf, int maxSize, const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
extern char *mprItoa(int num, char *buf, int width);
extern void mprLog(int level, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
extern void mprBreakpoint(const char *file, int line, const char *msg);
#endif /* BLD_GOAHEAD_WEBSERVER */
extern MprArray *mprCreateArray(void);
extern void mprDestroyArray(MprArray *array);
extern int mprAddToArray(MprArray *array, void *item);
extern int mprRemoveFromArray(MprArray *array, int idx);
extern char *mprStrTok(char *str, const char *delim, char **tok);
extern int mprGetDirName(char *buf, int bufsize, char *path);
extern int mprReallocStrcat(char **dest, int max, int existingLen,
const char *delim, const char *src, ...);
extern int mprStrcpy(char *dest, int destMax, const char *src);
extern int mprMemcpy(char *dest, int destMax, const char *src, int nbytes);
extern void mprSetCtx(void *ctx);
extern void *mprMemCtx(void);
#ifdef __cplusplus
}
#endif
#endif /* !BLD_APPWEB */
#endif /* _h_MINI_MPR */
/*****************************************************************************/
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim:tw=78
* vim600: sw=4 ts=4 fdm=marker
* vim<600: sw=4 ts=4
*/

2197
source/lib/appweb/ejs/var.c
View File

File diff suppressed because it is too large Load Diff

496
source/lib/appweb/ejs/var.h
View File

@@ -1,496 +0,0 @@
/*
* @file var.h
* @brief MPR Universal Variable Type
* @copy default.m
*
* Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
* Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
*
* This software is distributed under commercial and open source licenses.
* You may use the GPL open source license described below or you may acquire
* a commercial license from Mbedthis Software. You agree to be fully bound
* by the terms of either license. Consult the LICENSE.TXT distributed with
* this software for full details.
*
* This software is open source; 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. See the GNU General Public License for more
* details at: http://www.mbedthis.com/downloads/gplLicense.html
*
* This program is distributed WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* This GPL license does NOT permit incorporating this software into
* proprietary programs. If you are unable to comply with the GPL, you must
* acquire a commercial license to use this software. Commercial licenses
* for this software and support services are available from Mbedthis
* Software at http://www.mbedthis.com
*
* @end
*/
/******************************* Documentation ********************************/
/*
* Variables can efficiently store primitive types and can hold references to
* objects. Objects can store properties which are themselves variables.
* Properties can be primitive data types, other objects or functions.
* Properties are indexed by a character name. A variable may store one of
* the following types:
*
* string, integer, integer-64bit, C function, C function with string args,
* Javascript function, Floating point number, boolean value, Undefined
* value and the Null value.
*
* Variables have names while objects may be referenced by multiple variables.
* Objects use reference counting for garbage collection.
*
* This module is not thread safe for performance and compactness. It relies
* on upper modules to provide thread synchronization as required. The API
* provides primitives to get variable/object references or to get copies of
* variables which will help minimize required lock times.
*/
#ifndef _h_MPR_VAR
#define _h_MPR_VAR 1
/********************************* Includes ***********************************/
#include "miniMpr.h"
/********************************** Defines ***********************************/
/*
* Define VAR_DEBUG if you want to track objects. However, this code is not
* thread safe and you need to run the server single threaded.
*
* #define VAR_DEBUG 1
*/
#ifdef __cplusplus
extern "C" {
#endif
/*
* Forward declare types
*/
struct MprProperties;
struct MprVar;
/*
* Possible variable types. Don't use enum because we need to be able to
* do compile time conditional compilation on BLD_FEATURE_NUM_TYPE_ID.
*/
typedef int MprType;
#define MPR_TYPE_UNDEFINED 0 /* Undefined. No value has been set. */
#define MPR_TYPE_NULL 1 /* Value defined to be null. */
#define MPR_TYPE_BOOL 2 /* Boolean type. */
#define MPR_TYPE_CFUNCTION 3 /* C function or C++ method */
#define MPR_TYPE_FLOAT 4 /* Floating point number */
#define MPR_TYPE_INT 5 /* Integer number */
#define MPR_TYPE_INT64 6 /* 64-bit Integer number */
#define MPR_TYPE_OBJECT 7 /* Object reference */
#define MPR_TYPE_FUNCTION 8 /* JavaScript function */
#define MPR_TYPE_STRING 9 /* String (immutable) */
#define MPR_TYPE_STRING_CFUNCTION 10 /* C/C++ function with string args */
#define MPR_TYPE_PTR 11 /* Opaque pointer */
/*
* Create a type for the default number type
* Config.h will define the default number type. For example:
*
* BLD_FEATURE_NUM_TYPE=int
* BLD_FEATURE_NUM_TYPE_ID=MPR_TYPE_INT
*/
/**
* Set to the type used for MPR numeric variables. Will equate to int, int64
* or double.
*/
typedef BLD_FEATURE_NUM_TYPE MprNum;
/**
* Set to the MPR_TYPE used for MPR numeric variables. Will equate to
* MPR_TYPE_INT, MPR_TYPE_INT64 or MPR_TYPE_FLOAT.
*/
#define MPR_NUM_VAR BLD_FEATURE_NUM_TYPE_ID
#define MPR_TYPE_NUM BLD_FEATURE_NUM_TYPE_ID
/*
* Return TRUE if a variable is a function type
*/
#define mprVarIsFunction(type) \
(type == MPR_TYPE_FUNCTION || type == MPR_TYPE_STRING_CFUNCTION || \
type == MPR_TYPE_CFUNCTION)
/*
* Return TRUE if a variable is a numeric type
*/
#define mprVarIsNumber(type) \
(type == MPR_TYPE_INT || type == MPR_TYPE_INT64 || type == MPR_TYPE_FLOAT)
/*
* Return TRUE if a variable is a boolean
*/
#define mprVarIsBoolean(type) \
(type == MPR_TYPE_BOOL)
#define mprVarIsString(type) \
(type == MPR_TYPE_STRING)
#define mprVarIsObject(type) \
(type == MPR_TYPE_OBJECT)
#define mprVarIsFloating(type) \
(type == MPR_TYPE_FLOAT)
#define mprVarIsPtr(type) \
(type == MPR_TYPE_PTR)
#define mprVarIsUndefined(var) \
((var)->type == MPR_TYPE_UNDEFINED)
#define mprVarIsNull(var) \
((var)->type == MPR_TYPE_NULL)
#define mprVarIsValid(var) \
(((var)->type != MPR_TYPE_NULL) && ((var)->type != MPR_TYPE_UNDEFINED))
#define MPR_VAR_MAX_RECURSE 5 /* Max object loops */
#if BLD_FEATURE_SQUEEZE
#define MPR_MAX_VAR 64 /* Max var full name */
#else
#define MPR_MAX_VAR 512
#endif
#ifndef __NO_PACK
#pragma pack(2)
#endif /* _NO_PACK */
/*
* Function signatures
*/
typedef int MprVarHandle;
typedef int (*MprCFunction)(MprVarHandle userHandle, int argc,
struct MprVar **argv);
typedef int (*MprStringCFunction)(MprVarHandle userHandle, int argc,
char **argv);
/*
* Triggers
*/
typedef enum {
MPR_VAR_WRITE, /* This property is being updated */
MPR_VAR_READ, /* This property is being read */
MPR_VAR_CREATE_PROPERTY, /* A property is being created */
MPR_VAR_DELETE_PROPERTY, /* A property is being deleted */
MPR_VAR_DELETE /* This object is being deleted */
} MprVarTriggerOp;
/*
* Trigger function return codes.
*/
typedef enum {
MPR_TRIGGER_ABORT, /* Abort the current operation */
MPR_TRIGGER_USE_NEW_VALUE, /* Proceed and use the newValue */
MPR_TRIGGER_PROCEED /* Proceed with the operation */
} MprVarTriggerStatus;
/*
* The MprVarTrigger arguments have the following meaning:
*
* op The operation being performed. See MprVarTriggerOp.
* parentProperties Pointer to the MprProperties structure.
* vp Pointer to the property that registered the trigger.
* newValue New value (see below for more details).
* copyDepth Specify what data items to copy.
*
* For VAR_READ, newVar is set to a temporary variable that the trigger
* function may assign a value to be returned instead of the actual
* property value.
* For VAR_WRITE, newValue holds the new value. The old existing value may be
* accessed via vp.
* For DELETE_PROPERTY, vp is the property being deleted. newValue is null.
* For ADD_PROPERTY, vp is set to the property being added and newValue holds
* the new value.
*/
typedef MprVarTriggerStatus (*MprVarTrigger)(MprVarTriggerOp op,
struct MprProperties *parentProperties, struct MprVar *vp,
struct MprVar *newValue, int copyDepth);
/*
* mprCreateFunctionVar flags
*/
/** Use the alternate handle on function callbacks */
#define MPR_VAR_ALT_HANDLE 0x1
/** Use the script handle on function callbacks */
#define MPR_VAR_SCRIPT_HANDLE 0x2
/*
* Useful define for the copyDepth argument
*/
/** Don't copy any data. Copy only the variable name */
#define MPR_NO_COPY 0
/** Copy strings. Increment object reference counts. */
#define MPR_SHALLOW_COPY 1
/** Copy strings and do complete object copies. */
#define MPR_DEEP_COPY 2
/*
* GetFirst / GetNext flags
*/
/** Step into data properties. */
#define MPR_ENUM_DATA 0x1
/** Step into functions properties. */
#define MPR_ENUM_FUNCTIONS 0x2
/*
* Collection type to hold properties in an object
*/
typedef struct MprProperties { /* Collection of properties */
#if VAR_DEBUG
struct MprProperties *next; /* Linked list */
struct MprProperties *prev; /* Linked list */
char name[32]; /* Debug name */
#endif
struct MprVar **buckets; /* Hash chains */
int numItems; /* Total count of items */
/* FUTURE - Better way of doing this */
int numDataItems; /* Enumerable data items */
uint hashSize : 8; /* Size of the hash table */
/* FUTURE -- increase size of refCount */
uint refCount : 8; /* References to this property*/
/* FUTURE - make these flags */
uint deleteProtect : 8; /* Don't recursively delete */
uint visited : 8; /* Node has been processed */
} MprProperties;
/*
* Universal Variable Type
*/
typedef struct MprVar {
/* FUTURE - remove name to outside reference */
MprStr name; /* Property name */
/* FUTURE - remove */
MprStr fullName; /* Full object name */
/* FUTURE - make part of the union */
MprProperties *properties; /* Pointer to properties */
/*
* Packed bit field
*/
MprType type : 8; /* Selector into union */
uint bucketIndex : 8; /* Copy of bucket index */
uint flags : 5; /* Type specific flags */
uint allocatedData : 1; /* Data needs freeing */
uint readonly : 1; /* Unmodifiable */
uint deleteProtect : 1; /* Don't recursively delete */
uint visited : 1; /* Node has been processed */
uint allocatedVar : 1; /* Var needs freeing */
uint spare : 6; /* Unused */
struct MprVar *forw; /* Hash table linkage */
MprVarTrigger trigger; /* Trigger function */
#if UNUSED && KEEP
struct MprVar *baseClass; /* Pointer to class object */
#endif
MprProperties *parentProperties; /* Pointer to parent object */
/*
* Union of primitive types. When debugging on Linux, don't use unions
* as the gdb debugger can't display them.
*/
#if !BLD_DEBUG && !LINUX && !VXWORKS
union {
#endif
int boolean; /* Use int for speed */
#if BLD_FEATURE_FLOATING_POINT
double floating;
#endif
int integer;
#if BLD_FEATURE_INT64
int64 integer64;
#endif
struct { /* Javascript functions */
MprArray *args; /* Null terminated */
char *body;
} function;
struct { /* Function with MprVar args */
MprCFunction fn;
void *thisPtr;
} cFunction;
struct { /* Function with string args */
MprStringCFunction fn;
void *thisPtr;
} cFunctionWithStrings;
MprStr string; /* Allocated string */
void *ptr; /* Opaque pointer */
#if !BLD_DEBUG && !LINUX && !VXWORKS
};
#endif
} MprVar;
/*
* Define a field macro so code an use numbers in a "generic" fashion.
*/
#if MPR_NUM_VAR == MPR_TYPE_INT || DOXYGEN
/* Default numeric type */
#define mprNumber integer
#endif
#if MPR_NUM_VAR == MPR_TYPE_INT64
/* Default numeric type */
#define mprNumber integer64
#endif
#if MPR_NUM_VAR == MPR_TYPE_FLOAT
/* Default numeric type */
#define mprNumber floating
#endif
typedef BLD_FEATURE_NUM_TYPE MprNumber;
#ifndef __NO_PACK
#pragma pack()
#endif /* __NO_PACK */
/********************************* Prototypes *********************************/
/*
* Variable constructors and destructors
*/
extern MprVar mprCreateObjVar(const char *name, int hashSize);
extern MprVar mprCreateBoolVar(bool value);
extern MprVar mprCreateCFunctionVar(MprCFunction fn, void *thisPtr,
int flags);
#if BLD_FEATURE_FLOATING_POINT
extern MprVar mprCreateFloatVar(double value);
#endif
extern MprVar mprCreateIntegerVar(int value);
#if BLD_FEATURE_INT64
extern MprVar mprCreateInteger64Var(int64 value);
#endif
extern MprVar mprCreateFunctionVar(char *args, char *body, int flags);
extern MprVar mprCreateNullVar(void);
extern MprVar mprCreateNumberVar(MprNumber value);
extern MprVar mprCreateStringCFunctionVar(MprStringCFunction fn,
void *thisPtr, int flags);
extern MprVar mprCreateStringVar(const char *value, bool allocate);
extern MprVar mprCreateUndefinedVar(void);
extern MprVar mprCreatePtrVar(void *ptr);
extern bool mprDestroyVar(MprVar *vp);
extern bool mprDestroyAllVars(MprVar* vp);
extern MprType mprGetVarType(MprVar *vp);
/*
* Copy
*/
extern void mprCopyVar(MprVar *dest, MprVar *src, int copyDepth);
extern void mprCopyVarValue(MprVar *dest, MprVar src, int copyDepth);
extern MprVar *mprDupVar(MprVar *src, int copyDepth);
/*
* Manage vars
*/
extern MprVarTrigger
mprAddVarTrigger(MprVar *vp, MprVarTrigger fn);
extern int mprGetVarRefCount(MprVar *vp);
extern void mprSetVarDeleteProtect(MprVar *vp, int deleteProtect);
extern void mprSetVarFullName(MprVar *vp, char *name);
extern void mprSetVarReadonly(MprVar *vp, int readonly);
extern void mprSetVarName(MprVar *vp, char *name);
/*
* Create properties and return a reference to the property.
*/
extern MprVar *mprCreateProperty(MprVar *obj, const char *property,
MprVar *newValue);
extern MprVar *mprCreatePropertyValue(MprVar *obj, const char *property,
MprVar newValue);
extern int mprDeleteProperty(MprVar *obj, const char *property);
/*
* Get/Set properties. Set will update/create.
*/
extern MprVar *mprGetProperty(MprVar *obj, const char *property,
MprVar *value);
extern MprVar *mprSetProperty(MprVar *obj, const char *property,
MprVar *value);
extern MprVar *mprSetPropertyValue(MprVar *obj, const char *property,
MprVar value);
/*
* Directly read/write property values (the property must already exist)
* For mprCopyProperty, mprDestroyVar must always called on the var.
*/
extern int mprReadProperty(MprVar *prop, MprVar *value);
extern int mprWriteProperty(MprVar *prop, MprVar *newValue);
extern int mprWritePropertyValue(MprVar *prop, MprVar newValue);
/*
* Copy a property. NOTE: reverse of most other args: (dest, src)
*/
extern int mprCopyProperty(MprVar *dest, MprVar *prop, int copyDepth);
/*
* Enumerate properties
*/
extern MprVar *mprGetFirstProperty(MprVar *obj, int includeFlags);
extern MprVar *mprGetNextProperty(MprVar *obj, MprVar *currentProperty,
int includeFlags);
/*
* Query properties characteristics
*/
extern int mprGetPropertyCount(MprVar *obj, int includeFlags);
/*
* Conversion routines
*/
extern MprVar mprParseVar(char *str, MprType prefType);
extern MprNum mprVarToNumber(const MprVar *vp);
extern int mprVarToInteger(const MprVar *vp);
#if BLD_FEATURE_INT64
extern int64 mprVarToInteger64(const MprVar *vp);
#endif
extern bool mprVarToBool(const MprVar *vp);
#if BLD_FEATURE_FLOATING_POINT
extern double mprVarToFloat(const MprVar *vp);
#endif
extern void mprVarToString(char** buf, int size, char *fmt, MprVar *vp);
/*
* Parsing and utility routines
*/
extern MprNum mprParseNumber(char *str);
extern int mprParseInteger(char *str);
#if BLD_FEATURE_INT64
extern int64 mprParseInteger64(char *str);
#endif
#if BLD_FEATURE_FLOATING_POINT
extern double mprParseFloat(char *str);
extern bool mprIsInfinite(double f);
extern bool mprIsNan(double f);
#endif
#if VAR_DEBUG
extern void mprPrintObjects(char *msg);
extern void mprPrintObjRefCount(MprVar *vp);
#endif
#ifdef __cplusplus
}
#endif
/*****************************************************************************/
#endif /* _h_MPR_VAR */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim:tw=78
* vim600: sw=4 ts=4 fdm=marker
* vim<600: sw=4 ts=4
*/