?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Example: Changed glyph-outline.shape for use with FontConfig.
[shapes.git] / source / charconverters.cc
blob23c6e7d6235066d57d933bec8939adf938ecb18a
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 <string>
29 #include <fstream>
30 #include <sstream>
31
32
33
34 using namespace Shapes;
35
36 const char * Helpers::theUCS4EncodingName = "UCS-4-INTERNAL";
37
38 void
39 iconv_maybe_open( iconv_t * converter, const char * to_encoding, const char * from_encoding )
40 {
41 if( *converter == (iconv_t)( -1 ) )
42 {
43 *converter = iconv_open( to_encoding, from_encoding );
44 if( *converter == (iconv_t)( -1 ) )
45 {
46 std::ostringstream msg;
47 msg << "iconv_open failed to create converter from " << from_encoding << " to " << to_encoding << "." ;
48 throw Exceptions::ExternalError( strrefdup( msg ) );
49 }
50 }
51 }
52
53 iconv_t
54 Helpers::requireUTF8ToMacRomanConverter( bool cleanup )
55 {
56 static iconv_t converter = (iconv_t)( - 1 );
57 if( cleanup )
58 {
59 if( converter != (iconv_t)( -1 ) )
60 {
61 iconv_close( converter );
62 converter = (iconv_t)( -1 );
63 }
64 }
65 else
66 {
67 iconv_maybe_open( & converter,
68 "Macintosh", // This is meant to be what is called MacRoman in PDF.
69 "UTF-8" );
70 }
71 return converter;
72 }
73
74 iconv_t
75 Helpers::requireMacRomanToUTF8Converter( bool cleanup )
76 {
77 static iconv_t converter = (iconv_t)( - 1 );
78 if( cleanup )
79 {
80 if( converter != (iconv_t)( -1 ) )
81 {
82 iconv_close( converter );
83 converter = (iconv_t)( -1 );
84 }
85 }
86 else
87 {
88 iconv_maybe_open( & converter,
89 "UTF-8",
90 "Macintosh" ); // This is meant to be what is called MacRoman in PDF.
91 }
92 return converter;
93 }
94
95 iconv_t
96 Helpers::requireUTF8ToASCIIConverter( bool cleanup )
97 {
98 static iconv_t converter = (iconv_t)( - 1 );
99 if( cleanup )
100 {
101 if( converter != (iconv_t)( -1 ) )
102 {
103 iconv_close( converter );
104 converter = (iconv_t)( -1 );
105 }
106 }
107 else
108 {
109 iconv_maybe_open( & converter,
110 "ASCII", // This is used for the names of glyphs in a font
111 "UTF-8" );
112 }
113 return converter;
114 }
115
116 iconv_t
117 Helpers::requireUTF8ToUCS4Converter( bool cleanup )
118 {
119 static iconv_t converter = (iconv_t)( - 1 );
120 if( cleanup )
121 {
122 if( converter != (iconv_t)( -1 ) )
123 {
124 iconv_close( converter );
125 converter = (iconv_t)( -1 );
126 }
127 }
128 else
129 {
130 iconv_maybe_open( & converter,
131 Helpers::theUCS4EncodingName,
132 "UTF-8" );
133 }
134 return converter;
135 }
136
137 iconv_t
138 Helpers::requireUCS4ToUTF8Converter( bool cleanup )
139 {
140 static iconv_t converter = (iconv_t)( - 1 );
141 if( cleanup )
142 {
143 if( converter != (iconv_t)( -1 ) )
144 {
145 iconv_close( converter );
146 converter = (iconv_t)( -1 );
147 }
148 }
149 else
150 {
151 iconv_maybe_open( & converter,
152 "UTF-8",
153 Helpers::theUCS4EncodingName );
154 }
155 return converter;
156 }
157
158 iconv_t
159 Helpers::requireUCS4ToMacRomanConverter( bool cleanup )
160 {
161 static iconv_t converter = (iconv_t)( - 1 );
162 if( cleanup )
163 {
164 if( converter != (iconv_t)( -1 ) )
165 {
166 iconv_close( converter );
167 converter = (iconv_t)( -1 );
168 }
169 }
170 else
171 {
172 iconv_maybe_open( & converter,
173 "MacRoman",
174 Helpers::theUCS4EncodingName );
175 }
176 return converter;
177 }
178
179 iconv_t
180 Helpers::requireUTF16BEToUCS4Converter( bool cleanup )
181 {
182 static iconv_t converter = (iconv_t)( - 1 );
183 if( cleanup )
184 {
185 if( converter != (iconv_t)( -1 ) )
186 {
187 iconv_close( converter );
188 converter = (iconv_t)( -1 );
189 }
190 }
191 else
192 {
193 iconv_maybe_open( & converter,
194 Helpers::theUCS4EncodingName,
195 "UTF-16BE" );
196 }
197 return converter;
198 }
199
200 iconv_t
201 Helpers::requireUCS4ToUTF16BEConverter( bool cleanup )
202 {
203 static iconv_t converter = (iconv_t)( - 1 );
204 if( cleanup )
205 {
206 if( converter != (iconv_t)( -1 ) )
207 {
208 iconv_close( converter );
209 converter = (iconv_t)( -1 );
210 }
211 }
212 else
213 {
214 iconv_maybe_open( & converter,
215 "UTF-16BE",
216 Helpers::theUCS4EncodingName );
217 }
218 return converter;
219 }
220
221 iconv_t
222 Helpers::requireUTF8ToWinANSIConverter( bool cleanup )
223 {
224 static iconv_t converter = (iconv_t)( - 1 );
225 if( cleanup )
226 {
227 if( converter != (iconv_t)( -1 ) )
228 {
229 iconv_close( converter );
230 converter = (iconv_t)( -1 );
231 }
232 }
233 else
234 {
235 iconv_maybe_open( & converter,
236 "LATIN1", // This is meant to be what is called WinANSI in PDF.
237 "UTF-8" );
238 }
239 return converter;
240 }
241
242 iconv_t
243 Helpers::requireUTF8ToUTF16BEConverter( bool cleanup )
244 {
245 static iconv_t converter = (iconv_t)( - 1 );
246 if( cleanup )
247 {
248 if( converter != (iconv_t)( -1 ) )
249 {
250 iconv_close( converter );
251 converter = (iconv_t)( -1 );
252 }
253 }
254 else
255 {
256 iconv_maybe_open( & converter,
257 "UTF-16BE",
258 "UTF-8" );
259 }
260 return converter;
261 }
262
263 const FontMetrics::GlyphList &
264 Helpers::requireGlyphList( bool cleanup )
265 {
266 static const FontMetrics::GlyphList * converter = 0;
267 if( cleanup )
268 {
269 if( converter != 0 )
270 {
271 delete converter;
272 converter = 0;
273 }
274 }
275 else
276 {
277 if( converter == 0 )
278 {
279 std::string filename = Lang::Font::searchGlyphList( );
280 std::ifstream iFile( filename.c_str( ) );
281 if( ! iFile.is_open( ) )
282 {
283 std::ostringstream oss;
284 oss << "Could locate, but not open the glyph list " << filename ;
285 throw Exceptions::ExternalError( strrefdup( oss ) );
286 }
287 try
288 {
289 converter = new FontMetrics::GlyphList( iFile );
290 }
291 catch( const char * ball )
292 {
293 std::ostringstream oss;
294 oss << "Parsing the glyph list " << filename << " resulted in the error: " << ball ;
295 throw Exceptions::ExternalError( strrefdup( oss ) );
296 }
297 catch( const std::string ball )
298 {
299 std::ostringstream oss;
300 oss << "Parsing the glyph list " << filename << " resulted in the error: " << ball ;
301 throw Exceptions::ExternalError( strrefdup( oss ) );
302 }
303 catch( const Shapes::Exceptions::Exception & ball )
304 {
305 std::cerr << "Parsing the glyph list " << filename << " resulted an error. Rethrowing." << std::endl ;
306 throw;
307 }
308 catch( ... )
309 {
310 throw Exceptions::InternalError( "An unrecognized exception was caught from glyph list parsing." );
311 }
312 }
313 }
314 return *converter;
315 }
316
317 const FontMetrics::CharacterEncoding &
318 Helpers::requireMacRomanEncoding( bool cleanup )
319 {
320 static const FontMetrics::CharacterEncoding * converter = 0;
321 if( cleanup )
322 {
323 if( converter != 0 )
324 {
325 delete converter;
326 converter = 0;
327 }
328 }
329 else
330 {
331 if( converter == 0 )
332 {
333 std::string filename = Lang::Font::searchCharacterEncoding( "MacRoman" );
334 std::ifstream iFile( filename.c_str( ) );
335 if( ! iFile.is_open( ) )
336 {
337 std::ostringstream oss;
338 oss << "Could locate, but not open the character encoding " << filename ;
339 throw Exceptions::ExternalError( strrefdup( oss ) );
340 }
341 try
342 {
343 converter = new FontMetrics::CharacterEncoding( iFile );
344 }
345 catch( const char * ball )
346 {
347 std::ostringstream oss;
348 oss << "Parsing the character encoding " << filename << " resulted in the error: " << ball ;
349 throw Exceptions::ExternalError( strrefdup( oss ) );
350 }
351 catch( const std::string ball )
352 {
353 std::ostringstream oss;
354 oss << "Parsing the character encoding " << filename << " resulted in the error: " << ball ;
355 throw Exceptions::ExternalError( strrefdup( oss ) );
356 }
357 catch( const Shapes::Exceptions::Exception & ball )
358 {
359 std::cerr << "Parsing the character encoding " << filename << " resulted an error. Rethrowing." << std::endl ;
360 throw;
361 }
362 catch( ... )
363 {
364 throw Exceptions::InternalError( "An unrecognized exception was caught from character encoding parsing." );
365 }
366 }
367 }
368 return *converter;
369 }
370
371 unsigned char
372 Kernel::UnicodeCodePoint::get_MacRoman( ) const
373 {
374 static iconv_t converter = Helpers::requireUCS4ToMacRomanConverter( );
375
376 const size_t BUF_SIZE = 1;
377 char buf[ BUF_SIZE ];
378 char * dst = buf;
379 size_t outbytesleft = BUF_SIZE;
380
381 const char * src = reinterpret_cast< const char * >( & value_ );
382 size_t inbytesleft = sizeof( value_ );
383
384 size_t count = iconv( converter,
385 ICONV_CAST( & src ), & inbytesleft,
386 & dst, & outbytesleft );
387 if( count == (size_t)(-1) )
388 {
389 if( errno == EILSEQ )
390 {
391 std::cerr << "Unicode: " << std::hex << value_ << std::endl ;
392 throw Exceptions::MiscellaneousRequirement( "The UCS-4 code point cannot be represented in MacRoman encodig." );
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