hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

removed redundant code

Browse Source
This commit is contained in:
hyung-hwan 2011-12-28 14:26:02 +00:00
parent 29107a71be
commit bd7fd49a72
46 changed files with 156 additions and 424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
qse/cmd/awk/awk.c
View File

@ -507,7 +507,7 @@ static int comparg (int argc, qse_char_t* argv[], struct arg_t* arg)
}
gvm = qse_htb_open (
QSE_NULL, 0, 30, 70,
QSE_MMGR_GETDFL(), 0, 30, 70,
QSE_SIZEOF(qse_char_t), QSE_SIZEOF(struct gvmv_t)
);
if (gvm == QSE_NULL)
@ -885,7 +885,7 @@ static int awk_main (int argc, qse_char_t* argv[])
#endif
if (arg.memlimit > 0)
{
xma_mmgr.ctx = qse_xma_open (QSE_NULL, 0, arg.memlimit);
xma_mmgr.ctx = qse_xma_open (QSE_MMGR_GETDFL(), 0, arg.memlimit);
if (xma_mmgr.ctx == QSE_NULL)
{
qse_printf (QSE_T("ERROR: cannot open memory heap\n"));

3
qse/cmd/fs/fs.c
View File

@ -19,6 +19,7 @@
*/
#include <qse/cmn/fs.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/main.h>
#include <qse/cmn/stdio.h>
@ -46,7 +47,7 @@ int fs_main (int argc, qse_char_t* argv[])
qse_fs_t* fs;
fs = qse_fs_open (QSE_NULL, 0);
fs = qse_fs_open (QSE_MMGR_GETDFL(), 0);
if (fs == QSE_NULL)
{
qse_fprintf (QSE_STDERR, QSE_T("ERROR: cannot open fs\n"));

2
qse/cmd/sed/sed.c
View File

@ -541,7 +541,7 @@ int sed_main (int argc, qse_char_t* argv[])
#endif
if (g_memlimit > 0)
{
xma_mmgr.ctx = qse_xma_open (QSE_NULL, 0, g_memlimit);
xma_mmgr.ctx = qse_xma_open (QSE_MMGR_GETDFL(), 0, g_memlimit);
if (xma_mmgr.ctx == QSE_NULL)
{
qse_printf (QSE_T("ERROR: cannot open memory heap\n"));

3
qse/cmd/stx/stx.c
View File

@ -1,5 +1,6 @@
/*#include <qse/stx/stx.h>*/
#include "../../lib/stx/stx.h"
#include <qse/cmn/mem.h>
#include <qse/cmn/main.h>
#include <qse/cmn/stdio.h>
@ -198,7 +199,7 @@ static int stx_main (int argc, qse_char_t* argv[])
}
#endif
stx = qse_stx_open (QSE_NULL, 0, 10000);
stx = qse_stx_open (QSE_MMGR_GETDFL(), 0, 10000);
if (stx == QSE_NULL)
{
qse_printf (QSE_T("cannot open stx\n"));

16
qse/include/qse/cmn/pio.h
View File

@ -33,9 +33,9 @@
*/
/**
* The qse_pio_oflag_t defines enumerators to compose flags to qse_pio_open().
* The qse_pio_flag_t defines enumerators to compose flags to qse_pio_open().
*/
enum qse_pio_oflag_t
enum qse_pio_flag_t
{
/** enable text based I/O. */
QSE_PIO_TEXT = (1 << 0),
@ -201,7 +201,7 @@ QSE_DEFINE_COMMON_FUNCTIONS (pio)
* If @a env is #QSE_NULL, the environment of @a cmd inherits that of the
* calling process. If you want to pass an empty environment, you can pass
* an empty @a env object with no items inserted. If #QSE_PIO_MBSCMD is
* specified in @a oflags, @a cmd is treated as a multi-byte string whose
* specified in @a flags, @a cmd is treated as a multi-byte string whose
* character type is #qse_mchar_t.
* @return #qse_pio_t object on success, #QSE_NULL on failure
*/
@ -210,8 +210,8 @@ qse_pio_t* qse_pio_open (
qse_size_t ext, /**< extension size */
const qse_char_t* cmd, /**< command to execute */
qse_env_t* env, /**< environment */
int oflags /**< 0 or a number OR'ed of the
#qse_pio_oflag_t enumerators*/
int flags /**< 0 or a number OR'ed of the
#qse_pio_flag_t enumerators*/
);
/**
@ -232,9 +232,9 @@ int qse_pio_init (
qse_pio_t* pio, /**< pio object */
qse_mmgr_t* mmgr, /**< memory manager */
const qse_char_t* cmd, /**< command to execute */
qse_env_t* env, /**< environment */
int oflags /**< 0 or a number OR'ed of the
#qse_pio_oflag_t enumerators*/
qse_env_t* env, /**< environment */
int flags /**< 0 or a number OR'ed of the
#qse_pio_flag_t enumerators*/
);
/**

10
qse/lib/awk/awk.c
View File

@ -108,16 +108,6 @@ qse_awk_t* qse_awk_open (qse_mmgr_t* mmgr, qse_size_t xtn, qse_awk_prm_t* prm)
QSE_HTB_HASHER_DEFAULT
};
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
/* allocate the object */
awk = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_awk_t) + xtn);
if (awk == QSE_NULL) return QSE_NULL;

12
qse/lib/cmn/dll.c
View File

@ -51,16 +51,6 @@ qse_dll_t* qse_dll_open (qse_mmgr_t* mmgr, qse_size_t xtnsize)
{
qse_dll_t* dll;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
dll = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_dll_t) + xtnsize);
if (dll == QSE_NULL) return QSE_NULL;
@ -81,8 +71,6 @@ void qse_dll_close (qse_dll_t* dll)
int qse_dll_init (qse_dll_t* dll, qse_mmgr_t* mmgr)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
/* do not zero out the xtnsizeension */
QSE_MEMSET (dll, 0, QSE_SIZEOF(*dll));

10
qse/lib/cmn/env.c
View File

@ -38,16 +38,6 @@ qse_env_t* qse_env_open (qse_mmgr_t* mmgr, qse_size_t xtnsize, int fromcurenv)
{
qse_env_t* env;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
env = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_env_t) + xtnsize);
if (env == QSE_NULL) return QSE_NULL;

12
qse/lib/cmn/fio.c
View File

@ -55,16 +55,6 @@ qse_fio_t* qse_fio_open (
{
qse_fio_t* fio;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
fio = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_fio_t) + ext);
if (fio == QSE_NULL) return QSE_NULL;
@ -93,8 +83,6 @@ int qse_fio_init (
qse_char_t* temp_ptr;
qse_size_t temp_tries;
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (fio, 0, QSE_SIZEOF(*fio));
fio->mmgr = mmgr;

12
qse/lib/cmn/fma.c
View File

@ -29,16 +29,6 @@ qse_fma_t* qse_fma_open (
{
qse_fma_t* fma;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
fma = (qse_fma_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(*fma) + xtnsize);
if (fma == QSE_NULL) return QSE_NULL;
@ -61,8 +51,6 @@ int qse_fma_init (
qse_fma_t* fma, qse_mmgr_t* mmgr,
qse_size_t blksize, qse_size_t maxblks, qse_size_t maxcnks)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (fma, 0, QSE_SIZEOF(*fma));
fma->mmgr = mmgr;

10
qse/lib/cmn/fs.c
View File

@ -57,16 +57,6 @@ qse_fs_t* qse_fs_open (qse_mmgr_t* mmgr, qse_size_t xtnsize)
{
qse_fs_t* fs;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
fs = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(*fs) + xtnsize);
if (fs == QSE_NULL) return QSE_NULL;

12
qse/lib/cmn/htb.c
View File

@ -261,16 +261,6 @@ htb_t* qse_htb_open (
{
htb_t* htb;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
htb = (htb_t*) QSE_MMGR_ALLOC (mmgr, SIZEOF(htb_t) + xtnsize);
if (htb == QSE_NULL) return QSE_NULL;
@ -293,8 +283,6 @@ int qse_htb_init (
htb_t* htb, mmgr_t* mmgr, size_t capa,
int factor, int kscale, int vscale)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (capa > 0,
"The initial capacity should be greater than 0. Otherwise, it is adjusted to 1 in the release mode");
QSE_ASSERTX (factor >= 0 && factor <= 100,

12
qse/lib/cmn/lda.c
View File

@ -98,16 +98,6 @@ lda_t* qse_lda_open (mmgr_t* mmgr, size_t ext, size_t capa)
{
lda_t* lda;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
lda = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(lda_t) + ext);
if (lda == QSE_NULL) return QSE_NULL;
@ -128,8 +118,6 @@ void qse_lda_close (lda_t* lda)
int qse_lda_init (lda_t* lda, mmgr_t* mmgr, size_t capa)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (lda, 0, QSE_SIZEOF(*lda));
lda->mmgr = mmgr;

10
qse/lib/cmn/oht.c
View File

@ -48,16 +48,6 @@ qse_oht_t* qse_oht_open (
{
qse_oht_t* oht;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
oht = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_oht_t) + xtnsize);
if (oht == QSE_NULL) return QSE_NULL;

170
qse/lib/cmn/pio.c
View File

@ -45,24 +45,14 @@ static qse_ssize_t pio_output (qse_tio_cmd_t cmd, void* arg, void* buf, qse_size
qse_pio_t* qse_pio_open (
qse_mmgr_t* mmgr, qse_size_t ext,
const qse_char_t* cmd, qse_env_t* env, int oflags)
const qse_char_t* cmd, qse_env_t* env, int flags)
{
qse_pio_t* pio;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
pio = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_pio_t) + ext);
if (pio == QSE_NULL) return QSE_NULL;
if (qse_pio_init (pio, mmgr, cmd, env, oflags) <= -1)
if (qse_pio_init (pio, mmgr, cmd, env, flags) <= -1)
{
QSE_MMGR_FREE (mmgr, pio);
return QSE_NULL;
@ -79,7 +69,7 @@ void qse_pio_close (qse_pio_t* pio)
int qse_pio_init (
qse_pio_t* pio, qse_mmgr_t* mmgr, const qse_char_t* cmd,
qse_env_t* env, int oflags)
qse_env_t* env, int flags)
{
qse_pio_hnd_t handle[6] =
{
@ -127,8 +117,6 @@ int qse_pio_init (
qse_pio_pid_t pid;
#endif
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (pio, 0, QSE_SIZEOF(*pio));
pio->mmgr = mmgr;
@ -139,7 +127,7 @@ int qse_pio_init (
secattr.bInheritHandle = TRUE;
secattr.lpSecurityDescriptor = QSE_NULL;
if (oflags & QSE_PIO_WRITEIN)
if (flags & QSE_PIO_WRITEIN)
{
/* child reads, parent writes */
if (CreatePipe (
@ -153,7 +141,7 @@ int qse_pio_init (
minidx = 0; maxidx = 1;
}
if (oflags & QSE_PIO_READOUT)
if (flags & QSE_PIO_READOUT)
{
/* child writes, parent reads */
if (CreatePipe (
@ -168,7 +156,7 @@ int qse_pio_init (
maxidx = 3;
}
if (oflags & QSE_PIO_READERR)
if (flags & QSE_PIO_READERR)
{
/* child writes, parent reads */
if (CreatePipe (
@ -189,9 +177,9 @@ int qse_pio_init (
goto oops;
}
if ((oflags & QSE_PIO_INTONUL) ||
(oflags & QSE_PIO_OUTTONUL) ||
(oflags & QSE_PIO_ERRTONUL))
if ((flags & QSE_PIO_INTONUL) ||
(flags & QSE_PIO_OUTTONUL) ||
(flags & QSE_PIO_ERRTONUL))
{
windevnul = CreateFile(
QSE_T("NUL"), GENERIC_READ | GENERIC_WRITE,
@ -220,27 +208,27 @@ int qse_pio_init (
startup.hStdOutput == INVALID_HANDLE_VALUE ||
startup.hStdError == INVALID_HANDLE_VALUE) goto oops;
if (oflags & QSE_PIO_WRITEIN) startup.hStdInput = handle[0];
if (flags & QSE_PIO_WRITEIN) startup.hStdInput = handle[0];
if (oflags & QSE_PIO_READOUT)
if (flags & QSE_PIO_READOUT)
{
startup.hStdOutput = handle[3];
if (oflags & QSE_PIO_ERRTOOUT) startup.hStdError = handle[3];
if (flags & QSE_PIO_ERRTOOUT) startup.hStdError = handle[3];
}
if (oflags & QSE_PIO_READERR)
if (flags & QSE_PIO_READERR)
{
startup.hStdError = handle[5];
if (oflags & QSE_PIO_OUTTOERR) startup.hStdOutput = handle[5];
if (flags & QSE_PIO_OUTTOERR) startup.hStdOutput = handle[5];
}
if (oflags & QSE_PIO_INTONUL) startup.hStdInput = windevnul;
if (oflags & QSE_PIO_OUTTONUL) startup.hStdOutput = windevnul;
if (oflags & QSE_PIO_ERRTONUL) startup.hStdError = windevnul;
if (flags & QSE_PIO_INTONUL) startup.hStdInput = windevnul;
if (flags & QSE_PIO_OUTTONUL) startup.hStdOutput = windevnul;
if (flags & QSE_PIO_ERRTONUL) startup.hStdError = windevnul;
if (oflags & QSE_PIO_DROPIN) startup.hStdInput = INVALID_HANDLE_VALUE;
if (oflags & QSE_PIO_DROPOUT) startup.hStdOutput = INVALID_HANDLE_VALUE;
if (oflags & QSE_PIO_DROPERR) startup.hStdError = INVALID_HANDLE_VALUE;
if (flags & QSE_PIO_DROPIN) startup.hStdInput = INVALID_HANDLE_VALUE;
if (flags & QSE_PIO_DROPOUT) startup.hStdOutput = INVALID_HANDLE_VALUE;
if (flags & QSE_PIO_DROPERR) startup.hStdError = INVALID_HANDLE_VALUE;
startup.dwFlags |= STARTF_USESTDHANDLES;
@ -251,10 +239,10 @@ int qse_pio_init (
qse_char_t* dupcmd;
BOOL x;
if (oflags & QSE_PIO_SHELL)
if (flags & QSE_PIO_SHELL)
{
#if defined(QSE_CHAR_IS_WCHAR)
if (oflags & QSE_PIO_MBSCMD)
if (flags & QSE_PIO_MBSCMD)
{
const qse_mchar_t* x[3];
x[0] = QSE_MT("cmd.exe /c ");
@ -273,7 +261,7 @@ int qse_pio_init (
else
{
#if defined(QSE_CHAR_IS_WCHAR)
if (oflags & QSE_PIO_MBSCMD)
if (flags & QSE_PIO_MBSCMD)
{
dupcmd = qse_mbstowcsdup ((const qse_mchar_t*)cmd, mmgr);
}
@ -320,17 +308,17 @@ int qse_pio_init (
windevnul = INVALID_HANDLE_VALUE;
}
if (oflags & QSE_PIO_WRITEIN)
if (flags & QSE_PIO_WRITEIN)
{
CloseHandle (handle[0]);
handle[0] = QSE_PIO_HND_NIL;
}
if (oflags & QSE_PIO_READOUT)
if (flags & QSE_PIO_READOUT)
{
CloseHandle (handle[3]);
handle[3] = QSE_PIO_HND_NIL;
}
if (oflags & QSE_PIO_READERR)
if (flags & QSE_PIO_READERR)
{
CloseHandle (handle[5]);
handle[5] = QSE_PIO_HND_NIL;
@ -345,7 +333,7 @@ int qse_pio_init (
if (DosDupHandle(x,y) != NO_ERROR) goto oops; \
)
if (oflags & QSE_PIO_WRITEIN)
if (flags & QSE_PIO_WRITEIN)
{
/* child reads, parent writes */
if (DosCreatePipe (
@ -363,7 +351,7 @@ int qse_pio_init (
minidx = 0; maxidx = 1;
}
if (oflags & QSE_PIO_READOUT)
if (flags & QSE_PIO_READOUT)
{
/* child writes, parent reads */
if (DosCreatePipe (
@ -377,7 +365,7 @@ int qse_pio_init (
maxidx = 3;
}
if (oflags & QSE_PIO_READERR)
if (flags & QSE_PIO_READERR)
{
/* child writes, parent reads */
if (DosCreatePipe (
@ -397,9 +385,9 @@ int qse_pio_init (
goto oops;
}
if ((oflags & QSE_PIO_INTONUL) ||
(oflags & QSE_PIO_OUTTONUL) ||
(oflags & QSE_PIO_ERRTONUL))
if ((flags & QSE_PIO_INTONUL) ||
(flags & QSE_PIO_OUTTONUL) ||
(flags & QSE_PIO_ERRTONUL))
{
ULONG action_taken;
LONGLONG zero;
@ -444,7 +432,7 @@ int qse_pio_init (
DosSetFHState (old_out, OPEN_FLAGS_NOINHERIT);
DosSetFHState (old_err, OPEN_FLAGS_NOINHERIT);
if (oflags & QSE_PIO_WRITEIN)
if (flags & QSE_PIO_WRITEIN)
{
/* the child reads from handle[0] inherited and expects it to
* be stdin(0). so we duplicate handle[0] to stdin */
@ -455,27 +443,27 @@ int qse_pio_init (
DosClose (handle[0]); handle[0] = QSE_PIO_HND_NIL;
}
if (oflags & QSE_PIO_READOUT)
if (flags & QSE_PIO_READOUT)
{
/* the child writes to handle[3] inherited and expects it to
* be stdout(1). so we duplicate handle[3] to stdout. */
DOS_DUP_HANDLE (handle[3], &std_out);
if (oflags & QSE_PIO_ERRTOOUT) DOS_DUP_HANDLE (handle[3], &std_err);
if (flags & QSE_PIO_ERRTOOUT) DOS_DUP_HANDLE (handle[3], &std_err);
/* the parent reads from handle[2] but does not write to handle[3].
* so we close it */
DosClose (handle[3]); handle[3] = QSE_PIO_HND_NIL;
}
if (oflags & QSE_PIO_READERR)
if (flags & QSE_PIO_READERR)
{
DOS_DUP_HANDLE (handle[5], &std_err);
if (oflags & QSE_PIO_OUTTOERR) DOS_DUP_HANDLE (handle[5], &std_out);
if (flags & QSE_PIO_OUTTOERR) DOS_DUP_HANDLE (handle[5], &std_out);
DosClose (handle[5]); handle[5] = QSE_PIO_HND_NIL;
}
if (oflags & QSE_PIO_INTONUL) DOS_DUP_HANDLE (os2devnul, &std_in);
if (oflags & QSE_PIO_OUTTONUL) DOS_DUP_HANDLE (os2devnul, &std_out);
if (oflags & QSE_PIO_ERRTONUL) DOS_DUP_HANDLE (os2devnul, &std_err);
if (flags & QSE_PIO_INTONUL) DOS_DUP_HANDLE (os2devnul, &std_in);
if (flags & QSE_PIO_OUTTONUL) DOS_DUP_HANDLE (os2devnul, &std_out);
if (flags & QSE_PIO_ERRTONUL) DOS_DUP_HANDLE (os2devnul, &std_err);
if (os2devnul != QSE_PIO_HND_NIL)
{
@ -487,18 +475,18 @@ int qse_pio_init (
/* at this moment, stdin/out/err are already redirected to pipes
* if proper flags have been set. we close them selectively if
* dropping is requested */
if (oflags & QSE_PIO_DROPIN) DosClose (std_in);
if (oflags & QSE_PIO_DROPOUT) DosClose (std_out);
if (oflags & QSE_PIO_DROPERR) DosClose (std_err);
if (flags & QSE_PIO_DROPIN) DosClose (std_in);
if (flags & QSE_PIO_DROPOUT) DosClose (std_out);
if (flags & QSE_PIO_DROPERR) DosClose (std_err);
if (oflags & QSE_PIO_SHELL)
if (flags & QSE_PIO_SHELL)
{
qse_size_t n, mn;
#ifdef QSE_CHAR_IS_MCHAR
mn = qse_strlen(cmd);
#else
if (oflags & QSE_PIO_MBSCMD)
if (flags & QSE_PIO_MBSCMD)
{
mn = qse_mbslen((const qse_mchar_t*)cmd);
}
@ -524,7 +512,7 @@ int qse_pio_init (
#ifdef QSE_CHAR_IS_MCHAR
qse_mbscpy (&cmd_line[11], cmd);
#else
if (oflags & QSE_PIO_MBSCMD)
if (flags & QSE_PIO_MBSCMD)
{
qse_mbscpy (&cmd_line[11], (const qse_mchar_t*)cmd);
}
@ -552,7 +540,7 @@ int qse_pio_init (
goto oops;
}
#else
if (oflags & QSE_PIO_MBSCMD)
if (flags & QSE_PIO_MBSCMD)
{
mn = qse_mbslen((const qse_mchar_t*)cmd);
cmd_line = qse_mbsdup2 ((const qse_mchar_t*)cmd, QSE_MT(" "), pio->mmgr);
@ -632,20 +620,20 @@ int qse_pio_init (
#else
if (oflags & QSE_PIO_WRITEIN)
if (flags & QSE_PIO_WRITEIN)
{
if (QSE_PIPE(&handle[0]) <= -1) goto oops;
minidx = 0; maxidx = 1;
}
if (oflags & QSE_PIO_READOUT)
if (flags & QSE_PIO_READOUT)
{
if (QSE_PIPE(&handle[2]) <= -1) goto oops;
if (minidx == -1) minidx = 2;
maxidx = 3;
}
if (oflags & QSE_PIO_READERR)
if (flags & QSE_PIO_READERR)
{
if (QSE_PIPE(&handle[4]) <= -1) goto oops;
if (minidx == -1) minidx = 4;
@ -699,7 +687,7 @@ int qse_pio_init (
fd != handle[5]) QSE_CLOSE (fd);
}
if (oflags & QSE_PIO_WRITEIN)
if (flags & QSE_PIO_WRITEIN)
{
/* child should read */
QSE_CLOSE (handle[1]);
@ -709,14 +697,14 @@ int qse_pio_init (
handle[0] = QSE_PIO_HND_NIL;
}
if (oflags & QSE_PIO_READOUT)
if (flags & QSE_PIO_READOUT)
{
/* child should write */
QSE_CLOSE (handle[2]);
handle[2] = QSE_PIO_HND_NIL;
if (QSE_DUP2 (handle[3], 1) <= -1) goto child_oops;
if (oflags & QSE_PIO_ERRTOOUT)
if (flags & QSE_PIO_ERRTOOUT)
{
if (QSE_DUP2 (handle[3], 2) <= -1) goto child_oops;
}
@ -725,14 +713,14 @@ int qse_pio_init (
handle[3] = QSE_PIO_HND_NIL;
}
if (oflags & QSE_PIO_READERR)
if (flags & QSE_PIO_READERR)
{
/* child should write */
QSE_CLOSE (handle[4]);
handle[4] = QSE_PIO_HND_NIL;
if (QSE_DUP2 (handle[5], 2) <= -1) goto child_oops;
if (oflags & QSE_PIO_OUTTOERR)
if (flags & QSE_PIO_OUTTOERR)
{
if (QSE_DUP2 (handle[5], 1) <= -1) goto child_oops;
}
@ -741,9 +729,9 @@ int qse_pio_init (
handle[5] = QSE_PIO_HND_NIL;
}
if ((oflags & QSE_PIO_INTONUL) ||
(oflags & QSE_PIO_OUTTONUL) ||
(oflags & QSE_PIO_ERRTONUL))
if ((flags & QSE_PIO_INTONUL) ||
(flags & QSE_PIO_OUTTONUL) ||
(flags & QSE_PIO_ERRTONUL))
{
#ifdef O_LARGEFILE
devnull = QSE_OPEN (QSE_MT("/dev/null"), O_RDWR|O_LARGEFILE, 0);
@ -753,23 +741,23 @@ int qse_pio_init (
if (devnull <= -1) goto child_oops;
}
if ((oflags & QSE_PIO_INTONUL) &&
if ((flags & QSE_PIO_INTONUL) &&
QSE_DUP2(devnull,0) <= -1) goto child_oops;
if ((oflags & QSE_PIO_OUTTONUL) &&
if ((flags & QSE_PIO_OUTTONUL) &&
QSE_DUP2(devnull,1) <= -1) goto child_oops;
if ((oflags & QSE_PIO_ERRTONUL) &&
if ((flags & QSE_PIO_ERRTONUL) &&
QSE_DUP2(devnull,2) <= -1) goto child_oops;
if ((oflags & QSE_PIO_INTONUL) ||
(oflags & QSE_PIO_OUTTONUL) ||
(oflags & QSE_PIO_ERRTONUL)) QSE_CLOSE (devnull);
if ((flags & QSE_PIO_INTONUL) ||
(flags & QSE_PIO_OUTTONUL) ||
(flags & QSE_PIO_ERRTONUL)) QSE_CLOSE (devnull);
if (oflags & QSE_PIO_DROPIN) QSE_CLOSE(0);
if (oflags & QSE_PIO_DROPOUT) QSE_CLOSE(1);
if (oflags & QSE_PIO_DROPERR) QSE_CLOSE(2);
if (flags & QSE_PIO_DROPIN) QSE_CLOSE(0);
if (flags & QSE_PIO_DROPOUT) QSE_CLOSE(1);
if (flags & QSE_PIO_DROPERR) QSE_CLOSE(2);
#ifdef QSE_CHAR_IS_MCHAR
if (oflags & QSE_PIO_SHELL) mcmd = (qse_char_t*)cmd;
if (flags & QSE_PIO_SHELL) mcmd = (qse_char_t*)cmd;
else
{
mcmd = qse_strdup (cmd, pio->mmgr);
@ -784,12 +772,12 @@ int qse_pio_init (
}
}
#else
if (oflags & QSE_PIO_MBSCMD)
if (flags & QSE_PIO_MBSCMD)
{
/* the cmd is flagged to be of qse_mchar_t
* while the default character type is qse_wchar_t. */
if (oflags & QSE_PIO_SHELL) mcmd = (qse_mchar_t*)cmd;
if (flags & QSE_PIO_SHELL) mcmd = (qse_mchar_t*)cmd;
else
{
mcmd = qse_mbsdup ((const qse_mchar_t*)cmd, pio->mmgr);
@ -809,7 +797,7 @@ int qse_pio_init (
qse_size_t n, mn, wl;
qse_char_t* wcmd = QSE_NULL;
if (oflags & QSE_PIO_SHELL)
if (flags & QSE_PIO_SHELL)
{
if (qse_wcstombs (cmd, &wl, QSE_NULL, &mn) <= -1)
{
@ -859,7 +847,7 @@ int qse_pio_init (
if (mcmd == QSE_NULL) goto child_oops;
}
if (oflags & QSE_PIO_SHELL)
if (flags & QSE_PIO_SHELL)
{
/* qse_wcstombs() should succeed as
* it was successful above */
@ -878,7 +866,7 @@ int qse_pio_init (
}
#endif
if (oflags & QSE_PIO_SHELL)
if (flags & QSE_PIO_SHELL)
{
const qse_mchar_t* argv[4];
extern char** environ;
@ -924,7 +912,7 @@ int qse_pio_init (
/* parent */
pio->child = pid;
if (oflags & QSE_PIO_WRITEIN)
if (flags & QSE_PIO_WRITEIN)
{
/*
* 012345
@ -936,7 +924,7 @@ int qse_pio_init (
handle[0] = QSE_PIO_HND_NIL;
}
if (oflags & QSE_PIO_READOUT)
if (flags & QSE_PIO_READOUT)
{
/*
* 012345
@ -948,7 +936,7 @@ int qse_pio_init (
handle[3] = QSE_PIO_HND_NIL;
}
if (oflags & QSE_PIO_READERR)
if (flags & QSE_PIO_READERR)
{
/*
* 012345
@ -972,12 +960,12 @@ int qse_pio_init (
pio->pin[QSE_PIO_OUT].handle = handle[2];
pio->pin[QSE_PIO_ERR].handle = handle[4];
if (oflags & QSE_PIO_TEXT)
if (flags & QSE_PIO_TEXT)
{
int topt = 0;
if (oflags & QSE_PIO_IGNOREMBWCERR) topt |= QSE_TIO_IGNOREMBWCERR;
if (oflags & QSE_PIO_NOAUTOFLUSH) topt |= QSE_TIO_NOAUTOFLUSH;
if (flags & QSE_PIO_IGNOREMBWCERR) topt |= QSE_TIO_IGNOREMBWCERR;
if (flags & QSE_PIO_NOAUTOFLUSH) topt |= QSE_TIO_NOAUTOFLUSH;
for (i = 0; i < QSE_COUNTOF(tio); i++)
{

2
qse/lib/cmn/pma.c
View File

@ -73,8 +73,6 @@ void qse_pma_close (qse_pma_t* pma)
int qse_pma_init (qse_pma_t* pma, qse_mmgr_t* mmgr)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (pma, 0, QSE_SIZEOF(*pma));
pma->mmgr = mmgr;

12
qse/lib/cmn/rbt.c
View File

@ -201,16 +201,6 @@ rbt_t* qse_rbt_open (mmgr_t* mmgr, size_t xtnsize, int kscale, int vscale)
{
rbt_t* rbt;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
rbt = (rbt_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(rbt_t) + xtnsize);
if (rbt == QSE_NULL) return QSE_NULL;
@ -231,8 +221,6 @@ void qse_rbt_close (rbt_t* rbt)
int qse_rbt_init (rbt_t* rbt, mmgr_t* mmgr, int kscale, int vscale)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
/* do not zero out the extension */
QSE_MEMSET (rbt, 0, SIZEOF(*rbt));
rbt->mmgr = mmgr;

12
qse/lib/cmn/rex.c
View File

@ -120,8 +120,6 @@ QSE_IMPLEMENT_COMMON_FUNCTIONS (rex)
int qse_rex_init (qse_rex_t* rex, qse_mmgr_t* mmgr, qse_rex_node_t* code)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (rex, 0, QSE_SIZEOF(*rex));
rex->mmgr = mmgr;
@ -139,16 +137,6 @@ qse_rex_t* qse_rex_open (qse_mmgr_t* mmgr, qse_size_t xtn, qse_rex_node_t* code)
{
qse_rex_t* rex;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
rex = (qse_rex_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_rex_t) + xtn);
if (rex == QSE_NULL) return QSE_NULL;

12
qse/lib/cmn/sio.c
View File

@ -33,16 +33,6 @@ qse_sio_t* qse_sio_open (
{
qse_sio_t* sio;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
sio = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_sio_t) + xtnsize);
if (sio == QSE_NULL) return QSE_NULL;
@ -88,8 +78,6 @@ int qse_sio_init (
int mode;
int topt = 0;
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (sio, 0, QSE_SIZEOF(*sio));
sio->mmgr = mmgr;

12
qse/lib/cmn/sll.c
View File

@ -104,16 +104,6 @@ sll_t* qse_sll_open (mmgr_t* mmgr, size_t ext)
{
sll_t* sll;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
sll = QSE_MMGR_ALLOC (mmgr, SIZEOF(sll_t) + ext);
if (sll == QSE_NULL) return QSE_NULL;
@ -134,8 +124,6 @@ void qse_sll_close (sll_t* sll)
int qse_sll_init (sll_t* sll, mmgr_t* mmgr)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
/* do not zero out the extension */
QSE_MEMSET (sll, 0, SIZEOF(*sll));

12
qse/lib/cmn/str-dynm.c
View File

@ -27,16 +27,6 @@ qse_mbs_t* qse_mbs_open (qse_mmgr_t* mmgr, qse_size_t ext, qse_size_t capa)
{
qse_mbs_t* str;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
str = (qse_mbs_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_mbs_t) + ext);
if (str == QSE_NULL) return QSE_NULL;
@ -57,8 +47,6 @@ void qse_mbs_close (qse_mbs_t* str)
int qse_mbs_init (qse_mbs_t* str, qse_mmgr_t* mmgr, qse_size_t capa)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (str, 0, QSE_SIZEOF(qse_mbs_t));
str->mmgr = mmgr;

12
qse/lib/cmn/str-dynw.c
View File

@ -27,16 +27,6 @@ qse_wcs_t* qse_wcs_open (qse_mmgr_t* mmgr, qse_size_t ext, qse_size_t capa)
{
qse_wcs_t* str;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
str = (qse_wcs_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_wcs_t) + ext);
if (str == QSE_NULL) return QSE_NULL;
@ -57,8 +47,6 @@ void qse_wcs_close (qse_wcs_t* str)
int qse_wcs_init (qse_wcs_t* str, qse_mmgr_t* mmgr, qse_size_t capa)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (str, 0, QSE_SIZEOF(qse_wcs_t));
str->mmgr = mmgr;

12
qse/lib/cmn/tio.c
View File

@ -30,16 +30,6 @@ qse_tio_t* qse_tio_open (qse_mmgr_t* mmgr, qse_size_t xtnsize, int flags)
{
qse_tio_t* tio;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
tio = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_tio_t) + xtnsize);
if (tio == QSE_NULL) return QSE_NULL;
@ -61,8 +51,6 @@ int qse_tio_close (qse_tio_t* tio)
int qse_tio_init (qse_tio_t* tio, qse_mmgr_t* mmgr, int flags)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (tio, 0, QSE_SIZEOF(*tio));
tio->mmgr = mmgr;

12
qse/lib/cmn/tre.c
View File

@ -28,16 +28,6 @@ qse_tre_t* qse_tre_open (qse_mmgr_t* mmgr, qse_size_t xtnsize)
{
qse_tre_t* tre;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
tre = (qse_tre_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_tre_t) + xtnsize);
if (tre == QSE_NULL) return QSE_NULL;
@ -58,8 +48,6 @@ void qse_tre_close (qse_tre_t* tre)
int qse_tre_init (qse_tre_t* tre, qse_mmgr_t* mmgr)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (tre, 0, QSE_SIZEOF(*tre));
tre->mmgr = mmgr;

28
qse/lib/cmn/utf8.c
View File

@ -194,20 +194,26 @@ qse_size_t qse_utf8len (const qse_mchar_t* utf8, qse_size_t len)
{
int i;
if (len < cur->length)
/* if len is less that cur->length, the incomplete-seqeunce
* error is naturally indicated. so validate the string
* only if len is as large as cur->length. */
if (len >= cur->length)
{
/* the input is not as large as
* the expected number of bytes */
return len + 1; /* incomplete sequence */
for (i = 1; i < cur->length; i++)
{
/* in utf8, trailing bytes are all
* set with 0x80. if not, invalid */
if (!(utf8[i] & 0x80)) return 0;
}
}
for (i = 1; i < cur->length; i++)
{
/* in utf8, trailing bytes are all
* set with 0x80. if not, invalid */
if (!(utf8[i] & 0x80)) return 0;
}
return (qse_size_t)cur->length;
/* this return value can indicate both
* the correct length (len >= cur->length)
* and
* the incomplete seqeunce error (len < cur->length).
*/
return (qse_size_t)cur->length;
}
cur++;
}

12
qse/lib/cmn/xma.c
View File

@ -109,16 +109,6 @@ qse_xma_t* qse_xma_open (
{
qse_xma_t* xma;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
xma = (qse_xma_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(*xma) + xtnsize);
if (xma == QSE_NULL) return QSE_NULL;
@ -142,8 +132,6 @@ int qse_xma_init (qse_xma_t* xma, qse_mmgr_t* mmgr, qse_size_t zonesize)
qse_xma_blk_t* free;
qse_size_t xfi;
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
/* round 'zonesize' to be the multiples of ALIGN */
zonesize = ((zonesize + ALIGN - 1) / ALIGN) * ALIGN;

12
qse/lib/cut/cut.c
View File

@ -79,16 +79,6 @@ qse_cut_t* qse_cut_open (qse_mmgr_t* mmgr, qse_size_t xtn)
{
qse_cut_t* cut;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
cut = (qse_cut_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_cut_t) + xtn);
if (cut == QSE_NULL) return QSE_NULL;
@ -109,8 +99,6 @@ void qse_cut_close (qse_cut_t* cut)
static int qse_cut_init (qse_cut_t* cut, qse_mmgr_t* mmgr)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (cut, 0, QSE_SIZEOF(*cut));
cut->mmgr = mmgr;

10
qse/lib/fs/dir.c
View File

@ -106,16 +106,6 @@ qse_dir_t* qse_dir_open (qse_mmgr_t* mmgr, qse_size_t xtnsize)
{
qse_dir_t* dir;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
dir = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(*dir) + xtnsize);
if (dir == QSE_NULL) return QSE_NULL;

12
qse/lib/net/htrd.c
View File

@ -133,16 +133,6 @@ qse_htrd_t* qse_htrd_open (qse_mmgr_t* mmgr, qse_size_t xtnsize)
{
qse_htrd_t* htrd;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
htrd = (qse_htrd_t*) QSE_MMGR_ALLOC (
mmgr, QSE_SIZEOF(qse_htrd_t) + xtnsize
);
@ -165,8 +155,6 @@ void qse_htrd_close (qse_htrd_t* htrd)
int qse_htrd_init (qse_htrd_t* htrd, qse_mmgr_t* mmgr)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (htrd, 0, QSE_SIZEOF(*htrd));
htrd->mmgr = mmgr;
htrd->option = QSE_HTRD_REQUEST | QSE_HTRD_RESPONSE;

10
qse/lib/net/httpd.c
View File

@ -62,16 +62,6 @@ qse_httpd_t* qse_httpd_open (qse_mmgr_t* mmgr, qse_size_t xtnsize)
{
qse_httpd_t* httpd;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
httpd = (qse_httpd_t*) QSE_MMGR_ALLOC (
mmgr, QSE_SIZEOF(*httpd) + xtnsize
);

12
qse/lib/sed/sed.c
View File

@ -58,16 +58,6 @@ qse_sed_t* qse_sed_open (qse_mmgr_t* mmgr, qse_size_t xtnsize)
{
qse_sed_t* sed;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
sed = (qse_sed_t*) QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(qse_sed_t) + xtnsize);
if (sed == QSE_NULL) return QSE_NULL;
@ -88,8 +78,6 @@ void qse_sed_close (qse_sed_t* sed)
int qse_sed_init (qse_sed_t* sed, qse_mmgr_t* mmgr)
{
if (mmgr == QSE_NULL) mmgr = QSE_MMGR_GETDFL();
QSE_MEMSET (sed, 0, QSE_SIZEOF(*sed));
sed->mmgr = mmgr;
sed->errstr = qse_sed_dflerrstr;

8
qse/lib/stx/stx.c
View File

@ -28,14 +28,6 @@ qse_stx_t* qse_stx_open (
{
qse_stx_t* stx;
if (mmgr == QSE_NULL)
{
mmgr = QSE_MMGR_GETDFL();
QSE_ASSERTX (mmgr != QSE_NULL,
"Set the memory manager with QSE_MMGR_SETDFL()");
if (mmgr == QSE_NULL) return QSE_NULL;
}
stx = (qse_stx_t*) QSE_MMGR_ALLOC (
mmgr, QSE_SIZEOF(qse_stx_t) + xtnsize
);

7
qse/samples/cmn/env.c
View File

@ -1,4 +1,5 @@
#include <qse/cmn/env.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/str.h>
#include <qse/cmn/stdio.h>
@ -53,7 +54,7 @@ static int test1 (void)
{
qse_env_t* env;
env = qse_env_open (QSE_NULL, 0, 0);
env = qse_env_open (QSE_MMGR_GETDFL(), 0, 0);
qse_env_clear (env);
qse_env_insert (env, QSE_T("alice"), QSE_T("wonderland"));
@ -82,7 +83,7 @@ static int test2 (void)
{
qse_env_t* env;
env = qse_env_open (QSE_NULL, 0, 1);
env = qse_env_open (QSE_MMGR_GETDFL(), 0, 1);
qse_printf (QSE_T("DELETING HOME => %s\n"),
(qse_env_delete (env, QSE_T("HOME")) == 0?
@ -103,7 +104,7 @@ static int test3 (void)
{
qse_env_t* env;
env = qse_env_open (QSE_NULL, 0, 0);
env = qse_env_open (QSE_MMGR_GETDFL(), 0, 0);
qse_printf (QSE_T("inserting PATH => %d\n"), qse_env_insertsys (env, QSE_T("PATH")));
qse_printf (QSE_T("inserting HOME => %d\n"), qse_env_insertsysm (env, QSE_MT("HOME")));

7
qse/samples/cmn/fio01.c
View File

@ -1,4 +1,5 @@
#include <qse/cmn/fio.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/stdio.h>
#include <locale.h>
@ -19,7 +20,7 @@ static int test1 (void)
char buf[1000];
fio = qse_fio_open (
QSE_NULL,
QSE_MMGR_GETDFL(),
0,
QSE_T("fio1.txt"),
QSE_FIO_READ|QSE_FIO_WRITE|QSE_FIO_CREATE|QSE_FIO_TRUNCATE,
@ -104,7 +105,7 @@ static int test2 (void)
int i;
fio = qse_fio_open (
QSE_NULL,
QSE_MMGR_GETDFL(),
0,
QSE_T("fio2.txt"),
QSE_FIO_CREATE | QSE_FIO_TRUNCATE | QSE_FIO_APPEND,
@ -220,7 +221,7 @@ static int test3 (void)
qse_char_t buf[1000];
fio = qse_fio_open (
QSE_NULL,
QSE_MMGR_GETDFL(),
0,
QSE_T("fio3.txt"),

3
qse/samples/cmn/fio02.c
View File

@ -1,4 +1,5 @@
#include <qse/cmn/fio.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/stdio.h>
#define R(f) \
@ -18,7 +19,7 @@ static int test1 (void)
qse_char_t file[] = QSE_T("fio02-XXXX");
fio = qse_fio_open (
QSE_NULL,
QSE_MMGR_GETDFL(),
0,
file,
QSE_FIO_CREATE | QSE_FIO_EXCLUSIVE | QSE_FIO_TEMPORARY | QSE_FIO_READ | QSE_FIO_WRITE,

4
qse/samples/cmn/fs01.c
View File

@ -1,5 +1,5 @@
#include <qse/cmn/fs.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/stdio.h>
#include <qse/cmn/main.h>
@ -52,7 +52,7 @@ int fs_main (int argc, qse_char_t* argv[])
return -1;
}
fs = qse_fs_open (QSE_NULL, 0);
fs = qse_fs_open (QSE_MMGR_GETDFL(), 0);
if (fs == QSE_NULL)
{
qse_fprintf (QSE_STDERR, QSE_T("Error: Cannot open directory\n"), argv[1]);

4
qse/samples/cmn/oht.c
View File

@ -47,7 +47,7 @@ static int test1 ()
long x;
qse_oht_t* oht;
oht = qse_oht_open (QSE_NULL, 0, QSE_SIZEOF(x), 10, 5);
oht = qse_oht_open (QSE_MMGR_GETDFL(), 0, QSE_SIZEOF(x), 10, 5);
if (oht == QSE_NULL)
{
qse_printf (QSE_T("failed to open a table\n"));
@ -84,7 +84,7 @@ static int test2 ()
item_t x;
qse_oht_t* oht;
oht = qse_oht_open (QSE_NULL, 0, QSE_SIZEOF(x), 10, 10);
oht = qse_oht_open (QSE_MMGR_GETDFL(), 0, QSE_SIZEOF(x), 10, 10);
if (oht == QSE_NULL)
{
qse_printf (QSE_T("failed to open a table\n"));

9
qse/samples/cmn/pio.c
View File

@ -1,4 +1,5 @@
#include <qse/cmn/pio.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/env.h>
#include <qse/cmn/stdio.h>
@ -28,7 +29,7 @@ static int pio1 (const qse_char_t* cmd, qse_env_t* env, int oflags, qse_pio_hid_
int x;
pio = qse_pio_open (
QSE_NULL,
QSE_MMGR_GETDFL(),
0,
cmd,
env,
@ -88,7 +89,7 @@ static int pio2 (const qse_char_t* cmd, qse_env_t* env, int oflags, qse_pio_hid_
int x;
pio = qse_pio_open (
QSE_NULL,
QSE_MMGR_GETDFL(),
0,
cmd,
env,
@ -285,7 +286,7 @@ static int test11 (void)
qse_env_t* env;
int n;
env = qse_env_open (QSE_NULL, 0, 0);
env = qse_env_open (QSE_MMGR_GETDFL(), 0, 0);
if (env == QSE_NULL) return -1;
qse_env_insertsys (env, QSE_T("PATH"));
@ -312,7 +313,7 @@ static int test12 (void)
int x;
pio = qse_pio_open (
QSE_NULL,
QSE_MMGR_GETDFL(),
0,
#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
QSE_T("tree.com"),

3
qse/samples/cmn/rex01.c
View File

@ -1,4 +1,5 @@
#include <qse/cmn/rex.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/str.h>
#include <qse/cmn/main.h>
#include <qse/cmn/path.h>
@ -19,7 +20,7 @@ static int rex_main (int argc, qse_char_t* argv[])
return -1;
}
rex = qse_rex_open (QSE_NULL, 0, QSE_NULL);
rex = qse_rex_open (QSE_MMGR_GETDFL(), 0, QSE_NULL);
if (rex == QSE_NULL)
{
qse_printf (QSE_T("ERROR: cannot open rex\n"));

3
qse/samples/cmn/rex02.cpp
View File

@ -1,4 +1,5 @@
#include <qse/cmn/rex.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/str.h>
#include <qse/cmn/stdio.h>
@ -197,7 +198,7 @@ void MyFrame::OnComp(wxCommandEvent& WXUNUSED(event))
{
if (rex == NULL)
{
rex = qse_rex_open (QSE_NULL, 0, QSE_NULL);
rex = qse_rex_open (QSE_MMGR_GETDFL(), 0, QSE_NULL);
if (rex == NULL)
{
wxMessageBox(_T("Cannot open rex"),

13
qse/samples/cmn/sio01.c
View File

@ -1,4 +1,5 @@
#include <qse/cmn/sio.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/fmt.h>
#include <qse/cmn/stdio.h>
#include <locale.h>
@ -51,7 +52,7 @@ static int test1 (void)
x[0] = unistr;
x[2] = unistr;
x[5] = unistr;
sio = qse_sio_open (QSE_NULL, 0, QSE_T("sio.txt"),
sio = qse_sio_open (QSE_MMGR_GETDFL(), 0, QSE_T("sio.txt"),
QSE_SIO_WRITE | QSE_SIO_CREATE | QSE_SIO_TRUNCATE);
if (sio == QSE_NULL)
@ -81,8 +82,8 @@ static int test2 (void)
qse_wchar_t buf[20];
qse_sio_t* in, * out;
in = qse_sio_openstd (QSE_NULL, 0, QSE_SIO_STDIN, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR);
out = qse_sio_openstd (QSE_NULL, 0, QSE_SIO_STDOUT, QSE_SIO_WRITE | QSE_SIO_IGNOREMBWCERR);
in = qse_sio_openstd (QSE_MMGR_GETDFL(), 0, QSE_SIO_STDIN, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR);
out = qse_sio_openstd (QSE_MMGR_GETDFL(), 0, QSE_SIO_STDOUT, QSE_SIO_WRITE | QSE_SIO_IGNOREMBWCERR);
qse_sio_putstr (out, QSE_T("Type something here:\n"));
while (1)
@ -113,8 +114,8 @@ static int test3 (void)
qse_mchar_t buf[20];
qse_sio_t* in, * out;
in = qse_sio_openstd (QSE_NULL, 0, QSE_SIO_STDIN, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR);
out = qse_sio_openstd (QSE_NULL, 0, QSE_SIO_STDOUT, QSE_SIO_WRITE | QSE_SIO_IGNOREMBWCERR);
in = qse_sio_openstd (QSE_MMGR_GETDFL(), 0, QSE_SIO_STDIN, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR);
out = qse_sio_openstd (QSE_MMGR_GETDFL(), 0, QSE_SIO_STDOUT, QSE_SIO_WRITE | QSE_SIO_IGNOREMBWCERR);
qse_sio_putstr (out, QSE_T("Type something here:\n"));
while (1)
@ -151,7 +152,7 @@ int main ()
setlocale (LC_ALL, "");
g_out = qse_sio_openstd (QSE_NULL, 0, QSE_SIO_STDOUT, QSE_SIO_WRITE | QSE_SIO_IGNOREMBWCERR);
g_out = qse_sio_openstd (QSE_MMGR_GETDFL(), 0, QSE_SIO_STDOUT, QSE_SIO_WRITE | QSE_SIO_IGNOREMBWCERR);
R (test1);
R (test2);

9
qse/samples/cmn/sio02.c
View File

@ -1,5 +1,6 @@
#include <qse/cmn/stdio.h>
#include <qse/cmn/sio.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/stdio.h>
#include <locale.h>
@ -55,7 +56,7 @@ static int test1 (void)
x[1] = unistr;
x[2] = unistr2;
sio = qse_sio_openstd (QSE_NULL, 0, QSE_SIO_STDOUT, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR | QSE_SIO_NOAUTOFLUSH);
sio = qse_sio_openstd (QSE_MMGR_GETDFL(), 0, QSE_SIO_STDOUT, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR | QSE_SIO_NOAUTOFLUSH);
if (sio == QSE_NULL) return -1;
for (i = 0; i < QSE_COUNTOF(x); i++)
@ -83,7 +84,7 @@ static int test2 (void)
int i;
qse_sio_t* sio;
sio = qse_sio_openstd (QSE_NULL, 0, QSE_SIO_STDOUT, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR | QSE_SIO_NOAUTOFLUSH);
sio = qse_sio_openstd (QSE_MMGR_GETDFL(), 0, QSE_SIO_STDOUT, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR | QSE_SIO_NOAUTOFLUSH);
if (sio == QSE_NULL) return -1;
for (i = 0; i < QSE_COUNTOF(x); i++)
@ -111,7 +112,7 @@ static int test3 (void)
int i;
qse_sio_t* sio;
sio = qse_sio_openstd (QSE_NULL, 0, QSE_SIO_STDOUT, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR | QSE_SIO_NOAUTOFLUSH);
sio = qse_sio_openstd (QSE_MMGR_GETDFL(), 0, QSE_SIO_STDOUT, QSE_SIO_READ | QSE_SIO_IGNOREMBWCERR | QSE_SIO_NOAUTOFLUSH);
if (sio == QSE_NULL) return -1;
for (i = 0; i < QSE_COUNTOF(x); i++)

2
qse/samples/cmn/tre01.c
View File

@ -18,7 +18,7 @@ static int test_main (int argc, qse_char_t* argv[], qse_char_t* envp[])
return -1;
}
qse_tre_init (&tre, QSE_NULL);
qse_tre_init (&tre, QSE_MMGR_GETDFL());
if (qse_tre_comp (&tre, argv[1], &nsubmat, 0 /*QSE_TRE_EXTENDED*/) <= -1)
{

11
qse/samples/cmn/xma.c
View File

@ -1,4 +1,5 @@
#include <qse/cmn/xma.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/stdio.h>
#define R(f) \
@ -11,7 +12,7 @@ static int test1 ()
{
void* ptr[100];
qse_xma_t* xma = qse_xma_open (QSE_NULL, 0, 100000L);
qse_xma_t* xma = qse_xma_open (QSE_MMGR_GETDFL(), 0, 100000L);
if (xma == QSE_NULL)
{
qse_printf (QSE_T("cannot open xma\n"));
@ -40,7 +41,7 @@ static int test2 ()
{
void* ptr[100];
qse_xma_t* xma = qse_xma_open (QSE_NULL, 0, 100000L);
qse_xma_t* xma = qse_xma_open (QSE_MMGR_GETDFL(), 0, 100000L);
if (xma == QSE_NULL)
{
qse_printf (QSE_T("cannot open xma\n"));
@ -67,7 +68,7 @@ static int test3 ()
{
void* ptr[100];
qse_xma_t* xma = qse_xma_open (QSE_NULL, 0, 100000L);
qse_xma_t* xma = qse_xma_open (QSE_MMGR_GETDFL(), 0, 100000L);
if (xma == QSE_NULL)
{
qse_printf (QSE_T("cannot open xma\n"));
@ -97,7 +98,7 @@ static int test4 ()
int i;
void* ptr[100];
qse_xma_t* xma = qse_xma_open (QSE_NULL, 0, 2000000L);
qse_xma_t* xma = qse_xma_open (QSE_MMGR_GETDFL(), 0, 2000000L);
if (xma == QSE_NULL)
{
qse_printf (QSE_T("cannot open xma\n"));
@ -158,7 +159,7 @@ static int test5 ()
qse_xma_t* xma1, * xma2, * xma3;
xma1 = qse_xma_open (QSE_NULL, 0, 2000000L);
xma1 = qse_xma_open (QSE_MMGR_GETDFL(), 0, 2000000L);
if (xma1 == QSE_NULL)
{
qse_printf (QSE_T("cannot open outer xma\n"));

2
qse/samples/fs/dir01.c
View File

@ -52,7 +52,7 @@ int dir_main (int argc, qse_char_t* argv[])
return -1;
}
dir = qse_dir_open (QSE_NULL, 0);
dir = qse_dir_open (QSE_MMGR_GETDFL(), 0);
if (dir == QSE_NULL)
{
qse_fprintf (QSE_STDERR, QSE_T("Error: Cannot open directory\n"), argv[1]);

3
qse/samples/net/http01.c
View File

@ -3,6 +3,7 @@
#include <qse/cmn/stdio.h>
#include <qse/cmn/main.h>
#include <qse/cmn/str.h>
#include <qse/cmn/mem.h>
#include <signal.h>
#define MAX_SENDFILE_SIZE 4096
@ -168,7 +169,7 @@ int httpd_main (int argc, qse_char_t* argv[])
}
httpd = qse_httpd_open (QSE_NULL, QSE_SIZEOF(httpd_xtn_t));
httpd = qse_httpd_open (QSE_MMGR_GETDFL(), QSE_SIZEOF(httpd_xtn_t));
if (httpd == QSE_NULL)
{
qse_fprintf (QSE_STDERR, QSE_T("Cannot open httpd\n"));