/src/libfvde/libuna/libuna_codepage_windows_1255.c

Source (jump to first uncovered line)
/*
 * Windows 1255 codepage (Hebrew) functions
 *
 * Copyright (C) 2008-2024, Joachim Metz <joachim.metz@gmail.com>
 *
 * Refer to AUTHORS for acknowledgements.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include <common.h>
#include <types.h>

#include "libuna_codepage_windows_1255.h"
#include "libuna_libcerror.h"
#include "libuna_types.h"

/* Extended ASCII to Unicode character lookup table for the Windows 1255 codepage
 * Unknown are filled with the Unicode replacement character 0xfffd
 */
const uint16_t libuna_codepage_windows_1255_byte_stream_to_unicode_base_0x80[ 128 ] = {
  0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
  0x02c6, 0x2030, 0xfffd, 0x2039, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
  0x02dc, 0x2122, 0xfffd, 0x203a, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20aa, 0x00a5, 0x00a6, 0x00a7,
  0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
  0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
  0x05b0, 0x05b1, 0x05b2, 0x05b3, 0x05b4, 0x05b5, 0x05b6, 0x05b7,
  0x05b8, 0x05b9, 0xfffd, 0x05bb, 0x05bc, 0x05bd, 0x05be, 0x05bf,
  0x05c0, 0x05c1, 0x05c2, 0x05c3, 0x05f0, 0x05f1, 0x05f2, 0x05f3,
  0x05f4, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7,
  0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
  0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7,
  0x05e8, 0x05e9, 0x05ea, 0xfffd, 0xfffd, 0x200e, 0x200f, 0xfffd
};

/* Unicode to ASCII character lookup tables for the Windows 1255 codepage
 * Unknown are filled with the ASCII replacement character 0x1a
 */
const uint8_t libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x00a0[ 32 ] = {
  0xa0, 0xa1, 0xa2, 0xa3, 0x1a, 0xa5, 0xa6, 0xa7,
  0xa8, 0xa9, 0x1a, 0xab, 0xac, 0xad, 0xae, 0xaf,
  0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
  0xb8, 0xb9, 0x1a, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf
};

const uint8_t libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x05b0[ 24 ] = {
  0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
  0xc8, 0xc9, 0x1a, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
  0xd0, 0xd1, 0xd2, 0xd3, 0x1a, 0x1a, 0x1a, 0x1a
};

const uint8_t libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x05d0[ 40 ] = {
  0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
  0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
  0xf8, 0xf9, 0xfa, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
  0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0x1a, 0x1a, 0x1a
};

const uint8_t libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x2010[ 24 ] = {
  0x1a, 0x1a, 0x1a, 0x96, 0x97, 0x1a, 0x1a, 0x1a,
  0x91, 0x92, 0x82, 0x1a, 0x93, 0x94, 0x84, 0x1a,
  0x86, 0x87, 0x95, 0x1a, 0x1a, 0x1a, 0x85, 0x1a
};

/* Copies an Unicode character from a Windows 1255 encoded byte stream
 * Returns 1 if successful or -1 on error
 */
