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

added qse_dir_t.

Browse Source 
added qse_mux_t.
added dir::xxx() for awk
This commit is contained in:
hyung-hwan
2012-11-09 17:31:33 +00:00
parent a3ee069804
commit 7e509d4daa
40 changed files with 3448 additions and 1167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
qse/lib/cmn/Makefile.am
View File

@ -28,6 +28,7 @@ libqsecmn_la_SOURCES = \
alg-sort.c \
assert.c \
chr.c \
dir.c \
dll.c \
env.c \
gdl.c \
@ -46,6 +47,7 @@ libqsecmn_la_SOURCES = \
mbwc.c \
mbwc-str.c \
mem.c \
mux.c \
nwad.c \
nwif.c \
nwio.c \

24
qse/lib/cmn/Makefile.in
View File

@ -88,11 +88,11 @@ LTLIBRARIES = $(lib_LTLIBRARIES)
am__DEPENDENCIES_1 =
libqsecmn_la_DEPENDENCIES = $(am__DEPENDENCIES_1)
am__libqsecmn_la_SOURCES_DIST = alg-base64.c alg-rand.c alg-search.c \
alg-sort.c assert.c chr.c dll.c env.c gdl.c htb.c fio.c fma.c \
fmt.c fs.c fs-err.c fs-move.c glob.c hton.c ipad.c lda.c \
main.c mbwc.c mbwc-str.c mem.c nwad.c nwif.c nwio.c oht.c \
opt.c path-basename.c path-canon.c pio.c pma.c rbt.c rex.c \
sio.c sll.c slmb.c stdio.c str-beg.c str-cat.c str-chr.c \
alg-sort.c assert.c chr.c dir.c dll.c env.c gdl.c htb.c fio.c \
fma.c fmt.c fs.c fs-err.c fs-move.c glob.c hton.c ipad.c lda.c \
main.c mbwc.c mbwc-str.c mem.c mux.c nwad.c nwif.c nwio.c \
oht.c opt.c path-basename.c path-canon.c pio.c pma.c rbt.c \
rex.c sio.c sll.c slmb.c stdio.c str-beg.c str-cat.c str-chr.c \
str-cnv.c str-cmp.c str-cpy.c str-del.c str-dup.c str-dynm.c \
str-dynw.c str-end.c str-excl.c str-fcpy.c str-fnmat.c \
str-incl.c str-len.c str-pac.c str-pbrk.c str-put.c str-rev.c \
@ -103,10 +103,10 @@ am__libqsecmn_la_SOURCES_DIST = alg-base64.c alg-rand.c alg-search.c \
xma.c cp949.c cp950.c
@INCLUDE_MORE_CMGRS_TRUE@am__objects_1 = cp949.lo cp950.lo
am_libqsecmn_la_OBJECTS = alg-base64.lo alg-rand.lo alg-search.lo \
alg-sort.lo assert.lo chr.lo dll.lo env.lo gdl.lo htb.lo \
fio.lo fma.lo fmt.lo fs.lo fs-err.lo fs-move.lo glob.lo \
alg-sort.lo assert.lo chr.lo dir.lo dll.lo env.lo gdl.lo \
htb.lo fio.lo fma.lo fmt.lo fs.lo fs-err.lo fs-move.lo glob.lo \
hton.lo ipad.lo lda.lo main.lo mbwc.lo mbwc-str.lo mem.lo \
nwad.lo nwif.lo nwio.lo oht.lo opt.lo path-basename.lo \
mux.lo nwad.lo nwif.lo nwio.lo oht.lo opt.lo path-basename.lo \
path-canon.lo pio.lo pma.lo rbt.lo rex.lo sio.lo sll.lo \
slmb.lo stdio.lo str-beg.lo str-cat.lo str-chr.lo str-cnv.lo \
str-cmp.lo str-cpy.lo str-del.lo str-dup.lo str-dynm.lo \
@ -350,9 +350,9 @@ noinst_HEADERS = \
tre-stack.h
libqsecmn_la_SOURCES = alg-base64.c alg-rand.c alg-search.c alg-sort.c \
assert.c chr.c dll.c env.c gdl.c htb.c fio.c fma.c fmt.c fs.c \
fs-err.c fs-move.c glob.c hton.c ipad.c lda.c main.c mbwc.c \
mbwc-str.c mem.c nwad.c nwif.c nwio.c oht.c opt.c \
assert.c chr.c dir.c dll.c env.c gdl.c htb.c fio.c fma.c fmt.c \
fs.c fs-err.c fs-move.c glob.c hton.c ipad.c lda.c main.c \
mbwc.c mbwc-str.c mem.c mux.c nwad.c nwif.c nwio.c oht.c opt.c \
path-basename.c path-canon.c pio.c pma.c rbt.c rex.c sio.c \
sll.c slmb.c stdio.c str-beg.c str-cat.c str-chr.c str-cnv.c \
str-cmp.c str-cpy.c str-del.c str-dup.c str-dynm.c str-dynw.c \
@ -455,6 +455,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/chr.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cp949.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cp950.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dir.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dll.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/env.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fio.Plo@am__quote@
@ -473,6 +474,7 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mbwc-str.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mbwc.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mem.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mux.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nwad.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nwif.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nwio.Plo@am__quote@

536
qse/lib/cmn/dir.c Normal file
View File

