MagickCore  6.9.9
Convert, Edit, Or Compose Bitmap Images
token-private.h
Go to the documentation of this file.
1 /*
2  Copyright 1999-2018 ImageMagick Studio LLC, a non-profit organization
3  dedicated to making software imaging solutions freely available.
4 
5  You may not use this file except in compliance with the License.
6  obtain a copy of the License at
7 
8  https://www.imagemagick.org/script/license.php
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 
16  MagickCore private token methods.
17 */
18 #ifndef MAGICKCORE_TOKEN_PRIVATE_H
19 #define MAGICKCORE_TOKEN_PRIVATE_H
20 
21 #if defined(__cplusplus) || defined(c_plusplus)
22 extern "C" {
23 #endif
24 
25 #ifndef EILSEQ
26  #define EILSEQ ENOENT
27 #endif
28 
29 #define MaxMultibyteCodes 6
30 
31 typedef struct
32 {
33  int
34  code_mask,
35  code_value,
36  utf_mask,
37  utf_value;
38 } UTFInfo;
39 
40 static UTFInfo
42  {
43  { 0x80, 0x00, 0x000007f, 0x0000000 }, /* 1 byte sequence */
44  { 0xE0, 0xC0, 0x00007ff, 0x0000080 }, /* 2 byte sequence */
45  { 0xF0, 0xE0, 0x000ffff, 0x0000800 }, /* 3 byte sequence */
46  { 0xF8, 0xF0, 0x01fffff, 0x0010000 }, /* 4 byte sequence */
47  { 0xFC, 0xF8, 0x03fffff, 0x0200000 }, /* 5 byte sequence */
48  { 0xFE, 0xFC, 0x7ffffff, 0x4000000 }, /* 6 byte sequence */
49  };
50 
51 static inline unsigned char *ConvertLatin1ToUTF8(const unsigned char *content)
52 {
53  register const unsigned char
54  *p;
55 
56  register unsigned char
57  *q;
58 
59  size_t
60  length;
61 
62  unsigned char
63  *utf8;
64 
65  unsigned int
66  c;
67 
68  length=0;
69  for (p=content; *p != '\0'; p++)
70  length+=(*p & 0x80) != 0 ? 2 : 1;
71  utf8=(unsigned char *) NULL;
72  if (~length >= 1)
73  utf8=(unsigned char *) AcquireQuantumMemory(length+1UL,sizeof(*utf8));
74  if (utf8 == (unsigned char *) NULL)
75  return((unsigned char *) NULL);
76  q=utf8;
77  for (p=content; *p != '\0'; p++)
78  {
79  c=(*p);
80  if ((c & 0x80) == 0)
81  *q++=c;
82  else
83  {
84  *q++=0xc0 | ((c >> 6) & 0x3f);
85  *q++=0x80 | (c & 0x3f);
86  }
87  }
88  *q='\0';
89  return(utf8);
90 }
91 
92 static inline int GetNextUTFCode(const char *text,unsigned int *octets)
93 {
94  int
95  code;
96 
97  register ssize_t
98  i;
99 
100  register int
101  c,
102  unicode;
103 
104  *octets=1;
105  if (text == (const char *) NULL)
106  {
107  errno=EINVAL;
108  return(-1);
109  }
110  code=(int) (*text++) & 0xff;
111  unicode=code;
112  for (i=0; i < MaxMultibyteCodes; i++)
113  {
114  if ((code & utf_info[i].code_mask) == utf_info[i].code_value)
115  {
116  unicode&=utf_info[i].utf_mask;
117  if (unicode < utf_info[i].utf_value)
118  {
119  errno=EILSEQ;
120  return(-1);
121  }
122  *octets=(unsigned int) (i+1);
123  return(unicode);
124  }
125  c=(int) (*text++ ^ 0x80) & 0xff;
126  if ((c & 0xc0) != 0)
127  {
128  errno=EILSEQ;
129  return(-1);
130  }
131  unicode=(unicode << 6) | c;
132  }
133  errno=EILSEQ;
134  return(-1);
135 }
136 
137 static inline int GetUTFCode(const char *text)
138 {
139  unsigned int
140  octets;
141 
142  return(GetNextUTFCode(text,&octets));
143 }
144 
145 static inline unsigned int GetUTFOctets(const char *text)
146 {
147  unsigned int
148  octets;
149 
150  (void) GetNextUTFCode(text,&octets);
151  return(octets);
152 }
153 
154 static inline MagickBooleanType IsUTFSpace(int code)
155 {
156  if (((code >= 0x0009) && (code <= 0x000d)) || (code == 0x0020) ||
157  (code == 0x0085) || (code == 0x00a0) || (code == 0x1680) ||
158  (code == 0x180e) || ((code >= 0x2000) && (code <= 0x200a)) ||
159  (code == 0x2028) || (code == 0x2029) || (code == 0x202f) ||
160  (code == 0x205f) || (code == 0x3000))
161  return(MagickTrue);
162  return(MagickFalse);
163 }
164 
165 static inline MagickBooleanType IsUTFValid(int code)
166 {
167  int
168  mask;
169 
170  mask=(int) 0x7fffffff;
171  if (((code & ~mask) != 0) && ((code < 0xd800) || (code > 0xdfff)) &&
172  (code != 0xfffe) && (code != 0xffff))
173  return(MagickFalse);
174  return(MagickTrue);
175 }
176 
177 static inline MagickBooleanType IsUTFAscii(int code)
178 {
179  int
180  mask;
181 
182  mask=(int) 0x7f;
183  if ((code & ~mask) != 0)
184  return(MagickFalse);
185  return(MagickTrue);
186 }
187 
188 #if defined(__cplusplus) || defined(c_plusplus)
189 }
190 #endif
191 
192 #endif
#define EILSEQ
Definition: token-private.h:26
int code_value
Definition: token-private.h:34
Definition: token-private.h:31
static MagickBooleanType IsUTFSpace(int code)
Definition: token-private.h:154
static MagickBooleanType IsUTFValid(int code)
Definition: token-private.h:165
int utf_value
Definition: token-private.h:34
int utf_mask
Definition: token-private.h:34
MagickBooleanType
Definition: magick-type.h:189
static int GetUTFCode(const char *text)
Definition: token-private.h:137
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
Definition: memory.c:530
Definition: magick-type.h:192
static unsigned int GetUTFOctets(const char *text)
Definition: token-private.h:145
static unsigned char * ConvertLatin1ToUTF8(const unsigned char *content)
Definition: token-private.h:51
#define MaxMultibyteCodes
Definition: token-private.h:29
static UTFInfo utf_info[MaxMultibyteCodes]
Definition: token-private.h:41
static int GetNextUTFCode(const char *text, unsigned int *octets)
Definition: token-private.h:92
Definition: magick-type.h:191
static MagickBooleanType IsUTFAscii(int code)
Definition: token-private.h:177