int libuna_codepage_windows_1255_copy_from_byte_stream(
     libuna_unicode_character_t *unicode_character,
     const uint8_t *byte_stream,
     size_t byte_stream_size,
     size_t *byte_stream_index,
     libcerror_error_t **error )
{
  static char *function                             = "libuna_codepage_windows_1255_copy_from_byte_stream";
  libuna_unicode_character_t safe_unicode_character = 0xfffd;
  size_t safe_byte_stream_index                     = 0;
  uint8_t byte_stream_character                     = 0;

  if( unicode_character == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid Unicode character.",
     function );

    return( -1 );
  }
  if( byte_stream == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid byte stream.",
     function );

    return( -1 );
  }
  if( byte_stream_size > (size_t) SSIZE_MAX )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
     "%s: invalid byte stream size value exceeds maximum.",
     function );

    return( -1 );
  }
  if( byte_stream_index == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid byte stream index.",
     function );

    return( -1 );
  }
  safe_byte_stream_index = *byte_stream_index;

  if( safe_byte_stream_index >= byte_stream_size )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
     "%s: byte stream too small.",
     function );

    return( -1 );
  }
  byte_stream_character = byte_stream[ safe_byte_stream_index++ ];

  if( byte_stream_character < 0x80 )
  {
    safe_unicode_character = byte_stream_character;
  }
  else
  {
    byte_stream_character -= 0x80;

    safe_unicode_character = libuna_codepage_windows_1255_byte_stream_to_unicode_base_0x80[ byte_stream_character ];
  }
  *unicode_character = safe_unicode_character;
  *byte_stream_index = safe_byte_stream_index;

  return( 1 );
}

/* Copies an Unicode character to a Windows 1255 encoded byte stream
 * Returns 1 if successful or -1 on error
 */
int libuna_codepage_windows_1255_copy_to_byte_stream(
     libuna_unicode_character_t unicode_character,
     uint8_t *byte_stream,
     size_t byte_stream_size,
     size_t *byte_stream_index,
     libcerror_error_t **error )
{
  static char *function         = "libuna_codepage_windows_1255_copy_to_byte_stream";
  size_t safe_byte_stream_index = 0;
  uint16_t byte_stream_value    = 0x001a;

  if( byte_stream == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid byte stream.",
     function );

    return( -1 );
  }
  if( byte_stream_size > (size_t) SSIZE_MAX )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
     "%s: invalid byte stream size value exceeds maximum.",
     function );

    return( -1 );
  }
  if( byte_stream_index == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid byte stream index.",
     function );

    return( -1 );
  }
  safe_byte_stream_index = *byte_stream_index;

  if( safe_byte_stream_index >= byte_stream_size )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
     "%s: byte stream too small.",
     function );

    return( -1 );
  }
  if( unicode_character < 0x0080 )
  {
    byte_stream_value = (uint16_t) unicode_character;
  }
  else if( ( unicode_character >= 0x00a0 )
        && ( unicode_character < 0x00c0 ) )
  {
    unicode_character -= 0x00a0;

    byte_stream_value = libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x00a0[ unicode_character ];
  }
  else if( ( unicode_character >= 0x05b0 )
        && ( unicode_character < 0x05c8 ) )
  {
    unicode_character -= 0x05b0;

    byte_stream_value = libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x05b0[ unicode_character ];
  }
  else if( ( unicode_character >= 0x05d0 )
        && ( unicode_character < 0x05f8 ) )
  {
    unicode_character -= 0x05d0;

    byte_stream_value = libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x05d0[ unicode_character ];
  }
  else if( ( unicode_character >= 0x2010 )
        && ( unicode_character < 0x2028 ) )
  {
    unicode_character -= 0x2010;

    byte_stream_value = libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x2010[ unicode_character ];
  }
  else switch( unicode_character )
  {
    case 0x00d7:
      byte_stream_value = 0xaa;
      break;

    case 0x00f7:
      byte_stream_value = 0xba;
      break;

    case 0x0192:
      byte_stream_value = 0x83;
      break;

    case 0x02c6:
      byte_stream_value = 0x88;
      break;

    case 0x02dc:
      byte_stream_value = 0x98;
      break;

    case 0x200e:
      byte_stream_value = 0xfd;
      break;

    case 0x200f:
      byte_stream_value = 0xfe;
      break;

    case 0x2030:
      byte_stream_value = 0x89;
      break;

    case 0x2039:
      byte_stream_value = 0x8b;
      break;

    case 0x203a:
      byte_stream_value = 0x9b;
      break;

    case 0x20aa:
      byte_stream_value = 0xa4;
      break;

    case 0x20ac:
      byte_stream_value = 0x80;
      break;

    case 0x2122:
      byte_stream_value = 0x99;
      break;

    default:
      byte_stream_value = 0x1a;
      break;
  }
  byte_stream[ safe_byte_stream_index++ ] = (uint8_t) ( byte_stream_value & 0x00ff );

  *byte_stream_index = safe_byte_stream_index;

  return( 1 );
}