@ -0,0 +1,536 @@
/*
* $Id$
*
Copyright 2006-2012 Chung, Hyung-Hwan.
This file is part of QSE.
QSE is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
QSE is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with QSE. If not, see <http://www.gnu.org/licenses/>.
*/
#include <qse/cmn/dir.h>
#include <qse/cmn/str.h>
#include <qse/cmn/mbwc.h>
#include <qse/cmn/path.h>
#include "mem.h"
#if defined(_WIN32)
# include <windows.h>
#elif defined(__OS2__)
# define INCL_DOSFILEMGR
# define INCL_ERRORS
# include <os2.h>
#elif defined(__DOS__)
# include <dos.h>
# include <errno.h>
#else
# include "syscall.h"
#endif
struct qse_dir_t
{
qse_mmgr_t* mmgr;
int flags;
qse_str_t tbuf;
qse_mbs_t mbuf;
#if defined(_WIN32)
HANDLE h;
WIN32_FIND_DATA wfd;
int done;
#elif defined(__OS2__)
HDIR h;
FILEFINDBUF3L ffb;
ULONG count;
int opened;
#elif defined(__DOS__)
struct find_t f;
int done;
int opened;
#else
DIR* dp;
#endif
};
int qse_dir_init (qse_dir_t* dir, qse_mmgr_t* mmgr, const qse_char_t* path, int flags);
void qse_dir_fini (qse_dir_t* dir);
static int reset_to_path (qse_dir_t* dir, const qse_char_t* path);
qse_dir_t* qse_dir_open (qse_mmgr_t* mmgr, qse_size_t xtnsize, const qse_char_t* path, int flags)
{
qse_dir_t* dir;
dir = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(*dir) + xtnsize);
if (dir)
{
if (qse_dir_init (dir, mmgr, path, flags) <= -1)
{
QSE_MMGR_FREE (mmgr, dir);
dir = QSE_NULL;
}
else QSE_MEMSET (dir + 1, 0, xtnsize);
}
return dir;
}
void qse_dir_close (qse_dir_t* dir)
{
qse_dir_fini (dir);
QSE_MMGR_FREE (dir->mmgr, dir);
}
qse_mmgr_t* qse_dir_getmmgr (qse_dir_t* dir)
{
return dir->mmgr;
}
void* qse_dir_getxtn (qse_dir_t* dir)
{
return QSE_XTN (dir);
}
int qse_dir_init (qse_dir_t* dir, qse_mmgr_t* mmgr, const qse_char_t* path, int flags)
{
QSE_MEMSET (dir, 0, QSE_SIZEOF(*dir));
dir->mmgr = mmgr;
dir->flags = flags;
if (qse_str_init (&dir->tbuf, mmgr, 256) <= -1) return -1;
if (qse_mbs_init (&dir->mbuf, mmgr, 256) <= -1)
{
qse_str_fini (&dir->tbuf);
return -1;
}
#if defined(_WIN32)
dir->h = INVALID_HANDLE_VALUE;
#endif
return reset_to_path (dir, path);
}
static void close_dir_safely (qse_dir_t* dir)
{
#if defined(_WIN32)
if (dir->h != INVALID_HANDLE_VALUE)
{
FindClose (dir->h);
dir->h = INVALID_HANDLE_VALUE;
}
#elif defined(__OS2__)
if (dir->opened)
{
DosFindClose (dir->h);
dir->opened = 0;
}
#elif defined(__DOS__)
if (dir->opened)
{
_dos_findclose (&dir->f);
dir->opened = 0;
}
#else
if (dir->dp)
{
QSE_CLOSEDIR (dir->dp);
dir->dp = QSE_NULL;
}
#endif
}
void qse_dir_fini (qse_dir_t* dir)
{
close_dir_safely (dir);
qse_mbs_fini (&dir->mbuf);
qse_str_fini (&dir->tbuf);
}
static qse_mchar_t* wcs_to_mbuf (qse_dir_t* dir, const qse_wchar_t* wcs, qse_mbs_t* mbs)
{
qse_size_t ml, wl;
if (qse_wcstombs (wcs, &wl, QSE_NULL, &ml) <= -1 ||
qse_mbs_setlen (mbs, ml) == (qse_size_t)-1) return QSE_NULL;
qse_wcstombs (wcs, &wl, QSE_MBS_PTR(mbs), &ml);
return QSE_MBS_PTR(mbs);
}
static qse_wchar_t* mbs_to_wbuf (qse_dir_t* dir, const qse_mchar_t* mbs, qse_wcs_t* wcs)
{
qse_size_t ml, wl;
if (qse_mbstowcs (mbs, &ml, QSE_NULL, &wl) <= -1 ||
qse_wcs_setlen (wcs, wl) == (qse_size_t)-1) return QSE_NULL;
qse_mbstowcs (mbs, &ml, QSE_WCS_PTR(wcs), &wl);
return QSE_WCS_PTR(wcs);
}
static qse_mchar_t* make_mbsdos_path (qse_dir_t* dir, const qse_mchar_t* mpath)
{
if (mpath[0] == QSE_MT('\0'))
{
if (qse_mbs_cpy (&dir->mbuf, QSE_MT("*.*")) == (qse_size_t)-1) return QSE_NULL;
}
else
{
qse_size_t len;
if ((len = qse_mbs_cpy (&dir->mbuf, mpath)) == (qse_size_t)-1 ||
(!QSE_ISPATHMBSEP(mpath[len - 1]) &&
!qse_ismbsdrivecurpath(mpath) &&
qse_mbs_ccat (&dir->mbuf, QSE_MT('\\')) == (qse_size_t)-1) ||
qse_mbs_cat (&dir->mbuf, QSE_MT("*.*")) == (qse_size_t)-1)
{
return QSE_NULL;
}
}
return QSE_MBS_PTR(&dir->mbuf);
}
static qse_char_t* make_dos_path (qse_dir_t* dir, const qse_char_t* path)
{
if (path[0] == QSE_T('\0'))
{
if (qse_str_cpy (&dir->tbuf, QSE_T("*.*")) == (qse_size_t)-1) return QSE_NULL;
}
else
{
qse_size_t len;
if ((len = qse_str_cpy (&dir->tbuf, path)) == (qse_size_t)-1 ||
(!QSE_ISPATHSEP(path[len - 1]) &&
!qse_isdrivecurpath(path) &&
qse_str_ccat (&dir->tbuf, QSE_T('\\')) == (qse_size_t)-1) ||
qse_str_cat (&dir->tbuf, QSE_T("*.*")) == (qse_size_t)-1)
{
return QSE_NULL;
}
}
return QSE_STR_PTR(&dir->tbuf);
}
static qse_mchar_t* mkdospath (qse_dir_t* dir, const qse_char_t* path)
{
#if defined(QSE_CHAR_IS_MCHAR)
return make_dos_path (dir, path);
#else
if (dir->flags & QSE_DIR_MBSPATH)
{
return make_mbsdos_path (dir, (const qse_mchar_t*) path);
}
else
{
qse_char_t* tptr;
qse_mchar_t* mptr;
tptr = make_dos_path (dir, path);
if (tptr == QSE_NULL) return QSE_NULL;
mptr = wcs_to_mbuf (dir, QSE_STR_PTR(&dir->tbuf), &dir->mbuf);
if (mptr == QSE_NULL) return QSE_NULL;
return mptr;
}
#endif
}
static int reset_to_path (qse_dir_t* dir, const qse_char_t* path)
{
#if defined(_WIN32)
/* ------------------------------------------------------------------- */
qse_char_t* tptr;
dir->done = 0;
#if defined(QSE_CHAR_IS_MCHAR)
tptr = make_dos_path (dir, path);
#else
if (dir->flags & QSE_DIR_MBSPATH)
{
qse_mchar_t* mptr = make_mbsdos_path (dir, (const qse_mchar_t*) path);
if (mptr == QSE_NULL) return -1;
tptr = mbs_to_wbuf (dir, mptr, &dir->tbuf);
}
else
{
tptr = make_dos_path (dir, path);
if (tptr == QSE_NULL) return -1;
}
#endif
if (tptr == QSE_NULL) return -1;
dir->h = FindFirstFile (tptr, &dir->wfd);
if (dir->h == INVALID_HANDLE_VALUE) return -1;
return 0;
/* ------------------------------------------------------------------- */
#elif defined(__OS2__)
/* ------------------------------------------------------------------- */
APIRET rc;
qse_mchar_t* mptr;
dir->h = HDIR_CREATE;
dir->count = 1;
#if defined(QSE_CHAR_IS_MCHAR)
mptr = make_dos_path (dir, path);
#else
if (dir->flags & QSE_DIR_MBSPATH)
{
mptr = make_mbsdos_path (dir, (const qse_mchar_t*) path);
}
else
{
qse_char_t* tptr = make_dos_path (dir, path);
if (tptr == QSE_NULL) return -1;
mptr = wcs_to_mbuf (dir, tptr, &dir->mbuf);
}
#endif
if (mptr == QSE_NULL) return -1;
rc = DosFindFirst (
mptr,
&dir->h,
FILE_DIRECTORY | FILE_READONLY,
&dir->ffb,
QSE_SIZEOF(dir->ffb),
&dir->count,
FIL_STANDARDL);
if (rc != NO_ERROR) return -1;
dir->opened = 1;
return 0;
/* ------------------------------------------------------------------- */
#elif defined(__DOS__)
/* ------------------------------------------------------------------- */
unsigned int rc;
qse_mchar_t* mptr;
dir->done = 0;
#if defined(QSE_CHAR_IS_MCHAR)
mptr = make_dos_path (dir, path);
#else
if (dir->flags & QSE_DIR_MBSPATH)
{
mptr = make_mbsdos_path (dir, (const qse_mchar_t*) path);
}
else
{
qse_char_t* tptr = make_dos_path (dir, path);
if (tptr == QSE_NULL) return -1;
mptr = wcs_to_mbuf (dir, tptr, &dir->mbuf);
}
#endif
if (mptr == QSE_NULL) return -1;
rc = _dos_findfirst (mptr, _A_NORMAL | _A_SUBDIR, &dir->f);
if (rc != 0) return -1;
dir->opened = 1;
return 0;
/* ------------------------------------------------------------------- */
#else
DIR* dp;
#if defined(QSE_CHAR_IS_MCHAR)
dp = QSE_OPENDIR (path[0] == QSE_MT('\0')? QSE_T("."): path);
#else
if (dir->flags & QSE_DIR_MBSPATH)
{
const qse_mchar_t* mpath = (const qse_mchar_t*)path;
dp = QSE_OPENDIR (mpath == QSE_MT('\0')? QSE_MT("."): mpath);
}
else
{
if (path[0] == QSE_T('\0'))
{
dp = QSE_OPENDIR (QSE_MT("."));
}
else
{
qse_mchar_t* mptr;
mptr = wcs_to_mbuf (dir, path, &dir->mbuf);
if (mptr == QSE_NULL) return -1;
dp = QSE_OPENDIR (mptr);
}
}
#endif
dir->dp = dp;
return 0;
#endif
}
int qse_dir_reset (qse_dir_t* dir, const qse_char_t* path)
{
close_dir_safely (dir);
return reset_to_path (dir, path);
}
static int read_dir_to_tbuf (qse_dir_t* dir, void** name)
{
#if defined(_WIN32)
/* ------------------------------------------------------------------- */
if (dir->done) return (dir->done > 0)? 0: -1;
#if defined(QSE_CHAR_IS_MCHAR)
if (qse_str_cpy (&dir->tbuf, dir->wfd.cFileName) == (qse_size_t)-1) return -1;
*name = QSE_STR_PTR(&dir->tbuf);
#else
if (dir->flags & QSE_DIR_MBSPATH)
{
if (wcs_to_mbuf (dir, dir->wfd.cFileName, &dir->mbuf) == QSE_NULL) return -1;
*name = QSE_STR_PTR(&dir->mbuf);
}
else
{
if (qse_str_cpy (&dir->tbuf, dir->wfd.cFileName) == (qse_size_t)-1) return -1;
*name = QSE_STR_PTR(&dir->tbuf);
}
#endif
if (FindNextFile (dir->h, &dir->wfd) == FALSE)
dir->done = (GetLastError() == ERROR_NO_MORE_FILES)? 1: -1;
return 1;
/* ------------------------------------------------------------------- */
#elif defined(__OS2__)
/* ------------------------------------------------------------------- */
APIRET rc;
if (dir->count <= 0) return 0;
#if defined(QSE_CHAR_IS_MCHAR)
if (qse_str_cpy (&dir->tbuf, dir->ffb.achName) == (qse_size_t)-1) return -1;
*name = QSE_STR_PTR(&dir->tbuf);
#else
if (dir->flags & QSE_DIR_MBSPATH)
{
if (qse_mbs_cpy (&dir->mbuf, dir->ffb.achName) == (qse_size_t)-1) return -1;
*name = QSE_MBS_PTR(&dir->mbuf);
}
else
{
if (mbs_to_wbuf (dir, dir->ffb.achName, &dir->tbuf) == QSE_NULL) return -1;
*name = QSE_STR_PTR(&dir->tbuf);
}
#endif
rc = DosFindNext (dir->h, &dir->ffb, QSE_SIZEOF(dir->ffb), &dir->count);
if (rc == ERROR_NO_MORE_FILES) dir->count = 0;
else if (rc != NO_ERROR) return -1;
return 1;
/* ------------------------------------------------------------------- */
#elif defined(__DOS__)
/* ------------------------------------------------------------------- */
unsigned int rc;
if (dir->done) return (dir->done > 0)? 0: -1;
#if defined(QSE_CHAR_IS_MCHAR)
if (qse_str_cpy (&dir->tbuf, dir->f.name) == (qse_size_t)-1) return -1;
*name = QSE_STR_PTR(&dir->tbuf);
#else
if (dir->flags & QSE_DIR_MBSPATH)
{
if (qse_mbs_cpy (&dir->mbuf, dir->f.name) == (qse_size_t)-1) return -1;
*name = QSE_MBS_PTR(&dir->mbuf);
}
else
{
if (mbs_to_wbuf (dir, dir->f.name, &dir->tbuf) == QSE_NULL) return -1;
*name = QSE_STR_PTR(&dir->tbuf);
}
#endif
rc = _dos_findnext (&dir->f);
if (rc != 0) dir->done = (errno == ENOENT)? 1: -1;
return 1;
/* ------------------------------------------------------------------- */
#else
/* ------------------------------------------------------------------- */
qse_dirent_t* de;
errno = 0;
de = QSE_READDIR (dir->dp);
if (de == NULL) return (errno == 0)? 0: -1;
#if defined(QSE_CHAR_IS_MCHAR)
if (qse_str_cpy (&dir->tbuf, de->d_name) == (qse_size_t)-1) return -1;
*name = QSE_STR_PTR(&dir->tbuf);
#else
if (dir->flags & QSE_DIR_MBSPATH)
{
if (qse_mbs_cpy (&dir->mbuf, de->d_name) == (qse_size_t)-1) return -1;
*name = QSE_MBS_PTR(&dir->mbuf);
}
else
{
if (mbs_to_wbuf (dir, de->d_name, &dir->tbuf) == QSE_NULL) return -1;
*name = QSE_STR_PTR(&dir->tbuf);
}
#endif
return 1;
/* ------------------------------------------------------------------- */
#endif
}
int qse_dir_read (qse_dir_t* dir, qse_dir_ent_t* ent)
{
int x;
void* name;
x = read_dir_to_tbuf (dir, &name);
if (x >= 1)
{
QSE_MEMSET (ent, 0, QSE_SIZEOF(ent));
ent->name = name;
if (dir->flags & QSE_DIR_STAT)
{
/* TODO: more information */
}
}
return x;
}

