diff options
80 files changed, 33339 insertions, 0 deletions
diff --git a/source4/lib/appweb/ejs-2.0/.bashrc b/source4/lib/appweb/ejs-2.0/.bashrc new file mode 100644 index 0000000000..c05ee0e6e8 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/.bashrc @@ -0,0 +1,153 @@ +# +# .bashrc -- Login shell startup script for windows using Mbedthis winTools +# +# Copyright (c) Mbedthis Software, 2003-2005. All Rights Reserved. +# + +TERM=ansi +# +# Set the desired .NET Framework +# +# FRAMEWORK=v1.0.3705 +FRAMEWORK=v1.1.4322 +# FRAMEWORK=v2.0.40607 + +# +# Set the desired Microsoft C Compiler version +# +# PREFERRED_CC=VS2005 +# PREFERRED_CC=VS2003 +# PREFERRED_CC=VS.NET +PREFERRED_CC=VS6 + +# +# Set to 1 if VXWORKS support is required +# +# VXWORKS=1 + +HOME=`pwd` +if [ ! -x winTools -o ! -x winTools/cygpath.exe ] +then + echo "Can't find build tools. Install build tools in $HOME/winTools" +fi + +ROOT=`winTools/cygpath -u $HOMEDRIVE` +: ${ROOT:=C:/} +APPWEB_PATH="${HOME}/bin/DEBUG:${HOME}/bin/RELEASE:${HOME}/bin:${HOME}/winTools" +CDPATH=".:${HOME}:${HOME}/http:${HOME}/http/modules:${HOME}/packages" +PS1="$ " + +export CDPATH INCLUDE LIB LIBPATH PATH PS1 TERM + +echo -e "\n\n###################################################" +echo "Mbedthis AppWeb, Cygwin build tools." +echo "Using compiler: $PREFERRED_CC, .NET framework: $FRAMEWORK" +echo -e "###################################################" + +################################################################################ + +# +# Setup for Visual Studio and SDK +# +if [ $PREFERRED_CC == "VS2005" ] +then + # + # Visual Studio .NET 2005 defines. + # + CYNET="${ROOT}/Program Files/Microsoft Visual Studio 8" + DOSNET="C:/Program Files/Microsoft Visual Studio 8" + PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC/BIN:$CYNET/VC/VCPackages:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin:$CYNET/SDK/v2.0/bin:`cygpath -W`/Microsoft.NET/Framework/v2.0.40607:$CYNET/SDK/v2.0/bin:$PATH" + INCLUDE="$DOSNET/VC/ATLMFC/INCLUDE;$DOSNET/VC/INCLUDE;$DOSNET/VC/PlatformSDK/include;$DOSNET/SDK/v2.0/include;$INCLUDE" + LIB="$DOSNET/VC/ATLMFC/LIB;$DOSNET/VC/LIB;$DOSNET/VC/PlatformSDK/lib;$DOSNET/SDK/v2.0/lib;$LIB" + LIBPATH=c:/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK +fi + +if [ $PREFERRED_CC == "VS2003" ] +then + # + # Visual Studio .NET 2003 defines. + # + CYNET="${ROOT}/Program Files/Microsoft Visual Studio .NET 2003" + DOSNET="C:/Program Files/Microsoft Visual Studio .NET 2003" + PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC7/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:${ROOT}/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$CYNET/SDK/v1.1/bin:$PATH" + INCLUDE="$DOSNET/VC7/ATLMFC/INCLUDE;$DOSNET/VC7/INCLUDE;$DOSNET/VC7/PlatformSDK/include/prerelease;$DOSNET/VC7/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE" + LIB="$DOSNET/VC7/ATLMFC/LIB;$DOSNET/VC7/LIB;$DOSNET/VC7/PlatformSDK/lib/prerelease;$DOSNET/VC7/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB" +fi + + +if [ $PREFERRED_CC == "VS.NET" ] +then + # + # Visual Studio .NET defines. + # + CYNET="${ROOT}/Program Files/Microsoft Visual Studio .NET" + DOSNET="C:/Program Files/Microsoft Visual Studio .NET" + PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC7/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:${ROOT}/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$CYNET/SDK/v1.0/bin:$PATH" + INCLUDE="$DOSNET/VC7/ATLMFC/INCLUDE;$DOSNET/VC7/INCLUDE;$DOSNET/VC7/PlatformSDK/include/prerelease;$DOSNET/VC7/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE" + LIB="$DOSNET/VC7/ATLMFC/LIB;$DOSNET/VC7/LIB;$DOSNET/VC7/PlatformSDK/lib/prerelease;$DOSNET/VC7/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB" +fi + + +if [ $PREFERRED_CC == "VS6" ] +then + # Visual Studio 6 defines. + # + CYNET="${ROOT}/Program Files/Microsoft Visual Studio" + DOSNET="C:/Program Files/Microsoft Visual Studio" + PATH="$APPWEB_PATH:$CYNET/Common/MSDev98/bin:$CYNET/VC98/BIN:$CYNET/Common/IDE:$CYNET/Common/Tools/WinNT:$CYNET/Common/Tools:$PATH" + INCLUDE="$DOSNET/VC98/ATLMFC/INCLUDE;$DOSNET/VC98/INCLUDE;$DOSNET/VC98/MFC/INCLUDE;$INCLUDE" + LIB="$DOSNET/VC98/LIB;$DOSNET/VC98/MFC/LIB;$LIB" +fi + +if [ $VXWORKS ] +then + # + # Required by VxWorks + # + WIND_BASE=C:/tornado + WIND_HOST_TYPE=x86-win32 + WIND_REGISTRY=coalsack + WIND_LMHOST=coalsack + BLD_VX_HOST=i386-wrs-vxworks + VX_TOOLS=`cygpath $WIND_BASE`/host/$WIND_HOST_TYPE + export WIND_BASE WIND_HOST_TYPE WIND_REGISTRY WIND_LMHOST BLD_VX_HOST + + # + # Use cygwin make and tools by preference + # + PATH="$APPWEB_PATH:$VX_TOOLS/bin:$PATH" +fi + +# +# Make required directories for CYGWIN +# +if [ ! -x /bin/bash.exe ] +then + DIR=`cygpath -w "$HOME/winTools"` + echo -e "\nCreating /bin" + echo Mounting \"${DIR}\" as /bin + mount -f -b "$DIR" /bin +fi + +if [ ! -x /tmp ] +then + mkdir -p tmp + DIR=`cygpath -w "$HOME/tmp"` + echo -e "\nCreating /tmp" + echo Mounting \"${DIR}\" as /tmp + mount -f -b "$DIR" /tmp +fi +echo + +################################################################################ +# +# Do a bit of validation +# +type cl 2>/dev/null >/dev/null +if [ $? -ne 0 ] +then + echo "Can't find compiler: cl. Check WIN/bashrc settings for PATH" +fi +set -o vi + +################################################################################ diff --git a/source4/lib/appweb/ejs-2.0/.exrc b/source4/lib/appweb/ejs-2.0/.exrc new file mode 100644 index 0000000000..dd37846529 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/.exrc @@ -0,0 +1 @@ +set ts=4 sw=4 diff --git a/source4/lib/appweb/ejs-2.0/.ignore b/source4/lib/appweb/ejs-2.0/.ignore new file mode 100644 index 0000000000..866f06c6c1 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/.ignore @@ -0,0 +1,57 @@ +*.class +*.dll +*.exe +*.exp +*.jar +*.lib +*.lnk +*.map +*.new +*.old +*.pdb +*.res +*.sln +*.suo +*.sym +*.tmp +*.sav +.ICEauthority +.bash_history +.changes +.cvsignore +.esd_auth +.fonts.cache-1 +.viminfo +make.dep +thumbs.db +vc70.pdb +*.ncb +*.opt +*.idb +*.pch +*.dep +*.aps +all +tmp +make.vars +sh.vars +config.make +config.h +config.sh +configure +make.os +.firstBuild +.viminfo +.ssh +_viminfo +buildConfig.h +buildConfig.make +buildConfig.sh +.ccache +appWeb.kdev* +subversion +.vimrc +.subversion +.ignore +njs +msvc diff --git a/source4/lib/appweb/ejs-2.0/.loginrc b/source4/lib/appweb/ejs-2.0/.loginrc new file mode 100644 index 0000000000..90b76a2ad0 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/.loginrc @@ -0,0 +1,218 @@ +# +# .loginrc -- Michael's login shell startup script (used only for Windows) +# +# NOTE: this should not be distributed with releases. +# +# Copyright (c) Mbedthis Software, 2003-2005. All Rights Reserved. +# +HOME=`pwd` + +TERM=ansi +CYROOT=/cygdrive/c +JDK="/cygdrive/c/program files/java/jdk1.5.0_07/bin" +H=$CYROOT +R=usr/svn/appWeb/main +CDPATH=".:${H}/usr/svn/appWeb:${H}/${R}/http:${H}/${R}/http/modules:${H}/${R}:${H}/usr/svn/appWeb/releases:${H}/usr/svn/packages:${H}/usr/svn/bling/player/trunk:${H}/usr/svn/bling/player/trunk/src:${H}/usr/svn/bling/player/trunk/appdir:${H}/usr/svn:${H}:${H}/usr/svn:${H}/usr" +APPWEB_PATH="${H}/${R}/bin/DEBUG:${H}/${R}/bin/RELEASE:${H}/${R}/bin:${H}/usr/bin" +PATH="${H}/usr/bin:/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:$PATH:${H}/tcl/bin:${JDK}" + +CLASSPATH="c:/usr/svn/j/ggperf" +PS1='`cygpath -m $PWD`> ' +SVN_EDITOR=C:/cygwin/bin/vim.exe + +umask 022 + +export TERM CDPATH INCLUDE LIB LIBPATH PATH PS1 SVN_EDITOR MSCL CLASSPATH + +################################################################################ +# +# Set the dev environment PATH and other critical environment variables +# + +# export BLD_ALTERNATE_CONFIG=WIN/buildConfig + +# +# Desired .NET Framework +# +# FRAMEWORK=v1.0.3705 +# FRAMEWORK=v1.1.4322 +FRAMEWORK=v2.0.50727 + +# +# Desired C Compiler +# +# MSCL=VS2005 +# MSCL=VS2003 +# MSCL=VS.NET +MSCL=VS6 +VXWORKS=1 + +echo "Using compiler: $MSCL, .NET framework: $FRAMEWORK" + +# +# Setup for Visual Studio and SDK +# +if [ $MSCL == "VS2005" ] +then + # + # Visual Studio .NET 2005 defines. + # + CYNET="$H/Program Files/Microsoft Visual Studio 8" + DOSNET="C:/Program Files/Microsoft Visual Studio 8" + PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC/BIN:$CYNET/VC/VCPackages:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin:$CYNET/SDK/v2.0/bin:$CYROOT/WINDOWS/Microsoft.NET/Framework/v2.0.40607:$CYNET/SDK/v2.0/bin:$PATH" + INCLUDE="$DOSNET/VC/ATLMFC/INCLUDE;$DOSNET/VC/INCLUDE;$DOSNET/VC/PlatformSDK/include;$DOSNET/SDK/v2.0/include;$INCLUDE" + LIB="$DOSNET/VC/ATLMFC/LIB;$DOSNET/VC/LIB;$DOSNET/VC/PlatformSDK/lib;$DOSNET/SDK/v2.0/lib;$LIB" + LIBPATH=c:/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK + + # MOB -- old + # PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:$H/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$PATH" + # INCLUDE="$DOSNET/VC/ATLMFC/INCLUDE;$DOSNET/VC/INCLUDE;$DOSNET/VC/PlatformSDK/include/prerelease;$DOSNET/VC/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE" + # LIB="$DOSNET/VC/ATLMFC/LIB;$DOSNET/VC/LIB;$DOSNET/VC/PlatformSDK/lib/prerelease;$DOSNET/VC/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB" +fi + +if [ $MSCL == "VS2003" ] +then + # + # Visual Studio .NET 2003 defines. + # + CYNET="$H/Program Files/Microsoft Visual Studio .NET 2003" + DOSNET="C:/Program Files/Microsoft Visual Studio .NET 2003" + PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC7/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:$H/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$CYNET/SDK/v1.1/bin:$PATH" + INCLUDE="$DOSNET/VC7/ATLMFC/INCLUDE;$DOSNET/VC7/INCLUDE;$DOSNET/VC7/PlatformSDK/include/prerelease;$DOSNET/VC7/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE" + LIB="$DOSNET/VC7/ATLMFC/LIB;$DOSNET/VC7/LIB;$DOSNET/VC7/PlatformSDK/lib/prerelease;$DOSNET/VC7/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB" +fi + + +if [ $MSCL == "VS.NET" ] +then + # + # Visual Studio .NET defines. + # + CYNET="$H/Program Files/Microsoft Visual Studio .NET" + DOSNET="C:/Program Files/Microsoft Visual Studio .NET" + PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC7/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:$H/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$CYNET/SDK/v1.0/bin:$PATH" + INCLUDE="$DOSNET/VC7/ATLMFC/INCLUDE;$DOSNET/VC7/INCLUDE;$DOSNET/VC7/PlatformSDK/include/prerelease;$DOSNET/VC7/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE" + LIB="$DOSNET/VC7/ATLMFC/LIB;$DOSNET/VC7/LIB;$DOSNET/VC7/PlatformSDK/lib/prerelease;$DOSNET/VC7/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB" +fi + + +if [ $MSCL == "VS6" ] +then + # Visual Studio 6 defines. + # + CYNET="$H/Program Files/Microsoft Visual Studio" + DOSNET="C:/Program Files/Microsoft Visual Studio" + PATH="$APPWEB_PATH:$CYNET/Common/MSDev98/bin:$CYNET/VC98/BIN:$CYNET/Common/IDE:$CYNET/Common/Tools/WinNT:$CYNET/Common/Tools:$PATH" + # OLD PATH="$APPWEB_PATH:$CYNET/Common/IDE:$CYNET/VC98/BIN:$CYNET/Common/MSDev98/bin:$CYNET/Common/Tools:$CYNET/Common/Tools/bin/prerelease:$CYNET/Common/Tools/bin:$CYNET/FrameworkSDK/bin:$H/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$PATH" + INCLUDE="$DOSNET/VC98/ATLMFC/INCLUDE;$DOSNET/VC98/INCLUDE;$DOSNET/VC98/MFC/INCLUDE;$INCLUDE" + LIB="$DOSNET/VC98/LIB;$DOSNET/VC98/MFC/LIB;$LIB" +fi + +if [ $VXWORKS ] +then + # + # Required by VxWorks + # + WIND_BASE=C:/tornado + WIND_HOST_TYPE=x86-win32 + WIND_REGISTRY=coalsack + WIND_LMHOST=coalsack + BLD_VX_HOST=i386-wrs-vxworks + export WIND_BASE WIND_HOST_TYPE WIND_REGISTRY WIND_LMHOST BLD_VX_HOST + + VX_TOOLS=`cygpath $WIND_BASE`/host/$WIND_HOST_TYPE + # + # Use cygwin make and tools by preference + # + PATH="$APPWEB_PATH:$PATH:$VX_TOOLS/bin" +fi + +# +# Make required directories for CYGWIN +# +if [ ! -x /bin/bash.exe ] +then + DIR=`cygpath -w "$HOME/winTools"` + echo -e "\nCreating /bin" + echo Mounting \"${DIR}\" as /bin + mount -f -b "$DIR" /bin +fi + +if [ ! -x /tmp ] +then + mkdir -p tmp + DIR=`cygpath -w "$HOME/tmp"` + echo -e "\nCreating /tmp" + echo Mounting \"${DIR}\" as /tmp + mount -f -b "$DIR" /tmp +fi +echo + + +################################################################################ +# +# Do a bit of validation (MOB -- extend) +# +type cl 2>/dev/null >/dev/null +if [ $? -ne 0 ] +then + echo "Can't find compiler: cl. Check WIN/bashrc settings for PATH" +fi + +################################################################################ +# +# Some convenient functions +# +pvi () { + + pattern=$1 + shift + files=$* + if [ -z "${files}" ] + then + files='*.c *.cpp *.h Makefile *.html *.aspx *.cs' + fi + vi -c "/${pattern}" $(grep -l "${pattern}" ${files}) +} + +################################################################################ + +g() { + pattern=$1 + shift + files=$* + if [ -z "${files}" ] + then + files=`echo *.c *.cpp *.h Makefile *.html *.aspx *.cs` + fi + eval grep "${pattern}" ${files} +} + +################################################################################ + +usedvi() { + pvi $1 $HOME/mr/*.c $HOME/mr/*.h $HOME/mr/WIN/*.c $HOME/lib/*/*.c +} + +################################################################################ + +alias ls='ls -CF $*' +alias lc='ls -CF $*' +alias lr='ls -R $*' +alias xwin='startxwin.sh' +alias htmlview='"C:/Program Files/Internet Explorer/iexplore.exe" $*' +set -o vi + +if [ `uname -o` = "Cygwin" ] +then + alias vim='"C:/Program Files/vim/vim64/vim.exe" $*' + alias gvim='"C:/Program Files/vim/vim64/gvim.exe" $*' +fi + +brew() { + "C:/Program Files/BREW SDK v2.1.3/Bin/BREW_Emulator.exe" +} + +js() { + cscript /nologo $* +} diff --git a/source4/lib/appweb/ejs-2.0/ejs/.ignore b/source4/lib/appweb/ejs-2.0/ejs/.ignore new file mode 100644 index 0000000000..47f4ac63b2 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/.ignore @@ -0,0 +1,2 @@ +ejs +future diff --git a/source4/lib/appweb/ejs-2.0/ejs/Makefile b/source4/lib/appweb/ejs-2.0/ejs/Makefile new file mode 100644 index 0000000000..ea6be8c401 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/Makefile @@ -0,0 +1,61 @@ +# +# Makefile for Embedded Javascript (EJS) +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +# +# Ejs may be linked into shared handlers so we must build the objects both +# shared and static if --shared was specified to configure. +# +COMPILE := *.c +EXPORT_OBJECTS := yes +PRE_DIRS := classes system db +MAKE_IFLAGS := -I../mpr -I../exml + +include make.dep + +ifeq ($(BLD_PRODUCT),ejs) +POST_DIRS := package +endif + +ifeq ($(BLD_FEATURE_TEST),1) +POST_DIRS += test +endif + +ifeq ($(BLD_FEATURE_EJS_DB),1) +LIBS += sqlite +endif + +TARGETS += $(BLD_BIN_DIR)/libejs$(BLD_LIB) +TARGETS += $(BLD_BIN_DIR)/ejs$(BLD_EXE) + +ifeq ($(BLD_FEATURE_EJS),1) +compileExtra: $(TARGETS) +endif + +$(BLD_BIN_DIR)/libejs$(BLD_LIB): files \ + $(shell BLD_OBJ=$(BLD_OBJ) \; BLD_OBJ_DIR=$(BLD_OBJ_DIR) \; \ + eval echo `cat files`) + @bld --library $(BLD_BIN_DIR)/libejs \ + --objectsDir $(BLD_OBJ_DIR) --objectList files \ + --libs "exml mpr $(LIBS)" + +$(BLD_BIN_DIR)/ejs$(BLD_EXE): $(BLD_BIN_DIR)/libejs$(BLD_LIB) \ + $(BLD_BIN_DIR)/libmpr$(BLD_LIB) \ + $(BLD_BIN_DIR)/libejs$(BLD_LIB) $(FILES) + @bld --executable $(BLD_BIN_DIR)/ejs$(BLD_EXE) \ + --rpath "$(BLD_PREFIX)/bin" \ + --preferStatic --smartLibs "ejs exml mpr $(LIBS)" \ + --objectsDir $(BLD_OBJ_DIR) \ + --objects "$(BLD_OBJ_DIR)/ejsCmd$(BLD_OBJ)" + +cleanExtra: + @echo "rm -f $(TARGETS)" | $(BLDOUT) + @rm -f $(TARGETS) + @rm -f $(BLD_BIN_DIR)/libejs.* + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/ejs/classes/.ignore b/source4/lib/appweb/ejs-2.0/ejs/classes/.ignore new file mode 100644 index 0000000000..fb5a29031e --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/classes/.ignore @@ -0,0 +1 @@ +.updated diff --git a/source4/lib/appweb/ejs-2.0/ejs/classes/Makefile b/source4/lib/appweb/ejs-2.0/ejs/classes/Makefile new file mode 100644 index 0000000000..ce12bb3829 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/classes/Makefile @@ -0,0 +1,21 @@ +# +# Makefile to build the EJS Classes +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +COMPILE := *.c +EXPORT_OBJECTS := yes +MAKE_IFLAGS := -I.. -I../../mpr -I../../exml + +include make.dep + +compileExtra: .updated + +.updated: $(FILES) + @touch .updated + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/ejs/classes/ejsArray.c b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsArray.c new file mode 100644 index 0000000000..feb64b1aa8 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsArray.c @@ -0,0 +1,167 @@ +/* + * @file ejsArray.c + * @brief Array class + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/************************************ Code ************************************/ + +int ejsDefineArrayClass(Ejs *ep) +{ + if (ejsDefineClass(ep, "Array", "Object", ejsArrayConstructor) == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + return 0; +} + +/******************************************************************************/ +/* + * Routine to create the base array type + */ + +EjsVar *ejsCreateArrayInternal(EJS_LOC_DEC(ep, loc), int size) +{ + EjsProperty *pp; + EjsVar *obj, *vp; + + /* MOB -- need to supply hash size -- max(size, 503)); */ + + obj = ejsCreateSimpleObjInternal(EJS_LOC_PASS(ep, loc), "Array"); + if (obj == 0) { + mprAssert(0); + return obj; + } + obj->isArray = 1; + + /* MOB -- call constructor here and replace this code */ + + pp = ejsSetPropertyToInteger(ep, obj, "length", size); + ejsMakePropertyEnumerable(pp, 0); + + vp = ejsGetVarPtr(pp); + vp->isArrayLength = 1; + + return obj; +} + +/******************************************************************************/ + +EjsVar *ejsAddArrayElt(Ejs *ep, EjsVar *op, EjsVar *element, + EjsCopyDepth copyDepth) +{ + EjsProperty *pp; + EjsVar *vp; + char idx[16]; + int length; + + mprAssert(op->isArray); + + length = ejsGetPropertyAsInteger(ep, op, "length"); + + mprItoa(idx, sizeof(idx), length); + pp = ejsCreateProperty(ep, op, idx); + vp = ejsGetVarPtr(pp); + + ejsWriteVar(ep, vp, element, copyDepth); + + ejsSetPropertyToInteger(ep, op, "length", length + 1); + + return vp; +} + +/******************************************************************************/ +/* + * Constructor + */ + +int ejsArrayConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsProperty *pp; + EjsVar *vp; + char idx[16]; + int i, max; + + thisObj->isArray = 1; + max = 0; + + if (argc > 0) { + if (argc == 1 && ejsVarIsNumber(argv[0])) { + /* + * x = new Array(size); + */ + max = (int) ejsVarToInteger(argv[0]); + + } else { + /* + * x = new Array(element0, element1, ..., elementN): + */ + max = argc; + for (i = 0; i < max; i++) { + mprItoa(idx, sizeof(idx), i); + pp = ejsCreateSimpleProperty(ep, thisObj, idx); + vp = ejsGetVarPtr(pp); + ejsWriteVar(ep, vp, argv[i], EJS_SHALLOW_COPY); + } + } + } + + pp = ejsCreateSimpleProperty(ep, thisObj, "length"); + ejsMakePropertyEnumerable(pp, 0); + vp = ejsGetVarPtr(pp); + ejsWriteVarAsInteger(ep, vp, max); + vp->isArrayLength = 1; + + return 0; +} + +/******************************************************************************/ + +#else +void ejsArrayDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/classes/ejsDate.c b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsDate.c new file mode 100755 index 0000000000..096316a822 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsDate.c @@ -0,0 +1,197 @@ +/* + * @file ejsStndClasses.c + * @brief EJS support methods + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS && 0 + +/******************************************************************************/ +/* + * Date constructor + + * + * Date(); + * Date(milliseconds); + * Date(dateString); + * Date(year, month, date); + * Date(year, month, date, hour, minute, second); + */ + +int ejsDateConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + return 0; +} + +/******************************************************************************/ + +static int load(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + const char *fileName; + XmlState *parser; + Exml *xp; + MprFile *file; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ep, EJS_ARG_ERROR, "Bad args. Usage: load(fileName);"); + return -1; + } + fileName = argv[0]->string; + + /* FUTURE -- not romable + Need rom code in MPR not MprServices + */ + file = mprOpen(ep, fileName, O_RDONLY, 0664); + if (file == 0) { + ejsError(ep, EJS_IO_ERROR, "Can't open: %s", fileName); + return -1; + } + + xp = initParser(ep, thisObj, fileName); + parser = exmlGetParseArg(xp); + + exmlSetInputStream(xp, readFileData, (void*) file); + + if (exmlParse(xp) < 0) { + if (! ejsGotException(ep)) { + ejsError(ep, EJS_IO_ERROR, "Can't parse XML file: %s\nDetails %s", + fileName, exmlGetErrorMsg(xp)); + } + termParser(xp); + mprClose(file); + return -1; + } + + ejsSetReturnValue(ep, parser->nodeStack[0].obj); + + termParser(xp); + mprClose(file); + + return 0; +} + +/******************************************************************************/ + +int ejsDefineDateClass(Ejs *ep) +{ + EjsVar *dateClass; + + dateClass = ejsDefineClass(ep, "Date", "Object", ejsDateConstructor); + if (dateClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + ejsDefineCMethod(ep, dateClass, "getDate", xxxProc, EJS_NO_LOCAL); + + /* Returns "Friday" or 4 ? */ + ejsDefineCMethod(ep, dateClass, "getDay", xxxProc, EJS_NO_LOCAL); + + ejsDefineCMethod(ep, dateClass, "getMonth", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "getFullYear", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "getYear", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "getHours", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "getMinutes", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "getSeconds", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "getMilliseconds", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "getTime", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "getTimeZoneOffset", xxxProc, EJS_NO_LOCAL); + + ejsDefineCMethod(ep, dateClass, "parse", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "setDate", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "setMonth", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "setFullYear", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "setYear", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "setMinutes", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "setSeconds", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "setMilliseconds", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "setTime", xxxProc, EJS_NO_LOCAL); + + ejsDefineCMethod(ep, dateClass, "toString", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "toGMTString", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "toUTCString", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "toLocaleString", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "UTC", xxxProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, dateClass, "valueOf", xxxProc, EJS_NO_LOCAL); + /* + UTC: getUTCDate, getUTCDay, getUTCMonth, getUTCFullYear, getUTCHours, + getUTCMinutes, getUTCSeconds, getUTCMilliseconds + setUTCDate, setUTCDay, setUTCMonth, setUTCFullYear, setUTCHours, + setUTCMinutes, setUTCSeconds, setUTCMilliseconds + */ + + return ejsObjHasErrors(dateClass) ? MPR_ERR_CANT_INITIALIZE : 0; +} + +/******************************************************************************/ +/* + Time is since 1970/01/01 GMT + + Normal: Fri Feb 10 2006 05:06:44 GMT-0800 (Pacific Standard Time) + UTC: Sat, 11 Feb 2006 05:06:44 GMT + + // Using without New + + println(Date()); + + var myDate = new Date(); + myDate.setFullYear(2010, 0, 14); + + var today = new Date(); + + if (myDate > today) { + } else { + } + + + X=Date() should be equivalent to X=(new Date()).toString() + + */ +/******************************************************************************/ + +#else +void ejsStndClassesDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/classes/ejsError.c b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsError.c new file mode 100755 index 0000000000..99445afc7c --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsError.c @@ -0,0 +1,140 @@ +/* + * @file ejsError.c + * @brief Error class + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/************************************ Code ************************************/ +/* + * Parse the args and return the message. Convert non-string args using + * .toString. + */ + +static char *getMessage(Ejs *ep, int argc, EjsVar **argv) +{ + if (argc == 0) { + return ""; + + } else if (argc == 1) { + if (! ejsVarIsString(argv[0])) { + if (ejsRunMethod(ep, argv[0], "toString", 0) < 0) { + return 0; + } + return ep->result->string; + + } else { + return argv[0]->string; + } + + } else { + /* Don't call ejsError here or it will go recursive. */ + return 0; + } +} + + +/******************************************************************************/ +/* + * Error Constructor and also used for constructor for sub classes. + * + * Usage: new Error([message]) + */ + +int ejsErrorCons(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *msg, *stack; + + msg = getMessage(ep, argc, argv); + if (msg == 0) { + return -1; + } + + ejsSetPropertyToString(ep, thisObj, "name", ejsGetBaseClassName(thisObj)); + ejsSetPropertyToString(ep, thisObj, "message", msg); + + ejsSetPropertyToUndefined(ep, thisObj, "stack"); + + stack = ejsFormatStack(ep); + if (stack) { + ejsSetPropertyToString(ep, thisObj, "stack", stack); + mprFree(stack); + } + + if (ejsObjHasErrors(thisObj)) { + return -1; + } + + return 0; +} + +/******************************************************************************/ + +int ejsDefineErrorClasses(Ejs *ep) +{ + if (ejsDefineClass(ep, "Error", "Object", ejsErrorCons) == 0 || + ejsDefineClass(ep, "AssertError", "Error", ejsErrorCons) == 0 || + ejsDefineClass(ep, "EvalError", "Error", ejsErrorCons) == 0 || + ejsDefineClass(ep, "InternalError", "Error", ejsErrorCons) == 0 || + ejsDefineClass(ep, "IOError", "Error", ejsErrorCons) == 0 || + ejsDefineClass(ep, "MemoryError", "Error", ejsErrorCons) == 0 || + ejsDefineClass(ep, "RangeError", "Error", ejsErrorCons) == 0 || + ejsDefineClass(ep, "ReferenceError", "Error", ejsErrorCons) == 0 || + ejsDefineClass(ep, "SyntaxError", "Error", ejsErrorCons) == 0 || + ejsDefineClass(ep, "TypeError", "Error", ejsErrorCons) == 0) { + + return MPR_ERR_CANT_INITIALIZE; + } + return 0; +} + +/******************************************************************************/ + +#else +void ejsErrorDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/classes/ejsObject.c b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsObject.c new file mode 100644 index 0000000000..4f2e23beb2 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsObject.c @@ -0,0 +1,588 @@ +/* + * @file ejsObject.c + * @brief Object class + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/****************************** Forward Declarations **************************/ +/* + * Support routines + */ + +static void formatVar(Ejs *ep, MprBuf *bp, EjsVar *vp); + +/******************************************************************************/ +/* + * Routine to create an object of the desired class. Class name may + * contain "." + * + * The created object will be a stand-alone class NOT entered into the + * properties of any other object. Callers must do this if required. ClassName + * may contain "." and is interpreted relative to "obj" if supplied. + * + * Note: this does not call the constructors for the various objects and base + * classes. + */ + +EjsVar *ejsCreateSimpleObjInternal(EJS_LOC_DEC(ep, loc), const char *className) +{ + EjsVar *baseClass; + + if (className && *className) { + baseClass = ejsGetClass(ep, 0, className); + if (baseClass == 0) { + mprError(ep, MPR_LOC, "Can't find base class %s", className); + return 0; + } + } else { + baseClass = 0; + } + + return ejsCreateSimpleObjUsingClassInt(EJS_LOC_PASS(ep, loc), + baseClass); +} + +/******************************************************************************/ +/* + * Create an object based upon the specified base class object. It will be a + * stand-alone class not entered into the properties of any other object. + * Callers must do this if required. + * + * Note: this does not call the constructors for the various objects and base + * classes. + */ + +EjsVar *ejsCreateSimpleObjUsingClassInt(EJS_LOC_DEC(ep, loc), + EjsVar *baseClass) +{ + EjsVar *vp; + + mprAssert(baseClass); + + if (baseClass == 0) { + mprError(ep, MPR_LOC, "Missing base class\n"); + return 0; + } + + vp = ejsCreateObjVarInternal(EJS_LOC_PASS(ep, loc)); + if (vp == 0) { + return vp; + } + + ejsSetBaseClass(vp, baseClass); + + /* + * This makes all internal method accesses faster + * NOTE: this code is duplicated in ejsCreateSimpleClass + */ + mprAssert(vp->objectState); + vp->objectState->methods = baseClass->objectState->methods; + + return vp; +} + +/******************************************************************************/ + +void ejsSetMethods(Ejs *ep, EjsVar *op) +{ + op->objectState->methods = ep->global->objectState->methods; +} + +/******************************************************************************/ +/******************************** Internal Methods ****************************/ +/******************************************************************************/ + +static EjsVar *createObjProperty(Ejs *ep, EjsVar *obj, const char *property) +{ + return ejsGetVarPtr(ejsCreateSimpleProperty(ep, obj, property)); +} + +/******************************************************************************/ + +static int deleteObjProperty(Ejs *ep, EjsVar *obj, const char *property) +{ + return ejsDeleteProperty(ep, obj, property); +} + +/******************************************************************************/ + +static EjsVar *getObjProperty(Ejs *ep, EjsVar *obj, const char *property) +{ + return ejsGetVarPtr(ejsGetSimpleProperty(ep, obj, property)); +} + +/******************************************************************************/ +/* + * Set the value of a property. Create if it does not exist + */ + +static EjsVar *setObjProperty(Ejs *ep, EjsVar *obj, const char *property, + const EjsVar *value) +{ + EjsProperty *pp; + EjsVar *vp; + + pp = ejsCreateSimpleProperty(ep, obj, property); + if (pp == 0) { + mprAssert(pp); + return 0; + } + vp = ejsGetVarPtr(pp); + if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) < 0) { + mprAssert(0); + return 0; + } + return ejsGetVarPtr(pp); +} + +/******************************************************************************/ +/*********************************** Constructors *****************************/ +/******************************************************************************/ +#if UNUSED +/* + * Object constructor. We don't use this for speed. Think very carefully if + * you add an object constructor. + */ + +int ejsObjectConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + return 0; +} + +#endif +/******************************************************************************/ +/******************************** Visible Methods *****************************/ +/******************************************************************************/ + +static int cloneMethod(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int copyDepth; + + copyDepth = EJS_DEEP_COPY; + + if (argc == 1 && ejsVarToBoolean(argv[0])) { + copyDepth = EJS_RECURSIVE_DEEP_COPY; + } + + ejsWriteVar(ep, ep->result, thisObj, copyDepth); + + return 0; +} + +/******************************************************************************/ + +static int toStringMethod(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprBuf *bp; + int saveMaxDepth, saveDepth, saveFlags; + + saveMaxDepth = ep->maxDepth; + + if (argc >= 1) { + ep->maxDepth = ejsVarToInteger(argv[0]); + } else if (ep->maxDepth == 0) { + ep->maxDepth = MAXINT; + } + + saveFlags = ep->flags; + if (argc >= 2) { + if (ejsVarToBoolean(argv[1])) { + ep->flags |= EJS_FLAGS_ENUM_HIDDEN; + } + } + if (argc == 3) { + if (ejsVarToBoolean(argv[2])) { + ep->flags |= EJS_FLAGS_ENUM_BASE; + } + } + + bp = mprCreateBuf(ep, 0, 0); + + saveDepth = ep->depth; + + formatVar(ep, bp, thisObj); + + ep->depth = saveDepth; + ep->maxDepth = saveMaxDepth; + + mprAddNullToBuf(bp); + + ejsWriteVarAsString(ep, ep->result, mprGetBufStart(bp)); + mprFree(bp); + + ep->flags = saveFlags; + + return 0; +} + +/******************************************************************************/ + +static int valueOfMethod(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 0) { + mprAssert(0); + return -1; + } + + switch (thisObj->type) { + default: + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + case EJS_TYPE_CMETHOD: + case EJS_TYPE_OBJECT: + case EJS_TYPE_METHOD: + case EJS_TYPE_STRING_CMETHOD: + ejsWriteVar(ep, ep->result, thisObj, EJS_SHALLOW_COPY); + break; + + case EJS_TYPE_STRING: + ejsWriteVarAsInteger(ep, ep->result, atoi(thisObj->string)); + break; + + case EJS_TYPE_BOOL: + case EJS_TYPE_INT: +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: +#endif +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: +#endif + ejsWriteVar(ep, ep->result, thisObj, EJS_SHALLOW_COPY); + break; + } + return 0; +} + +/******************************************************************************/ + +static int hashGetAccessor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToInteger(ejs, (int) thisObj->objectState); + return 0; +} + +/******************************************************************************/ + +static int classGetAccessor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (thisObj->objectState == 0 || thisObj->objectState->baseClass == 0) { + ejsSetReturnValueToString(ejs, "object"); + } else { + ejsSetReturnValueToString(ejs, + thisObj->objectState->baseClass->objectState->className); + } + return 0; +} + +/******************************************************************************/ +/* + * Format an object. Called recursively to format properties and contained + * objects. + */ + +static void formatVar(Ejs *ep, MprBuf *bp, EjsVar *vp) +{ + EjsProperty *pp, *first; + EjsVar *propVar, *baseClass; + char *buf, *value; + int i; + + if (vp->type == EJS_TYPE_OBJECT) { + if (!vp->objectState->visited) { + + mprPutStringToBuf(bp, vp->isArray ? "[\n" : "{\n"); + + ep->depth++; + vp->objectState->visited = 1; + + if (ep->depth <= ep->maxDepth) { + first = ejsGetFirstProperty(vp, EJS_ENUM_ALL); + + if (ep->flags & EJS_FLAGS_ENUM_BASE) { + baseClass = vp->objectState->baseClass; + if (baseClass) { + for (i = 0; i < ep->depth; i++) { + mprPutStringToBuf(bp, " "); + } + mprPutStringToBuf(bp, baseClass->objectState->objName); + mprPutStringToBuf(bp, ": /* Base Class */ "); + if (baseClass->objectState == vp->objectState) { + value = "this"; + } else if (ejsRunMethodCmd(ep, baseClass, "toString", + "%d", ep->maxDepth) < 0) { + value = "[object Object]"; + } else { + mprAssert(ejsVarIsString(ep->result)); + value = ep->result->string; + } + mprPutStringToBuf(bp, value); + if (first) { + mprPutStringToBuf(bp, ",\n"); + } + } + } + + pp = first; + while (pp) { + if (! pp->dontEnumerate || + ep->flags & EJS_FLAGS_ENUM_HIDDEN) { + for (i = 0; i < ep->depth; i++) { + mprPutStringToBuf(bp, " "); + } + + if (! vp->isArray) { + mprPutStringToBuf(bp, pp->name); + mprPutStringToBuf(bp, ": "); + } + + propVar = ejsGetVarPtr(pp); + if (propVar->type == EJS_TYPE_OBJECT) { + if (pp->var.objectState == vp->objectState) { + value = "this"; + } else if (ejsRunMethodCmd(ep, propVar, + "toString", "%d", ep->maxDepth) < 0) { + value = "[object Object]"; + } else { + mprAssert(ejsVarIsString(ep->result)); + value = ep->result->string; + } + mprPutStringToBuf(bp, value); + + } else { + formatVar(ep, bp, &pp->var); + } + + pp = ejsGetNextProperty(pp, EJS_ENUM_ALL); + if (pp) { + mprPutStringToBuf(bp, ",\n"); + } + } else { + pp = ejsGetNextProperty(pp, EJS_ENUM_ALL); + } + } + } + vp->objectState->visited = 0; + + mprPutCharToBuf(bp, '\n'); + + ep->depth--; + for (i = 0; i < ep->depth; i++) { + mprPutStringToBuf(bp, " "); + } + mprPutCharToBuf(bp, vp->isArray ? ']' : '}'); + } + + } else if (vp->type == EJS_TYPE_METHOD) { + + mprPutStringToBuf(bp, "function ("); + for (i = 0; i < vp->method.args->length; i++) { + mprPutStringToBuf(bp, vp->method.args->items[i]); + if ((i + 1) < vp->method.args->length) { + mprPutStringToBuf(bp, ", "); + } + } + mprPutStringToBuf(bp, ") {"); + mprPutStringToBuf(bp, vp->method.body); + for (i = 0; i < ep->depth; i++) { + mprPutStringToBuf(bp, " "); + } + mprPutStringToBuf(bp, "}"); + + } else { + + if (vp->type == EJS_TYPE_STRING) { + mprPutCharToBuf(bp, '\"'); + } + + /* + * We don't use ejsVarToString for arrays, objects and strings. + * This is because ejsVarToString does not call "obj.toString" + * and it is not required for strings. + * MOB - rc + */ + buf = ejsVarToString(ep, vp); + mprPutStringToBuf(bp, buf); + + if (vp->type == EJS_TYPE_STRING) { + mprPutCharToBuf(bp, '\"'); + } + } +} + +/******************************************************************************/ +/* + * mixin code. Blends code at the "thisObj" level. + */ + +static int mixinMethod(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsProperty *pp; + char *buf; + int fid, i, rc; + + mprAssert(argv); + + /* + * Create a variable scope block set to the current object + */ + rc = 0; + fid = ejsSetBlock(ep, thisObj); + + for (i = 0; i < argc; i++) { + + if (ejsVarIsString(argv[i])) { + rc = ejsEvalScript(ep, argv[i]->string, 0); + + } else if (ejsVarIsObject(argv[i])) { + + /* MOB -- OPT. When we have proper scope chains, we should just + refer to the module and not copy */ + pp = ejsGetFirstProperty(argv[i], EJS_ENUM_ALL); + while (pp) { + ejsSetProperty(ep, thisObj, pp->name, ejsGetVarPtr(pp)); + pp = ejsGetNextProperty(pp, EJS_ENUM_ALL); + } + + } else { + /* MOB - rc */ + buf = ejsVarToString(ep, argv[i]); + rc = ejsEvalScript(ep, buf, 0); + + } + if (rc < 0) { + ejsCloseBlock(ep, fid); + return -1; + } + } + ejsCloseBlock(ep, fid); + return 0; +} + +/******************************************************************************/ +/* + * Create the object class + */ + +int ejsDefineObjectClass(Ejs *ep) +{ + EjsMethods *methods; + EjsProperty *objectProp, *protoProp; + EjsVar *op, *globalClass; + + /* + * Must specially hand-craft the object class as it is the base class + * of all objects. + */ + op = ejsCreateObjVar(ep); + if (op == 0) { + return MPR_ERR_CANT_CREATE; + } + ejsSetClassName(ep, op, "Object"); + + /* + * Don't use a constructor for objects for speed + */ + ejsMakeClassNoConstructor(op); + + /* + * MOB -- should mark properties as public / private and class or instance. + */ + ejsDefineCMethod(ep, op, "clone", cloneMethod, EJS_NO_LOCAL); + ejsDefineCMethod(ep, op, "toString", toStringMethod, EJS_NO_LOCAL); + ejsDefineCMethod(ep, op, "valueOf", valueOfMethod, EJS_NO_LOCAL); + ejsDefineCMethod(ep, op, "mixin", mixinMethod, EJS_NO_LOCAL); + + ejsDefineCAccessors(ep, op, "hash", hashGetAccessor, 0, EJS_NO_LOCAL); + ejsDefineCAccessors(ep, op, "baseClass", classGetAccessor, 0, EJS_NO_LOCAL); + + /* + * MOB -- make this an accessor + */ + protoProp = ejsSetProperty(ep, op, "prototype", op); + if (protoProp == 0) { + ejsFreeVar(ep, op); + return MPR_ERR_CANT_CREATE; + } + + /* + * Setup the internal methods. Most classes will never override these. + * The XML class will. We rely on talloc to free internal. Use "ep" as + * the parent as we need "methods" to live while the interpreter lives. + */ + methods = mprAllocTypeZeroed(ep, EjsMethods); + op->objectState->methods = methods; + + methods->createProperty = createObjProperty; + methods->deleteProperty = deleteObjProperty; + methods->getProperty = getObjProperty; + methods->setProperty = setObjProperty; + + objectProp = ejsSetPropertyAndFree(ep, ep->global, "Object", op); + + /* + * Change the global class to use Object's methods + */ + globalClass = ep->service->globalClass; + globalClass->objectState->methods = methods; + globalClass->objectState->baseClass = ejsGetVarPtr(protoProp); + + ep->objectClass = ejsGetVarPtr(objectProp); + + if (ejsObjHasErrors(ejsGetVarPtr(objectProp))) { + ejsFreeVar(ep, op); + return MPR_ERR_CANT_CREATE; + } + return 0; +} + +/******************************************************************************/ + +#else +void ejsObjectDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/classes/ejsStndClasses.c b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsStndClasses.c new file mode 100644 index 0000000000..fd6cda7813 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsStndClasses.c @@ -0,0 +1,144 @@ +/* + * @file ejsStndClasses.c + * @brief EJS support methods + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/******************************************************************************/ +/******************************* Function Class *******************************/ +/******************************************************************************/ + +int ejsDefineFunctionClass(Ejs *ep) +{ + if (ejsDefineClass(ep, "Function", "Object", ejsFunctionConstructor) == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + return 0; +} + +/******************************************************************************/ +/* + * Function constructor + */ + +int ejsFunctionConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsArgError(ep, "Usage: Function(\"function (arg) { script };\");"); + } + + rc = ejsEvalScript(ep, argv[0]->string, 0); + + /* + * Note: this will convert the object into a method. It will cease to be + * an object. + */ + if (rc == 0 && ejsVarIsMethod(ep->result)) { + /* + * Must make thisObj collectable. + */ + ejsMakeObjPermanent(thisObj, 0); + ejsMakeObjLive(thisObj, 1); + mprAssert(ejsObjIsCollectable(thisObj)); + ejsWriteVar(ep, thisObj, ep->result, EJS_SHALLOW_COPY); + } + return rc; +} + +/******************************************************************************/ +/******************************* Boolean Class ********************************/ +/******************************************************************************/ + +int ejsDefineBooleanClass(Ejs *ep) +{ + if (ejsDefineClass(ep, "Boolean", "Object", ejsBooleanConstructor) == 0){ + return MPR_ERR_CANT_INITIALIZE; + } + return 0; +} + +/******************************************************************************/ +/* + * Boolean constructor + */ + +int ejsBooleanConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + return 0; +} + +/******************************************************************************/ +/******************************** Number Class ********************************/ +/******************************************************************************/ + +int ejsDefineNumberClass(Ejs *ep) +{ + if (ejsDefineClass(ep, "Number", "Object", ejsNumberConstructor) == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + return 0; +} + +/******************************************************************************/ +/* + * Number constructor + */ + +int ejsNumberConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + return 0; +} + +/******************************************************************************/ + +#else +void ejsStndClassesDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/classes/ejsString.c b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsString.c new file mode 100644 index 0000000000..2339650361 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsString.c @@ -0,0 +1,381 @@ +/* + * @file ejsString.c + * @brief EJScript string class + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS +/******************************************************************************/ +/*********************************** Constructors *****************************/ +/******************************************************************************/ +/* + * String constructor. + */ + +int ejsStringConstructor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *str; + + if (argc == 0) { + ejsSetReturnValueToString(ejs, ""); + + } else if (argc == 1) { + /* MOB -- rc */ + str = ejsVarToString(ejs, argv[0]); + ejsSetReturnValueToString(ejs, str); + + } else { + ejsArgError(ejs, "usage: String([var])"); + return -1; + } + + return 0; +} + +/******************************************************************************/ +/******************************** Visible Methods *****************************/ +/******************************************************************************/ +/* + * Return a string containing the character at a given index + * + * String string.charAt(Number) + */ + +static int charAt(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsNum num; + char buf[2]; + + if (argc != 1) { + ejsArgError(ejs, "usage: charAt(integer)"); + return -1; + } + + num = ejsVarToNumber(argv[0]); + if (num < 0 || num >= thisObj->length) { + ejsError(ejs, EJS_RANGE_ERROR, "Bad index"); + return -1; + } + + mprAssert(ejsVarIsString(thisObj)); + + buf[0] = argv[0]->string[num]; + buf[1] = '\0'; + ejsSetReturnValueToString(ejs, buf); + + return 0; +} + +/******************************************************************************/ +/* + * Return an integer containing the character at a given index + * + * Number string.charCodeAt(Number) + */ + +static EjsNum charCodeAt(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsNum num; + + if (argc != 1) { + ejsArgError(ejs, "usage: charCodeAt(integer)"); + return -1; + } + + num = ejsVarToNumber(argv[0]); + if (num < 0 || num >= thisObj->length) { + ejsError(ejs, EJS_RANGE_ERROR, "Bad index"); + return -1; + } + ejsSetReturnValueToNumber(ejs, (EjsNum) argv[0]->string[num]); + + return 0; +} + +/******************************************************************************/ +/* + * Catenate + * + * String string.catenate(var, ...) + */ + +static int concat(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int i; + + if (argc == 0) { + ejsArgError(ejs, "usage: concat(String, ...)"); + return -1; + } + + mprAssert(ejsVarIsString(thisObj)); + + for (i = 0; i < argc; i++) { + if (ejsStrcat(ejs, thisObj, argv[i]) < 0) { + ejsMemoryError(ejs); + return -1; + } + } + ejsSetReturnValue(ejs, thisObj); + return 0; +} + +/******************************************************************************/ +/* + * Return the position of the first occurance of a substring + * + * Number string.indexOf(String subString [, Number start]) + */ + +static int indexOf(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *pat, *s1, *s2, *origin; + int start, i; + + if (argc == 0 || argc > 2) { + ejsArgError(ejs, "usage: indexOf(String [, Number])"); + return -1; + } + + pat = ejsVarToString(ejs, argv[0]); + + if (argc == 2) { + start = ejsVarToNumber(argv[1]); + if (start > thisObj->length) { + start = thisObj->length; + } + } else { + start = 0; + } + + i = start; + for (origin = &thisObj->string[i]; i < thisObj->length; i++, origin++) { + s1 = origin; + for (s2 = pat; *s1 && *s2; s1++, s2++) { + if (*s1 != *s2) { + break; + } + } + if (*s2 == '\0') { + ejsSetReturnValueToNumber(ejs, (EjsNum) (origin - thisObj->string)); + } + } + + ejsSetReturnValueToNumber(ejs, (EjsNum) -1); + return 0; +} + +/******************************************************************************/ +/* + * Return the position of the last occurance of a substring + * + * Number string.lastIndexOf(String subString [, Number start]) + */ + +static int lastIndexOf(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *pat, *s1, *s2, *origin; + int start; + + if (argc == 0 || argc > 2) { + ejsArgError(ejs, "usage: indexOf(String [, Number])"); + return -1; + } + + pat = ejsVarToString(ejs, argv[0]); + + if (argc == 2) { + start = ejsVarToNumber(argv[1]); + if (start > thisObj->length) { + start = thisObj->length; + } + } else { + start = 0; + } + + origin = &thisObj->string[thisObj->length - 1]; + for (; origin >= &thisObj->string[start]; origin--) { + + s1 = origin; + for (s2 = pat; *s1 && *s2; s1++, s2++) { + if (*s1 != *s2) { + break; + } + } + if (*s2 == '\0') { + ejsSetReturnValueToNumber(ejs, (EjsNum) (origin - thisObj->string)); + } + } + + ejsSetReturnValueToNumber(ejs, (EjsNum) -1); + return 0; +} + +/******************************************************************************/ +/* + * Return a substring + * + * Number string.slice(Number start, Number end) + */ + +static int slice(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsNum start, end; + + if (argc != 2) { + ejsArgError(ejs, "usage: slice(Number, Number)"); + return -1; + } + + start = ejsVarToNumber(argv[0]); + end = ejsVarToNumber(argv[1]); + if (start < 0 || start >= thisObj->length) { + ejsError(ejs, EJS_RANGE_ERROR, "Bad start index"); + return-1; + } + if (end < 0 || end >= thisObj->length) { + ejsError(ejs, EJS_RANGE_ERROR, "Bad end index"); + return -1; + } + + mprAssert(ejsVarIsString(thisObj)); + + ejsSetReturnValueToBinaryString(ejs, (uchar*) &thisObj->string[start], + end - start); + + return 0; +} + +/******************************************************************************/ +/* + * Split a string + * + * Number string.split(String delimiter [, Number limit]) + */ + +static int split(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsVar *array, *vp; + char *delim, *last, *cp; + int len, limit, alloc; + + if (argc == 0 || argc > 2) { + ejsArgError(ejs, "usage: split(String [, Number])"); + return -1; + } + + delim = ejsVarToStringEx(ejs, argv[0], &alloc); + + limit = ejsVarToNumber(argv[1]); + + array = ejsCreateArray(ejs, 0); + + len = strlen(delim); + + last = thisObj->string; + for (cp = last; *cp; cp++) { + if (*cp == *delim && strncmp(cp, delim, len) == 0) { + if (cp > last) { + vp = ejsCreateBinaryStringVar(ejs, (uchar*) last, (cp - last)); + ejsAddArrayElt(ejs, array, vp, EJS_SHALLOW_COPY); + ejsFreeVar(ejs, vp); + } + } + } + + ejsSetReturnValue(ejs, array); + ejsFreeVar(ejs, array); + + if (alloc) { + mprFree(delim); + } + + return 0; +} + +/******************************************************************************/ +/* + * Create the object class + */ + +int ejsDefineStringClass(Ejs *ejs) +{ + EjsVar *sc; + + sc = ejsDefineClass(ejs, "String", "Object", ejsStringConstructor); + if (sc == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + ejsDefineCMethod(ejs, sc, "charAt", charAt, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "charCodeAt", charCodeAt, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "concat", concat, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "indexOf", indexOf, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "lastIndexOf", lastIndexOf, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "slice", slice, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "split", split, EJS_NO_LOCAL); +#if UNUSED + ejsDefineCMethod(ejs, sc, "match", match, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "replace", replace, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "search", search, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "substring", substring, EJS_NO_LOCAL); + // MOB bad name + ejsDefineCMethod(ejs, sc, "substr", substr, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "toLowerCase", toLowerCase, EJS_NO_LOCAL); + ejsDefineCMethod(ejs, sc, "toUpperCase", toUpperCase, EJS_NO_LOCAL); + + // Static method + ejsDefineCMethod(ejs, sc, "fromCharCode", fromCharCode, 0, EJS_NO_LOCAL); +#endif + + if (ejsObjHasErrors(sc)) { + ejsFreeVar(ejs, sc); + return MPR_ERR_CANT_CREATE; + } + return 0; +} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/classes/ejsXml.c b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsXml.c new file mode 100644 index 0000000000..a2ef8d1390 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/classes/ejsXml.c @@ -0,0 +1,1327 @@ +/* + * @file ejsXml.c + * @brief E4X XML support + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/************************************ Doc *************************************/ +/* + * Javascript class definition + * + * class XML { + * public XML(); + * public XML(string xmlString); // "<tag... " + * public XML(string file); // "file" + * + * public void load(string file); + * public void save(string file); + * public Array children(); + * public Array attributes(); + * } + * + [[Internal Properties / Methods]] + - prototype - Ptr to class prototype (base class) + - class - Type of class + Object.prototype.toString + - Value - + - Get(name) - Returns the value + - Put(name, value) - Sets the value + - HasProperty(name) - Bool if property exists + - Delete(name) - Delete property + - DefaultValue(hint) - Return default primitive (not obj) value + toString, if result is obj, then call valueOf + if hint is number, then call valueOf, then toString + - Construct(arg list) - Constructor + - Call(arg list) - Function call + - HasInstance(value) - ?? + - Scope - Frame scope chain + - Match(string, index) - Regexp match + + - Example: + XML attribute @name + @* + * + var node = new XML("<order/>"); + Operators: + var prices = order..price; + var urgentItems = order.item(@level == "rush"); + var itemAttrs = order.item[0].@*; # @ for attributes + XML Literals + order.customer.address = + <address>..... + <zip>{zipCode}</zip> Where {var} is a JS var + <tag attribute={prefix}> ... Also for attributes + </address> + Omit namespaces + Example: + var html = <html/>; + html.head.title = "My title"; + head.body@bgcolor = "#e4e4e4"; +*/ + +/********************************** Includes **********************************/ + +#include "ejs.h" +#include "exml.h" + +/************************************ Data ************************************/ +#if BLD_FEATURE_EJS_E4X + +/* + * Per tag state + */ +typedef struct XmlTagState { + EjsVar *obj; + EjsVar *attributes; + EjsVar *comments; +} XmlTagState; + +/* + * Parser state + */ +typedef struct XmlState { + Ejs *ep; + EjsVar *xmlClass; + EjsVar *xmlListClass; + XmlTagState nodeStack[E4X_MAX_NODE_DEPTH]; + int topOfStack; + long inputSize; + long inputPos; + const char *inputBuf; + const char *fileName; +} XmlState; + +/****************************** Forward Declarations **************************/ +/* + * XML methods + */ +static int text(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int name(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int load(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int save(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int toString(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int valueOf(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); + +/* MOB -- temp */ +static int getList(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int setText(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); + +#if FUTURE +static int length(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int toXmlString(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); + +static int appendChild(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int attributes(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int child(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int children(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int comments(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int decendants(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int elements(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int insertChildAfter(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int insertChildBefore(Ejs *ep, EjsVar *thisObj, int argc, + EjsVar **argv); +static int replace(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int setName(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +static int text(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv); +#endif + +/* + * Internal methods + */ +static EjsVar *createXmlProperty(Ejs *ep, EjsVar *obj, const char *property); +static int deleteXmlProperty(Ejs *ep, EjsVar *obj, const char *property); +static EjsVar *getXmlProperty(Ejs *ep, EjsVar *obj, const char *property); +static EjsVar *setXmlProperty(Ejs *ep, EjsVar *obj, const char *property, + const EjsVar *value); +static int loadXmlString(Ejs *ep, EjsVar *thisObj, const char *xmlString); + +/* + * XMLList methods + */ +static EjsVar *createXmlListProperty(Ejs *ep, EjsVar *obj, + const char *property); +static int deleteXmlListProperty(Ejs *ep, EjsVar *obj, + const char *property); +static EjsVar *getXmlListProperty(Ejs *ep, EjsVar *obj, const char *property); +static EjsVar *setXmlListProperty(Ejs *ep, EjsVar *obj, const char *property, + const EjsVar *value); + +/* + * Misc + */ +static int readFileData(Exml *xp, void *data, char *buf, int size); +static int readStringData(Exml *xp, void *data, char *buf, int size); +static int parserHandler(Exml *xp, int state, const char *tagName, + const char *attName, const char *value); +static void termParser(Exml *xp); +static Exml *initParser(Ejs *ep, EjsVar *thisObj, const char *fileName); +static int getNumElements(EjsVar *obj); +static int getText(MprBuf *buf, EjsVar *obj); +static int xmlToString(Ejs *ep, MprBuf *buf, EjsVar *obj, int indentLevel); +static void indent(MprBuf *bp, int level); +static char *cleanTagName(char *name); + +/******************************************************************************/ +/* + * Define the E4X classes (XML, XMLList) + */ + +int ejsDefineXmlClasses(Ejs *ep) +{ + EjsMethods *methods; + EjsVar *xmlClass, *xmlListClass; + + /* + * Create the XML class + */ + xmlClass = ejsDefineClass(ep, "XML", "Object", ejsXmlConstructor); + if (xmlClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define the XML class methods + */ + ejsDefineCMethod(ep, xmlClass, "text", text, EJS_NO_LOCAL); + ejsDefineCMethod(ep, xmlClass, "name", name, EJS_NO_LOCAL); + ejsDefineCMethod(ep, xmlClass, "load", load, EJS_NO_LOCAL); + ejsDefineCMethod(ep, xmlClass, "save", save, EJS_NO_LOCAL); + ejsDefineCMethod(ep, xmlClass, "toString", toString, EJS_NO_LOCAL); + ejsDefineCMethod(ep, xmlClass, "valueOf", valueOf, EJS_NO_LOCAL); + +/* MOB -- temporary only */ + ejsDefineCMethod(ep, xmlClass, "getList", getList, EJS_NO_LOCAL); + ejsDefineCMethod(ep, xmlClass, "setText", setText, EJS_NO_LOCAL); + + /* + * Setup the XML internal methods. + */ + methods = mprAllocTypeZeroed(ep, EjsMethods); + xmlClass->objectState->methods = methods; + + methods->createProperty = createXmlProperty; + methods->deleteProperty = deleteXmlProperty; + methods->getProperty = getXmlProperty; + methods->setProperty = setXmlProperty; + + /* + * Create the XMLList class + */ + xmlListClass = ejsDefineClass(ep, "XMLList", "Array", + ejsXmlListConstructor); + + /* + * Define the XMLList class methods + */ + + /* + * Setup the XML internal methods. + */ + methods = mprAllocTypeZeroed(ep, EjsMethods); + xmlListClass->objectState->methods = methods; + + methods->createProperty = createXmlListProperty; + methods->deleteProperty = deleteXmlListProperty; + methods->getProperty = getXmlListProperty; + methods->setProperty = setXmlListProperty; + + /* MOB -- need to complete xmlListClass */ + + return (ejsObjHasErrors(xmlClass) || ejsObjHasErrors(xmlListClass)) + ? MPR_ERR_CANT_INITIALIZE : 0; + return 0; +} + +/******************************************************************************/ +/* + * Routine to create an XML object using a default constructor + */ + +EjsVar *ejsCreateXml(Ejs *ep) +{ + EjsVar *op; + + op = ejsCreateSimpleObj(ep, "XML"); + if (op == 0) { + mprAssert(op); + return op; + } + ejsSetVarName(ep, op, "xmlNode"); + + /* + * Invoke class constructors manually (for speed and space) + */ + if (ejsXmlConstructor(ep, op, 0, 0) < 0) { + mprFree(op); + mprAssert(0); + return 0; + } + return op; +} + +/******************************************************************************/ +/* + * XML constructor + */ + +int ejsXmlConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsVar *vp; + const char *str; + + ejsSetVarFlags(thisObj, EJS_XML_FLAGS_ELEMENT); + + if (argc == 1) { + vp = argv[0]; + + if (ejsVarIsObject(vp)) { + /* Convert DOM to XML. Not implemented */; + + } else if (ejsVarIsString(vp)) { + str = vp->string; + if (str == 0) { + return 0; + } + if (*str == '<') { + /* XML Literal */ + return loadXmlString(ep, thisObj, str); + + } else { + /* Load from file */ + return load(ep, thisObj, argc, argv); + } + } else { + ejsError(ep, EJS_TYPE_ERROR, "Bad type passed to XML constructor"); + return -1; + } + } + return 0; +} + +/******************************************************************************/ +/* + * Routine to create an XMLList object + */ + +EjsVar *ejsCreateXmlList(Ejs *ep) +{ + EjsVar *op; + + /* Sanity limit for size of hash table */ + + op = ejsCreateSimpleObj(ep, "XMLList"); + if (op == 0) { + mprAssert(0); + return op; + } + if (ejsArrayConstructor(ep, op, 0, 0) < 0 || + ejsXmlConstructor(ep, op, 0, 0) < 0) { + mprFree(op); + mprAssert(0); + return 0; + } + return op; +} + +/******************************************************************************/ +/* + * XMLList constructor + */ + +int ejsXmlListConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + // ejsSetVarFlags(vp, EJS_XML_FLAGS_ELEMENT); + return 0; +} + +/******************************************************************************/ +/******************************** Internal Methods ****************************/ +/******************************************************************************/ + +static EjsVar *createXmlProperty(Ejs *ep, EjsVar *obj, const char *property) +{ + return ejsGetVarPtr(ejsCreateSimpleProperty(ep, obj, property)); +} + +/******************************************************************************/ + +static int deleteXmlProperty(Ejs *ep, EjsVar *obj, const char *property) +{ + return ejsDeleteProperty(ep, obj, property); +} + +/******************************************************************************/ +/* MOB -- need ep as an arg */ +static EjsVar *getXmlProperty(Ejs *ep, EjsVar *obj, const char *property) +{ +#if NEW + EjsVar *lp; + + lp = ejsCreateXmlList(ep); + if (isdigit(*property)) { + /* MOB -- where do we store these. Do we need them ? */ + lp->targetObject = obj + lp->targetProperty = property + return getXmlListProperty(lp, property); + } + + /* What about a simple elment. Should it not return the text */ + + if (*property == '@') { + ap = ejsGetFirstProperty(obj, EJS_ENUM_ALL); + while (ap) { + vp = ejsGetVarPtr(ap); + /* MOB -- are attributes unique ? */ + if (vp->flags & EJS_XML_FLAGS_ATTRIBUTE && + strcmp(property, ap->name) == 0) { + ejsAppendXml(lp, vp); + } + ap = ejsGetNexttProperty(ap, EJS_ENUM_ALL); + } + } else { + while (ap) { + vp = ejsGetVarPtr(ap); + /* MOB -- are attributes unique ? */ + if (vp->flags & EJS_XML_FLAGS_ELEMENT && + strcmp(property, ap->name) == 0) { + ejsAppendXml(lp, vp); + } + ap = ejsGetNexttProperty(ap, EJS_ENUM_ALL); + } + } + return l; + + // Must always return XML or XMLList event for comments and attributes +#endif + return ejsGetVarPtr(ejsGetSimpleProperty(ep, obj, property)); +} + +/******************************************************************************/ + +static EjsVar *setXmlProperty(Ejs *ep, EjsVar *obj, const char *property, + const EjsVar *value) +{ + EjsProperty *pp; + EjsVar *vp; + + pp = ejsCreateSimpleProperty(ep, obj, property); + if (pp == 0) { + /* Should never happen */ + mprAssert(pp); + return 0; + } + vp = ejsGetVarPtr(pp); + if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) < 0) { + return 0; + } + return ejsGetVarPtr(pp); +} + +/******************************************************************************/ +/* + NEW + +static EjsVar *setXmlProperty(Ejs *ep, EjsVar *op, const char *property, + EjsVar *value) +{ + + if ((value->objectState->baseClass != XML && + value->objectState->baseClass != XMLList) || + value->string[0] != '<') { + ejsVarToString(luevalue.toString(); + ejsRunMethod(ep, value, "toString", 0); + value = ejsDupVar(ep->result); + + } else { + value = ejsDupVar(value); + } + + if (isdigit(*property)) { + // ERROR -- reserved for future versions + return 0; + } + + if (*property == '@') { + if (op->objectState->baseClass == XMLList) { + if (op->obj.LENGTH_PROPERTY == 0) { + c = ""; + } else { + // Catenate all result of toString on all elts in list + } + } else { + c = c.toString(); + } + // Replace existing attribute of same name or insert + return; + } + for (i = op->obj.LENGTH - 1; i >= 0; i--) { + // Delete item of same name + } + if (not Found) { + Append new Xml object + - set [[name]], [[class]] == "element" + } + + mprFree(value); +} + + */ +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ + +static int load(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + const char *fileName; + XmlState *parser; + Exml *xp; + MprFile *file; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ep, EJS_ARG_ERROR, "Bad args. Usage: load(fileName);"); + return -1; + } + fileName = argv[0]->string; + + /* MOB -- not romable + Need rom code in MPR not MprServices + */ + file = mprOpen(ep, fileName, O_RDONLY, 0664); + if (file == 0) { + ejsError(ep, EJS_IO_ERROR, "Can't open: %s", fileName); + return -1; + } + + /* MOB -- should we empty thisObj of all existing properties ? */ + + xp = initParser(ep, thisObj, fileName); + parser = exmlGetParseArg(xp); + + exmlSetInputStream(xp, readFileData, (void*) file); + + if (exmlParse(xp) < 0) { + if (! ejsGotException(ep)) { + ejsError(ep, EJS_IO_ERROR, "Can't parse XML file: %s\nDetails %s", + fileName, exmlGetErrorMsg(xp)); + } + termParser(xp); + mprClose(file); + return -1; + } + + ejsSetReturnValue(ep, parser->nodeStack[0].obj); + + termParser(xp); + mprClose(file); + + return 0; +} + +/******************************************************************************/ + +static int loadXmlString(Ejs *ep, EjsVar *thisObj, const char *xmlString) +{ + XmlState *parser; + Exml *xp; + + xp = initParser(ep, thisObj, "string"); + parser = exmlGetParseArg(xp); + + parser->inputBuf = xmlString; + parser->inputSize = strlen(xmlString); + + exmlSetInputStream(xp, readStringData, (void*) 0); + + if (exmlParse(xp) < 0) { + if (! ejsGotException(ep)) { + ejsError(ep, EJS_IO_ERROR, "Can't parse XML string\nError %s", + exmlGetErrorMsg(xp)); + } + termParser(xp); + return -1; + } + + ejsSetReturnValue(ep, parser->nodeStack[0].obj); + + termParser(xp); + + return 0; +} + +/******************************************************************************/ + +static int text(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsVar *vp; + + vp = ejsGetVarPtr(ejsGetSimpleProperty(ep, thisObj, E4X_TEXT_PROPERTY)); + if (vp == 0) { + ejsSetReturnValueToString(ep, ""); + return 0; + } + ejsSetReturnValue(ep, vp); + return 0; +} + +/******************************************************************************/ +/* + * Return the tag name + */ + +static int name(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsVar *vp; + + vp = ejsGetVarPtr(ejsGetSimpleProperty(ep, thisObj, E4X_TAG_NAME_PROPERTY)); + if (vp == 0) { + ejsSetReturnValueToString(ep, ""); + return 0; + } + ejsSetReturnValue(ep, vp); +#if UNDEFINED + char *name; + /* MOB -- not ideal as we can't guarantee thisObj is a property */ + name = ejsGetPropertyPtr(thisObj)->name; + if (name == 0) { + name = ""; + } + ejsSetReturnValueToString(ep, name); +#endif + return 0; +} + +/******************************************************************************/ +/* MOB -- temporary only */ + +static int setText(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1) { + ejsArgError(ep, "usage: setText(string)"); + } + + ejsSetProperty(ep, thisObj, E4X_TEXT_PROPERTY, argv[0]); + ejsSetReturnValue(ep, argv[0]); + return 0; +} + +/******************************************************************************/ + +static Exml *initParser(Ejs *ep, EjsVar *thisObj, const char *fileName) +{ + XmlState *parser; + Exml *xp; + + xp = exmlOpen(ep, 512, E4X_BUF_MAX); + mprAssert(xp); + + /* + * Create the parser stack + */ + parser = mprAllocTypeZeroed(ep, XmlState); + parser->ep = ep; + parser->nodeStack[0].obj = thisObj; + parser->xmlClass = ejsGetClass(ep, 0, "XML"); + parser->xmlListClass = ejsGetClass(ep, 0, "XMLList"); + parser->fileName = fileName; + + exmlSetParseArg(xp, parser); + exmlSetParserHandler(xp, parserHandler); + + return xp; +} + +/******************************************************************************/ + +static void termParser(Exml *xp) +{ + mprFree(exmlGetParseArg(xp)); + exmlClose(xp); +} + +/******************************************************************************/ +/* + * XML parsing callback. Called for each elt and attribute/value pair. + * For speed, we handcraft the object model here rather than calling + * putXmlProperty. + * + * "<!-- txt -->" parseHandler(efd, , EXML_COMMENT); + * "<elt" parseHandler(efd, , EXML_NEW_ELT); + * "...att=value" parseHandler(efd, , EXML_NEW_ATT); + * "<elt ...>" parseHandler(efd, , EXML_ELT_DEFINED); + * "<elt/>" parseHandler(efd, , EXML_SOLO_ELT_DEFINED); + * "<elt> ...<" parseHandler(efd, , EXML_ELT_DATA); + * "...</elt>" parseHandler(efd, , EXML_END_ELT); + * + * Note: we recurse on every new nested elt. + */ + +static int parserHandler(Exml *xp, int state, const char *tagName, + const char *attName, const char *value) +{ + XmlState *parser; + XmlTagState *tos; + EjsVar *currentNode, *vp, *tagNode, *parent, *vpx; + EjsProperty *pp; + Ejs *ep; + char *name; + + parser = (XmlState*) xp->parseArg; + ep = parser->ep; + tos = &parser->nodeStack[parser->topOfStack]; + currentNode = tos->obj; + + mprAssert(state >= 0); + mprAssert(tagName && *tagName); + + switch (state) { + case EXML_PI: + /* + * By using a property name with a leading space, we can store + * non-user-visible processing instructions as regular properties. + */ + pp = ejsCreateSimpleNonUniqueProperty(ep, currentNode, E4X_PI_PROPERTY); + ejsMakePropertyEnumerable(pp, 1); + vp = ejsGetVarPtr(pp); + ejsWriteVarAsString(ep, vp, value); + ejsSetVarFlags(vp, EJS_XML_FLAGS_PI); + break; + + case EXML_COMMENT: + /* + * By using a property name with a leading space, we can store + * non- user-visible comments as regular properties. + */ + pp = ejsCreateSimpleNonUniqueProperty(ep, currentNode, + E4X_COMMENT_PROPERTY); + ejsMakePropertyEnumerable(pp, 1); + vp = ejsGetVarPtr(pp); + ejsWriteVarAsString(ep, vp, value); + ejsSetVarFlags(vp, EJS_XML_FLAGS_COMMENT); + break; + + case EXML_NEW_ELT: + if (parser->topOfStack > E4X_MAX_NODE_DEPTH) { + ejsError(ep, EJS_IO_ERROR, + "XML nodes nested too deeply in %s at line %d", + parser->fileName, exmlGetLineNumber(xp)); + return MPR_ERR_BAD_SYNTAX; + } + + name = mprStrdup(xp, tagName); + if (name == 0) { + return MPR_ERR_MEMORY; + } + + if (cleanTagName(name) < 0) { + ejsError(ep, EJS_TYPE_ERROR, "Bad XML tag name in %s at %d", + parser->fileName, exmlGetLineNumber(xp)); + mprFree(name); + return MPR_ERR_BAD_SYNTAX; + } + + pp = ejsCreateSimpleNonUniqueProperty(ep, currentNode, name); + ejsMakePropertyEnumerable(pp, 1); + + tagNode = ejsGetVarPtr(pp); + + /* MOB -- OPT */ + vpx = ejsCreateXml(ep); + vp = ejsWriteVar(ep, tagNode, vpx, EJS_SHALLOW_COPY); + ejsMakeObjLive(vp, 1); + ejsFreeVar(ep, vpx); + + /* MOB -- return code */ + pp = ejsSetPropertyToString(ep, vp, E4X_TAG_NAME_PROPERTY, name); + ejsMakePropertyEnumerable(pp, 0); + + ejsSetVarFlags(vp, EJS_XML_FLAGS_ELEMENT); + ejsMakePropertyEnumerable(ejsGetPropertyPtr(vp), 1); + + tos = &parser->nodeStack[++(parser->topOfStack)]; + currentNode = tos->obj = vp; + tos->attributes = 0; + tos->comments = 0; + mprFree(name); + break; + + case EXML_NEW_ATT: + if (mprAllocSprintf(MPR_LOC_ARGS(xp), &name, 0, "@%s", attName) < 0) { + return MPR_ERR_MEMORY; + } + pp = ejsCreateProperty(ep, currentNode, name); + ejsMakePropertyEnumerable(pp, 1); + + vp = ejsGetVarPtr(pp); + ejsWriteVarAsString(ep, vp, value); + ejsSetVarFlags(vp, EJS_XML_FLAGS_ATTRIBUTE); + mprFree(name); + break; + + case EXML_SOLO_ELT_DEFINED: + parser->topOfStack--; + mprAssert(parser->topOfStack >= 0); + tos = &parser->nodeStack[parser->topOfStack]; + break; + + case EXML_ELT_DEFINED: + if (parser->topOfStack > 0) { + parent = parser->nodeStack[parser->topOfStack - 1].obj; + ejsSetProperty(ep, currentNode, E4X_PARENT_PROPERTY, parent); + } + break; + + case EXML_ELT_DATA: + case EXML_CDATA: + pp = ejsCreateSimpleNonUniqueProperty(ep, currentNode, + E4X_TEXT_PROPERTY); + ejsMakePropertyEnumerable(pp, 1); + vp = ejsGetVarPtr(pp); + ejsWriteVarAsString(ep, vp, value); + ejsSetVarFlags(vp, EJS_XML_FLAGS_TEXT); + break; + + case EXML_END_ELT: + /* + * This is the closing element in a pair "<x>...</x>". + * Pop the stack frame off the elt stack + */ + parser->topOfStack--; + mprAssert(parser->topOfStack >= 0); + tos = &parser->nodeStack[parser->topOfStack]; + break; + + default: + ejsError(ep, EJS_IO_ERROR, "XML error in %s at %d\nDetails %s", + parser->fileName, exmlGetLineNumber(xp), exmlGetErrorMsg(xp)); + mprAssert(0); + return MPR_ERR_BAD_SYNTAX; + } + return 0; +} + +/******************************************************************************/ + +static char *cleanTagName(char *name) +{ + char *cp; + + for (cp = name; *cp; cp++) { + if (*cp == ':') { + *cp = '_'; + } else if (!isalnum(*cp) && *cp != '_' && *cp != '$' && *cp != '@') { + return 0; + } + } + return name; +} + +/******************************************************************************/ + +static int readFileData(Exml *xp, void *data, char *buf, int size) +{ + mprAssert(xp); + mprAssert(data); + mprAssert(buf); + mprAssert(size > 0); + + return mprRead((MprFile*) data, buf, size); +} + +/******************************************************************************/ + +static int readStringData(Exml *xp, void *data, char *buf, int size) +{ + XmlState *parser; + int rc, len; + + mprAssert(xp); + mprAssert(buf); + mprAssert(size > 0); + + parser = (XmlState*) xp->parseArg; + + if (parser->inputPos < parser->inputSize) { + len = min(size, (parser->inputSize - parser->inputPos)); + rc = mprMemcpy(buf, size, &parser->inputBuf[parser->inputPos], len); + parser->inputPos += len; + return rc; + } + return 0; +} + +/******************************************************************************/ + +static int save(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + const char *fileName; + MprBuf *buf; + MprFile *file; + int bytes, len; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ep, EJS_ARG_ERROR, "Bad args. Usage: save(fileName);"); + return -1; + } + fileName = argv[0]->string; + + /* MOB -- not romable + Need rom code in MPR not MprServices + */ + + /* + * Convert to a string + */ + buf = mprCreateBuf(ep, E4X_BUF_SIZE, E4X_BUF_MAX); + if (xmlToString(ep, buf, thisObj, -1) < 0) { + mprFree(buf); + return -1; + } + + file = mprOpen(ep, fileName, + O_CREAT | O_TRUNC | O_WRONLY | O_TEXT, 0664); + if (file == 0) { + ejsError(ep, EJS_IO_ERROR, "Can't open: %s, %d", fileName, + mprGetOsError()); + return -1; + } + + len = mprGetBufLength(buf); + bytes = mprWrite(file, buf->start, len); + if (bytes != len) { + ejsError(ep, EJS_IO_ERROR, "Can't write to: %s", fileName); + mprClose(file); + return -1; + } + mprWrite(file, "\n", 1); + mprFree(buf); + + mprClose(file); + + return 0; +} + +/******************************************************************************/ + +static int toString(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprBuf *buf; + + buf = mprCreateBuf(ep, E4X_BUF_SIZE, E4X_BUF_MAX); + + if (xmlToString(ep, buf, thisObj, -1) < 0) { + mprFree(buf); + return -1; + } + ejsWriteVarAsString(ep, ep->result, (char*) buf->start); + + mprFree(buf); + + return 0; +} + +/******************************************************************************/ +/* MOB -- need to support XMLList */ + +static int xmlToString(Ejs *ep, MprBuf *buf, EjsVar *obj, int indentLevel) +{ + EjsProperty *pp; + EjsVar *vp; + char *varBuf; + int endTag, sawElements; + + if (indentLevel < 0) { + mprPutStringToBuf(buf, "<?xml version=\"1.0\"?>"); + } + + switch (obj->type) { + case EJS_TYPE_STRING: + if (obj->flags & EJS_XML_FLAGS_ATTRIBUTE) { + mprPutFmtStringToBuf(buf, " %s=\"%s\"", + &ejsGetPropertyPtr(obj)->name[1], obj->string); + /* No new line */ + + } else if (obj->flags & EJS_XML_FLAGS_COMMENT) { + mprPutCharToBuf(buf, '\n'); + indent(buf, indentLevel); + mprPutFmtStringToBuf(buf, "<!-- %s -->", obj->string); + + } else if (obj->flags & EJS_XML_FLAGS_TEXT) { + mprPutStringToBuf(buf, obj->string); + + } else { +// indent(buf, indentLevel); + mprPutStringToBuf(buf, obj->string); +// mprPutCharToBuf(buf, '\n'); + } + break; + + default: + /* Primitive types come here */ + indent(buf, indentLevel); + /* MOB -- rc */ + varBuf = ejsVarToString(ep, obj); + mprPutStringToBuf(buf, varBuf); + break; + + case EJS_TYPE_OBJECT: + if (obj->objectState->baseClass == ejsGetClass(ep, 0, "XML")) { + if (!obj->objectState->visited) { + obj->objectState->visited = 1; + + /* MOB -- opt. Flags would be quicker */ + if (strcmp(ejsGetPropertyPtr(obj)->name, + E4X_PARENT_PROPERTY) == 0) { + return 0; + } + /* + * MOB -- short term fix for tags with no body but with + * attributes + */ + if (getNumElements(obj) == 0 && 0) { + /* + * XML element is simple with no elements, so return just + * the text. + */ + if (getText(buf, obj) < 0) { + ejsError(ep, EJS_IO_ERROR, + "XML is to big to convert to a string"); + obj->objectState->visited = 0; + return -1; + } + + } else if (obj->flags & (EJS_XML_FLAGS_ELEMENT)) { + /* + * XML object is complex (has elements) so return full XML + * content. + */ + mprPutCharToBuf(buf, '\n'); + indent(buf, indentLevel); + + /* + * When called from toString, obj is not a property + */ + if (indentLevel >= 0) { + mprPutFmtStringToBuf(buf, "<%s", + ejsGetPropertyPtr(obj)->name); + endTag = 0; + + } else { + endTag = 1; + } + + sawElements = 0; + pp = ejsGetFirstProperty(obj, 0); + while (pp) { + vp = ejsGetVarPtr(pp); + + if (! (vp->flags & EJS_XML_FLAGS_ATTRIBUTE)) { + if (endTag == 0) { + endTag++; + mprPutStringToBuf(buf, ">"); + } + } + if (vp->flags & EJS_XML_FLAGS_ELEMENT) { + if (strcmp(ejsGetPropertyPtr(vp)->name, + E4X_PARENT_PROPERTY) != 0) { + sawElements++; + } + } + + if (xmlToString(ep, buf, ejsGetVarPtr(pp), + indentLevel + 1) < 0){ + return -1; + } + + pp = ejsGetNextProperty(pp, 0); + } + if (indentLevel >= 0) { + if (sawElements) { + mprPutCharToBuf(buf, '\n'); + indent(buf, indentLevel); + } + mprPutFmtStringToBuf(buf, "</%s>", + ejsGetPropertyPtr(obj)->name); + } + } + obj->objectState->visited = 0; + } + return 0; + } + + if (obj->objectState->baseClass == ejsGetClass(ep, 0, "XMLList")) { + indent(buf, indentLevel); + /* MOB -- TBD */ + return 0; + } + + /* + * All other objects. Allow other objects to override toString + */ + if (ejsRunMethod(ep, obj->objectState->baseClass, "toString", + 0) < 0) { + return -1; + } + if (ejsVarIsString(ep->result)) { + indent(buf, indentLevel); + mprPutStringToBuf(buf, obj->string); + } + break; + } + return 0; +} + +/******************************************************************************/ + +static void indent(MprBuf *bp, int level) +{ + int i; + + for (i = 0; i < level; i++) { + mprPutCharToBuf(bp, '\t'); + } +} + +/******************************************************************************/ + +static int valueOf(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 0) { + mprAssert(0); + return -1; + } + + switch (thisObj->type) { + default: + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + case EJS_TYPE_CMETHOD: + case EJS_TYPE_OBJECT: + case EJS_TYPE_METHOD: + case EJS_TYPE_STRING_CMETHOD: + ejsWriteVar(ep, ep->result, thisObj, EJS_SHALLOW_COPY); + break; + + case EJS_TYPE_STRING: + ejsWriteVarAsInteger(ep, ep->result, atoi(thisObj->string)); + break; + + case EJS_TYPE_BOOL: + case EJS_TYPE_INT: +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: +#endif +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: +#endif + ejsWriteVar(ep, ep->result, thisObj, EJS_SHALLOW_COPY); + break; + } + return 0; +} + +/******************************************************************************/ + +static int getList(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + const char *nodeName; + EjsProperty *pp; + EjsVar *list, *vp; + + if (argc != 1) { + nodeName = 0; + } else { + nodeName = argv[0]->string; + } + + list = ejsCreateArray(ep, 0); + + pp = ejsGetFirstProperty(thisObj, EJS_ENUM_ALL); + while (pp) { + vp = ejsGetVarPtr(pp); + if (vp->type == EJS_TYPE_OBJECT) { + if (strcmp(ejsGetPropertyPtr(vp)->name, E4X_PARENT_PROPERTY) != 0) { + if (vp->flags & EJS_XML_FLAGS_ELEMENT && + (nodeName == 0 || strcmp(nodeName, pp->name) == 0)) { + ejsAddArrayElt(ep, list, vp, EJS_SHALLOW_COPY); + } + } + } + pp = ejsGetNextProperty(pp, EJS_ENUM_ALL); + } + + ejsSetReturnValueAndFree(ep, list); + return 0; +} + +/******************************************************************************/ + +static int getNumElements(EjsVar *obj) +{ + EjsProperty *pp; + int count; + + count = 0; + pp = ejsGetFirstProperty(obj, EJS_ENUM_ALL); + while (pp) { + if (ejsGetVarPtr(pp)->flags & EJS_XML_FLAGS_ELEMENT) { + count++; + } + pp = ejsGetNextProperty(pp, EJS_ENUM_ALL); + } + return count; +} + +/******************************************************************************/ +/* MOB - This needs to be a public method */ + +static int getText(MprBuf *buf, EjsVar *obj) +{ + EjsProperty *pp; + EjsVar *vp; + + pp = ejsGetFirstProperty(obj, EJS_ENUM_ALL); + while (pp) { + vp = ejsGetVarPtr(pp); + if (vp->flags & EJS_XML_FLAGS_TEXT) { + /* MOB -- should test for overflow */ + mprPutStringToBuf(buf, vp->string); + } + pp = ejsGetNextProperty(pp, EJS_ENUM_ALL); + } + return 0; +} + +/******************************************************************************/ +/******************************************************************************/ +/******************************** Internal Methods ****************************/ +/******************************************************************************/ + +static EjsVar *createXmlListProperty(Ejs *ep, EjsVar *obj, const char *property) +{ + return ejsGetVarPtr(ejsCreateProperty(ep, obj, property)); +} + +/******************************************************************************/ + +static int deleteXmlListProperty(Ejs *ep, EjsVar *obj, const char *property) +{ + return ejsDeleteProperty(ep, obj, property); +} + +/******************************************************************************/ + +static EjsVar *getXmlListProperty(Ejs *ep, EjsVar *obj, const char *property) +{ + // Must always return XML or XMLList event for comments and attributes + return ejsGetVarPtr(ejsGetSimpleProperty(ep, obj, property)); +} + +/******************************************************************************/ + +static EjsVar *setXmlListProperty(Ejs *ep, EjsVar *obj, const char *property, + const EjsVar *value) +{ + EjsProperty *pp; + EjsVar *vp; + + pp = ejsGetSimpleProperty(ep, obj, property); + if (pp == 0) { + mprAssert(pp); + return 0; + } + vp = ejsGetVarPtr(pp); + if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) < 0){ + mprAssert(0); + return 0; + } + return ejsGetVarPtr(pp); +} + +/******************************************************************************/ +/* + NEW + +static EjsVar *putXmlListProperty(EjsVar *op, const char *property, + EjsVar *value) +{ + + if ((value->objectState->baseClass != XML && + value->objectState->baseClass != XMLList) || + value->string[0] != '<') { + c = value.toString(); + } else { + value = ejsDupVar(value); + ?? + } + if (isdigit(*property)) { + // ERROR + return 0; + } + if (*property == '@') { + if (op->objectState->baseClass == XMLList) { + if (op->obj.LENGTH_PROPERTY == 0) { + c = ""; + } else { + // Catenate all result of toString on all elts in list + } + } else { + c = c.toString(); + } + // Replace existing attribute of same name or insert + return; + } + for (i = op->obj.LENGTH - 1; i >= 0; i--) { + // Delete item of same name + } + if (not Found) { + Append new Xml object + - set [[name]], [[class]] == "element" + } +} + + */ + +/******************************************************************************/ +#else +void ejs4xDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS_E4X */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/ejs.c b/source4/lib/appweb/ejs-2.0/ejs/ejs.c new file mode 100644 index 0000000000..0fcc6f0545 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/ejs.c @@ -0,0 +1,1378 @@ +/* + * @file ejs.c + * @brief Embedded JavaScript (EJS) + * @overview Main module interface logic. + * @remarks The initialization code must be run single-threaded. Includes: + * ejsOpen, ejsClose. + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/************************************* Code ***********************************/ +/* + * Initialize the EJS subsystem + */ + +EjsService *ejsOpenService(MprCtx ctx) +{ + EjsService *service; + Ejs *interp; + + service = mprAllocTypeZeroed(ctx, EjsService); + if (service == 0) { + mprError(ctx, MPR_LOC, "Can't allocate service memory"); + return 0; + } + + interp = ejsCreateInterp(service, 0, 0, 0, 1); + if (interp == 0) { + mprError(ctx, MPR_LOC, "Can't create master interpreter"); + mprFree(service); + return 0; + } + service->master = interp; + + /* + * Restore the default GC settings for the master interpreter. + * ejsCreateInterp will have initialized them. + */ + ejsGCInit(interp, EJS_DEFAULT_OBJ_INC, EJS_DEFAULT_PROP_INC, + EJS_DEFAULT_VAR_INC, EJS_DEFAULT_STR_INC); + + /* + * Save the default interpreter and global class for all to access + * MOB -- don't store these. Store the service + */ + mprSetKeyValue(interp, "ejsMaster", interp); + mprSetKeyValue(interp, "ejsGlobalClass", interp->global); + + /* + * Once the Object class is created, this routine will also make the + * Global class a subclass of Object. + */ + if (ejsDefineObjectClass(interp) < 0) { + mprError(ctx, MPR_LOC, "Can't define EJS object class"); + mprFree(service); + return 0; + } + + /* + * Create all the standard classes + */ + if (ejsDefineStandardClasses(interp) < 0) { + mprError(ctx, MPR_LOC, "Can't define EJS standard classes"); + mprFree(service); + return 0; + } + + if (ejsDefineSystemClasses(interp) < 0) { + mprError(ctx, MPR_LOC, "Can't define EJS system classes"); + mprFree(service); + return 0; + } + + if (ejsCreateObjectModel(interp) < 0) { + mprError(ctx, MPR_LOC, "Can't create EJS object model"); + mprFree(service); + return 0; + } + +#if UNUSED && BLD_FEATURE_ALLOC_STATS +{ + EjsVar v; + mprLog(ctx, 0, "Obj %d, Var %d, Prop %d\n", sizeof(EjsObj), sizeof(EjsVar), + sizeof(EjsProperty)); + mprLog(ctx, 0, "GCLink %d\n", sizeof(EjsGCLink)); + mprLog(ctx, 0, "objectState %d\n", (uint) &v.objectState - (uint) &v); +} +#endif + + return service; +} + +/******************************************************************************/ +/* + * Close down the EJS Service + */ + +void ejsCloseService(EjsService *sp, bool doStats) +{ + Ejs *ep; + + mprAssert(sp); + + ep = sp->master; + mprAssert(ep); + + ejsTermSystemClasses(ep); + + if (ep) { + ejsFreeVar(ep, sp->globalClass); + +#if BLD_FEATURE_ALLOC_STATS + if (doStats) { + mprLog(sp, 0, "GC Statistics for the Global Interpreter"); + } +#endif + ejsDestroyInterp(ep, doStats); + } + + mprRemoveKeyValue(sp, "ejsMaster"); + mprRemoveKeyValue(sp, "ejsGlobalClass"); + + mprFree(sp); +} + +/******************************************************************************/ + +Ejs *ejsGetMasterInterp(EjsService *sp) +{ + return sp->master; +} + +/******************************************************************************/ +#if BLD_FEATURE_MULTITHREAD + +int ejsSetServiceLocks(EjsService *sp, EjsLockFn lock, EjsUnlockFn unlock, + void *data) +{ + mprAssert(sp); + + sp->lock = lock; + sp->unlock = unlock; + sp->lockData = data; + return 0; +} + +#endif +/******************************************************************************/ +/* + * Create and initialize an EJS interpreter. Interpreters have a global object + * that has the service global class set as a base class. This way, it + * inherits all the desired global properties, methods and classes. + * + * The primary and alternate handles are provided to C methods depending on + * the flags provided when the C methods are defined. The global variable + * (optionally) defines a predefined global variable space. + */ + +Ejs *ejsCreateInterp(EjsService *sp, void *primaryHandle, void *altHandle, + EjsVar *global, bool useOwnSlab) +{ + EjsProperty *pp; + EjsVar *baseClass; + Ejs *ep; + + ep = mprAllocTypeZeroed(sp, Ejs); + if (ep == 0) { + mprAssert(0); + return ep; + } + + ep->stkPtr = &ep->stack[EJS_MAX_STACK]; + + ep->service = sp; + ep->primaryHandle = primaryHandle; + ep->altHandle = altHandle; + + if (sp->master) { + ep->objectClass = sp->master->objectClass; + } + + if (useOwnSlab) { + ep->slabs = (EjsSlab*) mprAllocZeroed(ep, sizeof(EjsSlab) * + EJS_SLAB_MAX); + ep->slabAllocContext = ep; + + } else { + ep->slabs = sp->master->slabs; + ep->slabAllocContext = sp->master; + ep->flags |= EJS_FLAGS_SHARED_SLAB; + } + + ep->frames = mprCreateItemArray(ep, EJS_INC_FRAMES, EJS_MAX_FRAMES); + if (ep->frames == 0) { + mprFree(ep); + return 0; + } + + ejsGCInit(ep, EJS_OBJ_INC, EJS_PROP_INC, EJS_VAR_INC, EJS_STR_INC); + + if (sp->globalClass == 0) { + /* + * Only do this for the Global interpreter. Create a global class + * (prototype) object. This is base class from which all global + * spaces will inherit. + */ + sp->globalClass = ejsCreateObjVar(ep); + if (sp->globalClass == 0) { + mprFree(ep); + return 0; + } + ejsSetClassName(ep, sp->globalClass, "Global"); + global = sp->globalClass; + } + + if (global) { + /* + * The default interpreter uses the Global class as its global + * space. + */ + ep->global = ejsDupVar(ep, global, EJS_SHALLOW_COPY); + if (ep->global == 0) { + mprFree(ep); + return 0; + } + if (ep->global->objectState != sp->globalClass->objectState) { + ejsSetBaseClass(ep->global, sp->globalClass); + } + + } else { + /* + * Use the global class as our global so we can find the object class + */ + baseClass = ejsGetClass(ep, sp->globalClass, "Object"); + if (baseClass) { + ep->global = ejsCreateSimpleObjUsingClass(ep, baseClass); + if (ep->global == 0) { + mprFree(ep); + return 0; + } + + /* + * Override the base class and set to the master Global class + */ + ejsSetBaseClass(ep->global, sp->globalClass); + + } else { + ep->global = ejsCreateObjVar(ep); + } + } + + /* + * The "global" variable points to the global space + */ + pp = ejsSetProperty(ep, ep->global, "global", ep->global); + if (pp == 0) { + mprFree(ep); + return 0; + } + ejsMakePropertyEnumerable(pp, 0); + + /* + * The "Global" variable points to the Global class + */ + pp = ejsSetProperty(ep, ep->global, "Global", sp->globalClass); + if (pp == 0) { + mprFree(ep); + return 0; + } + ejsMakePropertyEnumerable(pp, 0); + + ep->local = ejsDupVar(ep, ep->global, EJS_SHALLOW_COPY); + if (ep->frames == 0 || ep->global == 0 || ep->local == 0) { + mprFree(ep); + return 0; + } + ejsSetVarName(ep, ep->local, "topLevelLocal"); + + if (mprAddItem(ep->frames, ep->global) < 0 || + mprAddItem(ep->frames, ep->local) < 0) { + mprFree(ep); + return 0; + } + + ep->result = ejsCreateUndefinedVar(ep); + if (ep->result == 0) { + mprFree(ep); + return 0; + } + + return ep; +} + +/******************************************************************************/ +/* + * Close an EJS interpreter + */ + +void ejsDestroyInterp(Ejs *ep, bool doStats) +{ + ejsCleanInterp(ep, doStats); + + mprFree(ep); +} + +/******************************************************************************/ +/* + * Clean an EJS interpreter of all allocated variables, but DONT destroy. + * We use this rather than DestroyInterp so we delay freeing the Ejs struct + * until after the service is closed. + */ + +void ejsCleanInterp(Ejs *ep, bool doStats) +{ + int i; + + if (ep->global) { + ejsDeleteProperty(ep, ep->local, "global"); + ejsDeleteProperty(ep, ep->global, "global"); + ep->global = 0; + } + if (ep->local) { + ejsFreeVar(ep, ep->local); + ep->local = 0; + } + if (ep->global) { + ejsFreeVar(ep, ep->global); + ep->global = 0; + } + if (ep->result) { + ejsFreeVar(ep, ep->result); + ep->result = 0; + } + if (ep->castAlloc && ep->castTemp) { + mprFree(ep->castTemp); + ep->castTemp = 0; + } + if (ep->frames) { + for (i = ep->frames->length - 1; i >= 0; i--) { + mprRemoveItemByIndex(ep->frames, i); + } + mprFree(ep->frames); + ep->frames = 0; + } + + if (doStats) { + +#if BLD_FEATURE_ALLOC_STATS + mprLog(ep, 0, " "); + mprLog(ep, 0, "GC Statistics for Interpreter (0x%X)", (uint) ep); +#endif + + /* + * Cleanup before printing the alloc report + */ + ejsSetGCDebugLevel(ep, 3); + ejsCollectGarbage(ep, -1); + +#if BLD_DEBUG + /* + * If we are the master, dump objects + */ + if (ep->service->master == ep) { + ejsDumpObjects(ep); + } +#endif + +#if BLD_FEATURE_ALLOC_STATS + /* + * Print an alloc report. 1 == do leak report + */ + ejsPrintAllocReport(ep, 1); +#endif + + } else { + /* + * Must collect garbage here incase sharing interpreters with the + * master. If we don't, the mprFree later in DestroyInterp will free + * all memory and when the master does GC --> crash. + */ + ejsCollectGarbage(ep, -1); + } +} + +/******************************************************************************/ +/* + * Evaluate an EJS script file. This will evaluate the script at the current + * context. Ie. if inside a function, declarations will be local. + */ + +int ejsEvalFile(Ejs *ep, const char *path, EjsVar *result) +{ + MprFile *file; + MprFileInfo info; + char *script; + char *saveFileName; + int rc; + + mprAssert(path && *path); + + if ((file = mprOpen(ep, path, O_RDONLY | O_BINARY, 0666)) == 0) { + ejsError(ep, EJS_IO_ERROR, "Can't open %s", path); + return -1; + } + + if (mprGetFileInfo(ep, path, &info) < 0) { + ejsError(ep, EJS_IO_ERROR, "Can't get file info for %s", path); + goto error; + } + + if ((script = (char*) mprAlloc(ep, info.size + 1)) == NULL) { + ejsError(ep, "MemoryError", "Cant malloc %d", (int) info.size); + goto error; + } + + if (mprRead(file, script, info.size) != (int) info.size) { + mprFree(script); + ejsError(ep, EJS_IO_ERROR, "Error reading %s", path); + goto error; + } + mprClose(file); + script[info.size] = '\0'; + + saveFileName = ep->fileName; + ep->fileName = mprStrdup(ep, path); + + rc = ejsEvalScript(ep, script, result); + mprFree(script); + + mprFree(ep->fileName); + ep->fileName = saveFileName; + + return rc; + +/* + * Error return + */ +error: + mprClose(file); + return -1; +} + +/******************************************************************************/ +/* + * Create a new variable scope block. This pushes the old local frame down + * the stack and creates a new local variables frame. + */ + +int ejsOpenBlock(Ejs *ep) +{ + EjsProperty *pp; + int fid; + + ep->local = ejsCreateSimpleObj(ep, "Object"); + ejsSetVarName(ep, ep->local, "local"); + + if (ep->local == 0) { + ejsMemoryError(ep); + return -1; + } + + if (ep->frames->length > EJS_MAX_FRAMES && !ep->gotException) { + ejsError(ep, EJS_RANGE_ERROR, "Recursion too deep: Max depth %d", + EJS_MAX_FRAMES); + return -1; + } + + /* + * Must add to frames before ejsSetProperty which will make the object live + */ + fid = mprAddItem(ep->frames, ep->local); + if (fid < 0) { + ejsMemoryError(ep); + return -1; + } + + /* Self reference */ + pp = ejsSetProperty(ep, ep->local, "local", ep->local); + ejsMakePropertyEnumerable(pp, 0); + + return fid; +} + +/******************************************************************************/ +/* + * Set a new variable scope block. This pushes the old local frame down + * the stack and creates a new local variables frame. + */ + +int ejsSetBlock(Ejs *ep, EjsVar *local) +{ + ep->local = ejsDupVar(ep, local, EJS_SHALLOW_COPY); + ejsMakeObjPermanent(ep->local, 1); + return mprAddItem(ep->frames, ep->local); +} + +/******************************************************************************/ +/* + * Close a variable scope block opened via ejsOpenBlock. Pop back the old + * local variables frame. + */ + +int ejsCloseBlock(Ejs *ep, int fid) +{ + mprAssert(ep->local >= 0); + mprAssert(fid >= 0); + + mprAssert(ep->local == (EjsVar*) mprGetItem(ep->frames, fid)); + + if (ep->local) { + /* Allow GC */ + ejsMakeObjPermanent(ep->local, 0); + ejsFreeVar(ep, ep->local); + } + + mprRemoveItemByIndex(ep->frames, fid); + + ep->local = (EjsVar*) mprGetItem(ep->frames, + mprGetItemCount(ep->frames) - 1); + + return 0; +} + +/******************************************************************************/ +/* + * Create a new variable scope block and evaluate a script. All frames + * created during this context will be automatically deleted when complete. + * vp is optional. i.e. created local variables will be discarded + * when this routine returns. + */ + +int ejsEvalBlock(Ejs *ep, char *script, EjsVar *vp) +{ + int rc, fid; + + mprAssert(script); + + fid = ejsOpenBlock(ep); + if (fid < 0) { + return fid; + } + + rc = ejsEvalScript(ep, script, vp); + + ejsCloseBlock(ep, fid); + + return rc; +} + +/******************************************************************************/ +/* + * Parse and evaluate a EJS. The script is evaluated at the current context. + * Return the result in *vp. The result is "owned" by EJ and the caller + * must not free it. Returns -1 on errors and zero for success. + */ + +int ejsEvalScript(Ejs *ep, const char *script, EjsVar *vp) +{ + int state; + + ejsClearVar(ep, ep->result); + ep->gotException = 0; + + if (script == 0) { + return 0; + } + + /* + * Allocate a new evaluation block, and save the old one + */ + if (ejsLexOpenScript(ep, script) < 0) { + return MPR_ERR_MEMORY; + } + + /* + * Do the actual parsing and evaluation + */ + ep->scriptStatus = 0; + + do { + state = ejsParse(ep, EJS_STATE_BEGIN, EJS_FLAGS_EXE); + + if (state == EJS_STATE_RET) { + state = EJS_STATE_EOF; + } + } while (state != EJS_STATE_EOF && state != EJS_STATE_ERR); + + ejsLexCloseScript(ep); + + if (state == EJS_STATE_ERR) { + return -1; + } + + if (vp) { + /* Caller must not free. */ + *vp = *ep->result; + } + + return ep->scriptStatus; +} + +/******************************************************************************/ + +void ejsSetFileName(Ejs *ep, const char *fileName) +{ + mprFree(ep->fileName); + ep->fileName = mprStrdup(ep, fileName); +} + +/******************************************************************************/ +/* + * Format the stack backtrace + */ + +char *ejsFormatStack(Ejs* ep) +{ + EjsInput *ip; + char *errbuf; + int frame, len; + + mprAssert(ep); + + ip = ep->input; + + errbuf = 0; + + len = 0; + frame = 0; + while (ip && frame < EJS_MAX_BACKTRACE) { + char *traceLine, *newErrbuf, *line; + for (line = ip->line; *line && isspace(*line); line++) { + ; + } + mprAllocSprintf(MPR_LOC_ARGS(ep), &traceLine, MPR_MAX_STRING, + " [%02d] %s, %s, line %d -> %s\n", + frame++, + ip->fileName ? ip->fileName : "script", + ip->procName ? ip->procName: "global", + ip->lineNumber, line); + if (traceLine == 0) { + break; + } + newErrbuf = mprRealloc(ep, errbuf, len + strlen(traceLine) + 1); + if (newErrbuf == NULL) { + break; + } + errbuf = newErrbuf; + memcpy(&errbuf[len], traceLine, strlen(traceLine) + 1); + len += strlen(traceLine); + mprFree(traceLine); + ip = ip->next; + } + return errbuf; +} + +/******************************************************************************/ +/* + * Internal use method to set the error message + * + * Error, ArgError, AssertError, IOError, MemoryError, RangeError, + * ReferenceError, SyntaxError, TypeError, MemoryError + */ + +void ejsError(Ejs* ep, const char *errorType, const char* fmt, ...) +{ + va_list fmtArgs; + EjsVar *error; + char *msg, *stack; + + va_start(fmtArgs, fmt); + mprAllocVsprintf(MPR_LOC_ARGS(ep), &msg, MPR_MAX_STRING, fmt, fmtArgs); + va_end(fmtArgs); + + /* + * Create a new Error exception object. If bad error type, default to + * "Error" + */ + if (ejsGetClass(ep, 0, errorType) == 0) { + errorType = "Error"; + } + ep->gotException = 1; + + error = ejsCreateObj(ep, 0, errorType, msg); + if (error == 0) { + return; + } + mprFree(msg); + + stack = ejsFormatStack(ep); + ejsSetPropertyToString(ep, error, "stack", stack); + mprFree(stack); + + ejsWriteVar(ep, ep->result, error, EJS_SHALLOW_COPY); + ejsFreeVar(ep, error); +} + +/******************************************************************************/ + +void ejsSyntaxError(Ejs *ep, const char *msg) +{ + if (msg == 0) { + msg = " "; + } + ejsError(ep, EJS_SYNTAX_ERROR, msg); +} + +/******************************************************************************/ + +void ejsMemoryError(Ejs *ep) +{ + ejsError(ep, EJS_MEMORY_ERROR, "Memory allocation error"); +} + +/******************************************************************************/ + +void ejsArgError(Ejs *ep, const char *msg) +{ + mprAssert(msg && *msg); + + ejsError(ep, EJS_ARG_ERROR, msg); +} + +/******************************************************************************/ + +void ejsInternalError(Ejs *ep, const char *msg) +{ + mprAssert(msg && *msg); + + ejsError(ep, EJS_INTERNAL_ERROR, msg); +} + +/******************************************************************************/ +/* + * Public routine to set the error message. Caller MUST NOT free. + */ + +char *ejsGetErrorMsg(Ejs *ep) +{ + EjsVar *error; + const char *message, *stack, *name; + char *buf; + + error = ep->result; + + if (! ejsVarIsObject(error)) { + name = message = stack = 0; + } else { + name = ejsGetPropertyAsString(ep, error, "name"); + message = ejsGetPropertyAsString(ep, error, "message"); + stack = ejsGetPropertyAsString(ep, error, "stack"); + } + if (name == 0 || message == 0) { + buf = mprStrdup(ep, "Unspecified execution error\n"); + } else { + mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, + "%s Exception: %s\nStack:\n%s\n", + name, message, stack ? stack : " " ); + } + mprFree(ep->errorMsg); + ep->errorMsg = buf; + return buf; +} + +/******************************************************************************/ +/* + * Get the current line number + */ + +int ejsGetLineNumber(Ejs *ep) +{ + if (ep->input == 0) { + return -1; + } + return ep->input->lineNumber; +} + +/******************************************************************************/ +/* + * Return the local object + */ + +EjsVar *ejsGetLocalObj(Ejs *ep) +{ + return ep->local; +} + +/******************************************************************************/ +/* + * Return the global object + */ + +EjsVar *ejsGetGlobalObj(Ejs *ep) +{ + return ep->global; +} + +/******************************************************************************/ +/* + * Set the expression return value + */ + +void ejsSetReturnValue(Ejs *ep, EjsVar *vp) +{ + mprAssert(ep); + mprAssert(vp); + + if (vp == 0) { + return; + } + ejsWriteVar(ep, ep->result, vp, EJS_SHALLOW_COPY); +} + +/******************************************************************************/ +/* + * Set the expression return value and free the arg. + */ + +void ejsSetReturnValueAndFree(Ejs *ep, EjsVar *vp) +{ + mprAssert(ep); + mprAssert(vp); + + ejsWriteVar(ep, ep->result, vp, EJS_SHALLOW_COPY); + ejsFreeVar(ep, vp); +} + +/******************************************************************************/ +/* + * Set the expression return value to a string value. + */ + +void ejsSetReturnValueToString(Ejs *ep, const char *value) +{ + mprAssert(ep); + mprAssert(value); + + ejsWriteVarAsString(ep, ep->result, value); +} + +/******************************************************************************/ +/* + * Set the expression return value to a binary string value. + */ + +void ejsSetReturnValueToBinaryString(Ejs *ep, const uchar *value, int len) +{ + mprAssert(ep); + mprAssert(value); + + ejsWriteVarAsBinaryString(ep, ep->result, value, len); +} + +/******************************************************************************/ +/* + * Set the expression return value to a integer value. + */ + +void ejsSetReturnValueToInteger(Ejs *ep, int value) +{ + mprAssert(ep); + + ejsWriteVarAsInteger(ep, ep->result, value); +} + +/******************************************************************************/ +/* + * Set the expression return value to an EjsNum value. + */ + +void ejsSetReturnValueToNumber(Ejs *ep, EjsNum value) +{ + mprAssert(ep); + + ejsWriteVarAsNumber(ep, ep->result, value); +} + +/******************************************************************************/ +/* + * Set the expression return value to a boolean value. + */ + +void ejsSetReturnValueToBoolean(Ejs *ep, int value) +{ + mprAssert(ep); + + ejsWriteVarAsBoolean(ep, ep->result, value); +} + +/******************************************************************************/ +/* + * Set the expression return value to a boolean value. + */ + +void ejsSetReturnValueToUndefined(Ejs *ep) +{ + mprAssert(ep); + + ejsWriteVarAsUndefined(ep, ep->result); +} + +/******************************************************************************/ +/* + * Get the expression return value + */ + +EjsVar *ejsGetReturnValue(Ejs *ep) +{ + mprAssert(ep); + + return ep->result; +} + +/******************************************************************************/ + +void *ejsGetUserData(Ejs *ep) +{ + mprAssert(ep); + + return ep->userData; +} + +/******************************************************************************/ +/* + * Get a variable given a full variable spec possibly containing "." or "[]". + */ + +EjsVar *ejsGetVar(Ejs *ep, const char *fullName) +{ + mprAssert(ep); + mprAssert(fullName && *fullName); + + return ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 0); +} + +/******************************************************************************/ +/* + * Get a string var given a full variable spec possibly containing "." or "[]". + */ + +const char *ejsGetStr(Ejs *ep, const char *fullName, const char *defaultValue) +{ + EjsVar *vp; + + mprAssert(fullName && *fullName); + + vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 0); + if (vp == 0 || !ejsVarIsString(vp)) { + return defaultValue; + } + /* MOB -- what about VarToStr */ + return vp->string; +} + +/******************************************************************************/ +/* + * Get an int var given a full variable spec possibly containing "." or "[]". + */ + +int ejsGetInt(Ejs *ep, const char *fullName, int defaultValue) +{ + EjsVar *vp; + + mprAssert(ep); + mprAssert(fullName && *fullName); + + vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 0); + if (vp == 0 || !ejsVarIsInteger(vp)) { + return defaultValue; + } + /* MOB -- should use VarToInt */ + return vp->integer; +} + +/******************************************************************************/ +/* + * Get an bool var given a full variable spec possibly containing "." or "[]". + */ + +int ejsGetBool(Ejs *ep, const char *fullName, int defaultValue) +{ + EjsVar *vp; + + mprAssert(ep); + mprAssert(fullName && *fullName); + + vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 0); + if (vp == 0 || !ejsVarIsBoolean(vp)) { + return defaultValue; + } + /* MOB -- should use VarToBool */ + return vp->boolean; +} + +/******************************************************************************/ +/* + * Set a variable that may be an arbitrarily complex object or array reference. + * Will always define in the top most variable frame. + */ + +int ejsSetVar(Ejs *ep, const char *fullName, const EjsVar *value) +{ + EjsVar *vp; + + mprAssert(fullName && *fullName); + + vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1); + if (vp == 0) { + return MPR_ERR_CANT_CREATE; + } + + if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) == 0) { + return MPR_ERR_CANT_WRITE; + } + + return 0; +} + +/******************************************************************************/ +/* + * Set a variable that may be an arbitrarily complex object or array reference. + * Will always define in the top most variable frame. + */ + +int ejsSetStr(Ejs *ep, const char *fullName, const char *value) +{ + EjsVar *vp; + + mprAssert(fullName && *fullName); + + vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1); + if (vp == 0) { + return MPR_ERR_CANT_CREATE; + } + + if (ejsWriteVarAsString(ep, vp, value) == 0) { + return MPR_ERR_CANT_WRITE; + } + + return 0; +} + +/******************************************************************************/ +/* + * Set a variable that may be an arbitrarily complex object or array reference. + * Will always define in the top most variable frame. + */ + +int ejsSetInt(Ejs *ep, const char *fullName, int value) +{ + EjsVar *vp; + + mprAssert(fullName && *fullName); + + vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1); + if (vp == 0) { + return MPR_ERR_CANT_CREATE; + } + + /* Can't fail */ + ejsWriteVarAsInteger(ep, vp, value); + + return 0; +} + +/******************************************************************************/ +/* + * Set a variable that may be an arbitrarily complex object or array reference. + * Will always define in the top most variable frame. + */ + +int ejsSetBool(Ejs *ep, const char *fullName, bool value) +{ + EjsVar *vp; + + mprAssert(fullName && *fullName); + + vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1); + if (vp == 0) { + return MPR_ERR_CANT_CREATE; + } + + /* Can't fail */ + ejsWriteVarAsBoolean(ep, vp, value); + + return 0; +} + +/******************************************************************************/ +/* + * Set a variable that may be an arbitrarily complex object or array reference. + * Will always define in the top most variable frame. Free the value passed in. + */ + +int ejsSetVarAndFree(Ejs *ep, const char *fullName, EjsVar *value) +{ + EjsVar *vp; + + mprAssert(fullName && *fullName); + + vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1); + if (vp == 0) { + return MPR_ERR_CANT_CREATE; + } + + if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) == 0) { + ejsFreeVar(ep, value); + return MPR_ERR_CANT_WRITE; + } + + ejsFreeVar(ep, value); + return 0; +} + +/******************************************************************************/ +/* + * Delete a variable + */ + +int ejsDeleteVar(Ejs *ep, const char *fullName) +{ + EjsVar *vp; + EjsVar *obj; + char *propertyName; + + vp = ejsFindProperty(ep, &obj, &propertyName, ep->global, ep->local, + fullName, 0); + if (vp == 0) { + return -1; + } + + mprAssert(propertyName); + mprAssert(propertyName); + + return ejsDeleteProperty(ep, obj, propertyName); +} + +/******************************************************************************/ +/* + * Utility routine to crack JavaScript arguments. Return the number of args + * seen. This routine only supports %s and %d type args. + * + * Typical usage: + * + * if (ejsParseArgs(argc, argv, "%s %d", &name, &age) < 2) { + * // Insufficient args + * return -1; + * } + */ + +int ejsParseArgs(int argc, char **argv, const char *fmt, ...) +{ + va_list vargs; + const char *cp; + char **sp, *s; + int *bp, *ip, argn; + + va_start(vargs, fmt); + + if (argv == 0) { + return 0; + } + + for (argn = 0, cp = fmt; cp && *cp && argn < argc && argv[argn]; ) { + if (*cp++ != '%') { + continue; + } + + s = argv[argn]; + switch (*cp) { + case 'b': + bp = va_arg(vargs, int*); + if (bp) { + if (strcmp(s, "true") == 0 || s[0] == '1') { + *bp = 1; + } else { + *bp = 0; + } + } else { + *bp = 0; + } + break; + + case 'd': + ip = va_arg(vargs, int*); + *ip = atoi(s); + break; + + case 's': + sp = va_arg(vargs, char**); + *sp = s; + break; + + default: + mprAssert(0); + } + argn++; + } + + va_end(vargs); + return argn; +} + +/******************************************************************************/ +/* + * Define the standard classes + */ + +int ejsDefineStandardClasses(Ejs *master) +{ + if (ejsDefineArrayClass(master) != 0 || + ejsDefineBooleanClass(master) != 0 || + ejsDefineErrorClasses(master) != 0 || + ejsDefineFunctionClass(master) != 0 || + ejsDefineNumberClass(master) != 0 || +#if FUTURE + ejsDefineDateClass(master) != 0 || +#endif +#if BLD_FEATURE_EJS_E4X + ejsDefineXmlClasses(master) != 0 || +#endif +#if BLD_FEATURE_EJS_DB && NOT_HERE + ejsDefineDbClasses(master) != 0 || +#endif + ejsDefineStringClass(master) != 0) { + return MPR_ERR_MEMORY; + } + return 0; +} + +/******************************************************************************/ +/* + * Define the EJS System Object Model + */ + +int ejsDefineSystemClasses(Ejs *master) +{ + if (ejsDefineSystemClass(master) != 0 || + ejsDefineAppClass(master) != 0 || + ejsDefineMemoryClass(master) != 0 || + ejsDefineLogClass(master) != 0 || + ejsDefineDebugClass(master) != 0 || + ejsDefineGCClass(master) != 0 || + ejsDefineFileSystemClass(master) != 0 || +#if BREW + ejsDefineFileClass(master) != 0 || + ejsDefineHTTPClass(master) != 0 || +#endif + ejsDefineGlobalProperties(master) != 0) { + return MPR_ERR_MEMORY; + } + return 0; +} + +/******************************************************************************/ +/* + * Terminate the system object model and classes + */ + +int ejsTermSystemClasses(Ejs *master) +{ +#if BREW + ejsTermHTTPClass(master); +#endif + return 0; +} + +/******************************************************************************/ +/* + * Define the EJS object model + */ + +int ejsCreateObjectModel(Ejs *ejs) +{ + EjsProperty *pp; + + pp = ejsSetPropertyToNewObj(ejs, ejs->global, "system", "System", 0); + if (pp == 0) { + return MPR_ERR_MEMORY; + } + + if (ejsSetPropertyToNewObj(ejs, ejsGetVarPtr(pp), "app", "System.App", + 0) == 0) { + return MPR_ERR_MEMORY; + } + return 0; +} + +/******************************************************************************/ + +void ejsTrace(Ejs *ep, const char *fmt, ...) +{ + va_list args; + char buf[MPR_MAX_LOG_STRING]; + int len; + + va_start(args, fmt); + len = mprVsprintf(buf, sizeof(buf) - 1, fmt, args); + va_end(args); + + mprLog(ep, 0, buf, len); + + va_end(args); +} + +/******************************************************************************/ + +bool ejsGotException(Ejs *ep) +{ + return (bool) ep->gotException; +} + +/******************************************************************************/ + +void ejsSetPrimaryHandle(Ejs *ep, void *primaryHandle) +{ + mprAssert(ep); + + ep->primaryHandle = primaryHandle; +} + +/******************************************************************************/ + +void ejsSetAlternateHandle(Ejs *ep, void *alternateHandle) +{ + mprAssert(ep); + + ep->altHandle = alternateHandle; +} + +/******************************************************************************/ + +#else +void ejsDummy() {} + +#endif /* BLD_FEATURE_EJS */ + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/ejs.h b/source4/lib/appweb/ejs-2.0/ejs/ejs.h new file mode 100644 index 0000000000..a926446524 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/ejs.h @@ -0,0 +1,849 @@ +/* + * ejs.h - EJScript Language (ECMAScript) header. + */ + +/********************************* Copyright **********************************/ +/* + * @copy default.g + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. + * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved. + * Portions Copyright (c) GoAhead Software, 1995-2000. 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 + */ +/********************************** Includes **********************************/ + +#ifndef _h_EJS +#define _h_EJS 1 + +#include "mpr.h" +#include "ejsVar.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/********************************* Prototypes *********************************/ +/* + * Constants + */ +#if BLD_FEATURE_SQUEEZE + #define EJS_GC_WORK_QUOTA 160 /* Allocations required before + garbage colllection */ + + #define EJS_PARSE_INCR 256 /* Growth factor */ + #define EJS_MAX_RECURSE 25 /* Sanity for maximum recursion */ + #define EJS_SMALL_OBJ_HASH_SIZE 11 /* Small object hash size */ + #define EJS_LIST_INCR 8 /* Growth increment for lists */ + #define EJS_MAX_BACKTRACE 10 /* Recursion limit for assert */ + +#else + #define EJS_GC_WORK_QUOTA 500 + + #define EJS_PARSE_INCR 1024 + #define EJS_MAX_RECURSE 100 + #define EJS_SMALL_OBJ_HASH_SIZE 11 + #define EJS_LIST_INCR 16 + #define EJS_MAX_BACKTRACE 25 + +#endif + +/* + * Allocation increments for the default interpreter + */ +#define EJS_DEFAULT_VAR_INC 8 /* Var allocation increment */ +#define EJS_DEFAULT_PROP_INC 96 /* Property allocation increment */ +#define EJS_DEFAULT_OBJ_INC 24 /* Object allocation increment */ +#define EJS_DEFAULT_STR_INC 64 /* Object allocation increment */ + +#define EJS_MIN_TIME_FOR_GC 300 /**< Need 1/3 sec for GC */ +#define EJS_GC_MIN_WORK_QUOTA 50 /**< Min to stop thrashing */ + +/* + * Allocation increments for all non-default interpreters + */ +#define EJS_VAR_INC 32 +#define EJS_PROP_INC 64 +#define EJS_OBJ_INC 64 +#define EJS_STR_INC 64 + +#define EJS_INC_FRAMES 8 /* Frame stack increment */ +#define EJS_MAX_FRAMES 64 /* Max frame stack */ + +/* + * Lexical analyser tokens + */ +#define EJS_TOK_ERR -1 /* Any error */ +#define EJS_TOK_LPAREN 1 /* ( */ +#define EJS_TOK_RPAREN 2 /* ) */ +#define EJS_TOK_IF 3 /* if */ +#define EJS_TOK_ELSE 4 /* else */ +#define EJS_TOK_LBRACE 5 /* { */ +#define EJS_TOK_RBRACE 6 /* } */ +#define EJS_TOK_LOGICAL 7 /* ||, &&, ! */ +#define EJS_TOK_EXPR 8 /* +, -, /, % */ +#define EJS_TOK_SEMI 9 /* ; */ +#define EJS_TOK_LITERAL 10 /* literal string */ +#define EJS_TOK_METHOD_NAME 11 /* methodName( */ +#define EJS_TOK_NEWLINE 12 /* newline white space */ +#define EJS_TOK_ID 13 /* Identifier */ +#define EJS_TOK_EOF 14 /* End of script */ +#define EJS_TOK_COMMA 15 /* Comma */ +#define EJS_TOK_VAR 16 /* var */ +#define EJS_TOK_ASSIGNMENT 17 /* = */ +#define EJS_TOK_FOR 18 /* for */ +#define EJS_TOK_INC_DEC 19 /* ++, -- */ +#define EJS_TOK_RETURN 20 /* return */ +#define EJS_TOK_PERIOD 21 /* . */ +#define EJS_TOK_LBRACKET 22 /* [ */ +#define EJS_TOK_RBRACKET 23 /* ] */ +#define EJS_TOK_NEW 24 /* new */ +#define EJS_TOK_DELETE 25 /* delete */ +#define EJS_TOK_IN 26 /* in */ +#define EJS_TOK_FUNCTION 27 /* function */ +#define EJS_TOK_NUMBER 28 /* Number */ +#define EJS_TOK_CLASS 29 /* class */ +#define EJS_TOK_EXTENDS 30 /* extends */ +#define EJS_TOK_PUBLIC 31 /* public */ +#define EJS_TOK_PRIVATE 32 /* private */ +#define EJS_TOK_PROTECTED 33 /* private */ +#define EJS_TOK_TRY 34 /* try */ +#define EJS_TOK_CATCH 35 /* catch */ +#define EJS_TOK_FINALLY 36 /* finally */ +#define EJS_TOK_THROW 37 /* throw */ +#define EJS_TOK_COLON 38 /* : */ +#define EJS_TOK_GET 39 /* get */ +#define EJS_TOK_SET 40 /* set */ +#define EJS_TOK_MODULE 41 /* module */ +#define EJS_TOK_EACH 42 /* each */ + +/* + * Expression operators + */ +#define EJS_EXPR_LESS 1 /* < */ +#define EJS_EXPR_LESSEQ 2 /* <= */ +#define EJS_EXPR_GREATER 3 /* > */ +#define EJS_EXPR_GREATEREQ 4 /* >= */ +#define EJS_EXPR_EQ 5 /* == */ +#define EJS_EXPR_NOTEQ 6 /* != */ +#define EJS_EXPR_PLUS 7 /* + */ +#define EJS_EXPR_MINUS 8 /* - */ +#define EJS_EXPR_DIV 9 /* / */ +#define EJS_EXPR_MOD 10 /* % */ +#define EJS_EXPR_LSHIFT 11 /* << */ +#define EJS_EXPR_RSHIFT 12 /* >> */ +#define EJS_EXPR_MUL 13 /* * */ +#define EJS_EXPR_ASSIGNMENT 14 /* = */ +#define EJS_EXPR_INC 15 /* ++ */ +#define EJS_EXPR_DEC 16 /* -- */ +#define EJS_EXPR_BOOL_COMP 17 /* ! */ + +/* + * Conditional operators + */ +#define EJS_COND_AND 1 /* && */ +#define EJS_COND_OR 2 /* || */ +#define EJS_COND_NOT 3 /* ! */ + +/** + * EJ Parsing States. Error and Return are be negative. + */ +#define EJS_STATE_ERR -1 /**< Error state */ +#define EJS_STATE_RET -2 /**< Return statement */ +#define EJS_STATE_EOF -3 /**< End of file */ +#define EJS_STATE_COND 2 /* Parsing a conditional stmt */ +#define EJS_STATE_COND_DONE 3 +#define EJS_STATE_RELEXP 4 /* Parsing a relational expr */ +#define EJS_STATE_RELEXP_DONE 5 +#define EJS_STATE_EXPR 6 /* Parsing an expression */ +#define EJS_STATE_EXPR_DONE 7 +#define EJS_STATE_STMT 8 /* Parsing General statement */ +#define EJS_STATE_STMT_DONE 9 +#define EJS_STATE_STMT_BLOCK_DONE 10 /* End of block "}" */ +#define EJS_STATE_ARG_LIST 11 /* Method arg list */ +#define EJS_STATE_ARG_LIST_DONE 12 +#define EJS_STATE_DEC_LIST 16 /* Declaration list */ +#define EJS_STATE_DEC_LIST_DONE 17 +#define EJS_STATE_DEC 18 /* Declaration statement */ +#define EJS_STATE_DEC_DONE 19 + +#define EJS_STATE_BEGIN EJS_STATE_STMT + +/* + * General parsing flags. + */ +#define EJS_FLAGS_EXE 0x1 /* Execute statements */ +#define EJS_FLAGS_LOCAL 0x2 /* Get local vars only */ +#define EJS_FLAGS_GLOBAL 0x4 /* Get global vars only */ +#define EJS_FLAGS_CREATE 0x8 /* Create var */ +#define EJS_FLAGS_ASSIGNMENT 0x10 /* In assignment stmt */ +#define EJS_FLAGS_DELETE 0x20 /* Deleting a variable */ +#define EJS_FLAGS_NEW 0x80 /* In a new stmt() */ +#define EJS_FLAGS_EXIT 0x100 /* Must exit */ +#define EJS_FLAGS_LHS 0x200 /* Left-hand-side of assignment */ +#define EJS_FLAGS_FORIN 0x400 /* In "for (v in ..." */ +#define EJS_FLAGS_CLASS_DEC 0x800 /* "class name [extends] name " */ +#define EJS_FLAGS_TRY 0x2000 /* In a try {} block */ +#define EJS_FLAGS_CATCH 0x4000 /* "catch (variable)" */ +#define EJS_FLAGS_DONT_GC 0x8000 /* Don't garbage collect */ +#define EJS_FLAGS_NO_ARGS 0x10000 /* Accessors don't use args */ +#define EJS_FLAGS_ENUM_HIDDEN 0x20000 /* Enumerate hidden fields */ +#define EJS_FLAGS_ENUM_BASE 0x40000 /* Enumerate base classes */ +#define EJS_FLAGS_TRACE_ARGS 0x80000 /* Support for printv */ +#define EJS_FLAGS_SHARED_SLAB 0x100000/* Using a shared slab */ + +/* + * Exceptions + */ +#define EJS_ARG_ERROR "ArgError" /**< Method argument error */ +#define EJS_ASSERT_ERROR "AssertError" /**< Assertion error */ +#define EJS_EVAL_ERROR "EvalError" /**< General evalation error */ +#define EJS_INTERNAL_ERROR "InternalError" /**< Internal error */ +#define EJS_IO_ERROR "IOError" /**< IO or data error */ +#define EJS_MEMORY_ERROR "MemoryError" /**< Memory allocation error */ +#define EJS_RANGE_ERROR "RangeError" /**< Data out of range (div by 0) */ +#define EJS_REFERENCE_ERROR "ReferenceError"/**< Object or property reference */ +#define EJS_SYNTAX_ERROR "SyntaxError" /**< Javascript syntax error */ +#define EJS_TYPE_ERROR "TypeError" /**< Wrong type supplied */ + +/* + * E4X + */ +#if BLD_FEATURE_EJS_E4X +#if BLD_FEATURE_SQUEEZE +#define E4X_BUF_SIZE 512 /* Initial buffer size for tokens */ +#define E4X_BUF_MAX (32 * 1024) /* Max size for tokens */ +#define E4X_MAX_NODE_DEPTH 24 /* Max nesting of tags */ +#else +#define E4X_BUF_SIZE 4096 +#define E4X_BUF_MAX (128 * 1024) +#define E4X_MAX_NODE_DEPTH 128 +#endif + +#define E4X_MAX_ELT_SIZE (E4X_BUF_MAX-1) +#define E4X_TEXT_PROPERTY "-txt" +#define E4X_TAG_NAME_PROPERTY "-tag" +#define E4X_COMMENT_PROPERTY "-com" +#define E4X_ATTRIBUTES_PROPERTY "-att" +#define E4X_PI_PROPERTY "-pi" +#define E4X_PARENT_PROPERTY "-parent" +#endif + +#if BLD_FEATURE_MULTITHREAD +/** + * Multithreaded lock function + */ +typedef void (*EjsLockFn)(void *lockData); +/** + * Multithreaded unlock function + */ +typedef void (*EjsUnlockFn)(void *lockData); +#endif + +/* + * Token limits + */ +#define EJS_MAX_LINE 128 /* Maximum input line buffer */ +#define EJS_MAX_TOKEN 640 /* Max input parse token */ +#define EJS_TOKEN_STACK 3 /* Put back token stack */ + +/* + * Putback token + */ + +typedef struct EjsToken { + char tokbuf[EJS_MAX_TOKEN]; + int tid; /* Token ID */ +} EjsToken; + +/* + * EJ evaluation block structure + */ +typedef struct EjsInput { + EjsToken putBack[EJS_TOKEN_STACK]; /* Put back token stack */ + int putBackIndex; /* Top of stack index */ + char line[EJS_MAX_LINE]; /* Current line */ + char *fileName; /* File or script name */ + int lineLength; /* Current line length */ + int lineNumber; /* Parse line number */ + int lineColumn; /* Column in line */ + struct EjsInput *next; /* Used for backtraces */ + const char *procName; /* Gives name in backtrace */ + const char *script; /* Input script for parsing */ + char *scriptServp; /* Next token in the script */ + int scriptSize; /* Length of script */ + char tokbuf[EJS_MAX_TOKEN]; /* Current token */ + int tid; /* Token ID */ + char *tokEndp; /* Pointer past end of token */ + char *tokServp; /* Pointer to next token char */ + struct EjsInput *nextInput; /* Free list of input structs */ +} EjsInput; + +/* + * Method call structure + */ +typedef struct EjsProc { + MprArray *args; /* Args for method */ + EjsVar *fn; /* Method definition */ + char *procName; /* Method name */ +} EjsProc; + + +/** + * @overview EJScript Service structure + * @description The EJScript service manages the overall language runtime. It + * is the factory that creates interpreter instances via ejsCreateInterp. + * The EJScript service creates a master interpreter that holds the + * standard language classes and properties. When user interpreters are + * created, they reference (without copying) the master interpreter to + * gain access to the standard classes and types. + * @stability Prototype. + * @library libejs. + * @see ejsOpenService, ejsCloseService, ejsCreateInterp, ejsDestoryInterp + */ +typedef struct EjsService { + EjsVar *globalClass; /* Global class */ + struct Ejs *master; /* Master Interp inherited by all */ +#if BLD_FEATURE_MULTITHREAD + EjsLockFn lock; + EjsUnlockFn unlock; + void *lockData; +#endif +} EjsService; + + +/* + * Memory statistics + */ +typedef struct EjsMemStats { + uint maxMem; + uint usedMem; +} EjsMemStats; + + +/* + * Garbage collection block alignment + */ +#define EJS_ALLOC_ALIGN(ptr) \ + (((ptr) + sizeof(void*) - 1) & ~(sizeof(void*) - 1)) + +/* + * Default GC tune factors + */ +#define EJS_GC_START_THRESHOLD (32 * 1024) + +/* + * The Garbage collector is a generational collector. It ages blocks and + * optimizes the mark / sweep algorithm to focus on new and recent blocks + */ +typedef enum EjsGeneration { + EJS_GEN_NEW = 0, + EJS_GEN_RECENT_1 = 1, + EJS_GEN_RECENT_2 = 2, + EJS_GEN_OLD = 3, + EJS_GEN_PERMANENT = 4, + EJS_GEN_MAX = 5, +} EjsGeneration; + +/* + * Garbage collector control + */ +typedef struct EjsGC { + bool enable; + bool enableDemandCollect; + bool enableIdleCollect; + /* + * maxMemory should be set to be 95% of the real max memory limit + */ + uint maxMemory; /* Above this, Throw Memory exception. */ + int workQuota; /* Quota of work before GC */ + int workDone; /* Count of allocations */ + int degraded; /* Have exceeded maxMemory */ + + /* + * Debug Levels 0-N (increases verbosity) + * 1 -- Sweep and collection count + * 2 -- Trace objects deleted + * 3 -- Trace objects marked + * 4 -- Print alloc report when needing a demand allocation + * + */ + int debugLevel; /* In debug mode */ + int collecting; /* Running garbage collection */ + uint collectionCount; /* Number of times GC ran */ +#if BLD_DEBUG + int gcIndent; /* Indent formatting */ + int objectsInUse; /* Objects currently reachable */ + int propertiesInUse; /* Properties currently reachable */ +#endif +} EjsGC; + +/* + * Slab memory allocation + */ +typedef struct EjsSlab { + uint allocIncrement; /* Growth increment in slab */ + uint size; /* Size of allocations */ + EjsGCLink freeList; /* Free list (only next ptr is used) */ + EjsObj *lastRecentBlock; /* Saved for GC age generations phase */ + EjsGCLink allocList[EJS_GEN_MAX]; /* Allocated block list */ + +#if BLD_FEATURE_ALLOC_STATS + uint totalAlloc; /* Total count of allocation calls */ + uint freeCount; /* Number of blocks on the slab freelist */ + uint allocCount; /* Number of allocated blocks */ + uint peakAllocated; /* Peak allocated */ + uint peakFree; /* Peak on the free list */ + uint totalReclaimed; /* Total blocks reclaimed on sweeps */ + uint totalSweeps; /* Total sweeps */ +#endif +} EjsSlab; + + +/** + * @overview EJ interpreter control structure. + * @description EJ allocates one control structure per active interpreter. + * The \ref ejsCreateInterp routine creates the Ejs structure and returns + * a reference to be used in subsequent EJ API calls. + * @stability Prototype. + * @library libejs. + * @see ejsCreateInterp, ejsDestroyInterp, ejsOpenService + */ +struct Ejs { + void *altHandle; /* Alternate callback handle */ + bool castAlloc; /* True if castTemp is allocated */ + char *castTemp; /* Temporary string for casting */ + char *currentClass; /* Current class name */ + EjsVar *currentObj; /* Ptr to current object */ + EjsVar *thisObject; /* Ptr to current "this" */ + EjsProperty *currentProperty; /* Ptr to current property */ + EjsGC gc; /* Garbage collector control */ + char *errorMsg; /* Error message */ + char *fileName; /* File or script name */ + int lineNumber; /* File line number */ + int scriptStatus; /* Status to exit() */ + int flags; /* Flags */ + MprArray *frames; /* List of variable frames */ + EjsVar *global; /* Global object */ + EjsVar *objectClass; /* Object class */ + int gotException; /* Exception thrown */ + EjsInput *input; /* Input evaluation block */ + int depth; /* Recursion depth */ + EjsVar *local; /* Local object */ + int maxDepth; /* Maximum depth for formatting */ + void *primaryHandle; /* primary callback handle */ + EjsProc *proc; /* Current method */ + int recurseCount; /* Recursion counter */ + EjsVar *result; /* Variable result */ + int tid; /* Current token id */ + char *token; /* Pointer to token string */ + EjsVar tokenNumber; /* Parsed number */ + EjsService *service; /* Service object */ + void *userData; /* Method user data */ + + EjsSlab *slabs; /* Memory allocation slabs */ + MprCtx slabAllocContext; /* Allocation context */ + EjsInput *inputList; /* Free list of input structs */ + +#if BLD_FEATURE_MULTITHREAD + EjsLockFn lock; /* Lock method */ + EjsUnlockFn unlock; /* Unlock method */ + void *lockData; /* Lock data argument */ +#endif +#define EJS_MAX_STACK (10 * 1024) + char stack[EJS_MAX_STACK]; /* Local variable stack */ + char *stkPtr; /* Local variable stack ptr */ + void *inputMarker; /* Recurse protection */ +}; + + +typedef struct EjsModule +{ + int dummy; +} EjsModule; + + +/* + * Method callback when using Alternate handles. GaCompat uses these and + * passes the web server request structure via the altHandle. + */ +typedef void *EjsHandle; +typedef int (*EjsAltCMethod)(Ejs *ejs, EjsHandle altHandle, + EjsVar *thisObj, int argc, EjsVar **argv); +typedef int (*EjsAltStringCMethod)(Ejs *ejs, EjsHandle altHandle, + EjsVar *thisObj, int argc, char **argv); + + +/* + * API Constants + */ +#define EJS_USE_OWN_SLAB 1 + +/******************************** Internal API ********************************/ +/* + * Ejs Lex + */ +extern int ejsLexOpenScript(Ejs *ejs, const char *script); +extern void ejsLexCloseScript(Ejs *ejs); +extern int ejsInitInputState(EjsInput *ip); +extern void ejsLexSaveInputState(Ejs *ejs, EjsInput* state); +extern void ejsLexFreeInputState(Ejs *ejs, EjsInput* state); +extern void ejsLexRestoreInputState(Ejs *ejs, EjsInput* state); +extern int ejsLexGetToken(Ejs *ejs, int state); +extern void ejsLexPutbackToken(Ejs *ejs, int tid, char *string); + +/* + * Parsing + */ +extern int ejsParse(Ejs *ejs, int state, int flags); +extern int ejsGetFlags(Ejs *ejs); + +/* + * Create variable scope blocks + */ +extern int ejsOpenBlock(Ejs *ejs); +extern int ejsSetBlock(Ejs *ejs, EjsVar *local); +extern int ejsCloseBlock(Ejs *ejs, int vid); +extern int ejsEvalBlock(Ejs *ejs, char *script, EjsVar *vp); +extern void ejsSetFileName(Ejs *ejs, const char *fileName); + +/* + * Class definitions + */ +extern EjsVar *ejsCreateSimpleClass(Ejs *ejs, EjsVar *baseClass, + const char *className); +extern int ejsDefineObjectClass(Ejs *ejs); +extern int ejsDefineArrayClass(Ejs *ejs); +extern int ejsDefineBooleanClass(Ejs *ejs); +extern int ejsDefineErrorClasses(Ejs *ejs); +extern int ejsDefineFileClass(Ejs *ejs); +extern int ejsDefineFileSystemClass(Ejs *ejs); +extern int ejsDefineHTTPClass(Ejs *ejs); +extern int ejsDefineFunctionClass(Ejs *ejs); +extern int ejsDefineNumberClass(Ejs *ejs); +extern int ejsDefineStringClass(Ejs *ejs); +extern int ejsDefineDateClass(Ejs *ejs); +extern int ejsDefineStandardClasses(Ejs *ejs); + +#if BLD_FEATURE_EJS_E4X +extern int ejsDefineXmlClasses(Ejs *ejs); +extern EjsVar *ejsCreateXml(Ejs *ejs); +#endif + +#if BLD_FEATURE_EJS_DB +extern int ejsDefineDbClasses(Ejs *ejs); +#endif + +/* + * System class definitions + */ +extern int ejsDefineSystemClasses(Ejs *ejs); +extern int ejsDefineSystemClass(Ejs *ejs); +extern int ejsDefineAppClass(Ejs *ejs); +extern int ejsDefineDebugClass(Ejs *ejs); +extern int ejsDefineLogClass(Ejs *ejs); +extern int ejsDefineMemoryClass(Ejs *ejs); +extern int ejsDefineGCClass(Ejs *ejs); +extern int ejsDefineGlobalProperties(Ejs *ejs); + +extern int ejsTermSystemClasses(Ejs *ejs); +extern void ejsTermHTTPClass(Ejs *ejs); + +extern int ejsCreateObjectModel(Ejs *ejs); + +/* + * Class constructors + */ +extern int ejsArrayConstructor(Ejs *ejs, EjsVar *thisObj, int argc, + EjsVar **argv); +extern int ejsXmlConstructor(Ejs *ejs, EjsVar *thisObj, int argc, + EjsVar **argv); +extern int ejsXmlListConstructor(Ejs *ejs, EjsVar *thisObj, int argc, + EjsVar **argv); +extern int ejsBooleanConstructor(Ejs *ejs, EjsVar *thisObj, int argc, + EjsVar **agv); +extern int ejsFunctionConstructor(Ejs *ejs, EjsVar *thisObj, int argc, + EjsVar **agv); +extern int ejsNumberConstructor(Ejs *ejs, EjsVar *thisObj, int argc, + EjsVar **argv); +extern int ejsStringConstructor(Ejs *ejs, EjsVar *thisObj, int argc, + EjsVar **argv); +extern int ejsDateConstructor(Ejs *ejs, EjsVar *thisObj, + int argc, EjsVar **argv); + +/* + * Garbage collection + */ +extern void ejsGCInit(Ejs *ejs, int objInc, int propInc, int varInc, + int strInc); +extern int ejsIsTimeForGC(Ejs *ep, int timeTillNextEvent); + +extern bool ejsSetGCDebugLevel(Ejs *ep, int debugLevel); +extern void ejsSweepAll(Ejs *ep); + +extern EjsObj *ejsAllocObj(EJS_LOC_DEC(ejs, loc)); +extern EjsProperty *ejsAllocProperty(EJS_LOC_DEC(ejs, loc)); +extern EjsVar *ejsAllocVar(EJS_LOC_DEC(ejs, loc)); +extern void ejsFree(Ejs *ejs, void *ptr, int slabIndex); + +extern int ejsCollectGarbage(Ejs *ejs, int slabIndex); +extern int ejsIncrementalCollectGarbage(Ejs *ejs); + +#if BLD_DEBUG +extern void ejsDumpObjects(Ejs *ejs); +#endif + +#if BLD_FEATURE_ALLOC_STATS +extern void ejsPrintAllocReport(Ejs *ejs, bool printLeakReport); +#endif + +extern void ejsCleanInterp(Ejs *ejs, bool doStats); +extern void ejsSetInternalMethods(Ejs *ejs, EjsVar *op); +extern void ejsSetPrimaryHandle(Ejs *ep, void *primaryHandle); +extern void ejsSetAlternateHandle(Ejs *ep, void *alternateHandle); +extern void *ejsGetUserData(Ejs *ejs); + +/* + * Could possibly make these routines public + */ + +extern int ejsSetGCMaxMemory(Ejs *ep, uint maxMemory); +extern uint ejsGetUsedMemory(Ejs *ejs); +extern uint ejsGetAllocatedMemory(Ejs *ejs); +extern uint ejsGetAvailableMemory(Ejs *ejs); +extern char *ejsFormatStack(Ejs* ep);; + +/********************************* Prototypes *********************************/ +#if BLD_FEATURE_MULTITHREAD +extern int ejsSetServiceLocks(EjsService *sp, EjsLockFn lock, + EjsUnlockFn unlock, void *data); +#endif + +/* + * Ejs service and interpreter management + */ +extern EjsService *ejsOpenService(MprCtx ctx); +extern void ejsCloseService(EjsService *sp, bool doStats); + +extern Ejs *ejsCreateInterp(EjsService *sp, void *primaryHandle, + void *altHandle, EjsVar *global, bool useOwnSlab); +extern void ejsDestroyInterp(Ejs *ejs, bool doStats); + +extern Ejs *ejsGetMasterInterp(EjsService *sp); +extern EjsVar *ejsGetGlobalClass(Ejs *ejs); + +/* + * Module support + */ +extern EjsModule *ejsCreateModule(const char *name, const char *version, + int (*start)(EjsModule*), int (*stop)(EjsModule*)); + +/* + * Native Objects + */ + +void ejsSetNativeData(EjsVar *obj, void *data); +void ejsSetNativeHelpers(Ejs *ejs, EjsVar *nativeClass, + int (*createInstance)(Ejs *ejs, EjsVar *thisObj, int argc, + EjsVar **argv), + void (*disposeInstance)(Ejs *ejs, EjsVar *thisObj), + bool (*hasProperty)(Ejs *ejs, EjsVar *thisObj, const char *prop), + int (*deleteProperty)(Ejs *ejs, EjsVar *thisObj, const char *prop), + int (*getProperty)(Ejs *ejs, EjsVar *thisObj, const char *prop, + EjsVar *dest), + int (*setProperty)(Ejs *ejs, EjsVar *thisObj, const char *prop, + EjsVar *value), + int (*doOperator)(Ejs *ejs, EjsVar *thisObj, EjsOp *op, EjsVar + *result, EjsVar *lhs, EjsVar *rhs, int *code) + ); + +/* + * Evaluation methods + */ +extern int ejsEvalFile(Ejs *ejs, const char *path, EjsVar *result); +extern int ejsEvalScript(Ejs *ejs, const char *script, EjsVar *result); +extern int ejsRunMethod(Ejs *ejs, EjsVar *obj, + const char *methodName, MprArray *args); +extern int ejsRunMethodCmd(Ejs *ejs, EjsVar *obj, + const char *methodName, const char *cmdFmt, ...); +extern EjsVar *ejsGetReturnValue(Ejs *ejs); + +extern EjsVar *ejsGetLocalObj(Ejs *ejs); +extern EjsVar *ejsGetGlobalObj(Ejs *ejs); + +/* + * Define a class in the specified interpreter. If used with the default + * interpeter, then the class is defined for all interpreters. + */ +extern EjsVar *ejsDefineClass(Ejs *ejs, const char *className, + const char *extends, EjsCMethod constructor); +extern EjsVar *ejsGetClass(Ejs *ejs, EjsVar *parentClass, + const char *className); + +extern const char *ejsGetClassName(EjsVar *obj); +extern const char *ejsGetBaseClassName(EjsVar *obj); + +extern bool ejsIsSubClass(EjsVar *target, EjsVar *baseClass); +extern EjsVar *ejsGetBaseClass(EjsVar *obj); +extern void ejsSetBaseClass(EjsVar *obj, EjsVar *baseClass); + + +#define ejsCreateSimpleObj(ejs, className) \ + ejsCreateSimpleObjInternal(EJS_LOC_ARGS(ejs), className) +extern EjsVar *ejsCreateSimpleObjInternal(EJS_LOC_DEC(ejs, loc), + const char *className); + +#define ejsCreateSimpleObjUsingClass(ejs, baseClass) \ + ejsCreateSimpleObjUsingClassInt(EJS_LOC_ARGS(ejs), \ + baseClass) +extern EjsVar *ejsCreateSimpleObjUsingClassInt(EJS_LOC_DEC(ejs, loc), + EjsVar *baseClass); + +/* + * This will create an object and call all required constructors + */ +extern EjsVar *ejsCreateObj(Ejs *ejs, EjsVar *obj, + const char *className, const char *constructorArgs); + +#define ejsCreateObjUsingArgv(ejs, obj, className, args) \ + ejsCreateObjUsingArgvInternal(EJS_LOC_ARGS(ejs), obj, \ + className, args) +extern EjsVar *ejsCreateObjUsingArgvInternal(EJS_LOC_DEC(ejs, loc), + EjsVar *obj, const char *className, MprArray *args); + +#define ejsCreateArray(ejs, size) \ + ejsCreateArrayInternal(EJS_LOC_ARGS(ejs), size) +extern EjsVar *ejsCreateArrayInternal(EJS_LOC_DEC(ejs, loc), + int size); + +/* + * Array methods. MOB -- need other array methods + */ +/* MOB -- spell out element */ +extern EjsVar *ejsAddArrayElt(Ejs *ejs, EjsVar *op, EjsVar *element, + EjsCopyDepth copyDepth); +/* + * Required: Array methods + * + array = obj.getMethods(); + array = obj.getProperties(); + + array.property.isPublic(); + array.property.isPrivate(); + array.property.isMethod(); + array.property.isEnumerable(); + array.property.isReadOnly(); + array.property.allowsNonUnique(); + array.property.getParent(); +*/ + +/* MOB -- should we have an API that takes a EjsCopyDepth */ +extern void ejsSetReturnValue(Ejs *ejs, EjsVar *vp); +extern void ejsSetReturnValueAndFree(Ejs *ejs, EjsVar *vp); +extern void ejsSetReturnValueToBoolean(Ejs *ejs, bool value); +extern void ejsSetReturnValueToBinaryString(Ejs *ejs, + const uchar *value, int len); +extern void ejsSetReturnValueToInteger(Ejs *ejs, int value); +extern void ejsSetReturnValueToNumber(Ejs *ejs, EjsNum value); +extern void ejsSetReturnValueToString(Ejs *ejs, const char *value); +extern void ejsSetReturnValueToUndefined(Ejs *ejs); + +/* + * Variable access and control. The fullName arg can contain "[]" and "." + */ +extern bool ejsGetBool(Ejs *ejs, const char *fullName, bool defaultValue); +extern int ejsGetInt(Ejs *ejs, const char *fullName, int defaultValue); +extern const char *ejsGetStr(Ejs *ejs, const char *fullName, + const char *defaultValue); +extern EjsVar *ejsGetVar(Ejs *ejs, const char *fullName); + +extern int ejsSetBool(Ejs *ejs, const char *fullName, bool value); +extern int ejsSetInt(Ejs *ejs, const char *fullName, int value); +extern int ejsSetStr(Ejs *ejs, const char *fullName, const char *value); +extern int ejsSetVar(Ejs *ejs, const char *fullName, const EjsVar *value); +extern int ejsSetVarAndFree(Ejs *ejs, const char *fullName, EjsVar *value); + +extern int ejsDeleteVar(Ejs *ejs, const char *fullName); + +/* + * Error handling + */ +extern void ejsError(Ejs *ejs, const char *errorType, const char *fmt, + ...) PRINTF_ATTRIBUTE(3,4); +/* MOB -- this should take no arguments */ +extern void ejsArgError(Ejs *ejs, const char *msg); +extern void ejsInternalError(Ejs *ejs, const char *msg); +extern void ejsMemoryError(Ejs *ejs); +extern void ejsSyntaxError(Ejs *ejs, const char *msg); + +/* + * Utility methods + */ +extern int ejsParseArgs(int argc, char **argv, const char *fmt, ...); + +extern void ejsExit(Ejs *ejs, int status); +extern bool ejsIsExiting(Ejs *ejs); +extern void ejsClearExiting(Ejs *ejs); + +extern bool ejsGotException(Ejs *ejs); + +/* MOB -- rename Method to Function */ +extern void ejsFreeMethodArgs(Ejs *ep, MprArray *args); +extern int ejsStrcat(Ejs *ep, EjsVar *dest, EjsVar *src); + +/* + * Debugging routines + */ +extern char *ejsGetErrorMsg(Ejs *ejs); +extern int ejsGetLineNumber(Ejs *ejs); +extern void ejsTrace(Ejs *ejs, const char *fmt, ...); + +/* + * Multithreaded lock routines + */ +#if BLD_FEATURE_MULTITHREAD +#define ejsLock(sp) if (sp->lock) { (sp->lock)(sp->lockData); } else +#define ejsUnlock(sp) if (sp->unlock) { (sp->unlock)(sp->lockData); } else +#else +#define ejsLock(sp) +#define ejsUnlock(sp) +#endif + +#ifdef __cplusplus +} +#endif +#endif /* _h_EJS */ + +/*****************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/ejsClass.c b/source4/lib/appweb/ejs-2.0/ejs/ejsClass.c new file mode 100644 index 0000000000..58609adf3f --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/ejsClass.c @@ -0,0 +1,273 @@ +/* + * @file ejsClass.c + * @brief EJS class support + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************* Includes ***********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/************************************ Code ************************************/ +/* + * Internal API + * + * Routine to create a simple class object. This routine will create a + * stand-alone class object. Callers must insert this into the relevant + * "global" object for name resolution. From these class objects, instance + * objects may be created via the javascript "new" command. + * + * Users should use ejsDefineClass + */ + +EjsVar *ejsCreateSimpleClass(Ejs *ep, EjsVar *baseClass, const char *className) +{ + EjsProperty *pp; + EjsVar *classObj; + + /* + * Create an instance of an Object to act as the static class object + */ + classObj = ejsCreateSimpleObjUsingClass(ep, baseClass); + if (classObj == 0) { + mprAssert(classObj); + return 0; + } + ejsSetClassName(ep, classObj, className); + + /* + * Set the propotype property to point to this class. + * Note: this is a self reference so the alive bit will not be turned on. + */ + pp = ejsSetProperty(ep, classObj, "prototype", classObj); + ejsMakePropertyEnumerable(pp, 0); + + return classObj; +} + +/******************************************************************************/ +/* + * Define a class in the given interpreter. If parentClass is specified, the + * class is defined in the parent. Otherwise, the class will be defined + * locally/globally. ClassName and extends are full variable specs + * (may contain ".") + */ + +EjsVar *ejsDefineClass(Ejs *ep, const char *className, const char *extends, + EjsCMethod constructor) +{ + EjsVar *parentClass, *classObj, *baseClass, *vp; + char *name; + char *cp; + + /* + * If the className is a qualified name (with "."), then get the + * parent class name. + */ + name = mprStrdup(ep, className); + cp = strrchr(name, '.'); + if (cp != 0) { + *cp++ = '\0'; + className = cp; + parentClass = ejsFindProperty(ep, 0, 0, ep->global, ep->local, name, 0); + if (parentClass == 0 || parentClass->type != EJS_TYPE_OBJECT) { + mprError(ep, MPR_LOC, "Can't find class's parent class %s", name); + mprFree(name); + return 0; + } + + } else { + /* + * Simple class name without a "." so create the class locally + * if a local scope exists, otherwise globally. + */ + parentClass = (ep->local) ? ep->local : ep->global; + } + + if (parentClass == 0) { + mprError(ep, MPR_LOC, "Can't find parent class"); + mprFree(name); + return 0; + } + + /* OPT should use function that doesn't parse [] . */ + baseClass = ejsGetClass(ep, 0, extends); + if (baseClass == 0) { + mprAssert(baseClass); + mprFree(name); + return 0; + } + + classObj = ejsCreateSimpleClass(ep, baseClass, className); + if (classObj == 0) { + mprAssert(classObj); + mprFree(name); + return 0; + } + + if (constructor) { + ejsDefineCMethod(ep, classObj, className, constructor, 0); + } + + ejsSetPropertyAndFree(ep, parentClass, className, classObj); + + vp = ejsGetPropertyAsVar(ep, parentClass, className); + mprFree(name); + + return vp; +} + +/******************************************************************************/ +/* + * Find a class and return the property defining the class. ClassName may + * contain "." and is interpreted relative to obj. Obj is typically some + * parent object, ep->local or ep->global. If obj is null, then the global + * space is used. + */ + +EjsVar *ejsGetClass(Ejs *ep, EjsVar *obj, const char *className) +{ + EjsVar *vp; + + mprAssert(ep); + + /* + * Search first for a constructor of the name of class + * global may not be defined yet. + */ + if (obj) { + vp = ejsFindProperty(ep, 0, 0, obj, 0, className, 0); + + } else { + mprAssert(ep->global); + vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, className, 0); + } + if (vp == 0 || vp->type != EJS_TYPE_OBJECT) { + return 0; + } + + /* + * Return a reference to the prototype (self) reference. This + * ensures that even if "obj" is deleted, this reference will remain + * usable. + */ + return ejsGetPropertyAsVar(ep, vp, "prototype"); +} + +/******************************************************************************/ +/* + * Return the class name of a class or object + */ + +const char *ejsGetClassName(EjsVar *vp) +{ + EjsObj *obj; + + mprAssert(vp); + mprAssert(vp->type == EJS_TYPE_OBJECT); + mprAssert(vp->objectState->baseClass); + + if (vp == 0 || !ejsVarIsObject(vp)) { + return 0; + } + obj = vp->objectState; + + return obj->className; +} + +/******************************************************************************/ +/* + * Return the class name of an objects underlying class + * If called on an object, it returns the base class. + * If called on a class, it returns the base class for the class. + */ + +const char *ejsGetBaseClassName(EjsVar *vp) +{ + EjsObj *obj; + + mprAssert(vp); + mprAssert(vp->type == EJS_TYPE_OBJECT); + mprAssert(vp->objectState->baseClass); + + if (vp == 0 || !ejsVarIsObject(vp)) { + return 0; + } + obj = vp->objectState; + if (obj->baseClass == 0) { + return 0; + } + mprAssert(obj->baseClass->objectState); + + return obj->baseClass->objectState->className; +} + +/******************************************************************************/ + +EjsVar *ejsGetBaseClass(EjsVar *vp) +{ + if (vp == 0 || !ejsVarIsObject(vp) || vp->objectState == 0) { + mprAssert(0); + return 0; + } + return vp->objectState->baseClass; +} + +/******************************************************************************/ + +void ejsSetBaseClass(EjsVar *vp, EjsVar *baseClass) +{ + if (vp == 0 || !ejsVarIsObject(vp) || vp->objectState == 0) { + mprAssert(0); + return; + } + vp->objectState->baseClass = baseClass; +} + +/******************************************************************************/ + +#else +void ejsProcsDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/ejsCmd.c b/source4/lib/appweb/ejs-2.0/ejs/ejsCmd.c new file mode 100644 index 0000000000..b5279c949a --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/ejsCmd.c @@ -0,0 +1,468 @@ +/* + * @file ejsCmd.c + * @brief Embedded JavaScript (EJS) command line program. + * @overview + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS && !BREW + +/************************************ Defines *********************************/ + +#define EJS_MAX_CMD_LINE (16 * 1024) +#define EJS_MAX_SCRIPT (4 * 1024 * 1024) +#define EJS_MAX_RESULT_SIZE (4 * 1024 * 1024) +#define EJS_PROMPT "ejs> " + +/****************************** Forward Declarations **************************/ + +static int parseFile(EjsService *ejsService, Ejs *ejs, const char *fileName, + const char *testName, MprFile *testLogFile); +static int ifConsole(); + +static int interactiveUse(MprApp *app, Ejs *ejs, FILE *input, + char *fileName); +static char *readCmd(MprApp *app, FILE *input); + +static int memoryFailure(MprApp *app, uint size, uint total, bool granted); + +static int isConsole = 0; +static int traceCmds = 0; +static int stats = 0; +static int verbose = 0; + +/************************************ Main ************************************/ + +int main(int argc, char *argv[]) +{ + MprApp *app; + const char *programName; + MprFile *testLogFile; + EjsService *ejsService; + Ejs *ejs; + char *commandLine; + const char *testName; + char *argp, *cmd, *testLog; + int i, rc, nextArg, err, len, firstArg, iterations, debugLevel; + + app = mprInit(memoryFailure); + + isConsole = ifConsole(); + programName = mprGetBaseName(argv[0]); + debugLevel = 0; + + ejsService = ejsOpenService(app); + if (ejsService == 0) { + mprError(app, MPR_LOC, "Can't initialize the EJS service."); + return -1; + } + + err = 0; + iterations = 1; + stats = 0; + testLog = getenv("TEST_LOG"); + testLogFile = 0; + testName = 0; + + for (nextArg = 1; nextArg < argc; nextArg++) { + argp = argv[nextArg]; + if (*argp != '-') { + break; + } + if (strcmp(argp, "--debug") == 0) { + if (nextArg >= argc) { + err++; + } else { + debugLevel = atoi(argv[++nextArg]); + } + + } else if (strcmp(argp, "--stats") == 0) { + stats++; + + } else if (strcmp(argp, "--trace") == 0) { + traceCmds++; + + } else if (strcmp(argp, "--iterations") == 0) { + if (nextArg >= argc) { + err++; + } else { + iterations = atoi(argv[++nextArg]); + } + + } else if (strcmp(argp, "--log") == 0) { + /* Get file to log test results to when using ejs as a test shell */ + if (nextArg >= argc) { + err++; + } else { + testLog = argv[++nextArg]; + } + + } else if (strcmp(argp, "--testName") == 0) { + if (nextArg >= argc) { + err++; + } else { + testName = argv[++nextArg]; + } + + } else if (strcmp(argp, "-v") == 0) { + verbose++; + + } else if (strcmp(argp, "-vv") == 0) { + verbose += 2; + + } else if (strcmp(argp, "--verbose") == 0) { + verbose += 2; + + } else { + err++; + break; + } + if (err) { + mprErrorPrintf(app, + "Usage: %s [options] files... or\n" + " %s < file or\n" + " %s or\n" + " Switches:\n" + " --iterations num # Number of iterations to eval file\n" + " --stats # Output stats on exit\n" + " --testName name # Set the test name", + programName, programName, programName); + return -1; + } + } + + if (testName) { + i = 0; + commandLine = 0; + len = mprAllocStrcat(MPR_LOC_ARGS(app), &commandLine, 0, " ", + mprGetBaseName(argv[i++]), 0); + for (; i < argc; i++) { + len = mprReallocStrcat(MPR_LOC_ARGS(app), &commandLine, 0, len, + " ", argv[i], 0); + } + mprPrintf(app, " %s\n", commandLine); + } + if (testLog) { + testLogFile = mprOpen(app, testLog, + O_CREAT | O_APPEND | O_WRONLY | O_TEXT, 0664); + if (testLogFile == 0) { + mprError(app, MPR_LOC, "Can't open %s", testLog); + return MPR_ERR_CANT_OPEN; + } + mprFprintf(testLogFile, "\n %s\n", commandLine); + } + + ejs = ejsCreateInterp(ejsService, 0, 0, 0, 0); + if (ejs == 0) { + mprError(app, MPR_LOC, "Can't create EJS interpreter"); + ejsCloseService(ejsService, stats); + if (testLogFile) { + mprClose(testLogFile); + } + mprTerm(app, stats); + exit(-1); + } + + if (debugLevel > 0) { + ejsSetGCDebugLevel(ejs, debugLevel); + } + + rc = 0; + + if (nextArg < argc) { + /* + * Process files supplied on the command line + */ + firstArg = nextArg; + for (i = 0; i < iterations; i++) { + for (nextArg = firstArg; nextArg < argc; nextArg++) { + rc = parseFile(ejsService, ejs, argv[nextArg], testName, + testLogFile); + if (rc < 0) { + return rc; + } + } + } + if (testName) { + if (verbose == 1) { + mprPrintf(app, "\n"); + } + if (verbose <= 1) { + mprPrintf(app, " # PASSED all tests for \"%s\"\n", testName); + } + } + + } else if (! isConsole) { + /* + * Read a script from stdin + */ + cmd = readCmd(app, stdin); + + ejsSetFileName(ejs, "stdin"); + + rc = ejsEvalScript(ejs, cmd, 0); + if (rc < 0) { + mprPrintf(app, "ejs: Error: %s\n", ejsGetErrorMsg(ejs)); + } + mprFree(cmd); + + } else { + /* + * Interactive use. Read commands from the command line. + */ + rc = interactiveUse(app, ejs, stdin, "stdin"); + } + + /* + * Cleanup. Do stats if required. + */ + if (ejs) { + ejsCleanInterp(ejs, 0); + ejsCleanInterp(ejs->service->master, 0); + ejsDestroyInterp(ejs, 0); + } + + ejsCloseService(ejsService, stats); + + if (testLogFile) { + mprClose(testLogFile); + } + + mprTerm(app, stats); + return rc; +} + +/******************************************************************************/ + +static int parseFile(EjsService *ejsService, Ejs *ejs, const char *fileName, + const char *testName, MprFile *testLogFile) +{ + int rc; + + if (testName && verbose == 1) { + mprPrintf(ejs, "."); + } + if (verbose > 1) { + mprPrintf(ejs, "File: %s\n", fileName); + } + + rc = ejsEvalFile(ejs, fileName, 0); + + if (testName) { + char fileBuf[MPR_MAX_FNAME], *cp; + mprStrcpy(fileBuf, sizeof(fileBuf), fileName); + if ((cp = strstr(fileBuf, ".ejs")) != 0) { + *cp = '\0'; + } + if (rc == 0) { + if (verbose > 1) { + mprPrintf(ejs, " # PASSED test \"%s.%s\"\n", testName, + fileBuf); + } + if (testLogFile) { + mprFprintf(testLogFile, " # PASSED test \"%s.%s\"\n", + testName, fileBuf); + } + + } else { + + mprPrintf(ejs, "FAILED test \"%s.%s\"\nDetails: %s\n", + testName, fileBuf, ejsGetErrorMsg(ejs)); + + if (testLogFile) { + mprFprintf(testLogFile, + "FAILED test \"%s.%s\"\nDetails: %s\n", + testName, fileBuf, ejsGetErrorMsg(ejs)); + } + } + } else if (rc < 0) { + mprPrintf(ejs, "ejs: %sIn file \"%s\"\n", + ejsGetErrorMsg(ejs), fileName); + } + return rc; +} + +/******************************************************************************/ + +static char *readCmd(MprApp *app, FILE *input) +{ + char line[EJS_MAX_CMD_LINE]; + char *cmd; + int len, cmdLen; + + cmd = 0; + cmdLen = 0; + + line[sizeof(line) - 1] = '\0'; + + while (1) { + + if (fgets(line, sizeof(line) - 1, input) == NULL) { + break; + } + + len = strlen(line); + + if (line[len - 1] == '\\') { + line[len - 1] = '\0'; + } + cmdLen = mprReallocStrcat(MPR_LOC_ARGS(app), &cmd, EJS_MAX_SCRIPT, + cmdLen, 0, line, 0); + } + return cmd; +} + +/******************************************************************************/ + +static int interactiveUse(MprApp *app, Ejs *ejs, FILE *input, char *fileName) +{ + EjsVar result; + char line[EJS_MAX_CMD_LINE]; + char *cmd, *buf; + int len, cmdLen, rc; + + cmd = 0; + cmdLen = 0; + + line[sizeof(line) - 1] = '\0'; + + ejsSetFileName(ejs, "console"); + + while (! ejsIsExiting(ejs)) { + + if (isConsole) { + write(1, EJS_PROMPT, strlen(EJS_PROMPT)); + } + + if (fgets(line, sizeof(line) - 1, input) == NULL) { + break; + } + + len = strlen(line); + while (len > 0 && + (line[len - 1] == '\n' || line[len - 1] == '\r')) { + len--; + line[len] = '\0'; + } + + if (line[len - 1] == '\\') { + line[len - 1] = '\0'; + cmdLen = mprReallocStrcat(MPR_LOC_ARGS(app), &cmd, EJS_MAX_SCRIPT, + cmdLen, 0, line, 0); + + } else { + + cmdLen = mprReallocStrcat(MPR_LOC_ARGS(app), &cmd, EJS_MAX_SCRIPT, + cmdLen, 0, line, 0); + + + if (traceCmds) { + mprPrintf(ejs, "# %s\n", cmd); + } + + if (cmd[0] == 0x4 || cmd[0] == 0x26 || strcmp(cmd, "quit") == 0) { + ejsExit(ejs, 0); + + } else if ((rc = ejsEvalScript(ejs, cmd, &result)) < 0) { + + mprPrintf(app, "ejs: Error: %s\n", ejsGetErrorMsg(ejs)); + + if (! isConsole) { + return rc; + } + + } else { + if (isConsole || traceCmds) { + buf = ejsVarToString(ejs, &result); + mprPrintf(ejs, "%s\n", buf); + } + } + mprFree(cmd); + cmd = 0; + cmdLen = 0; + } + } + return 0; +} + +/******************************************************************************/ + +static int ifConsole() +{ +#if WIN + INPUT_RECORD irec[1]; + int records = 0; + + if (PeekConsoleInput(GetStdHandle(STD_INPUT_HANDLE), irec, 1, + &records) != 0) { + return 1; + } +#else + return isatty(0); +#endif + return 0; +} + +/******************************************************************************/ + +static int memoryFailure(MprApp *app, uint size, uint total, bool granted) +{ + if (!granted) { + mprPrintf(app, "Can't allocate memory block of size %d\n", size); + mprPrintf(app, "Total memory used %d\n", total); + exit(255); + } + mprPrintf(app, "Memory request for %d bytes exceeds memory red-line\n", + size); + mprPrintf(app, "Total memory used %d\n", total); + return 0; +} + +/******************************************************************************/ + +#else +void ejsCmdLineDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + * vim600: sw=4 ts=4 fdm=marker + * vim<600: sw=4 ts=4 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/ejsGarbage.c b/source4/lib/appweb/ejs-2.0/ejs/ejsGarbage.c new file mode 100755 index 0000000000..264da05721 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/ejsGarbage.c @@ -0,0 +1,1214 @@ +/* + * @file ejsGarbage.c + * @brief EJS Garbage collector. + * @overview This implements a generational mark and sweep collection scheme. + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/****************************** Forward Declarations **************************/ + +static void mark(Ejs *ep); +static void markObjByVar(Ejs *ep, EjsVar *op); +static void markObj(EjsObj *obj); +static void markPerm(Ejs *ep, uint gen); +static int sweep(Ejs *ep, uint gen); +static EjsGCLink *ejsAlloc(EJS_LOC_DEC(ep, loc), int slabIndex); +static void ejsGracefulDegrade(Ejs *ep); +static void resetMarks(Ejs *ep, EjsSlab *slab); + +#if FUTURE +static void ageGenerations(Ejs *ep); +#endif + +#if BLD_DEBUG && (!BREW || BREW_SIMULATOR) +uint breakAddr; +#endif + +/************************************* Code ***********************************/ + +void ejsGCInit(Ejs *ep, int objInc, int propInc, int varInc, int strInc) +{ + EjsSlab *slab; + + if (ep->service && ep->service->globalClass) { + ep->service->globalClass->objectState->gcMarked = 1; + } + + slab = &ep->slabs[EJS_SLAB_OBJ]; + slab->allocIncrement = objInc; + slab->size = EJS_ALLOC_ALIGN(sizeof(EjsObj)); + + slab = &ep->slabs[EJS_SLAB_PROPERTY]; + slab->allocIncrement = propInc; + slab->size = EJS_ALLOC_ALIGN(sizeof(EjsProperty)); + + slab = &ep->slabs[EJS_SLAB_VAR]; + slab->allocIncrement = varInc; + slab->size = EJS_ALLOC_ALIGN(sizeof(EjsVar)); + + /* + * Initialize GC. + * Enable GC both idle and demand collections. + * Set no limits and garbage collect if the slabs are + * empty and we have used more than the THRESHOLD of ram. + */ + ep->gc.debugLevel = 0; + ep->gc.enable = 1; + ep->gc.enableIdleCollect = 1; + ep->gc.enableDemandCollect = 1; + ep->gc.workQuota = EJS_GC_WORK_QUOTA; + ep->gc.maxMemory = 0; +} + + +/******************************************************************************/ +#if BLD_FEATURE_ALLOC_STATS + +void ejsPrintAllocReport(Ejs *ep, bool printLeakReport) +{ + EjsSlab *slab; + char *name; + int slabIndex, isObj; + + for (slabIndex = 0; slabIndex < EJS_SLAB_MAX; slabIndex++) { + slab = &ep->slabs[slabIndex]; + if (slabIndex == EJS_SLAB_VAR) { + name = "var"; + } else if (slabIndex == EJS_SLAB_PROPERTY) { + name = "prop"; + } else { + name = "obj"; + } + mprLog(ep, 0, " "); + mprLog(ep, 0, " GC \"%s\" local slab", name); + mprLog(ep, 0, " Total blocks %14d", + slab->allocCount + slab->freeCount); + mprLog(ep, 0, " Block size %14d", slab->size); + mprLog(ep, 0, " Slab RAM allocated %14d", + (slab->allocCount + slab->freeCount) * slab->size); + mprLog(ep, 0, " Slab RAM in use %14d", + slab->allocCount * slab->size); + mprLog(ep, 0, " Blocks in use %14d", slab->allocCount); + mprLog(ep, 0, " Free blocks %14d", slab->freeCount); + mprLog(ep, 0, " Peak allocated %14d", slab->peakAllocated); + mprLog(ep, 0, " Peak free %14d", slab->peakFree); + mprLog(ep, 0, " Total allocations %14d", slab->totalAlloc); + mprLog(ep, 0, " Total blocks reclaimed %14d", slab->totalReclaimed); + mprLog(ep, 0, " Total sweeps %14d", slab->totalSweeps); + mprLog(ep, 0, " Allocation inc %14d", slab->allocIncrement); + } + + mprLog(ep, 0, " "); + mprLog(ep, 0, " Total EJS memory in use %10d", ejsGetUsedMemory(ep)); + mprLog(ep, 0, " Total EJS memory allocated %10d", + ejsGetAllocatedMemory(ep)); + + if (printLeakReport) { + mprLog(ep, 0, " "); + for (slabIndex = 0; slabIndex < EJS_SLAB_MAX; slabIndex++) { + int size; + + slab = &ep->slabs[slabIndex]; + + isObj = 0; + mprLog(ep, 0, " "); + if (slabIndex == EJS_SLAB_VAR) { + name = "var"; + size = sizeof(EjsVar); + } else if (slabIndex == EJS_SLAB_PROPERTY) { + name = "prop"; + size = sizeof(EjsProperty); + } else { + name = "obj"; + size = sizeof(EjsObj); + isObj++; + } +#if BLD_FEATURE_ALLOC_LEAK_TRACK +{ + EjsGCLink *lp; + EjsObj *obj; + int count; + + mprLog(ep, 0, "EJS Leak Report for \"%s\"", name); + count = 0; + + for (lp = slab->allocList[0].next; lp; lp = lp->next) { + mprLog(ep, 0, " %-20s %10d", lp->allocatedBy, size); + if (isObj) { + obj = (EjsObj*) lp; + mprLog(ep, 0, " %-20s %10d %s %s", + lp->allocatedBy, size, + obj->permanent ? "permanent" : "", + obj->alive ? "alive" : "" + ); + } else { + mprLog(ep, 0, " %-20s %10d", lp->allocatedBy, + size); + } + count++; + } + mprLog(ep, 0, " Total blocks %14d", count); +} +#endif + } + mprLog(ep, 0, " "); + } +} + +#endif +/******************************************************************************/ +/* + * Slab allocator + */ + +static EjsGCLink *ejsAlloc(EJS_LOC_DEC(ep, loc), int slabIndex) +{ + EjsSlab *slab; + EjsGCLink *block; + EjsGC *gc; + uint allocatedMemory; + int i; + + mprStackCheck(ep); + + if (slabIndex < 0 || slabIndex >= EJS_SLAB_MAX) { + mprAssert(0); + return 0; + } + + /* + * See if the slab has some free blocks + */ + slab = &ep->slabs[slabIndex]; + if ((block = slab->freeList.next) == 0) { + + allocatedMemory = ejsGetAllocatedMemory(ep); + gc = &ep->gc; + + /* + * No blocks available. If demand collection is enabled, try + * to garbage collect first. We collect if we have done a good + * work quota or we are over the max memory limit. + */ + if (slabIndex != EJS_SLAB_VAR && + ep->gc.enable && ep->gc.enableDemandCollect) { + if ((ep->gc.workDone > ep->gc.workQuota) || + (gc->maxMemory > 0 && allocatedMemory > gc->maxMemory)) { + +#if DEBUG_USE_ONLY + if (ep->gc.debugLevel > 0) { + mprLog(ep, 0, "Need GC, EJS RAM %d, MPR RAM %d\n", + allocatedMemory, mprGetAllocatedMemory(ep)); + if (ep->gc.debugLevel > 4) { + ejsPrintAllocReport(ep, 0); + } + } +#endif + if (ejsCollectGarbage(ep, slabIndex) == 0) { + block = slab->freeList.next; + } + } + } + + if (block == 0) { + if (gc->maxMemory > 0 && allocatedMemory > gc->maxMemory) { + /* + * We are above the max memory limit. We will fail this + * memory allocation, but allow subsequent allocations to + * permit error recovery. We gracefully degrade by setting + * slab chunk sizes to 1. This minimizes real memory + * consumption. This allows us to create + * an exception block to be created by upper layers. + */ + if (! gc->degraded) { + ejsGracefulDegrade(ep); + return 0; + } + } + + /* + * Still non available, so allocate more memory for a set of blocks + * OPT -- should bypass mprAlloc. Need mprMalloc. + */ + block = mprAlloc(ep->slabAllocContext, + slab->size * slab->allocIncrement); + if (block == 0) { + /* + * Now we're in trouble. We should really never get here + * as the graceful degrade will have signaled a memory + * allocation failure. + */ + mprAssert(block != 0); + return 0; + } + + /* + * Chain all the blocks together onto the slab free list + */ + for (i = slab->allocIncrement - 1; i >= 0; i--) { + block->next = slab->freeList.next; +#if BLD_DEBUG + block->magic = EJS_MAGIC_FREE; +#endif + slab->freeList.next = block; + block = (EjsGCLink*) ((char*) block + slab->size); + } + + block = slab->freeList.next; + +#if BLD_FEATURE_ALLOC_STATS + slab->freeCount += slab->allocIncrement; + if (slab->freeCount > slab->peakFree) { + slab->peakFree = slab->freeCount; + } +#endif + } + } + + /* + * We use block to point to the user data in the block. We only + * store the magic number (if debug). No other data is stored in the + * user block. + */ +#if BLD_DEBUG + mprAssert(block->magic == EJS_MAGIC_FREE); +#endif + + /* + * Remove from the free list + */ + slab->freeList.next = block->next; + + /* + * Zero block + */ + memset(block, 0, slab->size); + +#if BLD_DEBUG + block->magic = EJS_MAGIC; +#endif + +#if BLD_FEATURE_ALLOC_STATS + slab->totalAlloc++; + if (++slab->allocCount > slab->peakAllocated) { + slab->peakAllocated = slab->allocCount; + } + slab->freeCount--; +#endif + +#if BLD_DEBUG && (!BREW || BREW_SIMULATOR) + if ((uint) block == breakAddr) { + mprBreakpoint(MPR_LOC, "Watched Block"); + } +#endif + return block; +} + + +/******************************************************************************/ + +EjsObj *ejsAllocObj(EJS_LOC_DEC(ep, loc)) +{ + EjsObj *obj; + EjsSlab *slab; + + obj = (EjsObj*) ejsAlloc(EJS_LOC_PASS(ep, loc), EJS_SLAB_OBJ); + + /* + * Add to the allocated block list for the New generation. + */ + if (obj) { + slab = &ep->slabs[EJS_SLAB_OBJ]; + obj->gc.next = slab->allocList[EJS_GEN_NEW].next; + +#if BLD_FEATURE_ALLOC_LEAK_TRACK + obj->gc.allocatedBy = loc; +#endif + + obj->ejs = ep; + slab->allocList[EJS_GEN_NEW].next = (EjsGCLink*) obj; + + ep->gc.workDone++; + } + + return obj; +} + + +/******************************************************************************/ + +EjsProperty *ejsAllocProperty(EJS_LOC_DEC(ep, loc)) +{ + EjsProperty *prop; + + prop = (EjsProperty*) ejsAlloc(EJS_LOC_PASS(ep, loc), EJS_SLAB_PROPERTY); + mprAssert(prop); + + if (prop) { + prop->var.type = EJS_TYPE_NULL; + prop->var.isProperty = 1; +#if BLD_FEATURE_ALLOC_LEAK_TRACK + prop->var.gc.allocatedBy = loc; +#endif + } + return prop; +} + + +/******************************************************************************/ + +EjsVar *ejsAllocVar(EJS_LOC_DEC(ep, loc)) +{ + EjsVar *vp; + + vp = (EjsVar*) ejsAlloc(EJS_LOC_PASS(ep, loc), EJS_SLAB_VAR); + mprAssert(vp); + + if (vp) { +#if BLD_FEATURE_ALLOC_LEAK_TRACK + EjsSlab *slab; + vp->gc.allocatedBy = loc; + slab = &ep->slabs[EJS_SLAB_VAR]; + vp->gc.next = slab->allocList[EJS_GEN_NEW].next; + slab->allocList[EJS_GEN_NEW].next = (EjsGCLink*) vp; +#endif +#if BLD_DEBUG + vp->propertyName = 0; +#endif + } + return vp; +} + + +/******************************************************************************/ +/* + * Return the block back to the relevant slab + */ + +void ejsFree(Ejs *ep, void *ptr, int slabIndex) +{ + EjsSlab *slab; + EjsGCLink *block; + + mprAssert(ep); + mprAssert(ptr); + + if (slabIndex < 0 || slabIndex >= EJS_SLAB_MAX) { + mprAssert(slabIndex >= 0 && slabIndex < EJS_SLAB_MAX); + return; + } + slab = &ep->slabs[slabIndex]; + +#if BLD_FEATURE_ALLOC_LEAK_TRACK + if (slabIndex == EJS_SLAB_VAR) { + EjsVar *vp, *np, *prev; + + /* + * Remove the block rom the alloc list. WARNING: this is slow + * and should not be used in production code. + */ + vp = (EjsVar*) ptr; + prev = 0; + for (np = (EjsVar*) slab->allocList[0].next; np; + np = (EjsVar*) np->gc.next) { + if (vp == np) { + if (prev) { + prev->gc.next = (EjsGCLink*) np->gc.next; + } else { + slab->allocList[0].next = (EjsGCLink*) np->gc.next; + } + break; + } + prev = np; + } + if (np == 0) { + mprAssert(0); + } + } +#endif + + /* + * Insert into the free list. Only use the next ptr + */ + block = (EjsGCLink*) ptr; + +#if BLD_DEBUG +#if !BREW || BREW_SIMULATOR + if ((uint) block == breakAddr) { + mprBreakpoint(MPR_LOC, "Watched Block"); + } +#endif + mprAssert(block->magic == EJS_MAGIC); + block->magic = EJS_MAGIC_FREE; +#endif + + block->next = slab->freeList.next; + slab->freeList.next = block; + +#if BLD_FEATURE_ALLOC_STATS + slab->allocCount--; + if (++slab->freeCount >= slab->peakFree) { + slab->peakFree = slab->freeCount; + } + slab->totalReclaimed++; + if (slabIndex != 2) { + slabIndex = slabIndex; + } +#endif +} + +/******************************************************************************/ +/* + * Mark an object as being in-use. Traverse all properties for referenced + * objects and base classes. + */ + +static void markObjByVar(Ejs *ep, EjsVar *obj) +{ + EjsProperty *pp; + EjsVar *vp, *baseClass; + + mprAssert(ep); + mprAssert(obj); + + obj->objectState->gcMarked = 1; + +#if BLD_DEBUG + if (ep->gc.debugLevel >= 3) { + int indent = min(ep->gc.gcIndent * 2, 32); + mprLog(ep, 0, "%.*s %-24s %.*s 0x%08X", + indent, " ", + obj->propertyName, + 32 - indent, "................................ ", + (uint) obj->objectState); + ep->gc.gcIndent++; + } + ep->gc.objectsInUse++; +#endif + + /* + * Traverse all referenced objects + * OPT -- optimize by directly accessing the object links and not using + * ejsGetFirst/NextProperty. Then just examine objects + * OPT -- first property in global is global. Should optimize this. + */ + pp = ejsGetFirstProperty(obj, EJS_ENUM_ALL); + while (pp) { + vp = ejsGetVarPtr(pp); + if (vp->type == EJS_TYPE_OBJECT) { + if (!vp->objectState->gcMarked) { +#if FUTURE + /* + * OPT -- we can use the dirty bit on objects to avoid + * visiting permanent objects that are clean. If so, don't + * forget the else case below. + */ + obj = vp->objectState; + if ((!obj->alive && !obj->permanent) || obj->dirty) +#endif + markObjByVar(ep, vp); + } + + } else { +#if BLD_DEBUG + if (ep->gc.debugLevel >= 3) { + int indent = min(ep->gc.gcIndent * 2, 32); + mprLog(ep, 0, "%.*s %-24s %.*s %s", + indent, " ", + vp->propertyName, + 32 - indent, "................................ ", + ejsGetVarTypeAsString(vp)); + } + ep->gc.propertiesInUse++; +#endif + } + pp = ejsGetNextProperty(pp, EJS_ENUM_ALL); + } + + /* + * Traverse the base class + */ + baseClass = obj->objectState->baseClass; + if (baseClass) { + mprAssert(baseClass->type == EJS_TYPE_OBJECT); + mprAssert(baseClass->objectState); + if (baseClass->objectState) { + if (! baseClass->objectState->gcMarked) { + markObjByVar(ep, baseClass); + } + } + } +#if BLD_DEBUG + if (ep->gc.debugLevel >= 3) { + ep->gc.gcIndent--; + } +#endif +} + + +/******************************************************************************/ +/* + * Mark phase. Examine all variable frames and the return result. + */ + +static void mark(Ejs *ep) +{ + EjsVar *vp; + int i; + +#if BLD_DEBUG + if (ep->gc.debugLevel >= 3) { + mprLog(ep, 0, " "); + mprLog(ep, 0, "GC: Marked Blocks:"); + } +#endif + + if (ep->frames) { + for (i = 0; i < mprGetItemCount(ep->frames); i++) { + + vp = (EjsVar*) mprGetItem(ep->frames, i); + mprAssert(vp->type == EJS_TYPE_OBJECT); + + if (! vp->objectState->gcMarked) { + markObjByVar(ep, vp); + } + } + } + + vp = ep->result; + if (vp && vp->type == EJS_TYPE_OBJECT && ! vp->objectState->gcMarked) { + markObjByVar(ep, vp); + } + + vp = ep->currentObj; + if (vp && vp->type == EJS_TYPE_OBJECT && ! vp->objectState->gcMarked) { + markObjByVar(ep, vp); + } + + vp = ejsGetVarPtr(ep->currentProperty); + if (vp && vp->type == EJS_TYPE_OBJECT && ! vp->objectState->gcMarked) { + markObjByVar(ep, vp); + } + + /* + * OPT -- we could mark master as "mark permanent" somehow and + * then we would not need to walk the master objects. + */ + if (ep->slabAllocContext == ep->service->master) { + if (ep->service->master->global) { + markObjByVar(ep, ep->service->master->global); + } + } + +#if BLD_DEBUG + if (ep->gc.debugLevel >= 3) { + mprLog(ep, 0, " "); + } +#endif +} + + +/******************************************************************************/ +#if UNUSED + +static void resetMark(EjsVar *obj) +{ + EjsProperty *pp; + EjsVar *vp, *baseClass; + + obj->objectState->gcMarked = 0; + obj->objectState->visited = 1; + + pp = ejsGetFirstProperty(obj, EJS_ENUM_ALL); + while (pp) { + vp = ejsGetVarPtr(pp); + if (vp->type == EJS_TYPE_OBJECT && !vp->objectState->visited) { + resetMark(vp); + } + pp = ejsGetNextProperty(pp, EJS_ENUM_ALL); + } + + baseClass = obj->objectState->baseClass; + if (baseClass) { + mprAssert(baseClass->type == EJS_TYPE_OBJECT); + mprAssert(baseClass->objectState); + if (baseClass->objectState) { + if (! baseClass->objectState->visited) { + resetMark(baseClass); + } + } + } + obj->objectState->visited = 0; +} + +/******************************************************************************/ +/* + * Mark phase. Examine all variable frames and the return result. + */ + +static void resetAllMarks(Ejs *ep) +{ + EjsVar *vp; + int i; + + for (i = 0; i < mprGetItemCount(ep->frames); i++) { + vp = (EjsVar*) mprGetItem(ep->frames, i); + resetMark(vp); + } + + if (ep->result && ep->result->type == EJS_TYPE_OBJECT && + ! ep->result->objectState->gcMarked) { + resetMark(ep->result); + } +} + +#endif +/******************************************************************************/ +/* + * Sweep up the garbage + */ + +static void resetMarks(Ejs *ep, EjsSlab *slab) +{ + EjsVar *vp; + EjsObj *obj; + int gen, i; + + for (gen = EJS_GEN_NEW; gen < EJS_GEN_MAX; gen++) { + obj = (EjsObj*) slab->allocList[gen].next; + for (; obj; obj = (EjsObj*) obj->gc.next) { + obj->gcMarked = 0; + obj->visited = 0; + } + } + + if (ep->frames) { + for (i = 0; i < mprGetItemCount(ep->frames); i++) { + + vp = (EjsVar*) mprGetItem(ep->frames, i); + mprAssert(vp->type == EJS_TYPE_OBJECT); + + vp->objectState->gcMarked = 0; + vp->objectState->visited = 0; + } + } + + if (ep->result && ep->result->type == EJS_TYPE_OBJECT) { + ep->result->objectState->gcMarked = 0; + } +} + +/******************************************************************************/ +/* + * Mark all permanent and non-alive objects + */ + +static void markPerm(Ejs *ep, uint gen) +{ + EjsSlab *slab; + EjsObj *obj; + + slab = &ep->slabs[EJS_SLAB_OBJ]; + + for (obj = (EjsObj*) slab->allocList[gen].next; obj; ) { + + if (! obj->gcMarked) { + if (!obj->alive || obj->permanent) { + markObj(obj); + } + } + obj = (EjsObj*) obj->gc.next; + + } +} + +/******************************************************************************/ + +static void markObj(EjsObj *obj) +{ + EjsProperty *pp; + EjsPropLink *lp, *head; + EjsObj *op; + + mprAssert(obj); + + obj->gcMarked = 1; + + head = &obj->link; + for (lp = head->next; lp != head; lp = lp->next) { + + pp = ejsGetPropertyFromLink(lp); + + if (pp->var.type == EJS_TYPE_OBJECT) { + op = pp->var.objectState; + if (op != 0 && !op->gcMarked) { + markObj(op); + } + } + } +} + +/******************************************************************************/ +/* + * Sweep up the garbage. Return the number of objects freed. + */ + +static int sweep(Ejs *ep, uint gen) +{ + EjsSlab *slab; + EjsObj *obj, *next, *prev; + int count; + + slab = &ep->slabs[EJS_SLAB_OBJ]; + + /* + * Examine allocated objects in the specified generation (only). + * NOTE: we only sweep object allocated to this interpreter and so + * we do not sweep any permanent objects in the default interpreter. + */ + prev = 0; + count = 0; + for (obj = (EjsObj*) slab->allocList[gen].next; obj; obj = next) { + + next = (EjsObj*) obj->gc.next; + +#if BLD_DEBUG && (!BREW || BREW_SIMULATOR) + if ((uint) obj == breakAddr) { + mprBreakpoint(MPR_LOC, "Watched Block"); + } +#endif + + /* + * If object has not been marked inuse and is not a permanent + * object, then free it. + */ + if (! obj->gcMarked && obj->alive && !obj->permanent) { + +#if BLD_DEBUG + if (ep->gc.debugLevel >= 2) { + if (obj->objName) { + mprLog(ep, 0, "GC: destroy %-18s %10d, %8X", + obj->objName, (uint) obj, (uint) obj); + } else { + mprLog(ep, 0, "GC: destroy UNKNOWN %x", (uint) obj); + } + } +#endif + if (ejsDestroyObj(ep, obj) < 0) { + prev = obj; + obj->gcMarked = 0; + continue; + } + + if (prev) { + prev->gc.next = (EjsGCLink*) next; + } else { + slab->allocList[gen].next = (EjsGCLink*) next; + } + count++; + + } else { + prev = obj; + /* Reset for next time */ + obj->gcMarked = 0; + } + } + + if (gen == (EJS_GEN_OLD - 1)) { + slab->lastRecentBlock = prev; + } +#if BLD_FEATURE_ALLOC_STATS + slab->totalSweeps++; +#endif +#if BLD_DEBUG + if (ep->gc.debugLevel > 0) { + mprLog(ep, 0, "GC: Sweep freed %d objects", count); + } +#endif + return count; +} + +/******************************************************************************/ +/* + * Sweep all variables + */ + +void ejsSweepAll(Ejs *ep) +{ + EjsSlab *slab; + EjsObj *obj, *next, *prev; + int gen; + + slab = &ep->slabs[EJS_SLAB_OBJ]; + + for (gen = EJS_GEN_NEW; gen < EJS_GEN_MAX; gen++) { + prev = 0; + for (obj = (EjsObj*) slab->allocList[gen].next; obj; obj = next) { + next = (EjsObj*) obj->gc.next; + ejsDestroyObj(ep, obj); + } + break; + } +} + +/******************************************************************************/ + +bool ejsObjIsCollectable(EjsVar *vp) +{ + if (vp == 0 || !ejsVarIsObject(vp)) { + return 0; + } + return (vp->objectState->alive && !vp->objectState->permanent); +} + +/******************************************************************************/ +#if FUTURE + +static void ageGenerations(Ejs *ep) +{ + EjsSlab *slab; + EjsGCLink *oldList; + int gen; + + slab = &ep->slabs[EJS_SLAB_OBJ]; + + /* + * Age all blocks. First append all (old - 1) blocks onto the old + * alloc list + */ + oldList = &slab->allocList[EJS_GEN_OLD]; + + if (slab->lastRecentBlock) { + slab->lastRecentBlock->gc.next = oldList->next; + oldList->next = (EjsGCLink*) slab->lastRecentBlock; + } + + /* + * Now simply copy all allocation lists up one generation + */ + for (gen = EJS_GEN_OLD - 1; gen > 0; gen--) { + slab->allocList[gen] = slab->allocList[gen - 1]; + } + slab->allocList[0].next = 0; +} + +#endif +/******************************************************************************/ +/* + * Collect the garbage. This is a mark and sweep over all possible objects. + * If an object is not referenced, it and all contained properties will be + * freed. If a slabIndex is provided, the collection halts when a block is + * available for allocation on that slab. + * + * Return 0 if memory is now available after collecting garbage. Otherwise, + * return MPR_ERR_MEMORY. + */ + +int ejsCollectGarbage(Ejs *ep, int slabIndex) +{ + EjsGeneration gen; + + if (ep->flags & EJS_FLAGS_DONT_GC) { + return -1; + } + + /* + * Prevent destructors invoking the garbage collector + */ + if (ep->gc.collecting) { + return 0; + } + ep->gc.collecting = 1; + + resetMarks(ep, &ep->slabs[EJS_SLAB_OBJ]); + + /* + * Examine each generation of objects starting with the most recent + * generation. Stop scanning when we have a free block to use. + */ + for (gen = EJS_GEN_NEW; gen < EJS_GEN_MAX; gen++) { + + if (slabIndex >= 0 && ep->slabs[slabIndex].freeList.next) { + break; + } + + /* + * FUTURE OPT. Should mark objects in new generation and those + * with a dirty bit set in older generations. Don't need to mark + * entire heap. But how to keep list of dirty objects. + */ + mark(ep); + markPerm(ep, gen); + sweep(ep, gen); + + /* FUTURE - not using generations yet */ + break; + } + + /* + * FUTURE -- not using generations yet. + * + * ageGenerations(ep); + */ + + ep->gc.workDone = 0; + ep->gc.collecting = 0; + + return (gen < EJS_GEN_MAX) ? 0 : MPR_ERR_MEMORY; +} + + +/******************************************************************************/ +/* + * Should be called when the app has been idle for a little while and when it + * is likely to be idle a bit longer. Call ejsIsTimeForGC to see if this is + * true. Return the count of objects collected . + */ + +int ejsIncrementalCollectGarbage(Ejs *ep) +{ + int count; + + if (ep->gc.collecting) { + return 0; + } + + ep->gc.collecting = 1; + + resetMarks(ep, &ep->slabs[EJS_SLAB_OBJ]); + mark(ep); + + /* Not generational yet */ + count = sweep(ep, EJS_GEN_NEW); + + ep->gc.collecting = 0; + ep->gc.workDone = 0; + + return count; +} + +/******************************************************************************/ +#if BLD_DEBUG + +void ejsDumpObjects(Ejs *ep) +{ + int oldDebugLevel; + + mprLog(ep, 0, "Dump of objects in use\n"); + + oldDebugLevel = ep->gc.debugLevel; + + ep->gc.debugLevel = 3; + ep->gc.objectsInUse = 0; + ep->gc.propertiesInUse = 0; + ep->gc.collecting = 1; + + resetMarks(ep, &ep->slabs[EJS_SLAB_OBJ]); + mark(ep); + + ep->gc.collecting = 0; + ep->gc.debugLevel = oldDebugLevel; + + mprLog(ep, 0, "%d objects and %d properties in use", + ep->gc.objectsInUse, ep->gc.propertiesInUse); + mprLog(ep, 0, "%d object bytes, %d property bytes and %d total", + (int) (ep->gc.objectsInUse * sizeof(EjsObj)), + (int) (ep->gc.propertiesInUse * sizeof(EjsProperty)), + (int) ((ep->gc.objectsInUse * sizeof(EjsObj) + + ep->gc.propertiesInUse * sizeof(EjsProperty)))); +} + +#endif +/******************************************************************************/ +/* + * Return true if there is time to do a garbage collection and if we will + * benefit from it. + */ + +int ejsIsTimeForGC(Ejs *ep, int timeTillNextEvent) +{ + EjsGC *gc; + + if (timeTillNextEvent < EJS_MIN_TIME_FOR_GC) { + /* + * Not enough time to complete a collection + */ + return 0; + } + + gc = &ep->gc; + + /* + * Return if we haven't done enough work to warrant a collection + * Trigger a little short of the work quota to try to run GC before + * a demand allocation requires it. + */ + if (!gc->enable || !gc->enableIdleCollect || + (gc->workDone < (gc->workQuota - EJS_GC_MIN_WORK_QUOTA))) { + return 0; + } + +#if UNUSED + mprLog(ep, 0, "Time for GC. Work done %d, time till next event %d", + gc->workDone, timeTillNextEvent); +#endif + return 1; +} + +/******************************************************************************/ +/* + * Return the amount of memory in use by EJS + */ + +uint ejsGetUsedMemory(Ejs *ep) +{ +#if BLD_FEATURE_ALLOC_STATS + EjsSlab *slab; + int i, totalMemory, slabMemory; + + totalMemory = 0; + for (i = 0; i < EJS_SLAB_MAX; i++) { + slab = &ep->slabs[i]; + slabMemory = slab->allocCount * slab->size; + totalMemory += slabMemory; + } + return totalMemory; +#else + return 0; +#endif +} + +/******************************************************************************/ +/* + * Return the amount of memory allocated by EJS + */ + +uint ejsGetAllocatedMemory(Ejs *ep) +{ +#if BLD_FEATURE_ALLOC_STATS + EjsSlab *slab; + int i, totalMemory, slabMemory; + + totalMemory = 0; + for (i = 0; i < EJS_SLAB_MAX; i++) { + slab = &ep->slabs[i]; + slabMemory = (slab->allocCount + slab->freeCount) * slab->size; + totalMemory += slabMemory; + } + return totalMemory; +#else + return 0; +#endif +} + +/******************************************************************************/ +/* + * On a memory allocation failure, go into graceful degrade mode. Set all + * slab allocation chunk increments to 1 so we can create an exception block + * to throw. + */ + +static void ejsGracefulDegrade(Ejs *ep) +{ + EjsSlab *slab; + int i; + + mprLog(ep, 1, "WARNING: Memory almost depleted. In graceful degrade mode"); + for (i = 0; i < EJS_SLAB_MAX; i++) { + slab = &ep->slabs[i]; + slab->allocIncrement = 8; + } + ep->gc.degraded = 1; +} + +/******************************************************************************/ + +int ejsSetGCDebugLevel(Ejs *ep, int debugLevel) +{ + int old; + + old = ep->gc.debugLevel; + ep->gc.debugLevel = debugLevel; + return old; +} + +/******************************************************************************/ + +int ejsSetGCMaxMemory(Ejs *ep, uint maxMemory) +{ + int old; + + old = ep->gc.maxMemory; + ep->gc.maxMemory = maxMemory; + + return old; +} + +/******************************************************************************/ + +bool ejsBlockInUseInt(EjsVar *vp) +{ + if (vp) { +#if BLD_DEBUG + if (vp->gc.magic != EJS_MAGIC) { + return 0; + } + if (vp->type == EJS_TYPE_OBJECT && vp->objectState && + vp->objectState->gc.magic != EJS_MAGIC) { + return 0; + } +#endif + return 1; + } + return 1; +} + +/******************************************************************************/ +#else +void ejsGarbageDummy() {} + +#endif /* BLD_FEATURE_EJS */ + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/ejsLex.c b/source4/lib/appweb/ejs-2.0/ejs/ejsLex.c new file mode 100644 index 0000000000..fbfee6e4d5 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/ejsLex.c @@ -0,0 +1,1033 @@ +/* + * @file ejsLex.c + * @brief EJS Lexical Analyser + * @overview EJS lexical analyser. This implementes a lexical analyser + * for a subset of the JavaScript language. + */ +/********************************* Copyright **********************************/ +/* + * @copy default.g + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. + * Portions Copyright (c) GoAhead Software, 1995-2000. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/****************************** Forward Declarations **************************/ + +static int getLexicalToken(Ejs *ep, int state); +static int tokenAddChar(Ejs *ep, int c); +static int inputGetc(Ejs *ep); +static void inputPutback(Ejs *ep, int c); +static int charConvert(Ejs *ep, int base, int maxDig); +static void parseNumber(Ejs *ep, EjsType type); + +/************************************* Code ***********************************/ +/* + * Open a new input script + */ + +int ejsLexOpenScript(Ejs *ep, const char *script) +{ + EjsInput *ip; + + mprAssert(ep); + mprAssert(script); + + if ((ip = mprAllocTypeZeroed(ep, EjsInput)) == NULL) { + return MPR_ERR_MEMORY; + } + ip->next = ep->input; + ep->input = ip; + ip->procName = ep->proc ? ep->proc->procName : NULL; + ip->fileName = ep->fileName ? ep->fileName : NULL; + +/* + * Create the parse token buffer and script buffer + */ + ip->tokServp = ip->tokbuf; + ip->tokEndp = ip->tokbuf; + + ip->script = script; + ip->scriptSize = strlen(script); + ip->scriptServp = (char*) ip->script; + + ip->lineNumber = 1; + ip->lineColumn = 0; + + ip->putBackIndex = -1; + + return 0; +} + +/******************************************************************************/ +/* + * Close the input script + */ + +void ejsLexCloseScript(Ejs *ep) +{ + EjsInput *ip; + + mprAssert(ep); + + ip = ep->input; + mprAssert(ip); + ep->input = ip->next; + + mprFree(ip); +} + +/******************************************************************************/ +/* + * Initialize an input state structure + */ + +int ejsInitInputState(EjsInput *ip) +{ + mprAssert(ip); + + memset(ip, 0, sizeof(*ip)); + ip->putBackIndex = -1; + + return 0; +} +/******************************************************************************/ +/* + * Save the input state + */ + +void ejsLexSaveInputState(Ejs *ep, EjsInput *state) +{ + EjsInput *ip; + int i; + + mprAssert(ep); + + ip = ep->input; + mprAssert(ip); + + *state = *ip; + + for (i = 0; i <= ip->putBackIndex; i++) { + mprStrcpy(state->putBack[i].tokbuf, EJS_MAX_TOKEN, + ip->putBack[i].tokbuf); + state->putBack[i].tid = ip->putBack[i].tid; + } + + mprStrcpy(state->line, sizeof(state->line), ip->line); + + state->lineColumn = ip->lineColumn; + state->lineNumber = ip->lineNumber; +} + +/******************************************************************************/ +/* + * Restore the input state + */ + +void ejsLexRestoreInputState(Ejs *ep, EjsInput *state) +{ + EjsInput *ip; + EjsToken *tp; + int i; + + mprAssert(ep); + mprAssert(state); + + ip = ep->input; + mprAssert(ip); + + mprStrcpy(ip->tokbuf, sizeof(ip->tokbuf), state->tokbuf); + ip->tokServp = state->tokServp; + ip->tokEndp = state->tokEndp; + + ip->script = state->script; + ip->scriptServp = state->scriptServp; + ip->scriptSize = state->scriptSize; + + ip->putBackIndex = state->putBackIndex; + for (i = 0; i <= ip->putBackIndex; i++) { + tp = &ip->putBack[i]; + tp->tid = state->putBack[i].tid; + mprStrcpy(tp->tokbuf, sizeof(tp->tokbuf), state->putBack[i].tokbuf); + } + + mprStrcpy(ip->line, sizeof(ip->line), state->line); + + ip->lineColumn = state->lineColumn; + ip->lineNumber = state->lineNumber; +} + +/******************************************************************************/ +/* + * Free a saved input state + */ + +void ejsLexFreeInputState(Ejs *ep, EjsInput *state) +{ + mprAssert(ep); + mprAssert(state); + + state->putBackIndex = -1; + state->lineColumn = 0; +} + +/******************************************************************************/ +/* + * Get the next EJS token + */ + +int ejsLexGetToken(Ejs *ep, int state) +{ + mprAssert(ep); + + ep->tid = getLexicalToken(ep, state); + return ep->tid; +} + +/******************************************************************************/ + +/* + * Check for reserved words "if", "else", "var", "for", "delete", "function", + * "class", "extends", "public", "private", "protected", "try", "catch", + * "finally", "throw", "return", "get", "set", "this", "module", "each" + * + * The "new" and "in" reserved words are handled below. The "true", "false", + * "null" "typeof" and "undefined" reserved words are handled as global + * objects. + * + * Other reserved words not supported: + * "break", "case", "continue", "default", "do", + * "instanceof", "switch", "while", "with" + * + * ECMA extensions reserved words (not supported): + * "abstract", "boolean", "byte", "char", "const", + * "debugger", "double", "enum", "export", + * "final", "float", "goto", "implements", "import", "int", + * "interface", "long", "native", "package", + * "short", "static", "super", "synchronized", "transient", "volatile" + * + * FUTURE -- use a hash lookup + */ + +static int checkReservedWord(Ejs *ep, int state, int c, int tid) +{ + /* FUTURE -- probably should return for all tokens != EJS_TOK_ID */ + /* FUTURE -- Should have a hash for this. MUCH faster. */ + + if (!isalpha(ep->token[0]) || tid == EJS_TOK_LITERAL) { + return tid; + } + if (state == EJS_STATE_STMT) { + /* FUTURE OPT -- convert to hash lookup */ + if (strcmp(ep->token, "if") == 0) { + inputPutback(ep, c); + return EJS_TOK_IF; + } else if (strcmp(ep->token, "else") == 0) { + inputPutback(ep, c); + return EJS_TOK_ELSE; + } else if (strcmp(ep->token, "var") == 0) { + inputPutback(ep, c); + return EJS_TOK_VAR; + } else if (strcmp(ep->token, "new") == 0) { + inputPutback(ep, c); + return EJS_TOK_NEW; + } else if (strcmp(ep->token, "for") == 0) { + inputPutback(ep, c); + return EJS_TOK_FOR; + } else if (strcmp(ep->token, "delete") == 0) { + inputPutback(ep, c); + return EJS_TOK_DELETE; + } else if (strcmp(ep->token, "function") == 0) { + inputPutback(ep, c); + return EJS_TOK_FUNCTION; + } else if (strcmp(ep->token, "class") == 0) { + inputPutback(ep, c); + return EJS_TOK_CLASS; + } else if (strcmp(ep->token, "module") == 0) { + inputPutback(ep, c); + return EJS_TOK_MODULE; + } else if (strcmp(ep->token, "extends") == 0) { + inputPutback(ep, c); + return EJS_TOK_EXTENDS; + } else if (strcmp(ep->token, "try") == 0) { + inputPutback(ep, c); + return EJS_TOK_TRY; + } else if (strcmp(ep->token, "catch") == 0) { + inputPutback(ep, c); + return EJS_TOK_CATCH; + } else if (strcmp(ep->token, "finally") == 0) { + inputPutback(ep, c); + return EJS_TOK_FINALLY; + } else if (strcmp(ep->token, "throw") == 0) { + inputPutback(ep, c); + return EJS_TOK_THROW; + } else if (strcmp(ep->token, "public") == 0) { + inputPutback(ep, c); + return EJS_TOK_PUBLIC; + } else if (strcmp(ep->token, "protected") == 0) { + inputPutback(ep, c); + return EJS_TOK_PROTECTED; + } else if (strcmp(ep->token, "private") == 0) { + inputPutback(ep, c); + return EJS_TOK_PRIVATE; + } else if (strcmp(ep->token, "get") == 0) { + inputPutback(ep, c); + return EJS_TOK_GET; + } else if (strcmp(ep->token, "set") == 0) { + inputPutback(ep, c); + return EJS_TOK_SET; + } else if (strcmp(ep->token, "extends") == 0) { + inputPutback(ep, c); + return EJS_TOK_EXTENDS; + } else if (strcmp(ep->token, "try") == 0) { + inputPutback(ep, c); + return EJS_TOK_TRY; + } else if (strcmp(ep->token, "catch") == 0) { + inputPutback(ep, c); + return EJS_TOK_CATCH; + } else if (strcmp(ep->token, "finally") == 0) { + inputPutback(ep, c); + return EJS_TOK_FINALLY; + } else if (strcmp(ep->token, "throw") == 0) { + inputPutback(ep, c); + return EJS_TOK_THROW; + } else if (strcmp(ep->token, "public") == 0) { + inputPutback(ep, c); + return EJS_TOK_PUBLIC; + } else if (strcmp(ep->token, "protected") == 0) { + inputPutback(ep, c); + return EJS_TOK_PROTECTED; + } else if (strcmp(ep->token, "private") == 0) { + inputPutback(ep, c); + return EJS_TOK_PRIVATE; + } else if (strcmp(ep->token, "get") == 0) { + inputPutback(ep, c); + return EJS_TOK_GET; + } else if (strcmp(ep->token, "set") == 0) { + inputPutback(ep, c); + return EJS_TOK_SET; + } else if (strcmp(ep->token, "each") == 0) { + inputPutback(ep, c); + return EJS_TOK_EACH; + } else if (strcmp(ep->token, "return") == 0) { + if ((c == ';') || (c == '(')) { + inputPutback(ep, c); + } + return EJS_TOK_RETURN; + } + + } else if (state == EJS_STATE_EXPR) { + if (strcmp(ep->token, "new") == 0) { + inputPutback(ep, c); + return EJS_TOK_NEW; + } else if (strcmp(ep->token, "in") == 0) { + inputPutback(ep, c); + return EJS_TOK_IN; + } else if (strcmp(ep->token, "function") == 0) { + inputPutback(ep, c); + return EJS_TOK_FUNCTION; + } + + } else if (state == EJS_STATE_DEC) { + if (strcmp(ep->token, "extends") == 0) { + inputPutback(ep, c); + return EJS_TOK_EXTENDS; + } + } + return tid; +} + +/******************************************************************************/ +/* + * Get the next EJS token + */ + +static int getLexicalToken(Ejs *ep, int state) +{ + EjsType type; + EjsInput *ip; + int done, tid, c, quote, style, idx, isHex; + + mprAssert(ep); + ip = ep->input; + mprAssert(ip); + + ep->tid = -1; + tid = -1; + type = BLD_FEATURE_NUM_TYPE_ID; + isHex = 0; + + /* + * Use a putback tokens first. Don't free strings as caller needs access. + */ + if (ip->putBackIndex >= 0) { + idx = ip->putBackIndex; + tid = ip->putBack[idx].tid; + ep->token = (char*) ip->putBack[idx].tokbuf; + tid = checkReservedWord(ep, state, 0, tid); + ip->putBackIndex--; + return tid; + } + ep->token = ip->tokServp = ip->tokEndp = ip->tokbuf; + *ip->tokServp = '\0'; + + if ((c = inputGetc(ep)) < 0) { + return EJS_TOK_EOF; + } + + /* + * Main lexical analyser + */ + for (done = 0; !done; ) { + switch (c) { + case -1: + return EJS_TOK_EOF; + + case ' ': + case '\t': + case '\r': + do { + if ((c = inputGetc(ep)) < 0) + break; + } while (c == ' ' || c == '\t' || c == '\r'); + break; + + case '\n': + return EJS_TOK_NEWLINE; + + case '(': + tokenAddChar(ep, c); + return EJS_TOK_LPAREN; + + case ')': + tokenAddChar(ep, c); + return EJS_TOK_RPAREN; + + case '[': + tokenAddChar(ep, c); + return EJS_TOK_LBRACKET; + + case ']': + tokenAddChar(ep, c); + return EJS_TOK_RBRACKET; + + case '.': + tokenAddChar(ep, c); + return EJS_TOK_PERIOD; + + case '{': + tokenAddChar(ep, c); + return EJS_TOK_LBRACE; + + case '}': + tokenAddChar(ep, c); + return EJS_TOK_RBRACE; + + case '+': + if ((c = inputGetc(ep)) < 0) { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + if (c != '+' ) { + inputPutback(ep, c); + tokenAddChar(ep, EJS_EXPR_PLUS); + return EJS_TOK_EXPR; + } + tokenAddChar(ep, EJS_EXPR_INC); + return EJS_TOK_INC_DEC; + + case '-': + if ((c = inputGetc(ep)) < 0) { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + if (c != '-' ) { + inputPutback(ep, c); + tokenAddChar(ep, EJS_EXPR_MINUS); + return EJS_TOK_EXPR; + } + tokenAddChar(ep, EJS_EXPR_DEC); + return EJS_TOK_INC_DEC; + + case '*': + tokenAddChar(ep, EJS_EXPR_MUL); + return EJS_TOK_EXPR; + + case '%': + tokenAddChar(ep, EJS_EXPR_MOD); + return EJS_TOK_EXPR; + + case '/': + /* + * Handle the division operator and comments + */ + if ((c = inputGetc(ep)) < 0) { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + if (c != '*' && c != '/') { + inputPutback(ep, c); + tokenAddChar(ep, EJS_EXPR_DIV); + return EJS_TOK_EXPR; + } + style = c; + /* + * Eat comments. Both C and C++ comment styles are supported. + */ + while (1) { + if ((c = inputGetc(ep)) < 0) { + if (style == '/') { + return EJS_TOK_EOF; + } + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + if (c == '\n' && style == '/') { + break; + } else if (c == '*') { + c = inputGetc(ep); + if (style == '/') { + if (c == '\n') { + break; + } + } else { + if (c == '/') { + break; + } + } + } + } + /* + * Continue looking for a token, so get the next character + */ + if ((c = inputGetc(ep)) < 0) { + return EJS_TOK_EOF; + } + break; + + case '<': /* < and <= */ + if ((c = inputGetc(ep)) < 0) { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + if (c == '<') { + tokenAddChar(ep, EJS_EXPR_LSHIFT); + return EJS_TOK_EXPR; + } else if (c == '=') { + tokenAddChar(ep, EJS_EXPR_LESSEQ); + return EJS_TOK_EXPR; + } + tokenAddChar(ep, EJS_EXPR_LESS); + inputPutback(ep, c); + return EJS_TOK_EXPR; + + case '>': /* > and >= */ + if ((c = inputGetc(ep)) < 0) { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + if (c == '>') { + tokenAddChar(ep, EJS_EXPR_RSHIFT); + return EJS_TOK_EXPR; + } else if (c == '=') { + tokenAddChar(ep, EJS_EXPR_GREATEREQ); + return EJS_TOK_EXPR; + } + tokenAddChar(ep, EJS_EXPR_GREATER); + inputPutback(ep, c); + return EJS_TOK_EXPR; + + case '=': /* "==" */ + if ((c = inputGetc(ep)) < 0) { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + if (c == '=') { + tokenAddChar(ep, EJS_EXPR_EQ); + return EJS_TOK_EXPR; + } + inputPutback(ep, c); + return EJS_TOK_ASSIGNMENT; + + case '!': /* "!=" or "!"*/ + if ((c = inputGetc(ep)) < 0) { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + if (c == '=') { + tokenAddChar(ep, EJS_EXPR_NOTEQ); + return EJS_TOK_EXPR; + } + inputPutback(ep, c); + tokenAddChar(ep, EJS_EXPR_BOOL_COMP); + return EJS_TOK_EXPR; + + case ';': + tokenAddChar(ep, c); + return EJS_TOK_SEMI; + + case ',': + tokenAddChar(ep, c); + return EJS_TOK_COMMA; + + case ':': + tokenAddChar(ep, c); + return EJS_TOK_COLON; + + case '|': /* "||" */ + if ((c = inputGetc(ep)) < 0 || c != '|') { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + tokenAddChar(ep, EJS_COND_OR); + return EJS_TOK_LOGICAL; + + case '&': /* "&&" */ + if ((c = inputGetc(ep)) < 0 || c != '&') { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + tokenAddChar(ep, EJS_COND_AND); + return EJS_TOK_LOGICAL; + + case '\"': /* String quote */ + case '\'': + quote = c; + if ((c = inputGetc(ep)) < 0) { + ejsSyntaxError(ep, 0); + return EJS_TOK_ERR; + } + + while (c != quote) { + /* + * Check for escape sequence characters + */ + if (c == '\\') { + c = inputGetc(ep); + + if (isdigit(c)) { + /* + * Octal support, \101 maps to 65 = 'A'. Put first + * char back so converter will work properly. + */ + inputPutback(ep, c); + c = charConvert(ep, 8, 3); + + } else { + switch (c) { + case 'n': + c = '\n'; break; + case 'b': + c = '\b'; break; + case 'f': + c = '\f'; break; + case 'r': + c = '\r'; break; + case 't': + c = '\t'; break; + case 'x': + /* + * Hex support, \x41 maps to 65 = 'A' + */ + c = charConvert(ep, 16, 2); + break; + case 'u': + /* + * Unicode support, \x0401 maps to 65 = 'A' + */ + c = charConvert(ep, 16, 2); + c = c*16 + charConvert(ep, 16, 2); + + break; + case '\'': + case '\"': + case '\\': + break; + default: + if (tokenAddChar(ep, '\\') < 0) { + return EJS_TOK_ERR; + } + } + } + if (tokenAddChar(ep, c) < 0) { + return EJS_TOK_ERR; + } + } else { + if (tokenAddChar(ep, c) < 0) { + return EJS_TOK_ERR; + } + } + if ((c = inputGetc(ep)) < 0) { + ejsSyntaxError(ep, "Unmatched Quote"); + return EJS_TOK_ERR; + } + } + return EJS_TOK_LITERAL; + + case '0': + if (tokenAddChar(ep, c) < 0) { + return EJS_TOK_ERR; + } + if ((c = inputGetc(ep)) < 0) { + break; + } + if (tolower(c) == 'x') { + if (tokenAddChar(ep, c) < 0) { + return EJS_TOK_ERR; + } + if ((c = inputGetc(ep)) < 0) { + break; + } + isHex = 1; + if (! isxdigit(c)) { + parseNumber(ep, type); + inputPutback(ep, c); + return EJS_TOK_NUMBER; + } + } else if (! isdigit(c)) { +#if BLD_FEATURE_FLOATING_POINT + if (c == '.' || tolower(c) == 'e' || c == '+' || c == '-') { + /* Fall through */ + type = EJS_TYPE_FLOAT; + } else +#endif + { + parseNumber(ep, type); + inputPutback(ep, c); + return EJS_TOK_NUMBER; + } + } + /* Fall through to get more digits */ + + case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + if (isHex) { + do { + if (tokenAddChar(ep, c) < 0) { + return EJS_TOK_ERR; + } + if ((c = inputGetc(ep)) < 0) { + break; + } + } while (isxdigit(c)); + + } else { +#if BLD_FEATURE_FLOATING_POINT + do { + if (tokenAddChar(ep, c) < 0) { + return EJS_TOK_ERR; + } + if ((c = inputGetc(ep)) < 0) { + break; + } + c = tolower(c); + if (c == '.' || c == 'e' || c == 'f') { + type = EJS_TYPE_FLOAT; + } + } while (isdigit(c) || c == '.' || c == 'e' || + c == 'f' || + ((type == EJS_TYPE_FLOAT) && (c == '+' || c == '-'))); +#else + do { + if (tokenAddChar(ep, c) < 0) { + return EJS_TOK_ERR; + } + if ((c = inputGetc(ep)) < 0) { + break; + } + } while (isdigit(c)); +#endif + } + + parseNumber(ep, type); + inputPutback(ep, c); + return EJS_TOK_NUMBER; + + default: + /* + * Identifiers or a function names + */ + while (1) { + if (c == '\\') { + if ((c = inputGetc(ep)) < 0) { + break; + } + if (c == '\n' || c == '\r') { + break; + } + } else if (tokenAddChar(ep, c) < 0) { + break; + } + if ((c = inputGetc(ep)) < 0) { + break; + } + if (!isalnum(c) && c != '$' && c != '_' && + c != '\\' && c != '@') { + break; + } + } + if (*ep->token == '\0') { + c = inputGetc(ep); + break; + } + + if (! isalpha((int) *ep->token) && *ep->token != '$' && + *ep->token != '_' && *ep->token != '@') { + ejsError(ep, EJS_SYNTAX_ERROR, "Invalid identifier %s", + ep->token); + return EJS_TOK_ERR; + } + + tid = checkReservedWord(ep, state, c, EJS_TOK_ID); + if (tid != EJS_TOK_ID) { + return tid; + } + + /* + * Skip white space after token to find out whether this is + * a function or not. + */ + while (c == ' ' || c == '\t' || c == '\r' || c == '\n') { + if ((c = inputGetc(ep)) < 0) + break; + } + + tid = EJS_TOK_ID; + if ((strlen(ep->token) + 1) >= EJS_MAX_ID) { + ejsError(ep, EJS_SYNTAX_ERROR, + "Identifier too big. Max is %d letters.", EJS_MAX_ID); + return EJS_TOK_ERR; + } + done++; + } + } + + /* + * Putback the last extra character for next time + */ + inputPutback(ep, c); + return tid; +} + +/******************************************************************************/ + +static void parseNumber(Ejs *ep, EjsType type) +{ + switch (type) { + case EJS_TYPE_INT: + ep->tokenNumber.integer = ejsParseInteger(ep->token); + ep->tokenNumber.type = type; + break; + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + ep->tokenNumber.floating = atof(ep->token); + ep->tokenNumber.type = type; + break; +#endif + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + ep->tokenNumber.integer64 = ejsParseInteger64(ep->token); + ep->tokenNumber.type = type; + break; +#endif + } +} + +/******************************************************************************/ +/* + * Convert a hex or octal character back to binary, return original char if + * not a hex digit + */ + +static int charConvert(Ejs *ep, int base, int maxDig) +{ + int i, c, lval, convChar; + + lval = 0; + for (i = 0; i < maxDig; i++) { + if ((c = inputGetc(ep)) < 0) { + break; + } + /* + * Initialize to out of range value + */ + convChar = base; + if (isdigit(c)) { + convChar = c - '0'; + } else if (c >= 'a' && c <= 'f') { + convChar = c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + convChar = c - 'A' + 10; + } + /* + * If unexpected character then return it to buffer. + */ + if (convChar >= base) { + inputPutback(ep, c); + break; + } + lval = (lval * base) + convChar; + } + return lval; +} + +/******************************************************************************/ +/* + * Putback the last token read. Accept at most one push back token. + */ + +void ejsLexPutbackToken(Ejs *ep, int tid, char *string) +{ + EjsInput *ip; + EjsToken *tp; + int idx; + + mprAssert(ep); + ip = ep->input; + mprAssert(ip); + + ip->putBackIndex += 1; + + mprAssert(ip->putBackIndex < EJS_TOKEN_STACK); + idx = ip->putBackIndex; + + tp = &ip->putBack[idx]; + tp->tid = tid; + + mprStrcpy(tp->tokbuf, sizeof(tp->tokbuf), string); +} + +/******************************************************************************/ +/* + * Add a character to the token buffer + */ + +static int tokenAddChar(Ejs *ep, int c) +{ + EjsInput *ip; + + mprAssert(ep); + ip = ep->input; + mprAssert(ip); + + if (ip->tokEndp >= &ip->tokbuf[sizeof(ip->tokbuf) - 1]) { + ejsSyntaxError(ep, "Token too big"); + return -1; + } + *ip->tokEndp++ = c; + *ip->tokEndp = '\0'; + + return 0; +} + +/******************************************************************************/ +/* + * Get another input character + */ + +static int inputGetc(Ejs *ep) +{ + EjsInput *ip; + int c; + + mprAssert(ep); + ip = ep->input; + + if (ip->scriptSize <= 0) { + return -1; + } + + c = (uchar) (*ip->scriptServp++); + ip->scriptSize--; + + /* + * For debugging, accumulate the line number and the currenly parsed line + */ + if (c == '\n') { +#if 0 && BLD_DEBUG + if (ip->lineColumn > 0) { + printf("PARSED: %s\n", ip->line); + } +#endif + ip->lineNumber++; + ip->lineColumn = 0; + } else if ((ip->lineColumn + 2) < sizeof(ip->line)) { + ip->line[ip->lineColumn++] = c; + ip->line[ip->lineColumn] = '\0'; + } + return c; +} + +/******************************************************************************/ +/* + * Putback a character onto the input queue + */ + +static void inputPutback(Ejs *ep, int c) +{ + EjsInput *ip; + + mprAssert(ep); + + if (c > 0) { + ip = ep->input; + *--ip->scriptServp = c; + ip->scriptSize++; + if (--(ip->lineColumn) < 0) { + ip->lineColumn = 0; + } + mprAssert(ip->line); + mprAssert(ip->lineColumn >= 0); + mprAssert(ip->lineColumn < sizeof(ip->line)); + ip->line[ip->lineColumn] = '\0'; + } +} + +/******************************************************************************/ + +#else +void ejsLexDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/ejsParser.c b/source4/lib/appweb/ejs-2.0/ejs/ejsParser.c new file mode 100644 index 0000000000..9fce6d27ee --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/ejsParser.c @@ -0,0 +1,4514 @@ +/* + * @file ejsParser.c + * @brief EJS Parser and Execution + */ +/********************************* Copyright **********************************/ +/* + * @copy default.g + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. + * Portions Copyright (c) GoAhead Software, 1995-2000. 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 + */ + +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/****************************** Forward Declarations **************************/ + +static int createClass(Ejs *ep, EjsVar *parentClass, + const char *className, EjsVar *baseClass); +static int createProperty(Ejs *ep, EjsVar **obj, const char *id, + int state); +static int evalCond(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs); +static int evalExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs); +#if BLD_FEATURE_FLOATING_POINT +static int evalFloatExpr(Ejs *ep, double l, int rel, double r); +#endif +static int evalBoolExpr(Ejs *ep, int l, int rel, int r); +static int evalNumericExpr(Ejs *ep, EjsNum l, int rel, EjsNum r); +static int evalObjExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs) ; +static int evalStringExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs); +static int evalMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, int flags); +static EjsProperty *findProperty(Ejs *ep, EjsVar *op, const char *property, + int flags); +static EjsVar *pickSpace(Ejs *ep, int state, const char *property, int flags); +static void freeProc(Ejs *ep, EjsProc *proc); +static int parseArgs(Ejs *ep, int state, int flags); +static int parseArrayLiteral(Ejs *ep, int state, int flags, char *id); +static int parseAssignment(Ejs *ep, int state, int flags, char *id); +static int parseClass(Ejs *ep, int state, int flags); +static int parseForInner(Ejs *ep, int state, int flags, + EjsInput *condScript, EjsInput *incrScript, + EjsInput *bodyScript, EjsInput *endScript); +static int parseCond(Ejs *ep, int state, int flags); +static int parseDeclaration(Ejs *ep, int state, int flags); +static int parseExpr(Ejs *ep, int state, int flags); +static int parseFor(Ejs *ep, int state, int flags); +static int parseRegFor(Ejs *ep, int state, int flags); +static int parseForIn(Ejs *ep, int state, int flags, int each); +static int parseId(Ejs *ep, int state, int flags, char **id, int *done); +static int parseInc(Ejs *ep, int state, int flags); +static int parseIf(Ejs *ep, int state, int flags, int *done); +static int parseFunction(Ejs *ep, int state, int flags); +static int parseMethod(Ejs *ep, int state, int flags, char *id); +static int parseObjectLiteral(Ejs *ep, int state, int flags, char *id); +static int parseStmt(Ejs *ep, int state, int flags); +static int parseThrow(Ejs *ep, int state, int flags); +static int parseTry(Ejs *ep, int state, int flags); +static void removeNewlines(Ejs *ep, int state); +static EjsProperty *searchSpacesForProperty(Ejs *ep, int state, EjsVar *obj, + char *property, int flags); +static int assignPropertyValue(Ejs *ep, char *id, int state, EjsVar *value, + int flags); +static int updateProperty(Ejs *ep, EjsVar *obj, const char *id, int state, + EjsVar *value); +static void updateResult(Ejs *ep, int state, int flags, EjsVar *vp); +static int getNextNonSpaceToken(Ejs *ep, int state); + +static int callConstructor(Ejs *ep, EjsVar *thisObj, EjsVar *baseClass, + MprArray *args); +static int callCMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, + EjsVar *prototype); +static int callStringCMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, + EjsVar *prototype); +static int callMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, + EjsVar *prototype); +static int runMethod(Ejs *ep, EjsVar *thisObj, EjsVar *method, + const char *methodName, MprArray *args); + +static EjsInput *getInputStruct(Ejs *ep); +static void freeInputStruct(Ejs *ep, EjsInput *input); + +static void *pushFrame(Ejs *ep, int size); +static void *popFrame(Ejs *ep, int size); + +/************************************* Code ***********************************/ +/* + * Recursive descent parser for EJS + */ + +int ejsParse(Ejs *ep, int state, int flags) +{ + mprAssert(ep); + +#if MOB + if (mprStackCheck(ep)) { + char *stack; + stack = ejsFormatStack(ep); + mprLog(ep, 0, "\nStack grew : MAX %d\n", mprStackSize(ep)); + mprLog(ep, 0, "Stack\n %s\n", stack); + mprFree(stack); + } +#endif + + if (ep->flags & EJS_FLAGS_EXIT) { + return EJS_STATE_RET; + } + + ep->inputMarker = ep->input->scriptServp; + + switch (state) { + /* + * Any statement, method arguments or conditional expressions + */ + case EJS_STATE_STMT: + state = parseStmt(ep, state, flags); + if (state != EJS_STATE_STMT_BLOCK_DONE && state != EJS_STATE_STMT_DONE){ + goto err; + } + break; + + case EJS_STATE_DEC: + state = parseStmt(ep, state, flags); + if (state != EJS_STATE_DEC_DONE) { + goto err; + } + break; + + case EJS_STATE_EXPR: + state = parseStmt(ep, state, flags); + if (state != EJS_STATE_EXPR_DONE) { + goto err; + } + break; + + /* + * Variable declaration list + */ + case EJS_STATE_DEC_LIST: + state = parseDeclaration(ep, state, flags); + if (state != EJS_STATE_DEC_LIST_DONE) { + goto err; + } + break; + + /* + * Method argument string + */ + case EJS_STATE_ARG_LIST: + state = parseArgs(ep, state, flags); + if (state != EJS_STATE_ARG_LIST_DONE) { + goto err; + } + break; + + /* + * Logical condition list (relational operations separated by &&, ||) + */ + case EJS_STATE_COND: + state = parseCond(ep, state, flags); + if (state != EJS_STATE_COND_DONE) { + goto err; + } + break; + + /* + * Expression list + */ + case EJS_STATE_RELEXP: + state = parseExpr(ep, state, flags); + if (state != EJS_STATE_RELEXP_DONE) { + goto err; + } + break; + } + + /* + * Recursion protection + */ + if (ep->input->scriptServp == ep->inputMarker) { + if (ep->recurseCount++ > 20) { + ejsSyntaxError(ep, "Input syntax error"); + state = EJS_STATE_ERR; + } + } else { + ep->recurseCount = 0; + } + + if (state == EJS_STATE_RET || state == EJS_STATE_EOF) { + return state; + } + +done: + return state; + +err: + if (state == EJS_STATE_RET || state == EJS_STATE_EOF) { + goto done; + } + if (state != EJS_STATE_ERR) { + ejsSyntaxError(ep, 0); + } + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct ParseStmt { + EjsProc *saveProc; + EjsProperty *pp; + EjsVar *saveObj, *exception; + char *str, *id; + int done, tid, rs, saveObjPerm, expectEndOfStmt; +} ParseStmt; + +/* + * Parse expression (leftHandSide operator rightHandSide) + */ + + +static int parseStmt(Ejs *ep, int state, int flags) +{ + ParseStmt *sp; + + mprAssert(ep); + + if ((sp = pushFrame(ep, sizeof(ParseStmt))) == 0) { + return EJS_STATE_ERR; + } + + sp->id = 0; + sp->expectEndOfStmt = 0; + sp->saveProc = NULL; + + ep->currentObj = 0; + ep->currentProperty = 0; + + for (sp->done = 0; !sp->done && state != EJS_STATE_ERR; ) { + sp->tid = ejsLexGetToken(ep, state); + +#if (WIN || BREW_SIMULATOR) && BLD_DEBUG && DISABLED + /* MOB -- make cross platform */ + _CrtCheckMemory(); +#endif + + switch (sp->tid) { + default: + ejsLexPutbackToken(ep, sp->tid, ep->token); + goto done; + + case EJS_TOK_EXPR: + if (state == EJS_STATE_EXPR) { + ejsLexPutbackToken(ep, EJS_TOK_EXPR, ep->token); + } + goto done; + + case EJS_TOK_LOGICAL: + ejsLexPutbackToken(ep, sp->tid, ep->token); + goto done; + + case EJS_TOK_ERR: + if (state != EJS_STATE_ERR && !ep->gotException) { + ejsSyntaxError(ep, 0); + } + state = EJS_STATE_ERR; + goto done; + + case EJS_TOK_EOF: + state = EJS_STATE_EOF; + goto done; + + case EJS_TOK_NEWLINE: + break; + + case EJS_TOK_SEMI: + /* + * This case is when we discover no statement and just a lone ';' + */ + if (state != EJS_STATE_STMT) { + ejsLexPutbackToken(ep, sp->tid, ep->token); + } + goto done; + + case EJS_TOK_LBRACKET: + if (flags & EJS_FLAGS_EXE) { + ep->currentObj = &ep->currentProperty->var; + if (ep->currentObj != 0 && ep->currentObj->type != + EJS_TYPE_OBJECT) { + ejsError(ep, EJS_REFERENCE_ERROR, + "Property reference to a non-object type \"%s\"\n", + sp->id); + goto err; + } + } + + sp->saveObj = ep->currentObj; + sp->saveObjPerm = ejsMakeObjPermanent(sp->saveObj, 1); + + sp->rs = ejsParse(ep, EJS_STATE_RELEXP, flags); + + ejsMakeObjPermanent(sp->saveObj, sp->saveObjPerm); + ep->currentObj = sp->saveObj; + + if (sp->rs < 0) { + state = sp->rs; + goto done; + } + + mprFree(sp->id); + /* MOB rc */ + sp->str = ejsVarToString(ep, ep->result); + sp->id = mprStrdup(ep, sp->str); + + if (sp->id[0] == '\0') { + if (flags & EJS_FLAGS_EXE) { + ejsError(ep, EJS_RANGE_ERROR, + "[] expression evaluates to the empty string\n"); + goto err; + } + } else { + sp->pp = searchSpacesForProperty(ep, state, ep->currentObj, + sp->id, flags); + ep->currentProperty = sp->pp; + updateResult(ep, state, flags, ejsGetVarPtr(sp->pp)); + } + + if ((sp->tid = ejsLexGetToken(ep, state)) != EJS_TOK_RBRACKET) { + ejsSyntaxError(ep, "Missing ']'"); + goto err; + } + break; + + case EJS_TOK_PERIOD: + if (flags & EJS_FLAGS_EXE) { + if (ep->currentProperty == 0) { + ejsError(ep, EJS_REFERENCE_ERROR, + "Undefined object \"%s\"", sp->id); + goto err; + } + } + ep->currentObj = &ep->currentProperty->var; + if (flags & EJS_FLAGS_EXE) { + if (ep->currentObj != 0 && ep->currentObj->type != + EJS_TYPE_OBJECT) { + ejsError(ep, EJS_REFERENCE_ERROR, + "Property reference to a non-object type \"%s\"\n", + sp->id); + goto err; + } + } + if ((sp->tid = ejsLexGetToken(ep, state)) != EJS_TOK_ID) { + ejsError(ep, EJS_REFERENCE_ERROR, "Bad property after '.': %s", + ep->token); + goto err; + } + /* Fall through */ + + case EJS_TOK_ID: + state = parseId(ep, state, flags, &sp->id, &sp->done); + if (sp->done && state == EJS_STATE_STMT) { + sp->expectEndOfStmt = 1; + } + break; + + case EJS_TOK_ASSIGNMENT: + sp->tid = ejsLexGetToken(ep, state); + if (sp->tid == EJS_TOK_LBRACE) { + /* + * var = { name: value, name: value, ... } + */ + if (parseObjectLiteral(ep, state, flags, sp->id) < 0) { + ejsSyntaxError(ep, "Bad object literal"); + goto err; + } + + } else if (sp->tid == EJS_TOK_LBRACKET) { + /* + * var = [ array elements ] + */ + if (parseArrayLiteral(ep, state, flags, sp->id) < 0) { + ejsSyntaxError(ep, "Bad array literal"); + goto err; + } + + } else if (sp->tid == EJS_TOK_EXPR && + (int) *ep->token == EJS_EXPR_LESS) { + /* + * var = <xmlTag> .../</xmlTag> + */ + ejsSyntaxError(ep, "XML literals are not yet supported"); + goto err; + + } else { + /* + * var = expression + */ + ejsLexPutbackToken(ep, sp->tid, ep->token); + state = parseAssignment(ep, state, flags, sp->id); + if (state == EJS_STATE_ERR) { + if (ep->flags & EJS_FLAGS_EXIT) { + state = EJS_STATE_RET; + goto done; + } + if (!ep->gotException) { + ejsSyntaxError(ep, 0); + } + goto err; + } + } + + if (flags & EJS_FLAGS_EXE) { + if (assignPropertyValue(ep, sp->id, state, ep->result, + flags) < 0) { + if (ep->gotException == 0) { + ejsError(ep, EJS_EVAL_ERROR, "Can't set property %s", + sp->id); + } + goto err; + } + } + + if (state == EJS_STATE_STMT) { + sp->expectEndOfStmt = 1; + goto done; + } + break; + + case EJS_TOK_INC_DEC: + state = parseInc(ep, state, flags); + if (state == EJS_STATE_STMT) { + sp->expectEndOfStmt = 1; + } + break; + + case EJS_TOK_NEW: + /* MOB -- could we remove rs and just use state */ + sp->rs = ejsParse(ep, EJS_STATE_EXPR, flags | EJS_FLAGS_NEW); + if (sp->rs < 0) { + state = sp->rs; + goto done; + } + break; + + case EJS_TOK_DELETE: + sp->rs = ejsParse(ep, EJS_STATE_EXPR, flags | EJS_FLAGS_DELETE); + if (sp->rs < 0) { + state = sp->rs; + goto done; + } + if (flags & EJS_FLAGS_EXE) { + /* Single place where properties are deleted */ + if (ep->currentObj == 0 || ep->currentProperty == 0) { + ejsError(ep, EJS_EVAL_ERROR, + "Can't find property to delete"); + goto err; + } + if (ep->currentObj->isArray) { + ejsSetArrayLength(ep, ep->currentObj, 0, + ep->currentProperty->name, 0); + } + ejsDeleteProperty(ep, ep->currentObj, + ep->currentProperty->name); + ep->currentProperty = 0; + } + goto done; + + case EJS_TOK_FUNCTION: + /* + * Parse a function declaration + */ + state = parseFunction(ep, state, flags); + goto done; + + case EJS_TOK_THROW: + state = parseThrow(ep, state, flags); + goto done; + + case EJS_TOK_TRY: + state = parseTry(ep, state, flags); + goto done; + + case EJS_TOK_CLASS: + case EJS_TOK_MODULE: + state = parseClass(ep, state, flags); + goto done; + + case EJS_TOK_LITERAL: + /* + * Set the result to the string literal + */ + if (flags & EJS_FLAGS_EXE) { + ejsWriteVarAsString(ep, ep->result, ep->token); + ejsSetVarName(ep, ep->result, ""); + } + if (state == EJS_STATE_STMT) { + sp->expectEndOfStmt = 1; + } + goto done; + + case EJS_TOK_NUMBER: + /* + * Set the result to the parsed number + */ + if (flags & EJS_FLAGS_EXE) { + ejsWriteVar(ep, ep->result, &ep->tokenNumber, 0); + } + if (state == EJS_STATE_STMT) { + sp->expectEndOfStmt = 1; + } + goto done; + + case EJS_TOK_METHOD_NAME: + /* + * parse a method() invocation + */ + mprAssert(ep->currentObj); + state = parseMethod(ep, state, flags, sp->id); + if (state == EJS_STATE_STMT) { + sp->expectEndOfStmt = 1; + } + if (ep->flags & EJS_FLAGS_EXIT) { + state = EJS_STATE_RET; + } + goto done; + + case EJS_TOK_IF: + state = parseIf(ep, state, flags, &sp->done); + if (state < 0) { + goto done; + } + break; + + case EJS_TOK_FOR: + state = parseFor(ep, state, flags); + goto done; + + case EJS_TOK_VAR: + if ((sp->rs = ejsParse(ep, EJS_STATE_DEC_LIST, flags)) < 0) { + state = sp->rs; + goto done; + } + goto done; + + case EJS_TOK_COMMA: + ejsLexPutbackToken(ep, sp->tid, ep->token); + goto done; + + case EJS_TOK_LPAREN: + if (state == EJS_STATE_EXPR) { + if ((sp->rs = ejsParse(ep, EJS_STATE_RELEXP, flags)) < 0) { + state = sp->rs; + goto done; + } + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + ejsSyntaxError(ep, 0); + goto err; + } + goto done; + + } else if (state == EJS_STATE_STMT) { + ejsLexPutbackToken(ep, EJS_TOK_METHOD_NAME, ep->token); + } + break; + + case EJS_TOK_RPAREN: + ejsLexPutbackToken(ep, sp->tid, ep->token); + goto done; + + case EJS_TOK_EXTENDS: + if (! (flags & EJS_FLAGS_CLASS_DEC)) { + ejsSyntaxError(ep, 0); + goto err; + } + sp->saveObj = ep->currentObj; + sp->saveObjPerm = ejsMakeObjPermanent(sp->saveObj, 1); + + sp->rs = ejsParse(ep, EJS_STATE_STMT, flags); + ejsMakeObjPermanent(sp->saveObj, sp->saveObjPerm); + + if (sp->rs < 0) { + state = sp->rs; + goto done; + } + + if (flags & EJS_FLAGS_EXE) { + if (createClass(ep, sp->saveObj, sp->id, + ejsGetVarPtr(ep->currentProperty)) < 0) { + goto err; + } + } + if (ejsLexGetToken(ep, state) != EJS_TOK_LBRACE) { + ejsSyntaxError(ep, 0); + goto err; + } + ejsLexPutbackToken(ep, ep->tid, ep->token); + goto done; + + case EJS_TOK_LBRACE: + if (flags & EJS_FLAGS_CLASS_DEC) { + if (state == EJS_STATE_DEC) { + if (flags & EJS_FLAGS_EXE) { + if (createClass(ep, ep->currentObj, sp->id, 0) < 0) { + goto err; + } + } + ejsLexPutbackToken(ep, sp->tid, ep->token); + + } else if (state == EJS_STATE_STMT) { + ejsLexPutbackToken(ep, sp->tid, ep->token); + } + goto done; + } + + /* + * This handles any code in braces except "if () {} else {}" + */ + if (state != EJS_STATE_STMT) { + ejsSyntaxError(ep, 0); + goto err; + } + + /* + * Parse will return EJS_STATE_STMT_BLOCK_DONE when the RBRACE + * is seen. + */ + sp->exception = 0; + do { + state = ejsParse(ep, EJS_STATE_STMT, flags); + if (state == EJS_STATE_ERR) { + /* + * We need to keep parsing to get to the end of the block + */ + if (sp->exception == 0) { + sp->exception = ejsDupVar(ep, ep->result, + EJS_SHALLOW_COPY); + if (sp->exception == 0) { + ejsMemoryError(ep); + goto err; + } + if (sp->exception->type == EJS_TYPE_OBJECT) { + ejsMakeObjLive(sp->exception, 0); + mprAssert(sp->exception->objectState->alive == 0); + } + + /* + * If we're in a try block, we need to keep parsing + * so we can find the end of the block and the start + * of the catch block. Otherwise, we are done. + */ + if (!(flags & EJS_FLAGS_TRY)) { + break; + } + } + flags &= ~EJS_FLAGS_EXE; + if (ep->recurseCount > 20) { + break; + } + state = EJS_STATE_STMT_DONE; + ep->gotException = 0; + } + + } while (state == EJS_STATE_STMT_DONE); + + if (sp->exception) { + ep->gotException = 1; + ejsWriteVar(ep, ep->result, sp->exception, EJS_SHALLOW_COPY); + + /* Eat the closing brace */ + ejsLexGetToken(ep, state); + ejsFreeVar(ep, sp->exception); + + goto err; + } + ejsFreeVar(ep, sp->exception); + + if (state < 0) { + goto done; + } + + if (ejsLexGetToken(ep, state) != EJS_TOK_RBRACE) { + ejsSyntaxError(ep, 0); + goto err; + } + state = EJS_STATE_STMT_DONE; + goto done; + + case EJS_TOK_RBRACE: + if (state == EJS_STATE_STMT) { + ejsLexPutbackToken(ep, sp->tid, ep->token); + state = EJS_STATE_STMT_BLOCK_DONE; + + } else if (state == EJS_STATE_EXPR) { + ejsLexPutbackToken(ep, sp->tid, ep->token); + state = EJS_STATE_EXPR; + + } else { + ejsSyntaxError(ep, 0); + state = EJS_STATE_ERR; + } + goto done; + + case EJS_TOK_RETURN: + if ((sp->rs = ejsParse(ep, EJS_STATE_RELEXP, flags)) < 0) { + state = sp->rs; + goto done; + } + if (flags & EJS_FLAGS_EXE) { + state = EJS_STATE_RET; + goto done; + } + break; + } + } +done: + mprFree(sp->id); + + if (sp->expectEndOfStmt && state >= 0) { + sp->tid = ejsLexGetToken(ep, state); + if (sp->tid == EJS_TOK_RBRACE) { + ejsLexPutbackToken(ep, EJS_TOK_RBRACE, ep->token); + + } else if (sp->tid != EJS_TOK_SEMI && sp->tid != EJS_TOK_NEWLINE && + sp->tid != EJS_TOK_EOF) { + ejsSyntaxError(ep, 0); + state = EJS_STATE_ERR; + + } else { + /* + * Skip newlines after semi-colon + */ + removeNewlines(ep, state); + } + } + + /* + * Advance the state + */ + switch (state) { + case EJS_STATE_STMT: + case EJS_STATE_STMT_DONE: + state = EJS_STATE_STMT_DONE; + break; + + case EJS_STATE_DEC: + case EJS_STATE_DEC_DONE: + state = EJS_STATE_DEC_DONE; + break; + + case EJS_STATE_EXPR: + case EJS_STATE_EXPR_DONE: + state = EJS_STATE_EXPR_DONE; + break; + + case EJS_STATE_STMT_BLOCK_DONE: + case EJS_STATE_EOF: + case EJS_STATE_RET: + break; + + default: + if (state != EJS_STATE_ERR) { + ejsSyntaxError(ep, 0); + } + state = EJS_STATE_ERR; + } + popFrame(ep, sizeof(ParseStmt)); + return state; + +err: + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct ParseFor { + char *initToken; + int tid, foundVar, initId, each; +} ParseFor; + +/* + * Parse method arguments + */ + +static int parseFor(Ejs *ep, int state, int flags) +{ + ParseFor *sp; + + if ((sp = pushFrame(ep, sizeof(ParseFor))) == 0) { + return EJS_STATE_ERR; + } + + mprAssert(ep); + + if (state != EJS_STATE_STMT) { + ejsSyntaxError(ep, 0); + goto err; + } + + if ((sp->tid = ejsLexGetToken(ep, state)) == EJS_TOK_EACH) { + sp->each = 1; + sp->tid = ejsLexGetToken(ep, state); + + } else { + sp->each = 0; + } + + if (sp->tid != EJS_TOK_LPAREN) { + ejsSyntaxError(ep, 0); + goto err; + } + + /* + * Need to peek 2-3 tokens ahead and see if this is a + * for [each] ([var] x in set) + * or + * for (init ; whileCond; incr) + */ + sp->initId = ejsLexGetToken(ep, EJS_STATE_EXPR); + sp->foundVar = 0; + if (sp->initId == EJS_TOK_ID && strcmp(ep->token, "var") == 0) { + sp->foundVar = 1; + sp->initId = ejsLexGetToken(ep, EJS_STATE_EXPR); + } + sp->initToken = mprStrdup(ep, ep->token); + + sp->tid = ejsLexGetToken(ep, EJS_STATE_EXPR); + + ejsLexPutbackToken(ep, sp->tid, ep->token); + ejsLexPutbackToken(ep, sp->initId, sp->initToken); + mprFree(sp->initToken); + + if (sp->foundVar) { + ejsLexPutbackToken(ep, EJS_TOK_ID, "var"); + } + + if (sp->tid == EJS_TOK_IN) { + state = parseForIn(ep, state, flags, sp->each); + + } else { + state = parseRegFor(ep, state, flags); + } + +done: + popFrame(ep, sizeof(ParseFor)); + return state; + +err: + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Parse method arguments + */ + +static int parseArgs(Ejs *ep, int state, int flags) +{ + EjsVar *vp; + int tid; + + mprAssert(ep); + + do { + /* + * Peek and see if there are no args + */ + tid = ejsLexGetToken(ep, state); + ejsLexPutbackToken(ep, tid, ep->token); + if (tid == EJS_TOK_RPAREN) { + break; + } + + /* + * If this is part of a constructor, must run methods in args normally + */ + flags &= ~EJS_FLAGS_NEW; + + state = ejsParse(ep, EJS_STATE_RELEXP, flags); + if (state < 0) { + return state; + } + if (flags & EJS_FLAGS_EXE) { + mprAssert(ep->proc->args); + vp = ejsDupVar(ep, ep->result, EJS_SHALLOW_COPY); + if (vp == 0) { + ejsMemoryError(ep); + return EJS_STATE_ERR; + } + /* MOB */ + if (vp->type == EJS_TYPE_OBJECT) { + ejsMakeObjLive(vp, 0); + mprAssert(vp->objectState->alive == 0); + } + + /* + * Propagate the name + */ + ejsSetVarName(ep, vp, ep->result->propertyName); + + mprAddItem(ep->proc->args, vp); + + } + /* + * Peek at the next token, continue if more args (ie. comma seen) + */ + tid = ejsLexGetToken(ep, state); + if (tid != EJS_TOK_COMMA) { + ejsLexPutbackToken(ep, tid, ep->token); + } + } while (tid == EJS_TOK_COMMA); + + if (tid != EJS_TOK_RPAREN && state != EJS_STATE_RELEXP_DONE) { + ejsSyntaxError(ep, 0); + return EJS_STATE_ERR; + } + return EJS_STATE_ARG_LIST_DONE; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct ParseAssign { + EjsProperty *saveProperty; + EjsVar *saveObj; + int saveObjPerm, savePropPerm, rc; +} ParseAssign; + +/* + * Parse an assignment statement + */ + +static int parseAssignment(Ejs *ep, int state, int flags, char *id) +{ + ParseAssign *sp; + + + if (id == 0) { + if (!ep->gotException) { + ejsSyntaxError(ep, 0); + } + return EJS_STATE_ERR; + } + + if ((sp = pushFrame(ep, sizeof(ParseAssign))) == 0) { + return EJS_STATE_ERR; + } + + mprAssert(ep->currentObj); + + /* + * Parse the right hand side of the "=" + */ + sp->saveObj = ep->currentObj; + sp->saveProperty = ep->currentProperty; + + sp->saveObjPerm = ejsMakeObjPermanent(sp->saveObj, 1); + sp->savePropPerm = ejsMakeObjPermanent(ejsGetVarPtr(sp->saveProperty), 1); + + sp->rc = ejsParse(ep, EJS_STATE_RELEXP, flags | EJS_FLAGS_ASSIGNMENT); + + ejsMakeObjPermanent(sp->saveObj, sp->saveObjPerm); + ejsMakeObjPermanent(ejsGetVarPtr(sp->saveProperty), sp->savePropPerm); + + if (sp->rc < 0) { + state = EJS_STATE_ERR; + } + + ep->currentObj = sp->saveObj; + ep->currentProperty = sp->saveProperty; + + popFrame(ep, sizeof(ParseAssign)); + + if (! (flags & EJS_FLAGS_EXE)) { + return state; + } + + return state; +} + +/******************************************************************************/ + +static int assignPropertyValue(Ejs *ep, char *id, int state, EjsVar *value, + int flags) +{ + EjsProperty *saveProperty; + EjsVar *saveObj, *obj, *vp; + char *procName; + int saveObjPerm, savePropPerm, rc; + + mprAssert(flags & EJS_FLAGS_EXE); + + if (ep->currentProperty && + !ep->currentProperty->var.flags & EJS_GET_ACCESSOR) { + obj = ep->currentObj; + + } else { + /* + * Handle any set accessors. + * FUTURE OPT -- could be faster + * FUTURE OPT -- coming here even when doing just a set "x = value"; + */ + procName = 0; + if (mprAllocStrcat(MPR_LOC_ARGS(ep), &procName, EJS_MAX_ID + 5, 0, + "-set-", id, 0) > 0) { + + MprArray *args; + + ep->currentProperty = searchSpacesForProperty(ep, state, + ep->currentObj, procName, flags); + + if (ep->currentProperty) { + args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS); + + vp = ejsDupVar(ep, value, EJS_SHALLOW_COPY); + mprAddItem(args, vp); + mprAssert(! ejsObjIsCollectable(vp)); + + saveObj = ep->currentObj; + saveProperty = ep->currentProperty; + + saveObjPerm = ejsMakeObjPermanent(saveObj, 1); + savePropPerm = ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), + 1); + + /* + * Invoke the set accessor + */ + rc = ejsRunMethod(ep, ep->currentObj, procName, args); + mprFree(procName); + ejsFreeMethodArgs(ep, args); + + ejsMakeObjPermanent(saveObj, saveObjPerm); + ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), savePropPerm); + + ep->currentObj = saveObj; + ep->currentProperty = saveProperty; + + if (rc < 0) { + return EJS_STATE_ERR; + } + return state; + } + mprFree(procName); + } + + if (ep->currentProperty == 0) { + /* + * MOB -- can we omit this as updateProperty below will create + */ + if (createProperty(ep, &obj, id, state) < 0) { + return EJS_STATE_ERR; + } + } + } + + if (updateProperty(ep, obj, id, state, value) < 0) { + return EJS_STATE_ERR; + } + + vp = ejsGetVarPtr(ep->currentProperty); + if (vp->type == EJS_TYPE_OBJECT) { + ejsMakeObjLive(vp, 1); + } + + return state; +} + +/******************************************************************************/ + +static int parseObjectLiteral(Ejs *ep, int state, int flags, char *id) +{ + EjsProperty *saveProperty; + EjsVar *saveObj; + EjsVar *obj; + char *name; + int saveObjPerm, savePropPerm, tid; + + name = 0; + + saveObj = ep->currentObj; + saveProperty = ep->currentProperty; + + saveObjPerm = ejsMakeObjPermanent(saveObj, 1); + savePropPerm = ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), 1); + + if (flags & EJS_FLAGS_EXE) { + obj = ejsCreateSimpleObj(ep, "Object"); + if (obj == 0) { + ejsMemoryError(ep); + goto err; + } + mprAssert(! ejsObjIsCollectable(obj)); + + } else { + obj = 0; + } + + do { + tid = getNextNonSpaceToken(ep, state); + if (tid != EJS_TOK_ID) { + ejsSyntaxError(ep, 0); + goto err; + } + name = mprStrdup(ep, ep->token); + + tid = getNextNonSpaceToken(ep, state); + if (tid != EJS_TOK_COLON) { + ejsSyntaxError(ep, 0); + goto err; + } + + if (flags & EJS_FLAGS_EXE) { + /* FUTURE OPT -- can we optimize this. We are double accessing id + with the Put below. Should we be using this or ejsSetProperty + */ + if (ejsCreatePropertyMethod(ep, obj, name) == 0) { + ejsMemoryError(ep); + goto err; + } + } + + if (ejsParse(ep, EJS_STATE_RELEXP, flags) < 0) { + goto err; + } + if (flags & EJS_FLAGS_EXE) { + if (ejsSetPropertyMethod(ep, obj, name, ep->result) == 0) { + ejsMemoryError(ep); + goto err; + } + } + mprFree(name); + name = 0; + + tid = getNextNonSpaceToken(ep, state); + + } while (tid == EJS_TOK_COMMA); + + if (tid != EJS_TOK_RBRACE) { + ejsSyntaxError(ep, 0); + goto err; + } + + if (flags & EJS_FLAGS_EXE) { + ejsMakeObjLive(obj, 1); + ejsWriteVar(ep, ep->result, obj, EJS_SHALLOW_COPY); + } + +done: + ejsMakeObjPermanent(saveObj, saveObjPerm); + ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), savePropPerm); + + ep->currentObj = saveObj; + ep->currentProperty = saveProperty; + + if (obj) { + ejsFreeVar(ep, obj); + } + return state; + +err: + mprFree(name); + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ + +static int parseArrayLiteral(Ejs *ep, int state, int flags, char *id) +{ + EjsProperty *saveProperty; + EjsVar *saveObj; + EjsVar *obj; + int saveObjPerm, savePropPerm, tid; + + saveObj = ep->currentObj; + saveProperty = ep->currentProperty; + + saveObjPerm = ejsMakeObjPermanent(saveObj, 1); + savePropPerm = ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), 1); + + if (flags & EJS_FLAGS_EXE) { + obj = ejsCreateArray(ep, 0); + if (obj == 0) { + ejsMemoryError(ep); + goto err; + } + mprAssert(! ejsObjIsCollectable(obj)); + + } else { + obj = 0; + } + + do { + if (ejsParse(ep, EJS_STATE_RELEXP, flags) < 0) { + goto err; + } + if (flags & EJS_FLAGS_EXE) { + /* MOB _- should this be put[array.length] */ + if (ejsAddArrayElt(ep, obj, ep->result, EJS_SHALLOW_COPY) == 0) { + goto err; + } + } + + tid = getNextNonSpaceToken(ep, state); + + } while (tid == EJS_TOK_COMMA); + + if (tid != EJS_TOK_RBRACKET) { + ejsSyntaxError(ep, "Missing right bracket"); + goto err; + } + + if (flags & EJS_FLAGS_EXE) { + ejsMakeObjLive(obj, 1); + ejsWriteVar(ep, ep->result, obj, EJS_SHALLOW_COPY); + } + +done: + ejsMakeObjPermanent(saveObj, saveObjPerm); + ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), savePropPerm); + + ep->currentObj = saveObj; + ep->currentProperty = saveProperty; + + ejsFreeVar(ep, obj); + return state; + +err: + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Create a property. + */ + +/* +MOB -- simplify this. Enforce ep->currentObj to be always set. +Then we can delete this and just call + + ejsCreatePropertyMethod(ep->currentObj, id); +*/ +//XX +static int createProperty(Ejs *ep, EjsVar **objp, const char *id, int state) +{ + EjsVar *obj, *vp; + + mprAssert(id && *id); + mprAssert(objp); + + /* + * Determine the variable scope to use for the property. + * Standard says: "var x" means declare locally. + * "x = 2" means declare globally if x is undefined. + */ + if (ep->currentObj) { + if (ep->currentObj->type != EJS_TYPE_OBJECT) { + ejsSyntaxError(ep, "Reference is not an object"); + return EJS_STATE_ERR; + } + obj = ep->currentObj; + + } else { + /* MOB -- we should never be doing this here. ep->currentObj should + always be set already */ + obj = (state == EJS_STATE_DEC) ? ep->local : ep->global; + } + mprAssert(obj); + + vp = ejsCreatePropertyMethod(ep, obj, id); + if (vp == 0) { + if (!ep->gotException) { + ejsMemoryError(ep); + } + return EJS_STATE_ERR; + } + + *objp = obj; + return state; +} + +/******************************************************************************/ +/* + * Update a property. + * + * Return with ep->currentProperty updated to point to the property. + */ + +static int updateProperty(Ejs *ep, EjsVar *obj, const char *id, int state, + EjsVar *value) +{ + EjsVar *vp; + + /* + * MOB -- do ready-only check here + */ + vp = ejsSetPropertyMethod(ep, obj, id, value); + if (vp == 0) { + ejsMemoryError(ep); + return EJS_STATE_ERR; + } + ep->currentProperty = ejsGetPropertyPtr(vp); + + obj->objectState->dirty = 1; + + return state; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct ParseCond { + EjsVar lhs, rhs; + int tid, operator; +} ParseCond; + +/* + * Parse conditional expression (relational ops separated by ||, &&) + */ + +static int parseCond(Ejs *ep, int state, int flags) +{ + ParseCond *sp; + + if ((sp = pushFrame(ep, sizeof(ParseCond))) == 0) { + return EJS_STATE_ERR; + } + + mprAssert(ep); + + if (flags & EJS_FLAGS_EXE) { + ejsClearVar(ep, ep->result); + } + + sp->lhs.type = sp->rhs.type = EJS_TYPE_UNDEFINED; + sp->lhs.objectState = sp->rhs.objectState = 0; + sp->lhs.allocatedData = sp->rhs.allocatedData = 0; + + ejsSetVarName(ep, &sp->lhs, "lhs"); + ejsSetVarName(ep, &sp->rhs, "rhs"); + + sp->operator = 0; + + do { + /* + * Recurse to handle one side of a conditional. Accumulate the + * left hand side and the final result in ep->result. + */ + state = ejsParse(ep, EJS_STATE_RELEXP, flags); + if (state < 0) { + break; + } + + if (flags & EJS_FLAGS_EXE) { + if (sp->operator > 0) { + /* + * FUTURE -- does not do precedence + */ + ejsWriteVar(ep, &sp->rhs, ep->result, EJS_SHALLOW_COPY); + if (evalCond(ep, &sp->lhs, sp->operator, &sp->rhs) < 0) { + state = EJS_STATE_ERR; + break; + } + /* Result left in ep->result */ + /* MOB */ + if (sp->lhs.type == EJS_TYPE_OBJECT) { + mprAssert(sp->lhs.objectState->alive == 0); + } + if (sp->rhs.type == EJS_TYPE_OBJECT) { + mprAssert(sp->rhs.objectState->alive == 0); + } + } + } + + sp->tid = ejsLexGetToken(ep, state); + if (sp->tid == EJS_TOK_LOGICAL) { + sp->operator = (int) *ep->token; + + } else if (sp->tid == EJS_TOK_RPAREN || sp->tid == EJS_TOK_SEMI) { + ejsLexPutbackToken(ep, sp->tid, ep->token); + state = EJS_STATE_COND_DONE; + break; + + } else { + ejsLexPutbackToken(ep, sp->tid, ep->token); + } + + if (flags & EJS_FLAGS_EXE) { + ejsWriteVar(ep, &sp->lhs, ep->result, EJS_SHALLOW_COPY); + } + + } while (state == EJS_STATE_RELEXP_DONE); + + ejsClearVar(ep, &sp->lhs); + ejsClearVar(ep, &sp->rhs); + + popFrame(ep, sizeof(ParseCond)); + + return state; +} + +/******************************************************************************/ +/* + * Parse variable declaration list. Declarations can be of the following forms: + * var x; + * var x, y, z; + * var x = 1 + 2 / 3, y = 2 + 4; + * var x = { property: value, property: value ... }; + * var x = [ property: value, property: value ... ]; + * + * We set the variable to NULL if there is no associated assignment. + */ + +static int parseDeclaration(Ejs *ep, int state, int flags) +{ + int tid; + + mprAssert(ep); + + do { + if ((tid = ejsLexGetToken(ep, state)) != EJS_TOK_ID) { + ejsSyntaxError(ep, 0); + return EJS_STATE_ERR; + } + ejsLexPutbackToken(ep, tid, ep->token); + + /* + * Parse the entire assignment or simple identifier declaration + */ + if (ejsParse(ep, EJS_STATE_DEC, flags) != EJS_STATE_DEC_DONE) { + return EJS_STATE_ERR; + } + + /* + * Peek at the next token, continue if comma seen + * Stop on ";" or "in" which is used in a "for (var x in ..." + */ + tid = ejsLexGetToken(ep, state); + + if (tid == EJS_TOK_SEMI) { + return EJS_STATE_DEC_LIST_DONE; + + } else if (tid == EJS_TOK_IN) { + ejsLexPutbackToken(ep, tid, ep->token); + return EJS_STATE_DEC_LIST_DONE; + + } else if (flags & EJS_FLAGS_CLASS_DEC && + (tid == EJS_TOK_LBRACE || tid == EJS_TOK_EXTENDS)) { + ejsLexPutbackToken(ep, tid, ep->token); + return EJS_STATE_DEC_LIST_DONE; + + } else if (tid == EJS_TOK_RPAREN && flags & EJS_FLAGS_CATCH) { + ejsLexPutbackToken(ep, tid, ep->token); + return EJS_STATE_DEC_LIST_DONE; + + } else if (tid != EJS_TOK_COMMA) { + ejsSyntaxError(ep, 0); + return EJS_STATE_ERR; + } + + } while (tid == EJS_TOK_COMMA); + + if (tid != EJS_TOK_SEMI) { + ejsSyntaxError(ep, 0); + return EJS_STATE_ERR; + } + return EJS_STATE_DEC_LIST_DONE; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct ParseExpr { + EjsVar lhs, rhs; + int rel, tid, unaryMinus; +} ParseExpr; + +/* + * Parse expression (leftHandSide operator rightHandSide) + */ + +static int parseExpr(Ejs *ep, int state, int flags) +{ + ParseExpr *sp; + + mprAssert(ep); + + if ((sp = pushFrame(ep, sizeof(ParseExpr))) == 0) { + return EJS_STATE_ERR; + } + + if (flags & EJS_FLAGS_EXE) { + ejsClearVar(ep, ep->result); + } + + sp->lhs.type = sp->rhs.type = EJS_TYPE_UNDEFINED; + sp->lhs.objectState = sp->rhs.objectState = 0; + sp->lhs.allocatedData = sp->rhs.allocatedData = 0; + + ejsSetVarName(ep, &sp->lhs, "lhs"); + ejsSetVarName(ep, &sp->rhs, "rhs"); + + sp->rel = 0; + sp->tid = 0; + sp->unaryMinus = 0; + + do { + /* + * This loop will handle an entire expression list. We call parse + * to evalutate each term which returns the result in ep->result. + */ + if (sp->tid == EJS_TOK_LOGICAL) { + state = ejsParse(ep, EJS_STATE_RELEXP, flags); + if (state < 0) { + break; + } + } else { + sp->tid = ejsLexGetToken(ep, state); + if (sp->tid == EJS_TOK_EXPR && (int) *ep->token == EJS_EXPR_MINUS) { + sp->unaryMinus = 1; + + } else { + ejsLexPutbackToken(ep, sp->tid, ep->token); + } + + state = ejsParse(ep, EJS_STATE_EXPR, flags); + if (state < 0) { + break; + } + } + + if (flags & EJS_FLAGS_EXE) { + if (sp->unaryMinus) { + switch (ep->result->type) { + default: + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + case EJS_TYPE_STRING_CMETHOD: + case EJS_TYPE_CMETHOD: + case EJS_TYPE_METHOD: + case EJS_TYPE_PTR: + case EJS_TYPE_OBJECT: + case EJS_TYPE_STRING: + case EJS_TYPE_BOOL: + ejsError(ep, EJS_SYNTAX_ERROR, "Invalid unary minus"); + state = EJS_STATE_ERR; + break; + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + ep->result->floating = - ep->result->floating; + break; +#endif + + case EJS_TYPE_INT: + ep->result->integer = - ep->result->integer; + break; + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + ep->result->integer64 = - ep->result->integer64; + break; +#endif + } + } + sp->unaryMinus = 0; + + if (sp->rel > 0) { + ejsWriteVar(ep, &sp->rhs, ep->result, EJS_SHALLOW_COPY); + if (sp->tid == EJS_TOK_LOGICAL) { + if (evalCond(ep, &sp->lhs, sp->rel, &sp->rhs) < 0) { + state = EJS_STATE_ERR; + break; + } + } else { + if (evalExpr(ep, &sp->lhs, sp->rel, &sp->rhs) < 0) { + state = EJS_STATE_ERR; + break; + } + } + } + /* MOB */ + if (sp->lhs.type == EJS_TYPE_OBJECT) { + ejsMakeObjLive(&sp->lhs, 0); + mprAssert(sp->lhs.objectState->alive == 0); + } + if (sp->rhs.type == EJS_TYPE_OBJECT) { + ejsMakeObjLive(&sp->rhs, 0); + mprAssert(sp->rhs.objectState->alive == 0); + } + } + + if ((sp->tid = ejsLexGetToken(ep, state)) == EJS_TOK_EXPR || + sp->tid == EJS_TOK_INC_DEC || sp->tid == EJS_TOK_LOGICAL) { + sp->rel = (int) *ep->token; + ejsWriteVar(ep, &sp->lhs, ep->result, EJS_SHALLOW_COPY); + + } else { + ejsLexPutbackToken(ep, sp->tid, ep->token); + state = EJS_STATE_RELEXP_DONE; + } + + } while (state == EJS_STATE_EXPR_DONE); + + ejsClearVar(ep, &sp->lhs); + ejsClearVar(ep, &sp->rhs); + + popFrame(ep, sizeof(ParseExpr)); + + return state; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct ParseForIn { + EjsInput *endScript, *bodyScript; + EjsProperty *pp, *nextp; + EjsVar *iteratorVar, *setVar, *vp; + int forFlags, tid; +} ParseForIn; + +/* + * Parse the "for ... in" statement. Format for the statement is: + * + * for [each] (var varName in expression) { + * body; + * } + */ + +static int parseForIn(Ejs *ep, int state, int flags, int each) +{ + ParseForIn *sp; + + mprAssert(ep); + + if ((sp = pushFrame(ep, sizeof(ParseForIn))) == 0) { + return EJS_STATE_ERR; + } + + sp->setVar = 0; + sp->iteratorVar = 0; + sp->bodyScript = 0; + sp->endScript = 0; + + sp->tid = ejsLexGetToken(ep, state); + if (sp->tid != EJS_TOK_ID && sp->tid != EJS_TOK_VAR) { + ejsSyntaxError(ep, 0); + goto err; + } + ejsLexPutbackToken(ep, sp->tid, ep->token); + + state = ejsParse(ep, EJS_STATE_EXPR, EJS_FLAGS_FORIN | flags); + if (state < 0) { + goto done; + } + if (flags & EJS_FLAGS_EXE) { + if (ep->currentProperty == 0) { + ejsSyntaxError(ep, 0); + goto err; + } + sp->iteratorVar = &ep->currentProperty->var; + } else { + sp->iteratorVar = 0; + } + + if (ejsLexGetToken(ep, state) != EJS_TOK_IN) { + ejsSyntaxError(ep, 0); + goto err; + } + + /* + * Get the set + */ + sp->tid = ejsLexGetToken(ep, state); + if (sp->tid != EJS_TOK_ID) { + ejsSyntaxError(ep, 0); + goto err; + } + ejsLexPutbackToken(ep, sp->tid, ep->token); + + state = ejsParse(ep, EJS_STATE_EXPR, flags); + if (state < 0) { + goto done; + } + + if ((flags & EJS_FLAGS_EXE) && + (ep->result == 0 || ep->result->type == EJS_TYPE_UNDEFINED)) { + ejsError(ep, EJS_REFERENCE_ERROR, "Can't access array or object"); + goto err; + } + + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + ejsSyntaxError(ep, 0); + goto err; + } + + sp->setVar = ejsDupVar(ep, ep->result, EJS_SHALLOW_COPY); + + sp->bodyScript = getInputStruct(ep); + + /* + * Parse the body and remember the end of the body script + */ + sp->forFlags = flags & ~EJS_FLAGS_EXE; + ejsLexSaveInputState(ep, sp->bodyScript); + + state = ejsParse(ep, EJS_STATE_STMT, sp->forFlags); + if (state < 0) { + goto done; + } + + sp->endScript = getInputStruct(ep); + ejsInitInputState(sp->endScript); + ejsLexSaveInputState(ep, sp->endScript); + + /* + * Enumerate the properties + */ + if (flags & EJS_FLAGS_EXE) { + if (sp->setVar->type == EJS_TYPE_OBJECT) { + + sp->setVar->objectState->preventDeleteProp = 1; + + sp->pp = ejsGetFirstProperty(sp->setVar, 0); + while (sp->pp) { + sp->nextp = ejsGetNextProperty(sp->pp, 0); + if (! sp->pp->dontEnumerate && !sp->pp->delayedDelete) { + if (each) { + sp->vp = ejsWriteVar(ep, sp->iteratorVar, + ejsGetVarPtr(sp->pp), EJS_SHALLOW_COPY); + } else { + sp->vp = ejsWriteVarAsString(ep, sp->iteratorVar, + sp->pp->name); + } + if (sp->vp == 0) { + ejsError(ep, EJS_MEMORY_ERROR, + "Can't write to variable"); + goto err; + } + + ejsLexRestoreInputState(ep, sp->bodyScript); + + state = ejsParse(ep, EJS_STATE_STMT, flags); + + if (state < 0) { + if (sp->setVar->objectState) { + sp->setVar->objectState->preventDeleteProp = 0; + } + goto done; + } + } + sp->pp = sp->nextp; + } + + /* + * Process delayed deletes + */ + if (sp->setVar->objectState) { + sp->setVar->objectState->preventDeleteProp = 0; + if (sp->setVar->objectState->delayedDeleteProp) { + sp->pp = ejsGetFirstProperty(sp->setVar, 0); + while (sp->pp) { + sp->nextp = ejsGetNextProperty(sp->pp, 0); + if (sp->pp->delayedDelete) { + ejsDeleteProperty(ep, sp->setVar, sp->pp->name); + } + sp->pp = sp->nextp; + } + sp->setVar->objectState->delayedDeleteProp = 0; + } + } + + } else { + ejsError(ep, EJS_REFERENCE_ERROR, + "Variable to iterate over is not an array or object"); + goto err; + } + } + + ejsLexRestoreInputState(ep, sp->endScript); + +done: + if (sp->endScript) { + ejsLexFreeInputState(ep, sp->endScript); + ejsLexFreeInputState(ep, sp->bodyScript); + } + + if (sp->bodyScript) { + freeInputStruct(ep, sp->bodyScript); + } + if (sp->endScript) { + freeInputStruct(ep, sp->endScript); + } + + if (sp->setVar) { + ejsFreeVar(ep, sp->setVar); + } + + popFrame(ep, sizeof(ParseForIn)); + + return state; + +err: + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Parse the for statement. Format for the expression is: + * + * for (initial; condition; incr) { + * body; + * } + */ + +static int parseRegFor(Ejs *ep, int state, int flags) +{ + EjsInput *condScript, *endScript, *bodyScript, *incrScript; + + endScript = getInputStruct(ep); + bodyScript = getInputStruct(ep); + incrScript = getInputStruct(ep); + condScript = getInputStruct(ep); + + ejsInitInputState(endScript); + ejsInitInputState(bodyScript); + ejsInitInputState(incrScript); + ejsInitInputState(condScript); + + state = parseForInner(ep, state, flags, + condScript, incrScript, bodyScript, endScript); + + ejsLexFreeInputState(ep, condScript); + ejsLexFreeInputState(ep, incrScript); + ejsLexFreeInputState(ep, endScript); + ejsLexFreeInputState(ep, bodyScript); + + freeInputStruct(ep, condScript); + freeInputStruct(ep, incrScript); + freeInputStruct(ep, endScript); + freeInputStruct(ep, bodyScript); + + return state; +} + +/******************************************************************************/ + +static int parseForInner(Ejs *ep, int state, int flags, EjsInput *condScript, + EjsInput *incrScript, EjsInput *bodyScript, EjsInput *endScript) +{ + int forFlags, cond, rs; + + mprAssert(ep); + + /* + * Evaluate the for loop initialization statement + */ + if ((state = ejsParse(ep, EJS_STATE_STMT, flags)) < 0) { + return state; + } + + /* + * The first time through, we save the current input context just prior + * to each step: prior to the conditional, the loop increment and + * the loop body. + */ + ejsLexSaveInputState(ep, condScript); + if ((rs = ejsParse(ep, EJS_STATE_COND, flags)) < 0) { + return rs; + } + + cond = (ep->result->boolean != 0); + + if (ejsLexGetToken(ep, state) != EJS_TOK_SEMI) { + ejsSyntaxError(ep, 0); + return EJS_STATE_ERR; + } + + /* + * Don't execute the loop increment statement or the body + * first time. + */ + forFlags = flags & ~EJS_FLAGS_EXE; + ejsLexSaveInputState(ep, incrScript); + if ((rs = ejsParse(ep, EJS_STATE_EXPR, forFlags)) < 0) { + return rs; + } + + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + ejsSyntaxError(ep, 0); + return EJS_STATE_ERR; + } + + /* + * Parse the body and remember the end of the body script + */ + ejsLexSaveInputState(ep, bodyScript); + if ((rs = ejsParse(ep, EJS_STATE_STMT, forFlags)) < 0) { + return rs; + } + ejsLexSaveInputState(ep, endScript); + + /* + * Now actually do the for loop. Note loop has been rotated + */ + while (cond && (flags & EJS_FLAGS_EXE)) { + /* + * Evaluate the body + */ + ejsLexRestoreInputState(ep, bodyScript); + + if ((rs = ejsParse(ep, EJS_STATE_STMT, flags)) < 0) { + return rs; + } + + /* + * Evaluate the increment script + */ + ejsLexRestoreInputState(ep, incrScript); + if ((rs = ejsParse(ep, EJS_STATE_EXPR, flags)) < 0) { + return rs; + } + /* + * Evaluate the condition + */ + ejsLexRestoreInputState(ep, condScript); + if ((rs = ejsParse(ep, EJS_STATE_COND, flags)) < 0) { + return 0; + } + mprAssert(ep->result->type == EJS_TYPE_BOOL); + cond = (ep->result->boolean != 0); + } + + ejsLexRestoreInputState(ep, endScript); + + return state; +} + +/******************************************************************************/ +/* + * Create the bare class object + */ + +static int createClass(Ejs *ep, EjsVar *obj, const char *className, + EjsVar *baseClass) +{ + EjsVar *classObj, *existingClass; + + existingClass = ejsGetClass(ep, obj, className); + if (existingClass) { + /* + * We allow partial clases and method redefinition + * FUTURE -- should prevent this if the class is sealed. + * DISABLED Error message and return OK. + */ + /* ejsError(ep, EJS_EVAL_ERROR, "Can't create class %s", className); */ + return 0; + } + + if (baseClass == 0) { + baseClass = ejsGetClass(ep, ep->service->globalClass, "Object"); + mprAssert(baseClass); + } + + classObj = ejsCreateSimpleClass(ep, baseClass, className); + if (classObj == 0) { + ejsMemoryError(ep); + return -1; + } + mprAssert(! ejsObjIsCollectable(classObj)); + + ep->currentProperty = ejsSetPropertyAndFree(ep, obj, className, classObj); + mprAssert(ep->currentProperty); + + if (ep->currentProperty == 0) { + return -1; + } + + return 0; +} + +/******************************************************************************/ +/* + * Local vars for parseTry + */ + +typedef struct ParseTry { + EjsVar *exception; + int tid, caught, rs, catchFlags; +} ParseTry; + +/* + * Parse try block + * + * try {} + */ + +static int parseTry(Ejs *ep, int state, int flags) +{ + ParseTry *sp; + + if ((sp = pushFrame(ep, sizeof(ParseTry))) == 0) { + return EJS_STATE_ERR; + } + + mprAssert(ep); + + sp->caught = 0; + sp->exception = 0; + sp->catchFlags = flags; + + /* + * Execute the code in the try block + */ + sp->rs = ejsParse(ep, EJS_STATE_STMT, flags | EJS_FLAGS_TRY); + if (sp->rs < 0) { + if (sp->rs == EJS_STATE_ERR) { + sp->exception = ejsDupVar(ep, ep->result, EJS_SHALLOW_COPY); + if (sp->exception == 0) { + ejsMemoryError(ep); + goto err; + } + } else { + state = sp->rs; + goto done; + } + + } else { + sp->catchFlags = flags & ~EJS_FLAGS_EXE; + } + + /* + * On success path or when an exception is caught, we must parse all + * catch and finally blocks. + */ + sp->tid = getNextNonSpaceToken(ep, state); + + if (sp->tid == EJS_TOK_CATCH) { + + ep->gotException = 0; + + sp->tid = getNextNonSpaceToken(ep, state); + + if (sp->tid == EJS_TOK_LBRACE) { + /* + * Unqualified "catch " + */ + ejsLexPutbackToken(ep, sp->tid, ep->token); + if (ejsParse(ep, EJS_STATE_STMT, sp->catchFlags) >= 0) { + sp->caught++; + } + + } else if (sp->tid == EJS_TOK_LPAREN) { + + /* + * Qualified "catch (variable) " + */ + if ((sp->rs = ejsParse(ep, EJS_STATE_DEC_LIST, + sp->catchFlags | EJS_FLAGS_CATCH)) < 0) { + ejsSyntaxError(ep, "Bad catch statement"); + state = sp->rs; + goto done; + } + + sp->tid = getNextNonSpaceToken(ep, state); + if (sp->tid != EJS_TOK_RPAREN) { + ejsSyntaxError(ep, 0); + goto err; + } + + if (sp->catchFlags & EJS_FLAGS_EXE) { + if (ep->currentProperty == 0) { + ejsError(ep, EJS_EVAL_ERROR, "Can't define catch variable"); + goto err; + } + + /* + * Set the catch variable + */ + if (ejsWriteVar(ep, + ejsGetVarPtr(ep->currentProperty), sp->exception, + EJS_SHALLOW_COPY) == 0) { + ejsError(ep, EJS_EVAL_ERROR, "Can't update catch variable"); + goto err; + } + } + + /* + * Parse the catch block + */ + if ((sp->rs = ejsParse(ep, EJS_STATE_STMT, sp->catchFlags)) < 0) { + state = sp->rs; + goto done; + } + sp->caught++; + ep->gotException = 0; + } + sp->tid = getNextNonSpaceToken(ep, state); + } + + /* + * Parse the finally block + */ + if (sp->tid == EJS_TOK_FINALLY) { + if (ejsParse(ep, EJS_STATE_STMT, flags) < 0) { + goto err; + } + } else { + ejsLexPutbackToken(ep, sp->tid, ep->token); + } + + /* + * Set the exception value + */ + if (sp->exception && !sp->caught) { + ejsWriteVar(ep, ep->result, sp->exception, EJS_SHALLOW_COPY); + goto err; + } + + state = EJS_STATE_STMT_DONE; + +done: + if (sp->exception) { + ejsFreeVar(ep, sp->exception); + } + + popFrame(ep, sizeof(ParseTry)); + return state; + + +err: + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Parse throw statement + * + * throw expression + */ + +static int parseThrow(Ejs *ep, int state, int flags) +{ + int rc; + + mprAssert(ep); + + if ((rc = ejsParse(ep, EJS_STATE_EXPR, flags)) < 0) { + return rc; + } + + + if (flags & EJS_FLAGS_EXE) { + /* + * We have thrown the exception so set the state to ERR + */ + ep->gotException = 1; + return EJS_STATE_ERR; + } + return state; +} + +/******************************************************************************/ +/* + * Parse a class and module declaration + * + * class <name> [extends baseClass] { + * [public | private | ... ] var declarations ... + * [constructor] function declarations ... + * } + * + * Modules are identical except declared with a "module" instead of + * "class". Modules cannot be instantiated and are used for mixins. + * + */ + +static int parseClass(Ejs *ep, int state, int flags) +{ + int originalToken, tid, fid; + + mprAssert(ep); + + originalToken = ep->tid; + + /* + * Parse "class Name [extends BaseClass]" + */ + if (ejsParse(ep, EJS_STATE_DEC_LIST, flags | EJS_FLAGS_CLASS_DEC) < 0) { + return EJS_STATE_ERR; + } + + tid = getNextNonSpaceToken(ep, state); + + if (tid != EJS_TOK_LBRACE) { + return EJS_STATE_ERR; + } + + /* + * After parsing the class body, ep->local will contain the actual + * class/module object. So, we save ep->local by creating a new block. + */ + if (flags & EJS_FLAGS_EXE) { + fid = ejsSetBlock(ep, ejsGetVarPtr(ep->currentProperty)); + ejsSetVarName(ep, ep->local, ep->currentProperty->name); + + } else { + fid = -1; + } + + /* FUTURE -- should prevent modules from being instantiated */ + + /* + * Parse class body + */ + do { + state = ejsParse(ep, EJS_STATE_STMT, flags); + if (state < 0) { + if (fid >= 0) { + ejsCloseBlock(ep, fid); + } + return state; + } + tid = getNextNonSpaceToken(ep, state); + if (tid == EJS_TOK_RBRACE) { + break; + } + ejsLexPutbackToken(ep, tid, ep->token); + + } while (state >= 0); + + if (fid >= 0) { + ejsCloseBlock(ep, fid); + } + + if (tid != EJS_TOK_RBRACE) { + ejsSyntaxError(ep, 0); + state = EJS_STATE_ERR; + } + + return state; +} + +/******************************************************************************/ +/* + * Parse a function declaration + */ + +static int parseFunction(Ejs *ep, int state, int flags) +{ + EjsInput *endScript, *bodyScript; + EjsProperty *pp; + EjsVar *func, *funcProp, *currentObj, *vp, *baseClass; + char *procName; + int varFlags, len, tid, bodyFlags, innerState; + + mprAssert(ep); + + func = 0; + varFlags = 0; + + /* + * method <name>(arg, arg, arg) { body }; + * method name(arg, arg, arg) { body }; + */ + + tid = ejsLexGetToken(ep, state); + + if (tid == EJS_TOK_GET) { + varFlags |= EJS_GET_ACCESSOR; + tid = ejsLexGetToken(ep, state); + + } else if (tid == EJS_TOK_SET) { + varFlags |= EJS_SET_ACCESSOR; + tid = ejsLexGetToken(ep, state); + } + + if (tid == EJS_TOK_ID) { + if (varFlags & EJS_SET_ACCESSOR) { + + if (mprAllocStrcat(MPR_LOC_ARGS(ep), &procName, EJS_MAX_ID + 5, + 0, "-set-", ep->token, 0) < 0) { + ejsError(ep, EJS_SYNTAX_ERROR, + "Name %s is too long", ep->token); + return EJS_STATE_ERR; + } + + } else { + procName = mprStrdup(ep, ep->token); + } + + tid = ejsLexGetToken(ep, state); + + } else { + procName = 0; + } + + if (tid != EJS_TOK_LPAREN) { + mprFree(procName); + ejsSyntaxError(ep, 0); + return EJS_STATE_ERR; + } + + /* + * Hand craft the method value structure. + */ + if (flags & EJS_FLAGS_EXE) { + func = ejsCreateMethodVar(ep, 0, 0, 0); + if (func == 0) { + mprFree(procName); + ejsMemoryError(ep); + return EJS_STATE_ERR; + } + func->flags = varFlags; + } + + tid = ejsLexGetToken(ep, state); + while (tid == EJS_TOK_ID) { + if (flags & EJS_FLAGS_EXE) { + mprAddItem(func->method.args, + mprStrdup(func->method.args, ep->token)); + } + tid = ejsLexGetToken(ep, state); + if (tid == EJS_TOK_RPAREN || tid != EJS_TOK_COMMA) { + break; + } + tid = ejsLexGetToken(ep, state); + } + if (tid != EJS_TOK_RPAREN) { + mprFree(procName); + ejsFreeVar(ep, func); + ejsSyntaxError(ep, 0); + return EJS_STATE_ERR; + } + + /* Allow new lines before opening brace */ + do { + tid = ejsLexGetToken(ep, state); + } while (tid == EJS_TOK_NEWLINE); + + if (tid != EJS_TOK_LBRACE) { + mprFree(procName); + ejsFreeVar(ep, func); + ejsSyntaxError(ep, 0); + return EJS_STATE_ERR; + } + + /* + * Register the method name early to allow for recursive + * method calls (see note in ECMA standard, page 71) + */ + funcProp = 0; + if (flags & EJS_FLAGS_EXE && procName) { + currentObj = pickSpace(ep, 0, procName, flags | EJS_FLAGS_LOCAL); + pp = ejsSetProperty(ep, currentObj, procName, func); + if (pp == 0) { + ejsFreeVar(ep, func); + ejsMemoryError(ep); + return EJS_STATE_ERR; + } + funcProp = ejsGetVarPtr(pp); + } + + + bodyScript = getInputStruct(ep); + + /* + * Parse the method body. Turn execute off. + */ + bodyFlags = flags & ~EJS_FLAGS_EXE; + ejsLexSaveInputState(ep, bodyScript); + + do { + innerState = ejsParse(ep, EJS_STATE_STMT, bodyFlags); + } while (innerState == EJS_STATE_STMT_DONE); + + tid = ejsLexGetToken(ep, state); + + if (innerState != EJS_STATE_STMT_BLOCK_DONE || tid != EJS_TOK_RBRACE) { + mprFree(procName); + ejsFreeVar(ep, func); + ejsLexFreeInputState(ep, bodyScript); + if (innerState != EJS_STATE_ERR) { + ejsSyntaxError(ep, 0); + } + freeInputStruct(ep, bodyScript); + return EJS_STATE_ERR; + } + + if (flags & EJS_FLAGS_EXE) { + endScript = getInputStruct(ep); + ejsLexSaveInputState(ep, endScript); + + /* + * Save the method body between the starting and ending parse + * positions. Overwrite the trailing '}' with a null. + */ + len = endScript->scriptServp - bodyScript->scriptServp; + func->method.body = mprAlloc(ep, len + 1); + memcpy(func->method.body, bodyScript->scriptServp, len); + + if (len <= 0) { + func->method.body[0] = '\0'; + } else { + func->method.body[len - 1] = '\0'; + } + ejsLexFreeInputState(ep, bodyScript); + ejsLexFreeInputState(ep, endScript); + freeInputStruct(ep, endScript); + + /* + * If we are in an assignment, don't register the method name, rather + * return the method structure in the parser result. + */ + if (procName) { + currentObj = pickSpace(ep, 0, procName, flags | EJS_FLAGS_LOCAL); + pp = ejsSetProperty(ep, currentObj, procName, func); + if (pp == 0) { + ejsFreeVar(ep, func); + ejsMemoryError(ep); + return EJS_STATE_ERR; + } + + if (currentObj->objectState->className && + strcmp(currentObj->objectState->className, procName) == 0) { + baseClass = currentObj->objectState->baseClass; + if (baseClass) { + if (strstr(func->method.body, "super(") != 0) { + funcProp->callsSuper = 1; + /* + * Define super() to point to the baseClass constructor + */ + vp = ejsGetPropertyAsVar(ep, baseClass, + baseClass->objectState->className); + if (vp) { + mprAssert(vp); + if (ejsSetProperty(ep, currentObj, "super", + vp) == 0) { + ejsFreeVar(ep, func); + ejsMemoryError(ep); + return EJS_STATE_ERR; + } + } + } + } + } + } + /* + * Always return the function. Try for all stmts to be expressions. + */ + /* MOB - rc */ + ejsWriteVar(ep, ep->result, func, EJS_SHALLOW_COPY); + } + freeInputStruct(ep, bodyScript); + + mprFree(procName); + ejsFreeVar(ep, func); + + return state; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct ParseMethod { + EjsProc proc, *saveProc; + EjsVar *saveObj, *newObj; + int saveObjPerm, rc; + +} ParseMethod; + +/* + * Parse a method name and invoke the method. See parseFunction for + * function declarations. + */ + +static int parseMethod(Ejs *ep, int state, int flags, char *id) +{ + ParseMethod *sp; + + if ((sp = pushFrame(ep, sizeof(ParseMethod))) == 0) { + return EJS_STATE_ERR; + } + + /* + * Must save any current ep->proc value for the current stack frame + * to allow for recursive method calls. + */ + sp->saveProc = (ep->proc) ? ep->proc: 0; + + memset(&sp->proc, 0, sizeof(EjsProc)); + sp->proc.procName = mprStrdup(ep, id); + sp->proc.fn = &ep->currentProperty->var; + sp->proc.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS); + ep->proc = &sp->proc; + +#if BLD_DEBUG + if (strcmp(sp->proc.procName, "printv") == 0) { + flags |= EJS_FLAGS_TRACE_ARGS; + } +#endif + + if (flags & EJS_FLAGS_EXE) { + ejsClearVar(ep, ep->result); + } + + if (! (flags & EJS_FLAGS_NO_ARGS)) { + sp->saveObj = ep->currentObj; + sp->saveObjPerm = ejsMakeObjPermanent(sp->saveObj, 1); + sp->rc = ejsParse(ep, EJS_STATE_ARG_LIST, flags); + ejsMakeObjPermanent(sp->saveObj, sp->saveObjPerm); + if (sp->rc < 0) { + goto err; + } + ep->currentObj = sp->saveObj; + } + +#if BLD_DEBUG + flags &= ~EJS_FLAGS_TRACE_ARGS; +#endif + + /* + * Evaluate the method if required + */ + if (flags & EJS_FLAGS_EXE) { + if (flags & EJS_FLAGS_NEW) { + sp->newObj = ejsCreateObjUsingArgv(ep, ep->currentObj, + sp->proc.procName, sp->proc.args); + + if (sp->newObj == 0) { + state = EJS_STATE_ERR; + + } else { + mprAssert(! ejsObjIsCollectable(sp->newObj)); + + /* + * Return the newly created object as the result of the + * command. NOTE: newObj may not be an object! + */ + /* MOB - rc */ + ejsWriteVar(ep, ep->result, sp->newObj, EJS_SHALLOW_COPY); + if (ejsVarIsObject(sp->newObj)) { + ejsMakeObjLive(sp->newObj, 1); + mprAssert(ejsObjIsCollectable(sp->newObj)); + mprAssert(ejsBlockInUse(sp->newObj)); + } + ejsFreeVar(ep, sp->newObj); + } + + } else { + + if (evalMethod(ep, ep->currentObj, &sp->proc, flags) < 0) { + /* Methods must call ejsError to set exceptions */ + state = EJS_STATE_ERR; + } + } + } + + if (! (flags & EJS_FLAGS_NO_ARGS)) { + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + if (state != EJS_STATE_ERR) { + ejsSyntaxError(ep, 0); + } + state = EJS_STATE_ERR; + } + } + +done: + freeProc(ep, &sp->proc); + ep->proc = sp->saveProc; + + popFrame(ep, sizeof(ParseMethod)); + return state; + +err: + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Parse an identifier. This is a segment of a fully qualified variable. + * May come here for an initial identifier or for property names + * after a "." or "[...]". + */ + +static int parseId(Ejs *ep, int state, int flags, char **id, int *done) +{ + EjsVar *null; + int tid; + + mprFree(*id); + *id = mprStrdup(ep, ep->token); + + if (ep->currentObj == 0) { + /* First identifier segement */ + ep->currentObj = pickSpace(ep, state, *id, flags); + } + + tid = ejsLexGetToken(ep, state); + if (tid == EJS_TOK_ASSIGNMENT) { + flags |= EJS_FLAGS_LHS; + } + + /* + * Find the referenced variable and store it in currentProperty. + */ + if (flags & EJS_FLAGS_EXE) { + ep->currentProperty = searchSpacesForProperty(ep, state, + ep->currentObj, *id, flags); + + /* + * Handle properties that have been deleted inside an enumeration + */ + if (ep->currentProperty && ep->currentProperty->delayedDelete) { + ep->currentProperty = 0; + } + + if (ep->currentProperty && + ejsVarIsMethod(&ep->currentProperty->var) && + tid != EJS_TOK_LPAREN) { + if (ep->currentProperty->var.flags & EJS_GET_ACCESSOR) { + ejsLexPutbackToken(ep, tid, ep->token); + state = parseMethod(ep, state, flags | EJS_FLAGS_NO_ARGS, *id); + if (ep->flags & EJS_FLAGS_EXIT) { + state = EJS_STATE_RET; + } + if (state >= 0) { + ejsSetVarName(ep, ep->result, ep->currentProperty->name); + } + return state; + } + } + /* + * OPT. We should not have to do this always + */ + updateResult(ep, state, flags, ejsGetVarPtr(ep->currentProperty)); + } + + flags &= ~EJS_FLAGS_LHS; + + if (tid == EJS_TOK_LPAREN) { + if (ep->currentProperty == 0 && (flags & EJS_FLAGS_EXE)) { + ejsError(ep, EJS_REFERENCE_ERROR, + "Method name not defined \"%s\"", *id); + return EJS_STATE_ERR; + } + ejsLexPutbackToken(ep, EJS_TOK_METHOD_NAME, ep->token); + return state; + } + + if (tid == EJS_TOK_PERIOD || tid == EJS_TOK_LBRACKET || + tid == EJS_TOK_ASSIGNMENT || tid == EJS_TOK_INC_DEC) { + ejsLexPutbackToken(ep, tid, ep->token); + return state; + } + + if (flags & EJS_FLAGS_CLASS_DEC) { + if (tid == EJS_TOK_LBRACE || tid == EJS_TOK_EXTENDS) { + ejsLexPutbackToken(ep, tid, ep->token); + return state; + } + } + + if (flags & EJS_FLAGS_DELETE) { + if (tid == EJS_TOK_RBRACE) { + ejsLexPutbackToken(ep, tid, ep->token); + } + } + + /* + * Only come here for variable access and declarations. + * Assignment handled elsewhere. + */ + if (flags & EJS_FLAGS_EXE) { + if (state == EJS_STATE_DEC) { + /* + * Declare a variable. Standard allows: var x ; var x ; + */ +#if DISABLED + if (ep->currentProperty != 0) { + ejsError(ep, EJS_REFERENCE_ERROR, + "Variable already defined \"%s\"", *id); + return EJS_STATE_ERR; + } +#endif + /* + * Create or overwrite if it already exists + * Set newly declared variables to the null value. + */ + null = ejsCreateNullVar(ep); + ep->currentProperty = ejsSetPropertyAndFree(ep, ep->currentObj, + *id, null); + ejsClearVar(ep, ep->result); + + } else if (flags & EJS_FLAGS_FORIN) { + /* + * This allows "for (x" when x has not yet been defined + */ + if (ep->currentProperty == 0) { + /* MOB -- return code */ + ep->currentProperty = ejsCreateProperty(ep, + ep->currentObj, *id); + } + + } else if (ep->currentProperty == 0) { + + if (ep->currentObj && ((ep->currentObj == ep->global || + (ep->currentObj == ep->local)))) { + /* + * Test against currentObj and not currentObj->objectState + * as we must allow "i = global.x" and not allow + * "i = x" where x does not exist. + */ + ejsError(ep, EJS_REFERENCE_ERROR, + "Undefined variable \"%s\"", *id); + return EJS_STATE_ERR; + } + + if (flags & EJS_FLAGS_DELETE) { + ejsError(ep, EJS_REFERENCE_ERROR, + "Undefined variable \"%s\"", *id); + return EJS_STATE_ERR; + } + } + } + ejsLexPutbackToken(ep, tid, ep->token); + if (tid == EJS_TOK_RBRACKET || tid == EJS_TOK_COMMA || + tid == EJS_TOK_IN) { + *done = 1; + } + return state; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct ParseIf { + int ifResult, thenFlags, elseFlags, tid, rs; +} ParseIf; + +/* + * Parse an "if" statement + */ + +static int parseIf(Ejs *ep, int state, int flags, int *done) +{ + ParseIf *sp; + + if ((sp = pushFrame(ep, sizeof(ParseIf))) == 0) { + return EJS_STATE_ERR; + } + + if (state != EJS_STATE_STMT) { + goto err; + } + if (ejsLexGetToken(ep, state) != EJS_TOK_LPAREN) { + goto err; + } + + /* + * Evaluate the entire condition list "(condition)" + */ + if (ejsParse(ep, EJS_STATE_COND, flags) < 0) { + goto err; + } + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + goto err; + } + + /* + * This is the "then" case. We need to always parse both cases and + * execute only the relevant case. + */ + sp->ifResult = ejsVarToBoolean(ep->result); + if (sp->ifResult) { + sp->thenFlags = flags; + sp->elseFlags = flags & ~EJS_FLAGS_EXE; + } else { + sp->thenFlags = flags & ~EJS_FLAGS_EXE; + sp->elseFlags = flags; + } + + /* + * Process the "then" case. + */ + if ((sp->rs = ejsParse(ep, EJS_STATE_STMT, sp->thenFlags)) < 0) { + if (! ep->gotException) { + state = sp->rs; + goto done; + } + } + + /* + * Check to see if there is an "else" case + */ + removeNewlines(ep, state); + sp->tid = ejsLexGetToken(ep, state); + if (sp->tid != EJS_TOK_ELSE) { + ejsLexPutbackToken(ep, sp->tid, ep->token); + *done = 1; + if (ep->gotException) { + goto err; + } + goto done; + } + + /* + * Process the "else" case. + */ + state = ejsParse(ep, EJS_STATE_STMT, sp->elseFlags); + +done: + *done = 1; + if (ep->gotException) { + state = EJS_STATE_ERR; + } + popFrame(ep, sizeof(ParseIf)); + return state; + + +err: + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Parse a postix "++" or "--" statement + */ + +static int parseInc(Ejs *ep, int state, int flags) +{ + EjsVar *one; + + if (! (flags & EJS_FLAGS_EXE)) { + return state; + } + + if (ep->currentProperty == 0) { + ejsError(ep, EJS_REFERENCE_ERROR, + "Undefined variable \"%s\"", ep->token); + return EJS_STATE_ERR; + } + one = ejsCreateIntegerVar(ep, 1); + if (evalExpr(ep, &ep->currentProperty->var, (int) *ep->token, one) < 0) { + ejsFreeVar(ep, one); + return EJS_STATE_ERR; + } + if (ejsWriteVar(ep, &ep->currentProperty->var, ep->result, + EJS_SHALLOW_COPY) < 0) { + ejsError(ep, EJS_IO_ERROR, "Can't write to variable"); + ejsFreeVar(ep, one); + return EJS_STATE_ERR; + } + ejsFreeVar(ep, one); + return state; +} + +/******************************************************************************/ +/* + * Evaluate a condition. Implements &&, ||, !. Returns with a boolean result + * in ep->result. Returns EJS_STATE_ERR on errors, zero if successful. + */ + +static int evalCond(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs) +{ + int l, r, lval; + + mprAssert(rel > 0); + + l = ejsVarToBoolean(lhs); + r = ejsVarToBoolean(rhs); + + switch (rel) { + case EJS_COND_AND: + lval = l && r; + break; + case EJS_COND_OR: + lval = l || r; + break; + default: + ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel); + return -1; + } + + /* MOB - rc */ + ejsWriteVarAsBoolean(ep, ep->result, lval); + return 0; +} + + +/******************************************************************************/ +/* + * return true if this string is a valid number + */ + +static int stringIsNumber(const char *s) +{ + char *endptr = NULL; + + if (s == NULL || *s == 0) { + return 0; + } + /* MOB -- not ideal */ +#if BREW + /* MOB this should check all digits and not just the first. */ + /* Does not support floating point - easy */ + + if (isdigit(*s) || (*s == '-' && isdigit(s[1]))) { + return 1; + } +#else + strtod(s, &endptr); +#endif + if (endptr != NULL && *endptr == 0) { + return 1; + } + return 0; +} + +/******************************************************************************/ +/* + * Evaluate an operation. Returns with the result in ep->result. Returns -1 + * on errors, otherwise zero is returned. + */ + +static int evalExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs) +{ + EjsNum lval; + char *str; + int rc; + + mprAssert(rel > 0); + str = 0; + lval = 0; + + /* + * Type conversion. This is tricky and must be according to the standard. + * Only numbers (including floats) and strings can be compared. All other + * types are first converted to numbers by preference and if that fails, + * to strings. + * + * MOB -- should we do "valueOf" here also. + */ + if (lhs->type == EJS_TYPE_OBJECT && + (rhs->type != EJS_TYPE_OBJECT && + (rhs->type != EJS_TYPE_UNDEFINED && rhs->type != EJS_TYPE_NULL))) { + if (ejsVarIsNumber(rhs)) { + if (ejsRunMethod(ep, lhs, "toValue", 0) == 0) { + /* MOB - rc */ + ejsWriteVar(ep, lhs, ep->result, EJS_SHALLOW_COPY); + } else { + if (ejsRunMethod(ep, lhs, "toString", 0) == 0) { + /* MOB - rc */ + ejsWriteVar(ep, lhs, ep->result, EJS_SHALLOW_COPY); + } + } + + } else { + if (ejsRunMethod(ep, lhs, "toString", 0) == 0) { + /* MOB - rc */ + ejsWriteVar(ep, lhs, ep->result, EJS_SHALLOW_COPY); + } else { + if (ejsRunMethod(ep, lhs, "toValue", 0) == 0) { + /* MOB - rc */ + ejsWriteVar(ep, lhs, ep->result, EJS_SHALLOW_COPY); + } + } + } + /* Nothing more can be done */ + } + + if (rhs->type == EJS_TYPE_OBJECT && + (lhs->type != EJS_TYPE_OBJECT && + (lhs->type != EJS_TYPE_UNDEFINED && lhs->type != EJS_TYPE_NULL))) { + if (ejsVarIsNumber(lhs)) { + /* If LHS is number, then convert to a value first */ + if (ejsRunMethod(ep, rhs, "toValue", 0) == 0) { + /* MOB - rc */ + ejsWriteVar(ep, rhs, ep->result, EJS_SHALLOW_COPY); + } else { + if (ejsRunMethod(ep, rhs, "toString", 0) == 0) { + /* MOB - rc */ + ejsWriteVar(ep, rhs, ep->result, EJS_SHALLOW_COPY); + } + } + + } else { + /* If LHS is not a number, then convert to a string first */ + if (ejsRunMethod(ep, rhs, "toString", 0) == 0) { + /* MOB - rc */ + ejsWriteVar(ep, rhs, ep->result, EJS_SHALLOW_COPY); + + } else { + if (ejsRunMethod(ep, rhs, "toValue", 0) == 0) { + /* MOB - rc */ + ejsWriteVar(ep, rhs, ep->result, EJS_SHALLOW_COPY); + } + } + } + /* Nothing more can be done */ + } + + /* + * undefined and null are special, in that they don't get promoted when + * comparing. + */ + if (rel == EJS_EXPR_EQ || rel == EJS_EXPR_NOTEQ) { + if (lhs->type == EJS_TYPE_UNDEFINED || + rhs->type == EJS_TYPE_UNDEFINED) { + return evalBoolExpr(ep, + lhs->type == EJS_TYPE_UNDEFINED, + rel, + rhs->type == EJS_TYPE_UNDEFINED); + } + + if (lhs->type == EJS_TYPE_NULL || rhs->type == EJS_TYPE_NULL) { + return evalBoolExpr(ep, + lhs->type == EJS_TYPE_NULL, + rel, + rhs->type == EJS_TYPE_NULL); + } + } + + /* + * From here on, lhs and rhs may contain allocated data (strings), so + * we must always destroy before overwriting. + */ + + /* + * Only allow a few bool operations. Otherwise convert to number. + */ + if (lhs->type == EJS_TYPE_BOOL && rhs->type == EJS_TYPE_BOOL && + (rel != EJS_EXPR_EQ && rel != EJS_EXPR_NOTEQ && + rel != EJS_EXPR_BOOL_COMP)) { + ejsWriteVarAsNumber(ep, lhs, ejsVarToNumber(lhs)); + } + + /* + * Types do not match, so try to coerce the right operand to match the left + * But first, try to convert a left operand that is a numeric stored as a + * string, into a numeric. + */ + if (lhs->type != rhs->type) { + if (lhs->type == EJS_TYPE_STRING) { + if (stringIsNumber(lhs->string)) { + ejsWriteVarAsNumber(ep, lhs, ejsVarToNumber(lhs)); + + /* Examine further below */ + + } else { + /* + * Convert the RHS to a string + * MOB rc + */ + str = ejsVarToString(ep, rhs); + ejsWriteVarAsString(ep, rhs, str); + } + +#if BLD_FEATURE_FLOATING_POINT + } else if (lhs->type == EJS_TYPE_FLOAT) { + /* + * Convert rhs to floating + */ + ejsWriteVarAsFloat(ep, rhs, ejsVarToFloat(rhs)); + +#endif +#if BLD_FEATURE_INT64 + } else if (lhs->type == EJS_TYPE_INT64) { + /* + * Convert the rhs to 64 bit + */ + ejsWriteVarAsInteger64(ep, rhs, ejsVarToInteger64(rhs)); +#endif + } else if (lhs->type == EJS_TYPE_BOOL || lhs->type == EJS_TYPE_INT) { + + if (rhs->type == EJS_TYPE_STRING) { + if (stringIsNumber(rhs->string)) { + ejsWriteVarAsNumber(ep, rhs, ejsVarToNumber(rhs)); + } else { + /* + * Convert to lhs to a string + */ + str = ejsVarToString(ep, lhs); + /* MOB -- rc */ + if (str) { + ejsWriteVarAsString(ep, lhs, str); + } + } + +#if BLD_FEATURE_FLOATING_POINT + } else if (rhs->type == EJS_TYPE_FLOAT) { + /* + * Convert lhs to floating + */ + ejsWriteVarAsFloat(ep, lhs, ejsVarToFloat(lhs)); +#endif + + } else { + /* + * Forcibly convert both operands to numbers + */ + ejsWriteVarAsNumber(ep, lhs, ejsVarToNumber(lhs)); + ejsWriteVarAsNumber(ep, rhs, ejsVarToNumber(rhs)); + } + } + } + + /* + * We have failed to coerce the types to be the same. Special case here + * for undefined and null. We need to allow comparisions against these + * special values. + */ + if (lhs->type == EJS_TYPE_UNDEFINED || lhs->type == EJS_TYPE_NULL) { + switch (rel) { + case EJS_EXPR_EQ: + lval = lhs->type == rhs->type; + break; + case EJS_EXPR_NOTEQ: + lval = lhs->type != rhs->type; + break; + case EJS_EXPR_BOOL_COMP: + lval = ! ejsVarToBoolean(rhs); + break; + default: + ejsWriteVar(ep, ep->result, rhs, EJS_SHALLOW_COPY); + return 0; + } + ejsWriteVarAsBoolean(ep, ep->result, lval); + return 0; + } + + /* + * Types are the same here + */ + switch (lhs->type) { + default: + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + /* Should be handled above */ + mprAssert(0); + return 0; + + case EJS_TYPE_STRING_CMETHOD: + case EJS_TYPE_CMETHOD: + case EJS_TYPE_METHOD: + case EJS_TYPE_PTR: + ejsWriteVarAsBoolean(ep, ep->result, 0); + return 0; + + case EJS_TYPE_OBJECT: + rc = evalObjExpr(ep, lhs, rel, rhs); + break; + + case EJS_TYPE_BOOL: + rc = evalBoolExpr(ep, lhs->boolean, rel, rhs->boolean); + break; + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + rc = evalFloatExpr(ep, lhs->floating, rel, rhs->floating); + break; +#endif + + case EJS_TYPE_INT: + rc = evalNumericExpr(ep, (EjsNum) lhs->integer, rel, + (EjsNum) rhs->integer); + break; + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + rc = evalNumericExpr(ep, (EjsNum) lhs->integer64, rel, + (EjsNum) rhs->integer64); + break; +#endif + + case EJS_TYPE_STRING: + rc = evalStringExpr(ep, lhs, rel, rhs); + } + + /* MOB */ + if (lhs->type == EJS_TYPE_OBJECT) { + ejsMakeObjLive(lhs, 0); + mprAssert(lhs->objectState->alive == 0); + } + if (rhs->type == EJS_TYPE_OBJECT) { + ejsMakeObjLive(rhs, 0); + mprAssert(rhs->objectState->alive == 0); + } + + return rc; +} + +/******************************************************************************/ +#if BLD_FEATURE_FLOATING_POINT +/* + * Expressions with floating operands + */ + +static int evalFloatExpr(Ejs *ep, double l, int rel, double r) +{ + double lval; + int logical; + + lval = 0; + logical = 0; + + switch (rel) { + case EJS_EXPR_PLUS: + lval = l + r; + break; + case EJS_EXPR_INC: + lval = l + 1; + break; + case EJS_EXPR_MINUS: + lval = l - r; + break; + case EJS_EXPR_DEC: + lval = l - 1; + break; + case EJS_EXPR_MUL: + lval = l * r; + break; + case EJS_EXPR_DIV: + lval = l / r; + break; + default: + logical++; + break; + } + + /* + * Logical operators + */ + if (logical) { + + switch (rel) { + case EJS_EXPR_EQ: + lval = l == r; + break; + case EJS_EXPR_NOTEQ: + lval = l != r; + break; + case EJS_EXPR_LESS: + lval = (l < r) ? 1 : 0; + break; + case EJS_EXPR_LESSEQ: + lval = (l <= r) ? 1 : 0; + break; + case EJS_EXPR_GREATER: + lval = (l > r) ? 1 : 0; + break; + case EJS_EXPR_GREATEREQ: + lval = (l >= r) ? 1 : 0; + break; + case EJS_EXPR_BOOL_COMP: + lval = (r == 0) ? 1 : 0; + break; + default: + ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel); + return -1; + } + ejsWriteVarAsBoolean(ep, ep->result, lval != 0); + + } else { + ejsWriteVarAsFloat(ep, ep->result, lval); + } + return 0; +} + +#endif /* BLD_FEATURE_FLOATING_POINT */ +/******************************************************************************/ +/* + * Expressions with object operands + */ + +static int evalObjExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs) +{ + int lval; + + switch (rel) { + case EJS_EXPR_EQ: + lval = lhs->objectState == rhs->objectState; + break; + case EJS_EXPR_NOTEQ: + lval = lhs->objectState != rhs->objectState; + break; + default: + ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel); + return -1; + } + ejsWriteVarAsBoolean(ep, ep->result, lval); + return 0; +} + +/******************************************************************************/ +/* + * Expressions with boolean operands + */ + +static int evalBoolExpr(Ejs *ep, int l, int rel, int r) +{ + int lval; + + switch (rel) { + case EJS_EXPR_EQ: + lval = l == r; + break; + case EJS_EXPR_NOTEQ: + lval = l != r; + break; + case EJS_EXPR_BOOL_COMP: + lval = (r == 0) ? 1 : 0; + break; + default: + ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel); + return -1; + } + ejsWriteVarAsBoolean(ep, ep->result, lval); + return 0; +} + +/******************************************************************************/ +/* + * Expressions with numeric operands + */ + +static int evalNumericExpr(Ejs *ep, EjsNum l, int rel, EjsNum r) +{ + EjsNum lval; + int logical; + + lval = 0; + logical = 0; + + switch (rel) { + case EJS_EXPR_PLUS: + lval = l + r; + break; + case EJS_EXPR_INC: + lval = l + 1; + break; + case EJS_EXPR_MINUS: + lval = l - r; + break; + case EJS_EXPR_DEC: + lval = l - 1; + break; + case EJS_EXPR_MUL: + lval = l * r; + break; + case EJS_EXPR_DIV: + if (r != 0) { + lval = l / r; + } else { + ejsError(ep, EJS_RANGE_ERROR, "Divide by zero"); + return -1; + } + break; + case EJS_EXPR_MOD: + if (r != 0) { + lval = l % r; + } else { + ejsError(ep, EJS_RANGE_ERROR, "Modulo zero"); + return -1; + } + break; + case EJS_EXPR_LSHIFT: + lval = l << r; + break; + case EJS_EXPR_RSHIFT: + lval = l >> r; + break; + + default: + logical++; + break; + } + + /* + * Logical operators + */ + if (logical) { + + switch (rel) { + case EJS_EXPR_EQ: + lval = l == r; + break; + case EJS_EXPR_NOTEQ: + lval = l != r; + break; + case EJS_EXPR_LESS: + lval = (l < r) ? 1 : 0; + break; + case EJS_EXPR_LESSEQ: + lval = (l <= r) ? 1 : 0; + break; + case EJS_EXPR_GREATER: + lval = (l > r) ? 1 : 0; + break; + case EJS_EXPR_GREATEREQ: + lval = (l >= r) ? 1 : 0; + break; + case EJS_EXPR_BOOL_COMP: + lval = (r == 0) ? 1 : 0; + break; + default: + ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel); + return -1; + } + ejsWriteVarAsBoolean(ep, ep->result, lval != 0); + + } else { + ejsWriteVarAsNumber(ep, ep->result, lval); + } + return 0; +} + +/******************************************************************************/ +/* + * Expressions with string operands + */ + +static int evalStringExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs) +{ + int lval; + + mprAssert(ep); + mprAssert(lhs); + mprAssert(rhs); + + switch (rel) { + case EJS_EXPR_LESS: + lval = strcmp(lhs->string, rhs->string) < 0; + break; + case EJS_EXPR_LESSEQ: + lval = strcmp(lhs->string, rhs->string) <= 0; + break; + case EJS_EXPR_GREATER: + lval = strcmp(lhs->string, rhs->string) > 0; + break; + case EJS_EXPR_GREATEREQ: + lval = strcmp(lhs->string, rhs->string) >= 0; + break; + case EJS_EXPR_EQ: + lval = strcmp(lhs->string, rhs->string) == 0; + break; + case EJS_EXPR_NOTEQ: + lval = strcmp(lhs->string, rhs->string) != 0; + break; + case EJS_EXPR_PLUS: + /* + * This differs from all the above operations. We append rhs to lhs. + */ + ejsClearVar(ep, ep->result); + ejsStrcat(ep, ep->result, lhs); + ejsStrcat(ep, ep->result, rhs); + return 0; + + case EJS_EXPR_INC: + case EJS_EXPR_DEC: + case EJS_EXPR_MINUS: + case EJS_EXPR_DIV: + case EJS_EXPR_MOD: + case EJS_EXPR_LSHIFT: + case EJS_EXPR_RSHIFT: + default: + ejsSyntaxError(ep, "Bad operator"); + return -1; + } + + ejsWriteVarAsBoolean(ep, ep->result, lval); + return 0; +} + +/******************************************************************************/ +/* + * Evaluate a method. obj is set to the current object if a method is being + * run. + */ + +static int evalMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, int flags) +{ + EjsProperty *pp; + EjsVar *saveThis, *prototype; + int saveThisPerm, rc, fid; + + mprAssert(ep); + + rc = 0; + fid = -1; + saveThis = 0; + saveThisPerm = 0; + prototype = proc->fn; + + if (prototype == 0) { + ejsError(ep, EJS_EVAL_ERROR, "Undefined method"); + return EJS_STATE_ERR; + } + + if (prototype->type == EJS_TYPE_OBJECT) { + prototype = ejsGetPropertyAsVar(ep, prototype, proc->procName); + } + + if (prototype) { + /* + * Create a new variable stack frame. ie. new local variables. + * Some C methods (eg. include) don't create a new local context. + */ + if (! (prototype->flags & EJS_NO_LOCAL)) { + fid = ejsOpenBlock(ep); + if (fid < 0) { + return EJS_STATE_ERR; + } + mprAssert(ejsBlockInUse(ep->local)); + + pp = ejsSetProperty(ep, ep->local, "this", obj); + ejsMakePropertyEnumerable(pp, 0); + + /* + * Optimization. Save "this" during this block. + */ + saveThis = ep->thisObject; + ep->thisObject = ejsGetVarPtr(pp); + saveThisPerm = ejsMakeObjPermanent(saveThis, 1); + } + + switch (prototype->type) { + default: + mprAssert(0); + break; + + case EJS_TYPE_STRING_CMETHOD: + rc = callStringCMethod(ep, obj, proc, prototype); + break; + + case EJS_TYPE_CMETHOD: + rc = callCMethod(ep, obj, proc, prototype); + break; + + case EJS_TYPE_METHOD: + rc = callMethod(ep, obj, proc, prototype); + break; + } + + if (fid >= 0) { + ejsMakeObjPermanent(saveThis, saveThisPerm); + ep->thisObject = saveThis; + mprAssert(ejsBlockInUse(ep->local)); + mprAssert(ejsBlockInUse(ep->thisObject)); + ejsCloseBlock(ep, fid); + } + } + + return rc; +} + +/******************************************************************************/ +/* + * Create a new object and call all required constructors. + * obj may be null in which case we look globally for className. + */ + +EjsVar *ejsCreateObjUsingArgvInternal(EJS_LOC_DEC(ep, loc), EjsVar *obj, + const char *className, MprArray *args) +{ + EjsVar *baseClass, *objectClass, *thisObj; + int rc; + + mprAssert(className && *className); + + /* + * Create a new object of the required class and pass it into the + * constructor as the "this" local variable. + */ + baseClass = ejsGetClass(ep, obj, className); + if (baseClass == 0) { + + if (obj && obj->objectState->className && + strcmp(obj->objectState->className, className) == 0) { + /* + * Handle case where we are calling the constructor inside + * the class. In this case, obj == baseClass. + */ + thisObj = ejsCreateSimpleObjUsingClassInt(EJS_LOC_PASS(ep, loc), + obj); + + } else { + + /* + * If the baseClass does not exist, try to create an Object + * We do this for compatibility with JS 1.5 style new Function. + * MOB -- but this masks an error if we really need className. + */ + objectClass = ejsGetClass(ep, 0, "Object"); + thisObj = ejsCreateSimpleObjUsingClassInt(EJS_LOC_PASS(ep, loc), + objectClass); + } + + } else { + thisObj = ejsCreateSimpleObjUsingClassInt(EJS_LOC_PASS(ep, loc), + baseClass); + } + + if (thisObj == 0) { + ejsMemoryError(ep); + return 0; + } + + /* + * Make the object permanent. While currently not alive, the constructor + * below may make the object alive. + */ + ejsMakeObjPermanent(thisObj, 1); + mprAssert(! ejsObjIsCollectable(thisObj)); + + rc = 0; + if (baseClass) { + if (! baseClass->objectState->noConstructor) { + rc = callConstructor(ep, thisObj, baseClass, args); + } + } else { + /* + * className is the function name when calling new on functions + */ + rc = ejsRunMethod(ep, thisObj, className, args); + } + + /* + * Constructor may change the type to a non-object. + * Function() does this. Ensure object is not collectable yet. + */ + if (ejsVarIsObject(thisObj)) { + ejsMakeObjPermanent(thisObj, 0); + ejsMakeObjLive(thisObj, 0); + } + + if (rc < 0) { + if (rc == MPR_ERR_NOT_FOUND) { + /* No constructor (default) */ + return thisObj; + } + if (! (ep->flags & EJS_FLAGS_EXIT)) { + if (! ep->gotException) { + ejsMemoryError(ep); + } + } + ejsFreeVar(ep, thisObj); + return 0; + } + + mprAssert(ejsBlockInUse(thisObj)); + + return thisObj; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct CallCons { + EjsVar *subClassConstructor, *subClass, *method; +} CallCons; + +/* + * Create a new object and call all required constructors. + */ + +static int callConstructor(Ejs *ep, EjsVar *thisObj, EjsVar *baseClass, + MprArray *args) +{ + CallCons *sp; + int state; + + if ((sp = pushFrame(ep, sizeof(CallCons))) == 0) { + return EJS_STATE_ERR; + } + + mprAssert(baseClass); + mprAssert(baseClass->objectState); + + state = 0; + + /* + * method will be null if there is no constructor for this class + */ + sp->method = ejsGetPropertyAsVar(ep, baseClass, + baseClass->objectState->className); + + if (sp->method == 0 || !ejsVarIsMethod(sp->method) || + !sp->method->callsSuper) { + /* + * Invoke base class constructors in reverse order (RECURSIVE) + */ + sp->subClass = baseClass->objectState->baseClass; + if (sp->subClass) { + + /* + * Note that the Object class does not have a constructor for + * speed. Construction for the base Object is done via + * ejsCreateObj above. The code below will invoke constructors + * in the right order (bottom up) via recursion. MOB -- need to + * scan for super() MOB -- Bug. Fails poorly if no constructor. + * Should allows this and invoke a default constructor. + */ + sp->subClassConstructor = ejsGetPropertyAsVar(ep, sp->subClass, + sp->subClass->objectState->className); + + if (sp->subClassConstructor) { + + if (callConstructor(ep, thisObj, sp->subClass, 0) < 0) { + if (! ep->gotException) { + ejsMemoryError(ep); + } + goto err; + } + } + } + } + + if (sp->method) { + /* + * Finally, invoke the constructor for this class itself. + */ + state = runMethod(ep, thisObj, sp->method, + baseClass->objectState->className, args); + } + +done: + popFrame(ep, sizeof(CallCons)); + return state; + +err: + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Create a new object and call all required constructors using string args. + * MOB -- would be good to parse constructorArgs for "," and break into + * separate args. + * Returned object is not yet collectable. Will have alive bit cleared. + */ + +EjsVar *ejsCreateObj(Ejs *ep, EjsVar *obj, const char *className, + const char *constructorArgs) +{ + MprArray *args; + EjsVar *newp, *vp; + + args = mprCreateItemArray(ep, 0, 0); + if (args == 0) { + return 0; + } + + if (constructorArgs && *constructorArgs) { + vp = ejsCreateStringVarInternal(EJS_LOC_ARGS(ep), constructorArgs); + + if (mprAddItem(args, vp) < 0) { + mprFree(args); + return 0; + } + } + + newp = ejsCreateObjUsingArgv(ep, obj, className, args); + + ejsFreeMethodArgs(ep, args); + + mprAssert(! ejsObjIsCollectable(newp)); + mprAssert(ejsBlockInUse(newp)); + + return newp; +} + +/******************************************************************************/ + +static int callStringCMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, + EjsVar *prototype) +{ + EjsVar **argValues; + MprArray *actualArgs; + char **argBuf, *str; + int i, rc; + + actualArgs = proc->args; + argValues = (EjsVar**) actualArgs->items; + + if (actualArgs->length > 0) { + argBuf = mprAlloc(ep, actualArgs->length * sizeof(char*)); + for (i = 0; i < actualArgs->length; i++) { + str = ejsVarToString(ep, argValues[i]); + /* MOB rc */ + argBuf[i] = mprStrdup(ep, str); + } + } else { + argBuf = 0; + } + + /* + * Call the method depending on the various handle flags + */ + ep->userData = prototype->cMethodWithStrings.userData; + if (prototype->flags & EJS_ALT_HANDLE) { + /* + * Used by the AppWeb GaCompat module. The alt handle is set to the + * web server request struct + */ + rc = ((EjsAltStringCMethod) + prototype->cMethodWithStrings.fn) + (ep, ep->altHandle, obj, actualArgs->length, argBuf); + + } else if (prototype->flags & EJS_PRIMARY_HANDLE) { + /* + * Used by ESP. The primary handle is set to the esp struct + */ + rc = (prototype->cMethodWithStrings.fn)(ep->primaryHandle, + obj, actualArgs->length, argBuf); + + } else { + /* + * Used EJS for the standard procs + */ + rc = (prototype->cMethodWithStrings.fn)(ep, obj, actualArgs->length, + argBuf); + } + + if (actualArgs->length > 0) { + for (i = 0; i < actualArgs->length; i++) { + mprFree(argBuf[i]); + } + mprFree(argBuf); + } + ep->userData = 0; + + return rc; +} + +/******************************************************************************/ + +static int callCMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, EjsVar *prototype) +{ + EjsVar **argValues; + MprArray *actualArgs; + int rc; + + actualArgs = proc->args; + argValues = (EjsVar**) actualArgs->items; + + ep->userData = prototype->cMethod.userData; + + /* + * Call the method depending on the various handle flags + * Sometimes cMethod.fn is NULL if there is no constructor for + * an object. + */ + if (prototype->flags & EJS_ALT_HANDLE) { + /* + * Use by the GaCompat module. The alt handle is set to the + * web server request struct + */ + rc = ((EjsAltCMethod) prototype->cMethod.fn) + (ep, ep->altHandle, obj, actualArgs->length, argValues); + + } else if (prototype->flags & EJS_PRIMARY_HANDLE) { + /* + * Used by ESP. The primary handle is set to the esp struct + */ + rc = (prototype->cMethod.fn) + (ep->primaryHandle, obj, actualArgs->length, argValues); + + } else { + /* + * Used EJS for the standard procs + */ + rc = (prototype->cMethod.fn)(ep, obj, actualArgs->length, argValues); + } + + ep->userData = 0; + + return rc; +} + +/******************************************************************************/ +/* + * Local vars + */ + +typedef struct CallMethod { + MprArray *formalArgs, *actualArgs; + EjsVar *arguments, *callee, **argValues; + char **argNames, buf[16]; + int i, argumentsObj; +} CallMethod; + + +static int callMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, EjsVar *prototype) +{ + CallMethod *sp; + int i; + + if ((sp = pushFrame(ep, sizeof(CallMethod))) == 0) { + return EJS_STATE_ERR; + } + + sp->arguments = 0; + sp->callee = 0; + + sp->actualArgs = proc->args; + sp->argValues = (EjsVar**) sp->actualArgs->items; + sp->formalArgs = prototype->method.args; + sp->argNames = (char**) sp->formalArgs->items; + + /* + * Only create arguments and callee if the function actually uses them + */ + sp->argumentsObj = 0; + if (strstr(prototype->method.body, "arguments") != 0) { + sp->argumentsObj++; + + /* + * Create the arguments and callee variables + * MOB -- should we make real arrays here ? YES + */ + sp->arguments = ejsCreateSimpleObj(ep, "Object"); + ejsSetVarName(ep, sp->arguments, "arguments"); + mprAssert(! ejsObjIsCollectable(sp->arguments)); + + sp->callee = ejsCreateSimpleObj(ep, "Object"); + ejsSetVarName(ep, sp->callee, "callee"); + mprAssert(! ejsObjIsCollectable(sp->callee)); + + /* + * Overwrite the length property + */ + ejsSetPropertyToInteger(ep, sp->arguments, "length", + sp->actualArgs->length); + ejsSetPropertyToInteger(ep, sp->callee, "length", + sp->formalArgs->length); + } + + /* + * Define all the agruments to be set to the actual parameters + */ + for (i = 0; i < sp->formalArgs->length; i++) { + if (i >= sp->actualArgs->length) { + /* MOB -- return code */ + ejsCreateProperty(ep, ep->local, sp->argNames[i]); + + } else { + /* MOB -- return code */ + ejsSetProperty(ep, ep->local, sp->argNames[i], sp->argValues[i]); + } + } + + if (sp->argumentsObj) { + for (i = 0; i < sp->actualArgs->length; i++) { + mprItoa(sp->buf, sizeof(sp->buf), i); + ejsSetProperty(ep, sp->arguments, sp->buf, sp->argValues[i]); + } + + ejsSetPropertyAndFree(ep, sp->arguments, "callee", sp->callee); + ejsSetPropertyAndFree(ep, ep->local, "arguments", sp->arguments); + } + + /* + * Actually run the method + */ + + i = ejsEvalScript(ep, prototype->method.body, 0); + + popFrame(ep, sizeof(CallMethod)); + return i; +} + +/******************************************************************************/ +/* + * Run a method. Obj is set to "this" object. MethodName must exist in it + * or in a sub class. + */ + +int ejsRunMethod(Ejs *ep, EjsVar *obj, const char *methodName, MprArray *args) +{ + EjsProperty *pp; + EjsProc proc, *saveProc; + int rc; + + mprAssert(obj); + mprAssert(methodName && *methodName); + + pp = ejsGetProperty(ep, obj, methodName); + if (pp == 0) { + /* MOB -- this should be all in some common accessor routine */ + pp = ejsGetProperty(ep, ep->local, methodName); + if (pp == 0) { + pp = ejsGetProperty(ep, ep->global, methodName); + if (pp == 0) { + ejsError(ep, EJS_REFERENCE_ERROR, + "Undefined method \"%s\"", methodName); + return MPR_ERR_NOT_FOUND; + } + } + } + + saveProc = ep->proc; + ep->proc = &proc; + + memset(&proc, 0, sizeof(EjsProc)); + + ejsClearVar(ep, ep->result); + + /* MOB -- if closures are going to work, we need to have proc be an + Object and let the GC look after it */ + + proc.fn = &pp->var; + if (proc.fn == 0 || proc.fn->type == EJS_TYPE_UNDEFINED) { + ep->proc = saveProc; + return MPR_ERR_NOT_FOUND; + } + + proc.procName = mprStrdup(ep, methodName); + if (args == 0) { + proc.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS); + } else { + proc.args = args; + } + + rc = evalMethod(ep, obj, &proc, 0); + + if (args) { + proc.args = 0; + } + freeProc(ep, &proc); + + ep->proc = saveProc; + + return rc; +} + +/******************************************************************************/ +/* + * Run a method. Obj is set to "this" object. MethodName must exist in it + * or in a sub class. + */ + +int ejsRunMethodCmd(Ejs *ep, EjsVar *obj, const char *methodName, + const char *cmdFmt, ...) +{ + MprArray *args; + va_list cmdArgs; + char *buf, *arg, *cp; + int rc; + + mprAssert(methodName && *methodName); + mprAssert(cmdFmt && *cmdFmt); + + va_start(cmdArgs, cmdFmt); + mprAllocVsprintf(MPR_LOC_ARGS(ep), &buf, 0, cmdFmt, cmdArgs); + va_end(cmdArgs); + + args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS); + + for (arg = cp = buf; cp && *cp; cp++) { + if (*cp == ',') { + *cp = 0; + mprAddItem(args, ejsParseVar(ep, arg, 0)); + arg = cp + 1; + } + } + if (cp > arg) { + mprAddItem(args, ejsParseVar(ep, arg, 0)); + } + + rc = ejsRunMethod(ep, obj, methodName, args); + + ejsFreeMethodArgs(ep, args); + mprFree(buf); + + return rc; +} + +/******************************************************************************/ +/* + * Run a method. Obj is set to "this" object. + */ + +static int runMethod(Ejs *ep, EjsVar *thisObj, EjsVar *method, + const char *methodName, MprArray *args) +{ + EjsProc proc, *saveProc; + int rc; + + mprAssert(thisObj); + mprAssert(method); + + saveProc = ep->proc; + ep->proc = &proc; + + memset(&proc, 0, sizeof(EjsProc)); + + ejsClearVar(ep, ep->result); + + /* MOB -- if closures are going to work, we need to have proc be an + Object and let the GC look after it */ + + proc.fn = method; + if (proc.fn == 0 || proc.fn->type == EJS_TYPE_UNDEFINED) { + ep->proc = saveProc; + return MPR_ERR_NOT_FOUND; + } + + proc.procName = mprStrdup(ep, methodName); + if (args == 0) { + proc.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS); + } else { + proc.args = args; + } + + rc = evalMethod(ep, thisObj, &proc, 0); + + if (args) { + proc.args = 0; + } + freeProc(ep, &proc); + + ep->proc = saveProc; + + return rc; +} + +/******************************************************************************/ +/* + * Find which object contains the property given the current context. + * We call this when there is no explicit object and the object must be + * determined by the context. + */ + +static EjsVar *pickSpace(Ejs *ep, int state, const char *property, int flags) +{ + EjsVar *obj; + + mprAssert(ep); + mprAssert(property && *property); + + /* MOB - this is ugly and the logic is confused */ + + if (flags & EJS_FLAGS_GLOBAL) { + obj = ep->global; + + } else if (state == EJS_STATE_DEC || flags & EJS_FLAGS_LOCAL) { + obj = ep->local; + + } else { + /* First look local, then this and finally global */ + + if (ejsGetSimpleProperty(ep, ep->local, property)) { + obj = ep->local; + + } else if (ep->thisObject && + findProperty(ep, ep->thisObject, property, flags)) { + obj = ep->thisObject; + + } else { +#if EJS_ECMA_STND + obj = ep->global; +#else + if (flags & EJS_FLAGS_EXE && + !findProperty(ep, ep->global, property, flags)) { + obj = ep->local; + } else { + obj = ep->global; + } +#endif + } + } + return obj; +} + +/******************************************************************************/ +/* + * Find an object property given a object and a property name. We + * intelligently look in the local and global namespaces depending on + * our state. If not found in local or global, try base classes for method + * names only. Returns the property or NULL. + * MOB -- need to rework this API. + */ + +static EjsProperty *searchSpacesForProperty(Ejs *ep, int state, EjsVar *obj, + char *property, int flags) +{ + EjsProperty *pp; + + if (obj) { + return findProperty(ep, obj, property, flags); + } + + /* MOB -- really should have a search stack */ + + pp = findProperty(ep, ep->local, property, flags); + if (pp == 0 && state != EJS_STATE_DEC) { + + if (ep->thisObject) { + pp = findProperty(ep, ep->thisObject, property, flags); + } + if (pp == 0) { + pp = findProperty(ep, ep->global, property, flags); + } + } + return pp; +} + +/******************************************************************************/ +/* + * Search an object and its base classes to find an object given an object + * an a property name. If not an assignment (LHS), then follow base classes. + * Otherwise, just look in the specified object. + */ + +static EjsProperty *findProperty(Ejs *ep, EjsVar *op, const char *property, + int flags) +{ + /* MOB -- NEW. Remove when EXE fixes are in. */ + if (! (flags & EJS_FLAGS_EXE) && op->type == EJS_TYPE_UNDEFINED) { + return 0; + } + + if (flags & EJS_FLAGS_LHS) { + return ejsGetPropertyPtr(ejsGetSimpleProperty(ep, op, property)); + + } else { + /* + * Follow base classes + */ + return ejsGetPropertyPtr(ejsGetProperty(ep, op, property)); + } +} + +/******************************************************************************/ +/* + * Update result + */ + +static void updateResult(Ejs *ep, int state, int flags, EjsVar *vp) +{ + if (flags & EJS_FLAGS_EXE && state != EJS_STATE_DEC) { + ejsClearVar(ep, ep->result); + if (vp) { + ejsWriteVar(ep, ep->result, vp, EJS_SHALLOW_COPY); + ejsSetVarName(ep, ep->result, vp->propertyName); + } + } +} + +/******************************************************************************/ +/* + * Append to the pointer value + */ + +int ejsStrcat(Ejs *ep, EjsVar *dest, EjsVar *src) +{ + char *oldBuf, *buf, *str; + int oldLen, newLen, len; + + mprAssert(dest); + mprAssert(ejsVarIsString(src)); + + if (ejsVarIsValid(dest)) { + + if (! ejsVarIsString(dest)) { + /* Bad type for dest */ + return -1; + } + + if (! ejsVarIsString(src)) { + str = ejsVarToString(ep, src); + if (str == 0) { + return -1; + } + len = strlen(str); + + } else { + str = src->string; + len = src->length; + } + + oldBuf = dest->string; + oldLen = dest->length; + newLen = oldLen + len + 1; + + if (newLen < MPR_SLAB_STR_MAX) { + buf = oldBuf; + } else { + buf = mprRealloc(ep, oldBuf, newLen); + if (buf == 0) { + return -1; + } + dest->string = buf; + } + memcpy(&buf[oldLen], str, len); + dest->length += len; + + } else { + ejsWriteVarAsString(ep, dest, src->string); + } + return 0; +} + +/******************************************************************************/ +/* + * Exit the script + */ + +void ejsExit(Ejs *ep, int status) +{ + ep->scriptStatus = status; + ep->flags |= EJS_FLAGS_EXIT; +} + +/******************************************************************************/ +/* + * Free an argument list + */ + +static void freeProc(Ejs *ep, EjsProc *proc) +{ + if (proc->args) { + ejsFreeMethodArgs(ep, proc->args); + } + + if (proc->procName) { + mprFree(proc->procName); + proc->procName = NULL; + } +} + +/******************************************************************************/ + +void ejsFreeMethodArgs(Ejs *ep, MprArray *args) +{ + int i; + + for (i = args->length - 1; i >= 0; i--) { + ejsFreeVar(ep, args->items[i]); + mprRemoveItemByIndex(args, i); + } + mprFree(args); +} + +/******************************************************************************/ +/* + * This method removes any new lines. Used for else cases, etc. + */ + +static void removeNewlines(Ejs *ep, int state) +{ + int tid; + + do { + tid = ejsLexGetToken(ep, state); + } while (tid == EJS_TOK_NEWLINE); + + ejsLexPutbackToken(ep, tid, ep->token); +} + +/******************************************************************************/ + +static int getNextNonSpaceToken(Ejs *ep, int state) +{ + int tid; + + do { + tid = ejsLexGetToken(ep, state); + } while (tid == EJS_TOK_NEWLINE); + return tid; +} + +/******************************************************************************/ + +int ejsGetFlags(Ejs *ep) +{ + return ep->flags; +} + +/******************************************************************************/ + +bool ejsIsExiting(Ejs *ep) +{ + return (ep->flags & EJS_FLAGS_EXIT) ? 1: 0; +} + +/******************************************************************************/ + +void ejsClearExiting(Ejs *ep) +{ + ep->flags &= ~EJS_FLAGS_EXIT; +} + +/******************************************************************************/ + +static EjsInput *getInputStruct(Ejs *ep) +{ + EjsInput *input; + + if (ep->inputList) { + input = ep->inputList; + ep->inputList = input->nextInput; + + } else { + input = mprAlloc(ep, sizeof(EjsInput)); + } + return input; +} + +/******************************************************************************/ + +static void freeInputStruct(Ejs *ep, EjsInput *input) +{ + input->nextInput = ep->inputList; + ep->inputList = input; +} + +/******************************************************************************/ + +static void *pushFrame(Ejs *ep, int size) +{ + /* + * Grow down stack + */ + ep->stkPtr -= size; + if (ep->stkPtr < ep->stack) { + mprError(ep, MPR_LOC, "Exceeded parse stack"); + return 0; + } + return ep->stkPtr; +} + +/******************************************************************************/ + +static void *popFrame(Ejs *ep, int size) +{ + ep->stkPtr += size; + if (ep->stkPtr > &ep->stack[EJS_MAX_STACK]) { + mprError(ep, MPR_LOC, "Over poped parse stack"); + return 0; + } + return ep->stkPtr; +} + +/******************************************************************************/ +#else +void ejsParserDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/ejsVar.c b/source4/lib/appweb/ejs-2.0/ejs/ejsVar.c new file mode 100644 index 0000000000..5067215f03 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/ejsVar.c @@ -0,0 +1,4033 @@ +/** + * @file ejsVar.c + * @brief Mbedthis Portable Runtime Universal Variable Type + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 ********************************/ + +/* + * This module is NOT multithreaded. + * + * Properties are variables that are stored in an object type variable. + * Properties can be primitive data types, other objects or methods. + * Properties are indexed by a character name. + */ + +/********************************** Includes **********************************/ + +#include "ejs.h" + +/***************************** Forward Declarations ***************************/ + +static EjsProperty *allocProperty(Ejs *ep, EjsVar *op, const char *property, + int propertyIndex, EjsProperty *last); +static EjsVar *copyVar(EJS_LOC_DEC(ep, loc), EjsVar *dest, + const EjsVar *src, EjsCopyDepth copyDepth); +static EjsObj *createObj(EJS_LOC_DEC(ep, loc)); +static char *getNextVarToken(char **next, char *tokBuf, int tokBufLen); +static int hash(const char *property); +static void unlinkProperty(EjsObj *obj, EjsPropLink *propLink); +static void linkPropertyBefore(EjsObj *obj, EjsPropLink *at, + EjsPropLink *propLink); +static int sortAllProperties(Ejs *ep, EjsProperty *p1, + EjsProperty *p2, const char *propertyName, int order); +static int sortByProperty(Ejs *ep, EjsProperty *p1, EjsProperty *p2, + const char *propertyName, int order); +static int dupString(MPR_LOC_DEC(ctx, loc), uchar **dest, + const void *src, int nbytes); +#if UNUSED && KEEP +static void linkPropertyAfter(EjsObj *obj, EjsPropLink *at, + EjsPropLink *propLink); +#endif + +static EjsProperty *hashLookup(EjsObj *obj, const char *property, + int *propertyIndex, EjsProperty **hashTail); + +/******************************************************************************/ +/********************************** Var Routines ******************************/ +/******************************************************************************/ + +EjsType ejsGetVarType(EjsVar *vp) +{ + mprAssert(vp); + + return vp->type; +} + +/******************************************************************************/ + +void ejsFreeVar(Ejs *ep, EjsVar *vp) +{ + if (vp) { + ejsClearVar(ep, vp); + ejsFree(ep, vp, EJS_SLAB_VAR); + } +} + +/******************************************************************************/ +#if UNUSED +/* + * Clear the value by freeing any allocated data. This will release objects + * so that later garbage collection can reclaim storage if there are no other + * object references. + */ + +void ejsZeroVar(Ejs *ep, EjsVar *vp) +{ + vp->type = EJS_TYPE_UNDEFINED; + vp->objectState = 0; + vp->method.body = 0; + vp->method.args = 0; + vp->callsSuper = 0; + vp->ptr.destructor = 0; + vp->allocatedData = 0; +} + +#endif +/******************************************************************************/ +/* + * Clear the value by freeing any allocated data. This will release objects + * so that later garbage collection can reclaim storage if there are no other + * object references. + */ + +void ejsClearVar(Ejs *ep, EjsVar *vp) +{ + MprArray *argList; + int i; + + mprAssert(vp); + mprAssert(ep); + + if (! vp->allocatedData) { + vp->type = EJS_TYPE_UNDEFINED; + return; + } + if (vp->type == EJS_TYPE_UNDEFINED) { + return; + } + + switch (vp->type) { + default: + break; + + case EJS_TYPE_STRING: + mprFree(vp->string); + vp->string = 0; + break; + + case EJS_TYPE_OBJECT: + /* + * Set the "alive" bit so that the GC will cleanup if no + * other references. + */ + if (vp->objectState) { + vp->objectState->alive = 1; + } + vp->objectState = 0; + break; + + case EJS_TYPE_METHOD: + argList = vp->method.args; + /* + * MOB OPT -- should be able to do just one mprFree(vp->method.args) + */ + mprFree(vp->method.body); + if (argList) { + for (i = 0; i < argList->length; i++) { + mprFree(argList->items[i]); + } + mprFree(vp->method.args); + } + vp->method.args = 0; + vp->method.body = 0; + vp->callsSuper = 0; + break; + + case EJS_TYPE_PTR: + if (vp->ptr.destructor) { + (vp->ptr.destructor)(ep, vp); + } + break; + } + + vp->type = EJS_TYPE_UNDEFINED; + vp->allocatedData = 0; +} + +/******************************************************************************/ +/* + * Initialize an undefined value. + */ + +EjsVar *ejsCreateUndefinedVar(Ejs *ep) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_UNDEFINED; + } + return vp; +} + +/******************************************************************************/ +/* + * Initialize an null value. + */ + +EjsVar *ejsCreateNullVar(Ejs *ep) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_NULL; + } + return vp; +} + +/******************************************************************************/ + +EjsVar *ejsCreateBoolVar(Ejs *ep, int value) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_BOOL; + vp->boolean = value; + } + return vp; +} + +/******************************************************************************/ +/* + * Initialize a C method. + */ + +EjsVar *ejsCreateCMethodVar(Ejs *ep, EjsCMethod fn, void *userData, int flags) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_CMETHOD; + vp->cMethod.fn = fn; + vp->cMethod.userData = userData; + vp->flags = flags; + } + return vp; +} + +/******************************************************************************/ +/* + * Initialize a C method. + */ + +EjsVar *ejsCreateStringCMethodVar(Ejs *ep, EjsStringCMethod fn, + void *userData, int flags) +{ + EjsVar *vp; + + mprAssert(ep); + mprAssert(fn); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_STRING_CMETHOD; + vp->cMethodWithStrings.fn = fn; + vp->cMethodWithStrings.userData = userData; + vp->flags = flags; + } + return vp; +} + +/******************************************************************************/ +/* + * Initialize an opaque pointer. + */ + +EjsVar *ejsCreatePtrVar(Ejs *ep, void *ptr, EjsDestructor destructor) +{ + EjsVar *vp; + + mprAssert(ep); + mprAssert(ptr); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_PTR; + vp->ptr.userPtr = ptr; + vp->ptr.destructor = destructor; + vp->allocatedData = 1; + } + return vp; +} + +/******************************************************************************/ +#if BLD_FEATURE_FLOATING_POINT +/* + * Initialize a floating value. + */ + +EjsVar *ejsCreateFloatVar(Ejs *ep, double value) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_FLOAT; + vp->floating = value; + } + return vp; +} + +#endif +/******************************************************************************/ +/* + * Initialize an integer value. + */ + +EjsVar *ejsCreateIntegerVar(Ejs *ep, int value) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_INT; + vp->integer = value; + } + return vp; +} + +/******************************************************************************/ +#if BLD_FEATURE_INT64 +/* + * Initialize a 64-bit integer value. + */ + +EjsVar *ejsCreateInteger64Var(Ejs *ep, int64 value) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_INT64; + vp->integer64 = value; + } + return vp; +} + +#endif /* BLD_FEATURE_INT64 */ +/******************************************************************************/ +/* + * Initialize an number variable. Type is defined by configure. + */ + +EjsVar *ejsCreateNumberVar(Ejs *ep, EjsNum value) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + mprAssert(vp); + + if (vp) { + vp->type = BLD_FEATURE_NUM_TYPE_ID; +#if BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_INT64 + vp->integer64 = value; +#elif BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_FLOAT + vp->float = value; +#else + vp->integer = value; +#endif + } + return vp; +} + +/******************************************************************************/ +/* + * Initialize a (bare) JavaScript method. args and body can be null. + */ + +EjsVar *ejsCreateMethodVar(Ejs *ep, const char *body, MprArray *args, int flags) +{ + EjsVar *vp; + int i; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + mprAssert(vp); + + if (vp == 0) { + return 0; + } + + vp->type = EJS_TYPE_METHOD; + + vp->allocatedData = 1; + + vp->method.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS); + if (vp->method.args == 0) { + mprAssert(vp->method.args); + ejsFreeVar(ep, vp); + return 0; + } + + if (args) { + for (i = 0; i < args->length; i++) { + mprAddItem(vp->method.args, + mprStrdup(vp->method.args, mprGetItem(args, i))); + } + } + vp->method.body = mprStrdup(vp->method.args, body); + + if (vp->method.body == 0) { + ejsFreeVar(ep, vp); + return 0; + } + vp->flags = flags; + + return vp; +} + +/******************************************************************************/ +/* + * Initialize an object variable. + */ + +EjsVar *ejsCreateObjVarInternal(EJS_LOC_DEC(ep, loc)) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_PASS(ep, loc)); + mprAssert(vp); + + if (vp) { + vp->type = EJS_TYPE_OBJECT; + vp->objectState = createObj(EJS_LOC_PASS(ep, loc)); + if (vp->objectState == 0) { + ejsFreeVar(ep, vp); + return 0; + } + vp->allocatedData = 1; + } + return vp; +} + +/******************************************************************************/ +/* + * Initialize a string value. + */ + +EjsVar *ejsCreateStringVarInternal(EJS_LOC_DEC(ep, loc), const char *value) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_PASS(ep, loc)); + mprAssert(vp); + + if (vp) { + vp->type = EJS_TYPE_STRING; + vp->string = mprStrdupInternal(EJS_LOC_PASS(ep, loc), value); + if (vp->string == 0) { + ejsFreeVar(ep, vp); + return 0; + } + vp->length = strlen(vp->string); + vp->allocatedData = 1; + } + return vp; +} + +/******************************************************************************/ +/* + * Initialize a binary string value. + */ + +EjsVar *ejsCreateBinaryStringVar(Ejs *ep, const uchar *value, int len) +{ + EjsVar *vp; + + mprAssert(ep); + + vp = ejsAllocVar(EJS_LOC_ARGS(ep)); + if (vp) { + vp->type = EJS_TYPE_STRING; + vp->length = dupString(MPR_LOC_ARGS(ep), &vp->ustring, value, len); + if (vp->length < 0) { + ejsFreeVar(ep, vp); + return 0; + } + vp->allocatedData = 1; + } + return vp; +} + +/******************************************************************************/ + +void ejsSetClassName(Ejs *ep, EjsVar *vp, const char *name) +{ + EjsObj *obj; + + if (vp == 0 || !ejsVarIsObject(vp) || vp->objectState == 0) { + mprAssert(0); + return; + } + obj = vp->objectState; + + if (obj->className) { + mprFree(obj->className); + } + obj->className = mprStrdup(ep, name); +} + +/******************************************************************************/ + +EjsVar *ejsDupVarInternal(EJS_LOC_DEC(ep, loc), EjsVar *src, + EjsCopyDepth copyDepth) +{ + EjsVar *vp; + + vp = ejsAllocVar(EJS_LOC_PASS(ep, loc)); + if (vp == 0) { + return 0; + } + + vp->type = EJS_TYPE_UNDEFINED; + + return copyVar(EJS_LOC_PASS(ep, loc), vp, src, copyDepth); +} + +/******************************************************************************/ +/* + * Set a var to a new value + */ + +EjsVar *ejsWriteVarInternal(EJS_LOC_DEC(ep, loc), EjsVar *dest, + const EjsVar *src, EjsCopyDepth copyDepth) +{ + mprAssert(dest); + mprAssert(src); + + return copyVar(EJS_LOC_PASS(ep, loc), dest, src, copyDepth); +} + +/******************************************************************************/ +/* + * Set a var using a new bool value + */ + +EjsVar *ejsWriteVarAsBoolean(Ejs *ep, EjsVar *dest, int value) +{ + mprAssert(dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->type = EJS_TYPE_BOOL; + dest->boolean = value; + dest->allocatedData = 0; + dest->flags = 0; + + return dest; +} + +/******************************************************************************/ +/* + * Set a var using a new C Method + */ + +EjsVar *ejsWriteVarAsCMethod(Ejs *ep, EjsVar *dest, EjsCMethod fn, + void *userData, int flags) +{ + mprAssert(dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->type = EJS_TYPE_CMETHOD; + dest->cMethod.fn = fn; + dest->cMethod.userData = userData; + dest->flags = flags; + dest->allocatedData = 0; + + return dest; +} + +/******************************************************************************/ +#if BLD_FEATURE_FLOATING_POINT +/* + * Set a var using a new float value + */ + +EjsVar *ejsWriteVarAsFloat(Ejs *ep, EjsVar *dest, double value) +{ + mprAssert(dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->type = EJS_TYPE_FLOAT; + dest->floating = value; + dest->allocatedData = 0; + dest->flags = 0; + + return dest; +} + +#endif +/******************************************************************************/ +/* + * Set a var using a new integer value + */ + +EjsVar *ejsWriteVarAsInteger(Ejs *ep, EjsVar *dest, int value) +{ + mprAssert(dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->type = EJS_TYPE_INT; + dest->integer = value; + dest->allocatedData = 0; + dest->flags = 0; + + return dest; +} + +/******************************************************************************/ +#if BLD_FEATURE_INT64 +/* + * Set a var using a new integer value + */ + +EjsVar *ejsWriteVarAsInteger64(Ejs *ep, EjsVar *dest, int64 value) +{ + mprAssert(dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->type = EJS_TYPE_INT64; + dest->integer64 = value; + dest->allocatedData = 0; + dest->flags = 0; + + return dest; +} + +#endif +/******************************************************************************/ +/* + * Set a var using a new Method + */ + +EjsVar *ejsWriteVarAsMethod(Ejs *ep, EjsVar *dest, const char *body, + MprArray *args) +{ + EjsVar **srcArgs, *arg; + int i; + + mprAssert(ep); + mprAssert(dest); + mprAssert(body); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->method.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS); + if (dest->method.args == 0) { + return 0; + } + + dest->type = EJS_TYPE_METHOD; + + if (args) { + srcArgs = (EjsVar**) args->items; + for (i = 0; i < args->length; i++) { + arg = ejsDupVar(ep, srcArgs[i], EJS_SHALLOW_COPY); + if (arg == 0) { + return 0; + } + if (mprAddItem(dest->method.args, arg) < 0) { + return 0; + } + } + } + + dest->method.body = mprStrdup(dest->method.args, body); + if (dest->method.body == 0) { + return 0; + } + + dest->allocatedData = 1; + dest->flags = 0; + + return dest; +} + +/******************************************************************************/ +/* + * Set a var to null + */ + +EjsVar *ejsWriteVarAsNull(Ejs *ep, EjsVar *dest) +{ + mprAssert(dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->type = EJS_TYPE_NULL; + dest->allocatedData = 0; + dest->flags = 0; + + return dest; +} + +/******************************************************************************/ +/* + * Set a var using a new number value + */ + +EjsVar *ejsWriteVarAsNumber(Ejs *ep, EjsVar *dest, EjsNum value) +{ + mprAssert(dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->type = EJS_NUM_VAR; + dest->ejsNumber = value; + dest->allocatedData = 0; + dest->flags = 0; + + return dest; +} + +/******************************************************************************/ +/* + * Set a var using a new C Method + */ + +EjsVar *ejsWriteVarAsStringCMethod(Ejs *ep, EjsVar *dest, EjsStringCMethod fn, + void *userData, int flags) +{ + mprAssert(dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->type = EJS_TYPE_CMETHOD; + dest->cMethodWithStrings.fn = fn; + dest->cMethodWithStrings.userData = userData; + dest->flags = flags; + dest->allocatedData = 0; + + return dest; +} + +/******************************************************************************/ +/* + * Set a var using a new string value + */ + +EjsVar *ejsWriteVarAsStringInternal(EJS_LOC_DEC(ep, loc), EjsVar *dest, + const char *value) +{ + mprAssert(dest); + mprAssert(value); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->string = mprStrdupInternal(EJS_LOC_PASS(ep, loc), value); + if (dest->string == 0) { + return 0; + } + + dest->length = strlen(dest->string); + + dest->type = EJS_TYPE_STRING; + dest->allocatedData = 1; + dest->flags = 0; + + return dest; +} + +/******************************************************************************/ +/* + * Set a var using a new string value + */ + +EjsVar *ejsWriteVarAsBinaryString(Ejs *ep, EjsVar *dest, const uchar *value, + int len) +{ + mprAssert(dest); + mprAssert(value); + + ejsClearVar(ep, dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->length = dupString(MPR_LOC_ARGS(ep), &dest->ustring, value, len); + if (dest->length < 0) { + return 0; + } + + dest->type = EJS_TYPE_STRING; + dest->allocatedData = 1; + dest->flags = 0; + + return dest; +} + +/******************************************************************************/ +/* + * Set a var to undefined + */ + +EjsVar *ejsWriteVarAsUndefined(Ejs *ep, EjsVar *dest) +{ + mprAssert(dest); + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->type = EJS_TYPE_UNDEFINED; + dest->allocatedData = 0; + dest->flags = 0; + + return dest; +} + +/******************************************************************************/ +/* + * Convert a value to a text based representation of its value + * If you provide a format, you MUST ensure you know the type. + * Caller must free the result. + */ + +char *ejsFormatVar(Ejs *ep, const char *fmt, EjsVar *vp) +{ + char *buf, *src, *value, *allocValue; + uchar *ubuf; + int len; + + buf = 0; + allocValue = 0; + value = 0; + + switch (vp->type) { + case EJS_TYPE_UNDEFINED: + value = "undefined"; + break; + + case EJS_TYPE_NULL: + value = "null"; + break; + + case EJS_TYPE_PTR: + if (fmt == NULL || *fmt == '\0') { + len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, + "[Opaque Pointer %p]", vp->ptr.userPtr); + } else { + len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->ptr); + } + goto done; + + case EJS_TYPE_BOOL: + value = (vp->boolean) ? "true" : "false"; + break; + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + if (fmt == NULL || *fmt == '\0') { + fmt = "%f"; + } + len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->floating); + goto done; +#endif + + case EJS_TYPE_INT: + if (fmt == NULL || *fmt == '\0') { + fmt = "%d"; + } + mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->integer); + goto done; + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + if (fmt == NULL || *fmt == '\0') { + fmt = "%Ld"; + } + mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->integer64); + goto done; +#endif + + case EJS_TYPE_CMETHOD: + value = "[C Method]"; + break; + + case EJS_TYPE_STRING_CMETHOD: + value = "[C StringMethod]"; + break; + + case EJS_TYPE_METHOD: + value = ejsVarToString(ep, vp); + break; + + case EJS_TYPE_OBJECT: + value = ejsVarToString(ep, vp); + break; + + case EJS_TYPE_STRING: + src = vp->string; + mprAssert(src); + + if (fmt && *fmt && src) { + mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, src); + + } else if (src == NULL) { + buf = mprStrdup(ep, "null"); + + } else { + ubuf = (uchar*) buf; + if (dupString(MPR_LOC_ARGS(ep), &ubuf, src, vp->length) < 0) { + return mprStrdup(ep, ""); + } + buf = (char*) ubuf; + } + break; + + default: + mprAssert(0); + } + + if (fmt == NULL || *fmt == '\0') { + len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, "%s", value); + } else { + len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, value); + } + +done: + if (allocValue) { + mprFree(allocValue); + } + return buf; +} + +/******************************************************************************/ +/* + * Convert the variable to a boolean. Only for primitive types. + */ + +int ejsVarToBoolean(EjsVar *vp) +{ + mprAssert(vp); + + switch (vp->type) { + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + case EJS_TYPE_STRING_CMETHOD: + case EJS_TYPE_CMETHOD: + case EJS_TYPE_METHOD: + return 0; + + case EJS_TYPE_OBJECT: + return (vp->objectState != NULL); + + case EJS_TYPE_PTR: + return (vp->ptr.userPtr != NULL); + + case EJS_TYPE_BOOL: + return vp->boolean; + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + return (vp->floating != 0 && !ejsIsNan(vp->floating)); +#endif + + case EJS_TYPE_INT: + return (vp->integer != 0); + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + return (vp->integer64 != 0); +#endif + + case EJS_TYPE_STRING: + return (vp->length > 0); +#if UNUSED + if (strcmp(vp->string, "true") == 0 || + strcmp(vp->string, "TRUE") == 0) { + return 1; + + } else if (strcmp(vp->string, "false") == 0 || + strcmp(vp->string, "FALSE") == 0) { + return 0; + + } else { + return atoi(vp->string); + } +#endif + } + + /* Not reached */ + return 0; +} + +/******************************************************************************/ +#if BLD_FEATURE_FLOATING_POINT +/* + * Convert the variable to a floating point number. Only for primitive types. + */ + +double ejsVarToFloat(EjsVar *vp) +{ + mprAssert(vp); + + switch (vp->type) { + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + case EJS_TYPE_STRING_CMETHOD: + case EJS_TYPE_CMETHOD: + case EJS_TYPE_METHOD: + case EJS_TYPE_OBJECT: + case EJS_TYPE_PTR: + return 0; + + case EJS_TYPE_BOOL: + return (vp->boolean) ? 1.0 : 0.0; + + case EJS_TYPE_FLOAT: + return vp->floating; + + case EJS_TYPE_INT: + return (double) vp->integer; + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + return (double) vp->integer64; +#endif + + case EJS_TYPE_STRING: + if (vp->length == 0) { + return 0.0; + } else { + return atof(vp->string); + } + } + + /* Not reached */ + return 0; +} + +#endif +/******************************************************************************/ +/* + * Convert the variable to an Integer type. Only works for primitive types. + */ + +int ejsVarToInteger(EjsVar *vp) +{ + mprAssert(vp); + + switch (vp->type) { + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + case EJS_TYPE_STRING_CMETHOD: + case EJS_TYPE_CMETHOD: + case EJS_TYPE_METHOD: + case EJS_TYPE_OBJECT: + return 0; + + case EJS_TYPE_BOOL: + return (vp->boolean) ? 1 : 0; + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + if (ejsIsNan(vp->floating)) { + return 0; + } + return (int) vp->floating; +#endif + + case EJS_TYPE_INT: + return vp->integer; + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + return (int) vp->integer64; +#endif + + case EJS_TYPE_STRING: + if (vp->length == 0) { + return 0; + } else { + return ejsParseInteger(vp->string); + } + } + + /* Not reached */ + return 0; +} + +/******************************************************************************/ +#if BLD_FEATURE_INT64 +/* + * Convert the variable to an Integer64 type. Only works for primitive types. + */ + +int64 ejsVarToInteger64(EjsVar *vp) +{ + mprAssert(vp); + + switch (vp->type) { + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + case EJS_TYPE_STRING_CMETHOD: + case EJS_TYPE_CMETHOD: + case EJS_TYPE_METHOD: + case EJS_TYPE_OBJECT: + case EJS_TYPE_PTR: + return 0; + + case EJS_TYPE_BOOL: + return (vp->boolean) ? 1 : 0; + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + if (ejsIsNan(vp->floating)) { + return 0; + } + return (int64) vp->floating; +#endif + + case EJS_TYPE_INT: + return vp->integer; + + case EJS_TYPE_INT64: + return vp->integer64; + + case EJS_TYPE_STRING: + if (vp->length == 0) { + return 0; + } else { + return ejsParseInteger64(vp->string); + } + } + + /* Not reached */ + return 0; +} + +#endif /* BLD_FEATURE_INT64 */ +/******************************************************************************/ +/* + * Convert the variable to a number type. Only works for primitive types. + */ + +EjsNum ejsVarToNumber(EjsVar *vp) +{ +#if BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_INT64 + return ejsVarToInteger64(vp); +#elif BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_FLOAT + return ejsVarToFloat(vp); +#else + return ejsVarToInteger(vp); +#endif +} + +/******************************************************************************/ +/* + * Convert a var to a string. Store the result in ep->castTemp. If allocated + * set ep->castAlloc to TRUE. Caller must NOT free the result. + */ + +char *ejsVarToString(Ejs *ep, EjsVar *vp) +{ + MprBuf *bp; + char numBuf[16]; + int len, i; + + if (ep->castAlloc) { + mprFree(ep->castTemp); + } + ep->castTemp = 0; + ep->castAlloc = 0; + + switch (vp->type) { + case EJS_TYPE_UNDEFINED: + ep->castTemp = "undefined"; + break; + + case EJS_TYPE_NULL: + ep->castTemp = "null"; + break; + + case EJS_TYPE_PTR: + len = mprAllocSprintf(MPR_LOC_ARGS(ep), &ep->castTemp, 0, + "[Opaque Pointer %p]", vp->ptr.userPtr); + ep->castAlloc = 1; + break; + + case EJS_TYPE_BOOL: + if (vp->boolean) { + ep->castTemp = "true"; + } else { + ep->castTemp = "false"; + } + break; + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + len = mprAllocSprintf(MPR_LOC_ARGS(ep), &ep->castTemp, 0, + "%f", vp->floating); + ep->castAlloc = 1; + break; +#endif + + case EJS_TYPE_INT: + mprItoa(numBuf, sizeof(numBuf), vp->integer); + ep->castTemp = mprStrdup(ep, numBuf); + ep->castAlloc = 1; + break; + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + mprAllocSprintf(MPR_LOC_ARGS(ep), &ep->castTemp, 0, + "%Ld", vp->integer64); + ep->castAlloc = 1; + break; +#endif + + case EJS_TYPE_CMETHOD: + ep->castTemp = "[C Method]"; + break; + + case EJS_TYPE_STRING_CMETHOD: + ep->castTemp = "[C StringMethod]"; + break; + + case EJS_TYPE_METHOD: + bp = mprCreateBuf(ep, 0, 0); + mprPutStringToBuf(bp, "function ("); + for (i = 0; i < vp->method.args->length; i++) { + mprPutStringToBuf(bp, vp->method.args->items[i]); + if ((i + 1) < vp->method.args->length) { + mprPutStringToBuf(bp, ", "); + } + } + mprPutStringToBuf(bp, ") {"); + mprPutStringToBuf(bp, vp->method.body); + mprPutStringToBuf(bp, "}"); + mprAddNullToBuf(bp); + ep->castTemp = mprStealBuf(ep, bp); + ep->castAlloc = 1; + mprFree(bp); + break; + + case EJS_TYPE_OBJECT: + if (ejsRunMethod(ep, vp, "toString", 0) < 0) { + return mprStrdup(ep, "[object Object]"); + } + ep->castTemp = mprStrdup(ep, ep->result->string); + ep->castAlloc = 1; + break; + + case EJS_TYPE_STRING: + if (vp->string == 0) { + ep->castTemp = "null"; + } else { + ep->castTemp = vp->string; + } + break; + + default: + mprAssert(0); + } + + mprAssert(ep->castTemp); + return ep->castTemp; +} + +/******************************************************************************/ + +char *ejsVarToStringEx(Ejs *ep, EjsVar *vp, bool *alloc) +{ + char *str; + + mprAssert(alloc); + + str = ejsVarToString(ep, vp); + *alloc = ep->castAlloc; + ep->castAlloc = 0; + ep->castTemp = 0; + return str; +} + +/******************************************************************************/ +/* + * Parse a string based on formatting instructions and intelligently + * create a variable. + * + * Float format: [+|-]DIGITS][DIGITS][(e|E)[+|-]DIGITS] + */ + +EjsVar *ejsParseVar(Ejs *ep, const char *buf, EjsType preferredType) +{ + EjsType type; + const char *cp; + int isHex; + + mprAssert(buf); + + type = preferredType; + + if (preferredType == EJS_TYPE_UNDEFINED) { + isHex = 0; + if (*buf == '-' || *buf == '+') { + type = EJS_NUM_VAR; + + } else if (!isdigit((int) *buf)) { + if (strcmp(buf, "true") == 0 || strcmp(buf, "false") == 0) { + type = EJS_TYPE_BOOL; + } else { + type = EJS_TYPE_STRING; + } + + } else if (isdigit((int) *buf)) { + type = EJS_NUM_VAR; + cp = buf; + if (*cp && tolower(cp[1]) == 'x') { + cp = &cp[2]; + isHex = 1; + for (cp = buf; *cp; cp++) { + if (! isxdigit((int) *cp)) { + break; + } + } + } else { +#if BLD_FEATURE_FLOATING_POINT + /* Could be integer or float */ + for (cp = buf; *cp; cp++) { + if (! isdigit((int) *cp)) { + int c = tolower(*cp); + if (c == '.' || c == 'e' || c == 'f') { + type = EJS_TYPE_FLOAT; + break; + } + } + } +#endif + } + } + } + + switch (type) { + case EJS_TYPE_OBJECT: + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + case EJS_TYPE_PTR: + default: + break; + + case EJS_TYPE_BOOL: + return ejsCreateBoolVar(ep, ejsParseBoolean(buf)); + + case EJS_TYPE_INT: + return ejsCreateIntegerVar(ep, ejsParseInteger(buf)); + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + return ejsCreateInteger64Var(ep, ejsParseInteger64(buf)); +#endif + + case EJS_TYPE_STRING: + if (strcmp(buf, "null") == 0) { + return ejsCreateNullVar(ep); + + } else if (strcmp(buf, "undefined") == 0) { + return ejsCreateUndefinedVar(ep); + } + + return ejsCreateStringVar(ep, buf); + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + return ejsCreateFloatVar(ep, atof(buf)); +#endif + + } + return ejsCreateUndefinedVar(ep); +} + +/******************************************************************************/ +/* + * Convert the variable to a number type. Only works for primitive types. + */ + +bool ejsParseBoolean(const char *s) +{ + if (s == 0 || *s == '\0') { + return 0; + } + if (strcmp(s, "false") == 0 || strcmp(s, "FALSE") == 0) { + return 0; + } + return 1; +} + +/******************************************************************************/ +/* + * Convert the variable to a number type. Only works for primitive types. + */ + +EjsNum ejsParseNumber(const char *s) +{ +#if BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_INT64 + return ejsParseInteger64(s); +#elif BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_FLOAT + return ejsParseFloat(s); +#else + return ejsParseInteger(s); +#endif +} + +/******************************************************************************/ +#if BLD_FEATURE_INT64 +/* + * Convert the string buffer to an Integer64. + */ + +int64 ejsParseInteger64(const char *str) +{ + const char *cp; + int64 num64; + int radix, c, negative; + + mprAssert(str); + + cp = str; + num64 = 0; + negative = 0; + + if (*cp == '-') { + cp++; + negative = 1; + } else if (*cp == '+') { + cp++; + } + + /* + * Parse a number. Observe hex and octal prefixes (0x, 0) + */ + if (*cp != '0') { + /* + * Normal numbers (Radix 10) + */ + while (isdigit((int) *cp)) { + num64 = (*cp - '0') + (num64 * 10); + cp++; + } + } else { + cp++; + if (tolower(*cp) == 'x') { + cp++; + radix = 16; + while (*cp) { + c = tolower(*cp); + if (isdigit(c)) { + num64 = (c - '0') + (num64 * radix); + } else if (c >= 'a' && c <= 'f') { + num64 = (c - 'a' + 10) + (num64 * radix); + } else { + break; + } + cp++; + } + + } else{ + radix = 8; + while (*cp) { + c = tolower(*cp); + if (isdigit(c) && c < '8') { + num64 = (c - '0') + (num64 * radix); + } else { + break; + } + cp++; + } + } + } + + if (negative) { + return 0 - num64; + } + return num64; +} + +#endif /* BLD_FEATURE_INT64 */ +/******************************************************************************/ +/* + * Convert the string buffer to an Integer. + */ + +int ejsParseInteger(const char *str) +{ + const char *cp; + int num; + int radix, c, negative; + + mprAssert(str); + + cp = str; + num = 0; + negative = 0; + + if (*cp == '-') { + cp++; + negative = 1; + } else if (*cp == '+') { + cp++; + } + + /* + * Parse a number. Observe hex and octal prefixes (0x, 0) + */ + if (*cp != '0') { + /* + * Normal numbers (Radix 10) + */ + while (isdigit((int) *cp)) { + num = (*cp - '0') + (num * 10); + cp++; + } + } else { + cp++; + if (tolower(*cp) == 'x') { + cp++; + radix = 16; + while (*cp) { + c = tolower(*cp); + if (isdigit(c)) { + num = (c - '0') + (num * radix); + } else if (c >= 'a' && c <= 'f') { + num = (c - 'a' + 10) + (num * radix); + } else { + break; + } + cp++; + } + + } else{ + radix = 8; + while (*cp) { + c = tolower(*cp); + if (isdigit(c) && c < '8') { + num = (c - '0') + (num * radix); + } else { + break; + } + cp++; + } + } + } + + if (negative) { + return 0 - num; + } + return num; +} + +/******************************************************************************/ +#if BLD_FEATURE_FLOATING_POINT +/* + * Convert the string buffer to an Floating. + */ + +double ejsParseFloat(const char *str) +{ + return atof(str); +} + +/******************************************************************************/ + +int ejsIsNan(double f) +{ +#if WIN + return _isnan(f); +#elif VXWORKS + /* FUTURE */ + return (0); +#else + return (f == FP_NAN); +#endif +} +/******************************************************************************/ + +int ejsIsInfinite(double f) +{ +#if WIN + return !_finite(f); +#elif VXWORKS + /* FUTURE */ + return (0); +#else + return (f == FP_INFINITE); +#endif +} + +#endif /* BLD_FEATURE_FLOATING_POINT */ + +/******************************************************************************/ +/* + * Single point of control for all assignment to properties. + * + * Copy an objects core value (only). This preserves the destination object's + * name. This implements copy by reference for objects and copy by value for + * strings and other types. Caller must free dest prior to calling. + */ + +static EjsVar *copyVar(EJS_LOC_DEC(ep, loc), EjsVar *dest, const EjsVar *src, + EjsCopyDepth copyDepth) +{ + Ejs *ejsContext; + EjsObj *srcObj; + EjsProperty *destp; + const char **srcArgs; + char *str; + int i; + + mprAssert(dest); + mprAssert(src); + + if (dest == src) { + return dest; + } + + if (dest->type != EJS_TYPE_UNDEFINED) { + ejsClearVar(ep, dest); + } + + dest->allocatedData = 0; + + switch (src->type) { + default: + case EJS_TYPE_UNDEFINED: + case EJS_TYPE_NULL: + break; + + case EJS_TYPE_BOOL: + dest->boolean = src->boolean; + break; + + case EJS_TYPE_PTR: + dest->ptr = src->ptr; + if (dest->ptr.destructor) { + dest->allocatedData = 1; + } + break; + + case EJS_TYPE_STRING_CMETHOD: + dest->cMethodWithStrings = src->cMethodWithStrings; + break; + + case EJS_TYPE_CMETHOD: + dest->cMethod = src->cMethod; + break; + +#if BLD_FEATURE_FLOATING_POINT + case EJS_TYPE_FLOAT: + dest->floating = src->floating; + break; +#endif + + case EJS_TYPE_INT: + dest->integer = src->integer; + break; + +#if BLD_FEATURE_INT64 + case EJS_TYPE_INT64: + dest->integer64 = src->integer64; + break; +#endif + + case EJS_TYPE_OBJECT: + if (copyDepth == EJS_SHALLOW_COPY) { + + /* + * If doing a shallow copy and the src object is from the same + * interpreter, or we are copying from the master interpreter, or + * we are using a shared slab, then we can do a shallow copy. + * Otherwise, we must do a deep copy. + */ + srcObj = src->objectState; + if (srcObj->ejs == ep || srcObj->ejs == ep->service->master || + (ep->flags & EJS_FLAGS_SHARED_SLAB)) { + dest->objectState = src->objectState; + dest->allocatedData = 1; + break; + } + } + + /* + * Doing a deep or recursive deep. Can get here if doing a shallow + * copy and the object is from another non-master interpeter and not + * using a shared slab. + * + * We must make sure the data is allocated using the right memory + * context. It must be the same as the destination parent object. + * Otherwise, when we free the property memory, the parent may + * have a dangling pointer. + */ + if (dest->isProperty) { + destp = ejsGetPropertyPtr(dest); + if (destp->parentObj == 0) { + ejsContext = ep; + + } else { + mprAssert(destp->parentObj); + ejsContext = destp->parentObj->ejs; + mprAssert(ejsContext); + } + + } else { + ejsContext = ep; + } + + dest->objectState = createObj(EJS_LOC_PASS(ejsContext, loc)); + if (dest->objectState == 0) { + /* Memory Error */ + return 0; + } + + dest->objectState->baseClass = src->objectState->baseClass; + dest->objectState->methods = src->objectState->methods; + dest->objectState->noConstructor = src->objectState->noConstructor; + dest->objectState->objName = + mprStrdup(ejsContext, src->objectState->objName); + + if (dest->objectState->objName == 0) { + return 0; + } + + if (ejsCopyProperties(ep, dest, src, copyDepth) == 0) { + return 0; + } + dest->allocatedData = 1; + break; + + case EJS_TYPE_METHOD: + dest->method.args = mprCreateItemArray(ep, EJS_INC_ARGS, + EJS_MAX_ARGS); + if (dest->method.args == 0) { + return 0; + } + dest->allocatedData = 1; + if (src->method.args) { + srcArgs = (const char**) src->method.args->items; + for (i = 0; i < src->method.args->length; i++) { + str = mprStrdupInternal(EJS_LOC_PASS(dest->method.args, + loc), srcArgs[i]); + if (str == 0) { + mprFree(dest->method.args); + dest->method.args = 0; + return 0; + } + if (mprAddItem(dest->method.args, str) < 0) { + mprFree(dest->method.args); + dest->method.args = 0; + return 0; + } + } + } + dest->method.body = mprStrdup(dest->method.args, src->method.body); + if (dest->method.body == 0) { + mprFree(dest->method.args); + dest->method.args = 0; + return 0; + } + dest->callsSuper = src->callsSuper; + break; + + case EJS_TYPE_STRING: + dest->length = src->length; + if (src->string) { + /* Shallow, deep or recursive deep */ + dest->length = dupString(MPR_LOC_PASS(ep, loc), &dest->ustring, + src->ustring, src->length); + if (dest->length < 0) { + return 0; + } + dest->allocatedData = 1; + + } else { + dest->string = src->string; + dest->allocatedData = 0; + } + break; + } + + dest->type = src->type; + dest->flags = src->flags; + dest->isArray = src->isArray; + + return dest; +} + +/******************************************************************************/ +/* + * Copy all properies in an object. Must preserve property order + */ + +EjsVar *ejsCopyProperties(Ejs *ep, EjsVar *dest, const EjsVar *src, + EjsCopyDepth copyDepth) +{ + EjsProperty *srcProp, *destProp, *last, *next; + int propertyIndex; + + srcProp = ejsGetFirstProperty(src, EJS_ENUM_ALL); + while (srcProp) { + next = ejsGetNextProperty(srcProp, EJS_ENUM_ALL); + if (srcProp->visited) { + srcProp = next; + continue; + } + + /* + * This finds the last variable in the hash chain + * FUTURE OPT. This is slow. If used double link, we could locate the + * tail more easily. + */ + destProp = hashLookup(dest->objectState, srcProp->name, + &propertyIndex, &last); + mprAssert(destProp == 0); + + destProp = allocProperty(ep, dest, srcProp->name, propertyIndex, last); + if (destProp == 0) { + mprAssert(destProp); + return 0; + } + + /* + * Recursively copy the object. If DEEP_COPY, then we + * will do a shallow copy of the object contents. If + * RECURSIVE_DEEP, then we do a deep copy at all levels. + */ + srcProp->visited = 1; + + if (copyVar(EJS_LOC_ARGS(ep), ejsGetVarPtr(destProp), + ejsGetVarPtr(srcProp), + (copyDepth == EJS_DEEP_COPY) ? EJS_SHALLOW_COPY : copyDepth) + == 0) { + return 0; + } + srcProp->visited = 0; + + srcProp = next; + } + return dest; +} + +/******************************************************************************/ +/********************************** Properties ********************************/ +/******************************************************************************/ +/* + * Create a property in an object and return a pointer to it. If the property + * already exists then just return a pointer to it (no error). + * To test for existance of a property, use GetProperty + */ + +static EjsProperty *hashLookup(EjsObj *obj, const char *property, + int *propertyIndex, EjsProperty **hashTail) +{ + EjsProperty *prop, *last; + int index; + + mprAssert(obj); + mprAssert(property); + + if (obj == 0 || property == 0 || *property == '\0') { + mprAssert(0); + return 0; + } + + /* + * Find the property in the hash chain if it exists + */ + index = hash(property); + prop = obj->propertyHash[index]; + for (last = 0; prop != 0; last = prop, prop = prop->hashNext) { + if (prop->name[0] == property[0] && + strcmp(prop->name, property) == 0) { + break; + } + } + if (propertyIndex) { + *propertyIndex = index; + } + if (hashTail) { + *hashTail = last; + } + + return prop; +} + +/******************************************************************************/ +/* + * Create a property in an object and return a pointer to it. If the property + * already exists then just return a pointer to it (no error). If the property + * does not exist, create an undefined variable. To test for existance of a + * property, use GetProperty. + */ + +EjsProperty *ejsCreateSimpleProperty(Ejs *ep, EjsVar *op, const char *property) +{ + EjsProperty *prop, *last; + int propertyIndex; + + if (op == 0 || op->type != EJS_TYPE_OBJECT || property == 0 || + *property == '\0') { + mprAssert(0); + return 0; + } + + /* + * Find the property in the hash chain if it exists + */ + prop = hashLookup(op->objectState, property, &propertyIndex, &last); + + if (prop == 0) { + /* + * Create a new property + */ + prop = allocProperty(ep, op, property, propertyIndex, last); + if (prop == 0) { + mprAssert(prop == 0); + return 0; + } + } + return prop; +} + +/******************************************************************************/ +/* + * Create a property in an object and return a pointer to it. If the property + * already exists then just return a pointer to it (no error). + * To test for existance of a property, use GetProperty + */ + +EjsProperty *ejsCreateSimpleNonUniqueProperty(Ejs *ep, EjsVar *op, + const char *property) +{ + EjsProperty *prop, *last; + int propertyIndex; + + if (op == 0 || op->type != EJS_TYPE_OBJECT || property == 0 || + *property == '\0') { + mprAssert(0); + return 0; + } + + /* + * Find end of chain + */ + propertyIndex = hash(property); + prop = op->objectState->propertyHash[propertyIndex]; + for (last = 0; prop != 0; last = prop, prop = prop->hashNext) { + ; + } + + return allocProperty(ep, op, property, propertyIndex, last); +} + +/******************************************************************************/ +/* + * Find a property in an object and return a pointer to it. + * This does NOT traverse base classes. + */ + +EjsProperty *ejsGetSimpleProperty(Ejs *ep, EjsVar *op, const char *property) +{ + mprAssert(op); + mprAssert(op->type == EJS_TYPE_OBJECT); + mprAssert(property && *property); + + /* + * This is an internal API. It has very little checking. + */ + return hashLookup(op->objectState, property, 0, 0); +} + +/******************************************************************************/ + +/* + * NOTE: There is no ejsSetSimpleProperty as all the ejsSetProperty routines + * operate only on the instance and don't follow base classes. ie. there is + * no simple version required. However, there is a ejsSetBaseProperty routine + * that will follow base classes and is used to set static properties in base + * classes + */ + +/******************************************************************************/ +/******************************* Property Access ******************************/ +/******************************************************************************/ +/* + * The property get routines follow base classes and utilize the propery + * method access routines. The property set routines do not follow base + * classes. The property ejsSetBase... routines do follow base classes. + */ + +/* + * Find a property in an object and return a pointer to it. + * This follows base classes. + */ + +EjsProperty *ejsGetProperty(Ejs *ep, EjsVar *op, const char *property) +{ + EjsVar *vp, *newOp; + int maxBaseClasses = 50; + + do { + if (op->type != EJS_TYPE_OBJECT) { + mprAssert(op->type == EJS_TYPE_OBJECT); + return 0; + } + mprAssert(op->objectState); + + vp = ejsGetPropertyMethod(ep, op, property); + if (vp != 0) { + /* + * Found + */ + break; + } + + newOp = op->objectState->baseClass; + if (newOp == 0) { + if (op->objectState != ep->objectClass->objectState) { + newOp = ep->objectClass; + } + } + op = newOp; + + /* + * A little bit of sanity checking + */ + if (--maxBaseClasses <= 0) { + mprAssert(maxBaseClasses > 0); + break; + } + + } while (op); + + return ejsGetPropertyPtr(vp); +} + +/******************************************************************************/ +/* + * Get the property's variable. Optionally create if it does not exist. + */ + +EjsVar *ejsGetPropertyAsVar(Ejs *ep, EjsVar *vp, const char *property) +{ + return ejsGetVarPtr(ejsGetProperty(ep, vp, property)); +} + +/******************************************************************************/ +/* + * Get the property's value as a binary string. + */ + +const uchar *ejsGetPropertyAsBinaryString(Ejs *ep, EjsVar *obj, + const char *property, int *length) +{ + EjsVar *vp; + + vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property)); + if (vp == 0 || ejsVarIsUndefined(vp)) { + return 0; + } + + if (vp->type == EJS_TYPE_STRING) { + if (length) { + *length = vp->length; + } + return vp->ustring; + } + return 0; +} + +/******************************************************************************/ +/* + * Get the property's value as a string. + */ + +const char *ejsGetPropertyAsString(Ejs *ep, EjsVar *obj, const char *property) +{ + EjsVar *vp; + + vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property)); + if (vp == 0 || ejsVarIsUndefined(vp)) { + return 0; + } + + if (vp->type == EJS_TYPE_STRING) { + return vp->string; + } + return 0; +} + +/******************************************************************************/ +/* + * Get the property's value as a number. + */ + +BLD_FEATURE_NUM_TYPE ejsGetPropertyAsNumber(Ejs *ep, EjsVar *obj, + const char *property) +{ + EjsVar *vp; + + vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property)); + if (vp == 0 || ejsVarIsUndefined(vp)) { + return 0; + } + + return ejsVarToNumber(vp); +} + +/******************************************************************************/ +/* + * Get the property's value as a integer. + */ + +int ejsGetPropertyAsInteger(Ejs *ep, EjsVar *obj, const char *property) +{ + EjsVar *vp; + + vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property)); + if (vp == 0 || ejsVarIsUndefined(vp)) { + return 0; + } + + return ejsVarToInteger(vp); +} + +/******************************************************************************/ +/* + * Get the property's value as a boolean. + */ + +bool ejsGetPropertyAsBoolean(Ejs *ep, EjsVar *obj, const char *property) +{ + EjsVar *vp; + + vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property)); + if (vp == 0 || ejsVarIsUndefined(vp)) { + return 0; + } + + return ejsVarToBoolean(vp); +} + +/******************************************************************************/ +/* + * Get the property's value as a pointer. + */ + +void *ejsGetPropertyAsPtr(Ejs *ep, EjsVar *obj, const char *property) +{ + EjsVar *vp; + + vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property)); + if (vp == 0 || ejsVarIsUndefined(vp)) { + return 0; + } + if (vp->type == EJS_TYPE_PTR) { + return vp->ptr.userPtr; + } + return 0; +} + +/******************************************************************************/ +/* + * Create a property in the object. This will override any base class + * properties. + * + * MOB -- need to spell out the difference between ejsSetProperty and + * ejsCreateProperty. + */ + +EjsProperty *ejsCreateProperty(Ejs *ep, EjsVar *obj, const char *property) +{ + EjsVar *vp; + + vp = ejsCreatePropertyMethod(ep, obj, property); + return ejsGetPropertyPtr(vp); +} + +/******************************************************************************/ +/* + * Set a property's variable value. Create the property if it does not exist. + * This routine DOES follow base classes. + */ + +EjsProperty *ejsSetBaseProperty(Ejs *ep, EjsVar *op, const char *property, + const EjsVar *value) +{ + EjsVar *vp, *newOp; + int maxBaseClasses = 50; + + do { + if (op->type != EJS_TYPE_OBJECT) { + mprAssert(op->type == EJS_TYPE_OBJECT); + return 0; + } + mprAssert(op->objectState); + + vp = ejsGetPropertyMethod(ep, op, property); + if (vp != 0) { + /* + * Found + */ + vp = ejsSetPropertyMethod(ep, op, property, value); + break; + } + + newOp = op->objectState->baseClass; + if (newOp == 0) { + if (op->objectState != ep->objectClass->objectState) { + newOp = ep->objectClass; + } + } + op = newOp; + + /* + * A little bit of sanity checking + */ + if (--maxBaseClasses <= 0) { + mprAssert(maxBaseClasses > 0); + break; + } + + } while (op); + + return ejsGetPropertyPtr(vp); +} + +/******************************************************************************/ +/* + * Set a property's variable value. Create the property if it does not exist. + * This does NOT follow base classes. Okay when updating instance properties, + * but not for class (static) properties. This does a shallow copy which + * will copy references. + */ + +EjsProperty *ejsSetProperty(Ejs *ep, EjsVar *obj, const char *property, + const EjsVar *value) +{ + EjsVar *vp; + + vp = ejsSetPropertyMethod(ep, obj, property, value); + + return ejsGetPropertyPtr(vp); +} + +/******************************************************************************/ +/* + * Set a property's variable value by assigning the given value. The caller + * must NOT free value as it is assigned directly into the property's value. + */ + +EjsProperty *ejsSetPropertyAndFree(Ejs *ep, EjsVar *obj, + const char *property, EjsVar *value) +{ + EjsVar *vp; + + vp = ejsSetPropertyMethod(ep, obj, property, value); + + ejsFree(ep, value, EJS_SLAB_VAR); + + return ejsGetPropertyPtr(vp); +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToCMethod(Ejs *ep, EjsVar *vp, const char *prop, + EjsCMethod fn, void *userData, int flags) +{ + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_CMETHOD); + v.cMethod.fn = fn; + v.cMethod.userData = userData; + v.flags = flags; + + return ejsSetProperty(ep, vp, prop, &v); +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToBoolean(Ejs *ep, EjsVar *vp, const char *prop, + int value) +{ + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_BOOL); + v.boolean = value; + + return ejsSetProperty(ep, vp, prop, &v); +} + +/******************************************************************************/ +#if BLD_FEATURE_FLOATING_POINT + +EjsProperty *ejsSetPropertyToFloat(Ejs *ep, EjsVar *vp, const char *prop, + double value) +{ + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_FLOAT); + v.floating = value; + + return ejsSetProperty(ep, vp, prop, &v); +} + +#endif +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToInteger(Ejs *ep, EjsVar *vp, const char *prop, + int value) +{ + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_INT); + v.integer = value; + + return ejsSetProperty(ep, vp, prop, &v); +} + +/******************************************************************************/ +#if BLD_FEATURE_INT64 + +EjsProperty *ejsSetPropertyToInteger64(Ejs *ep, EjsVar *vp, const char *prop, + int64 value) +{ + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_INT64); + v.integer64 = value; + + return ejsSetProperty(ep, vp, prop, &v); +} + +#endif +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToNull(Ejs *ep, EjsVar *vp, const char *prop) +{ + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_NULL); + + return ejsSetProperty(ep, vp, prop, &v); +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToMethod(Ejs *ep, EjsVar *vp, const char *prop, + const char *body, MprArray *args, int flags) +{ + return ejsSetPropertyAndFree(ep, vp, prop, + ejsCreateMethodVar(ep, body, args, flags)); +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToNumber(Ejs *ep, EjsVar *vp, const char *prop, + EjsNum value) +{ + return ejsSetPropertyAndFree(ep, vp, prop, ejsCreateNumberVar(ep, value)); +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToStringCMethod(Ejs *ep, EjsVar *vp, + const char *prop, EjsStringCMethod fn, void *userData, int flags) +{ + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_STRING_CMETHOD); + v.cMethodWithStrings.fn = fn; + v.cMethodWithStrings.userData = userData; + v.flags = flags; + + return ejsSetProperty(ep, vp, prop, &v); +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToString(Ejs *ep, EjsVar *vp, const char *prop, + const char *value) +{ + EjsProperty *pp; + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_STRING); + + /* FUTURE OPT */ + v.string = mprStrdupInternal(EJS_LOC_ARGS(ep), value); + if (v.string == 0) { + return 0; + } + v.length = strlen(v.string); + v.allocatedData = 1; + + pp = ejsSetProperty(ep, vp, prop, &v); + + mprFree(v.string); + + return pp; +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToBinaryString(Ejs *ep, EjsVar *vp, + const char *prop, const uchar *value, int len) +{ + EjsProperty *pp; + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_STRING); + + /* FUTURE OPT */ + v.length = dupString(MPR_LOC_ARGS(ep), &v.ustring, value, len); + if (v.length < 0) { + return 0; + } + v.allocatedData = 1; + + pp = ejsSetProperty(ep, vp, prop, &v); + + mprFree(v.ustring); + + return pp; +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToUndefined(Ejs *ep, EjsVar *vp, const char *prop) +{ + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_UNDEFINED); + + return ejsSetProperty(ep, vp, prop, &v); +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToPtr(Ejs *ep, EjsVar *vp, const char *prop, + void *ptr, EjsDestructor destructor) +{ + EjsVar v; + + ejsInitVar(&v, EJS_TYPE_PTR); + v.ptr.userPtr = ptr; + v.ptr.destructor = destructor; + v.allocatedData = 1; + + return ejsSetProperty(ep, vp, prop, &v); +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToNewObj(Ejs *ep, EjsVar *vp, const char *prop, + const char *className, MprArray *args) +{ + return ejsSetPropertyAndFree(ep, vp, prop, + ejsCreateObjUsingArgv(ep, 0, className, args)); +} + +/******************************************************************************/ + +EjsProperty *ejsSetPropertyToObj(Ejs *ep, EjsVar *op, const char *prop) +{ + return ejsSetPropertyAndFree(ep, op, prop, ejsCreateObjVar(ep)); +} + +/******************************************************************************/ +/* + * Convenience routines + */ + +EjsVar *ejsSetPropertyToObjAsVar(Ejs *ep, EjsVar *op, const char *prop) +{ + return ejsGetVarPtr(ejsSetPropertyToObj(ep, op, prop)); +} + +/******************************************************************************/ +/******************************************************************************/ +/******************************************************************************/ +/******************************************************************************/ +/* + * Create a script method + */ + +EjsProperty *ejsDefineMethod(Ejs *ep, EjsVar *vp, const char *prop, + const char *body, MprArray *args) +{ + if (vp == 0) { + vp = ejsGetGlobalObj(ep); + } + return ejsSetPropertyToMethod(ep, vp, prop, body, args, 0); +} + +/******************************************************************************/ +/* + * Create a C language method + */ + +EjsProperty *ejsDefineCMethod(Ejs *ep, EjsVar *vp, const char *prop, + EjsCMethod fn, int flags) +{ + if (vp == 0) { + vp = ejsGetGlobalObj(ep); + } + return ejsSetPropertyToCMethod(ep, vp, prop, fn, 0, flags); +} + +/******************************************************************************/ +/* + * Define accessors + */ + +EjsProperty *ejsDefineAccessors(Ejs *ep, EjsVar *vp, const char *prop, + const char *getBody, const char *setBody) +{ + EjsProperty *pp; + MprArray *args; + char *propName; + + if (vp == 0) { + vp = ejsGetGlobalObj(ep); + } + + if (ejsSetPropertyToMethod(ep, vp, prop, getBody, 0, EJS_GET_ACCESSOR) < 0){ + ejsMemoryError(ep); + return 0; + } + + /* MOB -- OPT to use SLAB */ + /* MOB -- need to encapsulate this logic */ + + if (mprAllocStrcat(MPR_LOC_ARGS(ep), &propName, EJS_MAX_ID+5, 0, + "-set-", prop, 0) < 0) { + ejsMemoryError(ep); + return 0; + } + + args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS); + mprAddItem(args, mprStrdup(args, "value")); + + pp = ejsSetPropertyToMethod(ep, vp, propName, setBody, args, + EJS_SET_ACCESSOR); + mprFree(propName); + + if (pp == 0) { + ejsMemoryError(ep); + return 0; + } + + return pp; +} + +/******************************************************************************/ +/* + * Define C accessors + */ + +EjsProperty *ejsDefineCAccessors(Ejs *ep, EjsVar *vp, const char *prop, + EjsCMethod getFn, EjsCMethod setFn, int flags) +{ + EjsProperty *pp; + char *propName; + + if (vp == 0) { + vp = ejsGetGlobalObj(ep); + } + pp = ejsSetPropertyToCMethod(ep, vp, prop, getFn, 0, + flags | EJS_GET_ACCESSOR); + if (pp == 0) { + ejsMemoryError(ep); + return 0; + } + + /* MOB -- OPT to use SLAB */ + if (mprAllocStrcat(MPR_LOC_ARGS(ep), &propName, EJS_MAX_ID + 5, 0, + "-set-", prop, 0) < 0) { + ejsMemoryError(ep); + return 0; + } + pp = ejsSetPropertyToCMethod(ep, vp, propName, setFn, 0, + flags | EJS_SET_ACCESSOR); + mprFree(propName); + + if (pp == 0) { + ejsMemoryError(ep); + return 0; + } + return pp; +} + +/******************************************************************************/ +/* + * Create a C language method with string arguments + */ + +EjsProperty *ejsDefineStringCMethod(Ejs *ep, EjsVar *vp, const char *prop, + EjsStringCMethod fn, int flags) +{ + if (vp == 0) { + vp = ejsGetGlobalObj(ep); + } + return ejsSetPropertyToStringCMethod(ep, vp, prop, fn, 0, flags); +} + +/******************************************************************************/ + +void ejsSetCMethodUserData(EjsVar *obj, void *userData) +{ + /* + * This is a little dirty. We rely on the userData being in the same + * place in the var structure. + */ + obj->cMethod.userData = userData; +} + +/******************************************************************************/ + +void ejsSetVarFlags(EjsVar *obj, int flags) +{ + obj->flags = flags; +} + +/******************************************************************************/ + +void *ejsGetCMethodUserData(EjsVar *obj) +{ + return obj->cMethod.userData; +} + +/******************************************************************************/ + +int ejsGetVarFlags(EjsVar *obj) +{ + return obj->flags; +} + +/******************************************************************************/ + +void ejsSetObjDestructor(Ejs *ep, EjsVar *obj, EjsDestructor destructor) +{ + obj->objectState->destructor = destructor; +} + +/******************************************************************************/ + +void ejsClearObjDestructor(Ejs *ep, EjsVar *obj) +{ + obj->objectState->destructor = 0; +} + +/******************************************************************************/ +/* + * Create a new property + */ + +static EjsProperty *allocProperty(Ejs *ep, EjsVar *op, const char *property, + int propertyIndex, EjsProperty *last) +{ + EjsProperty *prop; + EjsObj *obj; + + obj = op->objectState; + + /* + * Allocate the property using the memory context of the owning object + */ + prop = ejsAllocProperty(EJS_LOC_ARGS(obj->ejs)); + if (prop == 0) { + return 0; + } + if (mprStrcpy(prop->name, sizeof(prop->name), property) < 0) { + ejsError(ep, EJS_REFERENCE_ERROR, + "Property name %s is too long. Max is %d letters.", + prop->name, EJS_MAX_ID); + return 0; + } + + ejsSetVarName(ep, ejsGetVarPtr(prop), &prop->name[0]); + + /* + * Do hash linkage + */ + if (last) { + last->hashNext = prop; + } else { + obj->propertyHash[propertyIndex] = prop; + } + +#if BLD_DEBUG + prop->link.propertyName = prop->name; + prop->link.property = prop; + prop->link.head = &obj->link; +#endif + + /* + * Inserting before the dummy head will append to the end + */ + linkPropertyBefore(obj, &obj->link, &prop->link); + + obj->numProperties++; + prop->parentObj = obj; + mprAssert(obj->ejs); + + return prop; +} + +/******************************************************************************/ +/* + * Delete a property from this object + */ + +int ejsDeleteProperty(Ejs *ep, EjsVar *vp, const char *property) +{ + EjsProperty *prop, *last; + EjsObj *obj; + int propertyIndex; + + mprAssert(vp); + mprAssert(property && *property); + mprAssert(vp->type == EJS_TYPE_OBJECT); + + if (vp->type != EJS_TYPE_OBJECT) { + mprAssert(vp->type == EJS_TYPE_OBJECT); + return MPR_ERR_BAD_ARGS; + } + + prop = hashLookup(vp->objectState, property, &propertyIndex, &last); + if (prop == (EjsProperty*) 0) { + return MPR_ERR_NOT_FOUND; + } + obj = vp->objectState; + +#if FUTURE + if (prop->readonly) { + mprAssert(! prop->readonly); + return MPR_ERR_READ_ONLY; + } +#endif + + /* + * If doing enumerations, then the object will mark preventDelete to + * prevent any properties being deleted and thus disturbing the + * traversal. + */ + if (obj->preventDeleteProp) { + obj->delayedDeleteProp = 1; + prop->delayedDelete = 1; + return 0; + } + + /* + * Remove from hash + */ + if (last) { + last->hashNext = prop->hashNext; + } else { + obj->propertyHash[propertyIndex] = prop->hashNext; + } + + unlinkProperty(obj, &prop->link); + obj->numProperties--; + + /* + * Free any property data and return to the slab + */ + if (prop->var.type != EJS_TYPE_OBJECT) { + ejsClearVar(ep, ejsGetVarPtr(prop)); + } + ejsFree(ep, prop, EJS_SLAB_PROPERTY); + + return 0; +} + +/******************************************************************************/ +/* + * Remove a property's value from this object. The property is set to + * undefined. + */ + +EjsVar *ejsClearProperty(Ejs *ep, EjsVar *vp, const char *property) +{ + EjsProperty *prop; + + mprAssert(vp); + mprAssert(property && *property); + mprAssert(vp->type == EJS_TYPE_OBJECT); + + if (vp->type != EJS_TYPE_OBJECT) { + mprAssert(vp->type == EJS_TYPE_OBJECT); + return 0; + } + + prop = hashLookup(vp->objectState, property, 0, 0); + if (prop == (EjsProperty*) 0) { + return 0; + } +#if FUTURE + if (prop->readonly) { + mprAssert(! prop->readonly); + return 0; + } +#endif + + ejsClearVar(ep, &prop->var); + return &prop->var; +} + +/******************************************************************************/ +/* + * Unlink a property from the ordered list of properties + */ + +static void unlinkProperty(EjsObj *obj, EjsPropLink *propLink) +{ + propLink->prev->next = propLink->next; + propLink->next->prev = propLink->prev; +} + +/******************************************************************************/ +#if UNUSED && KEEP +/* + * Insert a link after a specified link. + */ + +static void linkPropertyAfter(EjsObj *obj, EjsPropLink *at, + EjsPropLink *propLink) +{ + propLink->next = at->next; + propLink->prev = at; + + at->next->prev = propLink; + at->next = propLink; +} + +#endif +/******************************************************************************/ +/* + * Insert a link before a specified link. + */ + +static void linkPropertyBefore(EjsObj *obj, EjsPropLink *at, + EjsPropLink *propLink) +{ + propLink->prev = at->prev; + propLink->next = at; + + at->prev->next = propLink; + at->prev = propLink; +} + +/******************************************************************************/ +/* + * This routine will sort properties in an object. If propertyName is not + * null, then the properties in op must be objects with a property of the + * name propertyName. If propertyName is null, then the properties of op + * are directly sorted. If order is 1, they are sorted in ascending order. + * If -1, they are sorted in descending order. + * + * NOTE: arrays keep their original index values. + */ + +void ejsSortProperties(Ejs *ep, EjsVar *op, EjsSortFn fn, + const char *propertyName, int order) +{ + EjsProperty *p1, *p2, *tmp; + EjsPropLink *l1, *l2, *oldL1Spot; + EjsObj *obj; + + obj = op->objectState; + + p1 = ejsGetFirstProperty(op, 0); + while (p1) { + if (p1->dontEnumerate) { + p1 = ejsGetNextProperty(p1, 0); + continue; + } + + p2 = ejsGetFirstProperty(op, 0); + while (p2 && p2 != p1) { + + if (p2->dontEnumerate) { + p2 = ejsGetNextProperty(p2, 0); + continue; + } + + if (fn == 0) { + if (propertyName) { + fn = sortByProperty; + } else { + fn = sortAllProperties; + } + } + + if (fn(ep, p1, p2, propertyName, order) < 0) { + + l1 = &p1->link; + l2 = &p2->link; + + /* + * Swap the properties without disturbing the hash chains. + * l1 is always after l2 in the list. Unlink l1 and remember + * the one after l1. + */ + oldL1Spot = l1->next; + unlinkProperty(obj, l1); + + /* + * Manually reinsert l1 by replacing l2 with l1. l2 is out of + * the chain. + */ + l2->prev->next = l1; + l2->next->prev = l1; + l1->prev = l2->prev; + l1->next = l2->next; + + /* + * Reinsert l2 before the spot where l1 was. + */ + linkPropertyBefore(obj, oldL1Spot, l2); + + /* + * Swap the pointers so we continue to traverse correctly + */ + tmp = p1; + p1 = p2; + p2 = tmp; + } + p2 = ejsGetNextProperty(p2, 0); + } + p1 = ejsGetNextProperty(p1, 0); + } +} + +/******************************************************************************/ +/* + * Sort properties. Strings are sorted in ascending ASCII collating sequence + * Numbers are sorted in increasing numerical order. + */ +static int sortAllProperties(Ejs *ep, EjsProperty *p1, EjsProperty *p2, + const char *propertyName, int order) +{ + EjsVar *v1, *v2; + char *buf1, *buf2; + int rc, buf1Alloc; + + v1 = ejsGetVarPtr(p1); + v2 = ejsGetVarPtr(p2); + + if (v1->type == v2->type) { + /* MOB -- should support Numbers */ + if (v1->type == EJS_TYPE_INT) { + if (v1->integer < v2->integer) { + return - order; + + } else if (v1->integer == v2->integer) { + return 0; + } + return order; + +#if BLD_FEATURE_FLOATING_POINT + } else if (v1->type == EJS_TYPE_FLOAT) { + if (v1->floating < v2->floating) { + return - order; + + } else if (v1->floating == v2->floating) { + return 0; + } + return order; + +#endif + } else if (v1->type == EJS_TYPE_STRING) { + /* MOB -- need binary support ? */ + return strcmp(v1->string, v2->string) * order; + + } else { + + buf1 = ejsVarToStringEx(ep, v1, &buf1Alloc); + buf2 = ejsVarToString(ep, v2); + + rc = strcmp(buf1, buf2); + + if (buf1Alloc) { + mprFree(buf1); + } + + return rc * order; + } + + } else { + /* Type mismatch in array */ + return 0; + } + return 0; +} + +/******************************************************************************/ +/* + * Sort an object by a given property. + */ +static int sortByProperty(Ejs *ep, EjsProperty *p1, EjsProperty *p2, + const char *propertyName, int order) +{ + EjsVar *o1, *o2, *v1, *v2; + char *buf1, *buf2; + int rc, buf1Alloc; + + o1 = ejsGetVarPtr(p1); + o2 = ejsGetVarPtr(p2); + + if (!ejsVarIsObject(o1) || !ejsVarIsObject(o2)) { + mprAssert(ejsVarIsObject(o1)); + mprAssert(ejsVarIsObject(o2)); + return 0; + } + + v1 = ejsGetPropertyAsVar(ep, o1, propertyName); + v2 = ejsGetPropertyAsVar(ep, o2, propertyName); + + if (v1 == 0 || v2 == 0) { + /* Property name not found */ + return 0; + } + + if (v1->type != v2->type) { + mprAssert(v1->type == v2->type); + return 0; + } + + if (v1->type == v2->type) { + /* MOB -- should support Numbers */ + if (v1->type == EJS_TYPE_INT) { + if (v1->integer < v2->integer) { + return -order; + + } else if (v1->integer == v2->integer) { + return 0; + } + return order; + +#if BLD_FEATURE_FLOATING_POINT + } else if (v1->type == EJS_TYPE_FLOAT) { + if (v1->floating < v2->floating) { + return -order; + + } else if (v1->floating == v2->floating) { + return 0; + } + return order; + +#endif + } else if (v1->type == EJS_TYPE_STRING) { + /* MOB -- need binary support ? */ + return strcmp(v1->string, v2->string) * order; + + } else { + buf1 = ejsVarToStringEx(ep, v1, &buf1Alloc); + + buf2 = ejsVarToString(ep, v2); + + rc = strcmp(buf1, buf2); + + if (buf1Alloc) { + mprFree(buf1); + } + + return rc * order; + } + + } else { + /* Type mismatch in array */ + return 0; + } + return 0; +} + +/******************************************************************************/ +/* + * Set a property's name + */ + +void ejsSetPropertyName(EjsProperty *pp, const char *property) +{ + mprStrcpy(pp->name, sizeof(pp->name), property); +} + +/******************************************************************************/ + +int ejsMakePropertyEnumerable(EjsProperty *prop, int enumerate) +{ + int oldValue; + + oldValue = prop->dontEnumerate; + prop->dontEnumerate = !enumerate; + return oldValue; +} + +/******************************************************************************/ + +void ejsMakePropertyPrivate(EjsProperty *prop, int isPrivate) +{ + prop->isPrivate = isPrivate; +} + +/******************************************************************************/ +/* + * Make a variable read only. Can still be deleted. + */ + +void ejsMakePropertyReadOnly(EjsProperty *prop, int readonly) +{ + prop->readonly = readonly; +} + +/******************************************************************************/ + +int ejsMakeObjPermanent(EjsVar *vp, int permanent) +{ + int oldValue; + + if (vp && vp->type == EJS_TYPE_OBJECT) { + oldValue = vp->objectState->permanent; + vp->objectState->permanent = permanent; + } else { + oldValue = 0; + } + return oldValue; +} + +/******************************************************************************/ + +int ejsMakeObjLive(EjsVar *vp, bool alive) +{ + int oldValue; + + oldValue = 0; + if (vp && vp->type == EJS_TYPE_OBJECT) { + oldValue = vp->objectState->alive; + vp->objectState->alive = alive; + } else { + oldValue = 0; + } + return oldValue; +} + +/******************************************************************************/ + +void ejsMakeClassNoConstructor(EjsVar *vp) +{ + mprAssert(vp->type == EJS_TYPE_OBJECT); + + if (vp->type == EJS_TYPE_OBJECT) { + vp->objectState->noConstructor = 1; + } +} + +/******************************************************************************/ +/* + * Get the count of properties. + */ + +int ejsGetPropertyCount(EjsVar *vp) +{ + EjsProperty *pp; + EjsPropLink *lp, *head; + int count; + + mprAssert(vp); + + if (vp->type != EJS_TYPE_OBJECT) { + return 0; + } + + count = 0; + + head = &vp->objectState->link; + for (lp = head->next; lp != head; lp = lp->next) { + pp = ejsGetPropertyFromLink(lp); + if (! pp->dontEnumerate) { + count++; + } + } + return count; +} + +/******************************************************************************/ +/* + * Get the first property in an object. Used for walking all properties in an + * object. This will only enumerate properties in this class and not in base + * classes. + */ + +EjsProperty *ejsGetFirstProperty(const EjsVar *op, int flags) +{ + EjsProperty *pp; + EjsObj *obj; + EjsPropLink *head, *lp; + + mprAssert(op); + mprAssert(op->type == EJS_TYPE_OBJECT); + + if (op->type != EJS_TYPE_OBJECT) { + mprAssert(op->type == EJS_TYPE_OBJECT); + return 0; + } + pp = 0; + + do { + obj = op->objectState; + + head = &obj->link; + lp = head->next; + + while (lp != head) { + pp = ejsGetPropertyFromLink(lp); + if (! pp->dontEnumerate || (flags & EJS_ENUM_HIDDEN)) { + break; + } + lp = lp->next; + } + if (lp != head || op->type != EJS_TYPE_OBJECT || + !(flags & EJS_ENUM_CLASSES)) { + break; + } + + op = obj->baseClass; + + } while (lp == 0 && op); + + return pp; +} + +/******************************************************************************/ +/* + * Get the next property in sequence. This will only enumerate properties in + * this class and not in base classes. + */ + +EjsProperty *ejsGetNextProperty(EjsProperty *last, int flags) +{ + EjsProperty *pp; + EjsObj *obj; + EjsPropLink *lp, *head; + + obj = last->parentObj; + + lp = last->link.next; + head = &obj->link; + pp = 0; + + while (obj) { + while (lp != head) { + pp = ejsGetPropertyFromLink(lp); + if (! pp->dontEnumerate || (flags & EJS_ENUM_HIDDEN)) { + break; + } + lp = lp->next; + } + if (lp != head || !(flags & EJS_ENUM_CLASSES)) { + break; + } + + /* + * Now iterate over properties in base classes (down the chain) + */ + if (obj->baseClass == 0) { + break; + } + + obj = obj->baseClass->objectState; + if (obj == 0) { + break; + } + } + return pp; +} + +/******************************************************************************/ +/* + * Find a variable given a variable name and return the parent object and + * the variable itself. This routine supports literal variable and property + * names that may be objects or arrays but may NOT have expressions. + * Returns -1 on errors or if the variable is not found. + * FUTURE -- Needs OPT + */ + +EjsVar *ejsFindProperty(Ejs *ep, EjsVar **obj, char **property, EjsVar *global, + EjsVar *local, const char *fullName, int create) +{ + EjsProperty *currentProp; + EjsVar *currentObj; + /* MOB -- WARNING BIG */ + char tokBuf[EJS_MAX_ID], propertyName[EJS_MAX_ID]; + char *token, *next, *cp, *endp; + + mprAssert(fullName && *fullName); + + currentProp = 0; + currentObj = 0; + + if (global == 0) { + global = ep->global; + } + + if (obj) { + *obj = 0; + } + if (property) { + *property = 0; + } + + if (fullName == 0) { + return 0; + } + + next = (char*) fullName; + token = getNextVarToken(&next, tokBuf, sizeof(tokBuf)); + mprStrcpy(propertyName, sizeof(propertyName), token); + + if (local) { + currentProp = ejsGetProperty(ep, local, token); + currentObj = local; + } + if (currentProp == 0) { + currentProp = ejsGetProperty(ep, global, token); + currentObj = global; + } + + token = getNextVarToken(&next, tokBuf, sizeof(tokBuf)); + + while (currentObj != 0 && token != 0 && *token) { + + if (currentProp == 0) { + return 0; + } + currentObj = ¤tProp->var; + currentProp = 0; + + if (*token == '[') { + token = getNextVarToken(&next, tokBuf, sizeof(tokBuf)); + + mprStrcpy(propertyName, sizeof(propertyName), token); + cp = propertyName; + if (*cp == '\"') { + cp++; + if ((endp = strchr(cp, '\"')) != 0) { + *endp = '\0'; + } + } else if (*cp == '\'') { + cp++; + if ((endp = strchr(cp, '\'')) != 0) { + *endp = '\0'; + } + } + + currentProp = ejsGetProperty(ep, currentObj, propertyName); + + token = getNextVarToken(&next, tokBuf, sizeof(tokBuf)); + if (*token != ']') { + return 0; + } + + } else if (*token == '.') { + token = getNextVarToken(&next, tokBuf, sizeof(tokBuf)); + if (!isalpha((int) token[0]) && + token[0] != '_' && token[0] != '$') { + return 0; + } + + mprStrcpy(propertyName, sizeof(propertyName), token); + currentProp = ejsGetProperty(ep, currentObj, token); + + } else { + currentProp = ejsGetProperty(ep, currentObj, token); + } + + if (next == 0 || *next == '\0') { + break; + } + token = getNextVarToken(&next, tokBuf, sizeof(tokBuf)); + } + + if (obj) { + *obj = currentObj; + } + + + if (currentProp == 0 && currentObj >= 0 && create) { + currentProp = ejsCreateSimpleProperty(ep, currentObj, propertyName); + } + + if (property) { + *property = currentProp->name; + } + return ejsGetVarPtr(currentProp); +} + +/******************************************************************************/ +/* + * Get the next token as part of a variable specification. This will return + * a pointer to the next token and will return a pointer to the next token + * (after this one) in "next". The tokBuf holds the parsed token. + */ + +static char *getNextVarToken(char **next, char *tokBuf, int tokBufLen) +{ + char *start, *cp; + int len; + + start = *next; + while (isspace((int) *start) || *start == '\n' || *start == '\r') { + start++; + } + cp = start; + + if (*cp == '.' || *cp == '[' || *cp == ']') { + cp++; + } else { + while (*cp && *cp != '.' && *cp != '[' && *cp != ']' && + !isspace((int) *cp) && *cp != '\n' && *cp != '\r') { + cp++; + } + } + len = mprMemcpy(tokBuf, tokBufLen - 1, start, cp - start); + tokBuf[len] = '\0'; + + *next = cp; + return tokBuf; +} + +/******************************************************************************/ + +EjsVar *ejsGetGlobalClass(Ejs *ep) +{ + return ep->global; +} + +/******************************************************************************/ +/*************************** Property Access Methods **************************/ +/******************************************************************************/ +/* + * Create an undefined property. This routine calls the object method hooks. + */ + +/* MOB -- better suffix than "Method" */ +EjsVar *ejsCreatePropertyMethod(Ejs *ep, EjsVar *op, const char *property) +{ + EjsVar *vp; + + mprAssert(ep); + mprAssert(op); + mprAssert(property && *property); + + if (op == 0) { + return 0; + } + + mprAssert(op->type == EJS_TYPE_OBJECT); + mprAssert(op->objectState); + + if (op->objectState == 0) { + return 0; + } + + if (op->objectState->methods == 0) { + vp = ejsGetVarPtr(ejsCreateSimpleProperty(ep, op, property)); + } else { + vp = (op->objectState->methods->createProperty)(ep, op, property); + } + + if (vp == 0) { + mprAssert(vp); + op->objectState->hasErrors = 1; + return 0; + } + + /* + * FUTURE - find a better way. + */ + if (op->isArray) { + ejsSetArrayLength(ep, op, property, 0, 0); + } + return vp; +} + +/******************************************************************************/ + +int ejsDeletePropertyMethod(Ejs *ep, EjsVar *op, const char *property) +{ + int rc; + + mprAssert(ep); + mprAssert(op); + mprAssert(property && *property); + + if (op == 0) { + return -1; + } + + mprAssert(op->type == EJS_TYPE_OBJECT); + mprAssert(op->objectState); + + if (op->objectState == 0) { + return -1; + } + + if (op->objectState->methods == 0) { + rc = ejsDeleteProperty(ep, op, property); + } else { + rc = (op->objectState->methods->deleteProperty)(ep, op, property); + } + + if (rc < 0) { + op->objectState->hasErrors = 1; + } + + op->objectState->dirty = 1; + + return rc; +} + +/******************************************************************************/ +/* + * Set the value of a property. Create if it does not exist + * If the object has property accessor methods defined, use those. + */ + +EjsVar *ejsSetPropertyMethod(Ejs *ep, EjsVar *op, const char *property, + const EjsVar *value) +{ + EjsVar *vp; + + mprAssert(ep); + mprAssert(op); + mprAssert(property && *property); + mprAssert(value); + + if (op == 0) { + return 0; + } + + mprAssert(op->type == EJS_TYPE_OBJECT); + mprAssert(op->objectState); + + if (op->objectState == 0) { + return 0; + } + + if (op->objectState->methods == 0) { + vp = ejsGetVarPtr(ejsCreateSimpleProperty(ep, op, property)); + if (vp && ejsWriteVar(ep, vp, (EjsVar*) value, EJS_SHALLOW_COPY) < 0) { + mprAssert(0); + op->objectState->hasErrors = 1; + return 0; + } + + } else { + vp = (op->objectState->methods->setProperty)(ep, op, property, value); + } + + if (vp == 0) { + mprAssert(vp); + op->objectState->hasErrors = 1; + return 0; + } + + if (vp->type == EJS_TYPE_OBJECT) { + /* + * We make an object alive (and subject to garbage collection) when + * it is referenced in some other object. If this is undesirable, the + * caller should make the object permanent while calling this routine + * and then afterward clear the alive bit by calling ejsMakeObjLive(). + */ + if (op->objectState != vp->objectState) { + vp->objectState->alive = 1; + } +#if BLD_DEBUG + { + EjsProperty *pp = ejsGetPropertyPtr(vp); + ejsSetVarName(ep, vp, &pp->name[0]); + if (value->propertyName == 0) { + ejsSetVarName(ep, (EjsVar*) value, &pp->name[0]); + } + } +#endif + } + + /* + * Trap assignments to array.length. MOB - find a better way. + */ + if (vp->isArrayLength) { + ejsSetArrayLength(ep, op, 0, 0, value); + } + + op->objectState->dirty = 1; + + return vp; +} + +/******************************************************************************/ + +EjsVar *ejsGetPropertyMethod(Ejs *ep, EjsVar *op, const char *property) +{ + mprAssert(ep); + mprAssert(op); + mprAssert(property && *property); + + if (op == 0) { + return 0; + } + + mprAssert(op->type == EJS_TYPE_OBJECT); + mprAssert(op->objectState); + + if (op->objectState == 0) { + return 0; + } + + if (op->objectState->methods == 0) { + return ejsGetVarPtr(ejsGetSimpleProperty(ep, op, property)); + } else { + return (op->objectState->methods->getProperty)(ep, op, property); + } +} + +/******************************************************************************/ +/*************************** Advisory Locking Support *************************/ +/******************************************************************************/ +#if BLD_FEATURE_MULTITHREAD + +void ejsLockObj(EjsVar *vp) +{ + mprAssert(vp); + mprAssert(vp->type == EJS_TYPE_OBJECT); + mprAssert(vp->objectState); + + if (vp->objectState->mutex == 0) { + vp->objectState->mutex = mprCreateLock(vp->objectState->ejs); + } + mprLock(vp->objectState->mutex); +} + +/******************************************************************************/ + +void ejsUnlockObj(EjsVar *vp) +{ + mprAssert(vp); + mprAssert(vp->type == EJS_TYPE_OBJECT); + mprAssert(vp->objectState); + + if (vp->objectState->mutex) { + mprUnlock(vp->objectState->mutex); + } +} + +#endif +/******************************************************************************/ +/************************** Internal Support Routines *************************/ +/******************************************************************************/ +/* + * Create an object. + */ + +static EjsObj *createObj(EJS_LOC_DEC(ep, loc)) +{ + EjsObj *op; + EjsPropLink *lp; + + op = (EjsObj*) ejsAllocObj(EJS_LOC_PASS(ep, loc)); + if (op == NULL) { + return 0; + } + + /* + * The objectState holds the dummy head for the ordered list of properties + */ + lp = &op->link; + lp->next = lp->prev = lp; + +#if BLD_DEBUG + /* + * This makes it much easier to debug the list + */ + lp->head = lp; + lp->propertyName = "dummyHead"; +#endif + + return op; +} + +/******************************************************************************/ +/* + * Destroy an object. Called by the garbage collector if there are no more + * references to an object. + */ + +int ejsDestroyObj(Ejs *ep, EjsObj *obj) +{ + EjsProperty *pp; + EjsPropLink *lp, *head, *nextLink; + + mprAssert(obj); + + if (obj->destructor) { + EjsVar v; + memset(&v, 0, sizeof(v)); + v.type = EJS_TYPE_OBJECT; + v.objectState = obj; + ejsSetVarName(ep, &v, "destructor"); + +#if BLD_FEATURE_ALLOC_LEAK_TRACK + v.gc.allocatedBy = "static"; +#endif + + if ((obj->destructor)(ep, &v) < 0) { + return -1; + } + } + mprFree(obj->objName); + obj->objName = 0; + + /* + * Just for safety. An object may be marked by a GC on the default + * interpreter. After destroying, it won't be on the free list and so + * won't be reset. + */ + obj->gcMarked = 0; + obj->visited = 0; + + head = &obj->link; + for (lp = head->next; lp != head; lp = nextLink) { + + pp = ejsGetPropertyFromLink(lp); + nextLink = lp->next; + + /* + * We don't unlink as we are destroying all properties. + * If an object, we don't need to clear either. + */ + if (pp->var.type != EJS_TYPE_OBJECT) { + ejsClearVar(ep, ejsGetVarPtr(pp)); + } + ejsFree(ep, pp, EJS_SLAB_PROPERTY); + } + +#if BLD_FEATURE_MULTITHREAD + if (obj->mutex) { + mprDestroyLock(obj->mutex); + } +#endif + + ejsFree(ep, obj, EJS_SLAB_OBJ); + return 0; +} + +/******************************************************************************/ +/* + * Fast hash. The history of this algorithm is part of lost computer science + * folk lore. + */ + +static int hash(const char *property) +{ + uint sum; + + mprAssert(property); + + sum = 0; + while (*property) { + sum += (sum * 33) + *property++; + } + + return sum % EJS_OBJ_HASH_SIZE; +} + +/******************************************************************************/ +/* + * Set a new length for an array. If create is non-null, then it is the name + * of a new array index. If delete is set, it is the name of an index being + * deleted. If setLength is set to a variable, it counts the new length for the + * array. Note that create and delete are ignored if they are non-integer + * array indexes (eg. normal properties). + */ + +void ejsSetArrayLength(Ejs *ep, EjsVar *obj, const char *create, + const char *delete, const EjsVar *setLength) +{ + EjsVar *vp; + char idx[16]; + int oldSize, newSize, i; + + vp = ejsGetPropertyAsVar(ep, obj, "length"); + oldSize = vp->integer; + newSize = oldSize; + + if (create) { + if (isdigit(*create)) { + i = atoi(create); + newSize = max(i + 1, oldSize); + } + } else if (delete) { + if (isdigit(*delete)) { + i = atoi(delete); + newSize = (i == (oldSize - 1) ? oldSize - 1 : oldSize); + } + } else { + newSize = setLength->integer; + } + + for (i = newSize; i < oldSize; i++) { + mprItoa(idx, sizeof(idx), i); + ejsDeleteProperty(ep, obj, idx); + } + + if (ejsWriteVarAsInteger(ep, vp, newSize) == 0) { + mprAssert(0); + } +} + +/******************************************************************************/ + +void ejsClearObjErrors(EjsVar *vp) +{ + if (vp == 0 || vp->type != EJS_TYPE_OBJECT || vp->objectState == 0) { + mprAssert(0); + return; + } + vp->objectState->hasErrors = 0; +} + +/******************************************************************************/ + +int ejsObjHasErrors(EjsVar *vp) +{ + if (vp == 0 || vp->type != EJS_TYPE_OBJECT || vp->objectState == 0) { + mprAssert(0); + return -1; + } + return vp->objectState->hasErrors; +} + +/******************************************************************************/ + +bool ejsIsObjDirty(EjsVar *vp) +{ + mprAssert(vp->type == EJS_TYPE_OBJECT && vp->objectState); + + if (vp->type == EJS_TYPE_OBJECT && vp->objectState) { + return vp->objectState->dirty; + } + return 0; +} + +/******************************************************************************/ + +void ejsResetObjDirtyBit(EjsVar *vp) +{ + mprAssert(vp->type == EJS_TYPE_OBJECT && vp->objectState); + + if (vp->type == EJS_TYPE_OBJECT && vp->objectState) { + vp->objectState->dirty = 0; + } +} + +/******************************************************************************/ +/* + * Copy a string. Always null terminate. + */ + +static int dupString(MPR_LOC_DEC(ctx, loc), uchar **dest, const void *src, + int nbytes) +{ + mprAssert(dest); + mprAssert(src); + + if (nbytes > 0) { + *dest = mprMemdupInternal(MPR_LOC_PASS(ctx, loc), src, nbytes + 1); + if (*dest == 0) { + return MPR_ERR_MEMORY; + } + + } else { + *dest = (uchar*) mprAlloc(ctx, 1); + nbytes = 0; + } + + (*dest)[nbytes] = '\0'; + + return nbytes; +} + +/******************************************************************************/ + +const char *ejsGetVarTypeAsString(EjsVar *vp) +{ + switch (vp->type) { + default: + case EJS_TYPE_UNDEFINED: + return "undefined"; + case EJS_TYPE_NULL: + return "null"; + case EJS_TYPE_BOOL: + return "bool"; + case EJS_TYPE_CMETHOD: + return "cmethod"; + case EJS_TYPE_FLOAT: + return "float"; + case EJS_TYPE_INT: + return "int"; + case EJS_TYPE_INT64: + return "int64"; + case EJS_TYPE_OBJECT: + return "object"; + case EJS_TYPE_METHOD: + return "method"; + case EJS_TYPE_STRING: + return "string"; + case EJS_TYPE_STRING_CMETHOD: + return "string method"; + case EJS_TYPE_PTR: + return "ptr"; + } +} + +/******************************************************************************/ + +void *ejsGetVarUserPtr(EjsVar *vp) +{ + mprAssert(vp); + mprAssert(vp->type == EJS_TYPE_PTR); + + if (!ejsVarIsPtr(vp)) { + return 0; + } + return vp->ptr.userPtr; +} + +/******************************************************************************/ + +void ejsSetVarUserPtr(EjsVar *vp, void *data) +{ + mprAssert(vp); + mprAssert(vp->type == EJS_TYPE_PTR); + + vp->ptr.userPtr = data; +} + +/******************************************************************************/ +/* + * Return TRUE if target is a subclass (or the same class) as baseClass. + */ + +bool ejsIsSubClass(EjsVar *target, EjsVar *baseClass) +{ + do { + if (target->objectState == baseClass->objectState) { + return 1; + } + target = target->objectState->baseClass; + } while (target); + + return 0; +} + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/ejsVar.h b/source4/lib/appweb/ejs-2.0/ejs/ejsVar.h new file mode 100644 index 0000000000..071665e00b --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/ejsVar.h @@ -0,0 +1,1091 @@ +/* + * ejsVar.h -- EJS Universal Variable Type + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/* + * 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 methods. + * Properties are indexed by a character name. A variable may store one of + * the following types: + * + * string, integer, integer-64bit, C method, C method with string args, + * Javascript method, 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_EJS_VAR +#define _h_EJS_VAR 1 + +/********************************* Includes ***********************************/ + +#include "mpr.h" + +/********************************** Defines ***********************************/ +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Defined in ejs.h + */ +typedef struct Ejs Ejs; + +/* + * Constants + */ +#if BLD_FEATURE_SQUEEZE + /** + * Maximum property or variable name size + */ + #define EJS_MAX_ID 64 + + /* + * EJS_VAR_HASH_SIZE must be less than the size of the bit field + * propertyIndex in EjsProperty. + */ + #define EJS_OBJ_HASH_SIZE 13 + + /** + * Maximum number of arguments per function call + */ + #define EJS_MAX_ARGS 32 + #define EJS_INC_ARGS 8 /* Frame stack increment */ + +#else + #define EJS_MAX_ID 256 + #define EJS_OBJ_HASH_SIZE 29 + #define EJS_MAX_ARGS 64 + #define EJS_INC_ARGS 8 +#endif + +#define EJS_VAR_MAX_RECURSE 5 /* Max object loops */ + +#if !DOXYGEN +/* + * Forward declare types + */ +struct Ejs; +struct EjsObj; +struct EjsProperty; +struct EjsVar; +#endif + +/** + * @overview EJ primitive variable type + * @description EJ primitive variable values are stored in EjsVar structures. + * The type of the primitive data is described by an EjsType field. + * EjsVar variable types. + * @stability Prototype. + * @library libejs. + * @see EJS_TYPE_UNDEFINED, EJS_TYPE_NULL, EJS_TYPE_BOOL, EJS_TYPE_CMETHOD, + * EJS_TYPE_FLOAT, EJS_TYPE_INT, EJS_TYPE_INT64, EJS_TYPE_OBJECT, + * EJS_TYPE_METHOD, EJS_TYPE_STRING, EJS_TYPE_STRING_CMETHOD, EJS_TYPE_PTR, + */ +typedef uint EjsType; +#define EJS_TYPE_UNDEFINED 0 /**< Undefined. No value has been set */ +#define EJS_TYPE_NULL 1 /**< Value defined to be null. */ +#define EJS_TYPE_BOOL 2 /**< Boolean type. */ +#define EJS_TYPE_CMETHOD 3 /**< C method */ +#define EJS_TYPE_FLOAT 4 /**< Floating point number */ +#define EJS_TYPE_INT 5 /**< Integer number */ +#define EJS_TYPE_INT64 6 /**< 64-bit Integer number */ +#define EJS_TYPE_OBJECT 7 /**< Object reference */ +#define EJS_TYPE_METHOD 8 /**< JavaScript method */ +#define EJS_TYPE_STRING 9 /**< String (immutable) */ +#define EJS_TYPE_STRING_CMETHOD 10 /**< C method with string args */ +#define EJS_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=EJS_TYPE_INT + */ + +/** + * Set to the type used for EJS numeric variables. Will equate to int, int64 + * or double. + */ +typedef BLD_FEATURE_NUM_TYPE EjsNum; + +/** + * Set to the EJS_TYPE used for EJS numeric variables. Will equate to + * EJS_TYPE_INT, EJS_TYPE_INT64 or EJS_TYPE_FLOAT. + */ +#define EJS_NUM_VAR BLD_FEATURE_NUM_TYPE_ID +#define EJS_TYPE_NUM BLD_FEATURE_NUM_TYPE_ID + +/* + * Return TRUE if a variable is a method type + */ +#define ejsVarIsMethod(vp) \ + ((vp)->type == EJS_TYPE_METHOD || (vp)->type == EJS_TYPE_STRING_CMETHOD || \ + (vp)->type == EJS_TYPE_CMETHOD) + +/* + * Return TRUE if a variable is a numeric type + */ +#define ejsVarIsNumber(vp) \ + ((vp)->type == EJS_TYPE_INT || (vp)->type == EJS_TYPE_INT64 || \ + (vp)->type == EJS_TYPE_FLOAT) + +/* + * Return TRUE if a variable is a boolean + */ +#define ejsVarIsBoolean(vp) \ + ((vp)->type == EJS_TYPE_BOOL) + +/* + * Return TRUE if a variable is an integer type + */ +#define ejsVarIsInteger(vp) ((vp)->type == EJS_TYPE_INT) + +/* + * Return TRUE if a variable is a string + */ +#define ejsVarIsString(vp) \ + ((vp)->type == EJS_TYPE_STRING) + +/* + * Return TRUE if a variable is an object + */ +#define ejsVarIsObject(vp) \ + ((vp)->type == EJS_TYPE_OBJECT) + +/* + * Return TRUE if a variable is a floating number + */ +#define ejsVarIsFloating(vp) \ + ((vp)->type == EJS_TYPE_FLOAT) + +/* + * Return TRUE if a variable is undefined + */ +#define ejsVarIsUndefined(var) \ + ((var)->type == EJS_TYPE_UNDEFINED) + +/* + * Return TRUE if a variable is null + */ +#define ejsVarIsNull(var) \ + ((var)->type == EJS_TYPE_NULL) + +/* + * Return TRUE if a variable is a valid type (not null or undefined) + */ +#define ejsVarIsValid(var) \ + (((var)->type != EJS_TYPE_NULL) && ((var)->type != EJS_TYPE_UNDEFINED)) + +/* + * Return TRUE if a variable is a ptr type + */ +#define ejsVarIsPtr(vp) \ + ((vp)->type == EJS_TYPE_PTR) + +/* MOB -- convert all ep to ejs */ +/** + * @overview C Method signature + * @description This is the calling signature for C Methods. + * @param ejs Ejs reference returned from ejsCreateInterp + * @param thisObj Reference to the "this" object. (The object containing the + * method). + * @param argc Number of arguments. + * @param argv Array of arguments. Each argument is held in an EjsVar type. + * @stability Prototype. + * @library libejs. + * @see ejsCreateCMethodVar + */ +typedef int (*EjsCMethod)(struct Ejs *ejs, struct EjsVar *thisObj, + int argc, struct EjsVar **argv); + +/** + * C Method with string arguments signature + * @overview C Method with string arguments signature + * @description This is the calling signature for C Methods. + * @param ejs Ejs reference returned from ejsCreateInterp + * @param thisObj Reference to the "this" object (object containing the + * method. + * @param argc Number of arguments. + * @param argv Array of arguments. Each argument is held in an C string + * pointer. + * @stability Prototype. + * @library libejs. + * @see ejsCreateStringCMethodVar + */ +typedef int (*EjsStringCMethod)(struct Ejs *ep, struct EjsVar *thisObj, + int argc, char **argv); + +/** + * Flags for types: EJS_TYPE_CMETHOD, EJS_TYPE_STRING_CMETHOD + * NOTE: flags == 0 means to use the EJS handle on method callbacks + */ +/* Use the primary handle on method callbacks */ +#define EJS_PRIMARY_HANDLE 0x1 + +/* Use the alternate handle on method callbacks */ +#define EJS_ALT_HANDLE 0x2 + +/** Method should not create a new local variable block */ +#define EJS_NO_LOCAL 0x4 + +/* Method is a get accessor */ +#define EJS_GET_ACCESSOR 0x8 + +/* Method is a set accessor */ +#define EJS_SET_ACCESSOR 0x10 + +/* + * Flags for E4X (Xml type) + */ +/* Node is a text node */ +#define EJS_XML_FLAGS_TEXT 0x1 + +/* Node is a processing instruction */ +#define EJS_XML_FLAGS_PI 0x2 + +/* Node is a comment */ +#define EJS_XML_FLAGS_COMMENT 0x4 + +/* Node is an attribute */ +#define EJS_XML_FLAGS_ATTRIBUTE 0x8 + +/* Node is an element */ +#define EJS_XML_FLAGS_ELEMENT 0x10 + +/** + * Copy depth + * @overview Specifies how an object should be copied + * @description The EjsCopyDepth type specifies how an object's properties + * should be copied. Several routines take EjsCopyDepth parameters to + * control how the properties of an object should be copied. It provides + * three copy options: + * @see ejsWriteVar + */ +typedef enum EjsCopyDepth { + /** + * During an object copy, object property references will be copied so + * that the original object and the copy will share the same reference to + * a property object. Properties containing primitive types including + * strings will have their values copied and will not share references. + */ + EJS_SHALLOW_COPY, /** Copy strings. Copy object references. */ + /* + * During an object copy, object properties will be replicated so that + * the original object and the copy will not share references to the same + * object properties. If the original object's properties are themselves + * objects, their properties will not be copied. Only their references + * will be copied. i.e. the deep copy is one level deep. + */ + EJS_DEEP_COPY, /** Copy strings and copy object contents. */ + /* + * During an object copy, all object properties will be replicated so that + * the original object and the copy will not share references to the same + * object properties. If the original object's properties are themselves + * objects, their properties will be copied. i.e. the copy is of infinite + * depth. + */ + EJS_RECURSIVE_DEEP_COPY /** Copy strings and copy object contents + recursively (complete copy). */ +} EjsCopyDepth; + + +/* + * Enumeration flags + */ +/** Enumerate data properties */ +#define EJS_ENUM_DATA 0x0 + +/** Enumerate sub classes */ +#define EJS_ENUM_CLASSES 0x1 + +/** Enumerate non-enumerable properties */ +#define EJS_ENUM_HIDDEN 0x2 + +/** Enumerate all properties */ +#define EJS_ENUM_ALL (0x3) + +/** Magic number when allocated */ +#define EJS_MAGIC 0xe801e2ec +#define EJS_MAGIC_FREE 0xe701e3ea + + +/* + * Garbage Collection Linkage. Free list only uses the next pointers. + */ +typedef struct EjsGCLink { +#if BLD_DEBUG + uint magic; /* Magic number */ +#endif +#if BLD_FEATURE_ALLOC_LEAK_TRACK + const char *allocatedBy; /* Who allocated this */ +#endif + struct EjsGCLink *next; /* Next property */ +} EjsGCLink; + + +/** + * @overview EJS Variable Type + * @description The EJ language supports an extensive set of primitive types. + * These variable types can efficiently store primitive data types such as + * integers, strings, binary string, booleans, floating point numbers, + * pointer references, and objects. EjsVars are the universal type used by + * EJ to hold objects, classes and properties. + * \n\n + * An EjsVar may store one of the following types: + * @li Boolean + * @li Floating point (if supported in this build) + * @li Integer + * @li 64 bit integer (if supported in this build) + * @li String + * @li Binary string + * @li C function or C++ method + * @li C function with string args + * @li Javascript method + * @li Object + * @li Null value. + * @li Undefined value + * \n\n + * Objects can hold object properties which are themselves EJS variables. + * Properties are hash indexed by the property name and are stored in + * an ordered sequence. i.e. Order of properties is maintained. Objects may + * be referenced by multiple variables and they use garbage collection to + * reclaim memory no longer in use by objects and properties. + * + * @warning This module is @e 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 should + * help minimize required lock times. + * @stability Prototype. + * @library libejs + * @see Ejs, EjsProperty, ejsCreateStringVar, ejsFreeVar + */ + +typedef struct EjsVar { /* Size 12 bytes */ + /* + * GC must be first + */ +#if BLD_DEBUG || BLD_FEATURE_ALLOC_LEAK_TRACK + EjsGCLink gc; /* Garbage collection links */ +#endif + +#if BLD_DEBUG + const char *propertyName; /* Ptr to property name */ +#endif + + /* + * Union of primitive types. When debugging on Linux, don't use unions + * as the gdb debugger can't display them. + */ +#if (!BLD_DEBUG && !VXWORKS) || WIN || BREW_SIMULATOR + union { +#endif + /* + * For debugging, we order the common types first + */ + struct EjsObj *objectState; /* Object state information */ + int integer; + bool boolean; + +#if BLD_FEATURE_FLOATING_POINT + double floating; +#endif +#if BLD_FEATURE_INT64 + int64 integer64; +#endif + + struct { + int length; /* String length (sans null) */ + /* + * All strings always have a trailing null allocated + */ + union { + char *string; /* String */ + uchar *ustring; /* Binary string */ + }; + }; + + struct { /* Javascript methods */ + MprArray *args; /* Null terminated */ + char *body; + } method; + + struct { /* Method with EjsVar args */ + EjsCMethod fn; /* Method pointer */ + void *userData; /* User data for method */ + } cMethod; + + struct { /* Method with string args */ + EjsStringCMethod fn; /* Method pointer */ + void *userData; /* User data for method */ + } cMethodWithStrings; + + struct { + void *userPtr; /* Opaque pointer */ + int (*destructor)(Ejs *ejs, struct EjsVar *vp); + } ptr; + +#if (!BLD_DEBUG && !VXWORKS) || WIN || BREW_SIMULATOR + }; +#endif + + /* + * Packed bit field (32 bits) + */ + uint flags : 8; /* Type specific flags */ + EjsType type : 4; /* Selector into union */ + uint stringLen : 4; /* Length of string if inline */ + uint allocatedData : 1; /* Node needs freeing */ + uint isArray : 1; /* Var is an array */ + uint isArrayLength : 1; /* Var is array.length */ + uint callsSuper : 1; /* Method calls super() */ + uint isProperty : 1; /* Part of a property */ + uint reserved : 11; /* Unused */ + +} EjsVar; + + +/* + * Linkage for the ordered list of properties + */ +typedef struct EjsPropLink { + struct EjsPropLink *next; /* Next property */ + struct EjsPropLink *prev; /* Previous property */ + + /* + * To make debugging easier + */ +#if BLD_DEBUG + const char *propertyName; /* Pointer to name */ + struct EjsProperty *property; /* Pointer to property */ + struct EjsPropLink *head; /* Dummy head of list */ +#endif +} EjsPropLink; + + +/** + * @overview Object Property Type + * @description The EjsProperty type is used to store all object properties. + * It contains the property name, property linkage, propery attributes + * such as public/private, enumerable and readonly settings. It also + * contains an EjsVar to store the property data value. + * @stability Prototype. + * @library libejs + * @see Ejs, EjsVar + */ +typedef struct EjsProperty { /* Size 96 bytes in squeeze */ + /* + * EjsVar must be first. We often take the address of "var" and take + * advantage of if an EjsProperty is null, then &prop->var will be null + * also. Be WARNED. External users should use ejsGetVarPtr and + * ejsGetPropertyPtr to convert between the two. + */ + EjsVar var; /* Property value */ + + /* OPT change this to a pointer to the base class property */ + char name[EJS_MAX_ID]; /* Name */ + + uint visited : 1; /* Has been traversed */ + uint isPrivate : 1; /* Property is private */ + uint isProtected : 1; /* Property is protected */ + uint dontEnumerate : 1; /* Not enumerable */ + uint dontDelete : 1; /* Prevent delete */ + uint readonly : 1; /* Unmodifiable */ + uint allowNonUnique : 1; /* Multiple of same name ok */ + uint delayedDelete : 1; + uint reserved : 24; + + EjsPropLink link; /* Ordered linked list */ + struct EjsProperty *hashNext; /* Hash table linkage */ + + /* MOB -- is this really required */ + struct EjsObj *parentObj; /* Pointer to parent object */ + +} EjsProperty; + + +#define EJS_OP_DOT 0x1 +#define EJS_OP_INDEX 0x2 +#define EJS_OP_PLUS 0x3 +#define EJS_OP_MINUS 0x4 +#define EJS_OP_MULTIPLY 0x5 +#define EJS_OP_DIVIDE 0x6 +#define EJS_OP_CALL 0x7 + +typedef struct EjsOp { + int opType; + +} EjsOp; + +/* + * Propety Access Methods. Used per class. + * MOB -- rename EjsHelpers + */ +typedef struct EjsMethods { +#if FUTURE + int (*create)(Ejs *ep, EjsVar *thisObj); + int (*deleteProperty)(Ejs *ep, EjsVar *thisObj, const char *prop); + EjsVar *(*getProperty)(Ejs *ep, EjsVar *thisObj, const char *prop); + EjsVar *(*setProperty)(Ejs *ep, EjsVar *thisObj, const char *prop); + int (*hasProperty)(Ejs *ep, EjsVar *thisObj, const char *prop); + int (*hasInstance)(Ejs *ep, EjsVar *thisObj, const char *prop); + int (*operate)(Ejs *ep, EjsVar *thisObj, EjsOp op, EjsVar *result, + EjsVar *lhs, EjsVar *rhs, int *code); +#else + + EjsVar *(*createProperty)(Ejs *ep, EjsVar *obj, const char *property); + int (*deleteProperty)(Ejs *ep, EjsVar *obj, const char *property); + EjsVar *(*getProperty)(Ejs *ep, EjsVar *obj, const char *property); + EjsVar *(*setProperty)(Ejs *ep, EjsVar *obj, const char *property, + const EjsVar *value); + /* + * Other implemented internal properties in ECMA-262 are: + * + * [[Construct]] implemented via EjsVar methods + * [[Prototype]] implemented via EjsObj->baseClass + * [[Class]] implemented via EjsObj->baseClass->name + * [[Value]] Implemented via EjsProperty + EjsVar + EjsObj + */ + + /* + * FUTURE -- not implemented + */ + int (*canPut)(Ejs *ep, EjsVar *obj, const char *property); + int (*defaultValue)(Ejs *ep, EjsVar *obj, const char *property, + const char *hint); + int (*hasProperty)(Ejs *ep, EjsVar *obj, const char *property); + EjsVar *(*call)(Ejs *ep, EjsVar *obj, const char *property, + EjsVar *args); + int (*hasInstance)(Ejs *ep, EjsVar *obj, const char *property); + int (*scope)(Ejs *ep, EjsVar *obj, const char *property); + int (*match)(Ejs *ep, EjsVar *obj, const char *property, + const char *string, int index); +#endif +} EjsMethods; + + +/* + * Ejs Object Type + */ +typedef struct EjsObj { + /* + * GC must be first + */ + EjsGCLink gc; /* Garbage collection links */ + + union { + char *objName; /* Object name */ + char *className; /* Class name */ + }; + + struct EjsVar *baseClass; /* Pointer to base class object */ + + EjsPropLink link; /* Ordered list of properties */ + + /* OPT -- dynamically allocate this only if required */ + EjsProperty *propertyHash[EJS_OBJ_HASH_SIZE]; /* Hash chains */ + + /* OPT -- could save this and store off baseClass only */ + EjsMethods *methods; /* Property access methods */ + void *nativeData; /* Native object data */ + + int (*destructor)(Ejs *ejs, struct EjsVar *vp); + + uint numProperties : 16; /* Total count of items */ + uint visited : 1; /* Has been traversed */ + uint gcMarked : 1; /* Node marked in-use by GC */ + uint permanent : 1; /* Permanent object, dont GC */ + uint alive : 1; /* Only GC if alive */ + uint noConstructor : 1; /* Object has no constructor */ + uint dirty : 1; /* Object has been modified */ + uint hasErrors : 1; /* Update error */ + uint preventDeleteProp : 1; /* Don't allow prop deletion */ + uint delayedDeleteProp : 1; /* Delayed delete of props */ + uint reserved : 7; /* Unused */ + + Ejs *ejs; /* Owning interp */ + +#if BLD_FEATURE_MULTITHREAD + MprLock *mutex; /* Advisory mutex lock */ +#endif +} EjsObj; + + +/* + * Define a field macro so code an use numbers in a "generic" fashion. + */ +#if EJS_NUM_VAR == EJS_TYPE_INT || DOXYGEN +/* + * Default numeric type + */ +#define ejsNumber integer +#endif +#if EJS_NUM_VAR == EJS_TYPE_INT64 +/* Default numeric type */ +#define ejsNumber integer64 +#endif +#if EJS_NUM_VAR == EJS_TYPE_FLOAT +/* Default numeric type */ +#define ejsNumber floating +#endif + +typedef BLD_FEATURE_NUM_TYPE EjsNumber; + +/* + * Memory allocation slabs + */ +#define EJS_SLAB_OBJ 0 +#define EJS_SLAB_PROPERTY 1 +#define EJS_SLAB_VAR 2 +#define EJS_SLAB_MAX 3 + +/** + * Object and pointer property destructory type + */ +typedef int (*EjsDestructor)(Ejs *ejs, EjsVar *vp); + +#if BLD_FEATURE_ALLOC_LEAK_TRACK || DOXYGEN +/* + * Line number information args and declarations for ejsAlloc. + * Use EJS_LOC_ARGS in normal user code. + * Use EJS_LOC_DEC in declarations. + * Use EJS_LOC_PASS in layered APIs to pass original line info down. + */ +#define EJS_LOC_ARGS(ejs) ejs, MPR_LOC +#define EJS_LOC_DEC(ejs, loc) Ejs *ejs, const char *loc +#define EJS_LOC_PASS(ejs, loc) ejs, loc +#else +#define EJS_LOC_ARGS(ejs) ejs +#define EJS_LOC_DEC(ejs, loc) Ejs *ejs +#define EJS_LOC_PASS(ejs, loc) ejs +#endif + +/******************************* Internal Prototypes **************************/ + +#define ejsInitVar(vp, varType) \ + if (1) { \ + (vp)->type = varType; \ + (vp)->isArray = 0; \ + (vp)->flags = 0; \ + } else +extern void ejsClearVar(Ejs *ep, EjsVar *vp); + +extern int ejsDestroyObj(Ejs *ep, EjsObj *obj); +extern EjsVar *ejsCreatePropertyMethod(Ejs *ep, EjsVar *obj, + const char *name); +extern EjsVar *ejsSetPropertyMethod(Ejs *ep, EjsVar *obj, const char *name, + const EjsVar *value); +extern EjsVar *ejsGetPropertyMethod(Ejs *ep, EjsVar *obj, const char *name); +extern int ejsDeletePropertyMethod(Ejs *ep, EjsVar *obj, + const char *name); +extern void ejsSetArrayLength(Ejs *ep, EjsVar *obj, const char *creating, + const char *deleting, const EjsVar *setLength); + +/* + * At the moment, these are the same routine + */ +extern void ejsSetClassName(Ejs *ep, EjsVar *obj, const char *name); +#define ejsSetObjName ejsSetObjName + +extern bool ejsIsObjDirty(EjsVar *vp); +extern void ejsResetObjDirtyBit(EjsVar *vp); + +extern int ejsObjHasErrors(EjsVar *vp); +extern void ejsClearObjErrors(EjsVar *vp); + +extern EjsVar *ejsClearProperty(Ejs *ep, EjsVar *obj, const char *prop); + +typedef int (*EjsSortFn)(Ejs *ep, EjsProperty *p1, EjsProperty *p2, + const char *propertyName, int order); +extern void ejsSortProperties(Ejs *ep, EjsVar *obj, EjsSortFn fn, + const char *propertyName, int order); + +#if BLD_DEBUG +#define ejsSetVarName(ep, vp, varName) \ + if (1) { \ + (vp)->propertyName = varName; \ + if ((vp)->type == EJS_TYPE_OBJECT && \ + (vp)->objectState && \ + ((vp)->objectState->objName == 0)) { \ + (vp)->objectState->objName = \ + mprStrdup(ep, varName); \ + } \ + } else +#else +#define ejsSetVarName(ep, vp, varName) +#endif + +EjsVar *ejsFindProperty(Ejs *ep, EjsVar **obj, char **property, + EjsVar *global, EjsVar *local, const char *fullName, + int create); + +extern EjsVar *ejsCopyProperties(Ejs *ep, EjsVar *dest, + const EjsVar *src, EjsCopyDepth copyDepth); + +#define EJS_LINK_OFFSET ((uint) (&((EjsProperty*) 0)->link)) +#define ejsGetPropertyFromLink(lp) \ + ((EjsProperty*) ((char*) lp - EJS_LINK_OFFSET)) + +#define ejsGetObjPtr(vp) ((EjsObj*) vp->objectState) + +extern void ejsMakePropertyPrivate(EjsProperty *pp, int isPrivate); +extern void ejsMakePropertyReadOnly(EjsProperty *pp, int readonly); +extern void ejsMakePropertyUndeleteable(EjsProperty *pp, int deletable); +extern int ejsMakeObjLive(EjsVar *vp, bool alive); +extern void ejsMakeClassNoConstructor(EjsVar *vp); + +extern bool ejsBlockInUseInt(EjsVar *vp); +#if BLD_DEBUG + #define ejsBlockInUse(vp) ejsBlockInUseInt(vp) +#else + #define ejsBlockInUse(vp) +#endif + +/********************************* Prototypes *********************************/ + +/* + * Variable constructors and destructors + */ +extern EjsVar *ejsCreateBinaryStringVar(Ejs *ep, const uchar *value, + int len); +extern EjsVar *ejsCreateBoolVar(Ejs *ep, int value); +extern EjsVar *ejsCreateCMethodVar(Ejs *ep, EjsCMethod fn, + void *userData, int flags); +#if BLD_FEATURE_FLOATING_POINT +extern EjsVar *ejsCreateFloatVar(Ejs *ep, double value); +#endif +extern EjsVar *ejsCreateIntegerVar(Ejs *ep, int value); +#if BLD_FEATURE_INT64 +extern EjsVar *ejsCreateInteger64Var(Ejs *ep, int64 value); +#endif + +extern EjsVar *ejsCreateMethodVar(Ejs *ep, const char *body, + MprArray *args, int flags); +extern EjsVar *ejsCreateNullVar(Ejs *ep); +extern EjsVar *ejsCreateNumberVar(Ejs *ep, EjsNumber value); + +#define ejsCreateObjVar(ep) \ + ejsCreateObjVarInternal(EJS_LOC_ARGS(ep)) +extern EjsVar *ejsCreateObjVarInternal(EJS_LOC_DEC(ep, loc)); + +extern EjsVar *ejsCreatePtrVar(Ejs *ep, void *ptr, EjsDestructor dest); + +extern EjsVar *ejsCreateStringCMethodVar(Ejs *ep, EjsStringCMethod fn, + void *userData, int flags); + +#define ejsCreateStringVar(ep, value) \ + ejsCreateStringVarInternal(EJS_LOC_ARGS(ep), value) +extern EjsVar *ejsCreateStringVarInternal(EJS_LOC_DEC(ep, loc), + const char *value); + +extern EjsVar *ejsCreateUndefinedVar(Ejs *ep); + +/* MOB -- naming. Should be Create/Destroy */ +extern void ejsFreeVar(Ejs *ep, EjsVar *vp); + +/* + * Var support routines + */ +extern int ejsGetVarFlags(EjsVar *vp); +extern void ejsSetVarFlags(EjsVar *obj, int flags); + +extern EjsType ejsGetVarType(EjsVar *vp); +extern const char *ejsGetVarTypeAsString(EjsVar *vp); + +extern void *ejsGetCMethodUserData(EjsVar *obj); +extern void ejsSetCMethodUserData(EjsVar *obj, void *userData); + +extern void *ejsGetVarUserPtr(EjsVar *vp); +extern void ejsSetVarUserPtr(EjsVar *vp, void *data); + + +/* + * Variable access and manipulation. These work on standalone objects. + */ +#define ejsDupVar(ep, src, copyDepth) \ + ejsDupVarInternal(EJS_LOC_ARGS(ep), src, copyDepth) +extern EjsVar *ejsDupVarInternal(EJS_LOC_DEC(ep, loc), EjsVar *src, + EjsCopyDepth copyDepth); +#define ejsWriteVar(ep, dest, src, copyDepth) \ + ejsWriteVarInternal(EJS_LOC_ARGS(ep), dest, src, copyDepth) +extern EjsVar *ejsWriteVarInternal(EJS_LOC_DEC(ep, loc), EjsVar *dest, + const EjsVar *src, EjsCopyDepth copyDepth); +extern EjsVar *ejsWriteVarAsBinaryString(Ejs *ep, EjsVar *dest, + const uchar *value, int len); +extern EjsVar *ejsWriteVarAsBoolean(Ejs *ep, EjsVar *dest, bool value); +extern EjsVar *ejsWriteVarAsCMethod(Ejs *ep, EjsVar *dest, EjsCMethod fn, + void *userData, int flags); +#if BLD_FEATURE_FLOATING_POINT +extern EjsVar *ejsWriteVarAsFloat(Ejs *ep, EjsVar *dest, double value); +#endif +extern EjsVar *ejsWriteVarAsInteger(Ejs *ep, EjsVar *dest, int value); +#if BLD_FEATURE_INT64 +extern EjsVar *ejsWriteVarAsInteger64(Ejs *ep, EjsVar *dest, int64 value); +#endif +extern EjsVar *ejsWriteVarAsMethod(Ejs *ep, EjsVar *dest, + const char *body, MprArray *args); +extern EjsVar *ejsWriteVarAsNull(Ejs *ep, EjsVar *dest); +extern EjsVar *ejsWriteVarAsNumber(Ejs *ep, EjsVar *dest, EjsNum value); +#define ejsWriteVarAsString(ep, dest, value) \ + ejsWriteVarAsStringInternal(EJS_LOC_ARGS(ep), dest, value) +extern EjsVar *ejsWriteVarAsStringInternal(EJS_LOC_DEC(ep, loc), + EjsVar *dest, const char *value); +extern EjsVar *ejsWriteVarAsStringCMethod(Ejs *ep, EjsVar *dest, + EjsStringCMethod fn, void *userData, int flags); +extern EjsVar *ejsWriteVarAsUndefined(Ejs *ep, EjsVar *dest); + +/* + * These routines do not convert types + */ +/* MOB -- make this a fn and pass back the length as an arg */ +#define ejsReadVarAsBinaryString(vp) ((const uchar*) (vp->ustring)); +#define ejsReadVarAsBoolean(vp) (vp->boolean); +#define ejsReadVarAsCMethod(vp) (vp->cMethod); +#if BLD_FEATURE_FLOATING_POINT +#define ejsReadVarAsFloat(vp) (vp->floating); +#endif +#define ejsReadVarAsInteger(vp) (vp->integer); +#if BLD_FEATURE_INT64 +#define ejsReadVarAsInteger64(vp) (vp->int64); +#endif +#define ejsReadVarAsString(vp) ((const char*) (vp->string)); +#define ejsReadVarAsStringCMethod(vp) (vp->cMethodWithStrings); +/* MOB -- remove this fn */ +#define ejsReadVarStringLength(vp) (vp->length); + +/* + * Object property creation routines + */ +extern EjsProperty *ejsCreateProperty(Ejs *ep, EjsVar *obj, const char *prop); +extern EjsProperty *ejsCreateSimpleProperty(Ejs *ep, EjsVar *obj, + const char *prop); +extern EjsProperty *ejsCreateSimpleNonUniqueProperty(Ejs *ep, EjsVar *obj, + const char *prop); +/* MOB -- should be destroy */ +extern int ejsDeleteProperty(Ejs *ep, EjsVar *obj, const char *prop); + + +/* + * Get property routines + */ +extern EjsProperty *ejsGetProperty(Ejs *ep, EjsVar *obj, const char *prop); +extern EjsProperty *ejsGetSimpleProperty(Ejs *ep, EjsVar *obj, + const char *prop); + +extern EjsVar *ejsGetPropertyAsVar(Ejs *ep, EjsVar *obj, + const char *prop); +extern int ejsGetPropertyCount(EjsVar *obj); + +extern const uchar *ejsGetPropertyAsBinaryString(Ejs *ep, EjsVar *obj, + const char *prop, int *length); +extern bool ejsGetPropertyAsBoolean(Ejs *ep, EjsVar *obj, + const char *prop); +extern int ejsGetPropertyAsInteger(Ejs *ep, EjsVar *obj, + const char *prop); +extern int64 ejsGetPropertyAsInteger64(Ejs *ep, EjsVar *obj, + const char *prop); +extern EjsNum ejsGetPropertyAsNumber(Ejs *ep, EjsVar *obj, + const char *prop); +extern void *ejsGetPropertyAsPtr(Ejs *ep, EjsVar *obj, + const char *prop); +extern const char *ejsGetPropertyAsString(Ejs *ep, EjsVar *obj, + const char *prop); + +/* + * Object property update routines + */ +extern EjsProperty *ejsSetBaseProperty(Ejs *ep, EjsVar *obj, const char *prop, + const EjsVar *value); +extern EjsProperty *ejsSetProperty(Ejs *ep, EjsVar *obj, const char *prop, + const EjsVar *value); +extern EjsProperty *ejsSetPropertyAndFree(Ejs *ep, EjsVar *obj, + const char *prop, EjsVar *value); +extern EjsProperty *ejsSetPropertyToBinaryString(Ejs *ep, EjsVar *obj, + const char *prop, const uchar *value, int len); +extern EjsProperty *ejsSetPropertyToBoolean(Ejs *ep, EjsVar *obj, + const char *prop, bool value); +extern EjsProperty *ejsSetPropertyToCMethod(Ejs *ep, EjsVar *obj, + const char *prop, EjsCMethod fn, void *userData, + int flags); +#if BLD_FEATURE_FLOATING_POINT +extern EjsProperty *ejsSetPropertyToFloat(Ejs *ep, EjsVar *obj, + const char *prop, double value); +#endif +extern EjsProperty *ejsSetPropertyToInteger(Ejs *ep, EjsVar *obj, + const char *prop, int value); +#if BLD_FEATURE_INT64 +extern EjsProperty *ejsSetPropertyToInteger64(Ejs *ep, EjsVar *obj, + const char *prop, int64 value); +#endif +extern EjsProperty *ejsSetPropertyToMethod(Ejs *ep, EjsVar *obj, + const char *prop, const char *body, MprArray *args, + int flags); +extern EjsProperty *ejsSetPropertyToNewObj(Ejs *ep, EjsVar *obj, + const char *prop, const char *className, + MprArray *args); +extern EjsProperty *ejsSetPropertyToNull(Ejs *ep, EjsVar *obj, + const char *prop); +extern EjsProperty *ejsSetPropertyToNumber(Ejs *ep, EjsVar *obj, + const char *prop, EjsNum value); +extern EjsProperty *ejsSetPropertyToObj(Ejs *ep, EjsVar *obj, + const char *prop); +extern EjsProperty *ejsSetPropertyToPtr(Ejs *ep, EjsVar *obj, + const char *prop, void *ptr, EjsDestructor destructor); + +extern EjsProperty *ejsSetPropertyToStringCMethod(Ejs *ep, EjsVar *obj, + const char *prop, EjsStringCMethod fn, + void *userData, int flags); +extern EjsProperty *ejsSetPropertyToString(Ejs *ep, EjsVar *obj, + const char *prop, const char *value); +extern EjsProperty *ejsSetPropertyToUndefined(Ejs *ep, EjsVar *obj, + const char *prop); + + +/* Convenience function */ +extern EjsVar *ejsSetPropertyToObjAsVar(Ejs *ep, EjsVar *obj, + const char *prop); +extern void ejsSetObjDestructor(Ejs *ep, EjsVar *obj, + EjsDestructor destructor); +extern void ejsClearObjDestructor(Ejs *ep, EjsVar *obj); + +/* + * Enumeration of properties + * MOB -- should these take an ejs parameter to be consistent + */ +extern EjsProperty *ejsGetFirstProperty(const EjsVar *obj, int flags); +extern EjsProperty *ejsGetNextProperty(EjsProperty *last, int flags); + +/* + * Method definition and control. + */ +extern EjsProperty *ejsDefineMethod(Ejs *ep, EjsVar *obj, const char *prop, + const char *body, MprArray *args); +extern EjsProperty *ejsDefineCMethod(Ejs *ep, EjsVar *obj, const char *prop, + EjsCMethod fn, int flags); + +extern EjsProperty *ejsDefineStringCMethod(Ejs *ep, EjsVar *obj, + const char *prop, EjsStringCMethod fn, int flags); + +extern EjsProperty *ejsDefineAccessors(Ejs *ep, EjsVar *obj, + const char *prop, const char *getBody, + const char *setBody); +extern EjsProperty *ejsDefineCAccessors(Ejs *ep, EjsVar *obj, + const char *prop, EjsCMethod getFn, EjsCMethod setFn, + int flags); + +/* + * Macro to get the variable value portion of a property + */ +#define ejsGetVarPtr(pp) (&((pp)->var)) +#define ejsGetPropertyPtr(vp) ((EjsProperty*) vp) + +/* MOB -- take ejs to be consistent */ +extern int ejsMakePropertyEnumerable(EjsProperty *pp, bool enumerable); +extern int ejsMakeObjPermanent(EjsVar *vp, bool permanent); + + +/* + * Var conversion routines + * MOB -- should these take an Ejs as first arg for consistency + */ +extern bool ejsVarToBoolean(EjsVar *vp); +#if BLD_FEATURE_FLOATING_POINT +extern double ejsVarToFloat(EjsVar *vp); +#endif +extern int ejsVarToInteger(EjsVar *vp); +#if BLD_FEATURE_INT64 +extern int64 ejsVarToInteger64(EjsVar *vp); +#endif +extern EjsNum ejsVarToNumber(EjsVar *vp); +extern char *ejsVarToString(Ejs *ep, EjsVar *vp); +extern char *ejsVarToStringEx(Ejs *ep, EjsVar *vp, bool *alloc); +extern char *ejsFormatVar(Ejs *ep, const char *fmt, EjsVar *vp); + +#if BLD_FEATURE_FLOATING_POINT +extern double ejsParseFloat(const char *str); +#endif +/* + * Parsing and type range checking routines + */ +extern bool ejsParseBoolean(const char *str); +extern int ejsParseInteger(const char *str); +#if BLD_FEATURE_INT64 +extern int64 ejsParseInteger64(const char *str); +#endif +extern EjsNum ejsParseNumber(const char *str); +extern EjsVar *ejsParseVar(Ejs *ep, const char *str, EjsType prefType); + +#if BLD_FEATURE_FLOATING_POINT +extern bool ejsIsInfinite(double f); +extern bool ejsIsNan(double f); +#endif + +/* + * Advisory locking support + */ +#if BLD_FEATURE_MULTITHREAD +extern void ejsLockObj(EjsVar *vp); +extern void ejsUnlockObj(EjsVar *vp); +#endif + +/* + * Just for debugging + */ +extern bool ejsObjIsCollectable(EjsVar *vp); + +#ifdef __cplusplus +} +#endif + +/*****************************************************************************/ +#endif /* _h_EJS_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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/lib/event.js b/source4/lib/appweb/ejs-2.0/ejs/lib/event.js new file mode 100644 index 0000000000..283a3ec72f --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/lib/event.js @@ -0,0 +1,141 @@ +/* + * @file event.js + * @brief Event class + * @copy Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + * + * Usage: + * listener = new System.Listener(); + * listener.onClick = function() { + * // Any code here + * } + * eventTarget.addListener(eventName, listener); + * or + * listener = new System.Listener(obj, method); + * eventTarget.addListener(eventName, listener); + * + * To fire events: + * eventTarget.fire(eventName, new System.Event("My Event")); + */ + +/******************************************************************************/ +/* + * Base event class + */ +class System.Event +{ + var type; // keyboard + var timeStamp; + var arg; + + /* MOB -- constructor should take a type */ + function Event(arg) + { + timeStamp = time(); + type = "default"; + this.arg = arg; + } +} + +/* MOB -- should not be needed */ +Event = System.Event; + +class System.Listener +{ + var obj; + var method; + + function Listener(obj, method) + { + if (arguments.length >= 1) { + this.obj = obj; + } else { + this.obj = this; + } + if (arguments.length == 2) { + this.method = method; + } else { + this.method = "onEvent"; + } + } +} +/* MOB -- should not be needed */ +Listener = System.Listener; + + +/* + * The Event target class + */ +class System.EventTarget +{ + // Private + var events; /* Hash of a event names */ + + function EventTarget() + { + events = new Object(); + } + + // Public + function addListener(eventName, listener) + { + var listeners = events[eventName]; + if (listeners == undefined) { + listeners = events[eventName] = new Array(); + } + if (arguments.length == 2) { + var method = eventName; + } + /* MOB OPT */ + for (var i = 0; i < listeners.length; i++) { + var l = listeners[i]; + if (l == listener) { + return; + } + } + listeners[listeners.length] = listener; + } + + function removeListener(eventName, listener) + { + var listeners = events[eventName]; + + if (listeners == undefined) { + return; + } + + for (var i = 0; i < listeners.length; i++) { + var l = listeners[i]; + if (l == listener) { + // MOB -- want listeners.splice here + // listeners.splice(i, 1); + for (var j = i; j < (listeners.length - 1); j++) { + listeners[j] = listeners[j + 1]; + } + delete listeners[listeners.length - 1]; + i = listeners.length; + } + } + } + + function fire(eventName, event) + { + var listeners = events[eventName]; + + if (listeners == undefined) { + // println("Event.fire(): unknown eventName " + eventName); + return; + } + + for (var i = listeners.length - 1; i >= 0; i--) { + var listener = listeners[i]; + var method = listener.obj[listener.method]; + if (method == undefined) { + throw new EvalError("Undefined method: " + listener.method); + } + listener.obj[listener.method](listener, event); + } + } +} + +/* MOB -- should not be needed */ +EventTarget = System.EventTarget; diff --git a/source4/lib/appweb/ejs-2.0/ejs/lib/global.js b/source4/lib/appweb/ejs-2.0/ejs/lib/global.js new file mode 100644 index 0000000000..f2daaa57c0 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/lib/global.js @@ -0,0 +1,34 @@ +/* + * @file global.js + * @brief Misc global functions + * @copy Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + */ + +/******************************************************************************/ + +function min(a, b) +{ + if (a < b) { + return a; + } else { + return b; + } +} + + +function max(a, b) +{ + if (a > b) { + return a; + } else { + return b; + } +} + +function abs(a) +{ + if (a < 0) { + return -a; + } + return a; +} diff --git a/source4/lib/appweb/ejs-2.0/ejs/lib/startup.js b/source4/lib/appweb/ejs-2.0/ejs/lib/startup.js new file mode 100644 index 0000000000..e627a96e04 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/lib/startup.js @@ -0,0 +1,15 @@ +/* + * @file startup.js + * @brief Embedded JavaScript Startup Code + * @copy Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + * + * Invoked automatically on startup. + */ + +/******************************************************************************/ + +// println("Loading startup.js ..."); + +include("lib/event.js"); +include("lib/global.js"); +include("lib/timer.js"); diff --git a/source4/lib/appweb/ejs-2.0/ejs/lib/timer.js b/source4/lib/appweb/ejs-2.0/ejs/lib/timer.js new file mode 100644 index 0000000000..f4cb8b12ce --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/lib/timer.js @@ -0,0 +1,158 @@ +/* + * @file timer.js + * @brief Timer class + * @copy Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + * + * Usage: + * timer = new System.Timer("name", period); + * timer.onTick = function(arg) { + * // Anything here + * } + * timer.start(); + * or + * + * timer = new System.Timer("name", period, obj, method); + * timer.start(); + */ + +/******************************************************************************/ + +class System.Timer +{ + var id; + + /* MOB -- really need accessor on period. If user updates period, + then due must be updated. */ + var period; + var due; + var runOnce; // Run timer just once + var method; // Callback method + var obj; // Callback object + + function Timer(id, period, obj, method) + { + this.id = id; + this.period = period; + due = time() + period; + + if (arguments.length >= 3) { + this.obj = obj; + } else { + this.obj = this; + } + if (arguments.length >= 4) { + this.method = method; + } else { + this.method = "onTick"; + } + } + + /* MOB this should be deprecated */ + function reschedule(period) + { + /* MOB -- should update the timer service somehow */ + this.period = period; + } + + function run(now) + { + if (obj[method] == undefined) { + trace("Timer cant find timer method " + method); + due = now + this.period; + return; + } + + /* + * Run the timer + */ + try { + obj[method](this); + } + catch (error) { + trace("Timer exception: " + error); + } + + if (runOnce) { + timerService.removeTimer(this); + + } else { + due = now + this.period; + } + } + + function start() + { + if (obj[method] == undefined) { + throw new Error("Callback method is undefined"); + } else { + timerService.addTimer(this); + } + } + + function stop() + { + timerService.removeTimer(this); + } + +} + +/* MOB -- should not need this */ +Timer = System.Timer; + + +/* + * Timer service + */ +class System.TimerService +{ + var timers; + var nextDue; + + function TimerService() + { + timers = new Object(); + nextDue = 0; + global.timerService = this; + } + + function addTimer(timer) + { + timers[timer.id] = timer; + } + + function removeTimer(timer) + { + try { + delete timers[timer.id]; + } + catch {} + } + + function getIdleTime() + { + return nextDue - time(); + } + + function runTimers() + { + var now = time(); + + nextDue = 2147483647; /* MOB -- MATH.MAX_INT; */ + + for each (var timer in timers) + { + if (timer.due < now) { + timer.run(now); + } + } + for each (var timer in timers) + { + if (timer.due < nextDue) { + nextDue = timer.due; + } + } + // println("runTimers leaving with " + (nextDue - now)); + return nextDue - time(); + } +} +TimerService = System.TimerService; diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/.ignore b/source4/lib/appweb/ejs-2.0/ejs/system/.ignore new file mode 100755 index 0000000000..fb5a29031e --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/.ignore @@ -0,0 +1 @@ +.updated diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/Makefile b/source4/lib/appweb/ejs-2.0/ejs/system/Makefile new file mode 100755 index 0000000000..2d83662655 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/Makefile @@ -0,0 +1,27 @@ +# +# Makefile to build the EJS Object Model +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +COMPILE := *.c +EXPORT_OBJECTS := yes +MAKE_IFLAGS := -I.. -I../../mpr -I../../exml + +include make.dep + +ifeq ($(BLD_HOST_UNIX),1) +PRE_DIRS = UNIX +else +PRE_DIRS = $(BLD_HOST_OS) +endif + +compileExtra: .updated + +.updated: $(FILES) + @touch .updated + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/README.TXT b/source4/lib/appweb/ejs-2.0/ejs/system/README.TXT new file mode 100644 index 0000000000..a24e0e299c --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/README.TXT @@ -0,0 +1,63 @@ +Embedded JavaScript System Model + + +- Need args, arg types and exceptions thrown +- Error classes + +class Global + class System + class environment + var + class GC + void function run() + function tune() + function getUsedMemory() // Should be properties + function getAllocatedMemory() // Should be properties + + var javascript + var null + var undefined + var true + var false + var Nan + var Infinity + + function random // Not implemented + function sleep // Not implemented + function exit + function yield // Not implemented + + Debug + isDebugMode + + Limits + isLimitsMode // Not implemented + stack // Not implemented + heap // Not implemented + flash // Not implemented + + Memory + getUsedMemory() // Should be properties + getAvailableMemory() // Should be properties + used + flash // Not implemented + + assert() + breakpoint() + dirname() + basename() + eval() + exit() + print() + println() + printVars() + sleep() + sort() + time() + typeof() + include() + trace() + printf() // Not implemented + sprintf() + + diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/.ignore b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/.ignore new file mode 100644 index 0000000000..fb5a29031e --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/.ignore @@ -0,0 +1 @@ +.updated diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/Makefile b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/Makefile new file mode 100755 index 0000000000..424747052a --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/Makefile @@ -0,0 +1,21 @@ +# +# Makefile to build the EJS Object Model for WIN +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +COMPILE := *.c +EXPORT_OBJECTS := yes +MAKE_IFLAGS := -I../.. -I../../../mpr + +include make.dep + +compileExtra: .updated + +.updated: $(FILES) + @touch .updated + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/ejsFile.c b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/ejsFile.c new file mode 100644 index 0000000000..772303152e --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/ejsFile.c @@ -0,0 +1,98 @@ +/* + * @file ejsFile.c + * @brief File class for the EJ System Object Model + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +/******************************************************************************/ +/* + * Default Constructor + */ + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +/* + * function open(); + */ + +static int openProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "File.open()\n"); + return 0; +} + +/******************************************************************************/ +/* + * function close(); + */ + +static int closeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "File.close()\n"); + return 0; +} + +/******************************************************************************/ +/* + * function read(); + */ + +static int readProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "File.read()\n"); + return 0; +} + +/******************************************************************************/ +/* + * function write(); + */ + +static int writeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "File.write()\n"); + return 0; +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineFileClass(Ejs *ep) +{ + EjsVar *fileClass; + + fileClass = ejsDefineClass(ep, "File", "Object", 0); + if (fileClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define the methods + */ + ejsDefineCMethod(ep, fileClass, "open", openProc, 0); + ejsDefineCMethod(ep, fileClass, "close", closeProc, 0); + ejsDefineCMethod(ep, fileClass, "read", readProc, 0); + ejsDefineCMethod(ep, fileClass, "write", writeProc, 0); + + return ejsObjHasErrors(fileClass) ? MPR_ERR_CANT_INITIALIZE: 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/ejsFileSystem.c b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/ejsFileSystem.c new file mode 100755 index 0000000000..7b39c16e4d --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/ejsFileSystem.c @@ -0,0 +1,454 @@ +/* + * @file ejsFileSystem.c + * @brief FileSystem class for the EJ System Object Model + * MOB -- this is almost the same as for Windows. Should common up. + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" +#include <dirent.h> + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +/* + * function void access(string path); + * MOB - API insufficient. Access for read or write? + */ + +static int accessProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: access(path)"); + return -1; + } + + rc = access(argv[0]->string, 04); + + ejsSetReturnValueToBoolean(ejs, (rc == 0) ? 1 : 0); + return 0; +} + +/******************************************************************************/ +/* + * function void mkdir(string path); + */ + +static int mkdirProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: mkdir(path)"); + return -1; + } + + if (mprMakeDirPath(ejs, argv[0]->string) < 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant create directory"); + return -1; + } + return 0; +} + +/******************************************************************************/ +/* + * function void rmdir(string path); + */ + +static int rmdirProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: mkdir(path)"); + return -1; + } + + rc = mprDeleteDir(ejs, argv[0]->string); + + if (rc < 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant remove directory"); + return -1; + } + return 0; +} + +/******************************************************************************/ +/* + * function void dirList(string path, [bool enumDirs]); + * MOB -- need pattern to match (what about "." and ".." and ".*" + */ + +static int dirListProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + DIR *dir; + struct dirent *dirent; + char path[MPR_MAX_FNAME]; + EjsVar *array, *vp; + uchar enumDirs; + + if (argc < 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: dirList(path)"); + return -1; + } + if (argc == 2) { + enumDirs = ejsVarToBoolean(argv[1]); + } else { + enumDirs = 0; + } + array = ejsCreateArray(ejs, 0); + ejsMakeObjPermanent(array, 1); + + /* + * First collect the files + */ + mprSprintf(path, sizeof(path), "%s/*.*", argv[0]->string); + + dir = opendir(path); + if (dir == 0) { + ejsError(ejs, EJS_ARG_ERROR, "Can't enumerate dirList(path)"); + return -1; + } + + while ((dirent = readdir(dir)) != 0) { + if (dirent->d_name[0] == '.') { + continue; + } + if (!enumDirs || (dirent->d_type & DT_DIR)) { + mprSprintf(path, sizeof(path), "%s/%s", argv[0]->string, + dirent->d_name); + vp = ejsCreateStringVar(ejs, path); + ejsAddArrayElt(ejs, array, vp, EJS_SHALLOW_COPY); + ejsFreeVar(ejs, vp); + } + } + + closedir(dir); + + ejsSetReturnValue(ejs, array); + ejsMakeObjPermanent(array, 0); + + /* + * Can free now as the return value holds the reference + */ + ejsFreeVar(ejs, array); + + return 0; +} + +/******************************************************************************/ +/* + * function void getFreeSpace(); + */ + +static int getFreeSpaceProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ +#if UNUSED + MprApp *app; + uint space; + + app = mprGetApp(ejs); + space = IFILEMGR_GetFreeSpace(app->fileMgr, 0); + ejsSetReturnValueToInteger(ejs, space); +#endif + + return 0; +} + +/******************************************************************************/ +/* + * function void writeFile(string path, var data); + */ + +static int writeFileProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprFile *file; + char *data, *buf; + int bytes, length, rc; + + if (argc != 2 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: writeFile(path, var)"); + return -1; + } + + if (ejsVarIsString(argv[1])) { + data = argv[1]->string; + length = argv[1]->length; + buf = 0; + } else { + buf = data = ejsVarToString(ejs, argv[1]); + length = strlen(data); + } + + /* + * Create fails if already present + */ + rc = mprDelete(ejs, argv[0]->string); + file = mprOpen(ejs, argv[0]->string, O_CREAT | O_WRONLY | O_BINARY, 0664); + if (file == 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant create %s", argv[0]->string); + mprFree(buf); + return -1; + } + + rc = 0; + bytes = mprWrite(file, data, length); + if (bytes != length) { + ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string); + rc = -1; + } + + mprClose(file); + + mprFree(buf); + return rc; +} + +/******************************************************************************/ +/* + * function string readFile(string path); + */ + +static int readFileProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprApp *app; + MprFile *file; + MprBuf *buf; + char *data; + int bytes, rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: readFile(path)"); + return -1; + } + buf = mprCreateBuf(ejs, MPR_BUF_INCR, MPR_MAX_BUF); + if (buf == 0) { + ejsMemoryError(ejs); + return -1; + } + + data = mprAlloc(ejs, MPR_BUFSIZE); + if (buf == 0) { + mprFree(buf); + ejsMemoryError(ejs); + return -1; + } + + app = mprGetApp(ejs); + file = mprOpen(ejs, argv[0]->string, O_RDONLY, 0664); + if (file == 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant open %s", argv[0]->string); + mprFree(buf); + return -1; + } + + rc = 0; + while ((bytes = mprRead(file, data, MPR_BUFSIZE)) > 0) { + if (mprPutBlockToBuf(buf, data, bytes) != bytes) { + ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string); + rc = -1; + break; + } + } + + ejsSetReturnValueToBinaryString(ejs, (uchar*) mprGetBufStart(buf), + mprGetBufLength(buf)); + + mprClose(file); + mprFree(data); + mprFree(buf); + + return rc; +} + +/******************************************************************************/ +/* + * function void remove(string path); + */ + +static int removeProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: remove(path)"); + return -1; + } + + rc = unlink(argv[0]->string); + if (rc < 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant remove file"); + return -1; + } + return 0; +} + +/******************************************************************************/ +/* + * function void rename(string from, string to); + */ + +static int renameProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int rc; + + if (argc != 2 || !ejsVarIsString(argv[0]) || !ejsVarIsString(argv[1])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: rename(old, new)"); + return -1; + } + + unlink(argv[1]->string); + rc = rename(argv[0]->string, argv[1]->string); + if (rc < 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant rename file"); + return -1; + } + return 0; +} + +/******************************************************************************/ +/* + * function void copy(string old, string new); + */ + +static int copyProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprFile *from, *to; + char *buf; + uint bytes; + int rc; + + if (argc != 2 || !ejsVarIsString(argv[0]) || !ejsVarIsString(argv[1])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: copy(old, new)"); + return -1; + } + + buf = mprAlloc(ejs, MPR_BUFSIZE); + if (buf == 0) { + ejsMemoryError(ejs); + return -1; + } + + from = mprOpen(ejs, argv[0]->string, O_RDONLY | O_BINARY, 0664); + if (from == 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant open %s", argv[0]->string); + mprFree(buf); + return -1; + } + + to = mprOpen(ejs, argv[1]->string, O_CREAT | O_BINARY, 0664); + if (to == 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant create %s", argv[1]->string); + mprClose(from); + mprFree(buf); + return -1; + } + + rc = 0; + while ((bytes = mprRead(from, buf, MPR_BUFSIZE)) > 0) { + if (mprWrite(to, buf, bytes) != bytes) { + ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string); + rc = -1; + break; + } + } + + mprClose(from); + mprClose(to); + mprFree(buf); + + return rc; +} + +/******************************************************************************/ +/* + * function FileInfo getFileInfo(string path); + * + * MOB -- should create a real class FileInfo + */ + +static int getFileInfoProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprFileInfo info; + EjsVar *fileInfo; + int rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: getFileInfo(path)"); + return -1; + } + + fileInfo = ejsCreateObjVar(ejs); + if (fileInfo == 0) { + ejsMemoryError(ejs); + return -1; + } + ejsMakeObjPermanent(fileInfo, 1); + + rc = mprGetFileInfo(ejs, argv[0]->string, &info); + if (rc < 0) { + ejsMakeObjPermanent(fileInfo, 0); + ejsFreeVar(ejs, fileInfo); + ejsError(ejs, EJS_IO_ERROR, "Cant get file info for %s", + argv[0]->string); + return -1; + } + + ejsSetPropertyToInteger(ejs, fileInfo, "created", info.ctime); + ejsSetPropertyToInteger(ejs, fileInfo, "length", info.size); + ejsSetPropertyToBoolean(ejs, fileInfo, "isDir", info.isDir); + + ejsSetReturnValue(ejs, fileInfo); + ejsMakeObjPermanent(fileInfo, 0); + + return 0; +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineFileSystemClass(Ejs *ejs) +{ + EjsVar *fileSystemClass; + + fileSystemClass = ejsDefineClass(ejs, "FileSystem", "Object", 0); + if (fileSystemClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define the methods + */ + ejsDefineCMethod(ejs, fileSystemClass, "access", accessProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "mkdir", mkdirProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "rmdir", rmdirProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "dirList", dirListProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "writeFile", writeFileProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "readFile", readFileProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "remove", removeProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "rename", renameProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "copy", copyProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "getFileInfo", getFileInfoProc, 0); + + // MOB -- should be a property with accessor + ejsDefineCMethod(ejs, fileSystemClass, "getFreeSpace", getFreeSpaceProc, 0); + + return ejsObjHasErrors(fileSystemClass) ? MPR_ERR_CANT_INITIALIZE: 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/ejsHTTP.c b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/ejsHTTP.c new file mode 100755 index 0000000000..25821f6960 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/UNIX/ejsHTTP.c @@ -0,0 +1,488 @@ +/* + * @file ejsHTTP.c + * @brief HTTP class for the EJ System Object Model + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if UNUSED +/*********************************** Defines **********************************/ + +#define EJS_WEB_PROPERTY "-web" +#define EJS_HTTP_PROPERTY "-http" + +#define EJS_HTTP_DISPOSED 550 + +/* + * Control structure for one HTTP request structure + */ +typedef struct HTTPControl { + Ejs *ejs; + IWebResp *webResp; + AEECallback *callback; + MprBuf *buf; + EjsVar *thisObj; + char *url; + MprTime requestStarted; + uint timeout; +} HTTPControl; + +/****************************** Forward Declarations **************************/ + +static void cleanup(HTTPControl *hp); +static int createWeb(Ejs *ejs, EjsVar *thisObj); +static void brewCallback(HTTPControl *hp); +static int httpDestructor(Ejs *ejs, EjsVar *vp); +static void httpCallback(HTTPControl *hp, int responseCode); +static int setCallback(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv); + +/******************************************************************************/ +/* + * Constructor + */ + +int ejsHTTPConstructor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 0 && argc != 2) { + ejsError(ejs, EJS_ARG_ERROR, + "Bad usage: HTTP([obj = this, method = onComplete]);"); + return -1; + } + + if (createWeb(ejs, thisObj) < 0) { + return -1; + } + + setCallback(ejs, thisObj, argc, argv); + return 0; +} + +/******************************************************************************/ + +static int createWeb(Ejs *ejs, EjsVar *thisObj) +{ + MprApp *app; + void *web; + + app = mprGetApp(ejs); + + /* + * Create one instance of IWeb for the entire application. Do it here + * so only widgets that require HTTP incurr the overhead. + */ + web = mprGetKeyValue(ejs, "bpWeb"); + if (web == 0) { + if (ISHELL_CreateInstance(app->shell, AEECLSID_WEB, &web) != SUCCESS) { + ejsError(ejs, EJS_IO_ERROR, "Can't create IWEB"); + return -1; + } + } + mprSetKeyValue(ejs, "bpWeb", web); + return 0; +} + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +/* + * function setCallback(obj, methodString); + */ + +static int setCallback(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc >= 1) { + ejsSetProperty(ejs, thisObj, "obj", argv[0]); + } else { + ejsSetProperty(ejs, thisObj, "obj", thisObj); + } + + if (argc >= 2) { + ejsSetProperty(ejs, thisObj, "method", argv[1]); + } else { + ejsSetPropertyToString(ejs, thisObj, "method", "onComplete"); + } + + return 0; +} + +/******************************************************************************/ +/* + * function fetch(); + */ + +static int fetchProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + HTTPControl *hp; + EjsProperty *pp; + MprApp *app; + IWeb *web; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: fetch(url)"); + return -1; + } + + app = mprGetApp(ejs); + web = (IWeb*) mprGetKeyValue(ejs, "bpWeb"); + + /* + * Web options + * + * WEBOPT_USERAGENT (char*) sets user agent + * WEBOPT_HANDLERDATA (void*) + * WEBOPT_CONNECTTIMEOUT (uint) msec + * WEBOPT_CONTENTLENGTH (long) + * WEBOPT_IDLECONNTIMEOUT (int) + * WEBOPT_ACTIVEXACTIONST (uint) Number of active requests + * + * WEBREQUEST_REDIRECT redirect transparently + * + */ + + hp = mprAllocType(ejs, HTTPControl); + if (hp == 0) { + ejsMemoryError(ejs); + return -1; + } + + hp->ejs = ejs; + hp->buf = mprCreateBuf(hp, MPR_BUF_INCR, MPR_MAX_BUF); + if (hp->buf == 0) { + mprFree(hp); + ejsMemoryError(ejs); + return -1; + } + + /* + * We copy thisObj because we need to preserve both the var and the object. + * We pass the var to brewCallback and so it must persist. The call to + * ejsMakeObjPermanent will stop the GC from collecting the object. + */ + hp->thisObj = ejsDupVar(ejs, thisObj, EJS_SHALLOW_COPY); + ejsSetVarName(ejs, hp->thisObj, "internalHttp"); + + /* + * Must keep a reference to the http object + */ + ejsMakeObjPermanent(hp->thisObj, 1); + + /* + * Make a property so we can access the HTTPControl structure from other + * methods. + */ + pp = ejsSetPropertyToPtr(ejs, thisObj, EJS_HTTP_PROPERTY, hp, 0); + ejsMakePropertyEnumerable(pp, 0); + ejsSetObjDestructor(ejs, hp->thisObj, httpDestructor); + + hp->url = mprStrdup(hp, argv[0]->string); + + hp->timeout = ejsGetPropertyAsInteger(ejs, thisObj, "timeout"); + mprGetTime(hp, &hp->requestStarted); + + hp->callback = mprAllocTypeZeroed(hp, AEECallback); + CALLBACK_Init(hp->callback, brewCallback, hp); + + hp->webResp = 0; + IWEB_GetResponse(web, + (web, &hp->webResp, hp->callback, hp->url, + WEBOPT_HANDLERDATA, hp, + WEBOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)", + WEBOPT_CONNECTTIMEOUT, hp->timeout, + WEBOPT_COPYOPTS, TRUE, + WEBOPT_CONTENTLENGTH, 0, + WEBOPT_END)); + + ejsSetPropertyToString(ejs, thisObj, "status", "active"); + + return 0; +} + +/******************************************************************************/ +/* + * Called whenver the http object is deleted. + */ + +static int httpDestructor(Ejs *ejs, EjsVar *thisObj) +{ + HTTPControl *hp; + + /* + * If the httpCallback has run, then this property will not exist + */ + hp = ejsGetPropertyAsPtr(ejs, thisObj, EJS_HTTP_PROPERTY); + + if (hp) { + cleanup(hp); + } + + return 0; +} + +/******************************************************************************/ +/* + * Stop the request immediately without calling the callback + */ + +static int stopProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + HTTPControl *hp; + + hp = ejsGetPropertyAsPtr(ejs, thisObj, EJS_HTTP_PROPERTY); + + if (hp) { + cleanup(hp); + } + + return 0; +} + +/******************************************************************************/ +/* + * Brew HTTP callback. Invoked for any return data. + */ + +static void brewCallback(HTTPControl *hp) +{ + Ejs *ejs; + EjsVar *thisObj; + ISource *source; + WebRespInfo *info; + char data[MPR_BUF_INCR]; + int bytes; + + mprAssert(hp); + mprAssert(hp->webResp); + + info = IWEBRESP_GetInfo(hp->webResp); + + if (info == 0) { + mprAssert(info); + /* should not happen */ + return; + } + + ejs = hp->ejs; + thisObj = hp->thisObj; + + if (! WEB_ERROR_SUCCEEDED(info->nCode)) { + ejsSetPropertyToString(ejs, thisObj, "status", "error"); + httpCallback(hp, info->nCode); + return; + } + + if (hp->timeout) { + if (mprGetTimeRemaining(hp, hp->requestStarted, hp->timeout) <= 0) { + ejsSetPropertyToString(ejs, thisObj, "status", "timeout"); + httpCallback(hp, 504); + return; + } + } + + /* + * Normal success + */ + source = info->pisMessage; + mprAssert(source); + + bytes = ISOURCE_Read(source, data, sizeof(data)); + + switch (bytes) { + case ISOURCE_WAIT: // No data yet + ISOURCE_Readable(source, hp->callback); + break; + + case ISOURCE_ERROR: + ejsSetPropertyToString(ejs, thisObj, "status", "error"); + httpCallback(hp, info->nCode); + break; + + case ISOURCE_END: + mprAddNullToBuf(hp->buf); + ejsSetPropertyToString(ejs, thisObj, "status", "complete"); + httpCallback(hp, info->nCode); + break; + + default: + if (bytes > 0) { + if (mprPutBlockToBuf(hp->buf, data, bytes) != bytes) { + ejsSetPropertyToString(ejs, thisObj, "status", "partialData"); + httpCallback(hp, 500); + } + } + ISOURCE_Readable(source, hp->callback); + break; + } +} + +/******************************************************************************/ +/* + * Invoke the HTTP completion method + */ + +static void httpCallback(HTTPControl *hp, int responseCode) +{ + Ejs *ejs; + EjsVar *thisObj, *callbackObj; + MprArray *args; + char *msg; + const char *callbackMethod; + + mprAssert(hp); + mprAssert(hp->webResp); + + thisObj = hp->thisObj; + ejs = hp->ejs; + + ejsSetPropertyToInteger(ejs, thisObj, "responseCode", responseCode); + if (mprGetBufLength(hp->buf) > 0) { + ejsSetPropertyToBinaryString(ejs, thisObj, "responseData", + mprGetBufStart(hp->buf), mprGetBufLength(hp->buf)); + } + + callbackObj = ejsGetPropertyAsVar(ejs, thisObj, "obj"); + callbackMethod = ejsGetPropertyAsString(ejs, thisObj, "method"); + + if (callbackObj != 0 && callbackMethod != 0) { + + args = mprCreateItemArray(ejs, EJS_INC_ARGS, EJS_MAX_ARGS); + mprAddItem(args, ejsDupVar(ejs, hp->thisObj, EJS_SHALLOW_COPY)); + + if (ejsRunMethod(ejs, callbackObj, callbackMethod, args) < 0) { + msg = ejsGetErrorMsg(ejs); + mprError(ejs, MPR_LOC, "HTTP callback failed. Details: %s", msg); + } + ejsFreeMethodArgs(ejs, args); + + } else if (ejsRunMethod(ejs, thisObj, "onComplete", 0) < 0) { + msg = ejsGetErrorMsg(ejs); + mprError(ejs, MPR_LOC, "HTTP onComplete failed. Details: %s", msg); + } + + cleanup(hp); +} + +/******************************************************************************/ +/* + * Cleanup + */ + +static void cleanup(HTTPControl *hp) +{ + Ejs *ejs; + MprApp *app; + int rc; + + mprAssert(hp); + mprAssert(hp->webResp); + + ejs = hp->ejs; + + if (hp->webResp) { + rc = IWEBRESP_Release(hp->webResp); + // mprAssert(rc == 0); + hp->webResp = 0; + } + + if (hp->callback) { + CALLBACK_Cancel(hp->callback); + mprFree(hp->callback); + hp->callback = 0; + } + + /* + * Once the property is deleted, then if the destructor runs, it will + * notice that the EJS_HTTP_PROPERTY is undefined. + */ + ejsDeleteProperty(ejs, hp->thisObj, EJS_HTTP_PROPERTY); + + /* + * Allow garbage collection to work on thisObj + */ + ejsMakeObjPermanent(hp->thisObj, 0); + ejsFreeVar(ejs, hp->thisObj); + + mprFree(hp->buf); + mprFree(hp->url); + + mprFree(hp); + + app = mprGetApp(ejs); + + + ISHELL_SendEvent(app->shell, (AEECLSID) app->classId, EVT_USER, 0, 0); +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineHTTPClass(Ejs *ejs) +{ + EjsVar *httpClass; + + httpClass = + ejsDefineClass(ejs, "HTTP", "Object", ejsHTTPConstructor); + if (httpClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define the methods + */ + ejsDefineCMethod(ejs, httpClass, "fetch", fetchProc, 0); + ejsDefineCMethod(ejs, httpClass, "stop", stopProc, 0); + ejsDefineCMethod(ejs, httpClass, "setCallback", setCallback, 0); + +#if FUTURE + ejsDefineCMethod(ejs, httpClass, "put", put, 0); + ejsDefineCMethod(ejs, httpClass, "upload", upload, 0); + ejsDefineCMethod(ejs, httpClass, "addUploadFile", addUploadFile, 0); + ejsDefineCMethod(ejs, httpClass, "addPostData", addPostData, 0); + ejsDefineCMethod(ejs, httpClass, "setUserPassword", setUserPassword, 0); + ejsDefineCMethod(ejs, httpClass, "addCookie", addCookie, 0); +#endif + + /* + * Define properties + */ + ejsSetPropertyToString(ejs, httpClass, "status", "inactive"); + + /* This default should come from player.xml */ + + ejsSetPropertyToInteger(ejs, httpClass, "timeout", 30 * 1000); + ejsSetPropertyToInteger(ejs, httpClass, "responseCode", 0); + + return ejsObjHasErrors(httpClass) ? MPR_ERR_CANT_INITIALIZE: 0; +} + +/******************************************************************************/ + +void ejsTermHTTPClass(Ejs *ejs) +{ + IWeb *web; + int rc; + + web = (IWeb*) mprGetKeyValue(ejs, "bpWeb"); + if (web) { + rc = IWEB_Release(web); + mprAssert(rc == 0); + } +} + +#endif +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/WIN/.ignore b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/.ignore new file mode 100644 index 0000000000..fb5a29031e --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/.ignore @@ -0,0 +1 @@ +.updated diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/WIN/Makefile b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/Makefile new file mode 100755 index 0000000000..424747052a --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/Makefile @@ -0,0 +1,21 @@ +# +# Makefile to build the EJS Object Model for WIN +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +COMPILE := *.c +EXPORT_OBJECTS := yes +MAKE_IFLAGS := -I../.. -I../../../mpr + +include make.dep + +compileExtra: .updated + +.updated: $(FILES) + @touch .updated + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/WIN/ejsFile.c b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/ejsFile.c new file mode 100644 index 0000000000..24c521891e --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/ejsFile.c @@ -0,0 +1,98 @@ +/* + * @file ejsFile.c + * @brief File class for the EJScript System Object Model + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +/******************************************************************************/ +/* + * Default Constructor + */ + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +/* + * function open(); + */ + +static int openProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "File.open()\n"); + return 0; +} + +/******************************************************************************/ +/* + * function close(); + */ + +static int closeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "File.close()\n"); + return 0; +} + +/******************************************************************************/ +/* + * function read(); + */ + +static int readProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "File.read()\n"); + return 0; +} + +/******************************************************************************/ +/* + * function write(); + */ + +static int writeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "File.write()\n"); + return 0; +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineFileClass(Ejs *ep) +{ + EjsVar *fileClass; + + fileClass = ejsDefineClass(ep, "File", "Object", 0); + if (fileClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define the methods + */ + ejsDefineCMethod(ep, fileClass, "open", openProc, 0); + ejsDefineCMethod(ep, fileClass, "close", closeProc, 0); + ejsDefineCMethod(ep, fileClass, "read", readProc, 0); + ejsDefineCMethod(ep, fileClass, "write", writeProc, 0); + + return ejsObjHasErrors(fileClass) ? MPR_ERR_CANT_INITIALIZE: 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/WIN/ejsFileSystem.c b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/ejsFileSystem.c new file mode 100755 index 0000000000..66c3b84870 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/ejsFileSystem.c @@ -0,0 +1,456 @@ +/* + * @file ejsFileSystem.c + * @brief FileSystem class for the EJ System Object Model + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +/******************************************************************************/ +/* + * Default Constructor + */ + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +/* + * function void access(string path); + * MOB - API insufficient. Access for read or write? + */ + +static int accessProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: access(path)"); + return -1; + } + + rc = access(argv[0]->string, 04); + + ejsSetReturnValueToBoolean(ejs, (rc == 0) ? 1 : 0); + return 0; +} + +/******************************************************************************/ +/* + * function void mkdir(string path); + */ + +static int mkdirProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: mkdir(path)"); + return -1; + } + + if (mprMakeDirPath(ejs, argv[0]->string) < 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant create directory"); + return -1; + } + return 0; +} + +/******************************************************************************/ +/* + * function void rmdir(string path); + */ + +static int rmdirProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: mkdir(path)"); + return -1; + } + + rc = mprDeleteDir(ejs, argv[0]->string); + + if (rc < 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant remove directory"); + return -1; + } + return 0; +} + +/******************************************************************************/ +/* + * function void dirList(string path, [bool enumDirs]); + * MOB -- need pattern to match (what about "." and ".." and ".*" + */ + +static int dirListProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + WIN32_FIND_DATA findData; + HANDLE h; + char path[MPR_MAX_FNAME]; + EjsVar *array, *vp; + uchar enumDirs; + + if (argc < 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: dirList(path)"); + return -1; + } + if (argc == 2) { + enumDirs = ejsVarToBoolean(argv[1]); + } else { + enumDirs = 0; + } + array = ejsCreateArray(ejs, 0); + ejsMakeObjPermanent(array, 1); + + /* + * First collect the files + */ + mprSprintf(path, sizeof(path), "%s/*.*", argv[0]->string); + h = FindFirstFile(path, &findData); + if (h == INVALID_HANDLE_VALUE) { + ejsError(ejs, EJS_ARG_ERROR, "Can't enumerate dirList(path)"); + return -1; + } + + do { + if (findData.cFileName[0] == '.') { + continue; + } + if (!enumDirs || + (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { + mprSprintf(path, sizeof(path), "%s/%s", argv[0]->string, + findData.cFileName); + vp = ejsCreateStringVar(ejs, path); + ejsAddArrayElt(ejs, array, vp, EJS_SHALLOW_COPY); + ejsFreeVar(ejs, vp); + } + } while (FindNextFile(h, &findData) != 0); + + FindClose(h); + + ejsSetReturnValue(ejs, array); + ejsMakeObjPermanent(array, 0); + + /* + * Can free now as the return value holds the reference + */ + ejsFreeVar(ejs, array); + + return 0; +} + +/******************************************************************************/ +/* + * function void getFreeSpace(); + */ + +static int getFreeSpaceProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ +#if UNUSED + MprApp *app; + uint space; + + app = mprGetApp(ejs); + space = IFILEMGR_GetFreeSpace(app->fileMgr, 0); + ejsSetReturnValueToInteger(ejs, space); +#endif + + return 0; +} + +/******************************************************************************/ +/* + * function void writeFile(string path, var data); + */ + +static int writeFileProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprFile *file; + char *data, *buf; + int bytes, length, rc; + + if (argc != 2 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: writeFile(path, var)"); + return -1; + } + + if (ejsVarIsString(argv[1])) { + data = argv[1]->string; + length = argv[1]->length; + buf = 0; + } else { + buf = data = ejsVarToString(ejs, argv[1]); + length = strlen(data); + } + + /* + * Create fails if already present + */ + rc = mprDelete(ejs, argv[0]->string); + file = mprOpen(ejs, argv[0]->string, O_CREAT | O_WRONLY | O_BINARY, 0664); + if (file == 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant create %s", argv[0]->string); + mprFree(buf); + return -1; + } + + rc = 0; + bytes = mprWrite(file, data, length); + if (bytes != length) { + ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string); + rc = -1; + } + + mprClose(file); + + mprFree(buf); + return rc; +} + +/******************************************************************************/ +/* + * function string readFile(string path); + */ + +static int readFileProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprApp *app; + MprFile *file; + MprBuf *buf; + char *data; + int bytes, rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: readFile(path)"); + return -1; + } + buf = mprCreateBuf(ejs, MPR_BUF_INCR, MPR_MAX_BUF); + if (buf == 0) { + ejsMemoryError(ejs); + return -1; + } + + data = mprAlloc(ejs, MPR_BUFSIZE); + if (buf == 0) { + mprFree(buf); + ejsMemoryError(ejs); + return -1; + } + + app = mprGetApp(ejs); + file = mprOpen(ejs, argv[0]->string, O_RDONLY, 0664); + if (file == 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant open %s", argv[0]->string); + mprFree(buf); + return -1; + } + + rc = 0; + while ((bytes = mprRead(file, data, MPR_BUFSIZE)) > 0) { + if (mprPutBlockToBuf(buf, data, bytes) != bytes) { + ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string); + rc = -1; + break; + } + } + + ejsSetReturnValueToBinaryString(ejs, mprGetBufStart(buf), + mprGetBufLength(buf)); + + mprClose(file); + mprFree(data); + mprFree(buf); + + return rc; +} + +/******************************************************************************/ +/* + * function void remove(string path); + */ + +static int removeProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: remove(path)"); + return -1; + } + + rc = unlink(argv[0]->string); + if (rc < 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant remove file"); + return -1; + } + return 0; +} + +/******************************************************************************/ +/* + * function void rename(string from, string to); + */ + +static int renameProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int rc; + + if (argc != 2 || !ejsVarIsString(argv[0]) || !ejsVarIsString(argv[1])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: rename(old, new)"); + return -1; + } + + unlink(argv[1]->string); + rc = rename(argv[0]->string, argv[1]->string); + if (rc < 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant rename file"); + return -1; + } + return 0; +} + +/******************************************************************************/ +/* + * function void copy(string old, string new); + */ + +static int copyProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprFile *from, *to; + char *buf; + int bytes, rc; + + if (argc != 2 || !ejsVarIsString(argv[0]) || !ejsVarIsString(argv[1])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: copy(old, new)"); + return -1; + } + + buf = mprAlloc(ejs, MPR_BUFSIZE); + if (buf == 0) { + ejsMemoryError(ejs); + return -1; + } + + from = mprOpen(ejs, argv[0]->string, O_RDONLY | O_BINARY, 0664); + if (from == 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant open %s", argv[0]->string); + mprFree(buf); + return -1; + } + + to = mprOpen(ejs, argv[1]->string, O_CREAT | O_BINARY, 0664); + if (to == 0) { + ejsError(ejs, EJS_IO_ERROR, "Cant create %s", argv[1]->string); + mprClose(from); + mprFree(buf); + return -1; + } + + rc = 0; + while ((bytes = mprRead(from, buf, MPR_BUFSIZE)) > 0) { + if (mprWrite(to, buf, bytes) != bytes) { + ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string); + rc = -1; + break; + } + } + + mprClose(from); + mprClose(to); + mprFree(buf); + + return rc; +} + +/******************************************************************************/ +/* + * function FileInfo getFileInfo(string path); + * + * MOB -- should create a real class FileInfo + */ + +static int getFileInfoProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprFileInfo info; + EjsVar *fileInfo; + int rc; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: getFileInfo(path)"); + return -1; + } + + fileInfo = ejsCreateObjVar(ejs); + if (fileInfo == 0) { + ejsMemoryError(ejs); + return -1; + } + ejsMakeObjPermanent(fileInfo, 1); + + rc = mprGetFileInfo(ejs, argv[0]->string, &info); + if (rc < 0) { + ejsMakeObjPermanent(fileInfo, 0); + ejsFreeVar(ejs, fileInfo); + ejsError(ejs, EJS_IO_ERROR, "Cant get file info for %s", + argv[0]->string); + return -1; + } + + ejsSetPropertyToInteger(ejs, fileInfo, "created", info.ctime); + ejsSetPropertyToInteger(ejs, fileInfo, "length", info.size); + ejsSetPropertyToBoolean(ejs, fileInfo, "isDir", info.isDir); + + ejsSetReturnValue(ejs, fileInfo); + ejsMakeObjPermanent(fileInfo, 0); + + return 0; +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineFileSystemClass(Ejs *ejs) +{ + EjsVar *fileSystemClass; + + fileSystemClass = ejsDefineClass(ejs, "FileSystem", "Object", 0); + if (fileSystemClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define the methods + */ + ejsDefineCMethod(ejs, fileSystemClass, "access", accessProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "mkdir", mkdirProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "rmdir", rmdirProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "dirList", dirListProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "writeFile", writeFileProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "readFile", readFileProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "remove", removeProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "rename", renameProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "copy", copyProc, 0); + ejsDefineCMethod(ejs, fileSystemClass, "getFileInfo", getFileInfoProc, 0); + + // MOB -- should be a property with accessor + ejsDefineCMethod(ejs, fileSystemClass, "getFreeSpace", getFreeSpaceProc, 0); + + return ejsObjHasErrors(fileSystemClass) ? MPR_ERR_CANT_INITIALIZE: 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/WIN/ejsHTTP.c b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/ejsHTTP.c new file mode 100755 index 0000000000..25821f6960 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/WIN/ejsHTTP.c @@ -0,0 +1,488 @@ +/* + * @file ejsHTTP.c + * @brief HTTP class for the EJ System Object Model + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if UNUSED +/*********************************** Defines **********************************/ + +#define EJS_WEB_PROPERTY "-web" +#define EJS_HTTP_PROPERTY "-http" + +#define EJS_HTTP_DISPOSED 550 + +/* + * Control structure for one HTTP request structure + */ +typedef struct HTTPControl { + Ejs *ejs; + IWebResp *webResp; + AEECallback *callback; + MprBuf *buf; + EjsVar *thisObj; + char *url; + MprTime requestStarted; + uint timeout; +} HTTPControl; + +/****************************** Forward Declarations **************************/ + +static void cleanup(HTTPControl *hp); +static int createWeb(Ejs *ejs, EjsVar *thisObj); +static void brewCallback(HTTPControl *hp); +static int httpDestructor(Ejs *ejs, EjsVar *vp); +static void httpCallback(HTTPControl *hp, int responseCode); +static int setCallback(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv); + +/******************************************************************************/ +/* + * Constructor + */ + +int ejsHTTPConstructor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 0 && argc != 2) { + ejsError(ejs, EJS_ARG_ERROR, + "Bad usage: HTTP([obj = this, method = onComplete]);"); + return -1; + } + + if (createWeb(ejs, thisObj) < 0) { + return -1; + } + + setCallback(ejs, thisObj, argc, argv); + return 0; +} + +/******************************************************************************/ + +static int createWeb(Ejs *ejs, EjsVar *thisObj) +{ + MprApp *app; + void *web; + + app = mprGetApp(ejs); + + /* + * Create one instance of IWeb for the entire application. Do it here + * so only widgets that require HTTP incurr the overhead. + */ + web = mprGetKeyValue(ejs, "bpWeb"); + if (web == 0) { + if (ISHELL_CreateInstance(app->shell, AEECLSID_WEB, &web) != SUCCESS) { + ejsError(ejs, EJS_IO_ERROR, "Can't create IWEB"); + return -1; + } + } + mprSetKeyValue(ejs, "bpWeb", web); + return 0; +} + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +/* + * function setCallback(obj, methodString); + */ + +static int setCallback(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc >= 1) { + ejsSetProperty(ejs, thisObj, "obj", argv[0]); + } else { + ejsSetProperty(ejs, thisObj, "obj", thisObj); + } + + if (argc >= 2) { + ejsSetProperty(ejs, thisObj, "method", argv[1]); + } else { + ejsSetPropertyToString(ejs, thisObj, "method", "onComplete"); + } + + return 0; +} + +/******************************************************************************/ +/* + * function fetch(); + */ + +static int fetchProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + HTTPControl *hp; + EjsProperty *pp; + MprApp *app; + IWeb *web; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsError(ejs, EJS_ARG_ERROR, "Bad usage: fetch(url)"); + return -1; + } + + app = mprGetApp(ejs); + web = (IWeb*) mprGetKeyValue(ejs, "bpWeb"); + + /* + * Web options + * + * WEBOPT_USERAGENT (char*) sets user agent + * WEBOPT_HANDLERDATA (void*) + * WEBOPT_CONNECTTIMEOUT (uint) msec + * WEBOPT_CONTENTLENGTH (long) + * WEBOPT_IDLECONNTIMEOUT (int) + * WEBOPT_ACTIVEXACTIONST (uint) Number of active requests + * + * WEBREQUEST_REDIRECT redirect transparently + * + */ + + hp = mprAllocType(ejs, HTTPControl); + if (hp == 0) { + ejsMemoryError(ejs); + return -1; + } + + hp->ejs = ejs; + hp->buf = mprCreateBuf(hp, MPR_BUF_INCR, MPR_MAX_BUF); + if (hp->buf == 0) { + mprFree(hp); + ejsMemoryError(ejs); + return -1; + } + + /* + * We copy thisObj because we need to preserve both the var and the object. + * We pass the var to brewCallback and so it must persist. The call to + * ejsMakeObjPermanent will stop the GC from collecting the object. + */ + hp->thisObj = ejsDupVar(ejs, thisObj, EJS_SHALLOW_COPY); + ejsSetVarName(ejs, hp->thisObj, "internalHttp"); + + /* + * Must keep a reference to the http object + */ + ejsMakeObjPermanent(hp->thisObj, 1); + + /* + * Make a property so we can access the HTTPControl structure from other + * methods. + */ + pp = ejsSetPropertyToPtr(ejs, thisObj, EJS_HTTP_PROPERTY, hp, 0); + ejsMakePropertyEnumerable(pp, 0); + ejsSetObjDestructor(ejs, hp->thisObj, httpDestructor); + + hp->url = mprStrdup(hp, argv[0]->string); + + hp->timeout = ejsGetPropertyAsInteger(ejs, thisObj, "timeout"); + mprGetTime(hp, &hp->requestStarted); + + hp->callback = mprAllocTypeZeroed(hp, AEECallback); + CALLBACK_Init(hp->callback, brewCallback, hp); + + hp->webResp = 0; + IWEB_GetResponse(web, + (web, &hp->webResp, hp->callback, hp->url, + WEBOPT_HANDLERDATA, hp, + WEBOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)", + WEBOPT_CONNECTTIMEOUT, hp->timeout, + WEBOPT_COPYOPTS, TRUE, + WEBOPT_CONTENTLENGTH, 0, + WEBOPT_END)); + + ejsSetPropertyToString(ejs, thisObj, "status", "active"); + + return 0; +} + +/******************************************************************************/ +/* + * Called whenver the http object is deleted. + */ + +static int httpDestructor(Ejs *ejs, EjsVar *thisObj) +{ + HTTPControl *hp; + + /* + * If the httpCallback has run, then this property will not exist + */ + hp = ejsGetPropertyAsPtr(ejs, thisObj, EJS_HTTP_PROPERTY); + + if (hp) { + cleanup(hp); + } + + return 0; +} + +/******************************************************************************/ +/* + * Stop the request immediately without calling the callback + */ + +static int stopProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + HTTPControl *hp; + + hp = ejsGetPropertyAsPtr(ejs, thisObj, EJS_HTTP_PROPERTY); + + if (hp) { + cleanup(hp); + } + + return 0; +} + +/******************************************************************************/ +/* + * Brew HTTP callback. Invoked for any return data. + */ + +static void brewCallback(HTTPControl *hp) +{ + Ejs *ejs; + EjsVar *thisObj; + ISource *source; + WebRespInfo *info; + char data[MPR_BUF_INCR]; + int bytes; + + mprAssert(hp); + mprAssert(hp->webResp); + + info = IWEBRESP_GetInfo(hp->webResp); + + if (info == 0) { + mprAssert(info); + /* should not happen */ + return; + } + + ejs = hp->ejs; + thisObj = hp->thisObj; + + if (! WEB_ERROR_SUCCEEDED(info->nCode)) { + ejsSetPropertyToString(ejs, thisObj, "status", "error"); + httpCallback(hp, info->nCode); + return; + } + + if (hp->timeout) { + if (mprGetTimeRemaining(hp, hp->requestStarted, hp->timeout) <= 0) { + ejsSetPropertyToString(ejs, thisObj, "status", "timeout"); + httpCallback(hp, 504); + return; + } + } + + /* + * Normal success + */ + source = info->pisMessage; + mprAssert(source); + + bytes = ISOURCE_Read(source, data, sizeof(data)); + + switch (bytes) { + case ISOURCE_WAIT: // No data yet + ISOURCE_Readable(source, hp->callback); + break; + + case ISOURCE_ERROR: + ejsSetPropertyToString(ejs, thisObj, "status", "error"); + httpCallback(hp, info->nCode); + break; + + case ISOURCE_END: + mprAddNullToBuf(hp->buf); + ejsSetPropertyToString(ejs, thisObj, "status", "complete"); + httpCallback(hp, info->nCode); + break; + + default: + if (bytes > 0) { + if (mprPutBlockToBuf(hp->buf, data, bytes) != bytes) { + ejsSetPropertyToString(ejs, thisObj, "status", "partialData"); + httpCallback(hp, 500); + } + } + ISOURCE_Readable(source, hp->callback); + break; + } +} + +/******************************************************************************/ +/* + * Invoke the HTTP completion method + */ + +static void httpCallback(HTTPControl *hp, int responseCode) +{ + Ejs *ejs; + EjsVar *thisObj, *callbackObj; + MprArray *args; + char *msg; + const char *callbackMethod; + + mprAssert(hp); + mprAssert(hp->webResp); + + thisObj = hp->thisObj; + ejs = hp->ejs; + + ejsSetPropertyToInteger(ejs, thisObj, "responseCode", responseCode); + if (mprGetBufLength(hp->buf) > 0) { + ejsSetPropertyToBinaryString(ejs, thisObj, "responseData", + mprGetBufStart(hp->buf), mprGetBufLength(hp->buf)); + } + + callbackObj = ejsGetPropertyAsVar(ejs, thisObj, "obj"); + callbackMethod = ejsGetPropertyAsString(ejs, thisObj, "method"); + + if (callbackObj != 0 && callbackMethod != 0) { + + args = mprCreateItemArray(ejs, EJS_INC_ARGS, EJS_MAX_ARGS); + mprAddItem(args, ejsDupVar(ejs, hp->thisObj, EJS_SHALLOW_COPY)); + + if (ejsRunMethod(ejs, callbackObj, callbackMethod, args) < 0) { + msg = ejsGetErrorMsg(ejs); + mprError(ejs, MPR_LOC, "HTTP callback failed. Details: %s", msg); + } + ejsFreeMethodArgs(ejs, args); + + } else if (ejsRunMethod(ejs, thisObj, "onComplete", 0) < 0) { + msg = ejsGetErrorMsg(ejs); + mprError(ejs, MPR_LOC, "HTTP onComplete failed. Details: %s", msg); + } + + cleanup(hp); +} + +/******************************************************************************/ +/* + * Cleanup + */ + +static void cleanup(HTTPControl *hp) +{ + Ejs *ejs; + MprApp *app; + int rc; + + mprAssert(hp); + mprAssert(hp->webResp); + + ejs = hp->ejs; + + if (hp->webResp) { + rc = IWEBRESP_Release(hp->webResp); + // mprAssert(rc == 0); + hp->webResp = 0; + } + + if (hp->callback) { + CALLBACK_Cancel(hp->callback); + mprFree(hp->callback); + hp->callback = 0; + } + + /* + * Once the property is deleted, then if the destructor runs, it will + * notice that the EJS_HTTP_PROPERTY is undefined. + */ + ejsDeleteProperty(ejs, hp->thisObj, EJS_HTTP_PROPERTY); + + /* + * Allow garbage collection to work on thisObj + */ + ejsMakeObjPermanent(hp->thisObj, 0); + ejsFreeVar(ejs, hp->thisObj); + + mprFree(hp->buf); + mprFree(hp->url); + + mprFree(hp); + + app = mprGetApp(ejs); + + + ISHELL_SendEvent(app->shell, (AEECLSID) app->classId, EVT_USER, 0, 0); +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineHTTPClass(Ejs *ejs) +{ + EjsVar *httpClass; + + httpClass = + ejsDefineClass(ejs, "HTTP", "Object", ejsHTTPConstructor); + if (httpClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define the methods + */ + ejsDefineCMethod(ejs, httpClass, "fetch", fetchProc, 0); + ejsDefineCMethod(ejs, httpClass, "stop", stopProc, 0); + ejsDefineCMethod(ejs, httpClass, "setCallback", setCallback, 0); + +#if FUTURE + ejsDefineCMethod(ejs, httpClass, "put", put, 0); + ejsDefineCMethod(ejs, httpClass, "upload", upload, 0); + ejsDefineCMethod(ejs, httpClass, "addUploadFile", addUploadFile, 0); + ejsDefineCMethod(ejs, httpClass, "addPostData", addPostData, 0); + ejsDefineCMethod(ejs, httpClass, "setUserPassword", setUserPassword, 0); + ejsDefineCMethod(ejs, httpClass, "addCookie", addCookie, 0); +#endif + + /* + * Define properties + */ + ejsSetPropertyToString(ejs, httpClass, "status", "inactive"); + + /* This default should come from player.xml */ + + ejsSetPropertyToInteger(ejs, httpClass, "timeout", 30 * 1000); + ejsSetPropertyToInteger(ejs, httpClass, "responseCode", 0); + + return ejsObjHasErrors(httpClass) ? MPR_ERR_CANT_INITIALIZE: 0; +} + +/******************************************************************************/ + +void ejsTermHTTPClass(Ejs *ejs) +{ + IWeb *web; + int rc; + + web = (IWeb*) mprGetKeyValue(ejs, "bpWeb"); + if (web) { + rc = IWEB_Release(web); + mprAssert(rc == 0); + } +} + +#endif +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/ejsGC.c b/source4/lib/appweb/ejs-2.0/ejs/system/ejsGC.c new file mode 100644 index 0000000000..411975f80e --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/ejsGC.c @@ -0,0 +1,326 @@ +/* + * @file ejsGC.c + * @brief Garbage collector class for the EJS Object Model + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +#if (WIN || BREW_SIMULATOR) && BLD_DEBUG + +static int checkProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + _CrtCheckMemory(); + return 0; +} + +#endif +/******************************************************************************/ + +static int debugProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "Bad args: debug(debugLevel)"); + return -1; + } + + ejsSetGCDebugLevel(ep, ejsVarToInteger(argv[0])); + return 0; +} + +/******************************************************************************/ +/* + * Print stats and dump objects + */ + +static int printStatsProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + bool leakStats; + + if (argc > 1) { + leakStats = ejsVarToInteger(argv[0]); + } else { + leakStats = 0; + } + +#if BLD_FEATURE_ALLOC_STATS + ejsPrintAllocReport(ep, 0); + + mprPrintAllocReport(mprGetApp(ep), leakStats, 0); +#endif + +#if BLD_DEBUG + ejsDumpObjects(ep); +#endif + + return 0; +} + +/******************************************************************************/ + +static int runProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc > 1) { + ejsError(ep, EJS_ARG_ERROR, "Bad args: run([quick])"); + return -1; + } + + if (argc == 1) { + ejsIncrementalCollectGarbage(ep); + } else { + ejsCollectGarbage(ep, -1); + } + return 0; +} + +/******************************************************************************/ + +static int usedMemoryProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToInteger(ep, ejsGetUsedMemory(ep)); + return 0; +} + +/******************************************************************************/ + +static int allocatedMemoryProc(Ejs *ep, EjsVar *thisObj, int argc, + EjsVar **argv) +{ +#if BLD_FEATURE_ALLOC_STATS + ejsSetReturnValueToInteger(ep, ejsGetAllocatedMemory(ep)); +#endif + return 0; +} + +/******************************************************************************/ + +static int mprMemoryProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ +#if BLD_FEATURE_ALLOC_STATS + ejsSetReturnValueToInteger(ep, mprGetAllocatedMemory(ep)); +#endif + return 0; +} + +/******************************************************************************/ + +static int peakMprMemoryProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ +#if BLD_FEATURE_ALLOC_STATS + ejsSetReturnValueToInteger(ep, mprGetPeakAllocatedMemory(ep)); +#endif + return 0; +} + +/******************************************************************************/ + +static int getDebugLevel(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToInteger(ep, ep->gc.debugLevel); + return 0; +} + +/******************************************************************************/ + +static int setDebugLevel(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1) { + ejsArgError(ep, "Bad arguments"); + return -1; + } + ep->gc.debugLevel= ejsVarToInteger(argv[0]); + return 0; +} + +/******************************************************************************/ + +static int getEnable(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToBoolean(ep, ep->gc.enable); + return 0; +} + +/******************************************************************************/ + +static int setEnable(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1) { + ejsArgError(ep, "Bad arguments"); + return -1; + } + ep->gc.enable= ejsVarToBoolean(argv[0]); + return 0; +} + +/******************************************************************************/ + +static int getDemandCollect(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToBoolean(ep, ep->gc.enableDemandCollect); + return 0; +} + +/******************************************************************************/ + +static int setDemandCollect(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1) { + ejsArgError(ep, "Bad arguments"); + return -1; + } + ep->gc.enableDemandCollect = ejsVarToBoolean(argv[0]); + return 0; +} + +/******************************************************************************/ + +static int getIdleCollect(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToBoolean(ep, ep->gc.enableIdleCollect); + return 0; +} + +/******************************************************************************/ + +static int setIdleCollect(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1) { + ejsArgError(ep, "Bad arguments"); + return -1; + } + ep->gc.enableIdleCollect = ejsVarToBoolean(argv[0]); + return 0; +} + +/******************************************************************************/ + +static int getWorkQuota(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToInteger(ep, ep->gc.workQuota); + return 0; +} + +/******************************************************************************/ + +static int setWorkQuota(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int quota; + + if (argc != 1) { + ejsArgError(ep, "Bad arguments"); + return -1; + } + quota = ejsVarToInteger(argv[0]); + if (quota < EJS_GC_MIN_WORK_QUOTA && quota != 0) { + ejsArgError(ep, "Bad work quota"); + return -1; + } + + ep->gc.workQuota = quota; + return 0; +} + +/******************************************************************************/ + +static int getMaxMemory(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToInteger(ep, ep->gc.maxMemory); + return 0; +} + +/******************************************************************************/ + +static int setMaxMemory(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int maxMemory; + + if (argc != 1) { + ejsArgError(ep, "Bad arguments"); + return -1; + } + maxMemory = ejsVarToInteger(argv[0]); + if (maxMemory < 0) { + ejsArgError(ep, "Bad maxMemory"); + return -1; + } + + ep->gc.maxMemory = maxMemory; + return 0; +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineGCClass(Ejs *ep) +{ + EjsVar *gcClass; + int flags; + + flags = EJS_NO_LOCAL; + + /* + * NOTE: We create the GC class and define static methods on it. There + * is no object instance + */ + gcClass = ejsDefineClass(ep, "System.GC", "Object", 0); + if (gcClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * MOB -- convert these to properties with accessors when available + */ + ejsDefineCMethod(ep, gcClass, "printStats", printStatsProc, flags); + ejsDefineCMethod(ep, gcClass, "run", runProc, flags); + + ejsDefineCMethod(ep, gcClass, "getUsedMemory", usedMemoryProc, flags); + ejsDefineCMethod(ep, gcClass, "getAllocatedMemory", allocatedMemoryProc, + flags); + ejsDefineCMethod(ep, gcClass, "getMprMemory", mprMemoryProc, flags); + ejsDefineCMethod(ep, gcClass, "getPeakMprMemory", peakMprMemoryProc, flags); + ejsDefineCMethod(ep, gcClass, "debug", debugProc, flags); + +#if (WIN || BREW_SIMULATOR) && BLD_DEBUG + ejsDefineCMethod(ep, gcClass, "check", checkProc, flags); +#endif + + ejsDefineCAccessors(ep, gcClass, "debugLevel", + getDebugLevel, setDebugLevel, flags); + + ejsDefineCAccessors(ep, gcClass, "enable", + getEnable, setEnable, flags); + + ejsDefineCAccessors(ep, gcClass, "demandCollect", + getDemandCollect, setDemandCollect, flags); + + ejsDefineCAccessors(ep, gcClass, "idleCollect", + getIdleCollect, setIdleCollect, flags); + + ejsDefineCAccessors(ep, gcClass, "workQuota", + getWorkQuota, setWorkQuota, flags); + + ejsDefineCAccessors(ep, gcClass, "maxMemory", + getMaxMemory, setMaxMemory, flags); + + return ejsObjHasErrors(gcClass) ? MPR_ERR_CANT_INITIALIZE : 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/ejsGlobal.c b/source4/lib/appweb/ejs-2.0/ejs/system/ejsGlobal.c new file mode 100755 index 0000000000..6ab8f867e1 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/ejsGlobal.c @@ -0,0 +1,785 @@ +/* + * @file ejsGlobal.c + * @brief EJS support methods + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +#if BLD_FEATURE_EJS + +/******************************************************************************/ +/************************************* Code ***********************************/ +/******************************************************************************/ +/* + * assert(condition) + */ + +static int assertProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int b; + + if (argc < 1) { + ejsError(ep, EJS_ARG_ERROR, "usage: assert(condition)"); + return -1; + } + b = ejsVarToBoolean(argv[0]); + if (b == 0) { + ejsError(ep, EJS_ASSERT_ERROR, "Assertion failure at line %d", + ejsGetLineNumber(ep)); + return -1; + } + ejsWriteVarAsBoolean(ep, ep->result, b); + return 0; +} + +/******************************************************************************/ +/* + * breakpoint(msg) + */ + +static int breakpointProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *buf; + + if (argc < 1) { + return 0; + } + buf = ejsVarToString(ep, argv[0]); + if (buf) { + mprBreakpoint(0, buf); + } + return 0; +} + +/******************************************************************************/ +/* + * basename(path) + */ + +static int basenameProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *path; + + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "usage: basename(path)"); + return -1; + } + + path = ejsVarToString(ep, argv[0]); + if (path == 0) { + return MPR_ERR_MEMORY; + } + ejsSetReturnValueToString(ep, mprGetBaseName(path)); + + return 0; +} + +/******************************************************************************/ +/* + * stripext(path) + */ + +static int stripextProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *cp, *path, *stripPath; + + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "usage: stripext(path)"); + return -1; + } + + path = ejsVarToString(ep, argv[0]); + if (path == 0) { + return MPR_ERR_MEMORY; + } + stripPath = mprStrdup(ep, path); + + if ((cp = strrchr(stripPath, '.')) != 0) { + *cp = '\0'; + } + + ejsSetReturnValueToString(ep, stripPath); + + mprFree(stripPath); + + return 0; +} + +/******************************************************************************/ +/* + * dirname(path) + */ + +static int dirnameProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *path; + char dirname[MPR_MAX_FNAME]; + + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "usage: dirname(path)"); + return -1; + } + + path = ejsVarToString(ep, argv[0]); + if (path == 0) { + return MPR_ERR_MEMORY; + } + + ejsSetReturnValueToString(ep, + mprGetDirName(dirname, sizeof(dirname), path)); + + return 0; +} + +/******************************************************************************/ +/* + * trim(string) -- trim white space + */ + +static int trimProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *str, *buf, *cp; + + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "usage: trim(string)"); + return -1; + } + + str = ejsVarToString(ep, argv[0]); + if (str == 0) { + return MPR_ERR_MEMORY; + } + str = buf = mprStrdup(ep, str); + + while (isspace(*str)) { + str++; + } + cp = &str[strlen(str) - 1]; + while (cp >= str) { + if (isspace(*cp)) { + *cp = '\0'; + } else { + break; + } + cp--; + } + + ejsSetReturnValueToString(ep, str); + + mprFree(buf); + + return 0; +} + +/******************************************************************************/ +/* + * Terminate the script + */ + +static int exitScript(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int status; + + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "usage: exit(status)"); + return -1; + } + status = (int) ejsVarToInteger(argv[0]); + ejsExit(ep, status); + + ejsWriteVarAsString(ep, ep->result, ""); + return 0; +} + +/******************************************************************************/ +/* + * include javascript libraries. + */ + +static int includeProc(Ejs *ep, EjsVar *thisObj, int argc, char **argv) +{ + int i; + + mprAssert(argv); + + for (i = 0; i < argc; i++) { + if (ejsEvalFile(ep, argv[i], 0) < 0) { + return -1; + } + } + return 0; +} + +/******************************************************************************/ +/* + * include javascript libraries at the global level + */ + +static int includeGlobalProc(Ejs *ep, EjsVar *thisObj, int argc, char **argv) +{ + int fid, i; + + mprAssert(argv); + + /* + * Create a new block and set the context to be the global scope + */ + fid = ejsSetBlock(ep, ep->global); + + for (i = 0; i < argc; i++) { + if (ejsEvalFile(ep, argv[i], 0) < 0) { + ejsCloseBlock(ep, fid); + return -1; + } + } + ejsCloseBlock(ep, fid); + return 0; +} + +/******************************************************************************/ +#if BLD_DEBUG +/* + * Print variables to stdout + */ + +static int printvProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsVar *vp; + char *buf; + int i; + + for (i = 0; i < argc; ) { + vp = argv[i++]; + + /* mprPrintf(ep, "arg[%d] = ", i); */ + + buf = ejsVarToString(ep, vp); + + if (vp->propertyName == 0 || *vp->propertyName == '\0') { + mprPrintf(ep, "%s: ", buf); + + } else if (i < argc) { + mprPrintf(ep, "%s = %s, ", vp->propertyName, buf); + } else { + mprPrintf(ep, "%s = %s\n", vp->propertyName, buf); + } + } + return 0; +} + +#endif +/******************************************************************************/ +/* + * Print the args to stdout + */ + +static int printProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *buf; + int i; + + for (i = 0; i < argc; i++) { + buf = ejsVarToString(ep, argv[i]); + mprPrintf(ep, "%s", buf); + } + return 0; +} + +/******************************************************************************/ +/* + * println + */ + +static int printlnProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + printProc(ep, thisObj, argc, argv); + mprPrintf(ep, "\n"); + return 0; +} + +/******************************************************************************/ +#if FUTURE +/* + * sprintf + */ + +static int sprintfProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + va_list ap; + char *buf; + void **args; + int result; + + if (argc <= 1) { + ejsError(ep, EJS_ARG_ERROR, "Usage: sprintf(fmt, [args ...])"); + return -1; + } + + args = mprAlloc(ep, sizeof(void*) * (argc - 1)); + if (args == 0) { + mprAssert(args); + return -1; + } + + for (i = 1; i < argc; i++) { + args[i - 1] = argv[i]); + } + + va_start(ap, fmt); + *buf = 0; + result = inner(0, &buf, MPR_MAX_STRING, fmt, args); + va_end(ap); + + ejsSetReturnValueToString(ep, buf); + + mprFree(buf); + return 0; +} + +/******************************************************************************/ + +inner(const char *fmt, void **args) +{ + va_list ap; + + va_start(ap, fmt); + *buf = 0; + mprSprintfCore(ctx, &buf, maxSize, fmt, ap, MPR_PRINTF_ARGV); + va_end(ap); +} + +#endif +/******************************************************************************/ +/* + * sleep + */ + +static int sleepProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "Usage: sleep(milliseconds)"); + return -1; + } + mprSleep(ep, ejsVarToInteger(argv[0])); + return 0; +} + +/******************************************************************************/ +/* + * sort properties + * FUTURE -- should have option to sort object based on a given property value + * ascending or descending + * Usage: sort(object, order = ascending, property = 0); + */ + +static int sortProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + const char *property; + int error, order; + + error = 0; + property = 0; + + /* + * Default order is increasing + */ + order = 1; + + if (argc < 1 || argc > 3 || !ejsVarIsObject(argv[0])) { + error++; + } + + if (argc >= 2) { + order = ejsVarToInteger(argv[1]); + } + + /* + * If property is not defined, it sorts the properties in the object + */ + if (argc == 3) { + if (! ejsVarIsString(argv[2])) { + error++; + } else { + property = argv[2]->string; + } + } + + if (error) { + ejsError(ep, EJS_ARG_ERROR, "Usage: sort(object, [order], [property])"); + return -1; + } + ejsSortProperties(ep, argv[0], 0, property, order); + return 0; +} + +/******************************************************************************/ +/* + * Get a time mark + * MOB -- WARNING: this can overflow. OK on BREW, but other O/Ss it may have + * overflowed on the first call. It should be renamed. + * MOB -- replace with proper Date. + */ + +static int timeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + MprTime now; + + mprGetTime(ep, &now); +#if WIN || LINUX || SOLARIS +{ + /* MOB -- poor hack */ + static MprTime initial; + if (initial.sec == 0) { + initial = now; + } + now.sec -= initial.sec; + + if (initial.msec > now.msec) { + now.msec = now.msec + 1000 - initial.msec; + now.sec--; + } else { + now.msec -= initial.msec; + } +} +#endif + /* MOB -- this can overflow */ + ejsSetReturnValueToInteger(ep, now.sec * 1000 + now.msec); + return 0; +} + +/******************************************************************************/ +/* + * MOB -- Temporary Get the date (time since Jan 6, 1980 GMT + */ + +static int dateProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ +#if BREW + uint now; + + now = GETTIMESECONDS(); + ejsSetReturnValueToInteger(ep, now); +#endif + return 0; +} + +/******************************************************************************/ +/* + * strlen(string) + */ + +static int strlenProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *buf; + int len; + + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "Usage: strlen(var)"); + return -1; + } + + len = 0; + if (! ejsVarIsString(argv[0])) { + buf = ejsVarToString(ep, argv[0]); + if (buf) { + len = strlen(buf); + } + + } else { + len = argv[0]->length; + } + + ejsSetReturnValueToInteger(ep, len); + return 0; +} + +/******************************************************************************/ +/* + * toint(num) + */ + +static int tointProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int i; + + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "Usage: toint(number)"); + return -1; + } + + i = ejsVarToInteger(argv[0]); + + ejsSetReturnValueToInteger(ep, i); + return 0; +} + +/******************************************************************************/ +/* + * string strstr(string, pat) + */ + +static int strstrProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + char *str, *pat; + char *s; + int strAlloc; + + if (argc != 2) { + ejsError(ep, EJS_ARG_ERROR, "Usage: strstr(string, pat)"); + return -1; + } + + str = ejsVarToString(ep, argv[0]); + + strAlloc = ep->castAlloc; + ep->castTemp = 0; + + pat = ejsVarToString(ep, argv[1]); + + s = strstr(str, pat); + + if (s == 0) { + ejsSetReturnValueToUndefined(ep); + } else { + ejsSetReturnValueToString(ep, s); + } + + if (strAlloc) { + mprFree(str); + } + + return 0; +} + +/******************************************************************************/ +/* + * Trace + */ + +static int traceProc(Ejs *ep, EjsVar *thisObj, int argc, char **argv) +{ + if (argc == 1) { + mprLog(ep, 0, "%s", argv[0]); + + } else if (argc == 2) { + mprLog(ep, atoi(argv[0]), "%s", argv[1]); + + } else { + ejsError(ep, EJS_ARG_ERROR, "Usage: trace([level], message)"); + return -1; + } + ejsWriteVarAsString(ep, ep->result, ""); + return 0; +} + +/******************************************************************************/ +/* + * Evaluate a sub-script. It is evaluated in the same variable scope as + * the calling script / method. + */ + +static int evalScriptProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + EjsVar *arg; + int i; + + ejsWriteVarAsUndefined(ep, ep->result); + + for (i = 0; i < argc; i++) { + arg = argv[i]; + if (arg->type != EJS_TYPE_STRING) { + continue; + } + if (ejsEvalScript(ep, arg->string, 0) < 0) { + return -1; + } + } + /* + * Return with the value of the last expression + */ + return 0; +} + +/******************************************************************************/ + +/* MOB -- need a real datatype returning int, int64, etc */ + +static int typeofProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + const struct { + EjsType type; + const char *name; + } types[] = { + { EJS_TYPE_UNDEFINED, "undefined" }, +#if EJS_ECMA_STND + { EJS_TYPE_NULL, "object" }, +#else + { EJS_TYPE_NULL, "null" }, +#endif + { EJS_TYPE_BOOL, "boolean" }, + { EJS_TYPE_CMETHOD, "function" }, + { EJS_TYPE_FLOAT, "number" }, + { EJS_TYPE_INT, "number" }, + { EJS_TYPE_INT64, "number" }, + { EJS_TYPE_OBJECT, "object" }, + { EJS_TYPE_METHOD, "function" }, + { EJS_TYPE_STRING, "string" }, + { EJS_TYPE_STRING_CMETHOD, "function" }, + { EJS_TYPE_PTR, "pointer" } + }; + const char *type; + int i; + + type = NULL; + if (argc != 1) { + ejsError(ep, EJS_ARG_ERROR, "Bad args: typeof(var)"); + return -1; + } + + for (i = 0; i < MPR_ARRAY_SIZE(types); i++) { + if (argv[0]->type == types[i].type) { + type = types[i].name; + break; + } + } + if (type == NULL) { + mprAssert(type); + return -1; + } + + ejsSetReturnValueToString(ep, type); + return 0; +} + +/******************************************************************************/ +/* + * Define the standard properties and methods inherited by all interpreters + * Obj is set to the global class in the default interpreter. When an + * interpreter attempts to write to any property, a copy will be written + * into the interpeters own global space. This is like a "copy-on-write". + */ + +int ejsDefineGlobalProperties(Ejs *ep) +{ + EjsVar *obj; + + obj = ep->service->globalClass; + mprAssert(obj); + + ejsSetPropertyToNull(ep, obj, "null"); + ejsSetPropertyToUndefined(ep, obj, "undefined"); + ejsSetPropertyToBoolean(ep, obj, "true", 1); + ejsSetPropertyToBoolean(ep, obj, "false", 0); + +#if BLD_FEATURE_FLOATING_POINT + { + /* MOB. Fix. This generates warnings on some systems. + This is intended. */ + double d = 0.0; + double e = 0.0; + ejsSetPropertyToFloat(ep, obj, "NaN", e / d); + + d = MAX_FLOAT; + ejsSetPropertyToFloat(ep, obj, "Infinity", d * d); + } +#endif + +#if BLD_FEATURE_LEGACY_API + /* + * DEPRECATED: 2.0. + * So that ESP/ASP can ignore "language=javascript" statements + */ + ejsSetPropertyToInteger(ep, obj, "javascript", 0); +#endif + + /* + * Extension methods. We go directly to the mpr property APIs for speed. + * Flags will cause the callbacks to be supplied the Ejs handle. + */ + ejsDefineCMethod(ep, obj, "assert", assertProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "breakpoint", breakpointProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "basename", basenameProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "dirname", dirnameProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "stripext", stripextProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "trim", trimProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "eval", evalScriptProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "exit", exitScript, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "print", printProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "println", printlnProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "sleep", sleepProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "sort", sortProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "time", timeProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "date", dateProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "strlen", strlenProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "strstr", strstrProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "typeof", typeofProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "toint", tointProc, EJS_NO_LOCAL); + + ejsDefineStringCMethod(ep, obj, "include", includeProc, EJS_NO_LOCAL); + ejsDefineStringCMethod(ep, obj, "includeGlobal", includeGlobalProc, + EJS_NO_LOCAL); + ejsDefineStringCMethod(ep, obj, "trace", traceProc, EJS_NO_LOCAL); + +#if BLD_DEBUG + ejsDefineCMethod(ep, obj, "printv", printvProc, EJS_NO_LOCAL); +#endif + +#if FUTURE + ejsDefineCMethod(ep, obj, "printf", printfProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, obj, "sprintf", sprintfProc, EJS_NO_LOCAL); +#endif + + if (ejsObjHasErrors(obj)) { + return MPR_ERR_CANT_INITIALIZE; + } + return 0; +} + +/******************************************************************************/ + +#else +void ejsProcsDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystem.c b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystem.c new file mode 100644 index 0000000000..e035e1c740 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystem.c @@ -0,0 +1,112 @@ +/* + * @file ejsSystem.c + * @brief System class for the EJS Object Model + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +#if UNUSED +/* + * function int random() + */ + +static int randomProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "random()\n"); + return 0; +} + +/******************************************************************************/ +/* + * function void yield() + */ + +static int yieldProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "yield()\n"); + return 0; +} + +/******************************************************************************/ +/* + * function void sleep(int milliSeconds) + */ + +static int sleepProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ep, "sleep()\n"); + return 0; +} + +#endif +/******************************************************************************/ +/* + * function void exit(int status) + * + * Exit the widget with the given status. All JavaScript processing ceases. + */ + +static int exitProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv) +{ + int status; + + status = 0; + if ((argc == 1) && ejsVarIsInteger(argv[0])) { + status = argv[0]->integer; + } + ejsExit(ep, status); + return 0; +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineSystemClass(Ejs *ep) +{ + EjsVar *systemClass; + + /* + * We create the system class and define static methods on it. + * NOTE: There is no object instance + */ + systemClass = ejsDefineClass(ep, "System", "Object", 0); + if (systemClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + ejsDefineCMethod(ep, systemClass, "exit", exitProc, EJS_NO_LOCAL); + +#if UNUSED + ejsDefineCMethod(ep, systemClass, "random", randomProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, systemClass, "yield", yieldProc, EJS_NO_LOCAL); + ejsDefineCMethod(ep, systemClass, "sleep", sleepProc, EJS_NO_LOCAL); + + /* + * Define properties + */ + ejsSetPropertyToString(systemClass, "name", ""); +#endif + + return ejsObjHasErrors(systemClass) ? MPR_ERR_CANT_INITIALIZE : 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemApp.c b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemApp.c new file mode 100644 index 0000000000..e2f1ceb363 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemApp.c @@ -0,0 +1,49 @@ +/* + * @file ejsSystemApp.c + * @brief App class + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software Inc, 2005-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +/************************************ Code ************************************/ + +int ejsDefineAppClass(Ejs *ep) +{ + EjsVar *appClass; + + appClass = ejsDefineClass(ep, "System.App", "Object", 0); + if (appClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define properties + */ + ejsSetPropertyToString(ep, appClass, "name", BLD_PRODUCT); + ejsSetPropertyToString(ep, appClass, "title", BLD_NAME); + ejsSetPropertyToString(ep, appClass, "version", BLD_VERSION); + + /* + * Command line arguments + */ + ejsSetPropertyToNull(ep, appClass, "args"); + + return ejsObjHasErrors(appClass) ? MPR_ERR_CANT_INITIALIZE : 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemDebug.c b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemDebug.c new file mode 100644 index 0000000000..5a011e2a2d --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemDebug.c @@ -0,0 +1,60 @@ +/* + * @file ejsSystemDebug.c + * @brief System.Debug class + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +/* + * function bool isDebugMode() + * MOB -- convert to accessor + */ + +static int isDebugMode(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsTrace(ejs, "isDebugMode()\n"); + ejsSetReturnValueToInteger(ejs, mprGetDebugMode(ejs)); + return 0; +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineDebugClass(Ejs *ejs) +{ + EjsVar *systemDebugClass; + + systemDebugClass = ejsDefineClass(ejs, "System.Debug", "Object", 0); + if (systemDebugClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define the class methods + */ + ejsDefineCMethod(ejs, systemDebugClass, "isDebugMode", isDebugMode, + EJS_NO_LOCAL); + + return ejsObjHasErrors(systemDebugClass) ? MPR_ERR_CANT_INITIALIZE : 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemLog.c b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemLog.c new file mode 100644 index 0000000000..66467f8fcf --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemLog.c @@ -0,0 +1,163 @@ +/* + * @file ejsSystemLog.c + * @brief System.Log class for the EJS Object Model + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +/*********************************** Usage ************************************/ +/* + * System.Log.setLog(path); + * System.Log.enable; + */ +/******************************************************************************/ + +static void logHandler(MPR_LOC_DEC(ctx, loc), int flags, int level, + const char *msg) +{ + MprApp *app; + char *buf; + int len; + + app = mprGetApp(ctx); + if (app->logFile == 0) { + return; + } + + if (flags & MPR_LOG_SRC) { + len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0, + "Log %d: %s\n", level, msg); + + } else if (flags & MPR_ERROR_SRC) { + len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0, + "Error: %s\n", msg); + + } else if (flags & MPR_FATAL_SRC) { + len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0, + "Fatal: %s\n", msg); + + } else if (flags & MPR_ASSERT_SRC) { +#if BLD_FEATURE_ALLOC_LEAK_TRACK + len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0, + "Assertion %s, failed at %s\n", + msg, loc); +#else + len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0, + "Assertion %s, failed\n", msg); +#endif + + } else if (flags & MPR_RAW) { + /* OPT */ + len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0, + "%s", msg); + + } else { + return; + } + + mprPuts(app->logFile, buf, len); + + mprFree(buf); +} + +/******************************************************************************/ +/************************************ Methods *********************************/ +/******************************************************************************/ +/* + * function int setLog(string path) + */ + +static int setLog(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + const char *path; + MprFile *file; + MprApp *app; + + if (argc != 1 || !ejsVarIsString(argv[0])) { + ejsArgError(ejs, "Usage: setLog(path)"); + return -1; + } + + app = mprGetApp(ejs); + + /* + * Ignore errors if we can't create the log file. + * Use the app context so this will live longer than the interpreter + * MOB -- this leaks files. + */ + path = argv[0]->string; + file = mprOpen(app, path, O_CREAT | O_TRUNC | O_WRONLY, 0664); + if (file) { + app->logFile = file; + mprSetLogHandler(ejs, logHandler); + } + mprLog(ejs, 0, "Test log"); + + return 0; +} + +/******************************************************************************/ +#if UNUSED + +static int enableSetAccessor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + if (argc != 1) { + ejsArgError(ejs, "Usage: set(value)"); + return -1; + } + ejsSetProperty(ejs, thisObj, "_enabled", argv[0]); + return 0; +} + +/******************************************************************************/ + +static int enableGetAccessor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValue(ejs, ejsGetPropertyAsVar(ejs, thisObj, "_enabled")); + return 0; +} + +#endif +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineLogClass(Ejs *ejs) +{ + EjsVar *logClass; + + logClass = ejsDefineClass(ejs, "System.Log", "Object", 0); + if (logClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + ejsDefineCMethod(ejs, logClass, "setLog", setLog, EJS_NO_LOCAL); + +#if UNUSED + EjsProperty *pp; + ejsDefineCAccessors(ejs, logClass, "enable", enableSetAccessor, + enableGetAccessor, EJS_NO_LOCAL); + + pp = ejsSetPropertyToBoolean(ejs, logClass, "_enabled", 0); + ejsMakePropertyEnumerable(pp, 0); +#endif + + return ejsObjHasErrors(logClass) ? MPR_ERR_CANT_INITIALIZE : 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemMemory.c b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemMemory.c new file mode 100755 index 0000000000..d10787b1b4 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/ejs/system/ejsSystemMemory.c @@ -0,0 +1,174 @@ +/* + * @file ejsSystemMemory.c + * @brief System.Memory class + */ +/********************************** Copyright *********************************/ +/* + * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved. + */ +/********************************** Includes **********************************/ + +#include "ejs.h" + +/****************************** Forward Declarations***************************/ + +static uint getUsedMemory(Ejs *ejs); + +/******************************************************************************/ +/*********************************** Methods *********************************/ +/******************************************************************************/ + +static int getUsedMemoryProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToInteger(ejs, getUsedMemory(ejs)); + return 0; +} + +/******************************************************************************/ + +static int getUsedStackProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv) +{ + ejsSetReturnValueToInteger(ejs, mprStackSize(ejs)); + return 0; +} + +/******************************************************************************/ +/* + * Public function + */ + +uint ejsGetAvailableMemory(Ejs *ejs) +{ + EjsVar *memoryClass; + uint ram; + + memoryClass = ejsGetClass(ejs, 0, "System.Memory"); + + ram = ejsGetPropertyAsInteger(ejs, memoryClass, "ram"); + return ram - getUsedMemory(ejs); +} + +/******************************************************************************/ + +static int getAvailableMemoryProc(Ejs *ejs, EjsVar *thisObj, int argc, + EjsVar **argv) +{ + EjsVar *memoryClass; + uint ram; + + memoryClass = ejsGetClass(ejs, 0, "System.Memory"); + + ram = ejsGetPropertyAsInteger(ejs, memoryClass, "ram"); +#if BREW + ejsSetReturnValueToInteger(ejs, ram - getUsedMemory(ejs)); +#else + ejsSetReturnValueToInteger(ejs, 0); +#endif + return 0; +} + +/******************************************************************************/ + +static uint getUsedMemory(Ejs *ejs) +{ +#if BREW + MprApp *app; + IHeap *heap; + uint memInUse; + void *ptr; + + app = mprGetApp(ejs); + ptr = (void*) &heap; + if (ISHELL_CreateInstance(app->shell, AEECLSID_HEAP, (void**) ptr) + == SUCCESS) { + memInUse = IHEAP_GetMemStats(heap); + IHEAP_Release(heap); + } else { + memInUse = 0; + } + + return memInUse; +#else + return 0; +#endif +} + +/******************************************************************************/ +/******************************** Initialization ******************************/ +/******************************************************************************/ + +int ejsDefineMemoryClass(Ejs *ejs) +{ + EjsVar *memoryClass; + uint used; + +#if BREW + MprApp *app; + AEEDeviceInfo *info; + + /* + * Get needed information for class properties. + */ + info = mprAllocType(ejs, AEEDeviceInfo); + if (info == 0) { + return MPR_ERR_CANT_ALLOCATE; + } + info->wStructSize = sizeof(AEEDeviceInfo); + app = mprGetApp(ejs); + ISHELL_GetDeviceInfo(app->shell, info); + used = getUsedMemory(ejs); +#else + used = 0; +#endif + + /* + * Create the class + */ + memoryClass = ejsDefineClass(ejs, "System.Memory", "Object", 0); + if (memoryClass == 0) { + return MPR_ERR_CANT_INITIALIZE; + } + + /* + * Define the class methods + * MOB -- change to accessors + */ + ejsDefineCMethod(ejs, memoryClass, "getUsedStack", getUsedStackProc, + EJS_NO_LOCAL); + ejsDefineCMethod(ejs, memoryClass, "getUsedMemory", getUsedMemoryProc, + EJS_NO_LOCAL); + ejsDefineCMethod(ejs, memoryClass, "getAvailableMemory", + getAvailableMemoryProc, EJS_NO_LOCAL); + + /* + * Define properties + */ +#if BREW + ejsSetPropertyToInteger(ejs, memoryClass, "ram", info->dwRAM); + +#if UNUSED + /* MOB -- delete this */ + ejsSetPropertyToInteger(ejs, memoryClass, "available", + info->dwRAM - used); +#endif +#endif + +#if UNUSED + ejsSetPropertyToInteger(ejs, memoryClass, "used", used); + ejsSetPropertyToInteger(ejs, memoryClass, "flash", 0); +#endif + + return ejsObjHasErrors(memoryClass) ? MPR_ERR_CANT_INITIALIZE : 0; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/exml/Makefile b/source4/lib/appweb/ejs-2.0/exml/Makefile new file mode 100644 index 0000000000..663e65ed53 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/exml/Makefile @@ -0,0 +1,42 @@ +# +# Makefile for Embedded XML (EXML) +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +# +# EXML may be linked into shared handlers so we must build the objects both +# shared and static. +# +COMPILE := *.c +EXPORT_OBJECTS := yes +MAKE_IFLAGS := -I../mpr + +include make.dep + +ifeq ($(BLD_FEATURE_TEST),1) +POST_DIRS := test +endif + +TARGETS += $(BLD_BIN_DIR)/libexml$(BLD_LIB) + +ifeq ($(BLD_FEATURE_XML),1) +compileExtra: $(TARGETS) +endif + +# MOB -- remove when FEATURE_XML is defined +compileExtra: $(TARGETS) + +$(BLD_BIN_DIR)/libexml$(BLD_LIB): $(FILES) + @bld --library $(BLD_BIN_DIR)/libexml \ + --objectsDir $(BLD_OBJ_DIR) --objectList files --libs mpr + +cleanExtra: + @echo "rm -f $(TARGETS)" | $(BLDOUT) + @rm -f $(TARGETS) + @rm -f $(BLD_BIN_DIR)/libexml.* + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/exml/exml.h b/source4/lib/appweb/ejs-2.0/exml/exml.h new file mode 100644 index 0000000000..44c50a56b9 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/exml/exml.h @@ -0,0 +1,94 @@ +/* + * exml.h -- Embedded Xml Parser header + * + * Copyright (c) Mbedthis Software, LLC, 2003-2003. All Rights Reserved. -- MOB + */ + +#ifndef _h_EXML +#define _h_EXML 1 + +/******************************** Description *********************************/ + +#include "mpr.h" + +/********************************** Defines ***********************************/ + +#if BLD_FEATURE_SQUEEZE + #define EXML_BUFSIZE 512 /* Read buffer size */ +#else + #define EXML_BUFSIZE 1024 /* Read buffer size */ +#endif + +/* + * XML parser states. The states that are passed to the user handler have + * "U" appended to the comment. The error states (ERR and EOF) must be + * negative. + */ +#define EXML_ERR -1 /* Error */ +#define EXML_EOF -2 /* End of input */ +#define EXML_BEGIN 1 /* Before next tag */ +#define EXML_AFTER_LS 2 /* Seen "<" */ +#define EXML_COMMENT 3 /* Seen "<!--" (usr) U */ +#define EXML_NEW_ELT 4 /* Seen "<tag" (usr) U */ +#define EXML_ATT_NAME 5 /* Seen "<tag att" */ +#define EXML_ATT_EQ 6 /* Seen "<tag att" = */ +#define EXML_NEW_ATT 7 /* Seen "<tag att = "val" U */ +#define EXML_SOLO_ELT_DEFINED 8 /* Seen "<tag../>" U */ +#define EXML_ELT_DEFINED 9 /* Seen "<tag...>" U */ +#define EXML_ELT_DATA 10 /* Seen "<tag>....<" U */ +#define EXML_END_ELT 11 /* Seen "<tag>....</tag>" U */ +#define EXML_PI 12 /* Seen "<?processingInst" U */ +#define EXML_CDATA 13 /* Seen "<![CDATA[" U */ + +/* + * Lex tokens + */ +typedef enum ExmlToken { + TOKEN_ERR, + TOKEN_TOO_BIG, /* Token is too big */ + TOKEN_CDATA, + TOKEN_COMMENT, + TOKEN_INSTRUCTIONS, + TOKEN_LS, /* "<" -- Opening a tag */ + TOKEN_LS_SLASH, /* "</" -- Closing a tag */ + TOKEN_GR, /* ">" -- End of an open tag */ + TOKEN_SLASH_GR, /* "/>" -- End of a solo tag */ + TOKEN_TEXT, + TOKEN_EQ, + TOKEN_EOF, + TOKEN_SPACE, +} ExmlToken; + +struct Exml; +typedef int (*ExmlHandler)(struct Exml *xp, int state, + const char *tagName, const char* attName, const char* value); +typedef int (*ExmlInputStream)(struct Exml *xp, void *arg, char *buf, int size); + +/* + * Per XML session structure + */ +typedef struct Exml { + ExmlHandler handler; /* Callback function */ + ExmlInputStream readFn; /* Read data function */ + MprBuf *inBuf; /* Input data queue */ + MprBuf *tokBuf; /* Parsed token buffer */ + int quoteChar; /* XdbAtt quote char */ + int lineNumber; /* Current line no for debug */ + void *parseArg; /* Arg passed to exmlParse() */ + void *inputArg; /* Arg passed to exmlSetInputStream() */ + char *errMsg; /* Error message text */ +} Exml; + +extern Exml *exmlOpen(MprCtx ctx, int initialSize, int maxSize); +extern void exmlClose(Exml *xp); +extern void exmlSetParserHandler(Exml *xp, ExmlHandler h); +extern void exmlSetInputStream(Exml *xp, ExmlInputStream s, void *arg); +extern int exmlParse(Exml *xp); +extern void exmlSetParseArg(Exml *xp, void *parseArg); +extern void *exmlGetParseArg(Exml *xp); +extern const char *exmlGetErrorMsg(Exml *xp); +extern int exmlGetLineNumber(Exml *xp); + +/******************************************************************************/ + +#endif /* _h_EXML */ diff --git a/source4/lib/appweb/ejs-2.0/exml/exmlParser.c b/source4/lib/appweb/ejs-2.0/exml/exmlParser.c new file mode 100644 index 0000000000..14871411a6 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/exml/exmlParser.c @@ -0,0 +1,752 @@ +/* + * exml.c -- A simple SAX style XML parser + */ + +/********************************* Description ********************************/ +/* + * This is a recursive descent parser for XML text files. It is a one-pass + * simple parser that invokes a user supplied callback for key tokens in the + * XML file. The user supplies a read function so that XML files can be parsed + * from disk or in-memory. + */ +/********************************** Includes **********************************/ + +#include "exml.h" + +/****************************** Forward Declarations **************************/ +/* MOB -- FIX */ +#if BLD_FEATURE_EXML || 1 + +static int parseNext(Exml *xp, int state); +static ExmlToken getToken(Exml *xp, int state); +static int getNextChar(Exml *xp); +static int scanFor(Exml *xp, char *str); +static int putLastChar(Exml *xp, int c); +static void error(Exml *xp, char *fmt, ...); +static void trimToken(Exml *xp); + +/************************************ Code ************************************/ + +Exml *exmlOpen(MprCtx ctx, int initialSize, int maxSize) +{ + Exml *xp; + + xp = mprAllocTypeZeroed(ctx, Exml); + + xp->inBuf = mprCreateBuf(xp, EXML_BUFSIZE, EXML_BUFSIZE); + xp->tokBuf = mprCreateBuf(xp, initialSize, maxSize); + + return xp; +} + +/******************************************************************************/ + +void exmlClose(Exml *xp) +{ + mprAssert(xp); + + mprFree(xp); +} + +/******************************************************************************/ + +void exmlSetParserHandler(Exml *xp, ExmlHandler h) +{ + mprAssert(xp); + + xp->handler = h; +} + +/******************************************************************************/ + +void exmlSetInputStream(Exml *xp, ExmlInputStream s, void *arg) +{ + mprAssert(xp); + + xp->readFn = s; + xp->inputArg = arg; +} + +/******************************************************************************/ +/* + * Set the parse arg + */ + +void exmlSetParseArg(Exml *xp, void *parseArg) +{ + mprAssert(xp); + + xp->parseArg = parseArg; +} + +/******************************************************************************/ +/* + * Set the parse arg + */ + +void *exmlGetParseArg(Exml *xp) +{ + mprAssert(xp); + + return xp->parseArg; +} + +/******************************************************************************/ +/* + * Parse an XML file. Return 0 for success, -1 for error. + */ + +int exmlParse(Exml *xp) +{ + mprAssert(xp); + + return parseNext(xp, EXML_BEGIN); +} + +/******************************************************************************/ +/* + * XML parser. This is a recursive descent parser. Return -1 for errors, 0 for + * EOF and 1 if there is still more data to parse. + */ + +static int parseNext(Exml *xp, int state) +{ + ExmlHandler handler; + ExmlToken token; + MprBuf *tokBuf; + char *tname, *aname; + int rc; + + mprAssert(state >= 0); + + tokBuf = xp->tokBuf; + handler = xp->handler; + tname = aname = 0; + rc = 0; + + /* + * In this parse loop, the state is never assigned EOF or ERR. In + * such cases we always return EOF or ERR. + */ + while (1) { + + token = getToken(xp, state); + + if (token == TOKEN_TOO_BIG) { + error(xp, "XML token is too big"); + goto err; + } + + switch (state) { + case EXML_BEGIN: /* ------------------------------------------ */ + /* + * Expect to get an element, comment or processing instruction + */ + switch (token) { + case TOKEN_EOF: + goto exit; + + case TOKEN_LS: + /* + * Recurse to handle the new element, comment etc. + */ + rc = parseNext(xp, EXML_AFTER_LS); + if (rc < 0) { + goto exit; + } + break; + + default: + error(xp, "Syntax error"); + goto err; + } + break; + + case EXML_AFTER_LS: /* ------------------------------------------ */ + switch (token) { + case TOKEN_COMMENT: + state = EXML_COMMENT; + rc = (*handler)(xp, state, "!--", 0, mprGetBufStart(tokBuf)); + if (rc < 0) { + goto err; + } + rc = 1; + goto exit; + + case TOKEN_CDATA: + state = EXML_CDATA; + rc = (*handler)(xp, state, "!--", 0, mprGetBufStart(tokBuf)); + if (rc < 0) { + goto err; + } + rc = 1; + goto exit; + + case TOKEN_INSTRUCTIONS: + /* Just ignore processing instructions */ + rc = 1; + goto exit; + + case TOKEN_TEXT: + state = EXML_NEW_ELT; + tname = mprStrdup(xp, mprGetBufStart(tokBuf)); + if (tname == 0) { + rc = MPR_ERR_MEMORY; + goto exit; + } + rc = (*handler)(xp, state, tname, 0, 0); + if (rc < 0) { + goto err; + } + break; + + default: + error(xp, "Syntax error"); + goto err; + } + break; + + case EXML_NEW_ELT: /* ------------------------------------------ */ + /* + * We have seen the opening "<element" for a new element and have + * not yet seen the terminating ">" of the opening element. + */ + switch (token) { + case TOKEN_TEXT: + /* + * Must be an attribute name + */ + aname = mprStrdup(xp, mprGetBufStart(tokBuf)); + token = getToken(xp, state); + if (token != TOKEN_EQ) { + error(xp, "Missing assignment for attribute \"%s\"", aname); + goto err; + } + + token = getToken(xp, state); + if (token != TOKEN_TEXT) { + error(xp, "Missing value for attribute \"%s\"", aname); + goto err; + } + state = EXML_NEW_ATT; + rc = (*handler)(xp, state, tname, aname, + mprGetBufStart(tokBuf)); + if (rc < 0) { + goto err; + } + state = EXML_NEW_ELT; + break; + + case TOKEN_GR: + /* + * This is ">" the termination of the opening element + */ + if (*tname == '\0') { + error(xp, "Missing element name"); + goto err; + } + + /* + * Tell the user that the opening element is now complete + */ + state = EXML_ELT_DEFINED; + rc = (*handler)(xp, state, tname, 0, 0); + if (rc < 0) { + goto err; + } + state = EXML_ELT_DATA; + break; + + case TOKEN_SLASH_GR: + /* + * If we see a "/>" then this is a solo element + */ + if (*tname == '\0') { + error(xp, "Missing element name"); + goto err; + } + state = EXML_SOLO_ELT_DEFINED; + rc = (*handler)(xp, state, tname, 0, 0); + if (rc < 0) { + goto err; + } + rc = 1; + goto exit; + + default: + error(xp, "Syntax error"); + goto err; + } + break; + + case EXML_ELT_DATA: /* -------------------------------------- */ + /* + * We have seen the full opening element "<name ...>" and now + * await data or another element. + */ + if (token == TOKEN_LS) { + /* + * Recurse to handle the new element, comment etc. + */ + rc = parseNext(xp, EXML_AFTER_LS); + if (rc < 0) { + goto exit; + } + break; + + } else if (token == TOKEN_LS_SLASH) { + state = EXML_END_ELT; + break; + + } else if (token != TOKEN_TEXT) { + goto err; + } + if (mprGetBufLength(tokBuf) > 0) { + /* + * Pass the data between the element to the user + */ + rc = (*handler)(xp, state, tname, 0, mprGetBufStart(tokBuf)); + if (rc < 0) { + goto err; + } + } + break; + + case EXML_END_ELT: /* -------------------------------------- */ + if (token != TOKEN_TEXT) { + error(xp, "Missing closing element name for \"%s\"", tname); + goto err; + } + /* + * The closing element name must match the opening element name + */ + if (strcmp(tname, mprGetBufStart(tokBuf)) != 0) { + error(xp, + "Closing element name \"%s\" does not match on line %d" + "opening name \"%s\"", + mprGetBufStart(tokBuf), xp->lineNumber, tname); + goto err; + } + rc = (*handler)(xp, state, tname, 0, 0); + if (rc < 0) { + goto err; + } + if (getToken(xp, state) != TOKEN_GR) { + error(xp, "Syntax error"); + goto err; + } + return 1; + + case EXML_EOF: /* ---------------------------------------------- */ + goto exit; + + case EXML_ERR: /* ---------------------------------------------- */ + default: + goto err; + } + } + mprAssert(0); + +err: + rc = -1; + +exit: + mprFree(tname); + mprFree(aname); + + return rc; +} + +/******************************************************************************/ +/* + * Lexical analyser for XML. Return the next token reading input as required. + * It uses a one token look ahead and push back mechanism (LAR1 parser). + * Text token identifiers are left in the tokBuf parser buffer on exit. + * This Lex has special cases for the states EXML_ELT_DATA where we + * have an optimized read of element data, and EXML_AFTER_LS where we + * distinguish between element names, processing instructions and comments. + */ + +static ExmlToken getToken(Exml *xp, int state) +{ + MprBuf *tokBuf, *inBuf; + uchar *cp; + int c, rc; + + tokBuf = xp->tokBuf; + inBuf = xp->inBuf; + + mprAssert(state >= 0); + + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + mprFlushBuf(tokBuf); + + /* + * Special case parsing for names and for element data. We do this for + * performance so we can return to the caller the largest token possible + */ + if (state == EXML_ELT_DATA) { + /* + * Read all the data up to the start of the closing element "<" or the + * start of a sub-element. + */ +#if UNUSED + while (isspace(c)) { + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + } +#endif + if (c == '<') { + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + if (c == '/') { + return TOKEN_LS_SLASH; + } + putLastChar(xp, c); + return TOKEN_LS; + } + do { + if (mprPutCharToBuf(tokBuf, c) < 0) { + return TOKEN_TOO_BIG; + } + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + } while (c != '<'); + + /* + * Put back the last look-ahead character + */ + putLastChar(xp, c); + + /* + * If all white space, then zero the token buffer + */ + for (cp = tokBuf->start; *cp; cp++) { + if (!isspace(*cp)) { + return TOKEN_TEXT; + } + } + mprFlushBuf(tokBuf); + return TOKEN_TEXT; + } + + while (1) { + switch (c) { + case ' ': + case '\n': + case '\t': + case '\r': + break; + + case '<': + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + if (c == '/') { + return TOKEN_LS_SLASH; + } + putLastChar(xp, c); + return TOKEN_LS; + + case '=': + return TOKEN_EQ; + + case '>': + return TOKEN_GR; + + case '/': + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + if (c == '>') { + return TOKEN_SLASH_GR; + } + return TOKEN_ERR; + + case '\"': + case '\'': + xp->quoteChar = c; + /* Fall through */ + + default: + /* + * We handle element names, attribute names and attribute values + * here. We do NOT handle data between elements here. Read the + * token. Stop on white space or a closing element ">" + */ + if (xp->quoteChar) { + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + while (c != xp->quoteChar) { + if (mprPutCharToBuf(tokBuf, c) < 0) { + return TOKEN_TOO_BIG; + } + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + } + xp->quoteChar = 0; + + } else { + while (!isspace(c) && c != '>' && c != '/' && c != '=') { + if (mprPutCharToBuf(tokBuf, c) < 0) { + return TOKEN_TOO_BIG; + } + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + } + putLastChar(xp, c); + } + if (mprGetBufLength(tokBuf) <= 0) { + return TOKEN_ERR; + } + mprAddNullToBuf(tokBuf); + + if (state == EXML_AFTER_LS) { + /* + * If we are just inside an element "<", then analyze what we + * have to see if we have an element name, instruction or + * comment. Tokbuf will hold "?" for instructions or "!--" + * for comments. + */ + if (mprLookAtNextCharInBuf(tokBuf) == '?') { + /* Just ignore processing instructions */ + rc = scanFor(xp, "?>"); + if (rc < 0) { + return TOKEN_TOO_BIG; + } else if (rc == 0) { + return TOKEN_ERR; + } + return TOKEN_INSTRUCTIONS; + + } else if (mprLookAtNextCharInBuf(tokBuf) == '!') { + /* + * First discard the comment leadin "!--" and eat leading + * white space. + */ + if (strcmp((char*) tokBuf->start, "![CDATA[") == 0) { + mprFlushBuf(tokBuf); +#if UNUSED + c = mprLookAtNextCharInBuf(inBuf); + while (isspace(c)) { + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + c = mprLookAtNextCharInBuf(inBuf); + } +#endif + rc = scanFor(xp, "]]>"); + if (rc < 0) { + return TOKEN_TOO_BIG; + } else if (rc == 0) { + return TOKEN_ERR; + } + return TOKEN_CDATA; + + } else { + mprFlushBuf(tokBuf); +#if UNUSED + c = mprLookAtNextCharInBuf(inBuf); + while (isspace(c)) { + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + c = mprLookAtNextCharInBuf(inBuf); + } +#endif + rc = scanFor(xp, "-->"); + if (rc < 0) { + return TOKEN_TOO_BIG; + } else if (rc == 0) { + return TOKEN_ERR; + } + return TOKEN_COMMENT; + } + } + } + trimToken(xp); + return TOKEN_TEXT; + } + if ((c = getNextChar(xp)) < 0) { + return TOKEN_EOF; + } + } + + /* Should never get here */ + mprAssert(0); + return TOKEN_ERR; +} + +/******************************************************************************/ +/* + * Scan for a pattern. Eat and discard input up to the pattern. Return 1 if + * the pattern was found, return 0 if not found. Return < 0 on errors. + */ + +static int scanFor(Exml *xp, char *str) +{ + MprBuf *tokBuf; + char *cp; + int c; + + mprAssert(str); + + tokBuf = xp->tokBuf; + + while (1) { + for (cp = str; *cp; cp++) { + if ((c = getNextChar(xp)) < 0) { + return 0; + } + if (tokBuf) { + if (mprPutCharToBuf(tokBuf, c) < 0) { + return -1; + } + } + if (c != *cp) { + break; + } + } + if (*cp == '\0') { + /* + * Remove the pattern from the tokBuf + */ + if (tokBuf) { + mprAdjustBufEnd(tokBuf, -(int) strlen(str)); + trimToken(xp); + } + return 1; + } + } +} + +/******************************************************************************/ +/* + * Get another character. We read and buffer blocks of data if we need more + * data to parse. + */ + +static int getNextChar(Exml *xp) +{ + MprBuf *inBuf; + char c; + int l; + + inBuf = xp->inBuf; + if (mprGetBufLength(inBuf) <= 0) { + /* + * Flush to reset the servp/endp pointers to the start of the buffer + * so we can do a maximal read + */ + mprFlushBuf(inBuf); + l = (xp->readFn)(xp, xp->inputArg, mprGetBufStart(inBuf), + mprGetBufLinearSpace(inBuf)); + if (l <= 0) { + return -1; + } + mprAdjustBufEnd(inBuf, l); + } + c = mprGetCharFromBuf(inBuf); + + if (c == '\n') { + xp->lineNumber++; + } + return c; +} + +/******************************************************************************/ +/* + * Put back a character in the input buffer + */ + +static int putLastChar(Exml *xp, int c) +{ + if (mprInsertCharToBuf(xp->inBuf, (char) c) < 0) { + mprAssert(0); + return -1; + } + if (c == '\n') { + xp->lineNumber--; + } + return 0; +} + +/******************************************************************************/ +/* + * Output a parse message + */ + +static void error(Exml *xp, char *fmt, ...) +{ + va_list args; + char *buf; + + mprAssert(fmt); + + va_start(args, fmt); + mprAllocVsprintf(MPR_LOC_ARGS(xp), &buf, MPR_MAX_STRING, fmt, args); + va_end(args); + + /* + * MOB need to add the failing line text and a pointer to which column + */ + mprFree(xp->errMsg); + mprAllocSprintf(MPR_LOC_ARGS(xp), &xp->errMsg, MPR_MAX_STRING, + "XML error: %s\nAt line %d\n", buf, xp->lineNumber); + + mprFree(buf); +} + +/******************************************************************************/ +/* + * Remove trailing whitespace in a token and ensure it is terminated with + * a NULL for easy parsing + */ + +static void trimToken(Exml *xp) +{ + while (isspace(mprLookAtLastCharInBuf(xp->tokBuf))) { + mprAdjustBufEnd(xp->tokBuf, -1); + } + mprAddNullToBuf(xp->tokBuf); +} + +/******************************************************************************/ + +const char *exmlGetErrorMsg(Exml *xp) +{ + if (xp->errMsg == 0) { + return ""; + } + return xp->errMsg; +} + +/******************************************************************************/ + +int exmlGetLineNumber(Exml *xp) +{ + return xp->lineNumber; +} + +/******************************************************************************/ +#else + +void exmlParserDummy() {} +#endif /* BLD_FEATURE_EXML */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/exml/files b/source4/lib/appweb/ejs-2.0/exml/files new file mode 100644 index 0000000000..0f10ea44dd --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/exml/files @@ -0,0 +1 @@ +${BLD_OBJ_DIR}/exmlParser${BLD_OBJ} diff --git a/source4/lib/appweb/ejs-2.0/mpr/Makefile b/source4/lib/appweb/ejs-2.0/mpr/Makefile new file mode 100644 index 0000000000..6dd0e45d9e --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/Makefile @@ -0,0 +1,41 @@ +# +# Makefile for the Mbedthis Portable Runtime (MPR) library +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +COMPILE := *.c +EXPORT_OBJECTS := yes + +include make.dep + +ifeq ($(BLD_HOST_UNIX),1) +PRE_DIRS = UNIX +else +PRE_DIRS = $(BLD_HOST_OS) +endif + +POST_DIRS = package + +TARGETS += $(BLD_BIN_DIR)/libmpr$(BLD_LIB) + +compileExtra: $(TARGETS) + +# +# Build the mpr libraries +# +$(BLD_BIN_DIR)/libmpr$(BLD_LIB): files \ + $(shell BLD_OBJ=$(BLD_OBJ) \; BLD_OBJ_DIR=$(BLD_OBJ_DIR) \; \ + eval echo `cat files`) + @bld --library $(BLD_BIN_DIR)/libmpr \ + --objectsDir $(BLD_OBJ_DIR) --objectList files + +cleanExtra: + @echo "rm -f $(TARGETS)" | $(BLDOUT) + @rm -f $(TARGETS) + @rm -f $(BLD_BIN_DIR)/libmpr.* + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/mpr/UNIX/Makefile b/source4/lib/appweb/ejs-2.0/mpr/UNIX/Makefile new file mode 100644 index 0000000000..5259b1e3a0 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/UNIX/Makefile @@ -0,0 +1,16 @@ +# +# Makefile for the Mbedthis Portable Runtime (MPR) library for UNIX +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +COMPILE := *.c +EXPORT_OBJECTS := yes +MAKE_IFLAGS := -I.. + +include make.dep + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/mpr/UNIX/mprFile.c b/source4/lib/appweb/ejs-2.0/mpr/UNIX/mprFile.c new file mode 100644 index 0000000000..f647f1ed56 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/UNIX/mprFile.c @@ -0,0 +1,86 @@ +/** + * @file mprFile.c + * @brief File services for Unix + * @overview + * @remarks + * See mprGenFile.c for other file services. + */ + +/******************************************************************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ + +#include "mpr.h" + +/************************************ Code ************************************/ + +int mprGetFileInfo(MprCtx ctx, const char *path, MprFileInfo *info) +{ + struct stat s; + + mprAssert(path); + mprAssert(info); + + if (stat(path, &s) < 0) { + return -1; + } + + info->size = s.st_size; + info->ctime = s.st_ctime; + info->mtime = s.st_mtime; + info->inode = s.st_ino; + info->isDir = (s.st_mode & S_IFDIR) != 0; + info->isReg = (s.st_mode & S_IFREG) != 0; + + if (strcmp(path, "/dev/null") == 0) { + info->isReg = 0; + } + + return 0; +} + +/******************************************************************************/ + +int mprMakeDir(MprCtx ctx, const char *path, int perms) +{ + return mkdir(path, perms); +} + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/UNIX/mprPlatform.c b/source4/lib/appweb/ejs-2.0/mpr/UNIX/mprPlatform.c new file mode 100644 index 0000000000..2c7fbf8a00 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/UNIX/mprPlatform.c @@ -0,0 +1,218 @@ +/** + * @file mprPlatform.c + * @brief Cross platform routines + * @overview This module provides low level cross platform routines. + * @remarks Most routines in this file are not thread-safe. It is the callers + * responsibility to perform all thread synchronization. + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ +/* + * We need to use the underlying str(cpy) routines to implement our safe + * alternatives + */ +#if !DOXYGEN +#define UNSAFE_FUNCTIONS_OK 1 +#endif + +#include "mpr.h" + +/************************************ Code ************************************/ + +char *mprInetToStr(char *buffer, int bufsize, const struct in_addr in) +{ +#if HAVE_NTOA_R + inet_ntoa_r(in, buffer, bufsize); +#else + uchar *cp; + /* FUTURE -- this is not portable */ + cp = (uchar*) ∈ + mprSprintf(buffer, bufsize, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]); +#endif + return buffer; +} + +/******************************************************************************/ + +void mprSetShell(MprCtx ctx, void *shell) +{ +} + +/******************************************************************************/ + +void *mprGetShell(MprCtx ctx) +{ + return 0; +} + +/******************************************************************************/ +/* + * Sleep. Period given in milliseconds. + */ + +void mprSleep(MprCtx ctx, int milliseconds) +{ + struct timespec timeout; + int rc; + + mprAssert(milliseconds >= 0); + timeout.tv_sec = milliseconds / 1000; + timeout.tv_nsec = (milliseconds % 1000) * 1000000; + do { + rc = nanosleep(&timeout, 0); + } while (rc < 0 && errno == EINTR); +} + +/******************************************************************************/ +/* + * Make intervening directories + */ + +int mprMakeDirPath(MprCtx ctx, const char *path) +{ + char dir[MPR_MAX_PATH], buf[MPR_MAX_PATH]; + char *dirSep; + char *next, *tok; + + dir[0] = '\0'; + dirSep = "/\\"; + + if (path == 0 || *path == '\0') { + return MPR_ERR_BAD_ARGS; + } + + mprStrcpy(buf, sizeof(buf), path); + next = mprStrTok(buf, dirSep, &tok); + if (*buf == '/') { + dir[0] = '/'; + } + while (next != NULL) { + if (strcmp(next, ".") == 0 ) { + next = mprStrTok(NULL, dirSep, &tok); + continue; + } + strcat(dir, next); + if (access(dir, R_OK) != 0) { + if (mkdir(dir, 0666) < 0) { + return MPR_ERR_CANT_CREATE; + } + } + strcat(dir, "/"); + next = mprStrTok(NULL, dirSep, &tok); + } + return 0; +} + +/******************************************************************************/ +/* + * Get a fully qualified file name for the given path. Return with forward + * slashes always + */ + +char *mprGetFullPathName(char *buf, int buflen, const char *path) +{ + if (mprStrcpy(buf, buflen, path) < 0) { + mprAssert(0); + return 0; + } + return buf; +} + +/******************************************************************************/ +/* + * Replacement for gethostbyname that is multi-thread safe + */ + +struct hostent *mprGetHostByName(MprCtx ctx, const char *name) +{ + MprApp *app; + struct hostent *hp; + struct hostent *ip; + int count, i; + + hp = (struct hostent*) mprAlloc(ctx, sizeof(struct hostent)); + memset(hp, 0, sizeof(struct hostent)); + + app = mprGetApp(ctx); + + #undef gethostbyname + + mprGlobalLock(app); + ip = gethostbyname(name); + mprGlobalUnlock(app); + + if (ip == 0) { + return 0; + } + hp->h_addrtype = ip->h_addrtype; + hp->h_length = ip->h_length; + hp->h_name = mprStrdup(hp, ip->h_name); + hp->h_addr_list = 0; + hp->h_aliases = 0; + + for (count = 0; ip->h_addr_list[count] != 0; ) { + count++; + } + if (count > 0) { + count++; + hp->h_addr_list = mprAlloc(hp, count * sizeof(char*)); + for (i = 0; ip->h_addr_list[i] != 0; i++) { + memcpy(&hp->h_addr_list[i], &ip->h_addr_list[i], ip->h_length); + } + hp->h_addr_list[i] = 0; + } + + for (count = 0; ip->h_aliases[count] != 0; ) { + count++; + } + if (count > 0) { + count++; + hp->h_aliases = mprAlloc(hp, count * sizeof(char*)); + for (i = 0; ip->h_aliases[i] != 0; i++) { + hp->h_aliases[i] = mprStrdup(hp, ip->h_aliases[i]); + } + hp->h_aliases[i] = 0; + } + return hp; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/UNIX/mprTime.c b/source4/lib/appweb/ejs-2.0/mpr/UNIX/mprTime.c new file mode 100644 index 0000000000..0153c0622d --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/UNIX/mprTime.c @@ -0,0 +1,163 @@ +/** + * @file mprTime.c + * @brief Time handling for Unix + * @overview + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************* Includes ***********************************/ + +#include "mpr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#undef localtime +#undef localtime_r +#undef gmtime +#undef gmtime_r +#undef ctime +#undef ctime_r +#undef asctime +#undef asctime_r + +/******************************************************************************/ +/* + * Returns time in seconds and milliseconds. This is NOT time-of-day. + */ + +MprTime *mprGetTime(MprCtx ctx, MprTime *tp) +{ + struct timeval tv; + + if (gettimeofday(&tv, 0) < 0) { + mprAssert(0); + tp->sec = 0; + tp->msec = 0; + return tp; + } + tp->sec = tv.tv_sec; + tp->msec = tv.tv_usec / 1000; + return tp; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of localtime + */ + +struct tm *mprLocaltime(MprCtx ctx, struct tm *timep, time_t *now) +{ + localtime_r(now, timep); + + return timep; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of gmtime + */ + +struct tm *mprGmtime(MprCtx ctx, time_t *now, struct tm *timep) +{ + gmtime_r(now, timep); + + return timep; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of ctime + */ + +int mprCtime(MprCtx ctx, char *buf, int bufsize, const time_t *timer) +{ + char localBuf[80]; + char *cp; + int len; + + mprAssert(buf); + + mprGlobalLock(ctx); + + cp = ctime_r(timer, localBuf); + if ((int) strlen(cp) >= bufsize) { + mprStrcpy(buf, bufsize, "WONT FIT"); + mprAssert(0); + return MPR_ERR_WONT_FIT; + } + len = mprStrcpy(buf, bufsize, cp); + + if (buf[len - 1] == '\n') { + buf[len - 1] = '\0'; + } + + mprGlobalUnlock(ctx); + + return 0; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of asctime + */ + +int mprAsctime(MprCtx ctx, char *buf, int bufsize, const struct tm *timeptr) +{ + char *cp; + char localBuf[80]; + + cp = asctime_r(timeptr, localBuf); + if ((int) strlen(cp) >= bufsize) { + mprAssert(0); + return MPR_ERR_WONT_FIT; + } + mprStrcpy(buf, bufsize, cp); + + return strlen(buf); +} + +/******************************************************************************/ + +#ifdef __cplusplus +} +#endif + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/Makefile b/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/Makefile new file mode 100644 index 0000000000..f3a2394b6e --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/Makefile @@ -0,0 +1,16 @@ +# +# Makefile for the Mbedthis Portable Runtime (MPR) library for VXWORKS +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +COMPILE := *.c +EXPORT_OBJECTS := yes +MAKE_IFLAGS := -I.. + +include make.dep + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/mprFile.c b/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/mprFile.c new file mode 100644 index 0000000000..ae0b523faa --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/mprFile.c @@ -0,0 +1,85 @@ +/** + * @file mprUnixFile.c + * @brief File services for Unix + * @overview + * @remarks + */ + +/******************************************************************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ + +#include "mpr.h" + +/************************************ Code ************************************/ + +int mprGetFileInfo(MprCtx ctx, const char *path, MprFileInfo *info) +{ + struct stat s; + + mprAssert(path); + mprAssert(info); + + if (stat(path, &s) < 0) { + return -1; + } + + info->size = s.st_size; + info->ctime = s.st_ctime; + info->mtime = s.st_mtime; + info->inode = s.st_ino; + info->isDir = (s.st_mode & S_IFDIR) != 0; + info->isReg = (s.st_mode & S_IFREG) != 0; + + if (strcmp(path, "/dev/null") == 0) { + info->isReg = 0; + } + + return 0; +} + +/******************************************************************************/ + +int mprMakeDir(MprCtx ctx, const char *path, int perms) +{ + return mkdir(path, perms); +} + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/mprPlatform.c b/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/mprPlatform.c new file mode 100644 index 0000000000..29258dfe1c --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/mprPlatform.c @@ -0,0 +1,191 @@ +/** + * @file mprPlatform.c + * @brief Cross platform routines + * @overview This module provides low level cross platform routines. + * @remarks Most routines in this file are not thread-safe. It is the callers + * responsibility to perform all thread synchronization. + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ +/* + * We need to use the underlying str(cpy) routines to implement our safe + * alternatives + */ +#if !DOXYGEN +#define UNSAFE_FUNCTIONS_OK 1 +#endif + +#include "mpr.h" + +/************************************ Code ************************************/ + +char *mprInetToStr(char *buffer, int bufsize, const struct in_addr in) +{ +#if HAVE_NTOA_R + inet_ntoa_r(in, buffer, bufsize); +#else + uchar *cp; + /* FUTURE -- this is not portable */ + cp = (uchar*) ∈ + mprSprintf(buffer, bufsize, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]); +#endif + return buffer; +} + +/******************************************************************************/ + +void mprSetShell(MprCtx ctx, void *shell) +{ +} + +/******************************************************************************/ + +void *mprGetShell(MprCtx ctx) +{ + return 0; +} + +/******************************************************************************/ +/* + * Sleep. Period given in milliseconds. + */ + +void mprSleep(MprCtx ctx, int milliseconds) +{ + struct timeval timeout; + int rc; + + timeout.tv_sec = milliseconds / 1000; + timeout.tv_usec = (milliseconds % 1000) * 1000; + do { + rc = select(1, 0, 0, 0, &timeout); + } while (rc < 0 && errno == EINTR); +} + +/******************************************************************************/ +/* + * Make intervening directories + */ + +int mprMakeDirPath(MprCtx ctx, const char *path) +{ + char dir[MPR_MAX_PATH], buf[MPR_MAX_PATH]; + char *dirSep; + char *next, *tok; + + dir[0] = '\0'; + dirSep = "/\\"; + + if (path == 0 || *path == '\0') { + return MPR_ERR_BAD_ARGS; + } + + mprStrcpy(buf, sizeof(buf), path); + next = mprStrTok(buf, dirSep, &tok); + if (*buf == '/') { + dir[0] = '/'; + } + while (next != NULL) { + if (strcmp(next, ".") == 0 ) { + next = mprStrTok(NULL, dirSep, &tok); + continue; + } + strcat(dir, next); + if (access(dir, R_OK) != 0) { + if (mkdir(dir) < 0) { + return MPR_ERR_CANT_CREATE; + } + } + strcat(dir, "/"); + next = mprStrTok(NULL, dirSep, &tok); + } + return 0; +} + +/******************************************************************************/ +/* + * Get a fully qualified file name for the given path. Return with forward + * slashes always + */ + +char *mprGetFullPathName(char *buf, int buflen, const char *path) +{ + if (mprStrcpy(buf, buflen, path) < 0) { + mprAssert(0); + return 0; + } + return buf; +} + +/******************************************************************************/ +/* + * Replacement for gethostbyname that is multi-thread safe + */ + +struct hostent *mprGetHostByName(MprCtx ctx, const char *name) +{ + struct hostent *hp; + + hp = (struct hostent*) mprAlloc(ctx, sizeof(struct hostent)); + memset(hp, 0, sizeof(struct hostent)); + + struct in_addr inaddr; + inaddr.s_addr = (ulong) hostGetByName(name); + if (inaddr.s_addr < 0) { + mprAssert(0); + return 0; + } + hp->h_addrtype = AF_INET; + hp->h_length = sizeof(int); + hp->h_name = mprStrdup(name); + hp->h_addr_list = 0; + hp->h_aliases = 0; + + hp->h_addr_list = new char*[2]; + hp->h_addr_list[0] = (char *) mprAlloc(hp, sizeof(struct in_addr)); + memcpy(&hp->h_addr_list[0], &inaddr, hp->h_length); + hp->h_addr_list[1] = 0; + + return hp; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/mprTime.c b/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/mprTime.c new file mode 100755 index 0000000000..c9b7560f46 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/VXWORKS/mprTime.c @@ -0,0 +1,163 @@ +/** + * @file mprTime.c + * @brief Time handling for VxWorks + * @overview + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************* Includes ***********************************/ + +#include "mpr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#undef localtime +#undef localtime_r +#undef gmtime +#undef gmtime_r +#undef ctime +#undef ctime_r +#undef asctime +#undef asctime_r + +/******************************************************************************/ +/* + * Returns time in seconds and milliseconds. This is NOT time-of-day. + */ + +MprTime *mprGetTime(MprCtx ctx, MprTime *tp) +{ + struct timeval tv; + + if (gettimeofday(&tv, 0) < 0) { + mprAssert(0); + tp->sec = 0; + tp->msec = 0; + return tp; + } + tp->sec = tv.tv_sec; + tp->msec = tv.tv_usec / 1000; + return tp; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of localtime + */ + +struct tm *mprLocaltime(MprCtx ctx, struct tm *timep, time_t *now) +{ + localtime_r(now, timep); + + return timep; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of gmtime + */ + +struct tm *mprGmtime(MprCtx ctx, time_t *now, struct tm *timep) +{ + gmtime_r(now, timep); + + return timep; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of ctime + */ + +int mprCtime(MprCtx ctx, char *buf, int bufsize, const time_t *timer) +{ + char localBuf[80]; + char *cp; + int len; + + mprAssert(buf); + + mprGlobalLock(ctx); + + cp = ctime_r(timer, localBuf); + if ((int) strlen(cp) >= bufsize) { + mprStrcpy(buf, bufsize, "WONT FIT"); + mprAssert(0); + return MPR_ERR_WONT_FIT; + } + len = mprStrcpy(buf, bufsize, cp); + + if (buf[len - 1] == '\n') { + buf[len - 1] = '\0'; + } + + mprGlobalUnlock(ctx); + + return 0; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of asctime + */ + +int mprAsctime(MprCtx ctx, char *buf, int bufsize, const struct tm *timeptr) +{ + char *cp; + char localBuf[80]; + + cp = asctime_r(timeptr, localBuf); + if ((int) strlen(cp) >= bufsize) { + mprAssert(0); + return MPR_ERR_WONT_FIT; + } + mprStrcpy(buf, bufsize, cp); + + return strlen(buf); +} + +/******************************************************************************/ + +#ifdef __cplusplus +} +#endif + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/WIN/Makefile b/source4/lib/appweb/ejs-2.0/mpr/WIN/Makefile new file mode 100644 index 0000000000..84e30ff8f1 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/WIN/Makefile @@ -0,0 +1,16 @@ +# +# Makefile for the Mbedthis Portable Runtime (MPR) library for Windows +# +# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved. +# + +COMPILE := *.c +EXPORT_OBJECTS := yes +MAKE_IFLAGS := -I.. + +include make.dep + +## Local variables: +## tab-width: 4 +## End: +## vim: tw=78 sw=4 ts=4 diff --git a/source4/lib/appweb/ejs-2.0/mpr/WIN/mprFile.c b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprFile.c new file mode 100644 index 0000000000..9ac1669f3d --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprFile.c @@ -0,0 +1,123 @@ +/** + * @file mprWinFile.c + * @brief File services for Windows + * @overview + * @remarks + */ + +/******************************************************************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ + +#include "mpr.h" + +/************************************ Code ************************************/ + +int mprGetFileInfo(MprCtx ctx, const char *path, MprFileInfo *info) +{ + struct stat s; + + mprAssert(path); + mprAssert(info); + + if (stat(path, &s) < 0) { + return -1; + } + + info->size = s.st_size; + /* + * MOB -- these are time64_t. Loss of precision + */ + info->ctime = (uint) s.st_ctime; + info->mtime = (uint) s.st_mtime; + info->inode = s.st_ino; + info->isDir = (s.st_mode & S_IFDIR) != 0; + info->isReg = (s.st_mode & S_IFREG) != 0; + + /* + * Work hard on windows to determine if the file is a regular file. + * FUTURE -- OPT. Eliminate this CreateFile. + */ + if (info->isReg) { + long fileType, att; + + if ((att = GetFileAttributes(path)) == -1) { + return -1; + } + if (att & (FILE_ATTRIBUTE_REPARSE_POINT | + FILE_ATTRIBUTE_DIRECTORY | + FILE_ATTRIBUTE_ENCRYPTED | + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_OFFLINE)) { + /* + * Catch accesses to devices like CON, AUX, NUL, LPT etc + * att will be set to ENCRYPTED on Win9X and NT. + */ + info->isReg = 0; + } + if (info->isReg) { + HANDLE handle; + handle = CreateFile(path, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, + 0, OPEN_EXISTING, 0, 0); + if (handle == INVALID_HANDLE_VALUE) { + info->isReg = 0; + } else { + fileType = GetFileType(handle); + if (fileType == FILE_TYPE_CHAR || fileType == FILE_TYPE_PIPE) { + info->isReg = 0; + } + CloseHandle(handle); + } + } + } + if (strcmp(path, "nul") == 0) { + info->isReg = 0; + } + return 0; +} + +/******************************************************************************/ + +int mprMakeDir(MprCtx ctx, const char *path, int perms) +{ + return mkdir(path, perms); +} + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/WIN/mprPlatform.c b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprPlatform.c new file mode 100644 index 0000000000..65718694b1 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprPlatform.c @@ -0,0 +1,378 @@ +/** + * @file mprPlatform.c + * @brief Cross platform routines + * @overview This module provides low level cross platform routines. + * @remarks Most routines in this file are not thread-safe. It is the callers + * responsibility to perform all thread synchronization. + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ +/* + * We need to use the underlying str(cpy) routines to implement our safe + * alternatives + */ +#if !DOXYGEN +#define UNSAFE_FUNCTIONS_OK 1 +#endif + +#include "mpr.h" + +/**************************** Forward Declarations ****************************/ + +static const char *getHive(const char *keyPath, HKEY *hive); + +/************************************ Code ************************************/ + +char *mprInetToStr(char *buffer, int bufsize, const struct in_addr in) +{ +#if HAVE_NTOA_R + inet_ntoa_r(in, buffer, bufsize); +#else + uchar *cp; + cp = (uchar*) ∈ + mprSprintf(buffer, bufsize, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]); +#endif + return buffer; +} + +/******************************************************************************/ + +void mprSetShell(MprCtx ctx, void *shell) +{ +} + +/******************************************************************************/ + +void *mprGetShell(MprCtx ctx) +{ + return 0; +} + +/******************************************************************************/ +/* + * Sleep. Period given in milliseconds. + */ + +void mprSleep(MprCtx ctx, int milliseconds) +{ + Sleep(milliseconds); +} + +/******************************************************************************/ +/* + * Make intervening directories + */ + +int mprMakeDirPath(MprCtx ctx, const char *path) +{ + char dir[MPR_MAX_PATH], buf[MPR_MAX_PATH]; + char *dirSep; + char *next, *tok; + + dir[0] = '\0'; + dirSep = "/\\"; + + if (path == 0 || *path == '\0') { + return MPR_ERR_BAD_ARGS; + } + + mprStrcpy(buf, sizeof(buf), path); + next = mprStrTok(buf, dirSep, &tok); + if (*buf == '/') { + dir[0] = '/'; + } + while (next != NULL) { + if (strcmp(next, ".") == 0 ) { + next = mprStrTok(NULL, dirSep, &tok); + continue; + } + strcat(dir, next); + if (access(dir, R_OK) != 0) { + if (_mkdir(dir) < 0) { + return MPR_ERR_CANT_CREATE; + } + } + strcat(dir, "/"); + next = mprStrTok(NULL, dirSep, &tok); + } + return 0; +} + +/******************************************************************************/ +/* + * Get a fully qualified file name for the given path. Return with forward + * slashes always + */ + +char *mprGetFullPathName(char *buf, int buflen, const char *path) +{ +#if (WIN || NW || OS2) && !BLD_FEATURE_ROMFS + char *junk, *cp; + int rc; + + --buflen; + rc = GetFullPathName(path, buflen, buf, &junk); + for (cp = buf; *cp; cp++) { + if (*cp == '\\') { + *cp = '/'; + } + } + buf[buflen] = '\0'; +#else + if (mprStrcpy(buf, buflen, path) < 0) { + mprAssert(0); + return 0; + } +#endif + return buf; +} + +/******************************************************************************/ +/* + * Replacement for gethostbyname that is multi-thread safe + */ + +struct hostent *mprGetHostByName(MprCtx ctx, const char *name) +{ + MprApp *app; + struct hostent *hp; + struct hostent *ip; + int count, i; + + hp = (struct hostent*) mprAlloc(ctx, sizeof(struct hostent)); + memset(hp, 0, sizeof(struct hostent)); + + app = mprGetApp(ctx); + + #undef gethostbyname + + mprGlobalLock(app); + ip = gethostbyname(name); + mprGlobalUnlock(app); + + if (ip == 0) { + return 0; + } + hp->h_addrtype = ip->h_addrtype; + hp->h_length = ip->h_length; + hp->h_name = mprStrdup(hp, ip->h_name); + hp->h_addr_list = 0; + hp->h_aliases = 0; + + for (count = 0; ip->h_addr_list[count] != 0; ) { + count++; + } + if (count > 0) { + count++; + hp->h_addr_list = mprAlloc(hp, count * sizeof(char*)); + for (i = 0; ip->h_addr_list[i] != 0; i++) { + memcpy(&hp->h_addr_list[i], &ip->h_addr_list[i], ip->h_length); + } + hp->h_addr_list[i] = 0; + } + + for (count = 0; ip->h_aliases[count] != 0; ) { + count++; + } + if (count > 0) { + count++; + hp->h_aliases = mprAlloc(hp, count * sizeof(char*)); + for (i = 0; ip->h_aliases[i] != 0; i++) { + hp->h_aliases[i] = mprStrdup(hp, ip->h_aliases[i]); + } + hp->h_aliases[i] = 0; + } + return hp; +} + +/******************************************************************************/ +/* + * Read a registry value. Returns allocated memory in buf. + */ + +int mprReadRegistry(MprCtx ctx, char **buf, int max, const char *key, + const char *name) +{ + HKEY top, h; + char *value; + ulong type, size; + + mprAssert(key && *key); + mprAssert(buf); + + /* + * Get the registry hive + */ + if ((key = getHive(key, &top)) == 0) { + return MPR_ERR_CANT_ACCESS; + } + + if (RegOpenKeyEx(top, key, 0, KEY_READ, &h) != ERROR_SUCCESS) { + return MPR_ERR_CANT_ACCESS; + } + + /* + * Get the type + */ + if (RegQueryValueEx(h, name, 0, &type, 0, &size) != ERROR_SUCCESS) { + RegCloseKey(h); + return MPR_ERR_CANT_READ; + } + if (type != REG_SZ && type != REG_EXPAND_SZ) { + RegCloseKey(h); + return MPR_ERR_BAD_TYPE; + } + + value = (char*) mprAlloc(ctx, size); + if ((int) size > max) { + RegCloseKey(h); + return MPR_ERR_WONT_FIT; + } + if (RegQueryValueEx(h, name, 0, &type, (uchar*) value, &size) != + ERROR_SUCCESS) { + mprFree(value); + RegCloseKey(h); + return MPR_ERR_CANT_READ; + } + + RegCloseKey(h); + *buf = value; + return 0; +} + +/******************************************************************************/ +/* + * Write a string registry value. Returns allocated memory in buf. + */ + +int mprWriteRegistry(MprCtx ctx, const char *key, const char *name, + const char *value) +{ + HKEY top, h, subHandle; + ulong disposition; + + mprAssert(key && *key); + mprAssert(name && *name); + mprAssert(value && *value); + + /* + * Get the registry hive + */ + if ((key = getHive(key, &top)) == 0) { + return MPR_ERR_CANT_ACCESS; + } + + if (name) { + /* + * Write a registry string value + */ + if (RegOpenKeyEx(top, key, 0, KEY_ALL_ACCESS, &h) != ERROR_SUCCESS) { + return MPR_ERR_CANT_ACCESS; + } + if (RegSetValueEx(h, name, 0, REG_SZ, value, strlen(value) + 1) + != ERROR_SUCCESS) { + RegCloseKey(h); + return MPR_ERR_CANT_READ; + } + + } else { + /* + * Create a new sub key + */ + if (RegOpenKeyEx(top, key, 0, KEY_CREATE_SUB_KEY, &h) != ERROR_SUCCESS){ + return MPR_ERR_CANT_ACCESS; + } + if (RegCreateKeyEx(h, name, 0, NULL, REG_OPTION_NON_VOLATILE, + KEY_ALL_ACCESS, NULL, &subHandle, &disposition) != ERROR_SUCCESS) { + return MPR_ERR_CANT_ACCESS; + } + RegCloseKey(subHandle); + } + RegCloseKey(h); + return 0; +} + +/******************************************************************************/ +/* + * Determine the registry hive by the first portion of the path. Return + * a pointer to the rest of key path after the hive portion. + */ + +static const char *getHive(const char *keyPath, HKEY *hive) +{ + char key[MPR_MAX_STRING], *cp; + int len; + + mprAssert(keyPath && *keyPath); + + *hive = 0; + + mprStrcpy(key, sizeof(key), keyPath); + key[sizeof(key) - 1] = '\0'; + + if (cp = strchr(key, '\\')) { + *cp++ = '\0'; + } + if (cp == 0 || *cp == '\0') { + return 0; + } + + if (!mprStrcmpAnyCase(key, "HKEY_LOCAL_MACHINE")) { + *hive = HKEY_LOCAL_MACHINE; + } else if (!mprStrcmpAnyCase(key, "HKEY_CURRENT_USER")) { + *hive = HKEY_CURRENT_USER; + } else if (!mprStrcmpAnyCase(key, "HKEY_USERS")) { + *hive = HKEY_USERS; + } else if (!mprStrcmpAnyCase(key, "HKEY_CLASSES_ROOT")) { + *hive = HKEY_CLASSES_ROOT; + } else { + return 0; + } + + if (*hive == 0) { + return 0; + } + len = strlen(key) + 1; + return keyPath + len; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/WIN/mprTime.c b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprTime.c new file mode 100644 index 0000000000..74e59c9c73 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprTime.c @@ -0,0 +1,192 @@ +/** + * @file mprTime.c + * @brief Time handling for Windows + * @overview + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************* Includes ***********************************/ + +#include "mpr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/************************************ Code ************************************/ +/* + * Returns time in seconds and milliseconds. This is NOT time-of-day. + */ + +MprTime *mprGetTime(MprCtx ctx, MprTime *tp) +{ + FILETIME fileTime; + int64 now, base; + + GetSystemTimeAsFileTime(&fileTime); + + now = ((((int64) fileTime.dwHighDateTime) << BITS(uint)) + + ((int64) fileTime.dwLowDateTime)); + + /* + * Convert from 100-nanosec units to milliseconds + */ + now = (now / 10000); + + /* + * Adjust to be seconds since Jan 1 1970. Do this to be consistent with + * UNIX but not really required by the API definition. + */ + base = ((UINT64(365) * 86400 * (1970 - 1601)) * 1000); + now -= base; + tp->sec = (uint) (now / 1000); + tp->msec = (uint) (now % 1000); + +#if UNUSED +{ + static int64 start; + + if (start == 0) { + start = now; + } + if (now < start) { + mprLog(ctx, 0, "TIME WENT BACKWARDS"); + mprLog(ctx, 0, "start %Ld", start); + mprLog(ctx, 0, "now %Ld", now); + } + mprLog(ctx, 0, "getTime %Ld", now); + start = now; +} +#endif + + return tp; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of localtime + */ + +struct tm *mprLocaltime(MprCtx ctx, struct tm *timep, time_t *now) +{ + struct tm *tbuf; + mprGlobalLock(ctx); + tbuf = localtime(now); + *timep = *tbuf; + mprGlobalUnlock(ctx); + + return timep; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of gmtime + */ + +struct tm *mprGmtime(MprCtx ctx, time_t *now, struct tm *timep) +{ + struct tm *tbuf; + tbuf = gmtime(now); + *timep = *tbuf; + + return timep; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of ctime + */ + +int mprCtime(MprCtx ctx, char *buf, int bufsize, const time_t *timer) +{ + char *cp; + int len; + + mprAssert(buf); + + mprGlobalLock(ctx); + + cp = ctime(timer); + if ((int) strlen(cp) >= bufsize) { + mprStrcpy(buf, bufsize, "WONT FIT"); + mprAssert(0); + mprGlobalUnlock(ctx); + return MPR_ERR_WONT_FIT; + } + + len = mprStrcpy(buf, bufsize, cp); + if (buf[len - 1] == '\n') { + buf[len - 1] = '\0'; + } + + mprGlobalUnlock(ctx); + + return 0; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of asctime + */ + +int mprAsctime(MprCtx ctx, char *buf, int bufsize, const struct tm *timeptr) +{ + char *cp; + + mprAssert(buf); + mprGlobalLock(ctx); + cp = asctime(timeptr); + if ((int) strlen(cp) >= bufsize) { + mprAssert(0); + mprGlobalUnlock(ctx); + return MPR_ERR_WONT_FIT; + } + mprStrcpy(buf, bufsize, cp); + mprGlobalUnlock(ctx); + + return strlen(buf); +} + +/******************************************************************************/ + +#ifdef __cplusplus +} +#endif + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/files b/source4/lib/appweb/ejs-2.0/mpr/files new file mode 100644 index 0000000000..290c9ce790 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/files @@ -0,0 +1,14 @@ +${BLD_OBJ_DIR}/mpr${BLD_OBJ} +${BLD_OBJ_DIR}/mprAlloc${BLD_OBJ} +${BLD_OBJ_DIR}/mprArray${BLD_OBJ} +${BLD_OBJ_DIR}/mprBuf${BLD_OBJ} +${BLD_OBJ_DIR}/mprFile${BLD_OBJ} +${BLD_OBJ_DIR}/mprGenFile${BLD_OBJ} +${BLD_OBJ_DIR}/mprGenTime${BLD_OBJ} +${BLD_OBJ_DIR}/mprLock${BLD_OBJ} +${BLD_OBJ_DIR}/mprLog${BLD_OBJ} +${BLD_OBJ_DIR}/mprPlatform${BLD_OBJ} +${BLD_OBJ_DIR}/mprPrintf${BLD_OBJ} +${BLD_OBJ_DIR}/mprString${BLD_OBJ} +${BLD_OBJ_DIR}/mprSymbol${BLD_OBJ} +${BLD_OBJ_DIR}/mprTime${BLD_OBJ} diff --git a/source4/lib/appweb/ejs-2.0/mpr/mpr.c b/source4/lib/appweb/ejs-2.0/mpr/mpr.c new file mode 100644 index 0000000000..163b51eccf --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mpr.c @@ -0,0 +1,340 @@ +/** + * @file mpr.c + * @brief Mpr initialization + * @overview + * @remarks Most routines in this file are not thread-safe. It is the callers + * responsibility to perform all thread synchronization. + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ +/* + * We need to use the underlying str(cpy) routines to implement our safe + * alternatives + */ +#if !DOXYGEN +#define UNSAFE_FUNCTIONS_OK 1 +#endif + +#include "mpr.h" + +/******************************************************************************/ +/* + * Initialize the MPR. Create the top level memory context. This routine is + * the first call an MPR application must do. If using MprServices, the + * creation of an Mpr object will call this routine. + */ + +MprApp *mprInit(MprAllocCback cback) +{ + return mprInitEx(cback, 0); +} + +/******************************************************************************/ +/* + * Add a shell parameter then do the regular init + */ + +MprApp *mprInitEx(MprAllocCback cback, void *shell) +{ + MprApp *app; + + app = (MprApp*) mprAllocInit(cback); + + mprAssert(app); + if (app == 0) { + return 0; + } + + app->name = mprStrdup(app, BLD_PRODUCT); + app->title = mprStrdup(app, BLD_NAME); + app->version = mprStrdup(app, BLD_VERSION); + + mprSetShell(app, shell); + + app->table = mprCreateSymbolTable(app, 0); + + if (mprStartFileServices(app) < 0) { + mprAllocTerm(app); + return 0; + } + +#if BLD_FEATURE_MULTITHREAD + mprInitThreads(app); +#endif + + /* + * See if any of the preceeding allocations failed + */ + if (mprGetAllocErrors(app) > 0) { + mprAllocTerm(app); + return 0; + } + + /* + * Mark all blocks allocated so far as required. They will then be + * omitted from leak reports. + */ + mprSetRequiredAlloc(app, 1); + + return app; +} + +/******************************************************************************/ +/* + * Terminate the MPR. If doStats is true, then output a memory allocation + * report. + */ + +void mprTerm(MprApp *app, bool doStats) +{ +#if BLD_FEATURE_ALLOC_STATS + if (doStats) { + mprPrintAllocReport(app, 1, "MPR Memory Allocation Report"); + } +#endif + +#if BLD_FEATURE_MULTITHREAD + mprTermThreads(app); +#endif + + mprStopFileServices(app); + +#if BLD_DEBUG + mprValidateAllocTree(app); +#endif + mprAllocTerm(app); +} + +/******************************************************************************/ + +bool mprIsExiting(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + if (app == 0) { + return 1; + } + return app->flags & MPR_APP_EXITING; +} + +/******************************************************************************/ + +int mprHasAllocError(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + if (app == 0) { + return 1; + } + + return app->flags & MPR_APP_ALLOC_ERROR; +} + +/******************************************************************************/ + +void mprSignalExit(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + app->flags |= MPR_APP_EXITING; +} + +/******************************************************************************/ + +void mprSignalAllocError(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + app->flags |= MPR_APP_ALLOC_ERROR; +} + +/******************************************************************************/ + +int mprSetAppName(MprCtx ctx, const char *name, const char *title, + const char *version) +{ + MprApp *app; + + app = mprGetApp(ctx); + + if (name) { + mprFree(app->name); + if ((app->name = mprStrdup(ctx, name)) == 0) { + return MPR_ERR_CANT_ALLOCATE; + } + } + + if (title) { + mprFree(app->title); + if ((app->title = mprStrdup(ctx, title)) == 0) { + return MPR_ERR_CANT_ALLOCATE; + } + } + + if (version) { + mprFree(app->version); + if ((app->version = mprStrdup(ctx, version)) == 0) { + return MPR_ERR_CANT_ALLOCATE; + } + } + return 0; +} + +/******************************************************************************/ + +const char *mprGetAppName(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + return app->name; +} + +/******************************************************************************/ + +const char *mprGetAppTitle(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + return app->title; +} + +/******************************************************************************/ + +const char *mprGetAppVersion(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + return app->version; +} + +/******************************************************************************/ + +int mprSetKeyValue(MprCtx ctx, const char *key, void *ptr) +{ + MprApp *app; + + app = mprGetApp(ctx); + if (mprInsertSymbol(app->table, key, ptr) == 0) { + return MPR_ERR_CANT_WRITE; + } + return 0; +} + +/******************************************************************************/ + +int mprRemoveKeyValue(MprCtx ctx, const char *key) +{ + MprApp *app; + + app = mprGetApp(ctx); + return mprRemoveSymbol(app->table, key); +} + +/******************************************************************************/ + +void *mprGetKeyValue(MprCtx ctx, const char *key) +{ + MprApp *app; + + app = mprGetApp(ctx); + return mprLookupSymbol(app->table, key); +} + +/******************************************************************************/ + +bool mprGetDebugMode(MprCtx ctx) +{ + return mprGetApp(ctx)->debugMode; +} + +/******************************************************************************/ + +void mprSetDebugMode(MprCtx ctx, bool on) +{ + mprGetApp(ctx)->debugMode = on; +} + +/******************************************************************************/ + +void mprSetLogHandler(MprCtx ctx, MprLogHandler handler) +{ + mprGetApp(ctx)->logHandler = handler; +} + +/******************************************************************************/ + +MprLogHandler mprGetLogHandler(MprCtx ctx) +{ + return mprGetApp(ctx)->logHandler; +} + +#if UNUSED +/******************************************************************************/ + +void mprSetMprInstance(MprCtx ctx, void *mprInstance) +{ + mprGetApp(ctx)->mprInstance = mprInstance; +} + +/******************************************************************************/ + +void *mprGetMprInstance(MprCtx ctx) +{ + return mprGetApp(ctx)->mprInstance; +} + +#endif +/******************************************************************************/ + +const char *mprCopyright() +{ + return "Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved."; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mpr.h b/source4/lib/appweb/ejs-2.0/mpr/mpr.h new file mode 100644 index 0000000000..67505a6e01 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mpr.h @@ -0,0 +1,1027 @@ +/* + * @file mpr.h + * @brief Header for the Mbedthis Portable Runtime (MPR) Base. + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 ********************************/ +/* + * See mpr.dox for additional documentation. + */ + +/******************************************************************************/ + +#ifndef _h_MPR +#define _h_MPR 1 + +/***********************************Includes **********************************/ + +#include "mprOs.h" + +/******************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +/********************************** Constants *********************************/ + +#if BLD_FEATURE_SQUEEZE +#if BREW || DOXYGEN +/* + * Maximum length of a file path name. Reduced from the system maximum to + * save memory space. + */ +#define MPR_MAX_FNAME 64 /**< Reasonable filename size */ +#define MPR_MAX_PATH 64 /**< Reasonable path name size */ +#define MPR_DEFAULT_STACK (16 * 1024) /**< Default stack size */ +#else +#define MPR_MAX_FNAME 128 /**< Reasonable filename size */ +#define MPR_MAX_PATH 256 /**< Reasonable path name size */ +#define MPR_DEFAULT_STACK (32 * 1024) /**< Default stack size */ +#endif +/* + * Reasonable length of a file name used by the product. Use where you know + * the expected file name and it is certain to be less than this limit. + */ +#define MPR_DEFAULT_ALLOC 64 /**< Default small alloc size */ +#define MPR_DEFAULT_HASH_SIZE 23 /**< Default size of hash table */ +#define MPR_MAX_ARGC 32 /**< Reasonable max of args */ +#define MPR_MAX_STRING 512 /**< Maximum (stack) string size */ +#define MPR_MAX_LOG_STRING 512 /**< Maximum log message */ +#define MPR_MAX_URL 256 /**< Reasonable size of a URL */ +#define MPR_BUFSIZE 512 /**< Reasonable size for buffers */ +#define MPR_SLAB_STR_MAX 32 /**< Size of string slab blocks */ +#define MPR_SLAB_STR_INC 32 /**< Pre-allocate increment */ +#define MPR_SLAB_DEFAULT_INC 8 /**< Default pre-allocate inc */ +#define MPR_ARRAY_INCR 8 /**< Default array growth inc */ +#define MPR_BUF_INCR 1024 /**< Default array growth inc */ +#define MPR_MAX_BUF (1024*4096) /**< Default array growth inc */ + +#define MPR_BLK_HDR_SIZE ((sizeof(struct MprBlk) + 3) & ~3) + +#else +#define MPR_MAX_FNAME 256 +#define MPR_MAX_PATH 1024 +#define MPR_DEFAULT_ALLOC 256 +#define MPR_DEFAULT_HASH_SIZE 43 +#define MPR_DEFAULT_STACK (64 * 1024) +#define MPR_MAX_ARGC 128 +#define MPR_MAX_STRING 4096 +#define MPR_MAX_LOG_STRING 8192 +#define MPR_MAX_URL 1024 +#define MPR_BUFSIZE 1024 +#define MPR_SLAB_STR_MAX 32 +#define MPR_SLAB_STR_INC 64 +#define MPR_SLAB_DEFAULT_INC 16 +#define MPR_ARRAY_INCR 16 +#define MPR_BUF_INCR 1024 +#define MPR_MAX_BUF (1024*4096) + +#define MPR_BLK_HDR_SIZE ((sizeof(struct MprBlk) + 15) & ~15) +#endif + +/** + * Maximum size of a host name string + */ +#define MPR_MAX_IP_NAME 64 + +/** + * Maximum size of an IP address + */ +#define MPR_MAX_IP_ADDR 16 + +/** + * Maximum size of an IP address including port number + */ +#define MPR_MAX_IP_ADDR_PORT 32 + +#define MPR_MAX_SLAB 16 /* Slabs from 32-512 bytes */ + +#define MPR_MAX_TIME_SYNC (10 * 1000) /* Time sync adjustments */ + +/** + * @overview Memory context type + * @description Blocks of memory are allocated using a memory context + * as the parent with the \ref MprApp structure being the root of the + * tree. Any allocated memory block may serve as the memory context for + * subsequent memory allocations. Freeing a block via \ref mprFree will + * release the allocated block and all child blocks. + * @stability Prototype. + * @library libmpr. + * @see mprInit, mprAlloc, mprFree + */ +typedef const void *MprCtx; + +/* + * Allocated memory destructor type + */ +typedef int (*MprDestructor)(void *); + +/******************************** Error Codes *********************************/ + +/* + * Standard MPR return and error codes + */ + +#define MPR_ERR_OK (0) +/**< Success */ + +#define MPR_ERR_BASE (-200) +/**< Base error code */ + +#define MPR_ERR_GENERAL (MPR_ERR_BASE - 1) +/**< General error */ +#define MPR_ERR_ABORTED (MPR_ERR_BASE - 2) +/**< Action aborted */ +#define MPR_ERR_ALREADY_EXISTS (MPR_ERR_BASE - 3) +/**< Item already exists */ +#define MPR_ERR_BAD_ARGS (MPR_ERR_BASE - 4) +/**< Bad arguments or paramaeters */ +#define MPR_ERR_BAD_FORMAT (MPR_ERR_BASE - 5) +/**< Bad input format */ +#define MPR_ERR_BAD_HANDLE (MPR_ERR_BASE - 6) +#define MPR_ERR_BAD_STATE (MPR_ERR_BASE - 7) +/**< Module is in a bad state */ +#define MPR_ERR_BAD_SYNTAX (MPR_ERR_BASE - 8) +/**< Input has bad syntax */ +#define MPR_ERR_BAD_TYPE (MPR_ERR_BASE - 9) +#define MPR_ERR_BAD_VALUE (MPR_ERR_BASE - 10) +#define MPR_ERR_BUSY (MPR_ERR_BASE - 11) +#define MPR_ERR_CANT_ACCESS (MPR_ERR_BASE - 12) +/**< Can't access the file or resource */ +#define MPR_ERR_CANT_COMPLETE (MPR_ERR_BASE - 13) +#define MPR_ERR_CANT_CREATE (MPR_ERR_BASE - 14) +/**< Can't create the file or resource */ +#define MPR_ERR_CANT_INITIALIZE (MPR_ERR_BASE - 15) +#define MPR_ERR_CANT_OPEN (MPR_ERR_BASE - 16) +/**< Can't open the file or resource */ +#define MPR_ERR_CANT_READ (MPR_ERR_BASE - 17) +/**< Can't read from the file or resource */ +#define MPR_ERR_CANT_WRITE (MPR_ERR_BASE - 18) +/**< Can't write to the file or resource */ +#define MPR_ERR_DELETED (MPR_ERR_BASE - 19) +#define MPR_ERR_NETWORK (MPR_ERR_BASE - 20) +#define MPR_ERR_NOT_FOUND (MPR_ERR_BASE - 21) +#define MPR_ERR_NOT_INITIALIZED (MPR_ERR_BASE - 22) +/**< Module or resource is not initialized */ +#define MPR_ERR_NOT_READY (MPR_ERR_BASE - 23) +#define MPR_ERR_READ_ONLY (MPR_ERR_BASE - 24) +/**< The operation timed out */ +#define MPR_ERR_TIMEOUT (MPR_ERR_BASE - 25) +#define MPR_ERR_TOO_MANY (MPR_ERR_BASE - 26) +#define MPR_ERR_WONT_FIT (MPR_ERR_BASE - 27) +#define MPR_ERR_WOULD_BLOCK (MPR_ERR_BASE - 28) +#define MPR_ERR_CANT_ALLOCATE (MPR_ERR_BASE - 29) +// MOB -- rename NO_MEMORY +#define MPR_ERR_MEMORY (MPR_ERR_BASE - 30) +#define MPR_ERR_CANT_DELETE (MPR_ERR_BASE - 31) +#define MPR_ERR_MAX (MPR_ERR_BASE - 32) + +/* + * Standard logging trace levels are 0 to 9 with 0 being the most verbose. + * the These are ored with the error source and type flags. 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 enabled. + */ +#define MPR_ERROR 1 /**< Hard error trace level */ +#define MPR_WARN 2 /**< Soft warning trace level */ +#define MPR_CONFIG 2 /**< Configuration settings trace level. */ +#define MPR_INFO 3 /**< Informational trace only */ +#define MPR_DEBUG 4 /**< Debug information trace level */ +#define MPR_VERBOSE 9 /**< Highest level of trace */ +#define MPR_LEVEL_MASK 0xf /**< Level mask */ + +/* + * Error source flags + */ +#define MPR_ERROR_SRC 0x10 /**< Originated from mprError */ +#define MPR_LOG_SRC 0x20 /**< Originated from mprLog */ +#define MPR_ASSERT_SRC 0x40 /**< Originated from mprAssert */ +#define MPR_FATAL_SRC 0x80 /**< Fatal error. Log and exit */ + +/* + * Log message type flags. Specify what kind of log / error message it is. + * Listener handlers examine this flag to determine if they should process + * the message.Assert messages are trapped when in DEV mode. Otherwise ignored. + */ +#define MPR_LOG_MSG 0x100 /**< Log trace message - not an error */ +#define MPR_ERROR_MSG 0x200 /**< General error */ +#define MPR_ASSERT_MSG 0x400 /**< Assert flags -- trap in debugger */ +#define MPR_USER_MSG 0x800 /**< User message */ + +/* + * Log output modifiers + */ +#define MPR_RAW 0x1000 /**< Raw trace output */ + +/* + * Error line number information. + */ +#define MPR_LINE(s) #s +#define MPR_LINE2(s) MPR_LINE(s) +#define MPR_LINE3 MPR_LINE2(__LINE__) +#define MPR_LOC __FILE__ ":" MPR_LINE3 + +/* + * Macros to pass file and line number information + * Use MPR_LOC_ARGS in normal user code. + * Use MPR_LOC_DEC in declarations. + * Use MPR_LOC_PASS in layered APIs to pass original line info down. + */ +#if BLD_FEATURE_ALLOC_LEAK_TRACK +#define MPR_LOC_ARGS(ctx) ctx, MPR_LOC +#define MPR_LOC_DEC(ctx, loc) MprCtx ctx, const char *loc +#define MPR_LOC_PASS(ctx, loc) ctx, loc +#else +#define MPR_LOC_ARGS(ctx) ctx +#define MPR_LOC_DEC(ctx, loc) MprCtx ctx +#define MPR_LOC_PASS(ctx, loc) ctx +#endif + +/******************************* Debug and Assert *****************************/ + +extern void mprBreakpoint(const char *loc, const char *msg); + +#if BLD_FEATURE_ASSERT + #define mprAssert(C) if (C) ; else mprStaticAssert(MPR_LOC, #C) +#else + #define mprAssert(C) if (1) ; else +#endif + +/********************************* Safe Strings *******************************/ +/* + * Unsafe functions that should not be used. Define UNSAFE_STRINGS_OK before + * including mpr.h if you really want to use these functions. A better approach + * is to undefine them just prior to using them in your C/C++ source file. + */ +#if BLD_FEATURE_SAFE_STRINGS + +#if BLD_FEATURE_PHP4_MODULE || BLD_FEATURE_PHP5_MODULE + #ifndef UNSAFE_FUNCTIONS_OK + #define UNSAFE_FUNCTIONS_OK 1 + #endif +#endif + +#ifndef UNSAFE_FUNCTIONS_OK + #define sprintf UseMprSprintfInstead + #define fprintf UseMprFprintfInstead + #define vsprintf UseMprVsprintfInstead + #define strtok UseMprStrTokInstead + #define gethostbyname UseMprGetHostByNameInstead + #define ctime UseMprCtimeInstead + #define asctime UseMprAsctimeInstead + #define localtime UseMprLocaltimeInstead + #define gmtime UseMprGmtimeInstead + #define malloc UseMprMallocInstead + #define free UseMprFreeInstead + #define realloc UseMprReallocInstead + #define strncpy UseMprStrcpyInstead + #define inet_ntoa UseMprInetToStrInstead + +#if !BREW + #define printf UseMprPrintfInstead +#endif + + #if FUTURE + #define strlen UseMprStrlenInstead + #define strcpy UseMprStrcpyInstead + #endif + +#endif /* UNSAFE_FUNCTIONS_OK */ +#endif /* BLD_FEATURE_SAFE_STRINGS */ + +/******************************************************************************/ + +struct MprBuf; +typedef int (*MprBufProc)(struct MprBuf* bp, void *arg); + +/** + * @overview Dynamic buffer structure + * @description MprBuf is a flexible, dynamic growable buffer structure. It + * utilizes a ring buffer mechanism and is suitable for high performance + * buffering in a variety of situations. + * @stability Prototype. + * @library libmpr. + * @see mprCreateBuf, mprFree, MprArray + */ +typedef struct MprBuf { + uchar *buf; /* Actual buffer for data */ + uchar *endbuf; /* Pointer one past the end of buffer */ + uchar *start; /* Pointer to next data char */ + uchar *end; /* Pointer one past the last data chr */ + int buflen; /* Current size of buffer */ + int maxsize; /* Max size the buffer can ever grow */ + int growBy; /* Next growth increment to use */ + MprBufProc refillProc; /* Auto-refill procedure */ + void *refillArg; /* Refill arg */ +} MprBuf; + +/** + * @overview File structure + * @description MprFile is the cross platform File I/O abstraction control + * structure. + * @stability Prototype. + * @library libmpr. + * @see mprOpen, mprClose, mprRead, mprWrite + */ +typedef struct MprFile +{ + MprBuf *buf; /* Buffer for I/O */ +#if BREW + IFile *fd; /* File handle */ +#else + int fd; +#endif +} MprFile; + +/** + * File information structure + * @overview File information structure + * @description MprFileInfo is the cross platform File information structure. + * @stability Prototype. + * @see mprGetFileInfo, mprOpen, mprClose, mprRead, mprWrite + */ +typedef struct MprFileInfo +{ + uint size; /* File length */ + uint ctime; /* Create time */ + uint mtime; /* Modified time */ + uint inode; /* Inode number */ + int isDir; /* Set if directory */ + int isReg; /* Set if a regular file */ +} MprFileInfo; + +/** + * @overview Mpr time structure. + * @description MprTime is the cross platform time abstraction structure. + * @stability Prototype. + * @library libmpr. + * @see mprGetTime + */ +typedef struct MprTime +{ + uint sec; /* Seconds */ + uint msec; /* Milliseconds */ +} MprTime; + + +/** + * @overview Generic array type + * @description The MprArray is a dynamic growable array suitable for storing + * pointers to arbitrary objects. + * @stability Prototype. + * @library libmpr. + * @see mprCreateItemArray, mprFree, MprBuf + */ +typedef struct MprArray +{ + int capacity; /* Current capacity of the array */ + int length; /* Count of used items */ + int incr; /* Growth increment */ + int maxSize; /* Maximum capacity */ + void **items; +} MprArray; + + +#if BLD_FEATURE_MULTITHREAD +/** + * @overview Multithreading lock control structure + * @description MprLock is used for multithread locking in multithreaded + * applications. + * @library libmpr. + * @see mprCreateLock, mprDestroyLock, mprLock, mprUnlock + */ +typedef struct +{ + #if WIN + CRITICAL_SECTION cs; /* O/S critical section */ + #endif + #if LINUX || MACOSX || SOLARIS + pthread_mutex_t cs; /* O/S critical section */ + #endif + #if VXWORKS + SEM_ID cs; /* Semaphore */ + #endif +} MprLock; +#endif + +/* + * Error and Logging callback + */ +typedef void (*MprLogHandler)(MPR_LOC_DEC(ctx, loc), int flags, + int level, const char *msg); + +/* + * Symbol table + * MOB -- rename hash + */ +typedef struct MprSymbol +{ + struct MprSymbol *next; /* Next symbol in hash chain */ + char *key; /* Symbol key */ + void *data; /* Pointer to symbol data */ + int bucket; /* Hash bucket index */ +} MprSymbol; + +typedef struct MprSymbolTable +{ + MprSymbol **buckets; + int hashSize; /* Size of the buckets array */ + int count; /* Number of symbols in the table */ +} MprSymbolTable; + + +/* + * Memory allocation error callback + */ +struct MprApp; +typedef int (*MprAllocCback)(struct MprApp *app, uint size, uint total, + bool granted); + + +/* + * Slab block pointer links + */ +typedef struct MprSlabBlock { + struct MprSlabBlock *next; +} MprSlabBlock; + + +#if BLD_FEATURE_ALLOC_STATS +/* + * Memory Slab Statistics + */ +typedef struct MprSlabStats { + uint allocCount; /* Number of allocated blocks */ + uint freeCount; /* Number of blocks on the slab freelist */ + uint peakAllocCount; /* Peak allocated */ + uint totalAllocCount; /* Total count of allocation calls */ + uint peakFreeCount; /* Peak on the free list */ + MprSlabBlock *next; +} MprSlabStats; +#endif + + +/* + * Slab control structure + */ +typedef struct MprSlab { + MprSlabBlock *next; + uint preAllocateIncr; /* Pre-allocation increment */ +#if BLD_FEATURE_ALLOC_STATS + MprSlabStats stats; +#endif +} MprSlab; + +/* + * Allocation stats (kept even in production code so we can detect memory + * allocation failures) + */ +typedef struct MprAllocStats +{ + uint bytesAllocated; /* Bytes currently allocated */ + uint peakAllocated; /* Peak bytes allocated */ + uint allocCount; /* Number of allocated blocks */ + uint redLine; /* Warn above this level */ + uint maxMemory; /* Max memory to allocate */ + uint errors; /* Allocation errors */ +} MprAllocStats; + +/* + * Memory allocation control + */ + +typedef struct MprAlloc { + MprSlab *slabs; /* Array[MPR_MAX_SLAB] of MprSlab */ + MprAllocCback cback; /* Memory allocation callback */ + MprAllocStats stats; /* Keep stats even in release */ + int inAllocException; /* Recursive protect */ +} MprAlloc; + + +/* + * MprApp State Flags + */ +#define MPR_APP_EXITING 0x1 /* App is exiting */ +#define MPR_APP_ALLOC_ERROR 0x2 /* App has allocation error */ + +/* MOB -- temporary */ +#define MPR_APP_NEED_GC 0x4 /* App needs GC */ + +/** + * @overview Primary MPR application control structure + * @description The MprApp structure stores critical application state + * information and is the root memory allocation context block. It is + * used as the MprCtx context for other memory allocations and is thus + * the ultimate parent of all allocated memory. + * \n\n + * The MprApp structure is allocated by the mprInit API. + */ +typedef struct MprApp +{ + uint magic; /* Corruption protection */ + MprFile *console; /* Stdout file */ + bool debugMode; /* Run in debug mode (no timers) */ + MprFile *error; /* Stderr file */ + int logLevel; /* Log trace level */ + MprFile *logFile; /* Log file */ + MprLogHandler logHandler; /* Current log handler callback */ + MprSymbolTable *table; + char *name; /* Product name */ + char *title; /* Product title */ + char *version; /* Product version */ + +#if BREW + uint classId; /* Brew class ID */ + IShell *shell; /* Brew shell object */ + IDisplay *display; /* Brew display object */ + IFileMgr *fileMgr; /* File manager */ + ITAPI *tapi; /* TAPI object */ + int displayHeight; /* Display height */ + int displayWidth; /* Display width */ + char *args; /* Command line args */ +#endif + + void *stackStart; /* Start of app stack */ + uint maxStack; /* Max stack size recorded */ + + MprAlloc alloc; /* Memory allocation data */ + int flags; /* App state flags */ + +#if BLD_FEATURE_MULTITHREAD + MprLock *globalLock; + MprLock *allocLock; +#endif +} MprApp; + + +/* + * String type. Minimum size is 8 words (32 bytes). + */ +#define MPR_MAX_INLINE_STR 24 + + +/* + * The block header structure for all allocated memory blocks (32 bytes) + * WARNING: Don't increase the size of this structure. It just fits into + * 32 bytes currently. Alignment requirements will double this size if you + * add one byte! + */ +typedef struct MprBlk +{ + MprApp *app; /* app is the top level alloc context */ + struct MprBlk *parent; /* Parent block */ + struct MprBlk *children; /* First child block */ + struct MprBlk *next; /* Next sibling */ + struct MprBlk *prev; /* Previous sibling */ + MprDestructor destructor; /* Destructor function (optional) */ + uint size; /* Size of block sans HDR_SIZE */ + uint flags; /* Allocation flags and magic number */ +#if BLD_FEATURE_ALLOC_LEAK_TRACK + const char *location; /* Allocating code (file + line) */ +#endif +} MprBlk; + +/******************************************************************************/ +/****************************** Internal Prototypes ***************************/ +/******************************************************************************/ + +extern void mprSignalAllocError(MprCtx ctx); + +/******************************************************************************/ +/********************************** Prototypes ********************************/ +/******************************************************************************/ + +extern MprApp *mprInit(MprAllocCback cback); +extern MprApp *mprInitEx(MprAllocCback cback, void *shell); +extern void mprTerm(MprApp *app, bool doStats); +extern void mprSignalExit(MprCtx ctx); +extern bool mprIsExiting(MprCtx ctx); +extern bool mprHasAllocError(MprCtx ctx); + +#if BLD_DEBUG && UNUSED +extern MprApp *mprGetApp(MprCtx ctx); +#else +#define mprGetApp(ctx) \ + (((MprBlk*) ((char*) ctx - MPR_BLK_HDR_SIZE))->app) +#endif + +/******************************************************************************/ + +extern int mprSetKeyValue(MprCtx ctx, const char *key, void *ptr); +/* MOB -- should this be delete or remove or unset */ +extern int mprRemoveKeyValue(MprCtx ctx, const char *key); +extern void *mprGetKeyValue(MprCtx ctx, const char *key); +/* MOB -- should be setAppName, getAppName */ +extern int mprSetAppName(MprCtx ctx, const char *name, const char *title, + const char *version); +extern const char *mprGetAppName(MprCtx ctx); +extern const char *mprGetAppTitle(MprCtx ctx); +extern const char *mprGetAppVersion(MprCtx ctx); + +/* + * File services + */ +extern void mprStopFileServices(MprCtx ctx); +extern int mprStartFileServices(MprCtx ctx); + +/* + * Item Array + */ +#define mprCreateItemArray(ctx, initialSize, maxSize) \ + mprCreateItemArrayInternal(MPR_LOC_ARGS(ctx), initialSize, \ + maxSize) + +extern MprArray *mprCreateItemArrayInternal(MPR_LOC_DEC(ctx, loc), + int initialSize, int maxSize); +/* MOB -- should be insert not add/delete or insert / remove */ +extern int mprAddItem(MprArray *array, void *item); +extern void mprClearItems(MprArray *array); +extern void mprClearAndFreeItems(MprArray *array); +extern int mprFindItem(MprArray *array, void *item); +extern void *mprGetFirstItem(MprArray *array, int *lastIndex); +extern void *mprGetItem(MprArray *array, int index); +extern int mprGetItemCapacity(MprArray *array); +extern int mprGetItemCount(MprArray *array); +extern void *mprGetNextItem(MprArray *array, int *lastIndex); +extern void *mprGetPrevItem(MprArray *array, int *lastIndex); +extern int mprRemoveItem(MprArray *array, void *item); +extern int mprRemoveItemByIndex(MprArray *array, int index); +extern int mprRemoveRangeOfItems(MprArray *array, int start, int end); + + +/* + * Printf replacements + */ +extern int mprSprintf(char *buf, int maxSize, const char *fmt, ...) + PRINTF_ATTRIBUTE(3,4); +extern int mprVsprintf(char *buf, int maxSize, const char *fmt, + va_list arg) PRINTF_ATTRIBUTE(3,0); +extern char *mprItoa(char *buf, int size, int value); +extern int mprAtoi(const char *str, int radix); + +extern int mprPrintf(MprCtx ctx, const char *fmt, ...) + PRINTF_ATTRIBUTE(2,3); +/* MOB -- NEED DOC */ +extern int mprErrorPrintf(MprCtx ctx, const char *fmt, ...) + PRINTF_ATTRIBUTE(2,3); +extern int mprStaticPrintf(MprCtx ctx, const char *fmt, ...) + PRINTF_ATTRIBUTE(2,3); +extern int mprPrintfError(MprCtx ctx, const char *fmt, ...) + PRINTF_ATTRIBUTE(2,3); +extern int mprFprintf(MprFile *file, const char *fmt, ...) + PRINTF_ATTRIBUTE(2,3); + +/* + * Safe string routines + */ +extern char *mprGetWordTok(char *buf, int bufsize, const char *str, + const char *delim, const char **tok); +extern int mprMemcpy(char *dest, int destMax, const char *src, + int nbytes); +extern int mprStrcat(char *dest, int max, const char *delim, + const char *src, ...); +extern int mprStrcpy(char *dest, int destMax, const char *src); + +extern int mprStrcmpAnyCase(const char *str1, const char *str2); +extern int mprStrcmpAnyCaseCount(const char *str1, const char *str2, + int len); +extern int mprStrlen(const char *src, int max); + +extern char *mprStrLower(char *str); +extern char *mprStrUpper(char *str); +extern char *mprStrTrim(char *str, const char *set); +extern char *mprStrTok(char *str, const char *delim, char **last); + +/* + * Symbol table + */ +extern MprSymbolTable *mprCreateSymbolTable(MprCtx ctx, int hashSize); +extern MprSymbol *mprGetFirstSymbol(MprSymbolTable *table); +extern MprSymbol *mprGetNextSymbol(MprSymbolTable *table, MprSymbol *last); +extern int mprGetSymbolCount(MprSymbolTable *table); +extern MprSymbol *mprInsertSymbol(MprSymbolTable *table, const char *key, + void *ptr); +extern void *mprLookupSymbol(MprSymbolTable *table, const char *key); +extern int mprRemoveSymbol(MprSymbolTable *table, const char *key); + +/* + * File I/O support + */ +extern void mprClose(MprFile *file); +extern int mprDelete(MprCtx ctx, const char *path); +extern int mprDeleteDir(MprCtx ctx, const char *path); +extern int mprGetFileInfo(MprCtx ctx, const char *path, MprFileInfo *info); +extern char *mprGets(MprFile *file, char *buf, uint size); +extern int mprMakeDir(MprCtx ctx, const char *path, int perms); +extern MprFile *mprOpen(MprCtx ctx, const char *path, int omode, int perms); +extern int mprPuts(MprFile *file, const char *buf, uint size); +extern int mprRead(MprFile *file, void *buf, uint size); +extern int mprSeek(MprFile *file, int seekType, long distance); +extern int mprWrite(MprFile *file, const void *buf, uint count); + +extern int mprMakeTempFileName(MprCtx ctx, char *buf, int bufsize, + const char *tmpDir); + + +/* + * Error handling and logging + */ +extern void mprSetLogHandler(MprCtx ctx, MprLogHandler handler); +extern MprLogHandler mprGetLogHandler(MprCtx ctx); + +extern void mprAssertError(MPR_LOC_DEC(ctx, loc), const char *msg); +extern void mprError(MPR_LOC_DEC(ctx, loc), + const char *fmt, ...) PRINTF_ATTRIBUTE(3,4); +extern void mprFatalError(MPR_LOC_DEC(ctx, loc), + const char *fmt, ...) PRINTF_ATTRIBUTE(3,4); +extern void mprLog(MprCtx ctx, int level, + const char *fmt, ...) PRINTF_ATTRIBUTE(3,4); +extern void mprRawLog(MprCtx ctx, const char *fmt, ...); +extern void mprStaticAssert(const char *loc, const char *msg); +extern void mprStaticError(MPR_LOC_DEC(ctx, loc), + const char *fmt, ...) PRINTF_ATTRIBUTE(3,4); +extern void mprUserError(MPR_LOC_DEC(ctx, loc), + const char *fmt, ...) PRINTF_ATTRIBUTE(3,4); + +/* + * Dynamic Buffering routines + */ +extern MprBuf *mprCreateBuf(MprCtx ctx, int initialSize, int maxSize); +extern char *mprStealBuf(MprCtx ctx, MprBuf *bp); +extern void mprAddNullToBuf(MprBuf *bp); +extern void mprAdjustBufStart(MprBuf *bp, int size); +extern void mprAdjustBufEnd(MprBuf *bp, int size); +extern void mprCopyBufDown(MprBuf *bp); +extern void mprFlushBuf(MprBuf *bp); +extern int mprGetCharFromBuf(MprBuf *bp); +extern int mprGetBlockFromBuf(MprBuf *bp, uchar *buf, int len); +extern int mprGetBufLength(MprBuf *bp); +extern int mprGetBufLinearSpace(MprBuf *bp); +extern int mprGetBufLinearData(MprBuf *bp); +extern char *mprGetBufOrigin(MprBuf *bp); +extern int mprGetBufSize(MprBuf *bp); +extern int mprGetBufSpace(MprBuf *bp); +extern char *mprGetBufStart(MprBuf *bp); +extern char *mprGetBufEnd(MprBuf *bp); +extern int mprInsertCharToBuf(MprBuf *bp, int c); +extern int mprLookAtNextCharInBuf(MprBuf *bp); +extern int mprLookAtLastCharInBuf(MprBuf *bp); +extern int mprPutCharToBuf(MprBuf *bp, int c); +extern int mprPutBlockToBuf(MprBuf *bp, const char *str, int size); +extern int mprPutIntToBuf(MprBuf *bp, int i); +extern int mprPutStringToBuf(MprBuf *bp, const char *str); +extern int mprPutFmtStringToBuf(MprBuf *bp, const char *fmt, ...); +extern int mprRefillBuf(MprBuf *bp); +extern void mprResetBufIfEmpty(MprBuf *bp); +extern void mprSetBufSize(MprBuf *bp, int initialSize, int maxSize); +extern MprBufProc mprGetBufRefillProc(MprBuf *bp); +extern void mprSetBufRefillProc(MprBuf *bp, MprBufProc fn, void *arg); + +/* + * General other xPlatform routines + */ +extern const char *mprGetBaseName(const char *name); +extern bool mprGetDebugMode(MprCtx ctx); +extern char *mprGetDirName(char *buf, int bufsize, const char *path); +extern char *mprGetFullPathName(char *buf, int buflen, const char *path); +extern int mprGetLogLevel(MprCtx ctx); +extern int mprGetOsError(); + + +extern int mprMakeArgv(MprCtx ctx, const char *prog, const char *cmd, + char ***argv, int *argc); +extern int mprMakeDirPath(MprCtx ctx, const char *path); +extern void mprSetDebugMode(MprCtx ctx, bool on); +extern void mprSetLogLevel(MprCtx ctx, int level); +extern void mprSleep(MprCtx ctx, int msec); +extern void mprSetShell(MprCtx ctx, void *shell); +extern void *mprGetShell(MprCtx ctx); +extern void mprSetClassId(MprCtx ctx, uint classId); +extern uint mprGetClassId(MprCtx ctx); + +#if BREW +extern void mprSetDisplay(MprCtx ctx, void *display); +extern void *mprGetDisplay(MprCtx ctx); +extern void mprSetFileMgr(MprCtx ctx, void *fileMgr); +extern void *mprGetFileMgr(MprCtx ctx); +#else +extern char *mprInetToStr(char *buf, int size, const struct in_addr in); +#endif + +/* + * Memory allocation + */ +extern MprApp *mprAllocInit(MprAllocCback cback); +extern void mprAllocTerm(MprApp *app); +extern void mprAllocAbort(); + +extern void *mprAllocBlock(MPR_LOC_DEC(ctx, loc), uint size); +extern void *mprAllocZeroedBlock(MPR_LOC_DEC(ctx, loc), uint size); +extern void *mprReallocBlock(MPR_LOC_DEC(ctx, loc), void *ptr, uint size); +extern int mprFree(void *ptr); +extern int mprStealAllocBlock(MPR_LOC_DEC(ctx, loc), const void *ptr); +extern void *mprMemdupInternal(MPR_LOC_DEC(ctx, loc), const void *ptr, + uint size); +extern char *mprStrndupInternal(MPR_LOC_DEC(ctx, loc), const char *str, + uint size); +extern char *mprStrdupInternal(MPR_LOC_DEC(ctx, loc), const char *str); + +extern void *mprSlabAllocBlock(MPR_LOC_DEC(ctx, loc), uint size, uint inc); +extern void *mprSlabAllocZeroedBlock(MPR_LOC_DEC(ctx, loc), uint size, + uint inc); + +extern uint mprGetAllocBlockSize(MprCtx ctx); +extern uint mprGetAllocBlockCount(MprCtx ctx); +extern uint mprGetAllocBlockMemory(MprCtx ctx); +extern void *mprGetAllocParent(MprCtx ctx); +extern uint mprGetAllocatedMemory(MprCtx ctx); +extern uint mprGetPeakAllocatedMemory(MprCtx ctx); +extern uint mprGetAllocatedSlabMemory(MprCtx ctx); +extern int mprIsAllocBlockValid(MprCtx ctx); +extern int mprStackCheck(MprCtx ctx); +extern int mprStackSize(MprCtx ctx); +extern int mprGetAllocErrors(MprCtx ctx); +extern void mprClearAllocErrors(MprCtx ctx); + +extern MprDestructor mprSetDestructor(MprCtx ctx, MprDestructor destructor); +extern MprAllocCback mprSetAllocCallback(MprApp *app, MprAllocCback cback); +extern void mprSetAllocLimits(MprApp *app, uint redLine, uint maxMemory); + +#if BLD_FEATURE_ALLOC_STATS +extern MprSlabStats *mprGetSlabAllocStats(MprApp *app, int slabIndex); +extern MprAllocStats *mprGetAllocStats(MprApp *app); +extern void mprPrintAllocReport(MprApp *app, bool doBlocks, + const char *msg); +#endif + +#if BLD_DEBUG +extern int mprPrintAllocBlocks(MprCtx ctx, int indent); +extern const char *mprGetAllocLocation(MprCtx ptr); +#endif + +extern int mprValidateBlock(MprCtx ctx); +extern int mprValidateAllocTree(MprCtx ptr); +extern void mprSetRequiredAlloc(MprCtx ptr, bool recurse); + +/* + * Sprintf style allocators + */ +extern int mprAllocSprintf(MPR_LOC_DEC(ctx, loc), char **buf, int maxSize, + const char *fmt, ...) PRINTF_ATTRIBUTE(5,6); +extern int mprAllocVsprintf(MPR_LOC_DEC(ctx, loc), char **buf, int maxSize, + const char *fmt, va_list arg) PRINTF_ATTRIBUTE(5,0); +extern int mprAllocMemcpy(MPR_LOC_DEC(ctx, loc), char **dest, int destMax, + const void *src, int nbytes); +extern int mprAllocStrcat(MPR_LOC_DEC(ctx, loc), char **dest, int max, + const char *delim, const char *src, ...); +extern int mprAllocStrcpy(MPR_LOC_DEC(ctx, loc), char **dest, int max, + const char *src); +extern int mprReallocStrcat(MPR_LOC_DEC(ctx, loc), char **dest, int max, + int existingLen, const char *delim, const char *src, ...); + +/* + * MACROS: These are the convenience macros to automatically supply file + * names and line numbers when debugging. + */ +#define mprNew(ctx) new(MPR_LOC_ARGS(ctx)) + +#define mprAlloc(ctx, size) mprAllocBlock(MPR_LOC_ARGS(ctx), size) + +#define mprAllocZeroed(ctx, size) mprAllocZeroedBlock(MPR_LOC_ARGS(ctx), size) + +#define mprSlabAlloc(ctx, size, inc) \ + ((type*) mprSlabAllocBlock(MPR_LOC_ARGS(ctx), size, inc)) + +#define mprSlabAllocZeroed(ctx, size, inc) \ + ((type*) mprSlabAllocBlock(MPR_LOC_ARGS(ctx), size, inc)) + +#define mprRealloc(ctx, ptr, size) mprReallocBlock(MPR_LOC_ARGS(ctx), ptr, size) + +#define mprMemdup(ctx, ptr, size) \ + mprMemdupInternal(MPR_LOC_ARGS(ctx), ptr, size) + +#define mprStrdup(ctx, str) mprStrdupInternal(MPR_LOC_ARGS(ctx), str) + +#define mprStrndup(ctx, str, size) mprStrndupDebug(MPR_LOC_ARGS(ctx), str, size) + +/* + * Allocate type macros + */ +#define mprAllocType(ctx, type) \ + ((type*) mprAllocBlock(MPR_LOC_ARGS(ctx), sizeof(type))) + +#define mprAllocTypeZeroed(ctx, type) \ + ((type*) mprAllocZeroedBlock(MPR_LOC_ARGS(ctx), sizeof(type))) + +#define mprSlabAllocType(ctx, type, inc) \ + ((type*) mprSlabAllocBlock(MPR_LOC_ARGS(ctx), sizeof(type), inc)) + +#define mprSlabAllocTypeZeroed(ctx, type, inc) \ + ((type*) mprSlabAllocZeroedBlock(MPR_LOC_ARGS(ctx), sizeof(type), \ + inc)) + +/* + * Multithread locking + */ +#if BLD_FEATURE_MULTITHREAD +extern void mprInitThreads(MprApp *app); +extern void mprTermThreads(MprApp *app); +extern MprLock *mprCreateLock(MprCtx ctx); +extern void mprDestroyLock(MprLock *lock); +extern void mprLock(MprLock *lock); +extern int mprTryLock(MprLock *lock); +extern void mprUnlock(MprLock *lock); +extern void mprGlobalLock(MprCtx ctx); +extern void mprGlobalUnlock(MprCtx ctx); +extern int mprGetCurrentThreadID(); +#else +/* + * Disable multithreading + */ +#define mprInitThreads(ctx, app) +#define mprTermThreads(app) +#define mprCreateLock(ctx) +#define mprDestroyLock(lock) +#define mprLock(lock) +#define mprTryLock(lock) +#define mprUnlock(lock) +#define mprGlobalLock(app) +#define mprGlobalUnlock(app) +#define mprGetCurrentThreadID() +#endif + +/* + * Time + */ +extern MprTime *mprGetTime(MprCtx ctx, MprTime *tp); +extern int mprGetTimeRemaining(MprCtx ctx, MprTime mark, uint timeout); +extern int mprGetElapsedTime(MprCtx ctx, MprTime mark); +extern int mprCompareTime(MprTime *t1, MprTime *t2); +extern uint mprSubtractTime(MprTime *t1, MprTime *t2); +extern void mprAddElapsedToTime(MprTime *time, uint elapsed); + +#if !BREW +extern int mprAsctime(MprCtx ctx, char *buf, int bufsize, + const struct tm *timeptr); +extern int mprCtime(MprCtx ctx, char *buf, int bufsize, + const time_t *timer); +extern struct tm *mprLocaltime(MprCtx ctx, struct tm *timep, time_t *now); +extern struct tm *mprGmtime(MprCtx ctx, time_t* now, struct tm *timep); +extern int mprRfcTime(MprCtx ctx, char *buf, int bufsize, + const struct tm *timep); +#endif /* !BREW */ + +/* + * Host name + */ +extern struct hostent* mprGetHostByName(MprCtx ctx, const char *name); + +#if WIN +extern int mprReadRegistry(MprCtx ctx, char **buf, int max, + const char *key, const char *val); +extern int mprWriteRegistry(MprCtx ctx, const char *key, const char *name, + const char *value); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* _h_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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprAlloc.c b/source4/lib/appweb/ejs-2.0/mpr/mprAlloc.c new file mode 100644 index 0000000000..6fcaa63a6c --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprAlloc.c @@ -0,0 +1,1775 @@ +/** + * @file mprAlloc.c + * @brief Memory Allocation + * @overview + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************* Includes ***********************************/ + +#define UNSAFE_FUNCTIONS_OK 1 + +#include "mpr.h" + +/******************************* Local Defines ********************************/ +/* + * Set to 1 to disable slab based allocations + */ +#define NO_SLAB 0 + +/* + * Validation mode is quite slow + */ +#define VALIDATE_ALLOC 0 +#if VALIDATE_ALLOC +#define VALIDATE_BLOCK(ptr) mprValidateBlock(ptr) +#else +#define VALIDATE_BLOCK(ptr) +#endif + +/* + * Align on 4 bytes if squeeze, Otherwize on 16 bytes. + */ +#define HDR_SIZE MPR_BLK_HDR_SIZE + +#define APP_MAGIC 0xa571cb80 +#define ALLOC_MAGIC 0xe814ecc0 + +/* + * This must be at least one word to ensure that the smallest allocation is + * 4 bytes. Slab allocations need at least one word to store their next ptr. + */ +#define ALLOC_ALIGN(x) (((x)+3)&~3) +#define GET_HDR(ptr) ((MprBlk*) (((char*) (ptr)) - HDR_SIZE)) +#define GET_PTR(bp) ((void*) (((char*) (bp)) + HDR_SIZE)) +#define VALID_HDR(bp) (((bp)->flags & ~0x3F) == ALLOC_MAGIC) +#define VALID_BLK(ptr) (VALID_HDR(GET_HDR(ptr))) + +/* + * In production releases, mprAssert will compile out (not be included) + * but CHECK_HDR will remain even in production builds. + */ +#define CHECK_HDR(bp) \ + if (1) { if (! VALID_HDR(bp)) { mprAllocAbort(); } } else + +/* + * Chunk the slabs into 32 byte increments. + * This allows for allocations up to 512 bytes via slabs and maximizes + * sharing of slab allocations. + * + * Index map: + * 0 == 32 bytes + * 1 == 64 bytes + * 2 == 96 bytes + * 3 == 128 bytes + * 4 == 160 bytes + * 5 == 192 bytes + * 6 == 224 bytes + * 7 == 256 bytes + * 8 == 288 bytes + * 9 == 320 bytes + * 10 == 352 bytes + * 11 == 384 bytes + * 12 == 416 bytes + * 13 == 448 bytes + * 14 == 480 bytes + * 15 == 512 bytes + */ +#define SLAB_ALIGN(size) ((size + 31) & ~31) +#define GET_SLAB(size) (size >> 6) + +/* + * Block flags + */ +#define ALLOC_FLAGS_FREE 0x1 /* Block is free */ +#define ALLOC_FLAGS_FREEING 0x2 /* Block is being freed */ +#define ALLOC_FLAGS_SLAB_BLOCK 0x4 /* Block was allocated from slab */ +#define ALLOC_FLAGS_REQUIRED 0x8 /* Block is required by alloc */ +#define ALLOC_FLAGS_KEEP 0x10 /* Keep block - don't mprFree */ +#define ALLOC_FLAGS_DONT_OS_FREE 0x20 /* Don't return mem to O/S */ +#define ALLOC_FLAGS_IS_SLAB 0x40 /* Block is a slab */ + +#if BLD_DEBUG && !BREW +/* + * Set this address to break when this address is allocated or freed. This is + * a block address (not a user ptr). + */ +static MprBlk *stopAlloc; +#endif + +#if !BREW +static MprCtx rootCtx; /* Root context if none supplied */ +#endif + +/***************************** Forward Declarations ***************************/ + +static int mprAllocException(MPR_LOC_DEC(ptr, loc), uint size, bool granted); +static void slabFree(MprBlk *bp); +static int growSlab(MPR_LOC_DEC(ctx, loc), MprSlab *slab, uint size, uint inc); + +/******************************************************************************/ +/* + * Put first in file so it is easy to locate in a debugger + */ + +void mprBreakpoint(const char *loc, const char *msg) +{ +} + +/******************************************************************************/ +#if (WIN || BREW_SIMULATOR) && BLD_DEBUG + +int crtReportHook(int type, char *msg, int *retval) +{ + printf("%s\n", msg); + *retval = 0; + return TRUE; +} + +#endif +/******************************************************************************/ +/* + * Initialize the memory subsystem + */ + +MprApp *mprAllocInit(MprAllocCback cback) +{ + MprAllocStats *stats; + MprApp *app; + MprSlab *slab; + MprBlk *bp, *sp; + int i; + + bp = malloc(sizeof(MprApp) + HDR_SIZE); + mprAssert(bp); + if (bp == 0) { + if (cback) { + (*cback)(0, sizeof(MprApp), 0, 0); + } + return 0; + } + memset(bp, 0, sizeof(MprApp) + HDR_SIZE); + + bp->parent = bp; + bp->size = sizeof(MprApp); + bp->flags = ALLOC_MAGIC; + bp->next = bp->prev = bp; + +#if BLD_FEATURE_ALLOC_LEAK_TRACK + bp->location = MPR_LOC; +#endif + + app = (MprApp*) GET_PTR(bp); + app->magic = APP_MAGIC; + + app->alloc.cback = cback; + app->stackStart = (void*) &app; + + bp->app = app; + + app->alloc.slabs = mprAllocZeroedBlock(MPR_LOC_PASS(app, MPR_LOC), + sizeof(MprSlab) * MPR_MAX_SLAB); + if (app->alloc.slabs == 0) { + mprFree(app); + return 0; + } + + /* + * The slab control structures must not be freed. Set keep to safeguard + * against accidents. + */ + sp = GET_HDR(app->alloc.slabs); + sp->flags |= ALLOC_FLAGS_KEEP; + + for (i = 0; i < MPR_MAX_SLAB; i++) { + /* + * This is overriden by requestors calling slabAlloc + */ + slab = &app->alloc.slabs[i]; + slab->preAllocateIncr = MPR_SLAB_DEFAULT_INC; + } + + /* + * Keep aggregated stats even in production code + */ + stats = &app->alloc.stats; + stats->bytesAllocated += sizeof(MprApp); + if (stats->bytesAllocated > stats->peakAllocated) { + stats->peakAllocated = stats->bytesAllocated; + } + stats->allocCount++; + +#if !BREW + rootCtx = app; +#endif +#if (WIN || BREW_SIMULATOR) && BLD_DEBUG + _CrtSetReportHook(crtReportHook); +#endif + return app; +} + +/******************************************************************************/ +/* + * Terminate the alloc module + */ + +void mprAllocTerm(MprApp *app) +{ + MprSlab *slabs; + MprBlk *appBlk, *slabBlk; + + /* + * Must do a carefully ordered cleanup. Need to free all children blocks + * before freeing the slab memory. Save a local pointer to the slabs. + */ + slabs = app->alloc.slabs; + + /* + * Free the app and all children. Set DONT_OS_FREE to prevent free() being + * called on app itself. We need that so we can free the slabs below. + */ + appBlk = GET_HDR(app); + appBlk->flags |= ALLOC_FLAGS_DONT_OS_FREE; + mprFree(app); + + /* + * Slabs are initially marked don't free. We must preserve them while all + * other blocks are freed. Then we clear the don't free flag and free. + * Now we don't have an app structure which is used by mprFree. We must + * fake it. + */ + slabBlk = GET_HDR(slabs); + slabBlk->flags &= ~ALLOC_FLAGS_KEEP; + mprFree(slabs); + + /* + * Now we can finally free the memory for the app structure + */ + free(appBlk); +} + +/******************************************************************************/ +/* + * Allocate a block + */ + +void *mprAllocBlock(MPR_LOC_DEC(ctx, loc), uint size) +{ + MprAllocStats *stats; + MprBlk *bp, *parent; + MprApp *app; + int diff; + + mprAssert(size > 0); + + if (ctx == 0) { +#if BREW + mprAssert(ctx); + return 0; +#else + ctx = rootCtx; +#endif + } + if (size == 0) { + size = 1; + } + + mprAssert(VALID_BLK(ctx)); + parent = GET_HDR(ctx); + mprAssert(VALID_HDR(parent)); + + CHECK_HDR(parent); + + size = ALLOC_ALIGN(size); + + app = parent->app; + + stats = &app->alloc.stats; + + mprLock(app->allocLock); + + stats->bytesAllocated += size + HDR_SIZE; + if (stats->bytesAllocated > stats->peakAllocated) { + stats->peakAllocated = stats->bytesAllocated; + } + + /* + * Prevent allocation if over the maximum + */ + if (stats->maxMemory && stats->bytesAllocated > stats->maxMemory) { + stats->bytesAllocated -= (size + HDR_SIZE); + mprUnlock(app->allocLock); + if (mprAllocException(MPR_LOC_PASS(ctx, loc), size, 0) < 0) { + return 0; + } + mprLock(app->allocLock); + } + + if ((bp = malloc(size + HDR_SIZE)) == 0) { + mprAssert(bp); + stats->errors++; + mprUnlock(app->allocLock); + mprAllocException(MPR_LOC_PASS(ctx, loc), size, 0); + return 0; + } + +#if BLD_DEBUG + memset(bp, 0xf7, size + HDR_SIZE); +#endif + +#if BLD_DEBUG && !BREW + if (bp == stopAlloc) { + mprBreakpoint(MPR_LOC, "breakOnAddr"); + } +#endif + + /* + * Warn if allocation puts us over the red line + */ + if (stats->redLine && stats->bytesAllocated > stats->redLine) { + mprUnlock(app->allocLock); + if (mprAllocException(MPR_LOC_PASS(ctx, loc), size, 1) < 0) { + return 0; + } + mprLock(app->allocLock); + } + + bp->size = size; + bp->flags = ALLOC_MAGIC; + bp->destructor = 0; + + bp->parent = parent; + + if (parent->children == 0) { + parent->children = bp; + bp->next = bp->prev = bp; + + } else { + /* + * Append to the end of the list. Preserve alloc order + */ + bp->next = parent->children; + bp->prev = parent->children->prev; + parent->children->prev->next = bp; + parent->children->prev = bp; + } + + bp->children = 0; + +#if BLD_FEATURE_ALLOC_LEAK_TRACK + bp->location = loc; +#endif + + bp->app = parent->app; + + VALIDATE_BLOCK(GET_PTR(bp)); + + stats->allocCount++; + + /* + * Monitor stack usage + */ + diff = (int) bp->app->stackStart - (int) &stats; + if (diff < 0) { + app->maxStack -= diff; + app->stackStart = (void*) &stats; + diff = 0; + } + + if ((uint) diff > app->maxStack) { + app->maxStack = diff; + } + mprUnlock(app->allocLock); + + return GET_PTR(bp); +} + +/******************************************************************************/ +/* + * Allocate and zero a block + */ + +void *mprAllocZeroedBlock(MPR_LOC_DEC(ctx, loc), uint size) +{ + void *newBlock; + + MprBlk *bp; + + bp = GET_HDR(ctx); + mprAssert(VALID_BLK(ctx)); + + newBlock = mprAllocBlock(MPR_LOC_PASS(ctx, loc), size); + if (newBlock) { + memset(newBlock, 0, size); + } + return newBlock; +} + +/******************************************************************************/ +/* + * Free a block of memory. Free all children recursively. + */ + +int mprFree(void *ptr) +{ + MprAllocStats *stats; + MprBlk *bp, *parent, *cp, *firstChild, *prev; + MprApp *app; + + if (ptr == 0) { + return 0; + } + + mprAssert(VALID_BLK(ptr)); + VALIDATE_BLOCK(ptr); + + bp = GET_HDR(ptr); + +#if BLD_DEBUG && !BREW + if (bp == stopAlloc) { + mprBreakpoint(MPR_LOC, "breakOnAddr"); + } +#endif + + mprAssert(bp); + mprAssert(VALID_HDR(bp)); + + CHECK_HDR(bp); + + /* + * Test if already freed + */ + mprAssert(! (bp->flags & ALLOC_FLAGS_FREE)); + if (bp->flags & ALLOC_FLAGS_FREE) { + return 0; + } + + /* + * Return if recursive freeing or this is a permanent block + */ + app = bp->app; + mprLock(app->allocLock); + if (bp->flags & (ALLOC_FLAGS_FREEING | ALLOC_FLAGS_KEEP)) { + mprUnlock(app->allocLock); + return 0; + } + bp->flags |= ALLOC_FLAGS_FREEING; + + + /* + * Call any destructors + */ + if (bp->destructor) { + mprUnlock(app->allocLock); + if ((bp->destructor)(ptr) < 0) { + return -1; + } + mprLock(app->allocLock); + bp->destructor = 0; + } + + /* + * Free the children. Free in reverse order so firstChild is preserved + * during the list scan as an end of list marker. + */ + if ((firstChild = bp->children) != 0) { + cp = firstChild->prev; + while (cp != firstChild) { + + mprAssert(VALID_HDR(cp)); + VALIDATE_BLOCK(GET_PTR(cp)); + + prev = cp->prev; + + /* + * FUTURE - OPT. Make this inline + */ + mprFree(GET_PTR(cp)); + + cp = prev; + } + + mprFree(GET_PTR(firstChild)); + + /* + * Just for clarity + */ + bp->children = 0; + } + + parent = bp->parent; + + mprAssert(VALID_HDR(parent)); + + /* + * Unlink from the parent + */ + if (parent->children == bp) { + if (bp->next == bp) { + parent->children = 0; + } else { + parent->children = bp->next; + } + } + + /* + * Remove from the sibling chain + */ + bp->prev->next = bp->next; + bp->next->prev = bp->prev; + + bp->flags |= ALLOC_FLAGS_FREE; + + /* + * Release the memory. If from a slab, return to the slab. Otherwise, + * return to the O/S. + */ + if (bp->flags & ALLOC_FLAGS_SLAB_BLOCK) { + slabFree(bp); + + } else { + mprAssert(bp); + + /* + * Update the stats + */ + stats = &bp->app->alloc.stats; + stats->bytesAllocated -= (bp->size + HDR_SIZE); + mprAssert(stats->bytesAllocated >= 0); + + stats->allocCount--; + mprAssert(stats->allocCount >= 0); + +#if BLD_DEBUG && !BREW + if (bp == stopAlloc) { + mprBreakpoint(MPR_LOC, "breakOnAddr"); + } +#endif + + /* + * Return to the O/S + */ + if (! (bp->flags & ALLOC_FLAGS_DONT_OS_FREE)) { + free(bp); + } + } + /* OPT */ + if (app != ptr) { + mprUnlock(app->allocLock); + } + + return 0; +} + +/******************************************************************************/ +/* + * Rallocate a block + */ + +void *mprReallocBlock(MPR_LOC_DEC(ctx, loc), void *ptr, uint size) +{ + MprBlk *bp, *newbp, *firstChild, *cp; + MprApp *app; + void *newPtr; + + mprAssert(VALID_BLK(ctx)); + mprAssert(size > 0); + + if (ptr == 0) { + return mprAllocBlock(MPR_LOC_PASS(ctx, loc), size); + } + + mprAssert(VALID_BLK(ptr)); + bp = GET_HDR(ptr); + mprAssert(bp); + mprAssert(VALID_HDR(bp)); + + CHECK_HDR(bp); + + if (size < bp->size) { + return ptr; + } + + newPtr = mprAllocBlock(MPR_LOC_PASS(ctx, loc), size); + if (newPtr == 0) { + bp->flags &= ~ALLOC_FLAGS_FREE; + free(bp); + return 0; + } + + newbp = GET_HDR(newPtr); + mprAssert(newbp->size >= size); + memcpy((char*) newbp + HDR_SIZE, (char*) bp + HDR_SIZE, bp->size); + mprAssert(newbp->size >= size); + + /* + * Fix the next / prev pointers + */ + app = bp->app; + mprLock(app->allocLock); + newbp->next->prev = newbp; + newbp->prev->next = newbp; + + /* + * Need to fix the parent pointer of all children + */ + if ((firstChild = newbp->children) != 0) { + cp = firstChild; + do { + cp->parent = newbp; + cp = cp->next; + } while (cp != firstChild); + } + + /* + * May need to set the children pointer of our parent + */ + if (newbp->parent->children == bp) { + newbp->parent->children = newbp; + } + + /* + * Free the original block + */ + mprFree(ptr); + + mprUnlock(app->allocLock); + + return GET_PTR(newbp); +} + +/******************************************************************************/ +/* + * Allocate a block from a slab + */ + +void *mprSlabAllocBlock(MPR_LOC_DEC(ctx, loc), uint size, uint inc) +{ + +#if NO_SLAB + return mprAllocBlock(MPR_LOC_PASS(ctx, loc), size); +#else + + MprBlk *parent, *bp; + MprSlabBlock *sb; + MprApp *app; + MprSlab *slab; + int slabIndex; + + if (ctx == 0) { + mprAssert(ctx); + return 0; + } + + mprAssert(size > 0); + mprAssert(VALID_BLK(ctx)); + + parent = GET_HDR(ctx); + mprAssert(VALID_HDR(parent)); + + CHECK_HDR(parent); + + size = SLAB_ALIGN(size); + + app = parent->app; + mprAssert(app); + + slabIndex = GET_SLAB(size); + + if (slabIndex < 0 || slabIndex >= MPR_MAX_SLAB) { + return mprAllocBlock(MPR_LOC_PASS(ctx, loc), size); + } + + /* + * Dequeue a block from the slab. "sb" will point to the user data + * portion of the block (i.e. after the MprBlk header). Slabs must be + * allocated off the "slabs" context to ensure they don't get freed + * until after all other blocks are freed. + */ + mprLock(app->allocLock); + slab = &app->alloc.slabs[slabIndex]; + if ((sb = slab->next) == 0) { + if (growSlab(MPR_LOC_ARGS(parent->app->alloc.slabs), + slab, size, inc) < 0) { + mprUnlock(app->allocLock); + return 0; + } + sb = slab->next; + } + mprAssert(sb); + + /* + * Dequeue the block + */ + slab->next = sb->next; + +#if BLD_FEATURE_ALLOC_STATS +{ + MprSlabStats *slabStats; + /* + * Update the slab stats + */ + slabStats = &slab->stats; + slabStats->totalAllocCount++; + slabStats->freeCount--; + slabStats->allocCount++; + if (slabStats->allocCount > slabStats->peakAllocCount) { + slabStats->peakAllocCount = slabStats->allocCount; + } +} +#endif /* BLD_FEATURE_ALLOC_STATS */ + + bp = GET_HDR(sb); + +#if BLD_DEBUG && !BREW + if (bp == stopAlloc) { + mprBreakpoint(MPR_LOC, "breakOnAddr"); + } +#endif + + bp->size = size; + bp->flags = ALLOC_MAGIC | ALLOC_FLAGS_SLAB_BLOCK; + bp->destructor = 0; + + bp->parent = parent; + + if (parent->children == 0) { + parent->children = bp; + bp->next = bp->prev = bp; + + } else { + /* + * Append to the end of the list. Preserve alloc order + */ + bp->next = parent->children; + bp->prev = parent->children->prev; + parent->children->prev->next = bp; + parent->children->prev = bp; + } + + bp->children = 0; + + bp->app = app; + +#if BLD_FEATURE_ALLOC_LEAK_TRACK + bp->location = loc; +#endif + mprUnlock(app->allocLock); + + return GET_PTR(bp); +#endif +} + +/******************************************************************************/ +/* + * Return a block back to its slab + */ + +static void slabFree(MprBlk *bp) +{ + MprSlab *slab; + MprApp *app; + void *ptr; + int slabIndex; + + mprAssert(VALID_HDR(bp)); + + slabIndex = GET_SLAB(bp->size); + mprAssert(0 <= slabIndex && slabIndex < MPR_MAX_SLAB); + + if (0 <= slabIndex && slabIndex < MPR_MAX_SLAB) { + mprLock(bp->app->allocLock); + slab = &bp->app->alloc.slabs[slabIndex]; + app = bp->app; + +#if BLD_DEBUG + memset(bp, 0xfc, bp->size + HDR_SIZE); +#endif + + ptr = GET_PTR(bp); + ((MprSlabBlock*) ptr)->next = slab->next; + slab->next = ((MprSlabBlock*) ptr); + +#if BLD_FEATURE_ALLOC_STATS +{ + MprSlabStats *slabStats; + slabStats = &slab->stats; + + slabStats->freeCount++; + slabStats->allocCount--; + + if (slabStats->freeCount >= slabStats->peakFreeCount) { + slabStats->peakFreeCount = slabStats->freeCount; + } +} +#endif + mprUnlock(app->allocLock); + } +} + +/******************************************************************************/ +/* + * Grow the slab and return the next free block + * Must be called locked. + */ + +static int growSlab(MPR_LOC_DEC(ctx, loc), MprSlab *slab, uint size, uint inc) +{ + MprBlk *bp; + MprSlabBlock *sb; + int i, chunkSize, len; + + mprAssert(VALID_BLK(ctx)); + mprAssert(slab); + mprAssert(size > 0); + + /* + * Take the maximum requested by anyone + */ + slab->preAllocateIncr = max(slab->preAllocateIncr, inc); + + /* + * We allocate an array of blocks each of user "size" bytes. + */ + chunkSize = HDR_SIZE + size; + len = chunkSize * slab->preAllocateIncr; + bp = mprAllocBlock(MPR_LOC_PASS(ctx, loc), len); + +#if BLD_DEBUG + memset(bp, 0xf1, len); +#endif + + if (bp == 0) { + mprAssert(0); + return MPR_ERR_MEMORY; + } + bp->flags |= ALLOC_FLAGS_IS_SLAB; + + /* + * We store the slab information in the user data portion + */ + sb = (MprSlabBlock*) GET_PTR(bp); + + + sb = (MprSlabBlock*) ((char*) sb + len - chunkSize); + for (i = slab->preAllocateIncr - 1; i >= 0; i--) { + sb->next = slab->next; + slab->next = sb; + sb = (MprSlabBlock*) ((char*) sb - chunkSize); + } + +#if BLD_FEATURE_ALLOC_STATS +{ + MprSlabStats *stats; + stats = &slab->stats; + stats->freeCount += slab->preAllocateIncr; + if (stats->freeCount > stats->peakFreeCount) { + stats->peakFreeCount = stats->freeCount; + } +} +#endif + + return 0; +} + +/******************************************************************************/ +/* + * Set the pre-allocate amount + */ + +int mprSetSlabPreAllocate(MprCtx ctx, int slabIndex, int preAllocateIncr) +{ + MprApp *app; + MprSlab *slab; + + mprAssert(VALID_BLK(ctx)); + mprAssert(0 <= slabIndex && slabIndex < MPR_MAX_SLAB); + mprAssert(preAllocateIncr > 0); + + if (0 <= slabIndex && slabIndex < MPR_MAX_SLAB) { + app = mprGetApp(ctx); + slab = &app->alloc.slabs[slabIndex]; + slab->preAllocateIncr = preAllocateIncr; + } else { + return MPR_ERR_BAD_ARGS; + } + return 0; +} + +/******************************************************************************/ + +void *mprSlabAllocZeroedBlock(MPR_LOC_DEC(ctx, loc), uint size, uint inc) +{ + void *newBlock; + + mprAssert(VALID_BLK(ctx)); + mprAssert(size > 0); + + newBlock = mprSlabAllocBlock(MPR_LOC_PASS(ctx, loc), size, inc); + if (newBlock) { + memset(newBlock, 0, size); + } + return newBlock; +} + +/******************************************************************************/ +/* + * Internal strdup function. Will use the slab allocator for small strings + */ + +char *mprStrdupInternal(MPR_LOC_DEC(ctx, loc), const char *str) +{ + char *newp; + int len; + + mprAssert(VALID_BLK(ctx)); + + if (str == 0) { + str = ""; + } + + len = strlen(str) + 1; + + if (len < MPR_SLAB_STR_MAX) { + newp = mprSlabAllocBlock(MPR_LOC_PASS(ctx, loc), MPR_SLAB_STR_MAX, + MPR_SLAB_STR_INC); + } else { + newp = mprAllocBlock(MPR_LOC_PASS(ctx, loc), len); + } + + if (newp) { + memcpy(newp, str, len); + } + + return newp; +} + +/******************************************************************************/ +/* + * Internal strndup function. Will use the slab allocator for small strings + */ + +char *mprStrndupInternal(MPR_LOC_DEC(ctx, loc), const char *str, uint size) +{ + char *newp; + uint len; + + mprAssert(VALID_BLK(ctx)); + + if (str == 0) { + str = ""; + } + len = strlen(str) + 1; + len = min(len, size); + + if (len < MPR_SLAB_STR_MAX) { + newp = mprSlabAllocBlock(MPR_LOC_PASS(ctx, loc), MPR_SLAB_STR_MAX, + MPR_SLAB_STR_INC); + } else { + newp = mprAllocBlock(MPR_LOC_PASS(ctx, loc), len); + } + + if (newp) { + memcpy(newp, str, len); + } + + return newp; +} + +/******************************************************************************/ +/* + * Internal memcpy function. Will use the slab allocator for small strings + */ + +void *mprMemdupInternal(MPR_LOC_DEC(ctx, loc), const void *ptr, uint size) +{ + char *newp; + + mprAssert(VALID_BLK(ctx)); + + if (size < MPR_SLAB_STR_MAX) { + newp = mprSlabAllocBlock(MPR_LOC_PASS(ctx, loc), MPR_SLAB_STR_MAX, + MPR_SLAB_STR_INC); + } else { + newp = mprAllocBlock(MPR_LOC_PASS(ctx, loc), size); + } + + if (newp) { + memcpy(newp, ptr, size); + } + + return newp; +} + +/******************************************************************************/ +/* + * Steal a block from one context and insert in another + */ + +int mprStealAllocBlock(MPR_LOC_DEC(ctx, loc), const void *ptr) +{ + MprBlk *bp, *parent; + + if (ptr == 0) { + return 0; + } + + mprAssert(VALID_BLK(ctx)); + mprAssert(VALID_BLK(ptr)); + + bp = GET_HDR(ptr); + +#if BLD_DEBUG && !BREW + if (bp == stopAlloc) { + mprBreakpoint(MPR_LOC, "breakOnAddr"); + } +#endif + + mprAssert(bp); + mprAssert(VALID_HDR(bp)); + mprAssert(ptr != mprGetAllocParent(ptr)); + + CHECK_HDR(bp); + + mprAssert(bp->prev); + mprAssert(bp->prev->next); + mprAssert(bp->next); + mprAssert(bp->next->prev); + + parent = bp->parent; + mprAssert(VALID_HDR(parent)); + + mprLock(bp->app->allocLock); + if (parent->children == bp) { + if (bp->next == bp) { + parent->children = 0; + } else { + parent->children = bp->next; + } + } + + bp->prev->next = bp->next; + bp->next->prev = bp->prev; + + parent = GET_HDR(ctx); + mprAssert(VALID_HDR(parent)); + bp->parent = parent; + + if (parent->children == 0) { + parent->children = bp; + bp->next = bp->prev = bp; + + } else { + bp->next = parent->children; + bp->prev = parent->children->prev; + parent->children->prev->next = bp; + parent->children->prev = bp; + } + +#if BLD_FEATURE_ALLOC_LEAK_TRACK + bp->location = loc; +#endif + + VALIDATE_BLOCK(GET_PTR(bp)); + + mprUnlock(bp->app->allocLock); + + return 0; +} + +/******************************************************************************/ + +void mprSetRequiredAlloc(MprCtx ptr, bool recurse) +{ + MprBlk *bp, *firstChild, *cp; + + bp = GET_HDR(ptr); + + bp->flags |= ALLOC_FLAGS_REQUIRED; + + if (recurse && (firstChild = bp->children) != 0) { + cp = firstChild; + do { + mprSetRequiredAlloc(GET_PTR(cp), recurse); + cp = cp->next; + } while (cp != firstChild); + } +} + +/******************************************************************************/ +/* + * Monitor stack usage. Return true if the stack has grown + */ + +int mprStackCheck(MprCtx ptr) +{ + MprApp *app; + int size; + + mprAssert(VALID_BLK(ptr)); + + app = mprGetApp(ptr); + + size = (int) app->stackStart - (int) &app; + if (size < 0) { + app->maxStack -= size; + app->stackStart = (void*) &app; + size = 0; + } + if ((uint) size > app->maxStack) { + app->maxStack = size; + return 1; + } + return 0; +} + +/******************************************************************************/ +/* + * Return the stack size + */ + +int mprStackSize(MprCtx ptr) +{ + MprApp *app; + + mprAssert(VALID_BLK(ptr)); + + app = mprGetApp(ptr); + return app->maxStack; +} + +/******************************************************************************/ + +static int mprAllocException(MPR_LOC_DEC(ctx, loc), uint size, bool granted) +{ + MprApp *app; + MprAlloc *alloc; + int rc; + + mprAssert(VALID_BLK(ctx)); + + app = mprGetApp(ctx); + alloc = &app->alloc; + + if (alloc->cback == 0) { + return 0; + } + + mprLock(app->allocLock); + if (alloc->inAllocException == 0) { + alloc->inAllocException = 1; + mprUnlock(app->allocLock); + + rc = (alloc->cback)(app, size, alloc->stats.bytesAllocated, granted); + + mprLock(app->allocLock); + app->alloc.inAllocException = 0; + mprUnlock(app->allocLock); + + return rc; + } + return 0; +} + +/******************************************************************************/ + +void mprSetAllocLimits(MprApp *app, uint redLine, uint maxMemory) +{ + app->alloc.stats.redLine = redLine; + app->alloc.stats.maxMemory = maxMemory; +} + +/******************************************************************************/ + +MprAllocCback mprSetAllocCallback(MprApp *app, MprAllocCback cback) +{ + MprAllocCback old; + + mprAssert(app); + mprAssert(VALID_BLK(app)); + + old = app->alloc.cback; + app->alloc.cback = cback; + return old; +} + +/******************************************************************************/ + +uint mprGetAllocBlockSize(MprCtx ptr) +{ + MprBlk *bp; + + mprAssert(VALID_BLK(ptr)); + + if (ptr == 0) { + return 0; + } + + bp = GET_HDR(ptr); + mprAssert(VALID_HDR(bp)); + + CHECK_HDR(bp); + + return bp->size; +} + +/******************************************************************************/ +/* + * Return the total block count used by a block including all children + */ + +uint mprGetAllocBlockCount(MprCtx ptr) +{ + MprBlk *bp, *firstChild, *cp; + uint count; + + mprAssert(VALID_BLK(ptr)); + + if (ptr == 0) { + return 0; + } + + bp = GET_HDR(ptr); + mprAssert(VALID_HDR(bp)); + + /* + * Add one for itself + */ + count = 1; + if ((firstChild = bp->children) != 0) { + cp = firstChild; + do { + count += mprGetAllocBlockCount(GET_PTR(cp)); + cp = cp->next; + } while (cp != firstChild); + } + return count; +} + +/******************************************************************************/ +/* + * Return the total of all memory allocated including slabs + */ + +uint mprGetAllocBlockMemory(MprCtx ptr) +{ + MprBlk *bp, *firstChild, *cp; + uint count; + + mprAssert(VALID_BLK(ptr)); + + if (ptr == 0) { + return 0; + } + + bp = GET_HDR(ptr); + mprAssert(VALID_HDR(bp)); + + count = bp->size + HDR_SIZE; + if ((firstChild = bp->children) != 0) { + cp = firstChild; + do { + count += mprGetAllocBlockMemory(GET_PTR(cp)); + cp = cp->next; + } while (cp != firstChild); + } + return count; +} + +/******************************************************************************/ +#if BLD_FEATURE_ALLOC_LEAK_TRACK + +const char *mprGetAllocLocation(MprCtx ptr) +{ + MprBlk *bp; + + if (ptr == 0) { + return 0; + } + mprAssert(VALID_BLK(ptr)); + + bp = GET_HDR(ptr); + mprAssert(VALID_HDR(bp)); + return bp->location; +} + +#endif +/******************************************************************************/ + +void *mprGetAllocParent(MprCtx ptr) +{ + MprBlk *bp; + + mprAssert(VALID_BLK(ptr)); + + if (ptr == 0) { + return 0; + } + + bp = GET_HDR(ptr); + mprAssert(VALID_HDR(bp)); + + CHECK_HDR(bp); + + return GET_PTR(bp->parent); +} + +/******************************************************************************/ + +MprAllocStats *mprGetAllocStats(MprApp *app) +{ + mprAssert(VALID_BLK(app)); + + return &app->alloc.stats; +} + +/******************************************************************************/ +#if BLD_FEATURE_ALLOC_STATS + +MprSlabStats *mprGetSlabAllocStats(MprApp *app, int slabIndex) +{ + MprSlab *slab; + + mprAssert(VALID_BLK(app)); + + if (0 <= slabIndex && slabIndex < MPR_MAX_SLAB) { + slab = &app->alloc.slabs[slabIndex]; + return &slab->stats; + } + + mprAssert(0 <= slabIndex && slabIndex < MPR_MAX_SLAB); + return 0; +} + +#endif /* BLD_FEATURE_ALLOC_STATS */ +/******************************************************************************/ +#if BLD_DEBUG + +int mprPrintAllocBlocks(MprCtx ptr, int indent) +{ + MprBlk *bp, *firstChild, *cp; + const char *location; + int subTotal, size, indentSpaces, code; + + subTotal = 0; + + bp = GET_HDR(ptr); + + if (! (bp->flags & ALLOC_FLAGS_REQUIRED)) { + size = bp->size + HDR_SIZE; + + /* + * Take one level off because we don't trace app + */ + indentSpaces = indent; + + if (bp->flags & ALLOC_FLAGS_REQUIRED) { + code = 'R'; + } else if (bp->flags & ALLOC_FLAGS_IS_SLAB) { + code = 'S'; + } else { + code = ' '; + } + +#if BLD_FEATURE_ALLOC_LEAK_TRACK + location = bp->location; +#else + location = ""; +#endif + mprLog(bp->app, 0, + "%c %.*s %-16s %.*s size %5d has %3d deps, total %6d", code, + indentSpaces, " ", + mprGetBaseName(location), + 8 - indent, " ", + size, + mprGetAllocBlockCount(GET_PTR(bp)), + mprGetAllocBlockMemory(GET_PTR(bp)) + /* (uint) bp */ + ); + + subTotal += size; + } + + if ((firstChild = bp->children) != 0) { + cp = firstChild; + do { + subTotal += mprPrintAllocBlocks(GET_PTR(cp), indent + 2); + cp = cp->next; + } while (cp != firstChild); + } + + return subTotal; +} + +#endif +/******************************************************************************/ +#if BLD_FEATURE_ALLOC_STATS +/* + * Print a memory allocation report that includes a list of allocated blocks + * and a statistics summary + */ + +void mprPrintAllocReport(MprApp *app, bool printBlocks, const char *msg) +{ + MprSlabStats *stats; + uint total; + int i, size; + + mprAssert(VALID_BLK(app)); + + if (msg) { + mprLog(app, 0, " "); + mprLog(app, 0, "%s", msg); + } + +#if BLD_DEBUG + /* + * Do block stats + */ + if (printBlocks) { + int sum; + mprLog(app, 0, " "); + sum = mprPrintAllocBlocks(app, 0); + if (sum) { + mprLog(app, 0, " Sum of blocks %d", sum); + } else { + mprLog(app, 0, " None"); + } + } +#endif + + /* + * Do Slab stats + */ + mprLog(app, 0, " "); + mprLog(app, 0, "MPR Slab Memory Stats"); + mprLog(app, 0, " "); + + mprLog(app, 0, + " Index Size Total Allocated Free PeakAlloc PeakFree TotalAlloc"); + + total = 0; + for (i = 0; i < MPR_MAX_SLAB; i++) { + stats = &app->alloc.slabs[i].stats; + size = 1 << (i + 5); + if (stats->totalAllocCount > 0) { + mprLog(app, 0, " %2d %6d %8d %9d %6d %9d %8d %10d", + i, size, size * (stats->allocCount + stats->freeCount), + stats->allocCount, stats->freeCount, + stats->peakAllocCount, stats->peakFreeCount, + stats->totalAllocCount); + total += size * (stats->allocCount + stats->freeCount); + } + } + mprLog(app, 0, " "); + mprLog(app, 0, "MPR Total Allocated Slab RAM: %10d", total); + mprLog(app, 0, "MPR Total Allocated RAM: %10d", + mprGetAllocatedMemory(app)); + mprLog(app, 0, "MPR Peak Allocated RAM: %10d", + mprGetPeakAllocatedMemory(app)); + mprLog(app, 0, " "); +} + +/******************************************************************************/ +/* + * Return the total memory allocated. + */ + +uint mprGetAllocatedMemory(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + + return app->alloc.stats.bytesAllocated; +} + +/******************************************************************************/ +/* + * Return the peak memory allocated. + */ + +uint mprGetPeakAllocatedMemory(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + + return app->alloc.stats.peakAllocated; +} + +/******************************************************************************/ +/* + * Return memory in the MPR slab. This excludes the EJS slabs + */ + +uint mprGetAllocatedSlabMemory(MprCtx ctx) +{ + MprApp *app; + MprSlabStats *stats; + uint total; + int i, size; + + app = mprGetApp(ctx); + + total = 0; + for (i = 0; i < MPR_MAX_SLAB; i++) { + stats = &app->alloc.slabs[i].stats; + size = 1 << (i + 5); + if (stats->totalAllocCount > 0) { + total += size * (stats->allocCount + stats->freeCount); + } + } + return total; +} + +#endif /* BLD_FEATURE_ALLOC_STATS */ +/******************************************************************************/ + +MprDestructor mprSetDestructor(MprCtx ptr, MprDestructor destructor) +{ + MprDestructor old; + MprBlk *bp; + + mprAssert(VALID_BLK(ptr)); + + if (ptr == 0) { + return 0; + } + + bp = GET_HDR(ptr); + + mprAssert(bp); + mprAssert(VALID_HDR(bp)); + mprAssert(ptr != mprGetAllocParent(ptr)); + + CHECK_HDR(bp); + + old = bp->destructor; + bp->destructor = destructor; + + return old; +} + +/******************************************************************************/ + +int mprIsAllocBlockValid(MprCtx ptr) +{ + MprBlk *bp; + + bp = GET_HDR(ptr); + return (bp && VALID_HDR(bp)); +} + +/******************************************************************************/ +#if VALIDATE_ALLOC +/* + * Exhaustive validation of the block and its children. Does not go recursive + * as it would be too slow. + */ + +int mprValidateBlock(MprCtx ptr) +{ + MprBlk *bp, *parent, *cp, *firstChild; + int count; + + mprAssert(ptr); + mprAssert(VALID_BLK(ptr)); + + bp = GET_HDR(ptr); + + mprAssert(bp); + mprAssert(VALID_HDR(bp)); + mprAssert(VALID_HDR(bp->parent)); + + if (ptr != bp->app) { + mprAssert(bp != bp->parent); + } + mprAssert(! (bp->flags & ALLOC_FLAGS_FREE)); + mprAssert(! (bp->flags & ALLOC_FLAGS_FREEING)); + + /* + * + */ + count = 0; + parent = bp->parent; + + if ((firstChild = bp->children) != 0) { + cp = firstChild; + mprAssert((int) cp != 0xfeefee); + do { + mprAssert(bp->next->prev == bp); + mprAssert(bp->prev->next == bp); + mprAssert(bp->prev->parent == parent); + mprAssert(bp->next->parent == parent); + + count++; + cp = cp->next; + + if (bp->next == bp) { + mprAssert(bp->prev == bp); + if (ptr != bp->app) { + mprAssert(parent->children == bp); + } + } + if (bp->prev == bp) { + mprAssert(bp->next == bp); + if (ptr != bp->app) { + mprAssert(parent->children == bp); + } + } + } while (cp != firstChild); + } + + return 0; +} + +#endif +/******************************************************************************/ +/* + * Validate a block and all children + */ + +int mprValidateAllocTree(MprCtx ptr) +{ +#if VALIDATE_ALLOC + MprBlk *bp, *cp, *firstChild; + + mprAssert(ptr); + mprAssert(VALID_BLK(ptr)); + + bp = GET_HDR(ptr); + + mprValidateBlock(GET_PTR(bp)); + + if ((firstChild = bp->children) != 0) { + cp = firstChild; + do { + mprValidateAllocTree(GET_PTR(cp)); + cp = cp->next; + } while (cp != firstChild); + } + +#endif + return 0; +} + +/******************************************************************************/ +#if UNUSED && FUTURE +/* + * Exhaustive validation of the block and its children. Does not go recursive + * as it would be too slow. + */ + +int mprValidateSlabs(MprApp *app) +{ + MprSlab *slab; + MprSlabStats *slabStats; + MprSlabBlock *sp; + int count, i; + + for (i = 0; i < MPR_MAX_SLAB; i++) { + slab = &app->alloc.slabs[i]; + slabStats = &slab->stats; + + count = 0; + for (sp = slab->next; sp; sp = sp->next) { + count++; + } + mprAssert(count == (int) slabStats->freeCount); + } + return 0; +} + +#endif +/******************************************************************************/ + +void mprAllocAbort() +{ +#if BREW + printf("Bad block header"); +#else + exit(255); +#endif +} + +/******************************************************************************/ +#undef mprGetApp +/* + * Get the root parent from any block (which is the MprApp structure) + */ + +MprApp *mprGetApp(MprCtx ptr) +{ + MprBlk *bp; + + mprAssert(ptr); + + bp = GET_HDR(ptr); + mprAssert(VALID_HDR(bp)); + + CHECK_HDR(bp); + + mprAssert(bp->app->magic == APP_MAGIC); + + return bp->app; +} + +/******************************************************************************/ + +int mprGetAllocErrors(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + return app->alloc.stats.errors; +} + +/******************************************************************************/ + +void mprClearAllocErrors(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + app->alloc.stats.errors = 0; +} + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprArray.c b/source4/lib/appweb/ejs-2.0/mpr/mprArray.c new file mode 100644 index 0000000000..95b0a14450 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprArray.c @@ -0,0 +1,385 @@ +/** + * @file mprArray.c + * @brief Growable array structure + * @overview Simple growable array structure. + * @remarks Most routines in this file are not thread-safe. It is the callers + * responsibility to perform all thread synchronization. + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ + +#include "mpr.h" + +/******************************************************************************/ +/* + * Create a general growable array structure. Use mprFree to destroy. + */ + +MprArray *mprCreateItemArrayInternal(MPR_LOC_DEC(ctx, loc), int initialSize, + int maxSize) +{ + MprArray *array; + int size; + + mprAssert(initialSize <= maxSize); + + array = (MprArray*) mprSlabAllocZeroedBlock(MPR_LOC_PASS(ctx, loc), + sizeof(MprArray), 0); + if (array == 0) { + return 0; + } + + if (initialSize == 0) { + initialSize = MPR_ARRAY_INCR; + } + if (maxSize == 0) { + maxSize = MAXINT; + } + size = initialSize * sizeof(void*); + + array->items = (void**) mprSlabAllocBlock(MPR_LOC_PASS(array, loc), + size, 0); + + if (array->items == 0) { + mprFree(array); + return 0; + } + + array->capacity = initialSize; + array->maxSize = maxSize; + array->incr = min(initialSize * 2, (array->maxSize - array->length)); + array->length = 0; + + return array; +} + +/******************************************************************************/ +/* + * Add an item to the array + */ + +int mprAddItem(MprArray *array, void *item) +{ + int memsize, index, len; + + mprAssert(array); + mprAssert(array->capacity >= 0); + mprAssert(array->length >= 0); + + if (array->length < array->capacity) { + /* + * Room to fit in the current capacity + */ + index = array->length++; + array->items[index] = item; + return index; + } + mprAssert(array->length == array->capacity); + + /* + * Need to grow the array + */ + if (array->capacity >= array->maxSize) { + mprAssert(array->capacity < array->maxSize); + return MPR_ERR_TOO_MANY; + } + + len = array->capacity + array->incr; + memsize = len * sizeof(void*); + + /* + * Grow the array of items + */ + + array->items = (void**) mprRealloc(array, array->items, memsize); + + /* + * Zero the new portion + */ + memset(&array->items[array->capacity], 0, sizeof(void*) * array->incr); + array->capacity = len; + + array->incr = min(array->incr * 2, (array->maxSize - array->length)); + + index = array->length++; + array->items[index] = item; + + return index; +} + +/******************************************************************************/ +/* + * Remove an item from the array + */ + +int mprRemoveItem(MprArray *array, void *item) +{ + int index; + + mprAssert(array); + mprAssert(array->capacity > 0); + mprAssert(array->length > 0); + + index = mprFindItem(array, item); + if (index < 0) { + return index; + } + + return mprRemoveItemByIndex(array, index); +} + +/******************************************************************************/ +/* + * Remove an index from the array + */ + +int mprRemoveItemByIndex(MprArray *array, int index) +{ + void **items; + int i; + + mprAssert(array); + mprAssert(array->capacity > 0); + mprAssert(index >= 0 && index < array->capacity); + mprAssert(array->items[index] != 0); + mprAssert(array->length > 0); + + if (index < 0 || index >= array->length) { + return MPR_ERR_NOT_FOUND; + } + + /* + * Copy down to compress + */ + items = array->items; + for (i = index; i < (array->length - 1); i++) { + items[i] = items[i + 1]; + } + array->length--; + +#if BLD_DEBUG + if (array->length < array->capacity) { + items[array->length] = 0; + } +#endif + return 0; +} + +/******************************************************************************/ + +int mprRemoveRangeOfItems(MprArray *array, int start, int end) +{ + void **items; + int i, count; + + mprAssert(array); + mprAssert(array->capacity > 0); + mprAssert(array->length > 0); + mprAssert(start > end); + + if (start < 0 || start >= array->length) { + return MPR_ERR_NOT_FOUND; + } + if (end < 0 || end >= array->length) { + return MPR_ERR_NOT_FOUND; + } + if (start > end) { + return MPR_ERR_BAD_ARGS; + } + + /* + * Copy down to compress + */ + items = array->items; + count = end - start; + for (i = start; i < (array->length - count); i++) { + items[i] = items[i + count]; + } + array->length -= count; + +#if BLD_DEBUG + if (array->length < array->capacity) { + for (i = array->length; i < array->capacity; i++) { + items[i] = 0; + } + } +#endif + return 0; +} + +/******************************************************************************/ + +void *mprGetItem(MprArray *array, int index) +{ + mprAssert(array); + + if (index < 0 || index >= array->length) { + return 0; + } + return array->items[index]; +} + +/******************************************************************************/ + +void *mprGetFirstItem(MprArray *array, int *last) +{ + mprAssert(array); + mprAssert(last); + + if (array == 0) { + return 0; + } + + *last = 0; + + if (array->length == 0) { + return 0; + } + return array->items[0]; +} + +/******************************************************************************/ + +void *mprGetNextItem(MprArray *array, int *last) +{ + int index; + + mprAssert(array); + mprAssert(last); + mprAssert(*last >= 0); + + index = *last; + + if (++index < array->length) { + *last = index; + return array->items[index]; + } + return 0; +} + +/******************************************************************************/ + +void *mprGetPrevItem(MprArray *array, int *last) +{ + int index; + + mprAssert(array); + mprAssert(last); + mprAssert(*last >= 0); + + if (array == 0) { + return 0; + } + + index = *last; + + if (--index < array->length && index >= 0) { + *last = index; + return array->items[index]; + } + return 0; +} + +/******************************************************************************/ + +int mprGetItemCount(MprArray *array) +{ + mprAssert(array); + + if (array == 0) { + return 0; + } + + return array->length; +} + +/******************************************************************************/ + +int mprGetItemCapacity(MprArray *array) +{ + mprAssert(array); + + if (array == 0) { + return 0; + } + + return array->capacity; +} + +/******************************************************************************/ + +void mprClearAndFreeItems(MprArray *array) +{ + int i; + + mprAssert(array); + + for (i = 0; i < array->length; i++) { + mprFree(array->items[i]); + } +} + +/******************************************************************************/ + +void mprClearItems(MprArray *array) +{ + mprAssert(array); + + array->length = 0; +} + +/******************************************************************************/ + +int mprFindItem(MprArray *array, void *item) +{ + int i; + + mprAssert(array); + + for (i = 0; i < array->length; i++) { + if (array->items[i] == item) { + return i; + } + } + return MPR_ERR_NOT_FOUND; +} + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprBuf.c b/source4/lib/appweb/ejs-2.0/mpr/mprBuf.c new file mode 100644 index 0000000000..ba9888a9fc --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprBuf.c @@ -0,0 +1,535 @@ +/** + * @file mprBuf.c + * @brief Dynamic buffer module + * @overview + * @remarks + */ + +/******************************************************************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + + +/********************************** Includes **********************************/ + +#include "mpr.h" + +/**************************** Forward Declarations ****************************/ + +static int grow(MprBuf *bp); + +/*********************************** Code *************************************/ +/* + * Create a new buffer. "maxsize" is the limit to which the buffer can + * ever grow. -1 means no limit. The buffer can ever only fix maxsize-1 bytes. + * "initialSize" is used to define the amount to increase the size of the + * buffer each time if it becomes full. (Note: grow() will exponentially + * increase this number for performance.) + */ + +MprBuf *mprCreateBuf(MprCtx ctx, int initialSize, int maxSize) +{ + MprBuf *bp; + + if (initialSize <= 0) { + initialSize = MPR_DEFAULT_ALLOC; + } + bp = mprAllocTypeZeroed(ctx, MprBuf); + bp->growBy = MPR_BUFSIZE; + bp->maxsize = 0; + mprSetBufSize(bp, initialSize, maxSize); + return bp; +} + +/******************************************************************************/ +/* + * Set the initial buffer parameters and create the first buffer + */ + +void mprSetBufSize(MprBuf *bp, int initialSize, int max) +{ + mprAssert(initialSize > 0); + + if (max > 0 && initialSize > max) { + initialSize = max; + } + + if (bp->buf && bp->growBy > 0) { + mprFree(bp->buf); + } + + bp->buf = (uchar*) mprAlloc(bp, initialSize); + bp->growBy = initialSize; + bp->maxsize = max; + bp->buflen = initialSize; + bp->endbuf = &bp->buf[bp->buflen]; + bp->start = bp->buf; + bp->end = bp->buf; + *bp->start = '\0'; +} + +/******************************************************************************/ + +char *mprStealBuf(MprCtx ctx, MprBuf *bp) +{ + char *str; + + str = (char*) bp->start; + + mprStealAllocBlock(MPR_LOC_ARGS(ctx), bp->start); + + bp->start = bp->end = bp->buf = bp->endbuf = 0; + bp->buflen = 0; + + return str; +} + +/******************************************************************************/ + +void mprAddNullToBuf(MprBuf *bp) +{ + *((char*) bp->end) = (char) '\0'; +} + +/******************************************************************************/ + +void mprAdjustBufEnd(MprBuf *bp, int size) +{ + mprAssert(bp->buflen == (bp->endbuf - bp->buf)); + mprAssert(size < bp->buflen); + + bp->end += size; + if (bp->end >= bp->endbuf) { + bp->end -= bp->buflen; + } + if (bp->end < bp->buf) { + bp->end += bp->buflen; + } + + if (bp->end >= bp->endbuf) { + mprAssert(bp->end < bp->endbuf); + mprFlushBuf(bp); + } +} + +/******************************************************************************/ +/* + * Adjust the start pointer after a user copy + */ + +void mprAdjustBufStart(MprBuf *bp, int size) +{ + mprAssert(bp->buflen == (bp->endbuf - bp->buf)); + mprAssert(size < bp->buflen); + + bp->start += size; + while (bp->start >= bp->endbuf) { + bp->start -= bp->buflen; + } + while (bp->start < bp->buf) { + bp->start += bp->buflen; + } + + /* + * Flush the buffer if the start pointer is corrupted via a bad size + */ + if (bp->start >= bp->endbuf) { + mprAssert(bp->start < bp->endbuf); + mprFlushBuf(bp); + } +} + + +/******************************************************************************/ + +void mprFlushBuf(MprBuf *bp) +{ + bp->start = bp->buf; + bp->end = bp->buf; +} + +/******************************************************************************/ + +int mprGetCharFromBuf(MprBuf *bp) +{ + int c; + + if (bp->start == bp->end) { + return -1; + } + c = (uchar) *bp->start++; + if (bp->start >= bp->endbuf) { + bp->start = bp->buf; + } + return c; +} + +/******************************************************************************/ + +int mprGetBlockFromBuf(MprBuf *bp, uchar *buf, int size) +{ + int thisLen, bytesRead; + + mprAssert(buf); + mprAssert(size > 0); + mprAssert(bp->buflen == (bp->endbuf - bp->buf)); + + /* + * Get the max bytes in a straight copy + */ + bytesRead = 0; + while (size > 0) { + thisLen = mprGetBufLinearData(bp); + thisLen = min(thisLen, size); + if (thisLen <= 0) { + break; + } + + memcpy(buf, bp->start, thisLen); + buf += thisLen; + bp->start += thisLen; + size -= thisLen; + bytesRead += thisLen; + + if (bp->start >= bp->endbuf) { + bp->start = bp->buf; + } + } + return bytesRead; +} + +/******************************************************************************/ + +int mprGetBufLength(MprBuf *bp) +{ + if (bp->start > bp->end) { + return (bp->buflen + (bp->end - bp->start)); + } else { + return (bp->end - bp->start); + } +} + +/******************************************************************************/ + +int mprGetBufLinearData(MprBuf *bp) +{ + return min(mprGetBufLength(bp), (bp->endbuf - bp->start)); +} + +/******************************************************************************/ + +int mprGetBufLinearSpace(MprBuf *bp) +{ + int len = mprGetBufLength(bp); + int space = bp->buflen - len - 1; + return min((bp->endbuf - bp->end), space); +} + +/******************************************************************************/ + +int mprGetBufSize(MprBuf *bp) +{ + return bp->buflen; +} + +/******************************************************************************/ + +int mprGetBufSpace(MprBuf *bp) +{ + return bp->buflen - mprGetBufLength(bp) - 1; +} + +/******************************************************************************/ + +char *mprGetBufOrigin(MprBuf *bp) +{ + return (char*) bp->buf; +} + +/******************************************************************************/ + +char *mprGetBufStart(MprBuf *bp) +{ + return (char*) bp->start; +} + +/******************************************************************************/ + +char *mprGetBufEnd(MprBuf *bp) +{ + return (char*) bp->end; +} + +/******************************************************************************/ + +int mprInsertCharToBuf(MprBuf *bp, int c) +{ + char *cp; + int space; + + mprAssert(bp->buflen == (bp->endbuf - bp->buf)); + + space = bp->buflen - mprGetBufLength(bp) - 1; + if (space < (int) sizeof(char)) { + if (!grow(bp)) { + return -1; + } + } + if (bp->start <= bp->buf) { + bp->start = bp->endbuf; + } + cp = (char*) bp->start; + *--cp = (char) c; + bp->start = (uchar *) cp; + return 0; +} + +/******************************************************************************/ + +int mprLookAtNextCharInBuf(MprBuf *bp) +{ + if (bp->start == bp->end) { + return -1; + } + return *bp->start; +} + +/******************************************************************************/ + +int mprLookAtLastCharInBuf(MprBuf *bp) +{ + if (bp->start == bp->end) { + return -1; + } + return (bp->end == bp->buf) ? bp->endbuf[-1] : bp->end[-1]; +} + +/******************************************************************************/ + +int mprPutCharToBuf(MprBuf *bp, int c) +{ + char *cp; + int space; + + mprAssert(bp->buflen == (bp->endbuf - bp->buf)); + + space = bp->buflen - mprGetBufLength(bp) - 1; + if (space < (int) sizeof(char)) { + if (! grow(bp)) { + return -1; + } + } + + cp = (char*) bp->end; + *cp++ = (char) c; + bp->end = (uchar *) cp; + if (bp->end >= bp->endbuf) { + bp->end = bp->buf; + } + *((char*) bp->end) = (char) '\0'; + return 0; +} + +/******************************************************************************/ + +int mprPutBlockToBuf(MprBuf *bp, const char *str, int size) +{ + int thisLen, bytes, space; + + mprAssert(str); + mprAssert(size >= 0); + mprAssert(bp->buflen == (bp->endbuf - bp->buf)); + + /* + * Add the max we can in one copy + */ + bytes = 0; + while (size > 0) { + space = mprGetBufLinearSpace(bp); + thisLen = min(space, size); + if (thisLen <= 0) { + if (! grow(bp)) { + break; + } + space = mprGetBufLinearSpace(bp); + thisLen = min(space, size); + } + + memcpy(bp->end, str, thisLen); + str += thisLen; + bp->end += thisLen; + size -= thisLen; + bytes += thisLen; + + if (bp->end >= bp->endbuf) { + bp->end = bp->buf; + } + } + *((char*) bp->end) = (char) '\0'; + return bytes; +} + +/******************************************************************************/ + +int mprPutStringToBuf(MprBuf *bp, const char *str) +{ + return mprPutBlockToBuf(bp, str, strlen(str)); +} + +/******************************************************************************/ + +int mprPutFmtStringToBuf(MprBuf *bp, const char *fmt, ...) +{ + va_list ap; + char *buf; + int rc, len, space; + + va_start(ap, fmt); + space = mprGetBufLinearSpace(bp); + + /* + * Add max that the buffer can grow + */ + space += (bp->maxsize - bp->buflen - 1); + + len = mprAllocVsprintf(MPR_LOC_ARGS(bp), &buf, space, fmt, ap); + rc = mprPutBlockToBuf(bp, buf, len); + + mprFree(buf); + va_end(ap); + return rc; +} + +/******************************************************************************/ +/* + * Grow the buffer to fit new data. Return 1 if the buffer can grow. + * Grow using the growBy size specified when creating the buffer. + */ + +static int grow(MprBuf *bp) +{ + uchar *newbuf; + + if (bp->maxsize > 0 && bp->buflen >= bp->maxsize) { + return 0; + } + + newbuf = (uchar*) mprAlloc(bp, bp->buflen + bp->growBy); + if (bp->buf) { + memcpy(newbuf, bp->buf, bp->buflen); + mprFree(bp->buf); + } + + bp->buflen += bp->growBy; + bp->end = newbuf + (bp->end - bp->buf); + bp->start = newbuf + (bp->start - bp->buf); + bp->buf = newbuf; + bp->endbuf = &bp->buf[bp->buflen]; + + /* + * Increase growBy to reduce overhead + */ + bp->growBy *= 2; + if (bp->maxsize > 0 && (bp->buflen + bp->growBy) > bp->maxsize) { + bp->growBy = bp->maxsize - bp->buflen; + } + return 1; +} + +/******************************************************************************/ +/* + * Add a number to the buffer (always null terminated). + */ + +int mprPutIntToBuf(MprBuf *bp, int i) +{ + char numBuf[16]; + int rc; + + mprItoa(numBuf, sizeof(numBuf), i); + rc = mprPutStringToBuf(bp, numBuf); + *((char*) bp->end) = (char) '\0'; + + return rc; +} + +/******************************************************************************/ + +void mprCopyBufDown(MprBuf *bp) +{ + if (mprGetBufLength(bp) == 0) { + mprFlushBuf(bp); + return; + } + memmove(bp->buf, bp->start, (bp->end - bp->start)); + bp->end -= (bp->start - bp->buf); + bp->start = bp->buf; +} + +/******************************************************************************/ + +MprBufProc mprGetBufRefillProc(MprBuf *bp) +{ + return bp->refillProc; +} + +/******************************************************************************/ + +void mprSetBufRefillProc(MprBuf *bp, MprBufProc fn, void *arg) +{ + bp->refillProc = fn; + bp->refillArg = arg; +} + +/******************************************************************************/ + +int mprRefillBuf(MprBuf *bp) +{ + return (bp->refillProc) ? (bp->refillProc)(bp, bp->refillArg) : 0; +} + +/******************************************************************************/ + +void mprResetBufIfEmpty(MprBuf *bp) +{ + if (mprGetBufLength(bp) == 0) { + mprFlushBuf(bp); + } +} + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprGenFile.c b/source4/lib/appweb/ejs-2.0/mpr/mprGenFile.c new file mode 100644 index 0000000000..517e43853f --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprGenFile.c @@ -0,0 +1,336 @@ +/** + * @file mprGenFile.c + * @brief Generic File services + * @overview + * @remarks + * See OS/mprFile.c for the per O/S portions + */ + +/******************************************************************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ + +#include "mpr.h" + +/****************************** Forward Declarations **************************/ +#if !BREW + +static int closeDestructor(void *data); + +/************************************ Code ************************************/ + +int mprStartFileServices(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + app->console = mprAllocTypeZeroed(ctx, MprFile); + app->error = mprAllocTypeZeroed(ctx, MprFile); + + /* + * We assume that STDOUT is 1 and STDERR is 2 + */ + app->console->fd = 1; + app->error->fd = 2; + + return 0; +} + +/******************************************************************************/ + +void mprStopFileServices(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + + mprFree(app->console); + app->console = 0; + mprFree(app->error); + app->error = 0; +} + +/******************************************************************************/ + +MprFile *mprOpen(MprCtx ctx, const char *path, int omode, int perms) +{ + MprFile *file; + + mprAssert(path && *path); + + file = mprAllocTypeZeroed(ctx, MprFile); + + file->fd = open(path, omode, perms); + if (file->fd < 0) { + mprFree(file); + return 0; + } + + mprSetDestructor(file, closeDestructor); + return file; +} + +/******************************************************************************/ + +static int closeDestructor(void *data) +{ + MprFile *file = (MprFile*) data; + + mprAssert(file); + + mprClose(file); + return 0; +} + +/******************************************************************************/ + +void mprClose(MprFile *file) +{ + mprAssert(file); + + if (file < 0) { + return; + } + + mprAssert(file->fd >= 0); + close(file->fd); + + mprSetDestructor(file, 0); + mprFree(file); +} + +/******************************************************************************/ + +int mprRead(MprFile *file, void *buf, uint size) +{ + mprAssert(file); + + if (file == 0) { + return MPR_ERR_BAD_HANDLE; + } + + return read(file->fd, buf, size); +} + +/******************************************************************************/ + +int mprWrite(MprFile *file, const void *buf, uint count) +{ + mprAssert(file); + + if (file == 0) { + return MPR_ERR_BAD_HANDLE; + } + + return write(file->fd, buf, count); +} + +/******************************************************************************/ + +int mprSeek(MprFile *file, int seekType, long distance) +{ + mprAssert(file); + + if (file == 0) { + return MPR_ERR_BAD_HANDLE; + } + + return lseek(file->fd, seekType, distance); +} + +/******************************************************************************/ + +int mprDelete(MprCtx ctx, const char *path) +{ + return unlink(path); +} + +/******************************************************************************/ + +int mprDeleteDir(MprCtx ctx, const char *path) +{ + return rmdir(path); +} + +#endif /* !BREW */ +/******************************************************************************/ + +char *mprGets(MprFile *file, char *buf, uint size) +{ + MprBuf *bp; + int count, len, c; + + mprAssert(file); + + if (file == 0) { + return 0; + } + + if (file->buf == 0) { + file->buf = mprCreateBuf(file, MPR_DEFAULT_ALLOC, MPR_MAX_STRING); + } + bp = file->buf; + + /* + * Must leave room for null + */ + count = 0; + while (--size > 0) { + if (mprGetBufLength(bp) == 0) { + mprFlushBuf(bp); + len = mprRead(file, mprGetBufEnd(bp), + mprGetBufLinearSpace(bp)); + if (len <= 0) { + return 0; + } + mprAdjustBufEnd(bp, len); + mprAddNullToBuf(bp); + } + if ((c = mprGetCharFromBuf(bp)) == '\n') { + buf[count] = '\0'; + return buf; + } + buf[count++] = c; + } + buf[count] = '\0'; + return buf; +} + +/******************************************************************************/ + +int mprPuts(MprFile *file, const char *writeBuf, uint count) +{ + MprBuf *bp; + char *buf; + int total, bytes, len; + + mprAssert(file); + + /* + * Buffer output and flush when full. + */ + if (file->buf == 0) { + file->buf = mprCreateBuf(file, MPR_BUFSIZE, 0); + if (file->buf == 0) { + return MPR_ERR_CANT_ALLOCATE; + } + } + bp = file->buf; + + if (mprGetBufLength(bp) > 0 && mprGetBufSpace(bp) < (int) count) { + len = mprGetBufLength(bp); + if (mprWrite(file, mprGetBufStart(bp), len) != len) { + return MPR_ERR_CANT_WRITE; + } + mprFlushBuf(bp); + } + + total = 0; + buf = (char*) writeBuf; + + while (count > 0) { + bytes = mprPutBlockToBuf(bp, buf, count); + if (bytes <= 0) { + return MPR_ERR_CANT_ALLOCATE; + } + count -= bytes; + buf += bytes; + total += bytes; + mprAddNullToBuf(bp); + + if (count > 0) { + len = mprGetBufLength(bp); + if (mprWrite(file, mprGetBufStart(bp), len) != len) { + return MPR_ERR_CANT_WRITE; + } + mprFlushBuf(bp); + } + } + return total; +} + +/******************************************************************************/ + +int mprMakeTempFileName(MprCtx ctx, char *buf, int bufsize, const char *tempDir) +{ + MprFile *file; + MprTime now; + char *dir; + int seed, i; + + if (tempDir == 0) { +#if WIN + char *cp; + dir = mprStrdup(ctx, getenv("TEMP")); + for (cp = dir; *cp; cp++) { + if (*cp == '\\') { + *cp = '/'; + } + } +#else + dir = mprStrdup(ctx, "/tmp"); +#endif + } else { + dir = mprStrdup(ctx, tempDir); + } + + mprGetTime(ctx, &now); + seed = now.msec % 64000; + file = 0; + + for (i = 0; i < 128; i++) { + mprSprintf(buf, bufsize, "%s/MPR_%d_%d.tmp", dir, getpid(), seed++); + file = mprOpen(ctx, buf, O_CREAT | O_EXCL | O_BINARY, 0664); + if (file) { + break; + } + } + + if (file == 0) { + return MPR_ERR_CANT_CREATE; + } + + mprClose(file); + mprFree(dir); + + return 0; +} + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprGenTime.c b/source4/lib/appweb/ejs-2.0/mpr/mprGenTime.c new file mode 100644 index 0000000000..6b0ed97bbc --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprGenTime.c @@ -0,0 +1,195 @@ +/** + * @file mprGenTime.c + * @brief Generic Time handling + * @overview + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************* Includes ***********************************/ + +#include "mpr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************/ +/* + * Return the number of milliseconds until the given timeout has expired. + */ + +int mprGetTimeRemaining(MprCtx ctx, MprTime mark, uint timeout) +{ + MprTime now; + uint diff; + + mprGetTime(ctx, &now); + diff = ((now.sec - mark.sec) * 1000) + (now.msec - mark.msec); + + if (diff < 0) { + /* + * Detect time going backwards + */ + mprAssert(diff >= 0); + diff = 0; + } + return (int) (timeout - diff); +} + +/******************************************************************************/ +/* + * Return the number of milliseconds until the given timeout has expired. + */ + +int mprGetElapsedTime(MprCtx ctx, MprTime mark) +{ + MprTime now; + + mprGetTime(ctx, &now); + return ((now.sec - mark.sec) * 1000) + (now.msec - mark.msec); +} + +/******************************************************************************/ + +void mprAddElapsedToTime(MprTime *time, uint elapsed) +{ + time->sec += elapsed / 1000; + time->msec += elapsed % 1000; + if (time->msec > 1000) { + time->msec -= 1000; + time->sec++; + } +} + +/******************************************************************************/ + +int mprCompareTime(MprTime *t1, MprTime *t2) +{ + if (t1->sec < t2->sec) { + return -1; + } else if (t1->sec == t2->sec) { + if (t1->msec < t2->msec) { + return -1; + } else if (t1->msec == t2->msec) { + return 0; + } + } + return 1; +} + +/******************************************************************************/ + +uint mprSubtractTime(MprTime *t1, MprTime *t2) +{ + return ((t1->sec - t2->sec) * 1000) + (t1->msec - t2->msec); +} + +/******************************************************************************/ +#if !BREW +/* + * Thread-safe RFC822 dates (Eg: "Fri, 07 Jan 2003 12:12:21 GMT") + */ + +int mprRfcTime(MprCtx ctx, char *buf, int bufsize, const struct tm *timep) +{ + char months[12][4] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", + "Oct", "Nov", "Dec" + }; + + char days[7][4] = { + "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" + }; + + char *dayp, *monthp; + int year; + + if (bufsize < 30) { + return MPR_ERR_WONT_FIT; + } + dayp = &days[timep->tm_wday][0]; + *buf++ = *dayp++; + *buf++ = *dayp++; + *buf++ = *dayp++; + *buf++ = ','; + *buf++ = ' '; + + *buf++ = timep->tm_mday / 10 + '0'; + *buf++ = timep->tm_mday % 10 + '0'; + *buf++ = ' '; + + monthp = &months[timep->tm_mon][0]; + *buf++ = *monthp++; + *buf++ = *monthp++; + *buf++ = *monthp++; + *buf++ = ' '; + + year = 1900 + timep->tm_year; + /* This routine isn't y10k ready. */ + *buf++ = year / 1000 + '0'; + *buf++ = year % 1000 / 100 + '0'; + *buf++ = year % 100 / 10 + '0'; + *buf++ = year % 10 + '0'; + *buf++ = ' '; + + *buf++ = timep->tm_hour / 10 + '0'; + *buf++ = timep->tm_hour % 10 + '0'; + *buf++ = ':'; + *buf++ = timep->tm_min / 10 + '0'; + *buf++ = timep->tm_min % 10 + '0'; + *buf++ = ':'; + *buf++ = timep->tm_sec / 10 + '0'; + *buf++ = timep->tm_sec % 10 + '0'; + *buf++ = ' '; + + *buf++ = 'G'; + *buf++ = 'M'; + *buf++ = 'T'; + *buf++ = 0; + return 0; +} + +#endif +/******************************************************************************/ + +#ifdef __cplusplus +} +#endif + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprLock.c b/source4/lib/appweb/ejs-2.0/mpr/mprLock.c new file mode 100644 index 0000000000..df9ce276d4 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprLock.c @@ -0,0 +1,266 @@ +/** + * @file mprThread.c + * @brief Mbedthis Portable Runtime Base Thread Locking Support + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 "mpr.h" + +#if BLD_FEATURE_MULTITHREAD +/************************************ Code ************************************/ + +void mprInitThreads(MprApp *app) +{ + mprAssert(app); + + if (app->globalLock == 0) { + app->globalLock = mprCreateLock(app); + app->allocLock = mprCreateLock(app); + } +} + +/******************************************************************************/ + +void mprTermThreads(MprApp *app) +{ + mprAssert(app); + + if (app->globalLock) { + mprDestroyLock(app->globalLock); + app->globalLock = 0; + } + if (app->allocLock) { + MprLock *lock = app->allocLock; + app->allocLock = 0; + mprDestroyLock(lock); + } +} + +/******************************************************************************/ + +MprLock *mprCreateLock(MprCtx ctx) +{ + MprLock *lock; + + mprAssert(ctx); + + lock = mprAllocType(ctx, MprLock); + +#if BLD_HOST_UNIX + pthread_mutexattr_t attr; + + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP); + pthread_mutex_init(&lock->cs, &attr); + pthread_mutexattr_destroy(&attr); +#elif WIN + InitializeCriticalSectionAndSpinCount(&lock->cs, 5000); +#elif VXWORKS + lock->cs = semMCreate(SEM_Q_PRIORITY | SEM_DELETE_SAFE | + SEM_INVERSION_SAFE); + if (lock->cs == 0) { + mprAssert(0); + mprFree(lock); + return 0; + } +#endif + return lock; +} + +/******************************************************************************/ +/* + * Destroy a lock. Must be locked on entrance. + */ + +void mprDestroyLock(MprLock *lock) +{ + mprAssert(lock); + if (lock == 0) { + return; + } + +#if BLD_HOST_UNIX + pthread_mutex_unlock(&lock->cs); + pthread_mutex_destroy(&lock->cs); +#elif WIN + DeleteCriticalSection(&lock->cs); +#elif VXWORKS + semDelete(lock->cs); +#endif + mprFree(lock); +} + +/******************************************************************************/ +/* + * Lock a mutex + */ + +void mprLock(MprLock *lock) +{ + /* + * OPT -- Do this just so we can allocate MprApp before we have created its + * lock. Should remove this test here and in mprUnlock. + */ + if (lock == 0) { + return; + } + +#if BLD_HOST_UNIX + pthread_mutex_lock(&lock->cs); +#elif WIN + EnterCriticalSection(&lock->cs); +#elif VXWORKS + semTake(lock->cs, WAIT_FOREVER); +#endif +} + +/******************************************************************************/ +/* + * Try to attain a lock. Do not block! + */ + +int mprTryLock(MprLock *lock) +{ + mprAssert(lock); + +#if BLD_HOST_UNIX + { + int err; + + if ((err = pthread_mutex_trylock(&lock->cs)) != 0) { + if (err == EBUSY) { + return MPR_ERR_BUSY; + } else { + return MPR_ERR_CANT_ACCESS; + } + } + return 0; + } +#elif WIN + if (TryEnterCriticalSection(&lock->cs) == 0) { + return MPR_ERR_BUSY; + } +#elif VXWORKS + { + int rc; + + rc = semTake(cs, NO_WAIT); + if (rc == -1) { + mprAssert(0); + } + if (rc == S_objLib_OBJ_UNAVAILABLE) { + return MPR_ERR_BUSY; + } else { + return MPR_ERR_CANT_ACCESS; + } + /* Success */ + return 0; + } +#endif + return 0; +} + +/******************************************************************************/ +/* + * Unlock. + */ + +void mprUnlock(MprLock *lock) +{ + if (lock == 0) { + return; + } + +#if BLD_HOST_UNIX + pthread_mutex_unlock(&lock->cs); +#elif WIN + LeaveCriticalSection(&lock->cs); +#elif VXWORKS + semGive(lock->cs); +#endif +} + +/******************************************************************************/ +/* + * Big global lock. Avoid using this. + */ + +void mprGlobalLock(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + mprAssert(app); + + if (app && app->globalLock) { + mprLock(app->globalLock); + } +} + +/******************************************************************************/ + +void mprGlobalUnlock(MprCtx ctx) +{ + MprApp *app; + + app = mprGetApp(ctx); + mprAssert(app); + + if (app && app->globalLock) { + mprUnlock(app->globalLock); + } +} + +/******************************************************************************/ + +int mprGetCurrentThreadID() +{ +#if BLD_HOST_UNIX + return (int) pthread_self(); +#elif WIN + return GetCurrentThreadId(); +#elif VXWORKS + return (int) pthread_self(); +#endif +} + +/******************************************************************************/ +#endif /* BLD_FEATURE_MULTITHREAD */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprLog.c b/source4/lib/appweb/ejs-2.0/mpr/mprLog.c new file mode 100644 index 0000000000..1eb175ed95 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprLog.c @@ -0,0 +1,602 @@ +/** + * @file mprLog.c + * @brief Mbedthis Portable Runtime (MPR) Logging and error reporting. + * @remarks We always provide these routines. + */ + +/*********************************** License **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 "mpr.h" + +/****************************** Forward Declarations **************************/ + +static void defaultLogHandler(MPR_LOC_DEC(ctx, loc), int flags, + int level, const char *msg); +static void logOutput(MPR_LOC_DEC(ctx, loc), int flags, int level, + const char *msg); + +/************************************ Code ************************************/ + +void mprLog(MprCtx ctx, int level, const char *fmt, ...) +{ + va_list args; + char *buf; + + if (level > mprGetLogLevel(ctx)) { + return; + } + + va_start(args, fmt); + mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args); + va_end(args); + + logOutput(MPR_LOC_ARGS(ctx), MPR_LOG_SRC, level, buf); + + va_end(args); + mprFree(buf); +} + +/*****************************************************************************/ +/* + * Do raw output + */ + +void mprRawLog(MprCtx ctx, const char *fmt, ...) +{ + va_list args; + char *buf; + int len; + + va_start(args, fmt); + len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args); + va_end(args); + + logOutput(MPR_LOC_ARGS(ctx), MPR_RAW, 0, buf); + mprFree(buf); +} + +/*****************************************************************************/ +/* + * Handle an error + */ + +void mprError(MPR_LOC_DEC(ctx, loc), const char *fmt, ...) +{ + va_list args; + char *buf; + int len; + + va_start(args, fmt); + len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args); + va_end(args); + + logOutput(MPR_LOC_PASS(ctx, loc), MPR_ERROR_MSG | MPR_ERROR_SRC, 0, buf); + + mprFree(buf); +} + +/*****************************************************************************/ +/* + * Handle an error that should be displayed to the user + */ + +void mprUserError(MPR_LOC_DEC(ctx, loc), const char *fmt, ...) +{ + va_list args; + char *buf; + int len; + + va_start(args, fmt); + len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args); + va_end(args); + + logOutput(MPR_LOC_PASS(ctx, loc), MPR_USER_MSG | MPR_ERROR_SRC, 0, buf); + + mprFree(buf); +} + +/*****************************************************************************/ +/* + * Handle a fatal error. Forcibly shutdown the application. + */ + +void mprFatalError(MPR_LOC_DEC(ctx, loc), const char *fmt, ...) +{ + va_list args; + char *buf; + int len; + + va_start(args, fmt); + len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args); + va_end(args); + + logOutput(MPR_LOC_PASS(ctx, loc), MPR_USER_MSG | MPR_FATAL_SRC, 0, buf); + + mprFree(buf); + +#if BREW + mprSignalExit(ctx); +#else + exit(2); +#endif +} + +/*****************************************************************************/ +/* + * Handle a program assertion + */ + +void mprAssertError(MPR_LOC_DEC(ctx, loc), const char *msg) +{ + logOutput(MPR_LOC_PASS(ctx, loc), MPR_ASSERT_MSG | MPR_ASSERT_SRC, 0, msg); +} + +/*****************************************************************************/ +/* + * Handle an error + */ + +void mprStaticError(MPR_LOC_DEC(ctx, loc), const char *fmt, ...) +{ + va_list args; + int len; + char buf[MPR_MAX_STRING]; + + va_start(args, fmt); + len = mprVsprintf(buf, sizeof(buf), fmt, args); + va_end(args); + + logOutput(MPR_LOC_PASS(ctx, loc), MPR_ERROR_MSG | MPR_ERROR_SRC, 0, buf); +} + +/*****************************************************************************/ +/* + * Direct output to the standard output. Does not hook into the logging + * system and does not allocate memory. + */ + +void mprStaticAssert(const char *loc, const char *msg) +{ +#if BLD_DEBUG + char buf[MPR_MAX_STRING]; + int len; + + len = mprSprintf(buf, sizeof(buf), "Assertion %s, failed at %s\n", + msg, loc); + mprBreakpoint(loc, buf); + +#if BLD_HOST_UNIX + /* + * MOB -- but is stdout always okay to use + */ + write(1, buf, len); +#elif BREW || WIN + /* + * Only time we use printf. We can't get an alloc context so we have + * to use real print + */ +#if BREW && !BREW_SIMULATOR + printf(" MP: %s\n", buf); +#else + printf("%s\n", buf); +#endif + +#endif +#endif +} + +/*****************************************************************************/ + +int mprGetLogLevel(MprCtx ctx) +{ + return mprGetApp(ctx)->logLevel; +} + +/******************************************************************************/ + +void mprSetLogLevel(MprCtx ctx, int level) +{ + mprGetApp(ctx)->logLevel = level; +} + +/*****************************************************************************/ +/* + * Output a log message to the log handler + */ + +static void logOutput(MPR_LOC_DEC(ctx, loc), int flags, int level, + const char *msg) +{ + MprLogHandler handler; + + if (flags & (MPR_ERROR_SRC | MPR_FATAL_SRC | MPR_ASSERT_SRC)) { + mprBreakpoint(MPR_LOC, 0); + } + + mprAssert(ctx != 0); + handler = mprGetApp(ctx)->logHandler; + if (handler != 0) { + (handler)(MPR_LOC_PASS(ctx, loc), flags, level, msg); + return; + } + defaultLogHandler(MPR_LOC_PASS(ctx, loc), flags, level, msg); +} + +/*****************************************************************************/ +/* + * Default log output is just to the console + */ + +static void defaultLogHandler(MPR_LOC_DEC(ctx, loc), int flags, + int level, const char *msg) +{ + MprApp *app; + char *prefix; + + app = mprGetApp(ctx); + prefix = app->name; + + while (*msg == '\n') { + mprPrintf(ctx, "\n"); + msg++; + } + + if (flags & MPR_LOG_SRC) { +#if BREW && !BREW_SIMULATOR + mprPrintf(ctx, "%s\n", msg); +#else + mprPrintf(ctx, "%s: %d: %s\n", prefix, level, msg); +#endif + + } else if (flags & MPR_ERROR_SRC) { + /* + * Use static printing to avoid malloc when the messages are small. + * This is important for memory allocation errors. + */ + if (strlen(msg) < (MPR_MAX_STRING - 32)) { + mprStaticPrintf(ctx, "%s: Error: %s\n", prefix, msg); + } else { + mprPrintf(ctx, "%s: Error: %s\n", prefix, msg); + } + + } else if (flags & MPR_FATAL_SRC) { + mprPrintf(ctx, "%s: Fatal: %s\n", prefix, msg); + + } else if (flags & MPR_ASSERT_SRC) { +#if BLD_FEATURE_ALLOC_LEAK_TRACK + mprPrintf(ctx, "%s: Assertion %s, failed at %s\n", prefix, msg, loc); +#else + mprPrintf(ctx, "%s: Assertion %s, failed\n", prefix, msg); +#endif + + } else if (flags & MPR_RAW) { + mprPrintf(ctx, "%s", msg); + + } else { + return; + } +} + +/*****************************************************************************/ +/* + * Map the O/S error code to portable error codes. + */ + +int mprGetOsError() +{ +#if WIN + int rc; + rc = GetLastError(); + + /* + * Client has closed the pipe + */ + if (rc == ERROR_NO_DATA) { + return EPIPE; + } + return rc; +#endif +#if LINUX || VXWORKS || SOLARIS + return errno; +#endif +#if BREW + /* + * No such thing on Brew. Errors are per class + */ + return 0; +#endif +} + +/******************************************************************************/ +#if UNUSED + +const char *mprGetErrorMsg(int err) +{ + /* + * MPR error messages. Declare here so we don't have any globals. + */ + char *mprErrMessages[] = { + /* 0 MPR_ERR_OK */ "Success", + /* -201 MPR_ERR_GENERAL */ "General error", + /* -202 MPR_ERR_ABORTED */ "Aborted", + /* -203 MPR_ERR_ALREADY_EXISTS */ "Already exists", + /* -204 MPR_ERR_BAD_ARGS */ "Bad args", + /* -205 MPR_ERR_BAD_FORMAT */ "Bad format", + /* -206 MPR_ERR_BAD_HANDLE */ "Bad handle", + /* -207 MPR_ERR_BAD_STATE */ "Bad state", + /* -208 MPR_ERR_BAD_SYNTAX */ "Bad syntax", + /* -209 MPR_ERR_BAD_TYPE */ "Bad type", + /* -210 MPR_ERR_BAD_VALUE */ "Bad value", + /* -211 MPR_ERR_BUSY */ "Busy", + /* -212 MPR_ERR_CANT_ACCESS */ "Can't access", + /* -213 MPR_ERR_CANT_COMPLETE */ "Can't complete", + /* -214 MPR_ERR_CANT_CREATE */ "Can't create", + /* -215 MPR_ERR_CANT_INITIALIZE */ "Can't initialize", + /* -216 MPR_ERR_CANT_OPEN */ "Can't open", + /* -217 MPR_ERR_CANT_READ */ "Can't read", + /* -218 MPR_ERR_CANT_WRITE */ "Can't write", + /* -219 MPR_ERR_DELETED */ "Already deleted", + /* -220 MPR_ERR_NETWORK */ "Network error", + /* -221 MPR_ERR_NOT_FOUND */ "Not found", + /* -222 MPR_ERR_NOT_INITIALIZED */ "Not initialized", + /* -223 MPR_ERR_NOT_READY */ "Not ready", + /* -224 MPR_ERR_READ_ONLY */ "Read only", + /* -225 MPR_ERR_TIMEOUT */ "Timeout", + /* -226 MPR_ERR_TOO_MANY */ "Too many", + /* -227 MPR_ERR_WONT_FIT */ "Won't fit", + /* -228 MPR_ERR_WOULD_BLOCK */ "Would block", + /* -229 MPR_ERR_CANT_ALLOCATE */ "Can't allocate", + }; + int mprNumErr = sizeof(mprErrMessages) / sizeof(char*); + +/* + * Operating system error messages + */ +#if WIN +char *osErrMessages[] = +{ + /* 0 */ "No error", + /* 1 EPERM */ "Operation not permitted", + /* 2 ENOENT */ "No such file or directory", + /* 3 ESRCH */ "No such process", + /* 4 EINTR */ "Interrupted function call", + /* 5 EIO */ "I/O error", + /* 6 ENXIO */ "No such device or address", + /* 7 E2BIG */ "Arg list too long", + /* 8 ENOEXEC */ "Exec format error", + /* 9 EBADF */ "Bad file number", + /* 10 ECHILD */ "No child processes", + /* 11 EAGAIN */ "Try again", + /* 12 ENOMEM */ "Out of memory", + /* 13 EACCES */ "Permission denied", + /* 14 EFAULT */ "Bad address", + /* 15 ENOTBLK */ "Unknown error", + /* 16 EBUSY */ "Resource busy", + /* 17 EEXIST */ "File exists", + /* 18 EXDEV */ "Improper link", + /* 19 ENODEV */ "No such device", + /* 20 ENOTDIR */ "Not a directory", + /* 21 EISDIR */ "Is a directory", + /* 22 EINVAL */ "Invalid argument", + /* 23 ENFILE */ "Too many open files in system", + /* 24 EMFILE */ "Too many open files", + /* 25 ENOTTY */ "Inappropriate I/O control operation", + /* 26 ETXTBSY */ "Unknown error", + /* 27 EFBIG */ "File too large", + /* 28 ENOSPC */ "No space left on device", + /* 29 ESPIPE */ "Invalid seek", + /* 30 EROFS */ "Read-only file system", + /* 31 EMLINK */ "Too many links", + /* 32 EPIPE */ "Broken pipe", + /* 33 EDOM */ "Domain error", + /* 34 ERANGE */ "Result too large", + /* 35 EUCLEAN */ "Unknown error", + /* 36 EDEADLK */ "Resource deadlock would occur", + /* 37 UNKNOWN */ "Unknown error", + /* 38 ENAMETOOLONG */ "Filename too long", + /* 39 ENOLCK */ "No locks available", + /* 40 ENOSYS */ "Function not implemented", + /* 41 ENOTEMPTY */ "Directory not empty", + /* 42 EILSEQ */ "Illegal byte sequence", + /* 43 ENETDOWN */ "Network is down", + /* 44 ECONNRESET */ "Connection reset", + /* 45 ECONNREFUSED */ "Connection refused", + /* 46 EADDRINUSE */ "Address already in use" + +}; + +#else /* WIN */ + +char *osErrMessages[] = +{ + /* 0 */ "Success" + /* 1 EPERM */ "Operation not permitted" + /* 2 ENOENT */ "No such file or directory" + /* 3 ESRCH */ "No such process" + /* 4 EINTR */ "Interrupted system call" + /* 5 EIO */ "I/O error" + /* 6 ENXIO */ "No such device or address" + /* 7 E2BIG */ "Arg list too long" + /* 8 ENOEXEC */ "Exec format error" + /* 9 EBADF */ "Bad file number" + /* 10 ECHILD */ "No child processes" + /* 11 EAGAIN */ "Try again" + /* 12 ENOMEM */ "Out of memory" + /* 13 EACCES */ "Permission denied" + /* 14 EFAULT */ "Bad address" + /* 15 ENOTBLK */ "Block device required" + /* 16 EBUSY */ "Device or resource busy" + /* 17 EEXIST */ "File exists" + /* 18 EXDEV */ "Cross-device link" + /* 19 ENODEV */ "No such device" + /* 20 ENOTDIR */ "Not a directory" + /* 21 EISDIR */ "Is a directory" + /* 22 EINVAL */ "Invalid argument" + /* 23 ENFILE */ "File table overflow" + /* 24 EMFILE */ "Too many open files" + /* 25 ENOTTY */ "Not a typewriter" + /* 26 ETXTBSY */ "Text file busy" + /* 27 EFBIG */ "File too large" + /* 28 ENOSPC */ "No space left on device" + /* 29 ESPIPE */ "Illegal seek" + /* 30 EROFS */ "Read-only file system" + /* 31 EMLINK */ "Too many links" + /* 32 EPIPE */ "Broken pipe" + /* 33 EDOM */ "Math argument out of domain of func" + /* 34 ERANGE */ "Math result not representable" + /* 35 EDEADLK */ "Resource deadlock would occur" + /* 36 ENAMETOOLONG */ "File name too long" + /* 37 ENOLCK */ "No record locks available" + /* 38 ENOSYS */ "Function not implemented" + /* 39 ENOTEMPTY */ "Directory not empty" + /* 40 ELOOP */ "Too many symbolic links encountered" + /* 41 EWOULDBLOCK EAGAIN */"Operation would block" + /* 42 ENOMSG */ "No message of desired type" + /* 43 EIDRM */ "Identifier removed" + +#if !BLD_FEATURE_SQUEEZE + /* 44 ECHRNG */ "Channel number out of range" + /* 45 EL2NSYNC */ "Level 2 not synchronized" + /* 46 EL3HLT */ "Level 3 halted" + /* 47 EL3RST */ "Level 3 reset" + /* 48 ELNRNG */ "Link number out of range" + /* 49 EUNATCH */ "Protocol driver not attached" + /* 50 ENOCSI */ "No CSI structure available" + /* 51 EL2HLT */ "Level 2 halted" + /* 52 EBADE */ "Invalid exchange" + /* 53 EBADR */ "Invalid request descriptor" + /* 54 EXFULL */ "Exchange full" + /* 55 ENOANO */ "No anode" + /* 56 EBADRQC */ "Invalid request code" + /* 57 EBADSLT */ "Invalid slot" + /* 59 EBFONT */ "Bad font file format" + /* 60 ENOSTR */ "Device not a stream" + /* 61 ENODATA */ "No data available" + /* 62 ETIME */ "Timer expired" + /* 63 ENOSR */ "Out of streams resources" + /* 64 ENONET */ "Machine is not on the network" + /* 65 ENOPKG */ "Package not installed" + /* 66 EREMOTE */ "Object is remote" + /* 67 ENOLINK */ "Link has been severed" + /* 68 EADV */ "Advertise error" + /* 69 ESRMNT */ "Srmount error" + /* 70 ECOMM */ "Communication error on send" + /* 71 EPROTO */ "Protocol error" + /* 72 EMULTIHOP */ "Multihop attempted" + /* 73 EDOTDOT */ "RFS specific error" + /* 74 EBADMSG */ "Not a data message" + /* 75 EOVERFLOW */ "Value too large for defined data type" + /* 76 ENOTUNIQ */ "Name not unique on network" + /* 77 EBADFD */ "File descriptor in bad state" + /* 78 EREMCHG */ "Remote address changed" + /* 79 ELIBACC */ "Can not access a needed shared library" + /* 80 ELIBBAD */ "Accessing a corrupted shared library" + /* 81 ELIBSCN */ ".lib section in a.out corrupted" + /* 82 ELIBMAX */ "Linking in too many shared libraries" + /* 83 ELIBEXEC */ "Cannot exec a shared library directly" + /* 84 EILSEQ */ "Illegal byte sequence" + /* 85 ERESTART */ "Interrupted system call should be restarted" + /* 86 ESTRPIPE */ "Streams pipe error" + /* 87 EUSERS */ "Too many users" + /* 88 ENOTSOCK */ "Socket operation on non-socket" + /* 89 EDESTADDRREQ */ "Destination address required" + /* 90 EMSGSIZE */ "Message too long" + /* 91 EPROTOTYPE */ "Protocol wrong type for socket" + /* 92 ENOPROTOOPT */ "Protocol not available" + /* 93 EPROTONOSUPPORT */ "Protocol not supported" + /* 94 ESOCKTNOSUPPORT */ "Socket type not supported" + /* 95 EOPNOTSUPP */ "Operation not supported on transport endpoint" + /* 96 EPFNOSUPPORT */ "Protocol family not supported" + /* 97 EAFNOSUPPORT */ "Address family not supported by protocol" + /* 98 EADDRINUSE */ "Address already in use" + /* 99 EADDRNOTAVAIL */ "Cannot assign requested address" + /* 100 ENETDOWN */ "Network is down" + /* 101 ENETUNREACH */ "Network is unreachable" + /* 102 ENETRESET */ "Network dropped connection because of reset" + /* 103 ECONNABORTED */ "Software caused connection abort" + /* 104 ECONNRESET */ "Connection reset by peer" + /* 105 ENOBUFS */ "No buffer space available" + /* 106 EISCONN */ "Transport endpoint is already connected" + /* 107 ENOTCONN */ "Transport endpoint is not connected" + /* 108 ESHUTDOWN */ "Cannot send after transport endpoint shutdown" + /* 109 ETOOMANYREFS */ "Too many references: cannot splice" + /* 110 ETIMEDOUT */ "Connection timed out" + /* 111 ECONNREFUSED */ "Connection refused" + /* 112 EHOSTDOWN */ "Host is down" + /* 113 EHOSTUNREACH */ "No route to host" + /* 114 EALREADY */ "Operation already in progress" + /* 115 EINPROGRESS */ "Operation now in progress" + /* 116 ESTALE */ "Stale NFS file handle" + /* 117 EUCLEAN */ "Structure needs cleaning" + /* 118 ENOTNAM */ "Not a XENIX named type file" + /* 119 ENAVAIL */ "No XENIX semaphores available" + /* 120 EISNAM */ "Is a named type file" + /* 121 EREMOTEIO */ "Remote I/O error" + /* 122 EDQUOT */ "Quota exceeded" + /* 123 ENOMEDIUM */ "No medium found" + /* 124 EMEDIUMTYPE */ "Wrong medium type" +}; +#endif /* BLD_FEATURE_SQUEEZE */ +#endif /* WIN */ + + int osNumErr = sizeof(osErrMessages) / sizeof(char*); + + if (err < MPR_ERR_BASE) { + err = MPR_ERR_BASE - err; + if (err < 0 || err >= mprNumErr) { + return "Bad error code"; + } + return mprErrMessages[err]; + + } else { + /* + * Negative O/S error code. Map to a positive standard Posix error. + */ + err = -err; + if (err < 0 || err >= osNumErr) { + return "Bad O/S error code"; + } + return osErrMessages[err]; + } +} + +#endif +/*****************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprOs.h b/source4/lib/appweb/ejs-2.0/mpr/mprOs.h new file mode 100644 index 0000000000..bed4ca5979 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprOs.h @@ -0,0 +1,707 @@ +/* + * @file mprOs.h + * @brief Include O/S headers and smooth out per-O/S differences + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 ********************************/ + +/* + * This header is part of the Mbedthis Portable Runtime and aims to include + * all necessary O/S headers and to unify the constants and declarations + * required by Mbedthis products. It can be included by C or C++ programs. + */ + +/******************************************************************************/ + +#ifndef _h_MPR_OS_HDRS +#define _h_MPR_OS_HDRS 1 + +#include "buildConfig.h" + +/********************************* CPU Families *******************************/ +/* + * Porters, add your CPU families here and update configure code. + */ +#define MPR_CPU_UNKNOWN 0 +#define MPR_CPU_IX86 1 +#define MPR_CPU_PPC 2 +#define MPR_CPU_SPARC 3 +#define MPR_CPU_XSCALE 4 +#define MPR_CPU_ARM 5 +#define MPR_CPU_MIPS 6 +#define MPR_CPU_68K 7 +#define MPR_CPU_SIMNT 8 /* VxWorks NT simulator */ +#define MPR_CPU_SIMSPARC 9 /* VxWorks sparc simulator */ + +/********************************* O/S Includes *******************************/ + +#if LINUX || SOLARIS + #include <sys/types.h> + #include <time.h> + #include <arpa/inet.h> + #include <ctype.h> + #include <dirent.h> + #include <dlfcn.h> + #include <fcntl.h> + #include <grp.h> + #include <errno.h> + #include <libgen.h> + #include <limits.h> + #include <netdb.h> + #include <net/if.h> + #include <netinet/in.h> + #include <netinet/tcp.h> + #include <netinet/ip.h> + #include <pthread.h> + #include <pwd.h> + #include <resolv.h> + #include <signal.h> + #include <stdarg.h> + #include <stdio.h> + #include <stdlib.h> + #include <string.h> + #include <syslog.h> + #include <sys/ioctl.h> + #include <sys/stat.h> + #include <sys/param.h> + #include <sys/resource.h> + #include <sys/sem.h> + #include <sys/shm.h> + #include <sys/socket.h> + #include <sys/select.h> + #include <sys/time.h> + #include <sys/times.h> + #include <sys/utsname.h> + #include <sys/wait.h> + #include <unistd.h> + +#if LINUX + #include <stdint.h> +#endif + +#if SOLARIS + #include <netinet/in_systm.h> +#endif + +#if BLD_FEATURE_FLOATING_POINT + #define __USE_ISOC99 1 + #include <math.h> + #include <values.h> +#endif + +#endif /* LINUX || SOLARIS */ + +#if VXWORKS + #include <vxWorks.h> + #include <envLib.h> + #include <sys/types.h> + #include <time.h> + #include <arpa/inet.h> + #include <ctype.h> + #include <dirent.h> + #include <fcntl.h> + #include <errno.h> + #include <limits.h> + #include <loadLib.h> + #include <netdb.h> + #include <net/if.h> + #include <netinet/tcp.h> + #include <netinet/in.h> + #include <netinet/ip.h> + #include <signal.h> + #include <stdarg.h> + #include <stdio.h> + #include <stdlib.h> + #include <string.h> + #include <sysSymTbl.h> + #include <sys/fcntlcom.h> + #include <sys/ioctl.h> + #include <sys/stat.h> + #include <sys/socket.h> + #include <sys/times.h> + #include <sys/wait.h> + #include <unistd.h> + #include <unldLib.h> + + #if BLD_FEATURE_FLOATING_POINT + #include <float.h> + #define __USE_ISOC99 1 + #include <math.h> + #endif + + #include <sockLib.h> + #include <inetLib.h> + #include <ioLib.h> + #include <pipeDrv.h> + #include <hostLib.h> + #include <netdb.h> + #include <tickLib.h> + #include <taskHookLib.h> + +#endif /* VXWORKS */ + +#if MACOSX + #include <time.h> + #include <arpa/inet.h> + #include <ctype.h> + #include <fcntl.h> + #include <grp.h> + #include <errno.h> + #include <libgen.h> + #include <limits.h> + #include <mach-o/dyld.h> + #include <netdb.h> + #include <net/if.h> + #include <netinet/in_systm.h> + #include <netinet/in.h> + #include <netinet/tcp.h> + #include <netinet/ip.h> + #include <pthread.h> + #include <pwd.h> + #include <resolv.h> + #include <signal.h> + #include <stdarg.h> + #include <stdio.h> + #include <stdlib.h> + #include <stdint.h> + #include <string.h> + #include <syslog.h> + #include <sys/ioctl.h> + #include <sys/types.h> + #include <sys/stat.h> + #include <sys/param.h> + #include <sys/resource.h> + #include <sys/sem.h> + #include <sys/shm.h> + #include <sys/socket.h> + #include <sys/select.h> + #include <sys/time.h> + #include <sys/times.h> + #include <sys/types.h> + #include <sys/utsname.h> + #include <sys/wait.h> + #include <unistd.h> +#endif /* MACOSX */ + +#if WIN + /* + * We replace insecure functions with Mbedthis replacements + */ + #define _CRT_SECURE_NO_DEPRECATE 1 + + #include <ctype.h> + #include <conio.h> + #include <direct.h> + #include <errno.h> + #include <fcntl.h> + #include <io.h> + #include <limits.h> + #include <malloc.h> + #include <process.h> + #include <sys/stat.h> + #include <sys/types.h> + #include <stddef.h> + #include <stdio.h> + #include <stdlib.h> + #include <string.h> + #include <stdarg.h> + #include <time.h> + #define WIN32_LEAN_AND_MEAN + #include <winsock2.h> + #include <windows.h> + #include <winbase.h> + #if BLD_FEATURE_FLOATING_POINT + #include <float.h> + #endif + #include <shlobj.h> + #include <shellapi.h> + #include <wincrypt.h> + +#if BLD_DEBUG + #include <crtdbg.h> +#endif + #include "mprUnix.h" +#endif /* WIN */ + +#if BREW + #if BLD_FEATURE_FLOATING_POINT + #warning "Floating point is not supported on Brew" + #endif + #if BLD_FEATURE_MULTITHREAD + #warning "Multithreading is not supported on Brew" + #endif + + #include "AEEModGen.h" + #include "AEEAppGen.h" + #include "BREWVersion.h" + + #if BREW_MAJ_VER == 2 + /* + * Fix for BREW 2.X + */ + #ifdef __GNUC__ + #define __inline extern __inline__ + #endif + #include "AEENet.h" + #undef __inline + #endif + + #include "AEE.h" + #include "AEEBitmap.h" + #include "AEEDisp.h" + #include "AEEFile.h" + #include "AEEHeap.h" + #include "AEEImageCtl.h" + #include "AEEMedia.h" + #include "AEEMediaUtil.h" + #include "AEEMimeTypes.h" + #include "AEEStdLib.h" + #include "AEEShell.h" + #include "AEESoundPlayer.h" + #include "AEEText.h" + #include "AEETransform.h" + #include "AEEWeb.h" + #if BREW_MAJ_VER >= 3 + #include "AEESMS.h" + #endif + #include "AEETAPI.h" + +#if 0 + #include "AEESound.h" + #include "AEEDb.h" + #include "AEEMenu.h" +#endif + +#endif /* BREW */ + +/******************************************************************************/ +/******************************* General Defines ******************************/ +/******************************************************************************/ + +#ifndef MAXINT +#if INT_MAX + #define MAXINT INT_MAX +#else + #define MAXINT 0x7fffffff +#endif +#endif + +#ifndef BITSPERBYTE +#define BITSPERBYTE (8 * sizeof(char)) +#endif + +#define BITS(type) (BITSPERBYTE * (int) sizeof(type)) + +#ifndef max +#define max(a,b) (((a) > (b)) ? (a) : (b)) +#endif + +#ifndef min +#define min(a,b) (((a) < (b)) ? (a) : (b)) +#endif + +#define MPR_ARRAY_SIZE(type) (sizeof(type) / sizeof(type[0])) + +#ifndef PRINTF_ATTRIBUTE +#if (__GNUC__ >= 3) && !DOXYGEN && BLD_FEATURE_ALLOC_LEAK_TRACK +/** Use gcc attribute to check printf fns. a1 is the 1-based index of + * the parameter containing the format, and a2 the index of the first + * argument. Note that some gcc 2.x versions don't handle this + * properly **/ +#define PRINTF_ATTRIBUTE(a1, a2) __attribute__ ((format (__printf__, a1, a2))) +#else +#define PRINTF_ATTRIBUTE(a1, a2) +#endif +#endif + +typedef char *MprStr; /* Used for dynamic strings */ + +#ifdef __cplusplus +extern "C" { +#else +typedef int bool; +#endif + +/******************************************************************************/ +/******************************** Linux Defines *******************************/ +/******************************************************************************/ + +#if LINUX + typedef unsigned char uchar; + +#if BLD_FEATURE_INT64 + __extension__ typedef long long int int64; + __extension__ typedef unsigned long long int uint64; + #define INT64(x) (x##LL) + #define UINT64(x) (x##ULL) +#endif + + #define closesocket(x) close(x) + #define MPR_BINARY "" + #define MPR_TEXT "" + #define O_BINARY 0 + #define O_TEXT 0 + #define SOCKET_ERROR -1 + #define MPR_DLL_EXT ".so" + +#if BLD_FEATURE_FLOATING_POINT + #define MAX_FLOAT MAXFLOAT +#endif + +/* + * For some reason it is removed from fedora pthreads.h and only + * comes in for UNIX96 + */ +extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict + __attr, int *__restrict __kind) __THROW; +/* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_NORMAL, + PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK, or + PTHREAD_MUTEX_DEFAULT). */ +extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) + __THROW; + +#endif /* LINUX */ + +/******************************************************************************/ +/******************************* VxWorks Defines ******************************/ +/******************************************************************************/ + +#if VXWORKS + + typedef unsigned char uchar; + typedef unsigned int uint; + typedef unsigned long ulong; + + #define HAVE_SOCKLEN_T + typedef int socklen_t; + +#if BLD_FEATURE_INT64 + typedef long long int int64; + typedef unsigned long long int uint64; + #define INT64(x) (x##LL) + #define UINT64(x) (x##ULL) +#endif + + #define closesocket(x) close(x) + #define getpid() taskIdSelf() + #define MPR_BINARY "" + #define MPR_TEXT "" + #define O_BINARY 0 + #define O_TEXT 0 + #define SOCKET_ERROR -1 + #define MPR_DLL_EXT ".so" + +#if BLD_FEATURE_FLOATING_POINT + #define MAX_FLOAT FLT_MAX +#endif + + #undef R_OK + #define R_OK 4 + #undef W_OK + #define W_OK 2 + #undef X_OK + #define X_OK 1 + #undef F_OK + #define F_OK 0 + + #define MSG_NOSIGNAL 0 + + extern int access(char *path, int mode); + extern int sysClkRateGet(); + +#endif /* VXWORKS */ + +/******************************************************************************/ +/******************************** MacOsx Defines ******************************/ +/******************************************************************************/ +#if MACOSX + typedef unsigned long ulong; + typedef unsigned char uchar; + +#if BLD_FEATURE_INT64 + __extension__ typedef long long int int64; + __extension__ typedef unsigned long long int uint64; + #define INT64(x) (x##LL) + #define UINT64(x) (x##ULL) +#endif + + #define closesocket(x) close(x) + #define MPR_BINARY "" + #define MPR_TEXT "" + #define O_BINARY 0 + #define O_TEXT 0 + #define SOCKET_ERROR -1 + #define MPR_DLL_EXT ".dylib" + #define MSG_NOSIGNAL 0 + #define __WALL 0x40000000 + #define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE + +#if BLD_FEATURE_FLOATING_POINT + #define MAX_FLOAT MAXFLOAT +#endif + +#endif /* MACOSX */ + +/******************************************************************************/ +/******************************* Windows Defines ******************************/ +/******************************************************************************/ + +#if WIN + typedef unsigned char uchar; + typedef unsigned int uint; + typedef unsigned long ulong; + typedef unsigned short ushort; + +/* + * We always define INT64 types on windows + */ +#if BLD_FEATURE_INT64 || 1 + typedef __int64 int64; + typedef unsigned __int64 uint64; + #define INT64(x) (x##i64) + #define UINT64(x) (x##Ui64) +#endif + + typedef int uid_t; + typedef void *handle; + typedef char *caddr_t; + typedef long pid_t; + typedef int gid_t; + typedef ushort mode_t; + typedef void *siginfo_t; + + #define HAVE_SOCKLEN_T + typedef int socklen_t; + + #undef R_OK + #define R_OK 4 + #undef W_OK + #define W_OK 2 + + /* + * On windows map X_OK to R_OK + */ + #undef X_OK + #define X_OK 4 + #undef F_OK + #define F_OK 0 + + #ifndef EADDRINUSE + #define EADDRINUSE 46 + #endif + #ifndef EWOULDBLOCK + #define EWOULDBLOCK EAGAIN + #endif + #ifndef ENETDOWN + #define ENETDOWN 43 + #endif + #ifndef ECONNRESET + #define ECONNRESET 44 + #endif + #ifndef ECONNREFUSED + #define ECONNREFUSED 45 + #endif + + #define MSG_NOSIGNAL 0 + #define MPR_BINARY "b" + #define MPR_TEXT "t" + +#if BLD_FEATURE_FLOATING_POINT + #define MAX_FLOAT DBL_MAX +#endif + +#ifndef FILE_FLAG_FIRST_PIPE_INSTANCE +#define FILE_FLAG_FIRST_PIPE_INSTANCE 0x00080000 +#endif + + #define MPR_DLL_EXT ".dll" +#endif /* WIN */ + +/******************************************************************************/ +/****************************** Solaris Defines *******************************/ +/******************************************************************************/ + +#if SOLARIS + typedef unsigned char uchar; + +#if BLD_FEATURE_INT64 + typedef long long int int64; + typedef unsigned long long int uint64; + #define INT64(x) (x##LL) + #define UINT64(x) (x##ULL) +#endif + + #define closesocket(x) close(x) + #define MPR_BINARY "" + #define MPR_TEXT "" + #define O_BINARY 0 + #define O_TEXT 0 + #define SOCKET_ERROR -1 + #define MPR_DLL_EXT ".so" + #define MSG_NOSIGNAL 0 + #define INADDR_NONE ((in_addr_t) 0xffffffff) + #define __WALL 0 + #define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE + +#if BLD_FEATURE_FLOATING_POINT + #define MAX_FLOAT MAXFLOAT +#endif + +#endif /* SOLARIS */ + +/******************************************************************************/ +/********************************* BREW Defines *******************************/ +/******************************************************************************/ + +#if BREW + typedef unsigned char uchar; + typedef unsigned int uint; + typedef unsigned long ulong; + typedef unsigned short ushort; + + typedef uint off_t; + typedef long pid_t; + +#if UNUSED + typedef int uid_t; + typedef void *handle; + typedef char *caddr_t; + typedef int gid_t; + typedef ushort mode_t; + typedef void *siginfo_t; + + #define HAVE_SOCKLEN_T + typedef int socklen_t; + + #ifndef EADDRINUSE + #define EADDRINUSE 46 + #endif + #ifndef EWOULDBLOCK + #define EWOULDBLOCK EAGAIN + #endif + #ifndef ENETDOWN + #define ENETDOWN 43 + #endif + #ifndef ECONNRESET + #define ECONNRESET 44 + #endif + #ifndef ECONNREFUSED + #define ECONNREFUSED 45 + #endif + + #define MSG_NOSIGNAL 0 + #define MPR_BINARY "b" + #define MPR_TEXT "t" + + #define MPR_DLL_EXT ".dll" +#endif + + #define O_RDONLY 0 + #define O_WRONLY 1 + #define O_RDWR 2 + #define O_CREAT 0x200 + #define O_TRUNC 0x400 + #define O_BINARY 0 + #define O_TEXT 0x20000 + #define O_EXCL 0x40000 + #define O_APPEND 0x80000 + + #define R_OK 4 + #define W_OK 2 + #define X_OK 1 + #define F_OK 0 + + #define SEEK_SET 0 + #define SEEK_CUR 1 + #define SEEK_END 2 + +#if UNUSED +struct stat { + uint st_size; +}; +#endif + +extern int getpid(); +extern int isalnum(int c); +extern int isalpha(int c); +extern int isdigit(int c); +extern int islower(int c); +extern int isupper(int c); +extern int isspace(int c); +extern int isxdigit(int c); + +extern uint strlen(const char *str); +extern char *strstr(const char *string, const char *strSet); +extern void *memset(const void *dest, int c, uint count); +extern void exit(int status); +extern char *strpbrk(const char *str, const char *set); +extern uint strspn(const char *str, const char *set); +extern int tolower(int c); +extern int toupper(int c); +extern void *memcpy(void *dest, const void *src, uint count); +extern void *memmove(void *dest, const void *src, uint count); + +extern int atoi(const char *str); +extern void free(void *ptr); +extern void *malloc(uint size); +extern void *realloc(void *ptr, uint size); +extern char *strcat(char *dest, const char *src); +extern char *strchr(const char *str, int c); +extern int strcmp(const char *s1, const char *s2); +extern int strncmp(const char *s1, const char *s2, uint count); +extern char *strcpy(char *dest, const char *src); +extern char *strncpy(char *dest, const char *src, uint count); +extern char *strrchr(const char *str, int c); + +#undef printf +#define printf DBGPRINTF + +#if BREW_SIMULATOR && BLD_DEBUG +extern _CRTIMP int __cdecl _CrtCheckMemory(void); +extern _CRTIMP int __cdecl _CrtSetReportHook(); +#endif + +#endif /* BREW */ + +/******************************************************************************/ +#ifdef __cplusplus +} +#endif + +#endif /* _h_MPR_OS_HDRS */ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprPrintf.c b/source4/lib/appweb/ejs-2.0/mpr/mprPrintf.c new file mode 100644 index 0000000000..2d0951acfa --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprPrintf.c @@ -0,0 +1,924 @@ +/** + * @file mprPrintf.c + * @brief Printf routines safe for embedded programming + * @overview This module provides safe replacements for the standard + * printf formatting routines. + * @remarks Most routines in this file are not thread-safe. It is the callers + * responsibility to perform all thread synchronization. + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ + +/********************************** Includes **********************************/ +/* + * We need to use the underlying str(cpy) routines to implement our safe + * alternatives + */ +#if !DOXYGEN +#define UNSAFE_FUNCTIONS_OK 1 +#endif + +#include "mpr.h" + +/*********************************** Defines **********************************/ +/* + * Class definitions + */ +#define CLASS_NORMAL 0 /* [All other] Normal characters */ +#define CLASS_PERCENT 1 /* [%] Begin format */ +#define CLASS_MODIFIER 2 /* [-+ #,] Modifiers */ +#define CLASS_ZERO 3 /* [0] Special modifier */ +#define CLASS_STAR 4 /* [*] Width supplied by arg */ +#define CLASS_DIGIT 5 /* [1-9] Field widths */ +#define CLASS_DOT 6 /* [.] Introduce precision */ +#define CLASS_BITS 7 /* [hlL] Length bits */ +#define CLASS_TYPE 8 /* [cdfinopsSuxX] Type specifiers */ + +#define STATE_NORMAL 0 /* Normal chars in format string */ +#define STATE_PERCENT 1 /* "%" */ +#define STATE_MODIFIER 2 /* Read flag */ +#define STATE_WIDTH 3 /* Width spec */ +#define STATE_DOT 4 /* "." */ +#define STATE_PRECISION 5 /* Precision spec */ +#define STATE_BITS 6 /* Size spec */ +#define STATE_TYPE 7 /* Data type */ +#define STATE_COUNT 8 + +/* + * Format: %[modifier][width][precision][bits][type] + * + * #define CLASS_MODIFIER 2 [-+ #,] Modifiers + * #define CLASS_BITS 7 [hlL] Length bits + */ + + +/* + * Flags + */ +#define SPRINTF_LEFT 0x1 /* Left align */ +#define SPRINTF_SIGN 0x2 /* Always sign the result */ +#define SPRINTF_LEAD_SPACE 0x4 /* put leading space for +ve numbers */ +#define SPRINTF_ALTERNATE 0x8 /* Alternate format */ +#define SPRINTF_LEAD_ZERO 0x10 /* Zero pad */ +#define SPRINTF_SHORT 0x20 /* 16-bit */ +#define SPRINTF_LONG 0x40 /* 32-bit */ +#if BLD_FEATURE_INT64 +#define SPRINTF_LONGLONG 0x80 /* 64-bit */ +#endif +#define SPRINTF_COMMA 0x100 /* Thousand comma separators */ +#define SPRINTF_UPPER_CASE 0x200 /* As the name says for numbers */ + +typedef struct Format { + uchar *buf; + uchar *endbuf; + uchar *start; + uchar *end; + int growBy; + int maxsize; + + int precision; + int radix; + int width; + int flags; + int len; +} Format; + +static int growBuf(MPR_LOC_DEC(ctx, loc), Format *fmt); + +#define BPUT(ctx, loc, fmt, c) \ + if (1) { \ + /* Less one to allow room for the null */ \ + if ((fmt)->end >= ((fmt)->endbuf - sizeof(char))) { \ + if (growBuf(MPR_LOC_PASS(ctx, loc), fmt)) { \ + *(fmt)->end++ = (c); \ + } \ + } else { \ + *(fmt)->end++ = (c); \ + } \ + } else + +#define BPUTNULL(ctx, loc, fmt) \ + if (1) { \ + if ((fmt)->end > (fmt)->endbuf) { \ + if (growBuf(MPR_LOC_PASS(ctx, loc), fmt)) { \ + *(fmt)->end = '\0'; \ + } \ + } else { \ + *(fmt)->end = '\0'; \ + } \ + } else + +/******************************************************************************/ + +#if BLD_FEATURE_INT64 +#define unum uint64 +#define num int64 +#else +#define unum uint +#define num int +#endif + +/***************************** Forward Declarations ***************************/ +#ifdef __cplusplus +extern "C" { +#endif + +static int getState(char c, int state); +static int mprSprintfCore(MPR_LOC_DEC(ctx, loc), char **s, + int maxsize, const char *fmt, va_list arg); +static void outNum(MPR_LOC_DEC(ctx, loc), Format *fmt, const char *prefix, + unum val); + +#if BLD_FEATURE_FLOATING_POINT +static void outFloat(MPR_LOC_DEC(ctx, loc), Format *fmt, char specChar, + double value); +#endif + +/******************************************************************************/ + +int mprPrintf(MprCtx ctx, const char *fmt, ...) +{ + va_list ap; + char *buf; + int len; + MprApp *app; + + /* No asserts here as this is used as part of assert reporting */ + + app = mprGetApp(ctx); + + va_start(ap, fmt); + len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, ap); + va_end(ap); + if (len >= 0 && app->console) { + len = mprWrite(app->console, buf, len); + } + mprFree(buf); + + return len; +} + +/******************************************************************************/ + +int mprErrorPrintf(MprCtx ctx, const char *fmt, ...) +{ + va_list ap; + char *buf; + int len; + MprApp *app; + + /* No asserts here as this is used as part of assert reporting */ + + app = mprGetApp(ctx); + + va_start(ap, fmt); + len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, ap); + va_end(ap); + if (len >= 0 && app->error) { + len = mprWrite(app->error, buf, len); + } + mprFree(buf); + + return len; +} + +/******************************************************************************/ + +int mprFprintf(MprFile *file, const char *fmt, ...) +{ + va_list ap; + char *buf; + int len; + + if (file == 0) { + return MPR_ERR_BAD_HANDLE; + } + + va_start(ap, fmt); + len = mprAllocVsprintf(MPR_LOC_ARGS(file), &buf, 0, fmt, ap); + va_end(ap); + + if (len >= 0) { + len = mprWrite(file, buf, len); + } + mprFree(buf); + return len; +} + +/******************************************************************************/ +/* + * Printf with a static buffer. Used internally only. WILL NOT MALLOC. + */ + +int mprStaticPrintf(MprCtx ctx, const char *fmt, ...) +{ + va_list ap; + char buf[MPR_MAX_STRING]; + char *bufp; + int len; + MprApp *app; + + app = mprGetApp(ctx); + + va_start(ap, fmt); + bufp = buf; + len = mprSprintfCore(MPR_LOC_ARGS(0), &bufp, MPR_MAX_STRING, fmt, ap); + va_end(ap); + if (len >= 0) { + len = mprWrite(app->console, buf, len); + } + return len; +} + +/******************************************************************************/ + +int mprSprintf(char *buf, int n, const char *fmt, ...) +{ + va_list ap; + int result; + + mprAssert(buf); + mprAssert(fmt); + mprAssert(n > 0); + + va_start(ap, fmt); + result = mprSprintfCore(MPR_LOC_ARGS(0), &buf, n, fmt, ap); + va_end(ap); + return result; +} + +/******************************************************************************/ + +int mprVsprintf(char *buf, int n, const char *fmt, va_list arg) +{ + mprAssert(buf); + mprAssert(fmt); + mprAssert(n > 0); + + return mprSprintfCore(MPR_LOC_ARGS(0), &buf, n, fmt, arg); +} + +/******************************************************************************/ + +int mprAllocSprintf(MPR_LOC_DEC(ctx, loc), char **buf, int maxSize, + const char *fmt, ...) +{ + va_list ap; + int result; + + mprAssert(buf); + mprAssert(fmt); + + *buf = 0; + va_start(ap, fmt); + result = mprSprintfCore(MPR_LOC_PASS(ctx, loc), buf, maxSize, fmt, ap); + va_end(ap); + return result; +} + +/******************************************************************************/ + +int mprAllocVsprintf(MPR_LOC_DEC(ctx, loc), char **buf, int maxSize, + const char *fmt, va_list arg) +{ + mprAssert(buf); + mprAssert(fmt); + + *buf = 0; + return mprSprintfCore(MPR_LOC_PASS(ctx, loc), buf, maxSize, fmt, arg); +} + +/******************************************************************************/ + +static int getState(char c, int state) +{ + /* + * Declared here to remove all static / globals + * FUTURE OPT -- need to measure this. Could be slow on BREW. + */ + + char stateMap[] = { + /* STATES: Normal Percent Modifier Width Dot Prec Bits Type */ + /* CLASS 0 1 2 3 4 5 6 7 */ + /* Normal 0 */ 0, 0, 0, 0, 0, 0, 0, 0, + /* Percent 1 */ 1, 0, 1, 1, 1, 1, 1, 1, + /* Modifier 2 */ 0, 2, 2, 0, 0, 0, 0, 0, + /* Zero 3 */ 0, 2, 2, 3, 0, 5, 0, 0, + /* Star 4 */ 0, 3, 3, 0, 5, 0, 0, 0, + /* Digit 5 */ 0, 3, 3, 3, 5, 5, 0, 0, + /* Dot 6 */ 0, 4, 4, 4, 0, 0, 0, 0, + /* Bits 7 */ 0, 6, 6, 6, 6, 6, 6, 0, + /* Types 8 */ 0, 7, 7, 7, 7, 7, 7, 0, + }; + + /* + * Format: %[modifier][width][precision][bits][type] + */ + char classMap[] = { + /* 0 ' ' ! " # $ % & ' */ + 2, 0, 0, 2, 0, 1, 0, 0, + /* 07 ( ) * + , - . / */ + 0, 0, 4, 2, 2, 2, 6, 0, + /* 10 0 1 2 3 4 5 6 7 */ + 3, 5, 5, 5, 5, 5, 5, 5, + /* 17 8 9 : ; < = > ? */ + 5, 5, 0, 0, 0, 0, 0, 0, + /* 20 @ A B C D E F G */ + 0, 0, 0, 0, 0, 0, 0, 0, + /* 27 H I J K L M N O */ + 0, 0, 0, 0, 7, 0, 0, 0, + /* 30 P Q R S T U V W */ + 0, 0, 0, 8, 0, 0, 0, 0, + /* 37 X Y Z [ \ ] ^ _ */ + 8, 0, 0, 0, 0, 0, 0, 0, + /* 40 ' a b c d e f g */ + 0, 0, 0, 8, 8, 0, 8, 0, + /* 47 h i j k l m n o */ + 7, 8, 0, 0, 7, 0, 8, 8, + /* 50 p q r s t u v w */ + 8, 0, 0, 8, 0, 8, 0, 0, + /* 57 x y z */ + 8, 0, 0, + }; + + int chrClass; + + if (c < ' ' || c > 'z') { + chrClass = CLASS_NORMAL; + } else { + mprAssert((c - ' ') < (int) sizeof(classMap)); + chrClass = classMap[(c - ' ')]; + } + mprAssert((chrClass * STATE_COUNT + state) < (int) sizeof(stateMap)); + state = stateMap[chrClass * STATE_COUNT + state]; + return state; +} + +/******************************************************************************/ + +static int mprSprintfCore(MPR_LOC_DEC(ctx, loc), char **bufPtr, + int maxsize, const char *spec, va_list arg) +{ + Format fmt; + char *cp; + char c; + char *sValue; + num iValue; + unum uValue; + int count, i, len, state; + + mprAssert(bufPtr); + mprAssert(spec); + + if (*bufPtr != 0) { + mprAssert(maxsize > 0); + fmt.buf = (uchar*) *bufPtr; + fmt.endbuf = &fmt.buf[maxsize]; + fmt.growBy = 0; + } else { + if (maxsize <= 0) { + maxsize = MAXINT; + } + + len = min(MPR_DEFAULT_ALLOC, maxsize); + fmt.buf = (uchar*) mprAllocBlock(MPR_LOC_PASS(ctx, loc), len); + fmt.endbuf = &fmt.buf[len]; + fmt.growBy = MPR_DEFAULT_ALLOC * 2; + } + + fmt.maxsize = maxsize; + fmt.start = fmt.buf; + fmt.end = fmt.buf; + fmt.len = 0; + *fmt.start = '\0'; + + state = STATE_NORMAL; + + while ((c = *spec++) != '\0') { + state = getState(c, state); + + switch (state) { + case STATE_NORMAL: + BPUT(ctx, loc, &fmt, c); + break; + + case STATE_PERCENT: + fmt.precision = -1; + fmt.width = 0; + fmt.flags = 0; + break; + + case STATE_MODIFIER: + switch (c) { + case '+': + fmt.flags |= SPRINTF_SIGN; + break; + case '-': + fmt.flags |= SPRINTF_LEFT; + break; + case '#': + fmt.flags |= SPRINTF_ALTERNATE; + break; + case '0': + fmt.flags |= SPRINTF_LEAD_ZERO; + break; + case ' ': + fmt.flags |= SPRINTF_LEAD_SPACE; + break; + case ',': + fmt.flags |= SPRINTF_COMMA; + break; + } + break; + + case STATE_WIDTH: + if (c == '*') { + fmt.width = va_arg(arg, int); + if (fmt.width < 0) { + fmt.width = -fmt.width; + fmt.flags |= SPRINTF_LEFT; + } + } else { + while (isdigit((int)c)) { + fmt.width = fmt.width * 10 + (c - '0'); + c = *spec++; + } + spec--; + } + break; + + case STATE_DOT: + fmt.precision = 0; + fmt.flags &= ~SPRINTF_LEAD_ZERO; + break; + + case STATE_PRECISION: + if (c == '*') { + fmt.precision = va_arg(arg, int); + } else { + while (isdigit((int) c)) { + fmt.precision = fmt.precision * 10 + (c - '0'); + c = *spec++; + } + spec--; + } + break; + + case STATE_BITS: + switch (c) { +#if BLD_FEATURE_INT64 + case 'L': + fmt.flags |= SPRINTF_LONGLONG; /* 64 bit */ + break; +#endif + + case 'l': + fmt.flags |= SPRINTF_LONG; + break; + + case 'h': + fmt.flags |= SPRINTF_SHORT; + break; + } + break; + + case STATE_TYPE: + switch (c) { +#if BLD_FEATURE_FLOATING_POINT + case 'e': + case 'g': + case 'f': + fmt.radix = 10; + outFloat(MPR_LOC_PASS(ctx, loc), &fmt, c, + (double) va_arg(arg, double)); + break; +#endif + case 'c': + BPUT(ctx, loc, &fmt, (char) va_arg(arg, int)); + break; + + case 's': + case 'S': + sValue = va_arg(arg, char*); + if (sValue == 0) { + sValue = "null"; + len = strlen(sValue); + } else if (fmt.flags & SPRINTF_ALTERNATE) { + sValue++; + len = (int) *sValue; + } else if (fmt.precision >= 0) { + /* + * Can't use strlen(), the string may not have a null + */ + cp = sValue; + for (len = 0; len < fmt.precision; len++) { + if (*cp++ == '\0') { + break; + } + } + } else { + len = strlen(sValue); + } + if (!(fmt.flags & SPRINTF_LEFT)) { + for (i = len; i < fmt.width; i++) { + BPUT(ctx, loc, &fmt, (char) ' '); + } + } + for (i = 0; i < len && *sValue; i++) { + BPUT(ctx, loc, &fmt, *sValue++); + } + if (fmt.flags & SPRINTF_LEFT) { + for (i = len; i < fmt.width; i++) { + BPUT(ctx, loc, &fmt, (char) ' '); + } + } + break; + + case 'i': + ; + case 'd': + fmt.radix = 10; + if (fmt.flags & SPRINTF_SHORT) { + iValue = (short) va_arg(arg, int); + } else if (fmt.flags & SPRINTF_LONG) { + iValue = va_arg(arg, long); +#if BLD_FEATURE_INT64 + } else if (fmt.flags & SPRINTF_LONGLONG) { + iValue = va_arg(arg, num); +#endif + } else { + iValue = va_arg(arg, int); + } + if (iValue >= 0) { + if (fmt.flags & SPRINTF_LEAD_SPACE) { + outNum(MPR_LOC_PASS(ctx, loc), &fmt, " ", iValue); + } else if (fmt.flags & SPRINTF_SIGN) { + outNum(MPR_LOC_PASS(ctx, loc), &fmt, "+", iValue); + } else { + outNum(MPR_LOC_PASS(ctx, loc), &fmt, 0, iValue); + } + } else { + outNum(MPR_LOC_PASS(ctx, loc), &fmt, "-", -iValue); + } + break; + + case 'X': + fmt.flags |= SPRINTF_UPPER_CASE; + /* Fall through */ + case 'o': + case 'x': + case 'u': + if (fmt.flags & SPRINTF_SHORT) { + uValue = (ushort) va_arg(arg, uint); + } else if (fmt.flags & SPRINTF_LONG) { + uValue = va_arg(arg, ulong); +#if BLD_FEATURE_INT64 + } else if (fmt.flags & SPRINTF_LONGLONG) { + uValue = va_arg(arg, unum); +#endif + } else { + uValue = va_arg(arg, uint); + } + if (c == 'u') { + fmt.radix = 10; + outNum(MPR_LOC_PASS(ctx, loc), &fmt, 0, uValue); + } else if (c == 'o') { + fmt.radix = 8; + if (fmt.flags & SPRINTF_ALTERNATE && uValue != 0) { + outNum(MPR_LOC_PASS(ctx, loc), &fmt, "0", uValue); + } else { + outNum(MPR_LOC_PASS(ctx, loc), &fmt, 0, uValue); + } + } else { + fmt.radix = 16; + if (fmt.flags & SPRINTF_ALTERNATE && uValue != 0) { + if (c == 'X') { + outNum(MPR_LOC_PASS(ctx, loc), &fmt, "0X", uValue); + } else { + outNum(MPR_LOC_PASS(ctx, loc), &fmt, "0x", uValue); + } + } else { + outNum(MPR_LOC_PASS(ctx, loc), &fmt, 0, uValue); + } + } + break; + + case 'n': /* Count of chars seen thus far */ + if (fmt.flags & SPRINTF_SHORT) { + short *count = va_arg(arg, short*); + *count = fmt.end - fmt.start; + } else if (fmt.flags & SPRINTF_LONG) { + long *count = va_arg(arg, long*); + *count = fmt.end - fmt.start; + } else { + int *count = va_arg(arg, int *); + *count = fmt.end - fmt.start; + } + break; + + case 'p': /* Pointer */ +#if __WORDSIZE == 64 && BLD_FEATURE_INT64 + uValue = (unum) va_arg(arg, void*); +#else + uValue = (uint) (int) va_arg(arg, void*); +#endif + fmt.radix = 16; + outNum(MPR_LOC_PASS(ctx, loc), &fmt, "0x", uValue); + break; + + default: + BPUT(ctx, loc, &fmt, c); + } + } + } + BPUTNULL(ctx, loc, &fmt); + + count = fmt.end - fmt.start; + if (*bufPtr == 0) { + *bufPtr = (char*) fmt.buf; + } + return count; +} + +/******************************************************************************/ +/* + * Output a number according to the given format. If BLD_FEATURE_INT64 is + * defined, then uses 64 bits universally. Slower but smaller code. + */ + +static void outNum(MPR_LOC_DEC(ctx, loc), Format *fmt, const char *prefix, + unum value) +{ + char numBuf[64]; + char *cp; + char *endp; + char c; + int letter, len, leadingZeros, i, fill; + + endp = &numBuf[sizeof(numBuf) - 1]; + *endp = '\0'; + cp = endp; + + /* + * Convert to ascii + */ + if (fmt->radix == 16) { + do { + letter = (int) (value % fmt->radix); + if (letter > 9) { + if (fmt->flags & SPRINTF_UPPER_CASE) { + letter = 'A' + letter - 10; + } else { + letter = 'a' + letter - 10; + } + } else { + letter += '0'; + } + *--cp = letter; + value /= fmt->radix; + } while (value > 0); + + } else if (fmt->flags & SPRINTF_COMMA) { + i = 1; + do { + *--cp = '0' + (int) (value % fmt->radix); + value /= fmt->radix; + if ((i++ % 3) == 0 && value > 0) { + *--cp = ','; + } + } while (value > 0); + } else { + do { + *--cp = '0' + (int) (value % fmt->radix); + value /= fmt->radix; + } while (value > 0); + } + + len = endp - cp; + fill = fmt->width - len; + + if (prefix != 0) { + fill -= strlen(prefix); + } + leadingZeros = (fmt->precision > len) ? fmt->precision - len : 0; + fill -= leadingZeros; + + if (!(fmt->flags & SPRINTF_LEFT)) { + c = (fmt->flags & SPRINTF_LEAD_ZERO) ? '0': ' '; + for (i = 0; i < fill; i++) { + BPUT(ctx, loc, fmt, c); + } + } + if (prefix != 0) { + while (*prefix) { + BPUT(ctx, loc, fmt, *prefix++); + } + } + for (i = 0; i < leadingZeros; i++) { + BPUT(ctx, loc, fmt, '0'); + } + while (*cp) { + BPUT(ctx, loc, fmt, *cp); + cp++; + } + if (fmt->flags & SPRINTF_LEFT) { + for (i = 0; i < fill; i++) { + BPUT(ctx, loc, fmt, ' '); + } + } +} + +/******************************************************************************/ +#if BLD_FEATURE_FLOATING_POINT +/* + * Output a floating point number + */ + +static void outFloat(MPR_LOC_DEC(ctx, loc), Format *fmt, char specChar, + double value) +{ + char *cp; +#if FUTURE + char numBuf[64]; + char *endp; + char c; + int letter, len, leadingZeros, i, fill, width, precision; + + endp = &numBuf[sizeof(numBuf) - 1]; + *endp = '\0'; + + precision = fmt->precision; + if (precision < 0) { + precision = 6; + } else if (precision > (sizeof(numBuf) - 1)) { + precision = (sizeof(numBuf) - 1); + } + width = min(fmt->width, sizeof(numBuf) - 1); + + if (__isnanl(value)) { + "nan" + } else if (__isinfl(value)) { + "infinity" + } else if (value < 0) { + prefix = "-"; + } else if (fmt.flags & SPRINTF_LEAD_SPACE) { + prefix = " "; + } else if (fmt.flags & SPRINTF_SIGN) { + prefix = "+"; + } + + + /* + * Do the exponent part + */ + cp = &numBuf[sizeof(numBuf) - precision]; + for (i = 0; i < precision; i++) { + *cp++ = '0' + (int) (value % fmt->radix); + value /= fmt->radix; + } + + /* + * Do the decimal part + */ + if (fmt->flags & SPRINTF_COMMA) { + i = 1; + do { + *--cp = '0' + (int) (value % fmt->radix); + value /= fmt->radix; + if ((i++ % 3) == 0 && value > 0) { + *--cp = ','; + } + } while (value >= 1.0); + + } else { + do { + *--cp = '0' + (int) (value % fmt->radix); + value /= fmt->radix; + } while (value > 1.0); + } + + len = endp - cp; + fill = fmt->width - len; + + if (prefix != 0) { + fill -= strlen(prefix); + } + + leadingZeros = (fmt->precision > len) ? fmt->precision - len : 0; + fill -= leadingZeros; + + if (!(fmt->flags & SPRINTF_LEFT)) { + c = (fmt->flags & SPRINTF_LEAD_ZERO) ? '0': ' '; + for (i = 0; i < fill; i++) { + BPUT(ctx, loc, fmt, c); + } + } + if (prefix != 0) { + BPUT(ctx, loc, fmt, prefix); + } + for (i = 0; i < leadingZeros; i++) { + BPUT(ctx, loc, fmt, '0'); + } + BPUT(ctx, loc, fmt, cp); + if (fmt->flags & SPRINTF_LEFT) { + for (i = 0; i < fill; i++) { + BPUT(ctx, loc, fmt, ' '); + } + } +#else + char numBuf[64]; + if (specChar == 'f') { + sprintf(numBuf, "%*.*f", fmt->width, fmt->precision, value); + } else if (specChar == 'g') { + sprintf(numBuf, "%*.*g", fmt->width, fmt->precision, value); + } else if (specChar == 'e') { + sprintf(numBuf, "%*.*e", fmt->width, fmt->precision, value); + } + for (cp = numBuf; *cp; cp++) { + BPUT(ctx, loc, fmt, *cp); + } +#endif +} + +#endif /* BLD_FEATURE_FLOATING_POINT */ +/******************************************************************************/ +/* + * Grow the buffer to fit new data. Return 1 if the buffer can grow. + * Grow using the growBy size specified when creating the buffer. + */ + +static int growBuf(MPR_LOC_DEC(ctx, loc), Format *fmt) +{ + uchar *newbuf; + int buflen; + + buflen = fmt->endbuf - fmt->buf; + if (fmt->maxsize >= 0 && buflen >= fmt->maxsize) { + return 0; + } + if (fmt->growBy < 0) { + /* + * User supplied buffer + */ + return 0; + } + + newbuf = (uchar*) mprAlloc(ctx, buflen + fmt->growBy); + if (fmt->buf) { + memcpy(newbuf, fmt->buf, buflen); + mprFree(fmt->buf); + } + + buflen += fmt->growBy; + fmt->end = newbuf + (fmt->end - fmt->buf); + fmt->start = newbuf + (fmt->start - fmt->buf); + fmt->buf = newbuf; + fmt->endbuf = &fmt->buf[buflen]; + + /* + * Increase growBy to reduce overhead + */ + if ((buflen + (fmt->growBy * 2)) < fmt->maxsize) { + fmt->growBy *= 2; + } + return 1; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprString.c b/source4/lib/appweb/ejs-2.0/mpr/mprString.c new file mode 100644 index 0000000000..b688667bcc --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprString.c @@ -0,0 +1,727 @@ +/** + * @file mprString.c + * @brief String routines safe for embedded programming + * @overview This module provides safe replacements for the standard + * string library. + * @remarks Most routines in this file are not thread-safe. It is the callers + * responsibility to perform all thread synchronization. + */ + +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 "mpr.h" + +/********************************** Includes **********************************/ +/* + * We need to use the underlying str(cpy) routines to implement our safe + * alternatives + */ +#if !DOXYGEN +#define UNSAFE_FUNCTIONS_OK 1 +#endif + +/******************************************************************************/ +/**************************** Safe String Handling ****************************/ +/******************************************************************************/ + +int mprStrcpy(char *dest, int destMax, const char *src) +{ + int len; + + mprAssert(dest); + mprAssert(destMax >= 0); + mprAssert(src); + + len = strlen(src); + if (destMax > 0 && len >= destMax && len > 0) { + return MPR_ERR_WONT_FIT; + } + if (len > 0) { + memcpy(dest, src, len); + dest[len] = '\0'; + } else { + *dest = '\0'; + len = 0; + } + return len; +} + +/******************************************************************************/ + +int mprAllocStrcpy(MPR_LOC_DEC(ctx, loc), char **dest, int destMax, + const char *src) +{ + int len; + + mprAssert(dest); + mprAssert(destMax >= 0); + mprAssert(src); + + len = strlen(src); + if (destMax > 0 && len >= destMax) { + mprAssert(0); + return MPR_ERR_WONT_FIT; + } + if (len > 0) { + *dest = (char*) mprAllocBlock(MPR_LOC_PASS(ctx, loc), len); + memcpy(*dest, src, len); + (*dest)[len] = '\0'; + } else { + *dest = (char*) mprAlloc(ctx, 1); + *dest = '\0'; + len = 0; + } + return len; +} + +/******************************************************************************/ + +int mprMemcpy(char *dest, int destMax, const char *src, int nbytes) +{ + mprAssert(dest); + mprAssert(destMax <= 0 || destMax >= nbytes); + mprAssert(src); + mprAssert(nbytes >= 0); + + if (destMax > 0 && nbytes > destMax) { + mprAssert(0); + return MPR_ERR_WONT_FIT; + } + if (nbytes > 0) { + memcpy(dest, src, nbytes); + return nbytes; + } else { + return 0; + } +} + +/******************************************************************************/ + +int mprAllocMemcpy(MPR_LOC_DEC(ctx, loc), char **dest, int destMax, + const void *src, int nbytes) +{ + mprAssert(dest); + mprAssert(src); + mprAssert(nbytes > 0); + mprAssert(destMax <= 0 || destMax >= nbytes); + + if (destMax > 0 && nbytes > destMax) { + mprAssert(0); + return MPR_ERR_WONT_FIT; + } + if (nbytes > 0) { + *dest = (char*) mprAllocBlock(MPR_LOC_PASS(ctx,loc), nbytes); + if (*dest == 0) { + return MPR_ERR_MEMORY; + } + memcpy(*dest, src, nbytes); + } else { + *dest = (char*) mprAlloc(ctx, 1); + } + return nbytes; +} + +/******************************************************************************/ + +static int mprCoreStrcat(MPR_LOC_DEC(ctx, loc), char **destp, int destMax, + int existingLen, const char *delim, const char *src, va_list args) +{ + va_list ap; + char *dest, *str, *dp; + 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; + if (existingLen > 0) { + addBytes += sepLen; + } + str = (char*) src; + + while (str) { + addBytes += strlen(str); + str = va_arg(ap, char*); + if (str) { + addBytes += sepLen; + } + } + + required = existingLen + addBytes + 1; + if (destMax > 0 && required >= destMax) { + mprAssert(0); + return MPR_ERR_WONT_FIT; + } + + if (ctx != 0) { + if (dest == 0) { + dest = (char*) mprAllocBlock(MPR_LOC_PASS(ctx, loc), required); + } else { + dest = (char*) mprReallocBlock(MPR_LOC_PASS(ctx, loc), dest, + required); + } + } else { + dest = (char*) *destp; + } + + dp = &dest[existingLen]; + if (delim && existingLen > 0) { + strcpy(dp, delim); + dp += sepLen; + } + + if (addBytes > 0) { +#ifdef __va_copy + __va_copy(ap, args); +#else + ap = args; +#endif + str = (char*) 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*) mprAlloc(ctx, 1); + } + *dp = '\0'; + + *destp = dest; + mprAssert(dp < &dest[required]); + return required - 1; +} + +/******************************************************************************/ + +int mprStrcat(char *dest, int destMax, const char *delim, const char *src, ...) +{ + va_list ap; + int rc; + + mprAssert(dest); + mprAssert(src); + + va_start(ap, src); + rc = mprCoreStrcat(MPR_LOC_ARGS(0), &dest, destMax, strlen(dest), + delim, src, ap); + va_end(ap); + return rc; +} + +/******************************************************************************/ + +int mprAllocStrcat(MPR_LOC_DEC(ctx, loc), char **destp, int destMax, + const char *delim, const char *src, ...) +{ + va_list ap; + int rc; + + mprAssert(destp); + mprAssert(src); + + *destp = 0; + va_start(ap, src); + rc = mprCoreStrcat(MPR_LOC_PASS(ctx, loc), destp, destMax, 0, delim, + src, ap); + va_end(ap); + return rc; +} + +/******************************************************************************/ + +int mprReallocStrcat(MPR_LOC_DEC(ctx, loc), char **destp, int destMax, + int existingLen, const char *delim, const char *src,...) +{ + va_list ap; + int rc; + + va_start(ap, src); + rc = mprCoreStrcat(MPR_LOC_PASS(ctx, loc), destp, destMax, existingLen, + delim, src, ap); + va_end(ap); + return rc; +} + +/******************************************************************************/ + +int mprStrlen(const char *src, int max) +{ + int len; + + len = strlen(src); + if (len >= max) { + mprAssert(0); + return MPR_ERR_WONT_FIT; + } + return len; +} + +/******************************************************************************/ + +char *mprStrTrim(char *str, const char *set) +{ + int len, i; + + if (str == 0 || set == 0) { + return str; + } + + i = strspn(str, set); + str += i; + + len = strlen(str); + while (strspn(&str[len - 1], set) > 0) { + str[len - 1] = '\0'; + len--; + } + return str; +} + +/******************************************************************************/ +/* + * Map a string to lower case (overwrites original string) + */ + +char *mprStrLower(char *str) +{ + char *cp; + + mprAssert(str); + + if (str == 0) { + return 0; + } + + for (cp = str; *cp; cp++) { + if (isupper(*cp)) { + *cp = (char) tolower(*cp); + } + } + return str; +} + +/******************************************************************************/ +/* + * Map a string to upper case (overwrites buffer) + */ + +char *mprStrUpper(char *str) +{ + char *cp; + + mprAssert(str); + if (str == 0) { + return 0; + } + + for (cp = str; *cp; cp++) { + if (islower(*cp)) { + *cp = (char) toupper(*cp); + } + } + return str; +} + +/******************************************************************************/ +/* + * Case insensitive string comparison. Stop at the end of str1. + */ + +int mprStrcmpAnyCase(const char *str1, const char *str2) +{ + int rc; + + if (str1 == 0 || str2 == 0) { + return -1; + } + if (str1 == str2) { + return 0; + } + + for (rc = 0; *str1 && rc == 0; str1++, str2++) { + rc = tolower(*str1) - tolower(*str2); + } + if (*str2) { + return -1; + } + return rc; +} + +/******************************************************************************/ +/* + * Case insensitive string comparison. Limited by length + */ + +int mprStrcmpAnyCaseCount(const char *str1, const char *str2, int len) +{ + int rc; + + if (str1 == 0 || str2 == 0) { + return -1; + } + if (str1 == str2) { + return 0; + } + + for (rc = 0; len-- > 0 && *str1 && rc == 0; str1++, str2++) { + rc = tolower(*str1) - tolower(*str2); + } + return rc; +} + +/******************************************************************************/ +/* + * Return the last portion of a pathname + */ + +const char *mprGetBaseName(const char *name) +{ + char *cp; + + cp = strrchr(name, '/'); + + if (cp == 0) { + cp = strrchr(name, '\\'); + if (cp == 0) { + return name; + } + } + if (cp == name) { + if (cp[1] == '\0') { + return name; + } + } else { + if (cp[1] == '\0') { + return ""; + } + } + return &cp[1]; +} + +/******************************************************************************/ +/* + * Return the directory portion of a pathname into the users buffer. + */ + +char *mprGetDirName(char *buf, int bufsize, const 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 buf; + } + } + + if (cp == path && cp[1] == '\0') { + strcpy(buf, "."); + return buf; + } + + dlen = cp - path; + if (dlen < bufsize) { + if (dlen == 0) { + dlen++; + } + mprMemcpy(buf, bufsize, path, dlen); + buf[dlen] = '\0'; + return buf; + } + return 0; +} + +/******************************************************************************/ +/* + * Thread-safe wrapping of strtok. Note "str" is modifed as per strtok() + */ + +char *mprStrTok(char *str, const char *delim, char **last) +{ + char *start, *end; + int i; + + start = str ? str : *last; + + if (start == 0) { + return 0; + } + + i = strspn(start, delim); + start += i; + if (*start == '\0') { + *last = 0; + return 0; + } + end = strpbrk(start, delim); + if (end) { + *end++ = '\0'; + i = strspn(end, delim); + end += i; + } + *last = end; + return start; +} + +/******************************************************************************/ +/* + * Split the buffer into word tokens + */ + +char *mprGetWordTok(char *buf, int bufsize, const char *str, const char *delim, + const char **tok) +{ + const char *start, *end; + int i, len; + + 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) { + len = min(end - start, bufsize - 1); + mprMemcpy(buf, bufsize, start, len); + buf[len] = '\0'; + } else { + if (mprStrcpy(buf, bufsize, start) < 0) { + buf[bufsize - 1] = '\0'; + return 0; + } + buf[bufsize - 1] = '\0'; + } + *tok = end; + return buf; +} + +/******************************************************************************/ +/* + * Format a number as a string. + */ + +char *mprItoa(char *buf, int size, int value) +{ + char numBuf[16]; + char *cp, *dp, *endp; + int negative; + + cp = &numBuf[sizeof(numBuf)]; + *--cp = '\0'; + + if (value < 0) { + negative = 1; + value = -value; + size--; + } else { + negative = 0; + } + + do { + *--cp = '0' + (value % 10); + value /= 10; + } while (value > 0); + + if (negative) { + *--cp = '-'; + } + + dp = buf; + endp = &buf[size]; + while (dp < endp && *cp) { + *dp++ = *cp++; + } + *dp++ = '\0'; + return buf; +} + +/******************************************************************************/ +/* + * Parse an ascii number. Supports radix 10 or 16. + */ + +int mprAtoi(const char *str, int radix) +{ + int c, val, negative; + + mprAssert(radix == 10 || radix == 16); + + if (str == 0) { + return 0; + } + + val = 0; + if (radix == 10 && *str == '-') { + negative = 1; + str++; + } else { + negative = 0; + } + + if (radix == 10) { + while (*str && isdigit(*str)) { + val = (val * radix) + *str - '0'; + str++; + } + } else if (radix == 16) { + if (*str == '0' && tolower(str[1]) == 'x') { + str += 2; + } + while (*str) { + c = tolower(*str); + if (isdigit(c)) { + val = (val * radix) + c - '0'; + } else if (c >= 'a' && c <= 'f') { + val = (val * radix) + c - 'a' + 10; + } else { + break; + } + str++; + } + } + + return (negative) ? -val: val; +} + +/******************************************************************************/ +/* + * Make an argv array. Caller must free by calling mprFree(argv) to free + * everything. + */ + +int mprMakeArgv(MprCtx ctx, const char *program, const char *cmd, + char ***argvp, int *argcp) +{ + char *cp, **argv, *buf, *args; + int size, argc; + + /* + * Allocate one buffer for argv and the actual args themselves + */ + size = strlen(cmd) + 1; + + buf = (char*) mprAlloc(ctx, (MPR_MAX_ARGC * sizeof(char*)) + size); + if (buf == 0) { + return MPR_ERR_MEMORY; + } + + args = &buf[MPR_MAX_ARGC * sizeof(char*)]; + strcpy(args, cmd); + argv = (char**) buf; + + argc = 0; + if (program) { + argv[argc++] = (char*) mprStrdup(ctx, program); + } + + for (cp = args; cp && *cp != '\0'; argc++) { + if (argc >= MPR_MAX_ARGC) { + mprAssert(argc < MPR_MAX_ARGC); + mprFree(buf); + *argvp = 0; + if (argcp) { + *argcp = 0; + } + return MPR_ERR_TOO_MANY; + } + while (isspace(*cp)) { + cp++; + } + if (*cp == '\0') { + break; + } + if (*cp == '"') { + cp++; + argv[argc] = cp; + while ((*cp != '\0') && (*cp != '"')) { + cp++; + } + } else { + argv[argc] = cp; + while (*cp != '\0' && !isspace(*cp)) { + cp++; + } + } + if (*cp != '\0') { + *cp++ = '\0'; + } + } + argv[argc] = 0; + + if (argcp) { + *argcp = argc; + } + *argvp = argv; + + return argc; +} + +/******************************************************************************/ + +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprSymbol.c b/source4/lib/appweb/ejs-2.0/mpr/mprSymbol.c new file mode 100644 index 0000000000..11ac278db4 --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprSymbol.c @@ -0,0 +1,279 @@ +/* + * @file mprSym.cpp + * @brief Fast hashing symbol table lookup module + * @overview This symbol table uses a fast key lookup mechanism. Keys are + * strings and the value entries are arbitrary pointers. The keys are + * hashed into a series of buckets which then have a chain of hash + * entries using the standard doubly linked list classes (List/Link). + * The chain in in collating sequence so search time through the chain + * is on average (N/hashSize)/2. + * @remarks This module is not thread-safe. It is the callers responsibility + * to perform all thread synchronization. + */ +/********************************* Copyright **********************************/ +/* + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 + */ +/********************************** Includes **********************************/ + +#include "mpr.h" + +/**************************** Forward Declarations ****************************/ + +static int hashIndex(const char *key, int size); +static MprSymbol *lookupInner(int *bucketIndex, MprSymbol **prevSp, + MprSymbolTable *table, const char *key); + +/*********************************** Code *************************************/ +/* + * Create a new symbol table of a given size. Caller should provide a size + * that is a prime number for the greatest efficiency. Caller should use + * mprFree to free the symbol table. + */ + +MprSymbolTable *mprCreateSymbolTable(MprCtx ctx, int hashSize) +{ + MprSymbolTable *table; + + table = mprAllocTypeZeroed(ctx, MprSymbolTable); + if (table == 0) { + return 0; + } + + if (hashSize < MPR_DEFAULT_HASH_SIZE) { + hashSize = MPR_DEFAULT_HASH_SIZE; + } + table->hashSize = hashSize; + + table->count = 0; + table->hashSize = hashSize; + table->buckets = mprAllocZeroedBlock(MPR_LOC_ARGS(table), + sizeof(MprSymbol*) * hashSize); + + if (table->buckets == 0) { + mprFree(table); + return 0; + } + + return table; +} + +/******************************************************************************/ +/* + * Insert an entry into the symbol table. If the entry already exists, update + * its value. Order of insertion is not preserved. + */ + +MprSymbol *mprInsertSymbol(MprSymbolTable *table, const char *key, void *ptr) +{ + MprSymbol *sp, *prevSp; + int index; + + sp = lookupInner(&index, &prevSp, table, key); + + if (sp != 0) { + /* + * Already exists. Just update the data. + */ + sp->data = ptr; + return sp; + } + + /* + * New entry + */ + sp = mprAllocTypeZeroed(table, MprSymbol); + if (sp == 0) { + return 0; + } + + sp->data = ptr; + sp->key = mprStrdup(sp, key); + sp->bucket = index; + + sp->next = table->buckets[index]; + table->buckets[index] = sp; + + table->count++; + return sp; +} + +/******************************************************************************/ +/* + * Remove an entry from the table + */ + +int mprRemoveSymbol(MprSymbolTable *table, const char *key) +{ + MprSymbol *sp, *prevSp; + int index; + + if ((sp = lookupInner(&index, &prevSp, table, key)) == 0) { + return MPR_ERR_NOT_FOUND; + } + + if (prevSp) { + prevSp->next = sp->next; + } else { + table->buckets[index] = sp->next; + } + table->count--; + + mprFree(sp); + return 0; +} + +/******************************************************************************/ +/* + * Lookup a key and return the hash entry + */ + +void *mprLookupSymbol(MprSymbolTable *table, const char *key) +{ + MprSymbol *sp; + + mprAssert(key); + + sp = lookupInner(0, 0, table, key); + if (sp == 0) { + return 0; + } + return sp->data; +} + +/******************************************************************************/ + +static MprSymbol *lookupInner(int *bucketIndex, MprSymbol **prevSp, + MprSymbolTable *table, const char *key) +{ + MprSymbol *sp, *prev; + int index, rc; + + mprAssert(key); + + index = hashIndex(key, table->hashSize); + if (bucketIndex) { + *bucketIndex = index; + } + + sp = table->buckets[index]; + prev = 0; + + while (sp) { + rc = strcmp(sp->key, key); + if (rc == 0) { + if (prevSp) { + *prevSp = prev; + } + return sp; + } + prev = sp; + mprAssert(sp != sp->next); + sp = sp->next; + } + return 0; +} + +/******************************************************************************/ + +int mprGetSymbolCount(MprSymbolTable *table) +{ + return table->count; +} + +/******************************************************************************/ +/* + * Return the first entry in the table. + */ + +MprSymbol *mprGetFirstSymTab(MprSymbolTable *table) +{ + MprSymbol *sp; + int i; + + mprAssert(table); + + for (i = 0; i < table->hashSize; i++) { + if ((sp = (MprSymbol*) table->buckets[i]) != 0) { + return sp; + } + } + return 0; +} + +/******************************************************************************/ +/* + * Return the next entry in the table + */ + +MprSymbol *mprGetNextSymTab(MprSymbolTable *table, MprSymbol *last) +{ + MprSymbol *sp; + int i; + + mprAssert(table); + + if (last->next) { + return last->next; + } + + for (i = last->bucket + 1; i < table->hashSize; i++) { + if ((sp = (MprSymbol*) table->buckets[i]) != 0) { + return sp; + } + } + return 0; +} + +/******************************************************************************/ +/* + * Hash the key to produce a hash index. + */ + +static int hashIndex(const char *key, int size) +{ + uint sum; + + sum = 0; + while (*key) { + sum += (sum * 33) + *key++; + } + + return sum % size; +} + +/******************************************************************************/ +/* + * 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 + */ diff --git a/source4/lib/appweb/ejs-2.0/mpr/mprUnix.h b/source4/lib/appweb/ejs-2.0/mpr/mprUnix.h new file mode 100644 index 0000000000..fbbe29ae9c --- /dev/null +++ b/source4/lib/appweb/ejs-2.0/mpr/mprUnix.h @@ -0,0 +1,105 @@ +/* + * @file mprUnix.h + * @brief Make windows a bit more unix like + * @copy default + * + * Copyright (c) Mbedthis Software LLC, 2003-2006. 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 ********************************/ + +/* + * This header is part of the Mbedthis Portable Runtime and aims to include + * all necessary O/S headers and to unify the constants and declarations + * required by Mbedthis products. It can be included by C or C++ programs. + */ + +/******************************************************************************/ + +#ifndef _h_MPR_UNIX +#define _h_MPR_UNIX 1 + +/******************************************************************************/ +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Define BLD_NO_POSIX_REMAP if these defines mess with your app + */ +#if WIN && !BLD_NO_POSIX_REMAP +/* + * MOB -- clashes with ATL + */ +#define access _access +#define close _close +#define fileno _fileno +#define fstat _fstat +#define getpid _getpid +#define open _open +#define putenv _putenv +#define read _read +#define stat _stat +#define umask _umask +#define unlink _unlink +#define write _write +#define strdup _strdup +#define lseek _lseek +#define getcwd _getcwd +#define chdir _chdir + +#define mkdir(a,b) _mkdir(a) +#define rmdir(a) _rmdir(a) + +#define R_OK 4 +#define W_OK 2 +#define MPR_TEXT "t" + +extern void srand48(long); +extern long lrand48(void); +extern long ulimit(int, ...); +extern long nap(long); +extern int getuid(void); +extern int geteuid(void); +#endif + + +/******************************************************************************/ +#ifdef __cplusplus +} +#endif + +#endif /* _h_MPR_UNIX */ + +/* + * 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 + */ |