Coverage Report

Created: 2024-02-25 07:20

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Windows 1255 codepage (Hebrew) functions
3		*
4		* Copyright (C) 2008-2024, Joachim Metz <joachim.metz@gmail.com>
5		*
6		* Refer to AUTHORS for acknowledgements.
7		*
8		* This program is free software: you can redistribute it and/or modify
9		* it under the terms of the GNU Lesser General Public License as published by
10		* the Free Software Foundation, either version 3 of the License, or
11		* (at your option) any later version.
12		*
13		* This program is distributed in the hope that it will be useful,
14		* but WITHOUT ANY WARRANTY; without even the implied warranty of
15		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16		* GNU General Public License for more details.
17		*
18		* You should have received a copy of the GNU Lesser General Public License
19		* along with this program. If not, see <https://www.gnu.org/licenses/>.
20		*/
21
22		#include <common.h>
23		#include <types.h>
24
25		#include "libuna_codepage_windows_1255.h"
26		#include "libuna_libcerror.h"
27		#include "libuna_types.h"
28
29		/* Extended ASCII to Unicode character lookup table for the Windows 1255 codepage
30		* Unknown are filled with the Unicode replacement character 0xfffd
31		*/
32		const uint16_t libuna_codepage_windows_1255_byte_stream_to_unicode_base_0x80[ 128 ] = {
33		0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
34		0x02c6, 0x2030, 0xfffd, 0x2039, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
35		0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
36		0x02dc, 0x2122, 0xfffd, 0x203a, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
37		0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20aa, 0x00a5, 0x00a6, 0x00a7,
38		0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
39		0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
40		0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
41		0x05b0, 0x05b1, 0x05b2, 0x05b3, 0x05b4, 0x05b5, 0x05b6, 0x05b7,
42		0x05b8, 0x05b9, 0xfffd, 0x05bb, 0x05bc, 0x05bd, 0x05be, 0x05bf,
43		0x05c0, 0x05c1, 0x05c2, 0x05c3, 0x05f0, 0x05f1, 0x05f2, 0x05f3,
44		0x05f4, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
45		0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7,
46		0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
47		0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7,
48		0x05e8, 0x05e9, 0x05ea, 0xfffd, 0xfffd, 0x200e, 0x200f, 0xfffd
49		};
50
51		/* Unicode to ASCII character lookup tables for the Windows 1255 codepage
52		* Unknown are filled with the ASCII replacement character 0x1a
53		*/
54		const uint8_t libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x00a0[ 32 ] = {
55		0xa0, 0xa1, 0xa2, 0xa3, 0x1a, 0xa5, 0xa6, 0xa7,
56		0xa8, 0xa9, 0x1a, 0xab, 0xac, 0xad, 0xae, 0xaf,
57		0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
58		0xb8, 0xb9, 0x1a, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf
59		};
60
61		const uint8_t libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x05b0[ 24 ] = {
62		0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
63		0xc8, 0xc9, 0x1a, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
64		0xd0, 0xd1, 0xd2, 0xd3, 0x1a, 0x1a, 0x1a, 0x1a
65		};
66
67		const uint8_t libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x05d0[ 40 ] = {
68		0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
69		0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
70		0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
71		0xf8, 0xf9, 0xfa, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
72		0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0x1a, 0x1a, 0x1a
73		};
74
75		const uint8_t libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x2010[ 24 ] = {
76		0x1a, 0x1a, 0x1a, 0x96, 0x97, 0x1a, 0x1a, 0x1a,
77		0x91, 0x92, 0x82, 0x1a, 0x93, 0x94, 0x84, 0x1a,
78		0x86, 0x87, 0x95, 0x1a, 0x1a, 0x1a, 0x85, 0x1a
79		};
80
81		/* Copies an Unicode character from a Windows 1255 encoded byte stream
82		* Returns 1 if successful or -1 on error
83		*/
84		int libuna_codepage_windows_1255_copy_from_byte_stream(
85		libuna_unicode_character_t *unicode_character,
86		const uint8_t *byte_stream,
87		size_t byte_stream_size,
88		size_t *byte_stream_index,
89		libcerror_error_t **error )
90	0	{
91	0	static char *function = "libuna_codepage_windows_1255_copy_from_byte_stream";
92	0	libuna_unicode_character_t safe_unicode_character = 0xfffd;
93	0	size_t safe_byte_stream_index = 0;
94	0	uint8_t byte_stream_character = 0;
95
96	0	if( unicode_character == NULL )
97	0	{
98	0	libcerror_error_set(
99	0	error,
100	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
101	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
102	0	"%s: invalid Unicode character.",
103	0	function );
104
105	0	return( -1 );
106	0	}
107	0	if( byte_stream == NULL )
108	0	{
109	0	libcerror_error_set(
110	0	error,
111	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
112	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
113	0	"%s: invalid byte stream.",
114	0	function );
115
116	0	return( -1 );
117	0	}
118	0	if( byte_stream_size > (size_t) SSIZE_MAX )
119	0	{
120	0	libcerror_error_set(
121	0	error,
122	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
123	0	LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
124	0	"%s: invalid byte stream size value exceeds maximum.",
125	0	function );
126
127	0	return( -1 );
128	0	}
129	0	if( byte_stream_index == NULL )
130	0	{
131	0	libcerror_error_set(
132	0	error,
133	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
134	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
135	0	"%s: invalid byte stream index.",
136	0	function );
137
138	0	return( -1 );
139	0	}
140	0	safe_byte_stream_index = *byte_stream_index;
141
142	0	if( safe_byte_stream_index >= byte_stream_size )
143	0	{
144	0	libcerror_error_set(
145	0	error,
146	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
147	0	LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
148	0	"%s: byte stream too small.",
149	0	function );
150
151	0	return( -1 );
152	0	}
153	0	byte_stream_character = byte_stream[ safe_byte_stream_index++ ];
154
155	0	if( byte_stream_character < 0x80 )
156	0	{
157	0	safe_unicode_character = byte_stream_character;
158	0	}
159	0	else
160	0	{
161	0	byte_stream_character -= 0x80;
162
163	0	safe_unicode_character = libuna_codepage_windows_1255_byte_stream_to_unicode_base_0x80[ byte_stream_character ];
164	0	}
165	0	*unicode_character = safe_unicode_character;
166	0	*byte_stream_index = safe_byte_stream_index;
167
168	0	return( 1 );
169	0	}
170
171		/* Copies an Unicode character to a Windows 1255 encoded byte stream
172		* Returns 1 if successful or -1 on error
173		*/
174		int libuna_codepage_windows_1255_copy_to_byte_stream(
175		libuna_unicode_character_t unicode_character,
176		uint8_t *byte_stream,
177		size_t byte_stream_size,
178		size_t *byte_stream_index,
179		libcerror_error_t **error )
180	0	{
181	0	static char *function = "libuna_codepage_windows_1255_copy_to_byte_stream";
182	0	size_t safe_byte_stream_index = 0;
183	0	uint16_t byte_stream_value = 0x001a;
184
185	0	if( byte_stream == NULL )
186	0	{
187	0	libcerror_error_set(
188	0	error,
189	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
190	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
191	0	"%s: invalid byte stream.",
192	0	function );
193
194	0	return( -1 );
195	0	}
196	0	if( byte_stream_size > (size_t) SSIZE_MAX )
197	0	{
198	0	libcerror_error_set(
199	0	error,
200	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
201	0	LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
202	0	"%s: invalid byte stream size value exceeds maximum.",
203	0	function );
204
205	0	return( -1 );
206	0	}
207	0	if( byte_stream_index == NULL )
208	0	{
209	0	libcerror_error_set(
210	0	error,
211	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
212	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
213	0	"%s: invalid byte stream index.",
214	0	function );
215
216	0	return( -1 );
217	0	}
218	0	safe_byte_stream_index = *byte_stream_index;
219
220	0	if( safe_byte_stream_index >= byte_stream_size )
221	0	{
222	0	libcerror_error_set(
223	0	error,
224	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
225	0	LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
226	0	"%s: byte stream too small.",
227	0	function );
228
229	0	return( -1 );
230	0	}
231	0	if( unicode_character < 0x0080 )
232	0	{
233	0	byte_stream_value = (uint16_t) unicode_character;
234	0	}
235	0	else if( ( unicode_character >= 0x00a0 )
236	0	&& ( unicode_character < 0x00c0 ) )
237	0	{
238	0	unicode_character -= 0x00a0;
239
240	0	byte_stream_value = libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x00a0[ unicode_character ];
241	0	}
242	0	else if( ( unicode_character >= 0x05b0 )
243	0	&& ( unicode_character < 0x05c8 ) )
244	0	{
245	0	unicode_character -= 0x05b0;
246
247	0	byte_stream_value = libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x05b0[ unicode_character ];
248	0	}
249	0	else if( ( unicode_character >= 0x05d0 )
250	0	&& ( unicode_character < 0x05f8 ) )
251	0	{
252	0	unicode_character -= 0x05d0;
253
254	0	byte_stream_value = libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x05d0[ unicode_character ];
255	0	}
256	0	else if( ( unicode_character >= 0x2010 )
257	0	&& ( unicode_character < 0x2028 ) )
258	0	{
259	0	unicode_character -= 0x2010;
260
261	0	byte_stream_value = libuna_codepage_windows_1255_unicode_to_byte_stream_base_0x2010[ unicode_character ];
262	0	}
263	0	else switch( unicode_character )
264	0	{
265	0	case 0x00d7:
266	0	byte_stream_value = 0xaa;
267	0	break;
268
269	0	case 0x00f7:
270	0	byte_stream_value = 0xba;
271	0	break;
272
273	0	case 0x0192:
274	0	byte_stream_value = 0x83;
275	0	break;
276
277	0	case 0x02c6:
278	0	byte_stream_value = 0x88;
279	0	break;
280
281	0	case 0x02dc:
282	0	byte_stream_value = 0x98;
283	0	break;
284
285	0	case 0x200e:
286	0	byte_stream_value = 0xfd;
287	0	break;
288
289	0	case 0x200f:
290	0	byte_stream_value = 0xfe;
291	0	break;
292
293	0	case 0x2030:
294	0	byte_stream_value = 0x89;
295	0	break;
296
297	0	case 0x2039:
298	0	byte_stream_value = 0x8b;
299	0	break;
300
301	0	case 0x203a:
302	0	byte_stream_value = 0x9b;
303	0	break;
304
305	0	case 0x20aa:
306	0	byte_stream_value = 0xa4;
307	0	break;
308
309	0	case 0x20ac:
310	0	byte_stream_value = 0x80;
311	0	break;
312
313	0	case 0x2122:
314	0	byte_stream_value = 0x99;
315	0	break;
316
317	0	default:
318	0	byte_stream_value = 0x1a;
319	0	break;
320	0	}
321	0	byte_stream[ safe_byte_stream_index++ ] = (uint8_t) ( byte_stream_value & 0x00ff );
322
323	0	*byte_stream_index = safe_byte_stream_index;
324
325	0	return( 1 );
326	0	}
327
328