?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Namespace documentation: Private namespaces and detailed look-up rules
[shapes.git] / source / charconverters.cc
blobddfaebc4aa6784c592a1d1d232d615928aac3ca2
1 /* This file is part of Shapes.
2 *
3 * Shapes is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 3 of the License, or
6 * any later version.
7 *
8 * Shapes is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with Shapes. If not, see <http://www.gnu.org/licenses/>.
15 *
16 * Copyright 2008, 2010 Henrik Tidefelt
17 */
18
19 #include "strrefdup.h"
20 #include "charconverters.h"
21 #include "shapesexceptions.h"
22 #include "glyphlist.h"
23 #include "characterencoding.h"
24 #include "texttypes.h"
25
26
27 #include <iconv.h>
28 #include <errno.h>// How come iconv is not enough?
29 #include <string>
30 #include <fstream>
31 #include <sstream>
32
33
34
35 using namespace Shapes;
36
37 void
38 iconv_maybe_open( iconv_t * converter, const char * to_encoding, const char * from_encoding )
39 {
40 if( *converter == (iconv_t)( -1 ) )
41 {
42 *converter = iconv_open( to_encoding, from_encoding );
43 if( *converter == (iconv_t)( -1 ) )
44 {
45 std::ostringstream msg;
46 msg << "iconv_open failed to create converter from " << from_encoding << " to " << to_encoding << "." ;
47 throw Exceptions::ExternalError( strrefdup( msg ) );
48 }
49 }
50 }
51
52 iconv_t
53 Helpers::requireUTF8ToMacRomanConverter( bool cleanup )
54 {
55 static iconv_t converter = (iconv_t)( - 1 );
56 if( cleanup )
57 {
58 if( converter != (iconv_t)( -1 ) )
59 {
60 iconv_close( converter );
61 converter = (iconv_t)( -1 );
62 }
63 }
64 else
65 {
66 iconv_maybe_open( & converter,
67 MAC_ROMAN, // This is meant to be what is called MacRoman in PDF.
68 "UTF-8" );
69 }
70 return converter;
71 }
72
73 iconv_t
74 Helpers::requireMacRomanToUTF8Converter( bool cleanup )
75 {
76 static iconv_t converter = (iconv_t)( - 1 );
77 if( cleanup )
78 {
79 if( converter != (iconv_t)( -1 ) )
80 {
81 iconv_close( converter );
82 converter = (iconv_t)( -1 );
83 }
84 }
85 else
86 {
87 iconv_maybe_open( & converter,
88 "UTF-8",
89 MAC_ROMAN ); // This is meant to be what is called MacRoman in PDF.
90 }
91 return converter;
92 }
93
94 iconv_t
95 Helpers::requireUTF8ToASCIIConverter( bool cleanup )
96 {
97 static iconv_t converter = (iconv_t)( - 1 );
98 if( cleanup )
99 {
100 if( converter != (iconv_t)( -1 ) )
101 {
102 iconv_close( converter );
103 converter = (iconv_t)( -1 );
104 }
105 }
106 else
107 {
108 iconv_maybe_open( & converter,
109 "ASCII", // This is used for the names of glyphs in a font
110 "UTF-8" );
111 }
112 return converter;
113 }
114
115 iconv_t
116 Helpers::requireUTF8ToUCS4Converter( bool cleanup )
117 {
118 static iconv_t converter = (iconv_t)( - 1 );
119 if( cleanup )
120 {
121 if( converter != (iconv_t)( -1 ) )
122 {
123 iconv_close( converter );
124 converter = (iconv_t)( -1 );
125 }
126 }
127 else
128 {
129 iconv_maybe_open( & converter,
130 UCS_4_INTERNAL,
131 "UTF-8" );
132 }
133 return converter;
134 }
135
136 iconv_t
137 Helpers::requireUCS4ToUTF8Converter( bool cleanup )
138 {
139 static iconv_t converter = (iconv_t)( - 1 );
140 if( cleanup )
141 {
142 if( converter != (iconv_t)( -1 ) )
143 {
144 iconv_close( converter );
145 converter = (iconv_t)( -1 );
146 }
147 }
148 else
149 {
150 iconv_maybe_open( & converter,
151 "UTF-8",
152 UCS_4_INTERNAL );
153 }
154 return converter;
155 }
156
157 iconv_t
158 Helpers::requireUCS4ToMacRomanConverter( bool cleanup )
159 {
160 static iconv_t converter = (iconv_t)( - 1 );
161 if( cleanup )
162 {
163 if( converter != (iconv_t)( -1 ) )
164 {
165 iconv_close( converter );
166 converter = (iconv_t)( -1 );
167 }
168 }
169 else
170 {
171 iconv_maybe_open( & converter,
172 MAC_ROMAN,
173 UCS_4_INTERNAL );
174 }
175 return converter;
176 }
177
178 iconv_t
179 Helpers::requireUTF16BEToUCS4Converter( bool cleanup )
180 {
181 static iconv_t converter = (iconv_t)( - 1 );
182 if( cleanup )
183 {
184 if( converter != (iconv_t)( -1 ) )
185 {
186 iconv_close( converter );
187 converter = (iconv_t)( -1 );
188 }
189 }
190 else
191 {
192 iconv_maybe_open( & converter,
193 UCS_4_INTERNAL,
194 "UTF-16BE" );
195 }
196 return converter;
197 }
198
199 iconv_t
200 Helpers::requireUCS4ToUTF16BEConverter( bool cleanup )
201 {
202 static iconv_t converter = (iconv_t)( - 1 );
203 if( cleanup )
204 {
205 if( converter != (iconv_t)( -1 ) )
206 {
207 iconv_close( converter );
208 converter = (iconv_t)( -1 );
209 }
210 }
211 else
212 {
213 iconv_maybe_open( & converter,
214 "UTF-16BE",
215 UCS_4_INTERNAL );
216 }
217 return converter;
218 }
219
220 iconv_t
221 Helpers::requireUTF8ToWinANSIConverter( bool cleanup )
222 {
223 static iconv_t converter = (iconv_t)( - 1 );
224 if( cleanup )
225 {
226 if( converter != (iconv_t)( -1 ) )
227 {
228 iconv_close( converter );
229 converter = (iconv_t)( -1 );
230 }
231 }
232 else
233 {
234 iconv_maybe_open( & converter,
235 "LATIN1", // This is meant to be what is called WinANSI in PDF.
236 "UTF-8" );
237 }
238 return converter;
239 }
240
241 iconv_t
242 Helpers::requireUTF8ToUTF16BEConverter( bool cleanup )
243 {
244 static iconv_t converter = (iconv_t)( - 1 );
245 if( cleanup )
246 {
247 if( converter != (iconv_t)( -1 ) )
248 {
249 iconv_close( converter );
250 converter = (iconv_t)( -1 );
251 }
252 }
253 else
254 {
255 iconv_maybe_open( & converter,
256 "UTF-16BE",
257 "UTF-8" );
258 }
259 return converter;
260 }
261
262 const FontMetrics::GlyphList &
263 Helpers::requireGlyphList( bool cleanup )
264 {
265 static const FontMetrics::GlyphList * converter = 0;
266 if( cleanup )
267 {
268 if( converter != 0 )
269 {
270 delete converter;
271 converter = 0;
272 }
273 }
274 else
275 {
276 if( converter == 0 )
277 {
278 std::string filename = Lang::Font::searchGlyphList( );
279 std::ifstream iFile( filename.c_str( ) );
280 if( ! iFile.is_open( ) )
281 {
282 std::ostringstream oss;
283 oss << "Could locate, but not open the glyph list " << filename ;
284 throw Exceptions::ExternalError( strrefdup( oss ) );
285 }
286 try
287 {
288 converter = new FontMetrics::GlyphList( iFile );
289 }
290 catch( const char * ball )
291 {
292 std::ostringstream oss;
293 oss << "Parsing the glyph list " << filename << " resulted in the error: " << ball ;
294 throw Exceptions::ExternalError( strrefdup( oss ) );
295 }
296 catch( const std::string ball )
297 {
298 std::ostringstream oss;
299 oss << "Parsing the glyph list " << filename << " resulted in the error: " << ball ;
300 throw Exceptions::ExternalError( strrefdup( oss ) );
301 }
302 catch( const Shapes::Exceptions::Exception & ball )
303 {
304 std::cerr << "Parsing the glyph list " << filename << " resulted in an error. Rethrowing." << std::endl ;
305 throw;
306 }
307 catch( ... )
308 {
309 throw Exceptions::InternalError( "An unrecognized exception was caught from glyph list parsing." );
310 }
311 }
312 }
313 return *converter;
314 }
315
316 const FontMetrics::CharacterEncoding &
317 Helpers::requireMacRomanEncoding( bool cleanup )
318 {
319 static const FontMetrics::CharacterEncoding * converter = 0;
320 if( cleanup )
321 {
322 if( converter != 0 )
323 {
324 delete converter;
325 converter = 0;
326 }
327 }
328 else
329 {
330 if( converter == 0 )
331 {
332 std::string filename = Lang::Font::searchCharacterEncoding( "MacRoman" );
333 std::ifstream iFile( filename.c_str( ) );
334 if( ! iFile.is_open( ) )
335 {
336 std::ostringstream oss;
337 oss << "Could locate, but not open the character encoding " << filename ;
338 throw Exceptions::ExternalError( strrefdup( oss ) );
339 }
340 try
341 {
342 converter = new FontMetrics::CharacterEncoding( iFile );
343 }
344 catch( const char * ball )
345 {
346 std::ostringstream oss;
347 oss << "Parsing the character encoding " << filename << " resulted in the error: " << ball ;
348 throw Exceptions::ExternalError( strrefdup( oss ) );
349 }
350 catch( const std::string ball )
351 {
352 std::ostringstream oss;
353 oss << "Parsing the character encoding " << filename << " resulted in the error: " << ball ;
354 throw Exceptions::ExternalError( strrefdup( oss ) );
355 }
356 catch( const Shapes::Exceptions::Exception & ball )
357 {
358 std::cerr << "Parsing the character encoding " << filename << " resulted in an error. Rethrowing." << std::endl ;
359 throw;
360 }
361 catch( ... )
362 {
363 throw Exceptions::InternalError( "An unrecognized exception was caught from character encoding parsing." );
364 }
365 }
366 }
367 return *converter;
368 }
369
370 unsigned char
371 Kernel::UnicodeCodePoint::get_MacRoman( ) const
372 {
373 static iconv_t converter = Helpers::requireUCS4ToMacRomanConverter( );
374
375 const size_t BUF_SIZE = 1;
376 char buf[ BUF_SIZE ];
377 char * dst = buf;
378 size_t outbytesleft = BUF_SIZE;
379
380 const char * src = reinterpret_cast< const char * >( & value_ );
381 size_t inbytesleft = sizeof( value_ );
382
383 size_t count = iconv( converter,
384 ICONV_CAST( & src ), & inbytesleft,
385 & dst, & outbytesleft );
386 if( count == (size_t)(-1) )
387 {
388 if( errno == EILSEQ )
389 {
390 std::ostringstream msg;
391 msg << "The UCS-4 code point U+" << std::hex << value_ << " cannot be represented in MacRoman encodig." ;
392 throw Exceptions::MiscellaneousRequirement( strrefdup( msg ) );
393 }
394 else if( errno == EINVAL )
395 {
396 throw Exceptions::InternalError( "Malformed UCS-4 value (in conversion to MacRoman)." );
397 }
398 else if( errno == E2BIG )
399 {
400 throw Exceptions::InternalError( "The MacRoman destination buffer was too small when encoding a single UCS-4 code point." );
401 }
402 else
403 {
404 std::ostringstream msg;
405 msg << "iconv failed with an unrecognized error code: " << errno ;
406 throw Exceptions::InternalError( strrefdup( msg ) );
407 }
408 }
409 else if( inbytesleft != 0 )
410 {
411 throw Exceptions::InternalError( "Failed to use the entire UCS-4 code point when converting to MacRoman." );
412 }
413 return *reinterpret_cast< unsigned char * >( buf );
414 }
415
416 void
417 Kernel::UnicodeCodePoint::decode_UTF8( const char ** src, size_t * src_avail )
418 {
419 static iconv_t converter = Helpers::requireUTF8ToUCS4Converter( );
420
421 char * dst = reinterpret_cast< char * >( & value_ );
422 size_t outbytesleft = sizeof( value_ );
423
424 size_t tmp_src_avail;
425 if( **src > 0 )
426 {
427 tmp_src_avail = 1;
428 }
429 else
430 {
431 switch( 0xF0 & **src )
432 {
433 case 0xE0: tmp_src_avail = 3; break;
434 case 0xF0: tmp_src_avail = 4; break;
435 default: tmp_src_avail = 2; break;
436 }
437 }
438 if( tmp_src_avail > *src_avail )
439 {
440 throw Exceptions::InternalError( "The UTF-8 source did not contain a complete character when initializing a single UCS-4 code point." );
441 }
442 *src_avail -= tmp_src_avail;
443
444 size_t count = iconv( converter,
445 ICONV_CAST( src ), & tmp_src_avail,
446 & dst, & outbytesleft );
447 if( count == (size_t)(-1) )
448 {
449 if( errno == EILSEQ )
450 {
451 throw Exceptions::InternalError( "Failed to initialize UCS-4 code point from UTF-8 data." );
452 }
453 else if( errno == EINVAL )
454 {
455 throw Exceptions::MiscellaneousRequirement( "Malformed UTF-8 value in initialization of UCS-4 code point." );
456 }
457 else if( errno == E2BIG )
458 {
459 throw Exceptions::InternalError( "The UTF-8 source buffer contained more than one character when initializing a single UCS-4 code point." );
460 }
461 else
462 {
463 std::ostringstream msg;
464 msg << "iconv failed with an unrecognized error code: " << errno ;
465 throw Exceptions::InternalError( strrefdup( msg ) );
466 }
467 }
468 else if( outbytesleft != 0 )
469 {
470 throw Exceptions::InternalError( "Failed to initialize the entire UCS-4 code point when converting from UTF-8." );
471 }
472 }
473
474 void
475 Kernel::UnicodeCodePoint::decode_UTF8( const char * src )
476 {
477 static iconv_t converter = Helpers::requireUTF8ToUCS4Converter( );
478
479 char * dst = reinterpret_cast< char * >( & value_ );
480 size_t outbytesleft = sizeof( value_ );
481
482 size_t tmp_src_avail;
483 if( *src > 0 )
484 {
485 tmp_src_avail = 1;
486 }
487 else
488 {
489 switch( 0xF0 & *src )
490 {
491 case 0xE0: tmp_src_avail = 3; break;
492 case 0xF0: tmp_src_avail = 4; break;
493 default: tmp_src_avail = 2; break;
494 }
495 }
496
497 size_t count = iconv( converter,
498 ICONV_CAST( & src ), & tmp_src_avail,
499 & dst, & outbytesleft );
500 if( count == (size_t)(-1) )
501 {
502 if( errno == EILSEQ )
503 {
504 throw Exceptions::InternalError( "Failed to initialize UCS-4 code point from UTF-8 data." );
505 }
506 else if( errno == EINVAL )
507 {
508 throw Exceptions::MiscellaneousRequirement( "Malformed UTF-8 value in initialization of UCS-4 code point." );
509 }
510 else if( errno == E2BIG )
511 {
512 throw Exceptions::InternalError( "The UTF-8 source buffer contained more than one character when initializing a single UCS-4 code point." );
513 }
514 else
515 {
516 std::ostringstream msg;
517 msg << "iconv failed with an unrecognized error code: " << errno ;
518 throw Exceptions::InternalError( strrefdup( msg ) );
519 }
520 }
521 else if( outbytesleft != 0 )
522 {
523 throw Exceptions::InternalError( "Failed to initialize the entire UCS-4 code point when converting from UTF-8." );
524 }
525 }
526
527 void
528 Kernel::UnicodeCodePoint::decode_UCS4( const char ** src, size_t * src_avail )
529 {
530 if( *src_avail < 4 )
531 {
532 throw Exceptions::InternalError( "Not enough data available when initializing UCS-4 code point (needs four bytes)." );
533 }
534 memcpy( reinterpret_cast< char * >( & value_ ), *src, 4 );
535 *src += 4;
536 *src_avail -= 4;
537 }
538
539 void
540 Kernel::UnicodeCodePoint::decode_UCS4( const char * src )
541 {
542 memcpy( reinterpret_cast< char * >( & value_ ), src, 4 );
543 }
544
545 void
546 Kernel::UnicodeCodePoint::encode_UTF8( char ** dst, size_t * dst_avail ) const
547 {
548 static iconv_t converter = Helpers::requireUCS4ToUTF8Converter( );
549
550 const char * src = reinterpret_cast< const char * >( & value_ );
551 size_t inbytesleft = sizeof( value_ );
552
553 size_t count = iconv( converter,
554 ICONV_CAST( & src ), & inbytesleft,
555 dst, dst_avail );
556 if( count == (size_t)(-1) )
557 {
558 if( errno == EILSEQ )
559 {
560 throw Exceptions::InternalError( "Failed to convert UCS-4 code point to UTF-8." );
561 }
562 else if( errno == EINVAL )
563 {
564 throw Exceptions::InternalError( "Malformed UCS-4 value (in conversion to UTF-8)." );
565 }
566 else if( errno == E2BIG )
567 {
568 throw Exceptions::InternalError( "The UTF-8 destination buffer was too small when encoding a single UCS-4 code point." );
569 }
570 else
571 {
572 std::ostringstream msg;
573 msg << "iconv failed with an unrecognized error code: " << errno ;
574 throw Exceptions::InternalError( strrefdup( msg ) );
575 }
576 }
577 else if( inbytesleft != 0 )
578 {
579 throw Exceptions::InternalError( "Failed to use the entire UCS-4 code point when converting to UTF-8." );
580 }
581 }
582
583 void
584 Kernel::UnicodeCodePoint::encode_UTF16BE( char ** dst, size_t * dst_avail ) const
585 {
586 static iconv_t converter = Helpers::requireUCS4ToUTF16BEConverter( );
587
588 const char * src = reinterpret_cast< const char * >( & value_ );
589 size_t inbytesleft = sizeof( value_ );
590
591 size_t count = iconv( converter,
592 ICONV_CAST( & src ), & inbytesleft,
593 dst, dst_avail );
594 if( count == (size_t)(-1) )
595 {
596 if( errno == EILSEQ )
597 {
598 throw Exceptions::InternalError( "Failed to convert UCS-4 code point to UTF-16-BE." );
599 }
600 else if( errno == EINVAL )
601 {
602 throw Exceptions::InternalError( "Malformed UCS-4 value (in conversion to UTF-16-BE)." );
603 }
604 else if( errno == E2BIG )
605 {
606 throw Exceptions::InternalError( "The UTF-16-BE destination buffer was too small when encoding a single UCS-4 code point." );
607 }
608 else
609 {
610 std::ostringstream msg;
611 msg << "iconv failed with an unrecognized error code: " << errno ;
612 throw Exceptions::InternalError( strrefdup( msg ) );
613 }
614 }
615 else if( inbytesleft != 0 )
616 {
617 throw Exceptions::InternalError( "Failed to use the entire UCS-4 code point when converting to UTF-16-BE." );
618 }
619 }
620
621 void
622 Kernel::UnicodeCodePoint::decode_glyph_name( const char * name )
623 {
624 static const FontMetrics::GlyphList & glyphList = Helpers::requireGlyphList( );
625 if( ! glyphList.name_to_UCS4( name, & value_ ) )
626 {
627 std::ostringstream msg;
628 msg << "The glyph name \"" << name << "\" is not in the glyph list, and cannot be converted to a UCS-4 code point." ;
629 throw Exceptions::InternalError( strrefdup( msg ) );
630 }
631 }
632
633 Kernel::UnicodeCodePoint Kernel::UnicodeCodePoint::SPACE( 32 );
634 Kernel::UnicodeCodePoint Kernel::UnicodeCodePoint::NEWLINE( 10 );
Graphics language