From 55a024bff27158b2ec7c003d1ab9fbd63bb0438b Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Tue, 5 Apr 2022 10:46:00 +0000 Subject: [PATCH] fixed a bug in hawk_rtx_makembsvalwithbchars2() and hawk_rtx_makembsvalwithuchars2() fixing sed code being imported --- hawk/bin/Makefile.am | 12 +- hawk/bin/Makefile.in | 47 ++++-- hawk/lib/ecs.c | 4 + hawk/lib/err.c | 79 +-------- hawk/lib/hawk-cmn.h | 1 + hawk/lib/hawk-gem.h | 10 ++ hawk/lib/hawk-prv.h | 17 -- hawk/lib/hawk-sed.h | 97 +++++++---- hawk/lib/hawk-std.h | 2 +- hawk/lib/hawk.h | 157 +++++++----------- hawk/lib/sed.c | 248 +++++++++++++++------------- hawk/lib/std-sed.c | 378 ++++++++++++++++++++++++++++--------------- hawk/lib/std.c | 1 - hawk/lib/val.c | 18 --- 14 files changed, 584 insertions(+), 487 deletions(-) diff --git a/hawk/bin/Makefile.am b/hawk/bin/Makefile.am index a12a3160..d8419570 100644 --- a/hawk/bin/Makefile.am +++ b/hawk/bin/Makefile.am @@ -13,7 +13,7 @@ LDFLAGS_COMMON = -L$(abs_builddir)/../lib -L$(libdir) ##Use -l for third party libraries for automatic inclusion to DEPENDENCIES . LIBADD_COMMON = ../lib/libhawk.la -bin_PROGRAMS = hawk #hsed +bin_PROGRAMS = hawk hsed ################################################## # hawk @@ -38,8 +38,8 @@ hawk_LDFLAGS = $(LDFLAGS_COMMON) ## hawk_LDADD = $(LIBADD_COMMON) $(LIBM) -#hsed_SOURCES = main-hsed.c -#hsed_CPPFLAGS = $(CPPFLAGS_COMMON) -#hsed_CFLAGS = $(CFLAGS_COMMON) -#hsed_LDFLAGS = $(LDFLAGS_COMMON) -#hsed_LDADD = $(LIBADD_COMMON) $(LIBM) +hsed_SOURCES = main-hsed.c +hsed_CPPFLAGS = $(CPPFLAGS_COMMON) +hsed_CFLAGS = $(CFLAGS_COMMON) +hsed_LDFLAGS = $(LDFLAGS_COMMON) +hsed_LDADD = $(LIBADD_COMMON) $(LIBM) diff --git a/hawk/bin/Makefile.in b/hawk/bin/Makefile.in index 0bf7dfaa..f57fa5c9 100644 --- a/hawk/bin/Makefile.in +++ b/hawk/bin/Makefile.in @@ -88,7 +88,7 @@ PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ -bin_PROGRAMS = hawk$(EXEEXT) +bin_PROGRAMS = hawk$(EXEEXT) hsed$(EXEEXT) subdir = bin ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \ @@ -120,6 +120,12 @@ am__v_lt_1 = hawk_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(hawk_CFLAGS) $(CFLAGS) \ $(hawk_LDFLAGS) $(LDFLAGS) -o $@ +am_hsed_OBJECTS = hsed-main-hsed.$(OBJEXT) +hsed_OBJECTS = $(am_hsed_OBJECTS) +hsed_DEPENDENCIES = $(LIBADD_COMMON) $(am__DEPENDENCIES_1) +hsed_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(hsed_CFLAGS) $(CFLAGS) \ + $(hsed_LDFLAGS) $(LDFLAGS) -o $@ AM_V_P = $(am__v_P_@AM_V@) am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) am__v_P_0 = false @@ -135,7 +141,8 @@ am__v_at_1 = DEFAULT_INCLUDES = depcomp = $(SHELL) $(top_srcdir)/ac/depcomp am__maybe_remake_depfiles = depfiles -am__depfiles_remade = ./$(DEPDIR)/hawk-main-hawk.Po +am__depfiles_remade = ./$(DEPDIR)/hawk-main-hawk.Po \ + ./$(DEPDIR)/hsed-main-hsed.Po am__mv = mv -f COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) @@ -155,8 +162,8 @@ AM_V_CCLD = $(am__v_CCLD_@AM_V@) am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) am__v_CCLD_0 = @echo " CCLD " $@; am__v_CCLD_1 = -SOURCES = $(hawk_SOURCES) -DIST_SOURCES = $(hawk_SOURCES) +SOURCES = $(hawk_SOURCES) $(hsed_SOURCES) +DIST_SOURCES = $(hawk_SOURCES) $(hsed_SOURCES) am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ @@ -351,6 +358,11 @@ hawk_CPPFLAGS = $(CPPFLAGS_COMMON) hawk_CFLAGS = $(CFLAGS_COMMON) hawk_LDFLAGS = $(LDFLAGS_COMMON) hawk_LDADD = $(LIBADD_COMMON) $(LIBM) +hsed_SOURCES = main-hsed.c +hsed_CPPFLAGS = $(CPPFLAGS_COMMON) +hsed_CFLAGS = $(CFLAGS_COMMON) +hsed_LDFLAGS = $(LDFLAGS_COMMON) +hsed_LDADD = $(LIBADD_COMMON) $(LIBM) all: all-am .SUFFIXES: @@ -438,6 +450,10 @@ hawk$(EXEEXT): $(hawk_OBJECTS) $(hawk_DEPENDENCIES) $(EXTRA_hawk_DEPENDENCIES) @rm -f hawk$(EXEEXT) $(AM_V_CCLD)$(hawk_LINK) $(hawk_OBJECTS) $(hawk_LDADD) $(LIBS) +hsed$(EXEEXT): $(hsed_OBJECTS) $(hsed_DEPENDENCIES) $(EXTRA_hsed_DEPENDENCIES) + @rm -f hsed$(EXEEXT) + $(AM_V_CCLD)$(hsed_LINK) $(hsed_OBJECTS) $(hsed_LDADD) $(LIBS) + mostlyclean-compile: -rm -f *.$(OBJEXT) @@ -445,6 +461,7 @@ distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hawk-main-hawk.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hsed-main-hsed.Po@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @@ -490,6 +507,20 @@ hawk-main-hawk.obj: main-hawk.c @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(hawk_CPPFLAGS) $(CPPFLAGS) $(hawk_CFLAGS) $(CFLAGS) -c -o hawk-main-hawk.obj `if test -f 'main-hawk.c'; then $(CYGPATH_W) 'main-hawk.c'; else $(CYGPATH_W) '$(srcdir)/main-hawk.c'; fi` +hsed-main-hsed.o: main-hsed.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(hsed_CPPFLAGS) $(CPPFLAGS) $(hsed_CFLAGS) $(CFLAGS) -MT hsed-main-hsed.o -MD -MP -MF $(DEPDIR)/hsed-main-hsed.Tpo -c -o hsed-main-hsed.o `test -f 'main-hsed.c' || echo '$(srcdir)/'`main-hsed.c +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/hsed-main-hsed.Tpo $(DEPDIR)/hsed-main-hsed.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='main-hsed.c' object='hsed-main-hsed.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(hsed_CPPFLAGS) $(CPPFLAGS) $(hsed_CFLAGS) $(CFLAGS) -c -o hsed-main-hsed.o `test -f 'main-hsed.c' || echo '$(srcdir)/'`main-hsed.c + +hsed-main-hsed.obj: main-hsed.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(hsed_CPPFLAGS) $(CPPFLAGS) $(hsed_CFLAGS) $(CFLAGS) -MT hsed-main-hsed.obj -MD -MP -MF $(DEPDIR)/hsed-main-hsed.Tpo -c -o hsed-main-hsed.obj `if test -f 'main-hsed.c'; then $(CYGPATH_W) 'main-hsed.c'; else $(CYGPATH_W) '$(srcdir)/main-hsed.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/hsed-main-hsed.Tpo $(DEPDIR)/hsed-main-hsed.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='main-hsed.c' object='hsed-main-hsed.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(hsed_CPPFLAGS) $(CPPFLAGS) $(hsed_CFLAGS) $(CFLAGS) -c -o hsed-main-hsed.obj `if test -f 'main-hsed.c'; then $(CYGPATH_W) 'main-hsed.c'; else $(CYGPATH_W) '$(srcdir)/main-hsed.c'; fi` + mostlyclean-libtool: -rm -f *.lo @@ -624,6 +655,7 @@ clean-am: clean-binPROGRAMS clean-generic clean-libtool mostlyclean-am distclean: distclean-am -rm -f ./$(DEPDIR)/hawk-main-hawk.Po + -rm -f ./$(DEPDIR)/hsed-main-hsed.Po -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-tags @@ -670,6 +702,7 @@ installcheck-am: maintainer-clean: maintainer-clean-am -rm -f ./$(DEPDIR)/hawk-main-hawk.Po + -rm -f ./$(DEPDIR)/hsed-main-hsed.Po -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic @@ -707,12 +740,6 @@ uninstall-am: uninstall-binPROGRAMS .PRECIOUS: Makefile -#hsed_SOURCES = main-hsed.c -#hsed_CPPFLAGS = $(CPPFLAGS_COMMON) -#hsed_CFLAGS = $(CFLAGS_COMMON) -#hsed_LDFLAGS = $(LDFLAGS_COMMON) -#hsed_LDADD = $(LIBADD_COMMON) $(LIBM) - # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: diff --git a/hawk/lib/ecs.c b/hawk/lib/ecs.c index 2fff85ea..f911f8b0 100644 --- a/hawk/lib/ecs.c +++ b/hawk/lib/ecs.c @@ -69,6 +69,8 @@ hawk_oow_t hawk_becs_ncatuchars (hawk_becs_t* str, const hawk_uch_t* s, hawk_oow { hawk_oow_t bcslen, ucslen; + if (!cmgr) cmgr = str->gem->cmgr; + ucslen = len; if (hawk_conv_uchars_to_bchars_with_cmgr(s, &ucslen, HAWK_NULL, &bcslen, cmgr) <= -1) return (hawk_oow_t)-1; @@ -87,6 +89,8 @@ hawk_oow_t hawk_uecs_ncatbchars (hawk_uecs_t* str, const hawk_bch_t* s, hawk_oow { hawk_oow_t bcslen, ucslen; + if (!cmgr) cmgr = str->gem->cmgr; + bcslen = len; if (hawk_conv_bchars_to_uchars_with_cmgr(s, &bcslen, HAWK_NULL, &ucslen, cmgr, all) <= -1) return (hawk_oow_t)-1; diff --git a/hawk/lib/err.c b/hawk/lib/err.c index af17a949..2d7d4e72 100644 --- a/hawk/lib/err.c +++ b/hawk/lib/err.c @@ -223,38 +223,6 @@ hawk_errstr_t hawk_geterrstr (hawk_t* hawk) } /* ------------------------------------------------------------------------- */ - -const hawk_bch_t* hawk_geterrbmsg (hawk_t* hawk) -{ - return hawk_gem_geterrbmsg(hawk_getgem(hawk)); -} - -const hawk_uch_t* hawk_geterrumsg (hawk_t* hawk) -{ - return hawk_gem_geterrumsg(hawk_getgem(hawk)); -} - -void hawk_geterrinf (hawk_t* hawk, hawk_errinf_t* errinf) -{ - hawk_gem_geterrinf (hawk_getgem(hawk), errinf); -} - -void hawk_geterror (hawk_t* hawk, hawk_errnum_t* errnum, const hawk_ooch_t** errmsg, hawk_loc_t* errloc) -{ - hawk_gem_geterror (hawk_getgem(hawk), errnum, errmsg, errloc); -} - -const hawk_ooch_t* hawk_backuperrmsg (hawk_t* hawk) -{ - hawk_copy_oocstr (hawk->errmsg_backup, HAWK_COUNTOF(hawk->errmsg_backup), hawk_geterrmsg(hawk)); - return hawk->errmsg_backup; -} - -void hawk_seterrinf (hawk_t* hawk, const hawk_errinf_t* errinf) -{ - hawk_gem_seterrinf (hawk_getgem(hawk), errinf); -} - void hawk_seterrbfmt (hawk_t* hawk, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_bch_t* errfmt, ...) { va_list ap; @@ -281,44 +249,8 @@ void hawk_seterruvfmt (hawk_t* hawk, const hawk_loc_t* errloc, hawk_errnum_t err hawk_gem_seterruvfmt (hawk_getgem(hawk), errloc, errnum, errfmt, ap); } -void hawk_seterror (hawk_t* hawk, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_oocs_t* errarg) -{ - hawk_gem_seterror (hawk_getgem(hawk), errloc, errnum, errarg); -} - /* ------------------------------------------------------------------------- */ -const hawk_bch_t* hawk_rtx_geterrbmsg (hawk_rtx_t* rtx) -{ - return hawk_gem_geterrbmsg(hawk_rtx_getgem(rtx)); -} - -const hawk_uch_t* hawk_rtx_geterrumsg (hawk_rtx_t* rtx) -{ - return hawk_gem_geterrumsg(hawk_rtx_getgem(rtx)); -} - -void hawk_rtx_geterrinf (hawk_rtx_t* rtx, hawk_errinf_t* errinf) -{ - hawk_gem_geterrinf (hawk_rtx_getgem(rtx), errinf); -} - -void hawk_rtx_geterror (hawk_rtx_t* rtx, hawk_errnum_t* errnum, const hawk_ooch_t** errmsg, hawk_loc_t* errloc) -{ - hawk_gem_geterror (hawk_rtx_getgem(rtx), errnum, errmsg, errloc); -} - -const hawk_ooch_t* hawk_rtx_backuperrmsg (hawk_rtx_t* rtx) -{ - hawk_copy_oocstr (rtx->errmsg_backup, HAWK_COUNTOF(rtx->errmsg_backup), hawk_rtx_geterrmsg(rtx)); - return rtx->errmsg_backup; -} - -void hawk_rtx_seterrinf (hawk_rtx_t* rtx, const hawk_errinf_t* errinf) -{ - hawk_gem_seterrinf (hawk_rtx_getgem(rtx), errinf); -} - void hawk_rtx_seterrbfmt (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_bch_t* errfmt, ...) { va_list ap; @@ -345,11 +277,6 @@ void hawk_rtx_seterruvfmt (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnu hawk_gem_seterruvfmt (hawk_rtx_getgem(rtx), errloc, errnum, errfmt, ap); } -void hawk_rtx_seterror (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_oocs_t* errarg) -{ - hawk_gem_seterror (hawk_rtx_getgem(rtx), errloc, errnum, errarg); -} - void hawk_rtx_errortohawk (hawk_rtx_t* rtx, hawk_t* hawk) { /* copy error information in 'rtx' to the 'hawk' object */ @@ -562,3 +489,9 @@ void hawk_gem_seterror (hawk_gem_t* gem, const hawk_loc_t* errloc, hawk_errnum_t if (errloc != HAWK_NULL) gem->errloc = *errloc; else HAWK_MEMSET (&gem->errloc, 0, HAWK_SIZEOF(gem->errloc)); } + +const hawk_ooch_t* hawk_gem_backuperrmsg (hawk_gem_t* gem) +{ + hawk_copy_oocstr (gem->errmsg_backup, HAWK_COUNTOF(gem->errmsg_backup), hawk_gem_geterrmsg(gem)); + return gem->errmsg_backup; +} diff --git a/hawk/lib/hawk-cmn.h b/hawk/lib/hawk-cmn.h index bcac8309..12e49f00 100644 --- a/hawk/lib/hawk-cmn.h +++ b/hawk/lib/hawk-cmn.h @@ -1123,6 +1123,7 @@ struct hawk_gem_t #else hawk_bch_t xerrmsg[HAWK_ERRMSG_CAPA * 2]; #endif + hawk_ooch_t errmsg_backup[HAWK_ERRMSG_CAPA]; }; enum hawk_log_mask_t diff --git a/hawk/lib/hawk-gem.h b/hawk/lib/hawk-gem.h index aa79fa42..ed24cdc5 100644 --- a/hawk/lib/hawk-gem.h +++ b/hawk/lib/hawk-gem.h @@ -461,6 +461,12 @@ HAWK_EXPORT const hawk_uch_t* hawk_gem_geterrumsg ( hawk_gem_t* gem ); +#if defined(HAWK_OOCH_IS_BCH) +# define hawk_gem_geterrmsg hawk_gem_geterrbmsg +#else +# define hawk_gem_geterrmsg hawk_gem_geterrumsg +#endif + HAWK_EXPORT void hawk_gem_seterrinf ( hawk_gem_t* gem, const hawk_errinf_t* errinf @@ -511,6 +517,10 @@ HAWK_EXPORT void hawk_gem_seterruvfmt ( va_list ap ); +HAWK_EXPORT const hawk_ooch_t* hawk_gem_backuperrmsg ( + hawk_gem_t* gem +); + HAWK_EXPORT int hawk_gem_buildrex ( hawk_gem_t* gem, const hawk_ooch_t* ptn, diff --git a/hawk/lib/hawk-prv.h b/hawk/lib/hawk-prv.h index 186aedb5..cdbb7c2d 100644 --- a/hawk/lib/hawk-prv.h +++ b/hawk/lib/hawk-prv.h @@ -336,15 +336,7 @@ struct hawk_t } tmp; /* housekeeping */ - //hawk_oow_t errmsg_len; /* used by errbfmt() and errufmt(). don't rely on this. some other funtions don't set this properly */ hawk_ooch_t errmsg_backup[HAWK_ERRMSG_CAPA]; -#if 0 -#if defined(HAWK_OOCH_IS_BCH) - hawk_uch_t xerrmsg[HAWK_ERRMSG_CAPA]; -#else - hawk_bch_t xerrmsg[HAWK_ERRMSG_CAPA * 2]; -#endif -#endif struct { @@ -546,16 +538,7 @@ struct hawk_rtx_t hawk_oow_t capa; } forin; /* keys for for (x in y) ... */ - //hawk_oow_t errmsg_len; /* used by errbfmt() and errufmt(). don't rely on this. some other funtions don't set this properly */ hawk_ooch_t errmsg_backup[HAWK_ERRMSG_CAPA]; -#if 0 -#if defined(HAWK_OOCH_IS_BCH) - hawk_uch_t xerrmsg[HAWK_ERRMSG_CAPA]; -#else - hawk_bch_t xerrmsg[HAWK_ERRMSG_CAPA * 2]; -#endif -#endif - hawk_rtx_ecb_t* ecb; }; diff --git a/hawk/lib/hawk-sed.h b/hawk/lib/hawk-sed.h index 31f78b8f..280a7111 100644 --- a/hawk/lib/hawk-sed.h +++ b/hawk/lib/hawk-sed.h @@ -371,12 +371,14 @@ typedef enum hawk_sed_space_t hawk_sed_space_t; */ enum hawk_sed_iostd_type_t { - HAWK_SED_IOSTD_NULL, /**< null resource type */ - HAWK_SED_IOSTD_FILE, /**< file */ + HAWK_SED_IOSTD_NULL, /**< null resource type */ + HAWK_SED_IOSTD_FILE, /**< file */ HAWK_SED_IOSTD_FILEB, /**< file */ HAWK_SED_IOSTD_FILEU, /**< file */ - HAWK_SED_IOSTD_STR, /**< string */ - HAWK_SED_IOSTD_SIO /**< sio */ + HAWK_SED_IOSTD_OOCS, /**< string */ + HAWK_SED_IOSTD_BCS, + HAWK_SED_IOSTD_UCS, + HAWK_SED_IOSTD_SIO /**< sio */ }; typedef enum hawk_sed_iostd_type_t hawk_sed_iostd_type_t; @@ -429,7 +431,9 @@ struct hawk_sed_iostd_t * the ptr field with hawk_sed_freemem() once you're done with it * to avoid memory leaks. */ - hawk_oocs_t str; + hawk_oocs_t oocs; + hawk_bcs_t bcs; + hawk_ucs_t ucs; /** pre-opened sio stream */ hawk_sio_t* sio; @@ -488,10 +492,12 @@ static HAWK_INLINE hawk_gem_t* hawk_sed_getgem (hawk_sed_t* sed) { return &((haw * hawk_sed_open(). */ static HAWK_INLINE hawk_mmgr_t* hawk_sed_getmmgr (hawk_sed_t* sed) { return ((hawk_sed_alt_t*)sed)->_gem.mmgr; } +static HAWK_INLINE hawk_cmgr_t* hawk_sed_getcmgr (hawk_sed_t* sed) { return ((hawk_sed_alt_t*)sed)->_gem.cmgr; } #else #define hawk_sed_getxtn(sed) ((void*)((hawk_uint8_t*)sed + ((hawk_sed_alt_t*)sed)->_instsize)) #define hawk_sed_getgem(sed) (&((hawk_sed_alt_t*)(sed))->_gem) #define hawk_sed_getmmgr(sed) (((hawk_sed_alt_t*)(sed))->_gem.mmgr) +#define hawk_sed_getcmgr(sed) (((hawk_sed_alt_t*)(sed))->_gem.cmgr) #endif /* HAWK_HAVE_INLINE */ @@ -535,30 +541,27 @@ HAWK_EXPORT int hawk_sed_setopt ( * \return error number */ -#if defined(HAWK_HAVE_INLINE) -static HAWK_INLINE hawk_errnum_t hawk_sed_geterrnum (hawk_sed_t* sed) { return hawk_gem_geterrnum(hawk_sed_getgem(sed)); } -static HAWK_INLINE const hawk_loc_t* hawk_sed_geterrloc (hawk_sed_t* sed) { return hawk_gem_geterrloc(hawk_sed_getgem(sed)); } -static HAWK_INLINE const hawk_bch_t* hawk_sed_geterrbmsg (hawk_sed_t* sed) { return hawk_gem_geterrbmsg(hawk_sed_getgem(sed)); } -static HAWK_INLINE const hawk_uch_t* hawk_sed_geterrumsg (hawk_sed_t* sed) { return hawk_gem_geterrumsg(hawk_sed_getgem(sed)); } -#else -#define hawk_sed_geterrnum(sed) hawk_gem_geterrnum(hawk_sed_getgem(sed)) -#define hawk_sed_geterrloc(sed) hawk_gem_geterrloc(hawk_sed_getgem(sed)) -#define hawk_sed_geterrbmsg(sed) hawk_gem_geterrbmsg(hawk_sed_getgem(sed)) -#define hawk_sed_geterrumsg(sed) hawk_gem_geterrumsg(hawk_sed_getgem(sed)) -#endif - - /** * The hawk_sed_geterror() function gets an error number, an error location, * and an error message. The information is set to the memory area pointed * to by each parameter. */ -HAWK_EXPORT void hawk_sed_geterror ( - hawk_sed_t* sed, /**< stream editor */ - hawk_errnum_t* errnum, /**< error number */ - const hawk_ooch_t** errmsg, /**< error message */ - hawk_loc_t* errloc /**< error location */ -); +#if defined(HAWK_HAVE_INLINE) +static HAWK_INLINE hawk_errnum_t hawk_sed_geterrnum (hawk_sed_t* sed) { return hawk_gem_geterrnum(hawk_sed_getgem(sed)); } +static HAWK_INLINE const hawk_loc_t* hawk_sed_geterrloc (hawk_sed_t* sed) { return hawk_gem_geterrloc(hawk_sed_getgem(sed)); } +static HAWK_INLINE const hawk_bch_t* hawk_sed_geterrbmsg (hawk_sed_t* sed) { return hawk_gem_geterrbmsg(hawk_sed_getgem(sed)); } +static HAWK_INLINE const hawk_uch_t* hawk_sed_geterrumsg (hawk_sed_t* sed) { return hawk_gem_geterrumsg(hawk_sed_getgem(sed)); } +static HAWK_INLINE void hawk_sed_geterrinf (hawk_sed_t* sed, hawk_errinf_t* errinf) { return hawk_gem_geterrinf(hawk_sed_getgem(sed), errinf); } +static HAWK_INLINE void hawk_sed_geterror (hawk_sed_t* sed, hawk_errnum_t* errnum, const hawk_ooch_t** errmsg, hawk_loc_t* errloc) { return hawk_gem_geterror(hawk_sed_getgem(sed), errnum, errmsg, errloc); } +#else +#define hawk_sed_geterrnum(sed) hawk_gem_geterrnum(hawk_sed_getgem(sed)) +#define hawk_sed_geterrloc(sed) hawk_gem_geterrloc(hawk_sed_getgem(sed)) +#define hawk_sed_geterrbmsg(sed) hawk_gem_geterrbmsg(hawk_sed_getgem(sed)) +#define hawk_sed_geterrumsg(sed) hawk_gem_geterrumsg(hawk_sed_getgem(sed)) +#define hawk_sed_geterrinf(sed, errinf) (hawk_gem_geterrinf(hawk_sed_getgem(sed), errinf)) +#define hawk_sed_geterror(sed, errnum, errmsg, errloc) (hawk_gem_geterror(hawk_sed_getgem(sed), errnum, errmsg, errloc)) +#endif + /** * The hawk_sed_seterrnum() function sets the error information omitting @@ -568,12 +571,33 @@ HAWK_EXPORT void hawk_sed_geterror ( */ #if defined(HAWK_HAVE_INLINE) static HAWK_INLINE void hawk_sed_seterrnum (hawk_sed_t* sed, const hawk_loc_t* errloc, hawk_errnum_t errnum) { hawk_gem_seterrnum (hawk_sed_getgem(sed), errloc, errnum); } +static HAWK_INLINE void hawk_sed_seterrinf (hawk_sed_t* sed, const hawk_errinf_t* errinf) { hawk_gem_seterrinf (hawk_sed_getgem(sed), errinf); } static HAWK_INLINE void hawk_sed_seterror (hawk_sed_t* sed, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_oocs_t* errarg) { hawk_gem_seterror(hawk_sed_getgem(sed), errloc, errnum, errarg); } +static HAWK_INLINE const hawk_ooch_t* hawk_sed_backuperrmsg (hawk_sed_t* sed) { return hawk_gem_backuperrmsg(hawk_sed_getgem(sed)); } #else #define hawk_sed_seterrnum(sed, errloc, errnum) hawk_gem_seterrnum(hawk_sed_getgem(sed), errloc, errnum) -#define hawk_set_seterror(sed, errloc, errnum, errarg) hawk_sed_seterror(hawk_sed_getgem(sed), errloc, errnum, errarg) +#define hawk_sed_seterrinf(sed, errinf) hawk_gem_seterrinf(hawk_sed_getgem(sed), errinf) +#define hawk_sed_seterror(sed, errloc, errnum, errarg) hawk_gem_seterror(hawk_sed_getgem(sed), errloc, errnum, errarg) +#define hawk_sed_backuperrmsg(sed) hawk_gem_backuperrmsg(hawk_sed_getgem(sed)) #endif + +HAWK_EXPORT void hawk_sed_seterrbfmt ( + hawk_sed_t* sed, + const hawk_loc_t* errloc, + hawk_errnum_t errnum, + const hawk_bch_t* fmt, + ... +); + +HAWK_EXPORT void hawk_sed_seterrufmt ( + hawk_sed_t* sed, + const hawk_loc_t* errloc, + hawk_errnum_t errnum, + const hawk_uch_t* fmt, + ... +); + /** * The hawk_sed_popecb() function pops an sed event callback set * and returns the pointer to it. If no callback set can be popped, @@ -642,9 +666,20 @@ HAWK_EXPORT const hawk_ooch_t* hawk_sed_getcompid ( * If this function fails, the location set in the command * may be wrong. */ -HAWK_EXPORT const hawk_ooch_t* hawk_sed_setcompid ( +#if defined(HAWK_OOCH_IS_BCH) +#define hawk_sed_setcompid(sed, id) hawk_sed_setcompidwithbcstr(sed, id) +#else +#define hawk_sed_setcompid(sed, id) hawk_sed_setcompidwithucstr(sed, id) +#endif + +HAWK_EXPORT const hawk_ooch_t* hawk_sed_setcompidwithbcstr ( hawk_sed_t* sed, - const hawk_ooch_t* id + const hawk_bch_t* id +); + +HAWK_EXPORT const hawk_ooch_t* hawk_sed_setcompidwithucstr ( + hawk_sed_t* sed, + const hawk_uch_t* id ); /** @@ -782,21 +817,21 @@ HAWK_EXPORT int hawk_sed_compstdfileu ( ); /** - * The hawk_sed_compstdstr() function compiles a sed script stored + * The hawk_sed_compstdoocstr() function compiles a sed script stored * in a null-terminated string pointed to by \a script. * \return 0 on success, -1 on failure */ -HAWK_EXPORT int hawk_sed_compstdstr ( +HAWK_EXPORT int hawk_sed_compstdoocstr ( hawk_sed_t* sed, const hawk_ooch_t* script ); /** - * The hawk_sed_compstdxstr() function compiles a sed script of the + * The hawk_sed_compstdoocs() function compiles a sed script of the * length \a script->len pointed to by \a script->ptr. * \return 0 on success, -1 on failure */ -HAWK_EXPORT int hawk_sed_compstdxstr ( +HAWK_EXPORT int hawk_sed_compstdoocs ( hawk_sed_t* sed, const hawk_oocs_t* script ); diff --git a/hawk/lib/hawk-std.h b/hawk/lib/hawk-std.h index b8a82367..72bba2ce 100644 --- a/hawk/lib/hawk-std.h +++ b/hawk/lib/hawk-std.h @@ -159,7 +159,7 @@ HAWK_EXPORT hawk_t* hawk_openstdwithmmgr ( * in[0].u.str.len = hawk_count_oocstr(in.u.str.ptr); * in[1].type = HAWK_PARSESTD_NULL; * out.type = HAWK_PARSESTD_OOCS; - * n = hawk_parsestd (hawk, in, &out); + * n = hawk_parsestd(hawk, in, &out); * if (n >= 0) * { * hawk_printf (HAWK_T("%s\n"), out.u.str.ptr); diff --git a/hawk/lib/hawk.h b/hawk/lib/hawk.h index d3fca711..0a8d8df4 100644 --- a/hawk/lib/hawk.h +++ b/hawk/lib/hawk.h @@ -1589,23 +1589,12 @@ HAWK_EXPORT hawk_errstr_t hawk_geterrstr ( * last error has occurred. */ -#if defined(HAWK_HAVE_INLINE) -static HAWK_INLINE hawk_errnum_t hawk_geterrnum (hawk_t* hawk) { return ((hawk_alt_t*)hawk)->_gem.errnum; } -static HAWK_INLINE const hawk_loc_t* hawk_geterrloc (hawk_t* hawk) { return hawk_gem_geterrloc(hawk_getgem(hawk)); } -#else -# define hawk_geterrnum(hawk) (((hawk_alt_t*)(hawk))->_gem.errnum) -# define hawk_geterrloc(hawk) (hawk_gem_geterrloc(hawk_getgem(hawk))) -#endif - /** * The hawk_geterrbmsg() function returns the error message describing * the last error occurred. * * \return error message */ -HAWK_EXPORT const hawk_bch_t* hawk_geterrbmsg ( - hawk_t* hawk /**< hawk */ -); /** * The hawk_geterrumsg() function returns the error message describing @@ -1613,10 +1602,25 @@ HAWK_EXPORT const hawk_bch_t* hawk_geterrbmsg ( * * \return error message */ -HAWK_EXPORT const hawk_uch_t* hawk_geterrumsg ( - hawk_t* hawk /**< hawk */ -); +/** + * The hawk_geterrinf() function copies error information into memory + * pointed to by \a errinf from \a hawk. + */ + +#if defined(HAWK_HAVE_INLINE) +static HAWK_INLINE hawk_errnum_t hawk_geterrnum (hawk_t* hawk) { return ((hawk_alt_t*)hawk)->_gem.errnum; } +static HAWK_INLINE const hawk_loc_t* hawk_geterrloc (hawk_t* hawk) { return hawk_gem_geterrloc(hawk_getgem(hawk)); } +static HAWK_INLINE const hawk_bch_t* hawk_geterrbmsg (hawk_t* hawk) { return hawk_gem_geterrbmsg(hawk_getgem(hawk)); } +static HAWK_INLINE const hawk_uch_t* hawk_geterrumsg (hawk_t* hawk) { return hawk_gem_geterrumsg(hawk_getgem(hawk)); } +static HAWK_INLINE void hawk_geterrinf (hawk_t* hawk, hawk_errinf_t* errinf) { return hawk_gem_geterrinf(hawk_getgem(hawk), errinf); } +#else +#define hawk_geterrnum(hawk) (((hawk_alt_t*)(hawk))->_gem.errnum) +#define hawk_geterrloc(hawk) (hawk_gem_geterrloc(hawk_getgem(hawk))) +#define hawk_geterrbmsg(hawk) (hawk_gem_geterrbmsg(hawk_getgem(hawk))) +#define hawk_geterrumsg(hawk) (hawk_gem_geterrumsg(hawk_getgem(hawk))) +#define hawk_geterrinf(hawk, errinf) (hawk_gem_geterrinf(hawk_getgem(hawk), errinf)) +#endif #if defined(HAWK_OOCH_IS_BCH) # define hawk_geterrmsg hawk_geterrbmsg @@ -1624,33 +1628,33 @@ HAWK_EXPORT const hawk_uch_t* hawk_geterrumsg ( # define hawk_geterrmsg hawk_geterrumsg #endif - -HAWK_EXPORT const hawk_ooch_t* hawk_backuperrmsg ( - hawk_t* hawk /**< hawk */ -); - - -/** - * The hawk_geterrinf() function copies error information into memory - * pointed to by \a errinf from \a hawk. - */ -HAWK_EXPORT void hawk_geterrinf ( - hawk_t* hawk, /**< hawk */ - hawk_errinf_t* errinf /**< error information buffer */ -); - /** * The hawk_seterrnum() function sets the error information omitting * error location. You must pass a non-NULL for \a errarg if the specified * error number \a errnum requires one or more arguments to format an * error message. */ + +/** + * The hawk_seterrinf() function sets the error information. This function + * may be useful if you want to set a custom error message rather than letting + * it automatically formatted. + */ #if defined(HAWK_HAVE_INLINE) static HAWK_INLINE void hawk_seterrnum (hawk_t* hawk, const hawk_loc_t* errloc, hawk_errnum_t errnum) { hawk_gem_seterrnum (hawk_getgem(hawk), errloc, errnum); } +static HAWK_INLINE void hawk_seterrinf (hawk_t* hawk, const hawk_errinf_t* errinf) { hawk_gem_seterrinf (hawk_getgem(hawk), errinf); } +static HAWK_INLINE void hawk_seterror (hawk_t* hawk, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_oocs_t* errarg) { hawk_gem_seterror(hawk_getgem(hawk), errloc, errnum, errarg); } +static HAWK_INLINE const hawk_ooch_t* hawk_backuperrmsg (hawk_t* hawk) { return hawk_gem_backuperrmsg(hawk_getgem(hawk)); } +static HAWK_INLINE void hawk_geterror (hawk_t* hawk, hawk_errnum_t* errnum, const hawk_ooch_t** errmsg, hawk_loc_t* errloc) { return hawk_gem_geterror(hawk_getgem(hawk), errnum, errmsg, errloc); } #else #define hawk_seterrnum(hawk, errloc, errnum) hawk_gem_seterrnum(hawk_getgem(hawk), errloc, errnum) +#define hawk_seterrinf(hawk, errinf) hawk_gem_seterrinf(hawk_getgem(hawk), errinf) +#define hawk_seterror(hawk, errloc, errnum, errarg) hawk_gem_seterror(hawk_getgem(hawk), errloc, errnum, errarg) +#define hawk_backuperrmsg(hawk) hawk_gem_backuperrmsg(hawk_getgem(hawk)) +#define hawk_geterror(hawk, errnum, errmsg, errloc) (hawk_gem_geterror(hawk_getgem(hawk), errnum, errmsg, errloc)) #endif + HAWK_EXPORT void hawk_seterrbfmt ( hawk_t* hawk, const hawk_loc_t* errloc, @@ -1691,17 +1695,6 @@ HAWK_EXPORT void hawk_seterruvfmt ( # define hawk_seterrvfmt hawk_seterrbvfmt #endif -/** - * The hawk_seterrinf() function sets the error information. This function - * may be useful if you want to set a custom error message rather than letting - * it automatically formatted. - */ -HAWK_EXPORT void hawk_seterrinf ( - hawk_t* hawk, /**< hawk */ - const hawk_errinf_t* errinf /**< error information */ -); - - HAWK_EXPORT void hawk_seterror ( hawk_t* hawk, const hawk_loc_t* errloc, @@ -1709,16 +1702,6 @@ HAWK_EXPORT void hawk_seterror ( const hawk_oocs_t* errarg ); -/** - * The hawk_geterror() function gets error information via parameters. - */ -HAWK_EXPORT void hawk_geterror ( - hawk_t* hawk, /**< hawk */ - hawk_errnum_t* errnum, /**< error number */ - const hawk_ooch_t** errmsg, /**< error message */ - hawk_loc_t* errloc /**< error location */ -); - /** * The hawk_getopt() function gets the value of an option * specified by \a id into the buffer pointed to by \a value. @@ -2578,50 +2561,23 @@ HAWK_EXPORT hawk_htb_t* hawk_rtx_getnvmap ( * occurred during runtime. The * \return error location */ -#if defined(HAWK_HAVE_INLINE) -static HAWK_INLINE hawk_errnum_t hawk_rtx_geterrnum (hawk_rtx_t* rtx) { return ((hawk_rtx_alt_t*)rtx)->_gem.errnum; } -static HAWK_INLINE const hawk_loc_t* hawk_rtx_geterrloc (hawk_rtx_t* rtx) { return hawk_gem_geterrloc(hawk_rtx_getgem(rtx)); } -#else -# define hawk_rtx_geterrnum(rtx) (((hawk_rtx_alt_t*)(rtx))->_gem.errnum) -# define hawk_rtx_geterrloc(rtx) (hawk_gem_geterrloc(hawk_rtx_getgem(rtx))) -#endif /** * The hawk_rtx_geterrbmsg() function gets the string describing the last * error occurred during runtime. * \return error message */ -HAWK_EXPORT const hawk_bch_t* hawk_rtx_geterrbmsg ( - hawk_rtx_t* rtx /**< runtime context */ -); /** * The hawk_rtx_geterrumsg() function gets the string describing the last * error occurred during runtime. * \return error message */ -HAWK_EXPORT const hawk_uch_t* hawk_rtx_geterrumsg ( - hawk_rtx_t* rtx /**< runtime context */ -); - -#if defined(HAWK_OOCH_IS_BCH) -# define hawk_rtx_geterrmsg hawk_rtx_geterrbmsg -#else -# define hawk_rtx_geterrmsg hawk_rtx_geterrumsg -#endif - -HAWK_EXPORT const hawk_ooch_t* hawk_rtx_backuperrmsg ( - hawk_rtx_t* rtx /**< runtime context */ -); /** * The hawk_rtx_geterrinf() function copies error information into memory * pointed to by \a errinf from a runtime context \a rtx. */ -HAWK_EXPORT void hawk_rtx_geterrinf ( - hawk_rtx_t* rtx, /**< runtime context */ - hawk_errinf_t* errinf /**< error information */ -); /** * The hawk_rtx_geterror() function retrieves error information from a @@ -2629,33 +2585,44 @@ HAWK_EXPORT void hawk_rtx_geterrinf ( * to by \a errnum; the error message pointer into memory pointed to by * \a errmsg; the error line into memory pointed to by \a errlin. */ -HAWK_EXPORT void hawk_rtx_geterror ( - hawk_rtx_t* rtx, /**< runtime context */ - hawk_errnum_t* errnum, /**< error number */ - const hawk_ooch_t** errmsg, /**< error message */ - hawk_loc_t* errloc /**< error location */ -); #if defined(HAWK_HAVE_INLINE) -static HAWK_INLINE void hawk_rtx_seterrnum (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnum_t errnum) { hawk_gem_seterrnum (hawk_rtx_getgem(rtx), errloc, errnum); } +static HAWK_INLINE hawk_errnum_t hawk_rtx_geterrnum (hawk_rtx_t* rtx) { return ((hawk_rtx_alt_t*)rtx)->_gem.errnum; } +static HAWK_INLINE const hawk_loc_t* hawk_rtx_geterrloc (hawk_rtx_t* rtx) { return hawk_gem_geterrloc(hawk_rtx_getgem(rtx)); } +static HAWK_INLINE const hawk_bch_t* hawk_rtx_geterrbmsg (hawk_rtx_t* rtx) { return hawk_gem_geterrbmsg(hawk_rtx_getgem(rtx)); } +static HAWK_INLINE const hawk_uch_t* hawk_rtx_geterrumsg (hawk_rtx_t* rtx) { return hawk_gem_geterrumsg(hawk_rtx_getgem(rtx)); } +static HAWK_INLINE void hawk_rtx_geterrinf (hawk_rtx_t* rtx, hawk_errinf_t* errinf) { return hawk_gem_geterrinf(hawk_rtx_getgem(rtx), errinf); } +static HAWK_INLINE void hawk_rtx_geterror (hawk_rtx_t* rtx, hawk_errnum_t* errnum, const hawk_ooch_t** errmsg, hawk_loc_t* errloc) { return hawk_gem_geterror(hawk_rtx_getgem(rtx), errnum, errmsg, errloc); } #else -#define hawk_rtx_seterrnum(rtx, errloc, errnum) hawk_gem_seterrnum(hawk_rtx_getgem(rtx), errloc, errnum) +#define hawk_rtx_geterrnum(rtx) (((hawk_rtx_alt_t*)(rtx))->_gem.errnum) +#define hawk_rtx_geterrloc(rtx) (hawk_gem_geterrloc(hawk_rtx_getgem(rtx))) +#define hawk_rtx_geterrbmsg(rtx) (hawk_gem_geterrbmsg(hawk_rtx_getgem(rtx))) +#define hawk_rtx_geterrumsg(rtx) (hawk_gem_geterrumsg(hawk_rtx_getgem(rtx))) +#define hawk_rtx_geterrinf(rtx, errinf) (hawk_gem_geterrinf(hawk_rtx_getgem(rtx), errinf)) +#define hawk_rtx_geterror(rtx, errnum, errmsg, errloc) (hawk_gem_geterror(hawk_rtx_getgem(rtx), errnum, errmsg, errloc)) +#endif + +#if defined(HAWK_OOCH_IS_BCH) +# define hawk_rtx_geterrmsg hawk_rtx_geterrbmsg +#else +# define hawk_rtx_geterrmsg hawk_rtx_geterrumsg #endif /** * The hawk_rtx_seterrinf() function sets error information. */ -HAWK_EXPORT void hawk_rtx_seterrinf ( - hawk_rtx_t* rtx, /**< runtime context */ - const hawk_errinf_t* errinf /**< error information */ -); +#if defined(HAWK_HAVE_INLINE) +static HAWK_INLINE void hawk_rtx_seterrnum (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnum_t errnum) { hawk_gem_seterrnum (hawk_rtx_getgem(rtx), errloc, errnum); } +static HAWK_INLINE void hawk_rtx_seterrinf (hawk_rtx_t* rtx, const hawk_errinf_t* errinf) { hawk_gem_seterrinf (hawk_rtx_getgem(rtx), errinf); } +static HAWK_INLINE void hawk_rtx_seterror (hawk_rtx_t* rtx, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_oocs_t* errarg) { hawk_gem_seterror(hawk_rtx_getgem(rtx), errloc, errnum, errarg); } +static HAWK_INLINE const hawk_ooch_t* hawk_rtx_backuperrmsg (hawk_rtx_t* rtx) { return hawk_gem_backuperrmsg(hawk_rtx_getgem(rtx)); } +#else +#define hawk_rtx_seterrnum(rtx, errloc, errnum) hawk_gem_seterrnum(hawk_rtx_getgem(rtx), errloc, errnum) +#define hawk_rtx_seterrinf(rtx, errinf) hawk_gem_seterrinf(hawk_rtx_getgem(rtx), errinf) +#define hawk_rtx_seterror(rtx, errloc, errnum, errarg) hawk_gem_seterror(hawk_rtx_getgem(rtx), errloc, errnum, errarg) +#define hawk_rtx_backuperrmsg(rtx) hawk_gem_backuperrmsg(hawk_rtx_getgem(rtx)) +#endif -HAWK_EXPORT void hawk_rtx_seterror ( - hawk_rtx_t* rtx, - const hawk_loc_t* errloc, - hawk_errnum_t errnum, - const hawk_oocs_t* errarg -); HAWK_EXPORT void hawk_rtx_seterrbfmt ( hawk_rtx_t* rtx, diff --git a/hawk/lib/sed.c b/hawk/lib/sed.c index edb4f0a5..03784d39 100644 --- a/hawk/lib/sed.c +++ b/hawk/lib/sed.c @@ -37,9 +37,6 @@ static int emit_output (hawk_sed_t* sed, int skipline); #define EMPTY_REX ((void*)1) -#define ERRNUM(sed) ((sed)->_gem.errnum) -#define CLRERR(sed) hawk_sed_seterrnum(sed, HAWK_NULL, HAWK_ENOERR) - #define ADJERR_LOC(sed,l) do { (sed)->_gem.errloc = *(l); } while (0) #define SETERR1(sed,num,argp,argl,loc) \ @@ -148,6 +145,22 @@ void hawk_sed_fini (hawk_sed_t* sed) hawk_ooecs_fini (&sed->tmp.rex); } +void hawk_sed_seterrbfmt (hawk_sed_t* sed, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_bch_t* fmt, ...) +{ + va_list ap; + va_start (ap, fmt); + hawk_gem_seterrbvfmt (hawk_sed_getgem(sed), errloc, errnum, fmt, ap); + va_end (ap); +} + +void hawk_sed_seterrufmt (hawk_sed_t* sed, const hawk_loc_t* errloc, hawk_errnum_t errnum, const hawk_uch_t* fmt, ...) +{ + va_list ap; + va_start (ap, fmt); + hawk_gem_seterruvfmt (hawk_sed_getgem(sed), errloc, errnum, fmt, ap); + va_end (ap); +} + int hawk_sed_setopt (hawk_sed_t* sed, hawk_sed_opt_t id, const void* value) { switch (id) @@ -309,14 +322,8 @@ static int open_script_stream (hawk_sed_t* sed) { hawk_ooi_t n; - CLRERR (sed); - n = sed->src.fun (sed, HAWK_SED_IO_OPEN, &sed->src.arg, HAWK_NULL, 0); - if (n <= -1) - { - if (ERRNUM(sed) == HAWK_ENOERR) - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EIOIMPL); - return -1; - } + n = sed->src.fun(sed, HAWK_SED_IO_OPEN, &sed->src.arg, HAWK_NULL, 0); + if (n <= -1) return -1; sed->src.cur = sed->src.buf; sed->src.end = sed->src.buf; @@ -328,37 +335,20 @@ static int open_script_stream (hawk_sed_t* sed) return 0; } -static int close_script_stream (hawk_sed_t* sed) +static HAWK_INLINE int close_script_stream (hawk_sed_t* sed) { - hawk_ooi_t n; - - CLRERR (sed); - n = sed->src.fun (sed, HAWK_SED_IO_CLOSE, &sed->src.arg, HAWK_NULL, 0); - if (n <= -1) - { - if (ERRNUM(sed) == HAWK_ENOERR) - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EIOIMPL); - return -1; - } - - return 0; + return sed->src.fun(sed, HAWK_SED_IO_CLOSE, &sed->src.arg, HAWK_NULL, 0); } static int read_script_stream (hawk_sed_t* sed) { hawk_ooi_t n; - CLRERR (sed); n = sed->src.fun ( sed, HAWK_SED_IO_READ, &sed->src.arg, sed->src.buf, HAWK_COUNTOF(sed->src.buf) ); - if (n <= -1) - { - if (ERRNUM(sed) == HAWK_ENOERR) - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EIOIMPL); - return -1; /* error */ - } + if (n <= -1) return -1; /* error */ if (n == 0) { @@ -399,9 +389,7 @@ static int getnextsc (hawk_sed_t* sed, hawk_ooci_t* c) if (read_script_stream (sed) <= -1) return -1; } - sed->src.cc = - (sed->src.cur < sed->src.end)? - (*sed->src.cur++): HAWK_OOCI_EOF; + sed->src.cc = (sed->src.cur < sed->src.end)? (*sed->src.cur++): HAWK_OOCI_EOF; *c = sed->src.cc; return 0; @@ -1194,7 +1182,7 @@ static int get_subst (hawk_sed_t* sed, hawk_sed_cmd_t* cmd) c = CURSC (sed); CHECK_CMDIC (sed, cmd, c, goto oops); - delim = c; + delim = c; if (delim == HAWK_T('\\')) { /* backspace is an illegal delimiter */ @@ -1608,9 +1596,10 @@ static int get_command (hawk_sed_t* sed, hawk_sed_cmd_t* cmd) { hawk_ooci_t c; - c = CURSC (sed); + c = CURSC(sed); cmd->lid = sed->src.cid? ((const hawk_ooch_t*)(sed->src.cid + 1)): HAWK_NULL; cmd->loc = sed->src.loc; + switch (c) { default: @@ -1623,7 +1612,7 @@ static int get_command (hawk_sed_t* sed, hawk_sed_cmd_t* cmd) case HAWK_OOCI_EOF: case HAWK_T('\n'): hawk_sed_seterrnum (sed, &sed->src.loc, HAWK_SED_ECMDMS); - return -1; + return -1; case HAWK_T(':'): if (cmd->a1.type != HAWK_SED_ADR_NONE) @@ -1731,7 +1720,7 @@ static int get_command (hawk_sed_t* sed, hawk_sed_cmd_t* cmd) hawk_sed_seterrnum (sed, &sed->src.loc, HAWK_SED_EBSEXP); return -1; } - + NXTSC (sed, c, -1); while (IS_SPACE(c)) NXTSC (sed, c, -1); @@ -1752,7 +1741,7 @@ static int get_command (hawk_sed_t* sed, hawk_sed_cmd_t* cmd) sameline_ok: /* get_text() starts from the next line */ - if (get_text (sed, cmd) <= -1) return -1; + if (get_text(sed, cmd) <= -1) return -1; break; } @@ -1768,31 +1757,27 @@ static int get_command (hawk_sed_t* sed, hawk_sed_cmd_t* cmd) case HAWK_T('d'): case HAWK_T('D'): - case HAWK_T('p'): case HAWK_T('P'): case HAWK_T('l'): - case HAWK_T('h'): case HAWK_T('H'): case HAWK_T('g'): case HAWK_T('G'): case HAWK_T('x'): - case HAWK_T('n'): - case HAWK_T('N'): - + case HAWK_T('N'): case HAWK_T('z'): cmd->type = c; NXTSC (sed, c, -1); - if (terminate_command (sed) <= -1) return -1; + if (terminate_command(sed) <= -1) return -1; break; case HAWK_T('b'): case HAWK_T('t'): cmd->type = c; NXTSC (sed, c, -1); - if (get_branch_target (sed, cmd) <= -1) return -1; + if (get_branch_target(sed, cmd) <= -1) return -1; break; case HAWK_T('r'): @@ -1801,25 +1786,25 @@ static int get_command (hawk_sed_t* sed, hawk_sed_cmd_t* cmd) case HAWK_T('W'): cmd->type = c; NXTSC (sed, c, -1); - if (get_file (sed, &cmd->u.file) <= -1) return -1; + if (get_file(sed, &cmd->u.file) <= -1) return -1; break; case HAWK_T('s'): cmd->type = c; NXTSC (sed, c, -1); - if (get_subst (sed, cmd) <= -1) return -1; + if (get_subst(sed, cmd) <= -1) return -1; break; case HAWK_T('y'): cmd->type = c; NXTSC (sed, c, -1); - if (get_transet (sed, cmd) <= -1) return -1; + if (get_transet(sed, cmd) <= -1) return -1; break; case HAWK_T('C'): cmd->type = c; NXTSC (sed, c, -1); - if (get_cut (sed, cmd) <= -1) return -1; + if (get_cut(sed, cmd) <= -1) return -1; break; } @@ -1835,7 +1820,7 @@ int hawk_sed_comp (hawk_sed_t* sed, hawk_sed_io_impl_t inf) if (inf == HAWK_NULL) { hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINVAL); - return -1; + return -1; } /* free all the commands previously compiled */ @@ -1998,11 +1983,12 @@ int hawk_sed_comp (hawk_sed_t* sed, hawk_sed_io_impl_t inf) while (IS_SPACE(c)) NXTSC_GOTO (sed, c, oops); } - - n = get_command (sed, cmd); + + + n = get_command(sed, cmd); if (n <= -1) goto oops; - c = CURSC (sed); + c = CURSC(sed); /* cmd's end of life */ cmd = HAWK_NULL; @@ -2013,7 +1999,7 @@ int hawk_sed_comp (hawk_sed_t* sed, hawk_sed_io_impl_t inf) { /* the number of commands in the block has * reaches the maximum. add a new command block */ - if (add_command_block (sed) <= -1) goto oops; + if (add_command_block(sed) <= -1) goto oops; } } @@ -2041,24 +2027,17 @@ static int read_char (hawk_sed_t* sed, hawk_ooch_t* c) { if (sed->e.in.pos >= sed->e.in.len) { - CLRERR (sed); n = sed->e.in.fun ( sed, HAWK_SED_IO_READ, &sed->e.in.arg, sed->e.in.buf, HAWK_COUNTOF(sed->e.in.buf) ); - if (n <= -1) - { - if (ERRNUM(sed) == HAWK_ENOERR) - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EIOIMPL); - return -1; - } - + if (n <= -1) return -1; if (n == 0) return 0; /* end of file */ - + sed->e.in.len = n; sed->e.in.pos = 0; } - + *c = sed->e.in.buf[sed->e.in.pos++]; return 1; } @@ -2072,7 +2051,7 @@ static int read_char (hawk_sed_t* sed, hawk_ooch_t* c) { HAWK_ASSERT (sed->e.in.xbuf_len == -1); return 0; - } + } } static int read_line (hawk_sed_t* sed, int append) @@ -2125,26 +2104,12 @@ static int flush (hawk_sed_t* sed) while (sed->e.out.len > 0) { - CLRERR (sed); - n = sed->e.out.fun ( sed, HAWK_SED_IO_WRITE, &sed->e.out.arg, &sed->e.out.buf[pos], sed->e.out.len); - if (n <= -1) - { - if (ERRNUM(sed) == HAWK_ENOERR) - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EIOIMPL); - return -1; - } - - if (n == 0) - { - /* reached the end of file - this is also an error */ - if (ERRNUM(sed) == HAWK_ENOERR) - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EIOIMPL); - return -1; - } + if (n <= -1) return -1; + if (n == 0) return -1; /* reached the end of file - this is also an error */ pos += n; sed->e.out.len -= n; @@ -2356,31 +2321,23 @@ static int write_str_to_file ( ap = HAWK_MAP_VPTR(pair); if (ap->handle == HAWK_NULL) { - CLRERR (sed); ap->path = path; n = sed->e.out.fun(sed, HAWK_SED_IO_OPEN, ap, HAWK_NULL, 0); if (n <= -1) { - if (ERRNUM(sed) == HAWK_ENOERR) - SETERR1 (sed, HAWK_SED_EIOFIL, path, plen, &cmd->loc); - else - ADJERR_LOC (sed, &cmd->loc); + ADJERR_LOC (sed, &cmd->loc); return -1; } } while (len > 0) { - CLRERR (sed); n = sed->e.out.fun(sed, HAWK_SED_IO_WRITE, ap, (hawk_ooch_t*)str, len); if (n <= -1) { sed->e.out.fun (sed, HAWK_SED_IO_CLOSE, ap, HAWK_NULL, 0); ap->handle = HAWK_NULL; - if (ERRNUM(sed) == HAWK_ENOERR) - SETERR1 (sed, HAWK_SED_EIOFIL, path, plen, &cmd->loc); - else - ADJERR_LOC (sed, &cmd->loc); + ADJERR_LOC (sed, &cmd->loc); return -1; } @@ -2412,28 +2369,21 @@ static int write_file (hawk_sed_t* sed, hawk_sed_cmd_t* cmd, int first_line) arg.handle = HAWK_NULL; arg.path = cmd->u.file.ptr; - CLRERR (sed); n = sed->e.in.fun(sed, HAWK_SED_IO_OPEN, &arg, HAWK_NULL, 0); if (n <= -1) { - /*if (ERRNUM(sed) != HAWK_ENOERR) - * hawk_sed_seterrnum (sed, &cmd->loc, HAWK_EIOIMPL); - *return -1;*/ + /*return -1;*/ /* it is ok if it is not able to open a file */ return 0; } while (1) { - CLRERR (sed); n = sed->e.in.fun(sed, HAWK_SED_IO_READ, &arg, buf, HAWK_COUNTOF(buf)); if (n <= -1) { sed->e.in.fun(sed, HAWK_SED_IO_CLOSE, &arg, HAWK_NULL, 0); - if (ERRNUM(sed) == HAWK_ENOERR) - SETERR1 (sed, HAWK_SED_EIOFIL, cmd->u.file.ptr, cmd->u.file.len, &cmd->loc); - else - ADJERR_LOC (sed, &cmd->loc); + ADJERR_LOC (sed, &cmd->loc); return -1; } if (n == 0) break; @@ -3706,25 +3656,19 @@ int hawk_sed_exec (hawk_sed_t* sed, hawk_sed_io_impl_t inf, hawk_sed_io_impl_t o return -1; } - CLRERR (sed); sed->e.in.arg.path = HAWK_NULL; n = sed->e.in.fun(sed, HAWK_SED_IO_OPEN, &sed->e.in.arg, HAWK_NULL, 0); if (n <= -1) { ret = -1; - if (ERRNUM(sed) == HAWK_ENOERR) - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EIOIMPL); goto done3; } - - CLRERR (sed); + sed->e.out.arg.path = HAWK_NULL; n = sed->e.out.fun(sed, HAWK_SED_IO_OPEN, &sed->e.out.arg, HAWK_NULL, 0); if (n <= -1) { ret = -1; - if (ERRNUM(sed) == HAWK_ENOERR) - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EIOIMPL); goto done2; } @@ -3822,6 +3766,7 @@ const hawk_ooch_t* hawk_sed_getcompid (hawk_sed_t* sed) return sed->src.cid? ((const hawk_ooch_t*)(sed->src.cid + 1)): HAWK_NULL; } +#if 0 const hawk_ooch_t* hawk_sed_setcompid (hawk_sed_t* sed, const hawk_ooch_t* id) { hawk_sed_cid_t* cid; @@ -3853,6 +3798,93 @@ const hawk_ooch_t* hawk_sed_setcompid (hawk_sed_t* sed, const hawk_ooch_t* id) sed->src.cid = cid; return (const hawk_ooch_t*)(cid + 1); } +#endif + +const hawk_ooch_t* hawk_sed_setcompidwithbcstr (hawk_sed_t* sed, const hawk_bch_t* id) +{ + hawk_sed_cid_t* cid; + hawk_oow_t len; +#if !defined(HAWK_OOCH_IS_BCH) + hawk_oow_t tmplen; +#endif + + if (sed->src.cid == (hawk_sed_cid_t*)&sed->src.unknown_cid) + { + /* if an error has occurred in a previously, you can't set it + * any more */ + return (const hawk_ooch_t*)(sed->src.cid + 1); + } + + if (id == HAWK_NULL) id = HAWK_BT(""); + +#if defined(HAWK_OOCH_IS_BCH) + len = hawk_count_oocstr(id); +#else + hawk_conv_bcstr_to_ucstr_with_cmgr(id, &tmplen, HAWK_NULL, &len, hawk_sed_getcmgr(sed), 1); +#endif + cid = hawk_sed_allocmem(sed, HAWK_SIZEOF(*cid) + ((len + 1) * HAWK_SIZEOF(*id))); + if (cid == HAWK_NULL) + { + /* mark that an error has occurred */ + sed->src.unknown_cid.buf[0] = HAWK_T('\0'); + cid = (hawk_sed_cid_t*)&sed->src.unknown_cid; + } + else + { +#if defined(HAWK_OOCH_IS_BCH) + hawk_copy_oocstr_unlimited ((hawk_ooch_t*)(cid + 1), id); +#else + hawk_conv_bcstr_to_ucstr_with_cmgr(id, &tmplen, (hawk_ooch_t*)(cid + 1), &len, hawk_sed_getcmgr(sed), 1); +#endif + } + + cid->next = sed->src.cid; + sed->src.cid = cid; + return (const hawk_ooch_t*)(cid + 1); +} + +const hawk_ooch_t* hawk_sed_setcompidwithucstr (hawk_sed_t* sed, const hawk_uch_t* id) +{ + hawk_sed_cid_t* cid; + hawk_oow_t len; +#if defined(HAWK_OOCH_IS_BCH) + hawk_oow_t tmplen; +#endif + + if (sed->src.cid == (hawk_sed_cid_t*)&sed->src.unknown_cid) + { + /* if an error has occurred in a previously, you can't set it + * any more */ + return (const hawk_ooch_t*)(sed->src.cid + 1); + } + + if (id == HAWK_NULL) id = HAWK_UT(""); + +#if defined(HAWK_OOCH_IS_BCH) + hawk_conv_ucstr_to_bcstr_with_cmgr(id, &tmplen, HAWK_NULL, &len, hawk_sed_getcmgr(sed)); +#else + len = hawk_count_oocstr(id); +#endif + cid = hawk_sed_allocmem(sed, HAWK_SIZEOF(*cid) + ((len + 1) * HAWK_SIZEOF(hawk_ooch_t))); + if (cid == HAWK_NULL) + { + /* mark that an error has occurred */ + sed->src.unknown_cid.buf[0] = HAWK_T('\0'); + cid = (hawk_sed_cid_t*)&sed->src.unknown_cid; + } + else + { +#if defined(HAWK_OOCH_IS_BCH) + hawk_conv_ucstr_to_bcstr_with_cmgr(id, &tmplen, (hawk_ooch_t*)(cid + 1), &len, hawk_sed_getcmgr(sed)); +#else + hawk_copy_oocstr_unlimited ((hawk_ooch_t*)(cid + 1), id); +#endif + } + + cid->next = sed->src.cid; + sed->src.cid = cid; + return (const hawk_ooch_t*)(cid + 1); +} hawk_oow_t hawk_sed_getlinenum (hawk_sed_t* sed) { diff --git a/hawk/lib/std-sed.c b/hawk/lib/std-sed.c index d83e3dd8..ae6bce5d 100644 --- a/hawk/lib/std-sed.c +++ b/hawk/lib/std-sed.c @@ -33,14 +33,18 @@ struct xtn_in_t { hawk_sed_iostd_t* ptr; hawk_sed_iostd_t* cur; - hawk_oow_t mempos; + hawk_oow_t mempos; }; typedef struct xtn_out_t xtn_out_t; struct xtn_out_t { hawk_sed_iostd_t* ptr; - hawk_ooecs_t* memstr; + struct + { + hawk_becs_t* be; + hawk_uecs_t* ue; + } memstr; }; typedef struct xtn_t xtn_t; @@ -133,7 +137,7 @@ static int verify_iostd_in (hawk_sed_t* sed, hawk_sed_iostd_t in[]) { /* if 'in' is specified, it must contains at least one * valid entry */ - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINVAL); + hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_EINVAL, "no input handler provided"); return -1; } @@ -142,10 +146,12 @@ static int verify_iostd_in (hawk_sed_t* sed, hawk_sed_iostd_t in[]) if (in[i].type != HAWK_SED_IOSTD_FILE && in[i].type != HAWK_SED_IOSTD_FILEB && in[i].type != HAWK_SED_IOSTD_FILEU && - in[i].type != HAWK_SED_IOSTD_STR && + in[i].type != HAWK_SED_IOSTD_OOCS && + in[i].type != HAWK_SED_IOSTD_BCS && + in[i].type != HAWK_SED_IOSTD_UCS && in[i].type != HAWK_SED_IOSTD_SIO) { - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINVAL); + hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_EINVAL, "unsupported input type provided - handler %d type %d", i, in[i].type); return -1; } } @@ -158,12 +164,10 @@ static hawk_sio_t* open_sio_file (hawk_sed_t* sed, const hawk_ooch_t* file, int hawk_sio_t* sio; sio = hawk_sio_open(hawk_sed_getgem(sed), 0, file, flags); - if (sio == HAWK_NULL) + if (sio == HAWK_NULL) { - hawk_oocs_t ea; - ea.ptr = (hawk_ooch_t*)file; - ea.len = hawk_count_oocstr(file); - hawk_sed_seterror (sed, HAWK_NULL, HAWK_SED_EIOFIL, &ea); + const hawk_ooch_t* bem = hawk_sed_backuperrmsg(sed); + hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "unable to open %js - %js", file, bem); } return sio; } @@ -264,6 +268,41 @@ static hawk_sio_t* open_sio_std (hawk_sed_t* sed, hawk_sio_std_t std, int flags) return sio; } +static void set_eiofil_for_iostd (hawk_sed_t* sed, hawk_sed_iostd_t* io) +{ + HAWK_ASSERT (io->type == HAWK_SED_IOSTD_FILE || io->type == HAWK_SED_IOSTD_FILEB || io->type == HAWK_SED_IOSTD_FILEU); + + if (io->u.file.path) /* file, fileb, fileu are union members. checking file.path regardless of io->type must be safe */ + { + switch (io->type) + { + #if defined(HAWK_OOCH_IS_BCH) + case HAWK_SED_IOSTD_FILE: + #endif + case HAWK_SED_IOSTD_FILEB: + hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "I/O error with file '%hs'", io->u.fileb.path); + break; + + #if defined(HAWK_OOCH_IS_UCH) + case HAWK_SED_IOSTD_FILE: + #endif + case HAWK_SED_IOSTD_FILEU: + hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "I/O error with file '%ls'", io->u.fileu.path); + break; + + default: + HAWK_ASSERT (!"should never happen - unknown file I/O type"); + hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINVAL); + break; + } + } + else + { + hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_SED_EIOFIL, "I/O error with file '%js'", &sio_std_names[HAWK_SIO_STDIN]); + } +} + + static void close_main_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_sed_iostd_t* io) { switch (io->type) @@ -274,10 +313,11 @@ static void close_main_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_sed hawk_sio_close (arg->handle); break; - case HAWK_SED_IOSTD_STR: - /* nothing to do for input. - * i don't close xtn->e.out.memstr intentionally. - * i close this in hawk_awk_execstd() + case HAWK_SED_IOSTD_OOCS: + case HAWK_SED_IOSTD_BCS: + case HAWK_SED_IOSTD_UCS: + /* for input, there is nothing to do here. + * for output, closing xtn->e.out.memstr is required. but put it to hawk_awk_execstd(). */ break; @@ -355,7 +395,9 @@ static int open_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_sed_ break; } - case HAWK_SED_IOSTD_STR: + case HAWK_SED_IOSTD_OOCS: + case HAWK_SED_IOSTD_BCS: + case HAWK_SED_IOSTD_UCS: /* don't store anything to arg->handle */ base->mempos = 0; break; @@ -370,29 +412,49 @@ static int open_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_sed_ return -1; } - if (base == &xtn->s.in) { /* reset script location */ - if (io->type == HAWK_SED_IOSTD_FILE) + switch (io->type) { - hawk_sed_setcompid ( - sed, - ((io->u.file.path == HAWK_NULL)? sio_std_names[HAWK_SIO_STDIN].ptr: io->u.file.path) - ); - } - else - { - hawk_ooch_t buf[64]; + case HAWK_SED_IOSTD_FILE: + if (io->u.fileb.path) + { + hawk_sed_setcompid (sed, io->u.file.path); + } + else + { + compid_stdin: + hawk_sed_setcompid (sed, sio_std_names[HAWK_SIO_STDIN].ptr); + } + break; - /* format an identifier to be something like M#1, S#5 */ - buf[0] = (io->type == HAWK_SED_IOSTD_STR)? HAWK_T('M'): HAWK_T('S'); - buf[1] = HAWK_T('#'); - int_to_str (io - xtn->s.in.ptr, &buf[2], HAWK_COUNTOF(buf) - 2); + case HAWK_SED_IOSTD_FILEB: + if (!io->u.fileb.path) goto compid_stdin; + hawk_sed_setcompidwithbcstr (sed, io->u.fileb.path); + break; - /* don't care about failure int_to_str() though it's not - * likely to happen */ - hawk_sed_setcompid (sed, buf); + case HAWK_SED_IOSTD_FILEU: + if (!io->u.fileu.path) goto compid_stdin; + hawk_sed_setcompid (sed, sio_std_names[HAWK_SIO_STDIN].ptr); + break; + + default: + { + hawk_ooch_t buf[64]; + + /* format an identifier to be something like M#1, S#5 */ + buf[0] = (io->type == HAWK_SED_IOSTD_OOCS || + io->type == HAWK_SED_IOSTD_BCS || + io->type == HAWK_SED_IOSTD_UCS)? HAWK_T('M'): HAWK_T('S'); + buf[1] = HAWK_T('#'); + int_to_str (io - xtn->s.in.ptr, &buf[2], HAWK_COUNTOF(buf) - 2); + + /* don't care about failure int_to_str() though it's not + * likely to happen */ + hawk_sed_setcompid (sed, buf); + break; + } } sed->src.loc.line = 1; sed->src.loc.colm = 1; @@ -487,14 +549,21 @@ static int open_output_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_sed break; } - case HAWK_SED_IOSTD_STR: + #if defined(HAWK_OOCH_IS_BCH) + case HAWK_SED_IOSTD_OOCS: + #endif + case HAWK_SED_IOSTD_BCS: + xtn->e.out.memstr.be = hawk_becs_open(hawk_sed_getgem(sed), 0, 512); + if (xtn->e.out.memstr.be == HAWK_NULL) return -1; + break; + + #if defined(HAWK_OOCH_IS_UCH) + case HAWK_SED_IOSTD_OOCS: + #endif + case HAWK_SED_IOSTD_UCS: /* don't store anything to arg->handle */ - xtn->e.out.memstr = hawk_ooecs_open(hawk_sed_getgem(sed), 0, 512); - if (xtn->e.out.memstr == HAWK_NULL) - { - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_ENOMEM); - return -1; - } + xtn->e.out.memstr.ue = hawk_uecs_open(hawk_sed_getgem(sed), 0, 512); + if (xtn->e.out.memstr.ue == HAWK_NULL) return -1; break; case HAWK_SED_IOSTD_SIO: @@ -510,6 +579,7 @@ static int open_output_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_sed return 0; } + static hawk_ooi_t read_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, hawk_ooch_t* buf, hawk_oow_t len, xtn_in_t* base) { xtn_t* xtn = GET_XTN(sed); @@ -531,41 +601,77 @@ static hawk_ooi_t read_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, ha HAWK_ASSERT (io != HAWK_NULL); - if (io->type == HAWK_SED_IOSTD_STR) + if (io->type == HAWK_SED_IOSTD_OOCS) { + iostd_oocs: n = 0; - while (base->mempos < io->u.str.len && n < len) - buf[n++] = io->u.str.ptr[base->mempos++]; + while (base->mempos < io->u.oocs.len && n < len) + buf[n++] = io->u.oocs.ptr[base->mempos++]; + } + else if (io->type == HAWK_SED_IOSTD_BCS) + { + #if defined(HAWK_OOCH_IS_BCH) + goto iostd_oocs; + #else + int m; + hawk_oow_t mbslen, wcslen; + + mbslen = io->u.bcs.len - base->mempos; + wcslen = len; + if ((m = hawk_conv_bchars_to_uchars_with_cmgr(&io->u.bcs.ptr[base->mempos], &mbslen, buf, &wcslen, hawk_sed_getcmgr(sed), 0)) <= -1 && m != -2) + { + hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EECERR); + n = -1; + } + else + { + base->mempos += mbslen; + n = wcslen; + } + #endif + } + else if (io->type == HAWK_SED_IOSTD_UCS) + { + #if defined(HAWK_OOCH_IS_UCH) + goto iostd_oocs; + #else + int m; + hawk_oow_t mbslen, wcslen; + + wcslen = io->u.ucs.len - base->mempos; + mbslen = len; + if ((m = hawk_conv_uchars_to_bchars_with_cmgr(&io->u.ucs.ptr[base->mempos], &wcslen, buf, &mbslen, hawk_sed_getcmgr(sed))) <= -1 && m != -2) + { + hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EECERR); + n = -1; + } + else + { + base->mempos += mbslen; + n = mbslen; + } + #endif + } + else + { + n = hawk_sio_getoochars(arg->handle, buf, len); + if (n <= -1) + { + set_eiofil_for_iostd (sed, io); + break; + } } - else n = hawk_sio_getoochars(arg->handle, buf, len); if (n != 0) { - if (n <= -1) + if (base == &xtn->s.in) { - if (io->type == HAWK_SED_IOSTD_FILE) - { - hawk_oocs_t ea; - if (io->u.file.path) - { - ea.ptr = io->u.file.path; - ea.len = hawk_count_oocstr(io->u.file.path); - } - else - { - ea = sio_std_names[HAWK_SIO_STDIN]; - } - hawk_sed_seterror (sed, HAWK_NULL, HAWK_SED_EIOFIL, &ea); - } - } - else if (base == &xtn->s.in) - { - xtn->s.last = buf[n-1]; + xtn->s.last = buf[n - 1]; } break; } - + /* ============================================= */ /* == end of file on the current input stream == */ /* ============================================= */ @@ -583,7 +689,7 @@ static hawk_ooi_t read_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, ha next = base->cur + 1; if (next->type == HAWK_SED_IOSTD_NULL) { - /* no next stream available - return 0 */ + /* no next stream available - return 0 */ break; } @@ -593,21 +699,7 @@ static hawk_ooi_t read_input_stream (hawk_sed_t* sed, hawk_sed_io_arg_t* arg, ha if (open_input_stream(sed, arg, next, base) <= -1) { /* failed to open the next input stream */ - if (next->type == HAWK_SED_IOSTD_FILE) - { - hawk_oocs_t ea; - if (next->u.file.path) - { - ea.ptr = next->u.file.path; - ea.len = hawk_count_oocstr (next->u.file.path); - } - else - { - ea = sio_std_names[HAWK_SIO_STDIN]; - } - hawk_sed_seterror (sed, HAWK_NULL, HAWK_SED_EIOFIL, &ea); - } - + set_eiofil_for_iostd (sed, next); n = -1; break; } @@ -832,37 +924,39 @@ static hawk_ooi_t x_out ( else { hawk_sed_iostd_t* io = xtn->e.out.ptr; - if (io->type == HAWK_SED_IOSTD_STR) + switch (io->type) { - if (len > HAWK_TYPE_MAX(hawk_ooi_t)) len = HAWK_TYPE_MAX(hawk_ooi_t); + #if defined(HAWK_OOCH_IS_BCH) + case HAWK_SED_IOSTD_OOCS: + #endif + case HAWK_SED_IOSTD_BCS: + if (len > HAWK_TYPE_MAX(hawk_ooi_t)) len = HAWK_TYPE_MAX(hawk_ooi_t); + #if defined(HAWK_OOCH_IS_BCH) + if (hawk_becs_ncat(xtn->e.out.memstr.be, dat, len) == (hawk_oow_t)-1) return -1; + #else + if (hawk_becs_ncatuchars(xtn->e.out.memstr.be, dat, len, HAWK_NULL) == (hawk_oow_t)-1) return -1; + #endif + return len; - if (hawk_ooecs_ncat(xtn->e.out.memstr, dat, len) == (hawk_oow_t)-1) - { - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_ENOMEM); - return -1; - } + #if defined(HAWK_OOCH_IS_UCH) + case HAWK_SED_IOSTD_OOCS: + #endif + case HAWK_SED_IOSTD_UCS: + if (len > HAWK_TYPE_MAX(hawk_ooi_t)) len = HAWK_TYPE_MAX(hawk_ooi_t); + #if defined(HAWK_OOCH_IS_UCH) + if (hawk_uecs_ncat(xtn->e.out.memstr.ue, dat, len) == (hawk_oow_t)-1) return -1; + #else + if (hawk_uecs_ncatbchars(xtn->e.out.memstr.ue, dat, len, HAWK_NULL, 1) == (hawk_oow_t)-1) return -1; + #endif + return len; - return len; - } - else - { - hawk_ooi_t n; - n = hawk_sio_putoochars(arg->handle, dat, len); - if (n <= -1) - { - hawk_oocs_t ea; - if (io->u.file.path) + default: { - ea.ptr = io->u.file.path; - ea.len = hawk_count_oocstr(io->u.file.path); + hawk_ooi_t n; + n = hawk_sio_putoochars(arg->handle, dat, len); + if (n <= -1) set_eiofil_for_iostd (sed, io); + return n; } - else - { - ea = sio_std_names[HAWK_SIO_STDOUT]; - } - hawk_sed_seterror (sed, HAWK_NULL, HAWK_SED_EIOFIL, &ea); - } - return n; } } } @@ -896,10 +990,15 @@ int hawk_sed_compstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_oow_t* count) if (in == HAWK_NULL) { /* it requires a valid array unlike hawk_sed_execstd(). */ - hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINVAL); + hawk_sed_seterrbfmt (sed, HAWK_NULL, HAWK_EINVAL, "no input handler provided"); + if (count) *count = 0; + return -1; + } + if (verify_iostd_in(sed, in) <= -1) + { + if (count) *count = 0; return -1; } - if (verify_iostd_in(sed, in) <= -1) return -1; HAWK_MEMSET (&xtn->s, 0, HAWK_SIZEOF(xtn->s)); xtn->s.in.ptr = in; @@ -925,7 +1024,7 @@ int hawk_sed_execstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_sed_iostd_t* if (out->type != HAWK_SED_IOSTD_FILE && out->type != HAWK_SED_IOSTD_FILEB && out->type != HAWK_SED_IOSTD_FILEU && - out->type != HAWK_SED_IOSTD_STR && + out->type != HAWK_SED_IOSTD_OOCS && out->type != HAWK_SED_IOSTD_SIO) { hawk_sed_seterrnum (sed, HAWK_NULL, HAWK_EINVAL); @@ -938,16 +1037,41 @@ int hawk_sed_execstd (hawk_sed_t* sed, hawk_sed_iostd_t in[], hawk_sed_iostd_t* xtn->e.in.cur = in; xtn->e.out.ptr = out; - n = hawk_sed_exec (sed, x_in, x_out); + n = hawk_sed_exec(sed, x_in, x_out); - if (out && out->type == HAWK_SED_IOSTD_STR) + if (out && out->type == HAWK_SED_IOSTD_OOCS) { - if (n >= 0) + switch (out->type) { - HAWK_ASSERT (xtn->e.out.memstr != HAWK_NULL); - hawk_ooecs_yield (xtn->e.out.memstr, &out->u.str, 0); + #if defined(HAWK_OOCH_IS_BCH) + case HAWK_SED_IOSTD_OOCS: + #endif + case HAWK_SED_IOSTD_BCS: + if (n >= 0) + { + HAWK_ASSERT (xtn->e.out.memstr.be != HAWK_NULL); + hawk_becs_yield (xtn->e.out.memstr.be, &out->u.bcs, 0); + } + if (xtn->e.out.memstr.be) hawk_becs_close (xtn->e.out.memstr.be); + break; + + #if defined(HAWK_OOCH_IS_UCH) + case HAWK_SED_IOSTD_OOCS: + #endif + case HAWK_SED_IOSTD_UCS: + if (n >= 0) + { + HAWK_ASSERT (xtn->e.out.memstr.ue != HAWK_NULL); + hawk_uecs_yield (xtn->e.out.memstr.ue, &out->u.ucs, 0); + } + if (xtn->e.out.memstr.ue) hawk_uecs_close (xtn->e.out.memstr.ue); + break; + + default: + /* don't handle other types */ + break; } - if (xtn->e.out.memstr) hawk_ooecs_close (xtn->e.out.memstr); + } clear_sio_names (sed); @@ -990,27 +1114,27 @@ int hawk_sed_compstdfileu (hawk_sed_t* sed, const hawk_uch_t* file, hawk_cmgr_t* return hawk_sed_compstd(sed, in, HAWK_NULL); } -int hawk_sed_compstdstr (hawk_sed_t* sed, const hawk_ooch_t* script) +int hawk_sed_compstdoocstr (hawk_sed_t* sed, const hawk_ooch_t* script) { hawk_sed_iostd_t in[2]; - in[0].type = HAWK_SED_IOSTD_STR; - in[0].u.str.ptr = (hawk_ooch_t*)script; - in[0].u.str.len = hawk_count_oocstr(script); + in[0].type = HAWK_SED_IOSTD_OOCS; + in[0].u.oocs.ptr = (hawk_ooch_t*)script; + in[0].u.oocs.len = hawk_count_oocstr(script); in[1].type = HAWK_SED_IOSTD_NULL; - return hawk_sed_compstd (sed, in, HAWK_NULL); + return hawk_sed_compstd(sed, in, HAWK_NULL); } -int hawk_sed_compstdxstr (hawk_sed_t* sed, const hawk_oocs_t* script) +int hawk_sed_compstdoocs (hawk_sed_t* sed, const hawk_oocs_t* script) { hawk_sed_iostd_t in[2]; - in[0].type = HAWK_SED_IOSTD_STR; - in[0].u.str = *script; + in[0].type = HAWK_SED_IOSTD_OOCS; + in[0].u.oocs = *script; in[1].type = HAWK_SED_IOSTD_NULL; - return hawk_sed_compstd (sed, in, HAWK_NULL); + return hawk_sed_compstd(sed, in, HAWK_NULL); } int hawk_sed_execstdfile (hawk_sed_t* sed, const hawk_ooch_t* infile, const hawk_ooch_t* outfile, hawk_cmgr_t* cmgr) @@ -1045,15 +1169,15 @@ int hawk_sed_execstdxstr (hawk_sed_t* sed, const hawk_oocs_t* instr, hawk_oocs_t hawk_sed_iostd_t out; int n; - in[0].type = HAWK_SED_IOSTD_STR; - in[0].u.str = *instr; + in[0].type = HAWK_SED_IOSTD_OOCS; + in[0].u.oocs = *instr; in[1].type = HAWK_SED_IOSTD_NULL; - out.type = HAWK_SED_IOSTD_STR; + out.type = HAWK_SED_IOSTD_OOCS; n = hawk_sed_execstd(sed, in, &out); - if (n >= 0) *outstr = out.u.str; + if (n >= 0) *outstr = out.u.oocs; return n; } diff --git a/hawk/lib/std.c b/hawk/lib/std.c index d93aad57..5b8cd665 100644 --- a/hawk/lib/std.c +++ b/hawk/lib/std.c @@ -1385,7 +1385,6 @@ static hawk_ooi_t sf_in_read (hawk_t* hawk, hawk_sio_arg_t* arg, hawk_ooch_t* da } break; - case HAWK_PARSESTD_OOCS: parsestd_str: n = 0; diff --git a/hawk/lib/val.c b/hawk/lib/val.c index 023333df..4e48e53f 100644 --- a/hawk/lib/val.c +++ b/hawk/lib/val.c @@ -919,7 +919,6 @@ hawk_val_t* hawk_rtx_makembsvalwithucs (hawk_rtx_t* rtx, const hawk_ucs_t* ucs) return hawk_rtx_makembsvalwithuchars(rtx, ucs->ptr, ucs->len); } - hawk_val_t* hawk_rtx_makembsvalwithbcstr (hawk_rtx_t* rtx, const hawk_bch_t* bcs) { return make_mbs_val(rtx, bcs, hawk_count_bcstr(bcs), HAWK_NULL, 0); @@ -933,7 +932,6 @@ hawk_val_t* hawk_rtx_makembsvalwithucstr (hawk_rtx_t* rtx, const hawk_uch_t* ucs hawk_val_t* hawk_rtx_makembsvalwithuchars2 (hawk_rtx_t* rtx, const hawk_uch_t* ucs1, hawk_oow_t len1, const hawk_uch_t* ucs2, hawk_oow_t len2) { -#if defined(HAWK_OOCH_IS_UCH) hawk_val_t* v; hawk_bch_t* bcs; hawk_oow_t bcslen; @@ -944,27 +942,11 @@ hawk_val_t* hawk_rtx_makembsvalwithuchars2 (hawk_rtx_t* rtx, const hawk_uch_t* u v = make_mbs_val(rtx, bcs, bcslen, HAWK_NULL, 0); hawk_rtx_freemem (rtx, bcs); return v; -#else - return make_mbs_val(rtx, ucs1, len1, ucs2, len2); -#endif } hawk_val_t* hawk_rtx_makembsvalwithbchars2 (hawk_rtx_t* rtx, const hawk_bch_t* bcs1, hawk_oow_t len1, const hawk_bch_t* bcs2, hawk_oow_t len2) { -#if defined(HAWK_OOCH_IS_UCH) return make_mbs_val(rtx, bcs1, len1, bcs2, len2); -#else - hawk_val_t* v; - hawk_uch_t* ucs; - hawk_oow_t ucslen; - - ucs = hawk_rtx_dupb2tobchars(rtx, bcs1, len1, bcs2, len2, &ucslen, 1); - if (HAWK_UNLIKELY(!ucs)) return HAWK_NULL; - - v = make_mbs_val(rtx, ucs, ucslen, HAWK_NULL, 0); - hawk_rtx_freemem (rtx, ucs); - return v; -#endif } /* --------------------------------------------------------------------- */