Annotation of gpl/axl/babel/axl_babel.c, revision 1.1.1.1
1.1 misho 1: /*
2: * LibAxl: Another XML library
3: * Copyright (C) 2008 Advanced Software Production Line, S.L.
4: *
5: * This program is free software; you can redistribute it and/or
6: * modify it under the terms of the GNU Lesser General Public License
7: * as published by the Free Software Foundation; either version 2.1 of
8: * the License, or (at your option) any later version.
9: *
10: * This program is distributed in the hope that it will be useful,
11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: * GNU Lesser General Public License for more details.
14: *
15: * You should have received a copy of the GNU Lesser General Public
16: * License along with this program; if not, write to the Free
17: * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18: * 02111-1307 USA
19: *
20: * You may find a copy of the license under this software is released
21: * at COPYING file. This is LGPL software: you are welcome to
22: * develop proprietary applications using this library without any
23: * royalty or fee but returning back any change, improvement or
24: * addition in the form of source code, project image, documentation
25: * patches, etc.
26: *
27: * For commercial support on build XML enabled solutions contact us:
28: *
29: * Postal address:
30: * Advanced Software Production Line, S.L.
31: * Edificio Alius A, Oficina 102,
32: * C/ Antonio Suarez Nº 10,
33: * Alcalá de Henares 28802 Madrid
34: * Spain
35: *
36: * Email address:
37: * info@aspl.es - http://www.aspl.es/xml
38: */
39:
40: #include <axl_babel.h>
41:
42: /* include local headers */
43: #include <axl_babel_iso88591.h>
44: #include <axl_babel_iso88592.h>
45: #include <axl_babel_iso88593.h>
46: #include <axl_babel_iso88594.h>
47: #include <axl_babel_iso88595.h>
48: #include <axl_babel_iso88596.h>
49: #include <axl_babel_iso88597.h>
50: #include <axl_babel_iso88598.h>
51: #include <axl_babel_iso88599.h>
52: #include <axl_babel_iso885915.h>
53:
54: #define LOG_DOMAIN "axl-babel"
55:
56: /**
57: * \defgroup axl_babel Axl Babel: Main functions to enable axl babel support
58: */
59:
60: /**
61: * \addtogroup axl_babel
62: * @{
63: */
64:
65: /**
66: * @brief Allows to configure babel encoding functions making axl
67: * library to use its API to support encoding formats.
68: *
69: * Current encoding format supported at:
70: *
71: * - utf-8, ascii.
72: *
73: * - iso-8859-1, iso-8859-2, iso-8859-3, iso-8859-4, iso-8859-5,
74: * iso-8859-6, iso-8859-7, iso-8859-8, iso-8859-9, iso-8859-15
75: *
76: * @param error An optional reference to an axlError where failure
77: * will be notified.
78: *
79: * @return axl_true if the init operation was properly implemented,
80: * otherwise axl_false is returned.
81: */
82: axl_bool axl_babel_init (axlError ** error)
83: {
84: /* call to configure babel */
85: axl_doc_set_detect_codification_func (axl_babel_detect_codification, NULL);
86: axl_doc_set_configure_codification_func (axl_babel_configure_encoding, NULL);
87:
88: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "configure axl-babel handlers..");
89:
90: return axl_true;
91: }
92:
93: /**
94: * @brief Remove handlers installed and babel configuration from base
95: * library.
96: */
97: void axl_babel_finish ()
98: {
99: /* call to configure babel */
100: axl_doc_set_detect_codification_func (NULL, NULL);
101: axl_doc_set_configure_codification_func (NULL, NULL);
102:
103: return;
104: }
105:
106: /**
107: * @internal Library function that allows to detect entity codification
108: * found to use the appropiate built-in decoder handler until the
109: * right codification is found (due to encoding header
110: * declaration). The intention is to move the content read from the
111: * stream abstraction into a utf-8 unified representation inside
112: * memory.
113: *
114: * @param doc The document that is about to be checked for the
115: * appropiate codification.
116: *
117: * @param encoding Detected encoding by the function.
118: *
119: * @param error The reference where errors will be reported.
120: *
121: * @return axl_true if the codification detection was performed properly,
122: * otherwise axl_false is returned if an error is found.
123: */
124: axl_bool axl_babel_detect_codification (axlStream * stream,
125: const char ** encoding,
126: axlPointer user_data,
127: axlError ** error)
128: {
129: /* check basic case where the stream have no content to
130: * parse */
131: if (axl_stream_get_size (stream) < 4) {
132: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "unable to detect codification, stream received doesn't have enough content to parse");
133: return axl_false;
134: } /* end if */
135:
136: /* clear encoding */
137: if (encoding)
138: (*encoding) = NULL;
139:
140: /* Check built-in supported formats. First check for documents
141: * with the BOM mark configured */
142:
143: /* check UTF-8 BOM: EF BB BF */
144: if (axl_stream_inspect_code (stream, 0xEF, 0) &&
145: axl_stream_inspect_code (stream, 0xBB, 1) &&
146: axl_stream_inspect_code (stream, 0xBF, 2)) {
147:
148: /* configure encoding detected */
149: if (encoding)
150: (*encoding) = "utf8";
151:
152: /* update stream */
153: axl_stream_move (stream, axl_stream_get_index (stream) + 3);
154:
155: /* found utf-8 encoding, install associated filter */
156: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "utf-8 BOM mark found, assuming utf-8 content");
157: return axl_true;
158: } /* end if */
159:
160: /* check UTF-16 (little-endian) BOM: FF FE */
161: if (axl_stream_inspect_code (stream, 0xFF, 0) &&
162: axl_stream_inspect_code (stream, 0xFE, 1)) {
163: /* configure encoding detected */
164: if (encoding)
165: (*encoding) = "utf16";
166:
167: /* update stream */
168: axl_stream_move (stream, axl_stream_get_index (stream) + 2);
169:
170: /* found utf-16 encoding, install associated filter */
171: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "utf-16 BOM mark found, assuming utf-16 content");
172: return axl_true;
173: }
174:
175: /* check UTF-32 (little-endian) BOM: FF FE 00 00 */
176: if (axl_stream_inspect_code (stream, 0xFF, 0) &&
177: axl_stream_inspect_code (stream, 0xFE, 1) &&
178: axl_stream_inspect_code (stream, 0x00, 2) &&
179: axl_stream_inspect_code (stream, 0x00, 3)) {
180: /* configure encoding detected */
181: if (encoding)
182: (*encoding) = "utf32";
183:
184: /* update stream */
185: axl_stream_move (stream, axl_stream_get_index (stream) + 4);
186:
187: /* found utf-16 encoding, install associated filter */
188: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "utf-32 BOM mark found, assuming utf-8 content");
189: return axl_true;
190: } /* end if */
191:
192: /* NO BOM MARK SECTION */
193:
194: /* detect utf-8, iso 646, ascii,...*/
195: if (axl_stream_inspect_code (stream, 0x3C, 0) &&
196: axl_stream_inspect_code (stream, 0X3F, 1) &&
197: axl_stream_inspect_code (stream, 0x78, 2) &&
198: axl_stream_inspect_code (stream, 0x6D, 3)) {
199: assume_utf8:
200: /* no encoding detected we are not sure */
201:
202: /* found utf-16 encoding, install associated filter */
203: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "found utf-8, iso 646, ascii or something similiar without mark, assuming utf-8 until encoding declaration..");
204: return axl_true;
205: } /* end if */
206:
207: /* check last case where an utf-8 document could be found without xml header */
208: if (axl_stream_inspect_code (stream, 0x3C, 0) &&
209: ! axl_stream_inspect_code (stream, 0x3C, 1) &&
210: ! axl_stream_inspect_code (stream, 0x3E, 1)) {
211: goto assume_utf8;
212: }
213:
214: /* unable to detect the encoding format */
215: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL,
216: "unable to detect encoding format, failed to detect encoding format");
217: axl_error_new (-1, "unable to detect encoding format, failed to detect encoding format", NULL, error);
218: return axl_false;
219:
220: }
221:
222: /**
223: * @internal Function that implements the identity operation. Does
224: * nothing just translates data from source to output.
225: */
226: int axl_babel_identity_utf8 (const char * source, int source_size,
227: const char * source_encoding,
228: char * output, int output_size,
229: int * output_converted,
230: int * remain_source_index,
231: axlPointer user_data)
232: {
233: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "received request to translate source code from iso-8859-15 to utf-8: source size=%d: %s",
234: source_size, source);
235:
236: /* identity operation */
237: memcpy (output, source, source_size);
238: (*output_converted) = source_size;
239:
240: /* operation completed */
241: return 1;
242: }
243:
244: /**
245: * @internal Function that performs translation from encoding
246: * representations using 1 octect (0..255) into utf-8.
247: *
248: * @return The handler must return 1 if the operation was completed, 2
249: * if the operation was completed but not enough size was found on
250: * output buffer to store the content or 0 if the function fails.
251: */
252: int axl_babel_single_to_utf8 (const char * source, int source_size,
253: const char * source_encoding,
254: char * output, int output_size,
255: int * output_converted,
256: int * remain_source_index,
257: axlPointer user_data)
258: {
259: axlBabelTable * table = (axlBabelTable *)user_data;
260: int iterator;
261: int iterator2;
262: int desp;
263: unsigned char value;
264:
265:
266: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "received request to translate source code from %s to utf-8: source size=%d on output size=%d: %s",
267: source_encoding, source_size, output_size, source);
268:
269: iterator = 0;
270: iterator2 = 0;
271: while (iterator < source_size && iterator2 < output_size) {
272:
273: /* get the value */
274: value = source[iterator];
275:
276: /* __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "translating value=%c (%d)", source[iterator], value); */
277:
278: /* check if we are able to place all the encoded item */
279: if ((iterator2 + table[value].size) > output_size) {
280: /* __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "unable to completely decode following sequence (%d size, on remain: %d)",
281: table[value].size, output_size - iterator2); */
282: break;
283: }
284:
285: desp = 0;
286: while ((desp < table[value].size)) {
287: /* __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, " configuring at %d value: %d",
288: iterator2 + desp,
289: table[value].buffer[desp]); */
290: output[iterator2] = table[value].buffer[desp];
291: desp++;
292: iterator2++;
293: }
294:
295: /* next */
296: iterator++;
297:
298: } /* end while */
299:
300: /* update output converted */
301: *output_converted = iterator2;
302: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "output converted=%d: %s (iterator:%d == source_size:%d)",
303: iterator2, output, iterator, source_size);
304:
305: /* check exit condition (if all output was converted) */
306: if (iterator == source_size)
307: return 1;
308:
309: /* source to be converted remains */
310: *remain_source_index = iterator;
311: return 2;
312: }
313:
314: /**
315: * @internal Function that performs translation from encoding
316: * representations using 1 octect (0..255) into utf-8.
317: *
318: * @return The handler must return 1 if the operation was completed, 2
319: * if the operation was completed but not enough size was found on
320: * output buffer to store the content or 0 if the function fails.
321: */
322: int axl_babel_utf8_check (const char * source,
323: int source_size,
324: const char * source_encoding,
325: axlPointer user_data,
326: axlError ** error)
327: {
328: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "received notification to check content size=%d to have valid utf-8: %s", source_size, source);
329: return axl_babel_check_utf8_content (source, source_size, NULL) ? 1 : 0;
330: }
331:
332:
333: /**
334: * @internal Function that tries to check encoding found to configure the
335: * proper set of functions to translate from and to utf-8.
336: *
337: * @param stream Stream to be configured.
338: *
339: * @param encoding Encoding declaration found at the xml header.
340: *
341: * @param detected Detected encoding found by the detect codification
342: * configured.
343: *
344: * @param user_data User defined pointer.
345: *
346: * @param error An optional error that will be filled in the case an
347: * error is found.
348: *
349: * @return axl_true if the operation was completed, otherwise axl_false is
350: * returned.
351: */
352: axl_bool axl_babel_configure_encoding (axlStream * stream,
353: const char * encoding,
354: const char * detected,
355: axlPointer user_data, axlError ** error)
356: {
357: axlBabelTable * table = NULL;
358:
359: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "configuring final document enconding, previously detected=%s, declared=%s",
360: detected ? detected : "none",
361: encoding ? encoding : "none");
362:
363: /* check case were a encoding was detected (the entity content
364: * is encoded as detected due to marks or other means) */
365: if (detected && encoding == NULL)
366: detected = encoding;
367:
368: /* check encoding found (either detected or defined) */
369: if (axl_cmp (encoding, "iso88591")) {
370: /* install a translator handler */
371: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-1");
372: table = axl_babel_build_iso88591_table ();
373: } /* end if */
374:
375: if (axl_cmp (encoding, "iso88592")) {
376: /* install a translator handler */
377: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-2");
378: table = axl_babel_build_iso88592_table ();
379: } /* end if */
380:
381: if (axl_cmp (encoding, "iso88593")) {
382: /* install a translator handler */
383: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-3");
384: table = axl_babel_build_iso88593_table ();
385: } /* end if */
386:
387: if (axl_cmp (encoding, "iso88594")) {
388: /* install a translator handler */
389: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-4");
390: table = axl_babel_build_iso88594_table ();
391: } /* end if */
392:
393: if (axl_cmp (encoding, "iso88595")) {
394: /* install a translator handler */
395: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-5");
396: table = axl_babel_build_iso88595_table ();
397: } /* end if */
398:
399: if (axl_cmp (encoding, "iso88596")) {
400: /* install a translator handler */
401: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-6");
402: table = axl_babel_build_iso88596_table ();
403: } /* end if */
404:
405: if (axl_cmp (encoding, "iso88597")) {
406: /* install a translator handler */
407: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-7");
408: table = axl_babel_build_iso88597_table ();
409: } /* end if */
410:
411: if (axl_cmp (encoding, "iso88598")) {
412: /* install a translator handler */
413: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-8");
414: table = axl_babel_build_iso88598_table ();
415: } /* end if */
416:
417: if (axl_cmp (encoding, "iso88599")) {
418: /* install a translator handler */
419: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-9");
420: table = axl_babel_build_iso88599_table ();
421: } /* end if */
422:
423: if (axl_cmp (encoding, "iso885915")) {
424: /* install a translator handler */
425: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for iso-8859-15");
426: table = axl_babel_build_iso885915_table ();
427: } /* end if */
428:
429: if (axl_cmp (encoding, "utf8")) {
430: /* install a translator handler */
431: __axl_log (LOG_DOMAIN, AXL_LEVEL_DEBUG, "installed handler encoding for utf-8");
432:
433: /* install checker without table */
434: if (! axl_stream_setup_check (stream, encoding, axl_babel_utf8_check, NULL, error))
435: return axl_false;
436: return axl_true;
437: } /* end if */
438:
439: if (table == NULL) {
440: /* format not defined, use default utf-8 */
441: __axl_log (LOG_DOMAIN, AXL_LEVEL_WARNING, "encoding='%s' (detected: '%s') not supported, falling back into utf-8 without restriction",
442: encoding ? encoding : "",
443: detected ? detected : "");
444:
445: return axl_true;
446: } /* end if */
447:
448: /* associate to the stream */
449: axl_stream_link_full (stream, table, axl_free, axl_true);
450:
451: if (! axl_stream_setup_decode (stream, encoding, axl_babel_single_to_utf8, table, error))
452: return axl_false;
453:
454: return axl_true;
455: }
456:
457: /**
458: * @brief Allows to check if the provided string is in utf-8 coding
459: * form.
460: *
461: * @param content The content to length.
462: *
463: * @param content_length Length (in octets) of the string received. If
464: * provided -1, content will be calculated using strlen function.
465: *
466: * @param index_error Optional reference where will be reported the
467: * index position that caused the error.
468: *
469: * @return axl_true if the content provided is all in utf-8 otherwise
470: * axl_false is returned. In the case index_error or error is defined and
471: * an error is found, they are defined to the appropriate value.
472: */
473: axl_bool axl_babel_check_utf8_content (const char * content,
474: int content_length,
475: int * index_error)
476: {
477: int iterator = 0;
478: unsigned char value;
479:
480:
481: if (index_error)
482: *index_error = 0;
483:
484: axl_return_val_if_fail (content, axl_false);
485: axl_return_val_if_fail (content_length >= -1, axl_false);
486:
487: /* check and calculate content */
488: if (content_length == -1)
489: content_length = strlen (content);
490:
491: while (iterator < content_length) {
492: /* utf with 4 octects */
493: value = content[iterator];
494: if (value >= 240 && value <= 247 && (iterator + 1) < content_length ) {
495:
496: /* get next value */
497: value = content[iterator + 1];
498: if (value >= 128 && value <= 191 && (iterator + 2) < content_length ) {
499:
500: /* get next value */
501: value = content[iterator + 2];
502: if (value >= 128 && value <= 191 && (iterator + 3) < content_length ) {
503:
504: /* get next value */
505: value = content[iterator + 3];
506: if (value >= 128 && value <= 191) {
507: iterator += 4;
508: continue;
509: } /* end if */
510: }
511: }
512:
513: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "found error while detecting 4 octect utf-8 format..");
514: /* found error */
515: if (index_error)
516: *index_error = iterator;
517: return axl_false;
518: } /* end if */
519:
520: /* utf with 3 octects */
521: if (value >= 224 && value <= 239 && (iterator + 1) < content_length ) {
522: /* get next value */
523: value = content[iterator + 1];
524: if (value >= 128 && value <= 191 && (iterator + 2) < content_length ) {
525:
526: /* get next value */
527: value = content[iterator + 2];
528: if (value >= 128 && value <= 191) {
529: iterator += 3;
530: continue;
531: } /* end if */
532: }
533:
534: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "found error while detecting 3 octect utf-8 format..");
535:
536: /* found error */
537: if (index_error)
538: *index_error = iterator;
539: return axl_false;
540: }
541:
542: /* utf with 2 octects */
543: if (value >= 192 && value <= 223 && (iterator + 1) < content_length ) {
544: /* get next value */
545: value = content[iterator + 1];
546: if (value >= 128 && value <= 191) {
547: iterator += 2;
548: continue;
549: } /* end if */
550:
551: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "found error while detecting 2 octect utf-8 format value=%d..", value);
552:
553: /* found error */
554: if (index_error)
555: *index_error = iterator;
556: return axl_false;
557: }
558:
559: if (value <= 127 ) {
560: iterator++;
561: continue;
562: } /* end if */
563:
564: __axl_log (LOG_DOMAIN, AXL_LEVEL_CRITICAL, "found error while detecting single octect utf-8 format..");
565:
566: /* found error */
567: if (index_error)
568: *index_error = iterator;
569: return axl_false;
570:
571:
572: } /* end while */
573:
574: return axl_true;
575: }
576:
577: /**
578: * @}
579: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to axl_babel.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / gpl / axl / babel