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