1%% options 2 3copyright owner = Dirk Krause 4copyright year = 2015-xxxx 5SPDX-License-Identifier: BSD-3-Clause 6 7 8 9%% header 10 11/** @file 12 Text stream processing for dkChar characters. 13 14 CRT on Windows: Optional. 15*/ 16 17#ifndef DK4CONF_H_INCLUDED 18#if DK4_BUILDING_DKTOOLS4 19#include "dk4conf.h" 20#else 21#include <dktools-4/dk4conf.h> 22#endif 23#endif 24 25#ifndef DK4TYPES_H_INCLUDED 26#if DK4_BUILDING_DKTOOLS4 27#include <libdk4base/dk4types.h> 28#else 29#include <dktools-4/dk4types.h> 30#endif 31#endif 32 33#ifndef DK4ERROR_H_INCLUDED 34#if DK4_BUILDING_DKTOOLS4 35#include <libdk4base/dk4error.h> 36#else 37#include <dktools-4/dk4error.h> 38#endif 39#endif 40 41#if DK4_CHAR_SIZE > 1 42#if DK4_CHAR_SIZE > 2 43/* +++++ dkChar 4 bytes */ 44 45#ifndef DK4TSP32_H_INCLUDED 46#if DK4_BUILDING_DKTOOLS4 47#include <libdk4c/dk4tsp32.h> 48#else 49#include <dktools-4/dk4tsp32.h> 50#endif 51#endif 52 53/** Handler function to process a single character. 54*/ 55typedef dk4_c32_handler_t dk4_dk_handler_t; 56 57/** Handler function to process an input line. 58*/ 59typedef dk4_c32_line_handler_t dk4_dk_line_handler_t; 60 61/** Text stream processor. 62*/ 63typedef dk4_tsp32_t dk4_tspdk_t; 64 65/* ----- dkChar 4 bytes */ 66#else 67/* +++++ dkChar 2 bytes */ 68 69#ifndef DK4TSP16_H_INCLUDED 70#if DK4_BUILDING_DKTOOLS4 71#include <libdk4c/dk4tsp16.h> 72#else 73#include <dktools-4/dk4tsp16.h> 74#endif 75#endif 76 77/** Handler function to process a single character. 78*/ 79typedef dk4_c16_handler_t dk4_dk_handler_t; 80 81/** Handler function to process an input line. 82*/ 83typedef dk4_c16_line_handler_t dk4_dk_line_handler_t; 84 85/** Text stream processor. 86*/ 87typedef dk4_tsp16_t dk4_tspdk_t; 88 89/* ----- dkChar 2 bytes */ 90#endif 91#else 92/* +++++ dkChar 1 byte */ 93 94#ifndef DK4TSP08_H_INCLUDED 95#if DK4_BUILDING_DKTOOLS4 96#include <libdk4c/dk4tsp08.h> 97#else 98#include <dktools-4/dk4tsp08.h> 99#endif 100#endif 101 102/** Handler function to process a single character. 103*/ 104typedef dk4_c8_handler_t dk4_dk_handler_t; 105 106/** Handler function to process an input line. 107*/ 108typedef dk4_c8_line_handler_t dk4_dk_line_handler_t; 109 110/** Text stream processor. 111*/ 112typedef dk4_tsp08_t dk4_tspdk_t; 113 114/* ----- dkChar 1 byte */ 115#endif 116 117 118 119#ifdef __cplusplus 120extern "C" { 121#endif 122 123/** Set up processor for char by char processing. 124 @param tsp Processor to set up. 125 @param obj Object to modify when processing input, may be NULL. 126 @param fct Handler function to call for each character. 127 @param pre Encoding required for processing. 128 @param eie Expected input encoding. 129 @param erp Error report, may be NULL. 130 @return 1 on success, 0 on error. 131*/ 132int 133dk4tspdk_setup_char( 134 dk4_tspdk_t *tsp, 135 void *obj, 136 dk4_dk_handler_t *fct, 137 int pre, 138 int eie, 139 dk4_er_t *erp 140); 141 142/** Set up processor for line processing. 143 @param tsp Processor to set up. 144 @param obj Object to modify when processing input, may be NULL. 145 @param fct Handler function to invoke for each line. 146 @param inbuf Input line buffer. 147 @param szin Size of input line buffer. 148 @param pre Encoding required for processing. 149 @param eie Expected input encoding. 150 @param erp Error report, may be NULL. 151 @return 1 on success, 0 on error. 152*/ 153int 154dk4tspdk_setup_line( 155 dk4_tspdk_t *tsp, 156 void *obj, 157 dk4_dk_line_handler_t *fct, 158 dkChar *inbuf, 159 size_t szin, 160 int pre, 161 int eie, 162 dk4_er_t *erp 163); 164 165/** Allow pass-through of UTF-8 encoded data. 166 @param tsp Text stream processor to set up. 167 @param fl Flag: Enable pass-through of UTF-8 encoded data. 168*/ 169void 170dk4tspdk_enable_utf8_pass_through(dk4_tspdk_t *tsp, int fl); 171 172/** Add one single byte. 173 @param tsp Text stream processor. 174 @param inbyte Byte to process. 175 @return DK4_TSP_RES_OK if the character was processed 176 successfully, 177 DK4_TSP_RES_ERROR if there was an error but we can 178 continue, 179 DK4_TSP_RES_FATAL if there was a fatal error so we 180 should abort processing. 181*/ 182int 183dk4tspdk_add_one_byte( 184 dk4_tspdk_t *tsp, 185 unsigned char inbyte 186); 187 188/** Add multiple bytes. 189 @param tsp Text stream processor. 190 @param buffer Buffer start address. 191 @param sz Number of bytes in buffer. 192 @return DK4_TSP_RES_OK if the character was processed 193 successfully, 194 DK4_TSP_RES_ERROR if there was an error but we can 195 continue, 196 DK4_TSP_RES_FATAL if there was a fatal error so we 197 should abort processing. 198*/ 199int 200dk4tspdk_add_bytes( 201 dk4_tspdk_t *tsp, 202 const unsigned char *buffer, 203 size_t sz 204); 205 206/** Finish processing. 207 @param tsp Text stream processor. 208 @return DK4_TSP_RES_OK if processing was finished 209 successfully, 210 DK4_TSP_RES_ERROR if there was an error, 211 DK4_TSP_RES_FATAL if there was a fatal error. 212*/ 213int 214dk4tspdk_finish(dk4_tspdk_t *tsp); 215 216/** Retrieve error reports for encoding/decoding and processing. 217 @param er_en Destination error report buffer for encoding/decoding. 218 @param er_pr Destination error report buffer for processing. 219 @param tsp Text stream processor to retrieve errors from. 220*/ 221void 222dk4tspdk_get_errors(dk4_er_t *er_en, dk4_er_t *er_pr, dk4_tspdk_t const *tsp); 223 224#ifdef __cplusplus 225} 226#endif 227 228%% module 229 230 231 232#include "dk4conf.h" 233#include <libdk4c/dk4tspdk.h> 234#include <libdk4base/dk4unused.h> 235 236#if DK4_HAVE_ASSERT_H 237#ifndef ASSERT_H_INCLUDED 238#include <assert.h> 239#define ASSERT_H_INCLUDED 1 240#endif 241#endif 242 243 244int 245dk4tspdk_setup_char( 246 dk4_tspdk_t *tsp, 247 void *obj, 248 dk4_dk_handler_t *fct, 249#if 1 == DK4_CHAR_SIZE 250 int pre, 251#else 252 int DK4_ARG_UNUSED(pre), 253#endif 254 int eie, 255 dk4_er_t *erp 256) 257{ 258#if DK4_CHAR_SIZE > 1 259 DK4_UNUSED_ARG(pre) 260#endif 261#if DK4_USE_ASSERT 262 assert(NULL != tsp); 263#endif 264#if DK4_CHAR_SIZE > 1 265#if DK4_CHAR_SIZE > 2 266 return (dk4tsp32_setup_char(tsp, obj, fct, eie, erp)); 267#else 268 return (dk4tsp16_setup_char(tsp, obj, fct, eie, erp)); 269#endif 270#else 271 return (dk4tsp08_setup_char(tsp, obj, fct, pre, eie, erp)); 272#endif 273} 274 275 276 277int 278dk4tspdk_setup_line( 279 dk4_tspdk_t *tsp, 280 void *obj, 281 dk4_dk_line_handler_t *fct, 282 dkChar *inbuf, 283 size_t szin, 284#if 1 == DK4_CHAR_SIZE 285 int pre, 286#else 287 int DK4_ARG_UNUSED(pre), 288#endif 289 int eie, 290 dk4_er_t *erp 291) 292{ 293#if DK4_CHAR_SIZE > 1 294 DK4_UNUSED_ARG(pre) 295#endif 296#if DK4_USE_ASSERT 297 assert(NULL != tsp); 298 assert(NULL != inbuf); 299 assert(0 < szin); 300#endif 301#if DK4_CHAR_SIZE > 1 302#if DK4_CHAR_SIZE > 2 303 return (dk4tsp32_setup_line(tsp, obj, fct, inbuf, szin, eie, erp)); 304#else 305 return (dk4tsp16_setup_line(tsp, obj, fct, inbuf, szin, eie, erp)); 306#endif 307#else 308 return (dk4tsp08_setup_line(tsp, obj, fct, inbuf, szin, pre, eie, erp)); 309#endif 310} 311 312 313 314int 315dk4tspdk_add_one_byte( 316 dk4_tspdk_t *tsp, 317 unsigned char inbyte 318) 319{ 320#if DK4_USE_ASSERT 321 assert(NULL != tsp); 322#endif 323#if DK4_CHAR_SIZE > 1 324#if DK4_CHAR_SIZE > 2 325 return (dk4tsp32_add_one_byte(tsp, inbyte)); 326#else 327 return (dk4tsp16_add_one_byte(tsp, inbyte)); 328#endif 329#else 330 return (dk4tsp08_add_one_byte(tsp, inbyte)); 331#endif 332} 333 334 335 336int 337dk4tspdk_add_bytes( 338 dk4_tspdk_t *tsp, 339 const unsigned char *buffer, 340 size_t sz 341) 342{ 343#if DK4_USE_ASSERT 344 assert(NULL != tsp); 345 assert(NULL != buffer); 346 assert(0 < sz); 347#endif 348#if DK4_CHAR_SIZE > 1 349#if DK4_CHAR_SIZE > 2 350 return (dk4tsp32_add_bytes(tsp, buffer, sz)); 351#else 352 return (dk4tsp16_add_bytes(tsp, buffer, sz)); 353#endif 354#else 355 return (dk4tsp08_add_bytes(tsp, buffer, sz)); 356#endif 357} 358 359 360 361int 362dk4tspdk_finish(dk4_tspdk_t *tsp) 363{ 364#if DK4_USE_ASSERT 365 assert(NULL != tsp); 366#endif 367#if DK4_CHAR_SIZE > 1 368#if DK4_CHAR_SIZE > 2 369 return (dk4tsp32_finish(tsp)); 370#else 371 return (dk4tsp16_finish(tsp)); 372#endif 373#else 374 return (dk4tsp08_finish(tsp)); 375#endif 376} 377 378 379 380void 381dk4tspdk_get_errors(dk4_er_t *er_en, dk4_er_t *er_pr, dk4_tspdk_t const *tsp) 382{ 383#if DK4_USE_ASSERT 384 assert(NULL != tsp); 385#endif 386#if DK4_CHAR_SIZE > 1 387#if DK4_CHAR_SIZE > 2 388 dk4tsp32_get_errors(er_en, er_pr, tsp); 389#else 390 dk4tsp16_get_errors(er_en, er_pr, tsp); 391#endif 392#else 393 dk4tsp08_get_errors(er_en, er_pr, tsp); 394#endif 395} 396 397 398 399void 400dk4tspdk_enable_utf8_pass_through( 401#if 1 == DK4_CHAR_SIZE 402 dk4_tspdk_t *tsp, 403 int fl 404#else 405 dk4_tspdk_t * DK4_ARG_UNUSED(tsp), 406 int DK4_ARG_UNUSED(fl) 407#endif 408) 409{ 410#if DK4_CHAR_SIZE > 1 411 DK4_UNUSED_ARG(tsp) 412 DK4_UNUSED_ARG(fl) 413#endif 414#if DK4_USE_ASSERT 415 assert(NULL != tsp); 416#endif 417#if DK4_CHAR_SIZE == 1 418 dk4tsp08_enable_utf8_pass_through(tsp, fl); 419#endif 420} 421 422 423