MagickCore  7.0.8
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://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 
32  IsGlob(const char *);
33 
34 typedef struct
35 {
36  int
37  code_mask,
38  code_value,
39  utf_mask,
40  utf_value;
41 } UTFInfo;
42 
43 static UTFInfo
45  {
46  { 0x80, 0x00, 0x000007f, 0x0000000 }, /* 1 byte sequence */
47  { 0xE0, 0xC0, 0x00007ff, 0x0000080 }, /* 2 byte sequence */
48  { 0xF0, 0xE0, 0x000ffff, 0x0000800 }, /* 3 byte sequence */
49  { 0xF8, 0xF0, 0x01fffff, 0x0010000 }, /* 4 byte sequence */
50  { 0xFC, 0xF8, 0x03fffff, 0x0200000 }, /* 5 byte sequence */
51  { 0xFE, 0xFC, 0x7ffffff, 0x4000000 }, /* 6 byte sequence */
52  };
53 
54 static inline unsigned char *ConvertLatin1ToUTF8(const unsigned char *content)
55 {
56  int
57  c;
58 
59  register const unsigned char
60  *p;
61 
62  register unsigned char
63  *q;
64 
65  size_t
66  length;
67 
68  unsigned char
69  *utf8;
70 
71  length=0;
72  for (p=content; *p != '\0'; p++)
73  length+=(*p & 0x80) != 0 ? 2 : 1;
74  utf8=(unsigned char *) NULL;
75  if (~length >= 1)
76  utf8=(unsigned char *) AcquireQuantumMemory(length+1UL,sizeof(*utf8));
77  if (utf8 == (unsigned char *) NULL)
78  return((unsigned char *) NULL);
79  q=utf8;
80  for (p=content; *p != '\0'; p++)
81  {
82  c=(*p);
83  if ((c & 0x80) == 0)
84  *q++=(unsigned char) c;
85  else
86  {
87  *q++=(unsigned char) (0xc0 | ((c >> 6) & 0x3f));
88  *q++=(unsigned char) (0x80 | (c & 0x3f));
89  }
90  }
91  *q='\0';
92  return(utf8);
93 }
94 
95 static inline int GetNextUTFCode(const char *text,unsigned int *octets)
96 {
97  int
98  code;
99 
100  register ssize_t
101  i;
102 
103  register int
104  c,
105  unicode;
106 
107  *octets=1;
108  if (text == (const char *) NULL)
109  {
110  errno=EINVAL;
111  return(-1);
112  }
113  code=(int) (*text++) & 0xff;
114  unicode=code;
115  for (i=0; i < MaxMultibyteCodes; i++)
116  {
117  if ((code & utf_info[i].code_mask) == utf_info[i].code_value)
118  {
119  unicode&=utf_info[i].utf_mask;
120  if (unicode < utf_info[i].utf_value)
121  break;
122  *octets=(unsigned int) (i+1);
123  return(unicode);
124  }
125  c=(int) (*text++ ^ 0x80) & 0xff;
126  if ((c & 0xc0) != 0)
127  break;
128  if (unicode > 0x10FFFF)
129  break;
130  unicode=(unicode << 6) | c;
131  }
132  errno=EILSEQ;
133  return(-1);
134 }
135 
136 static inline int GetUTFCode(const char *text)
137 {
138  unsigned int
139  octets;
140 
141  return(GetNextUTFCode(text,&octets));
142 }
143 
144 static inline unsigned int GetUTFOctets(const char *text)
145 {
146  unsigned int
147  octets;
148 
149  (void) GetNextUTFCode(text,&octets);
150  return(octets);
151 }
152 
153 static inline MagickBooleanType IsUTFSpace(int code)
154 {
155  if (((code >= 0x0009) && (code <= 0x000d)) || (code == 0x0020) ||
156  (code == 0x0085) || (code == 0x00a0) || (code == 0x1680) ||
157  (code == 0x180e) || ((code >= 0x2000) && (code <= 0x200a)) ||
158  (code == 0x2028) || (code == 0x2029) || (code == 0x202f) ||
159  (code == 0x205f) || (code == 0x3000))
160  return(MagickTrue);
161  return(MagickFalse);
162 }
163 
164 static inline MagickBooleanType IsUTFValid(int code)
165 {
166  int
167  mask;
168 
169  mask=(int) 0x7fffffff;
170  if (((code & ~mask) != 0) && ((code < 0xd800) || (code > 0xdfff)) &&
171  (code != 0xfffe) && (code != 0xffff))
172  return(MagickFalse);
173  return(MagickTrue);
174 }
175 
176 static inline MagickBooleanType IsUTFAscii(int code)
177 {
178  int
179  mask;
180 
181  mask=(int) 0x7f;
182  if ((code & ~mask) != 0)
183  return(MagickFalse);
184  return(MagickTrue);
185 }
186 
187 #if defined(__cplusplus) || defined(c_plusplus)
188 }
189 #endif
190 
191 #endif
#define EILSEQ
Definition: token-private.h:26
int code_value
Definition: token-private.h:37
static MagickBooleanType IsUTFSpace(int code)
static MagickBooleanType IsUTFValid(int code)
int utf_value
Definition: token-private.h:37
int utf_mask
Definition: token-private.h:37
MagickBooleanType
Definition: magick-type.h:156
static int GetUTFCode(const char *text)
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
Definition: memory.c:533
static unsigned int GetUTFOctets(const char *text)
static unsigned char * ConvertLatin1ToUTF8(const unsigned char *content)
Definition: token-private.h:54
#define MaxMultibyteCodes
Definition: token-private.h:29
MagickPrivate MagickBooleanType IsGlob(const char *)
Definition: token.c:598
static UTFInfo utf_info[MaxMultibyteCodes]
Definition: token-private.h:44
static int GetNextUTFCode(const char *text, unsigned int *octets)
Definition: token-private.h:95
#define MagickPrivate
static MagickBooleanType IsUTFAscii(int code)