374
qse/lib/cmn/glob.c
View File

@ -22,6 +22,7 @@
#include <qse/cmn/str.h>
#include <qse/cmn/mbwc.h>
#include <qse/cmn/path.h>
#include <qse/cmn/dir.h>
#include "mem.h"
#if defined(_WIN32)
@ -44,17 +45,7 @@
# define IS_ESC(c) ((c) == QSE_T('\\'))
#endif
#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
# define SEPC QSE_T('\\')
#else
# define SEPC QSE_T('/')
#endif
#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
# define IS_SEP(c) ((c) == QSE_T('/') || (c) == QSE_T('\\'))
#else
# define IS_SEP(c) ((c) == QSE_T('/'))
#endif
#define IS_SEP(c) QSE_ISPATHSEP(c)
#define IS_NIL(c) ((c) == QSE_T('\0'))
#define IS_SEP_OR_NIL(c) (IS_SEP(c) || IS_NIL(c))
@ -83,7 +74,6 @@ struct glob_t
void* cbctx;
qse_mmgr_t* mmgr;
qse_cmgr_t* cmgr;
qse_str_t path;
qse_str_t tbuf; /* temporary buffer */
@ -108,10 +98,10 @@ static qse_mchar_t* wcs_to_mbuf (glob_t* g, const qse_wchar_t* wcs, qse_mbs_t* m
{
qse_size_t ml, wl;
if (qse_wcstombswithcmgr (wcs, &wl, QSE_NULL, &ml, g->cmgr) <= -1 ||
if (qse_wcstombs (wcs, &wl, QSE_NULL, &ml) <= -1 ||
qse_mbs_setlen (mbs, ml) == (qse_size_t)-1) return QSE_NULL;
qse_wcstombswithcmgr (wcs, &wl, QSE_MBS_PTR(mbs), &ml, g->cmgr);
qse_wcstombs (wcs, &wl, QSE_MBS_PTR(mbs), &ml);
return QSE_MBS_PTR(mbs);
}
@ -322,338 +312,6 @@ static int get_next_segment (glob_t* g, segment_t* seg)
return seg->type;
}
#if defined(_WIN32)
struct qse_dir_t
{
HANDLE h;
WIN32_FIND_DATA wfd;
int done;
};
typedef struct qse_dir_t qse_dir_t;
#elif defined(__OS2__)
struct qse_dir_t
{
HDIR h;
FILEFINDBUF3L ffb;
ULONG count;
};
typedef struct qse_dir_t qse_dir_t;
#elif defined(__DOS__)
struct qse_dir_t
{
struct find_t f;
int done;
};
typedef struct qse_dir_t qse_dir_t;
#endif
static qse_dir_t* xopendir (glob_t* g, const qse_cstr_t* path)
{
#if defined(_WIN32)
/* ------------------------------------------------------------------- */
qse_dir_t* dp;
dp = QSE_MMGR_ALLOC (g->mmgr, QSE_SIZEOF(*dp));
if (dp == QSE_NULL) return QSE_NULL;
dp->done = 0;
if (path->len <= 0)
{
if (qse_str_cpy (&g->tbuf, QSE_T("*")) == (qse_size_t)-1)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
}
else
{
if (qse_str_cpy (&g->tbuf, path->ptr) == (qse_size_t)-1 ||
(!IS_SEP(path->ptr[path->len-1]) &&
!qse_isdrivecurpath(path->ptr) &&
qse_str_ccat (&g->tbuf, QSE_T('\\')) == (qse_size_t)-1) ||
qse_str_ccat (&g->tbuf, QSE_T('*')) == (qse_size_t)-1)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
}
dp->h = FindFirstFile (QSE_STR_PTR(&g->tbuf), &dp->wfd);
if (dp->h == INVALID_HANDLE_VALUE)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
return dp;
/* ------------------------------------------------------------------- */
#elif defined(__OS2__)
/* ------------------------------------------------------------------- */
qse_dir_t* dp;
APIRET rc;
qse_mchar_t* mptr;
dp = QSE_MMGR_ALLOC (g->mmgr, QSE_SIZEOF(*dp));
if (dp == QSE_NULL) return QSE_NULL;
if (path->len <= 0)
{
if (qse_str_cpy (&g->tbuf, QSE_T("*.*")) == (qse_size_t)-1)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
}
else
{
if (qse_str_cpy (&g->tbuf, path->ptr) == (qse_size_t)-1 ||
(!IS_SEP(path->ptr[path->len-1]) &&
!qse_isdrivecurpath(path->ptr) &&
qse_str_ccat (&g->tbuf, QSE_T('\\')) == (qse_size_t)-1) ||
qse_str_cat (&g->tbuf, QSE_T("*.*")) == (qse_size_t)-1)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
}
dp->h = HDIR_CREATE;
dp->count = 1;
#if defined(QSE_CHAR_IS_MCHAR)
mptr = QSE_STR_PTR(&g->tbuf);
#else
mptr = wcs_to_mbuf (g, QSE_STR_PTR(&g->tbuf), &g->mbuf);
if (mptr == QSE_NULL)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
#endif
rc = DosFindFirst (
mptr,
&dp->h,
FILE_DIRECTORY | FILE_READONLY,
&dp->ffb,
QSE_SIZEOF(dp->ffb),
&dp->count,
FIL_STANDARDL);
if (rc != NO_ERROR)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
return dp;
/* ------------------------------------------------------------------- */
#elif defined(__DOS__)
/* ------------------------------------------------------------------- */
qse_dir_t* dp;
unsigned int rc;
qse_mchar_t* mptr;
qse_size_t wl, ml;
dp = QSE_MMGR_ALLOC (g->mmgr, QSE_SIZEOF(*dp));
if (dp == QSE_NULL) return QSE_NULL;
dp->done = 0;
if (path->len <= 0)
{
if (qse_str_cpy (&g->tbuf, QSE_T("*.*")) == (qse_size_t)-1)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
}
else
{
if (qse_str_cpy (&g->tbuf, path->ptr) == (qse_size_t)-1 ||
(!IS_SEP(path->ptr[path->len-1]) &&
!qse_isdrivecurpath(path->ptr) &&
qse_str_ccat (&g->tbuf, QSE_T('\\')) == (qse_size_t)-1) ||
qse_str_cat (&g->tbuf, QSE_T("*.*")) == (qse_size_t)-1)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
}
#if defined(QSE_CHAR_IS_MCHAR)
mptr = QSE_STR_PTR(&g->tbuf);
#else
mptr = wcs_to_mbuf (g, QSE_STR_PTR(&g->tbuf), &g->mbuf);
if (mptr == QSE_NULL)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
#endif
rc = _dos_findfirst (mptr, _A_NORMAL | _A_SUBDIR, &dp->f);
if (rc != 0)
{
QSE_MMGR_FREE (g->mmgr, dp);
return QSE_NULL;
}
return dp;
/* ------------------------------------------------------------------- */
#else
/* ------------------------------------------------------------------- */
#if defined(QSE_CHAR_IS_MCHAR)
return QSE_OPENDIR ((path->len <= 0)? QSE_T("."): path->ptr);
#else
if (path->len <= 0)
{
return QSE_OPENDIR (QSE_MT("."));
}
else
{
qse_mchar_t* mptr;
mptr = wcs_to_mbuf (g, path->ptr, &g->mbuf);
if (mptr == QSE_NULL) return QSE_NULL;
return QSE_OPENDIR (mptr);
}
#endif
/* ------------------------------------------------------------------- */
#endif
}
static int xreaddir (glob_t* g, qse_dir_t* dp, qse_str_t* path)
{
#if defined(_WIN32)
/* ------------------------------------------------------------------- */
if (dp->done) return (dp->done > 0)? 0: -1;
if (qse_str_cat (path, dp->wfd.cFileName) == (qse_size_t)-1) return -1;
if (FindNextFile (dp->h, &dp->wfd) == FALSE)
dp->done = (GetLastError() == ERROR_NO_MORE_FILES)? 1: -1;
return 1;
/* ------------------------------------------------------------------- */
#elif defined(__OS2__)
/* ------------------------------------------------------------------- */
APIRET rc;
#if defined(QSE_CHAR_IS_MCHAR)
/* nothing */
#else
qse_size_t ml, wl, tmp;
#endif
if (dp->count <= 0) return 0;
#if defined(QSE_CHAR_IS_MCHAR)
if (qse_str_cat (path, dp->ffb.achName) == (qse_size_t)-1) return -1;
#else
tmp = QSE_STR_LEN(path);
if (qse_mbstowcswithcmgr (dp->ffb.achName, &ml, QSE_NULL, &wl, g->cmgr) <= -1 ||
qse_str_setlen (path, tmp + wl) == (qse_size_t)-1) return -1;
qse_mbstowcswithcmgr (dp->ffb.achName, &ml, QSE_STR_CPTR(&g->path,tmp), &wl, g->cmgr);
#endif
rc = DosFindNext (dp->h, &dp->ffb, QSE_SIZEOF(dp->ffb), &dp->count);
if (rc == ERROR_NO_MORE_FILES) dp->count = 0;
else if (rc != NO_ERROR) return -1;
return 1;
/* ------------------------------------------------------------------- */
#elif defined(__DOS__)
/* ------------------------------------------------------------------- */
unsigned int rc;
#if defined(QSE_CHAR_IS_MCHAR)
/* nothing */
#else
qse_size_t ml, wl, tmp;
#endif
if (dp->done) return (dp->done > 0)? 0: -1;
#if defined(QSE_CHAR_IS_MCHAR)
if (qse_str_cat (path, dp->f.name) == (qse_size_t)-1) return -1;
#else
tmp = QSE_STR_LEN(path);
if (qse_mbstowcswithcmgr (dp->f.name, &ml, QSE_NULL, &wl, g->cmgr) <= -1 ||
qse_str_setlen (path, tmp + wl) == (qse_size_t)-1) return -1;
qse_mbstowcswithcmgr (dp->f.name, &ml, QSE_STR_CPTR(&g->path,tmp), &wl, g->cmgr);
#endif
rc = _dos_findnext (&dp->f);
if (rc != 0) dp->done = (errno == ENOENT)? 1: -1;
return 1;
/* ------------------------------------------------------------------- */
#else
/* ------------------------------------------------------------------- */
qse_dirent_t* de;
#if defined(QSE_CHAR_IS_MCHAR)
/* nothing */
#else
qse_size_t ml, wl, tmp;
#endif
de = QSE_READDIR (dp);
if (de == NULL) return 0;
#if defined(QSE_CHAR_IS_MCHAR)
if (qse_str_cat (path, de->d_name) == (qse_size_t)-1) return -1;
#else
tmp = QSE_STR_LEN(path);
if (qse_mbstowcswithcmgr (de->d_name, &ml, QSE_NULL, &wl, g->cmgr) <= -1 ||
qse_str_setlen (path, tmp + wl) == (qse_size_t)-1) return -1;
qse_mbstowcswithcmgr (de->d_name, &ml, QSE_STR_CPTR(&g->path,tmp), &wl, g->cmgr);
#endif
return 1;
/* ------------------------------------------------------------------- */
#endif
}
static void xclosedir (glob_t* g, qse_dir_t* dp)
{
#if defined(_WIN32)
FindClose (dp->h);
QSE_MMGR_FREE (g->mmgr, dp);
#elif defined(__OS2__)
DosFindClose (dp->h);
QSE_MMGR_FREE (g->mmgr, dp);
#elif defined(__DOS__)
_dos_findclose (&dp->f);
QSE_MMGR_FREE (g->mmgr, dp);
#else
QSE_CLOSEDIR (dp);
#endif
}
static int handle_non_wild_segments (glob_t* g, segment_t* seg)
{
while (get_next_segment(g, seg) != NONE && !seg->wild)
@ -731,6 +389,8 @@ static int search (glob_t* g, segment_t* seg)
{
qse_dir_t* dp;
qse_size_t tmp, tmp2;
qse_dir_ent_t ent;
int x;
#if defined(NO_RECURSION)
stack_node_t* r;
@ -744,7 +404,7 @@ entry:
if (seg->wild)
{
dp = xopendir (g, QSE_STR_CSTR(&g->path));
dp = qse_dir_open (g->mmgr, 0, QSE_STR_PTR(&g->path), 0);
if (dp)
{
tmp = QSE_STR_LEN(&g->path);
@ -756,7 +416,11 @@ entry:
{
qse_str_setlen (&g->path, tmp2);
if (xreaddir (g, dp, &g->path) <= 0) break;
x = qse_dir_read (dp, &ent);
if (x <= -1) goto oops;
if (x == 0) break;
if (qse_str_cat (&g->path, ent.name) == (qse_size_t)-1) goto oops;
if (qse_strnfnmat (QSE_STR_CPTR(&g->path,tmp2), seg->ptr, seg->len, g->fnmat_flags) > 0)
{
@ -810,7 +474,7 @@ entry:
}
qse_str_setlen (&g->path, tmp);
xclosedir (g, dp); dp = QSE_NULL;
qse_dir_close (dp); dp = QSE_NULL;
}
}
@ -850,14 +514,14 @@ entry:
return 0;
oops:
if (dp) xclosedir (g, dp);
if (dp) qse_dir_close (dp);
#if defined(NO_RECURSION)
while (g->stack)
{
r = g->stack;
g->stack = r->next;
xclosedir (g, r->dp);
qse_dir_close (r->dp);
QSE_MMGR_FREE (g->mmgr, r);
}
@ -871,7 +535,7 @@ oops:
return -1;
}
int qse_globwithcmgr (const qse_char_t* pattern, qse_glob_cbimpl_t cbimpl, void* cbctx, int flags, qse_mmgr_t* mmgr, qse_cmgr_t* cmgr)
int qse_glob (const qse_char_t* pattern, qse_glob_cbimpl_t cbimpl, void* cbctx, int flags, qse_mmgr_t* mmgr)
{
segment_t seg;
glob_t g;
@ -881,7 +545,6 @@ int qse_globwithcmgr (const qse_char_t* pattern, qse_glob_cbimpl_t cbimpl, void*
g.cbimpl = cbimpl;
g.cbctx = cbctx;
g.mmgr = mmgr;
g.cmgr = cmgr;
#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
g.fnmat_flags |= QSE_STRFNMAT_IGNORECASE;
@ -928,8 +591,3 @@ int qse_globwithcmgr (const qse_char_t* pattern, qse_glob_cbimpl_t cbimpl, void*
return g.expanded;
}
int qse_glob (const qse_char_t* pattern, qse_glob_cbimpl_t cbimpl, void* cbctx, int flags, qse_mmgr_t* mmgr)
{
return qse_globwithcmgr (pattern, cbimpl, cbctx, flags, mmgr, qse_getdflcmgr());
}

621
qse/lib/cmn/mux.c Normal file
View File

@ -0,0 +1,621 @@
/*
* $Id$
*
Copyright 2006-2012 Chung, Hyung-Hwan.
This file is part of QSE.
QSE is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
QSE is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with QSE. If not, see <http://www.gnu.org/licenses/>.
*/
#include <qse/cmn/mux.h>
#include "mem.h"
#if defined(_WIN32)
# define FD_SETSIZE 4096 /* what is the best value??? */
# include <winsock2.h>
# include <windows.h>
# define USE_SELECT
#elif defined(__OS2__)
# include <types.h>
# include <sys/socket.h>
# include <netinet/in.h>
# include <tcpustd.h>
# include <sys/ioctl.h>
# include <nerrno.h>
# define INCL_DOSERRORS
# include <os2.h>
# pragma library("tcpip32.lib")
#elif defined(__DOS__)
# include <errno.h>
#else
# include <unistd.h>
# include <fcntl.h>
# include <errno.h>
# if defined(HAVE_SYS_EPOLL_H)
# include <sys/epoll.h>
# if defined(HAVE_EPOLL_CREATE)
# define USE_EPOLL
# endif
# elif defined(HAVE_POLL_H)
# define USE_POLL
# else
# define USE_SELECT
# endif
#endif
struct qse_mux_t
{
qse_mmgr_t* mmgr;
qse_mux_errnum_t errnum;
qse_mux_evtfun_t evtfun;
#if defined(USE_SELECT)
fd_set rset;
fd_set wset;
fd_set tmprset;
fd_set tmpwset;
int size;
int maxhnd;
struct
{
qse_mux_evt_t** ptr;
int ubound;
} me;
#elif defined(USE_EPOLL)
int fd;
struct
{
struct epoll_event* ptr;
qse_size_t len;
qse_size_t capa;
} ee;
struct
{
qse_mux_evt_t** ptr;
int ubound;
} me;
#endif
};
int qse_mux_init (qse_mux_t* mux, qse_mmgr_t* mmgr, qse_mux_evtfun_t evtfun, qse_size_t capahint);
void qse_mux_fini (qse_mux_t* mux);
#if defined(_WIN32)
static qse_mux_errnum_t syserr_to_errnum (DWORD e)
{
switch (e)
{
case ERROR_NOT_ENOUGH_MEMORY:
case ERROR_OUTOFMEMORY:
return QSE_MUX_ENOMEM;
case ERROR_INVALID_PARAMETER:
case ERROR_INVALID_HANDLE:
case ERROR_INVALID_NAME:
return QSE_MUX_EINVAL;
case ERROR_ACCESS_DENIED:
return QSE_MUX_EACCES;
case ERROR_FILE_NOT_FOUND:
case ERROR_PATH_NOT_FOUND:
return QSE_MUX_ENOENT;
case ERROR_ALREADY_EXISTS:
case ERROR_FILE_EXISTS:
return QSE_MUX_EEXIST;
default:
return QSE_MUX_ESYSERR;
}
}
#elif defined(__OS2__)
static qse_mux_errnum_t syserr_to_errnum (APIRET e)
{
switch (e)
{
case ERROR_NOT_ENOUGH_MEMORY:
return QSE_MUX_ENOMEM;
case ERROR_INVALID_PARAMETER:
case ERROR_INVALID_HANDLE:
case ERROR_INVALID_NAME:
return QSE_MUX_EINVAL;
case ERROR_ACCESS_DENIED:
return QSE_MUX_EACCES;
case ERROR_FILE_NOT_FOUND:
case ERROR_PATH_NOT_FOUND:
return QSE_MUX_ENOENT;
case ERROR_ALREADY_EXISTS:
return QSE_MUX_EEXIST;
default:
return QSE_MUX_ESYSERR;
}
}
#elif defined(__DOS__)
static qse_mux_errnum_t syserr_to_errnum (int e)
{
switch (e)
{
case ENOMEM:
return QSE_MUX_ENOMEM;
case EINVAL:
return QSE_MUX_EINVAL;
case EACCES:
return QSE_MUX_EACCES;
case ENOENT:
return QSE_MUX_ENOENT;
case EEXIST:
return QSE_MUX_EEXIST;
default:
return QSE_MUX_ESYSERR;
}
}
#else
static qse_mux_errnum_t syserr_to_errnum (int e)
{
switch (e)
{
case ENOMEM:
return QSE_MUX_ENOMEM;
case EINVAL:
return QSE_MUX_EINVAL;
case ENOENT:
return QSE_MUX_ENOENT;
case EACCES:
return QSE_MUX_EACCES;
case EEXIST:
return QSE_MUX_EEXIST;
case EINTR:
return QSE_MUX_EINTR;
default:
return QSE_MUX_ESYSERR;
}
}
#endif
qse_mux_t* qse_mux_open (qse_mmgr_t* mmgr, qse_size_t xtnsize, qse_mux_evtfun_t evtfun, qse_size_t capahint)
{
qse_mux_t* mux;
mux = QSE_MMGR_ALLOC (mmgr, QSE_SIZEOF(*mux) + xtnsize);
if (mux)
{
if (qse_mux_init (mux, mmgr, evtfun, capahint) <= -1)
{
QSE_MMGR_FREE (mmgr, mux);
mux = QSE_NULL;
}
else QSE_MEMSET (mux + 1, 0, xtnsize);
}
return mux;
}
void qse_mux_close (qse_mux_t* mux)
{
qse_mux_fini (mux);
QSE_MMGR_FREE (mux->mmgr, mux);
}
int qse_mux_init (qse_mux_t* mux, qse_mmgr_t* mmgr, qse_mux_evtfun_t evtfun, qse_size_t capahint)
{
QSE_MEMSET (mux, 0, QSE_SIZEOF(*mux));
mux->mmgr = mmgr;
mux->evtfun = evtfun;
/* epoll_create returns an error and set errno to EINVAL
* if size is 0. Having a positive size greater than 0
* also makes easier other parts like maintaining internal
* event buffers */
if (capahint <= 0) capahint = 1;
#if defined(USE_SELECT)
FD_ZERO (&mux->rset);
FD_ZERO (&mux->wset);
mux->maxhnd = -1;
#elif defined(USE_EPOLL)
#if defined(HAVE_EPOLL_CREATE1) && defined(O_CLOEXEC)
mux->fd = epoll_create1 (O_CLOEXEC);
#else
mux->fd = epoll_create (capahint);
#endif
if (mux->fd <= -1)
{
mux->errnum = syserr_to_errnum (errno);
return -1;
}
#if defined(HAVE_EPOLL_CREATE1) && defined(O_CLOEXEC)
/* nothing to do */
#elif defined(FD_CLOEXEC)
{
int flag = fcntl (mux->fd, F_GETFD);
if (flag >= 0) fcntl (mux->fd, F_SETFD, flag | FD_CLOEXEC);
}
#endif
#else
/* TODO: */
mux->errnum = QSE_MUX_ENOIMPL;
return -1;
#endif
return 0;
}
void qse_mux_fini (qse_mux_t* mux)
{
#if defined(USE_SELECT)
FD_ZERO (&mux->rset);
FD_ZERO (&mux->wset);
if (mux->me.ptr)
{
int i;
for (i = 0; i < mux->me.ubound; i++)
{
if (mux->me.ptr[i])
QSE_MMGR_FREE (mux->mmgr, mux->me.ptr[i]);
}
QSE_MMGR_FREE (mux->mmgr, mux->me.ptr);
mux->me.ubound = 0;
mux->maxhnd = -1;
}
#elif defined(USE_EPOLL)
close (mux->fd);
if (mux->ee.ptr)
{
QSE_MMGR_FREE (mux->mmgr, mux->ee.ptr);
mux->ee.len = 0;
mux->ee.capa = 0;
}
if (mux->me.ptr)
{
int i;
for (i = 0; i < mux->me.ubound; i++)
{
if (mux->me.ptr[i])
QSE_MMGR_FREE (mux->mmgr, mux->me.ptr[i]);
}
QSE_MMGR_FREE (mux->mmgr, mux->me.ptr);
mux->me.ubound = 0;
}
#endif
}
qse_mmgr_t* qse_mux_getmmgr (qse_mux_t* mux)
{
return mux->mmgr;
}
void* qse_mux_getxtn (qse_mux_t* mux)
{
return QSE_XTN (mux);
}
#define ALIGN_TO(num,align) ((((num) + (align) - 1) / (align)) * (align))
int qse_mux_insert (qse_mux_t* mux, const qse_mux_evt_t* evt)
{
#if defined(USE_SELECT)
if (evt->hnd >= mux->me.ubound)
{
qse_mux_evt_t** tmp;
int ubound;
ubound = evt->hnd + 1;
ubound = ALIGN_TO (ubound, 128);
tmp = QSE_MMGR_REALLOC (mux->mmgr, mux->me.ptr, QSE_SIZEOF(*mux->me.ptr) * ubound);
if (tmp == QSE_NULL)
{
mux->errnum = QSE_MUX_ENOMEM;
return -1;
}
QSE_MEMSET (&tmp[mux->me.ubound], 0, QSE_SIZEOF(*mux->me.ptr) * (ubound - mux->me.ubound));
mux->me.ptr = tmp;
mux->me.ubound = ubound;
}
if (!mux->me.ptr[evt->hnd])
{
mux->me.ptr[evt->hnd] = QSE_MMGR_ALLOC (mux->mmgr, QSE_SIZEOF(*evt));
if (!mux->me.ptr[evt->hnd])
{
mux->errnum = QSE_MUX_ENOMEM;
return -1;
}
}
if (evt->mask & QSE_MUX_IN) FD_SET (evt->hnd, &mux->rset);
if (evt->mask & QSE_MUX_OUT) FD_SET (evt->hnd, &mux->wset);
*mux->me.ptr[evt->hnd] = *evt;
if (evt->hnd > mux->maxhnd) mux->maxhnd = evt->hnd;
mux->size++;
return 0;
#elif defined(USE_EPOLL)
struct epoll_event ev;
QSE_MEMSET (&ev, 0, QSE_SIZEOF(ev));
if (evt->mask & QSE_MUX_IN) ev.events |= EPOLLIN;
if (evt->mask & QSE_MUX_OUT) ev.events |= EPOLLOUT;
ev.data.fd = evt->hnd;
if (ev.events == 0 || evt->hnd < 0)
{
mux->errnum = QSE_MUX_EINVAL;
return -1;
}
if (evt->hnd >= mux->me.ubound)
{
qse_mux_evt_t** tmp;
int ubound;
ubound = evt->hnd + 1;
ubound = ALIGN_TO (ubound, 128);
tmp = QSE_MMGR_REALLOC (mux->mmgr, mux->me.ptr, QSE_SIZEOF(*mux->me.ptr) * ubound);
if (tmp == QSE_NULL)
{
mux->errnum = QSE_MUX_ENOMEM;
return -1;
}
QSE_MEMSET (&tmp[mux->me.ubound], 0, QSE_SIZEOF(*mux->me.ptr) * (ubound - mux->me.ubound));
mux->me.ptr = tmp;
mux->me.ubound = ubound;
}
if (!mux->me.ptr[evt->hnd])
{
mux->me.ptr[evt->hnd] = QSE_MMGR_ALLOC (mux->mmgr, QSE_SIZEOF(*evt));
if (!mux->me.ptr[evt->hnd])
{
mux->errnum = QSE_MUX_ENOMEM;
return -1;
}
}
if (mux->ee.len >= mux->ee.capa)
{
struct epoll_event* tmp;
qse_size_t newcapa;
newcapa = (mux->ee.capa + 1) * 2;
newcapa = ALIGN_TO (newcapa, 256);
tmp = QSE_MMGR_REALLOC (
mux->mmgr, mux->ee.ptr,
QSE_SIZEOF(*mux->ee.ptr) * newcapa);
if (tmp == QSE_NULL)
{
mux->errnum = QSE_MUX_ENOMEM;
return -1;
}
mux->ee.ptr = tmp;
mux->ee.capa = newcapa;
}
if (epoll_ctl (mux->fd, EPOLL_CTL_ADD, evt->hnd, &ev) == -1)
{
mux->errnum = syserr_to_errnum (errno);
return -1;
}
*mux->me.ptr[evt->hnd] = *evt;
mux->ee.len++;
return 0;
#else
/* TODO: */
mux->errnum = QSE_MUX_ENOIMPL;
return -1;
#endif
}
int qse_mux_delete (qse_mux_t* mux, const qse_mux_evt_t* evt)
{
#if defined(USE_SELECT)
qse_mux_evt_t* mevt;
if (mux->size <= 0 || evt->hnd < 0 || evt->hnd >= mux->me.ubound)
{
mux->errnum = QSE_MUX_EINVAL;
return -1;
}
mevt = mux->me.ptr[evt->hnd];
if (mevt->hnd != evt->hnd)
{
/* already deleted??? */
mux->errnum = QSE_MUX_EINVAL;
return -1;
}
if (mevt->mask & QSE_MUX_IN) FD_CLR (evt->hnd, &mux->rset);
if (mevt->mask & QSE_MUX_OUT) FD_CLR (evt->hnd, &mux->wset);
if (mevt->hnd == mux->maxhnd)
{
qse_mux_hnd_t i;
for (i = mevt->hnd; i > 0; )
{
i--;
if (mux->me.ptr[i] && mux->me.ptr[i]->hnd >= 0)
{
QSE_ASSERT (i == mux->me.ptr[i]->hnd);
mux->maxhnd = mux->me.ptr[i]->hnd;
goto done;
}
}
mux->maxhnd = -1;
QSE_ASSERT (mux->size == 1);
}
done:
mevt->hnd = -1;
mux->size--;
return 0;
#elif defined(USE_EPOLL)
if (mux->ee.len <= 0)
{
mux->errnum = QSE_MUX_EINVAL;
return -1;
}
if (epoll_ctl (mux->fd, EPOLL_CTL_DEL, evt->hnd, QSE_NULL) <= -1)
{
mux->errnum = syserr_to_errnum(errno);
return -1;
}
mux->ee.len--;
return 0;
#else
/* TODO */
mux->errnum = QSE_MUX_ENOIMPL;
return -1;
#endif
}
int qse_mux_poll (qse_mux_t* mux, qse_ntime_t timeout)
{
#if defined(USE_SELECT)
struct timeval tv;
int n;
tv.tv_sec = timeout / QSE_MSECS_PER_SEC;
tv.tv_usec = (timeout % QSE_MSECS_PER_SEC) * QSE_USECS_PER_MSEC;
mux->tmprset = mux->rset;
mux->tmpwset = mux->wset;
n = select (mux->maxhnd + 1, &mux->tmprset, &mux->tmpwset, QSE_NULL, &tv);
if (n <= -1)
{
#if defined(_WIN32)
mux->errnum = syserr_to_errnum(WSAGetLastError());
#else
mux->errnum = syserr_to_errnum(errno);
#endif
return -1;
}
if (n > 0)
{
qse_mux_hnd_t i;
qse_mux_evt_t* evt, xevt;
for (i = 0 ; i < mux->maxhnd; i++)
{
evt = mux->me.ptr[i];
if (!evt || evt->hnd != i) continue;
QSE_MEMCPY (&xevt, evt, QSE_SIZEOF(xevt));
xevt.mask = 0;
if ((evt->mask & QSE_MUX_IN) && FD_ISSET(evt->hnd, &mux->tmprset)) xevt.mask |= QSE_MUX_IN;
if ((evt->mask & QSE_MUX_OUT) && FD_ISSET(evt->hnd, &mux->tmpwset)) xevt.mask |= QSE_MUX_OUT;
if (xevt.mask > 0) mux->evtfun (mux, &xevt);
}
}
return n;
#elif defined(USE_EPOLL)
int nfds, hnd, i, mask;
qse_mux_evt_t* evt, xevt;
nfds = epoll_wait (mux->fd, mux->ee.ptr, mux->ee.len, timeout);
if (nfds <= -1)
{
mux->errnum = syserr_to_errnum(errno);
return -1;
}
for (i = 0; i < nfds; i++)
{
hnd = mux->ee.ptr[i].data.fd;
evt = mux->me.ptr[hnd];
QSE_ASSERT (evt->hnd == hnd);
QSE_MEMCPY (&xevt, evt, QSE_SIZEOF(xevt));
xevt.mask = 0;
if (mux->ee.ptr[i].events & EPOLLIN) xevt.mask |= QSE_MUX_IN;
if (mux->ee.ptr[i].events & EPOLLOUT) xevt.mask |= QSE_MUX_OUT;
if (mux->ee.ptr[i].events & EPOLLHUP)
{
if (evt->mask & QSE_MUX_IN)
xevt.mask |= QSE_MUX_IN;
if (evt->mask & QSE_MUX_OUT)
xevt.mask |= QSE_MUX_OUT;
}
mux->evtfun (mux, &xevt);
}
return nfds;
#else
/* TODO */
mux->errnum = QSE_MUX_ENOIMPL;
return -1;
#endif
}

9
qse/lib/cmn/path-basename.c
View File

@ -20,13 +20,8 @@
#include <qse/cmn/path.h>
#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
# define IS_MSEP(c) ((c) == QSE_MT('/') || (c) == QSE_MT('\\'))
# define IS_WSEP(c) ((c) == QSE_WT('/') || (c) == QSE_WT('\\'))
#else
# define IS_MSEP(c) ((c) == QSE_MT('/'))
# define IS_WSEP(c) ((c) == QSE_WT('/'))
#endif
#define IS_MSEP(c) QSE_ISPATHMBSEP(c)
#define IS_WSEP(c) QSE_ISPATHWCSEP(c)
const qse_mchar_t* qse_mbsbasename (const qse_mchar_t* path)
{

7
qse/lib/cmn/path-canon.c
View File

@ -24,12 +24,7 @@
/* MBS IMPLEMENTATION */
/* ------------------------------------------------------------------ */
#if defined(_WIN32) || defined(__OS2__) || defined(__DOS__)
# define IS_MSEP(c) ((c) == QSE_MT('/') || (c) == QSE_MT('\\'))
#else
# define IS_MSEP(c) ((c) == QSE_MT('/'))
#endif
#define IS_MSEP(c) QSE_ISPATHMBSEP(c)
#define IS_MNIL(c) ((c) == QSE_MT('\0'))
#define IS_MSEP_OR_MNIL(c) (IS_MSEP(c) || IS_MNIL(c))

1
qse/lib/cmn/syscall.h
View File

@ -363,7 +363,6 @@
#endif
/* ===== DIRECTORY - not really system calls ===== */
typedef DIR qse_dir_t;
#define QSE_OPENDIR(name) opendir(name)
#define QSE_CLOSEDIR(name) closedir(name)