MagickCore  7.0.7
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 
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  {
122  errno=EILSEQ;
123  return(-1);
124  }
125  *octets=(unsigned int) (i+1);
126  return(unicode);
127  }
128  c=(int) (*text++ ^ 0x80) & 0xff;
129  if ((c & 0xc0) != 0)
130  {
131  errno=EILSEQ;
132  return(-1);
133  }
134  unicode=(unicode << 6) | c;
135  }
136  errno=EILSEQ;
137  return(-1);
138 }
139 
140 static inline int GetUTFCode(const char *text)
141 {
142  unsigned int
143  octets;
144 
145  return(GetNextUTFCode(text,&octets));
146 }
147 
148 static inline unsigned int GetUTFOctets(const char *text)
149 {
150  unsigned int
151  octets;
152 
153  (void) GetNextUTFCode(text,&octets);
154  return(octets);
155 }
156 
157 static inline MagickBooleanType IsUTFSpace(int code)
158 {
159  if (((code >= 0x0009) && (code <= 0x000d)) || (code == 0x0020) ||
160  (code == 0x0085) || (code == 0x00a0) || (code == 0x1680) ||
161  (code == 0x180e) || ((code >= 0x2000) && (code <= 0x200a)) ||
162  (code == 0x2028) || (code == 0x2029) || (code == 0x202f) ||
163  (code == 0x205f) || (code == 0x3000))
164  return(MagickTrue);
165  return(MagickFalse);
166 }
167 
168 static inline MagickBooleanType IsUTFValid(int code)
169 {
170  int
171  mask;
172 
173  mask=(int) 0x7fffffff;
174  if (((code & ~mask) != 0) && ((code < 0xd800) || (code > 0xdfff)) &&
175  (code != 0xfffe) && (code != 0xffff))
176  return(MagickFalse);
177  return(MagickTrue);
178 }
179 
180 static inline MagickBooleanType IsUTFAscii(int code)
181 {
182  int
183  mask;
184 
185  mask=(int) 0x7f;
186  if ((code & ~mask) != 0)
187  return(MagickFalse);
188  return(MagickTrue);
189 }
190 
191 #if defined(__cplusplus) || defined(c_plusplus)
192 }
193 #endif
194 
195 #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:529
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:619
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)