2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6 % TTTTT OOO K K EEEEE N N %
8 % T O O KKK EEE N N N %
10 % T OOO K K EEEEE N N %
13 % MagickCore Token Methods %
20 % Copyright 1999-2018 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
26 % https://www.imagemagick.org/script/license.php %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
43 #include "MagickCore/studio.h"
44 #include "MagickCore/exception.h"
45 #include "MagickCore/exception-private.h"
46 #include "MagickCore/image.h"
47 #include "MagickCore/image-private.h"
48 #include "MagickCore/memory_.h"
49 #include "MagickCore/memory-private.h"
50 #include "MagickCore/string_.h"
51 #include "MagickCore/string-private.h"
52 #include "MagickCore/token.h"
53 #include "MagickCore/token-private.h"
54 #include "MagickCore/utility.h"
55 #include "MagickCore/utility-private.h"
58 Typedef declaractions.
79 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
83 % A c q u i r e T o k e n I n f o %
87 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
89 % AcquireTokenInfo() allocates the TokenInfo structure.
91 % The format of the AcquireTokenInfo method is:
93 % TokenInfo *AcquireTokenInfo()
96 MagickExport TokenInfo *AcquireTokenInfo(void)
101 token_info=(TokenInfo *) AcquireCriticalMemory(sizeof(*token_info));
102 token_info->signature=MagickCoreSignature;
107 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
111 % D e s t r o y T o k e n I n f o %
115 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
117 % DestroyTokenInfo() deallocates memory associated with an TokenInfo
120 % The format of the DestroyTokenInfo method is:
122 % TokenInfo *DestroyTokenInfo(TokenInfo *token_info)
124 % A description of each parameter follows:
126 % o token_info: Specifies a pointer to an TokenInfo structure.
129 MagickExport TokenInfo *DestroyTokenInfo(TokenInfo *token_info)
131 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
132 assert(token_info != (TokenInfo *) NULL);
133 assert(token_info->signature == MagickCoreSignature);
134 token_info->signature=(~MagickCoreSignature);
135 token_info=(TokenInfo *) RelinquishMagickMemory(token_info);
140 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
144 + G e t N e x t T o k e n %
148 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
150 % GetNextToken() gets a token from the token stream. A token is defined as
151 % a sequence of characters delimited by whitespace (e.g. clip-path), a
152 % sequence delimited with quotes (.e.g "Quote me"), or a sequence enclosed in
153 % parenthesis (e.g. rgb(0,0,0)). GetNextToken() also recognizes these
154 % separator characters: ':', '=', ',', and ';'.
156 % The format of the GetNextToken method is:
158 % void GetNextToken(const char *start,const char **end,
159 % const size_t extent,char *token)
161 % A description of each parameter follows:
163 % o start: the start of the token sequence.
165 % o end: point to the end of the token sequence.
167 % o extent: maximum extent of the token.
169 % o token: copy the token to this buffer.
172 MagickExport void GetNextToken(const char *start,const char **end,
173 const size_t extent,char *token)
187 assert(start != (const char *) NULL);
188 assert(token != (char *) NULL);
190 length=strlen(start);
192 while ((isspace((int) ((unsigned char) *p)) != 0) && (*p != '\0'))
208 case '"': escape='"'; break;
209 case '\'': escape='\''; break;
210 case '`': escape='\''; break;
211 case '{': escape='}'; break;
212 default: escape=(*p); break;
214 for (p++; *p != '\0'; p++)
216 if ((*p == '\\') && ((*(p+1) == escape) || (*(p+1) == '\\')))
224 if (i < (ssize_t) (extent-1))
226 if ((size_t) (p-start) >= length)
233 if (i < (ssize_t) (extent-1))
236 if ((*p == '>') || (*p == '/'))
238 if (i < (ssize_t) (extent-1))
249 value=StringToDouble(p,&q);
251 if ((p != q) && (*p != ','))
253 for ( ; (p < q) && (*p != ','); p++)
255 if (i < (ssize_t) (extent-1))
257 if ((size_t) (p-start) >= length)
262 if (i < (ssize_t) (extent-1))
268 if ((*p != '\0') && (isalpha((int) ((unsigned char) *p)) == 0) &&
269 (*p != *DirectorySeparator) && (*p != '#') && (*p != '<'))
271 if (i < (ssize_t) (extent-1))
276 for ( ; *p != '\0'; p++)
278 if (((isspace((int) ((unsigned char) *p)) != 0) || (*p == '=') ||
279 (*p == ',') || (*p == ':') || (*p == ';')) && (*(p-1) != '\\'))
281 if ((i > 0) && (*p == '<'))
283 if (i < (ssize_t) (extent-1))
288 for (p++; *p != '\0'; p++)
290 if (i < (ssize_t) (extent-1))
292 if ((*p == ')') && (*(p-1) != '\\'))
294 if ((size_t) (p-start) >= length)
297 if ((size_t) (p-start) >= length)
304 if ((LocaleNCompare(token,"url(",4) == 0) && (strlen(token) > 5))
310 if (token[offset] == '#')
312 i=(ssize_t) strlen(token);
315 (void) CopyMagickString(token,token+offset,MagickPathExtent);
316 token[i-offset-1]='\0';
319 while (isspace((int) ((unsigned char) *p)) != 0)
321 if (end != (const char **) NULL)
322 *end=(const char *) p;
326 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
330 % G l o b E x p r e s s i o n %
334 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
336 % GlobExpression() returns MagickTrue if the expression matches the pattern.
338 % The format of the GlobExpression function is:
340 % MagickBooleanType GlobExpression(const char *expression,
341 % const char *pattern,const MagickBooleanType case_insensitive)
343 % A description of each parameter follows:
345 % o expression: Specifies a pointer to a text string containing a file name.
347 % o pattern: Specifies a pointer to a text string containing a pattern.
349 % o case_insensitive: set to MagickTrue to ignore the case when matching
353 MagickExport MagickBooleanType GlobExpression(const char *expression,
354 const char *pattern,const MagickBooleanType case_insensitive)
364 Return on empty pattern or '*'.
366 if (pattern == (char *) NULL)
368 if (GetUTFCode(pattern) == 0)
370 if (LocaleCompare(pattern,"*") == 0)
372 p=pattern+strlen(pattern)-1;
373 if ((GetUTFCode(p) == ']') && (strchr(pattern,'[') != (char *) NULL))
382 Determine if pattern is a scene, i.e. img0001.pcd[2].
384 image_info=AcquireImageInfo();
385 (void) CopyMagickString(image_info->filename,pattern,MagickPathExtent);
386 exception=AcquireExceptionInfo();
387 (void) SetImageInfo(image_info,0,exception);
388 exception=DestroyExceptionInfo(exception);
389 if (LocaleCompare(image_info->filename,pattern) != 0)
391 image_info=DestroyImageInfo(image_info);
394 image_info=DestroyImageInfo(image_info);
397 Evaluate glob expression.
400 while ((GetUTFCode(pattern) != 0) && (done == MagickFalse))
402 if (GetUTFCode(expression) == 0)
403 if ((GetUTFCode(pattern) != '{') && (GetUTFCode(pattern) != '*'))
405 switch (GetUTFCode(pattern))
413 while (GetUTFCode(pattern) == '*')
414 pattern+=GetUTFOctets(pattern);
415 while ((GetUTFCode(expression) != 0) && (status == MagickFalse))
417 status=GlobExpression(expression,pattern,case_insensitive);
418 expression+=GetUTFOctets(expression);
420 if (status != MagickFalse)
422 while (GetUTFCode(expression) != 0)
423 expression+=GetUTFOctets(expression);
424 while (GetUTFCode(pattern) != 0)
425 pattern+=GetUTFOctets(pattern);
434 pattern+=GetUTFOctets(pattern);
437 if ((GetUTFCode(pattern) == 0) || (GetUTFCode(pattern) == ']'))
442 if (GetUTFCode(pattern) == '\\')
444 pattern+=GetUTFOctets(pattern);
445 if (GetUTFCode(pattern) == 0)
451 if (GetUTFCode(pattern+GetUTFOctets(pattern)) == '-')
453 c=GetUTFCode(pattern);
454 pattern+=GetUTFOctets(pattern);
455 pattern+=GetUTFOctets(pattern);
456 if (GetUTFCode(pattern) == ']')
461 if (GetUTFCode(pattern) == '\\')
463 pattern+=GetUTFOctets(pattern);
464 if (GetUTFCode(pattern) == 0)
470 if ((GetUTFCode(expression) < c) ||
471 (GetUTFCode(expression) > GetUTFCode(pattern)))
473 pattern+=GetUTFOctets(pattern);
478 if (GetUTFCode(pattern) != GetUTFCode(expression))
480 pattern+=GetUTFOctets(pattern);
483 pattern+=GetUTFOctets(pattern);
484 while ((GetUTFCode(pattern) != ']') && (GetUTFCode(pattern) != 0))
486 if ((GetUTFCode(pattern) == '\\') &&
487 (GetUTFCode(pattern+GetUTFOctets(pattern)) > 0))
488 pattern+=GetUTFOctets(pattern);
489 pattern+=GetUTFOctets(pattern);
491 if (GetUTFCode(pattern) != 0)
493 pattern+=GetUTFOctets(pattern);
494 expression+=GetUTFOctets(expression);
502 pattern+=GetUTFOctets(pattern);
503 expression+=GetUTFOctets(expression);
514 target=AcquireString(pattern);
516 while ((GetUTFCode(pattern) != '}') && (GetUTFCode(pattern) != 0))
519 if ((GetUTFCode(pattern) == ',') || (GetUTFCode(pattern) == '}'))
522 match=GlobExpression(expression,target,case_insensitive);
523 if (match != MagickFalse)
525 expression+=MagickMin(strlen(expression),strlen(target));
529 pattern+=GetUTFOctets(pattern);
532 while ((GetUTFCode(pattern) != '}') && (GetUTFCode(pattern) != 0))
533 pattern+=GetUTFOctets(pattern);
534 if (GetUTFCode(pattern) != 0)
535 pattern+=GetUTFOctets(pattern);
536 target=DestroyString(target);
541 pattern+=GetUTFOctets(pattern);
542 if (GetUTFCode(pattern) == 0)
547 if (case_insensitive != MagickFalse)
549 if (tolower((int) GetUTFCode(expression)) !=
550 tolower((int) GetUTFCode(pattern)))
557 if (GetUTFCode(expression) != GetUTFCode(pattern))
562 expression+=GetUTFOctets(expression);
563 pattern+=GetUTFOctets(pattern);
567 while (GetUTFCode(pattern) == '*')
568 pattern+=GetUTFOctets(pattern);
569 match=(GetUTFCode(expression) == 0) && (GetUTFCode(pattern) == 0) ?
570 MagickTrue : MagickFalse;
575 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
583 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
585 % IsGlob() returns MagickTrue if the path specification contains a globbing
588 % The format of the IsGlob method is:
590 % MagickBooleanType IsGlob(const char *geometry)
592 % A description of each parameter follows:
597 MagickPrivate MagickBooleanType IsGlob(const char *path)
600 status = MagickFalse;
605 if (IsPathAccessible(path) != MagickFalse)
607 for (p=path; *p != '\0'; p++)
629 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
633 % T o k e n i z e r %
637 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
639 % Tokenizer() is a generalized, finite state token parser. It extracts tokens
640 % one at a time from a string of characters. The characters used for white
641 % space, for break characters, and for quotes can be specified. Also,
642 % characters in the string can be preceded by a specifiable escape character
643 % which removes any special meaning the character may have.
645 % Here is some terminology:
647 % o token: A single unit of information in the form of a group of
650 % o white space: Apace that gets ignored (except within quotes or when
651 % escaped), like blanks and tabs. in addition, white space terminates a
654 % o break set: One or more characters that separates non-quoted tokens.
655 % Commas are a common break character. The usage of break characters to
656 % signal the end of a token is the same as that of white space, except
657 % multiple break characters with nothing or only white space between
658 % generate a null token for each two break characters together.
660 % For example, if blank is set to be the white space and comma is set to
661 % be the break character, the line
665 % ... consists of 5 tokens:
670 % 4) "" (the null string)
673 % o Quote character: A character that, when surrounding a group of other
674 % characters, causes the group of characters to be treated as a single
675 % token, no matter how many white spaces or break characters exist in
676 % the group. Also, a token always terminates after the closing quote.
677 % For example, if ' is the quote character, blank is white space, and
678 % comma is the break character, the following string
682 % ... consists of 4 tokens:
685 % 2) " B, CD" (note the blanks & comma)
689 % The quote characters themselves do not appear in the resultant
690 % tokens. The double quotes are delimiters i use here for
691 % documentation purposes only.
693 % o Escape character: A character which itself is ignored but which
694 % causes the next character to be used as is. ^ and \ are often used
695 % as escape characters. An escape in the last position of the string
696 % gets treated as a "normal" (i.e., non-quote, non-white, non-break,
697 % and non-escape) character. For example, assume white space, break
698 % character, and quote are the same as in the above examples, and
699 % further, assume that ^ is the escape character. Then, in the string
701 % ABC, ' DEF ^' GH' I ^ J K^ L ^
703 % ... there are 7 tokens:
708 % 4) " " (a lone blank)
711 % 7) "^" (passed as is at end of line)
713 % The format of the Tokenizer method is:
715 % int Tokenizer(TokenInfo *token_info,const unsigned flag,char *token,
716 % const size_t max_token_length,const char *line,const char *white,
717 % const char *break_set,const char *quote,const char escape,
718 % char *breaker,int *next,char *quoted)
720 % A description of each parameter follows:
722 % o flag: right now, only the low order 3 bits are used.
724 % 1 => convert non-quoted tokens to upper case
725 % 2 => convert non-quoted tokens to lower case
726 % 0 => do not convert non-quoted tokens
728 % o token: a character string containing the returned next token
730 % o max_token_length: the maximum size of "token". Characters beyond
731 % "max_token_length" are truncated.
733 % o string: the string to be parsed.
735 % o white: a string of the valid white spaces. example:
737 % char whitesp[]={" \t"};
739 % blank and tab will be valid white space.
741 % o break: a string of the valid break characters. example:
743 % char breakch[]={";,"};
745 % semicolon and comma will be valid break characters.
747 % o quote: a string of the valid quote characters. An example would be
749 % char whitesp[]={"'\"");
751 % (this causes single and double quotes to be valid) Note that a
752 % token starting with one of these characters needs the same quote
753 % character to terminate it.
759 % is unterminated, but
763 % are properly terminated. Note that different quote characters
764 % can appear on the same line; only for a given token do the quote
765 % characters have to be the same.
767 % o escape: the escape character (NOT a string ... only one
768 % allowed). Use zero if none is desired.
770 % o breaker: the break character used to terminate the current
771 % token. If the token was quoted, this will be the quote used. If
772 % the token is the last one on the line, this will be zero.
774 % o next: this variable points to the first character of the
775 % next token. it gets reset by "tokenizer" as it steps through the
776 % string. Set it to 0 upon initialization, and leave it alone
777 % after that. You can change it if you want to jump around in the
778 % string or re-parse from the beginning, but be careful.
780 % o quoted: set to True if the token was quoted and MagickFalse
781 % if not. You may need this information (for example: in C, a
782 % string with quotes around it is a character string, while one
783 % without is an identifier).
785 % o result: 0 if we haven't reached EOS (end of string), and 1
795 static ssize_t sindex(int c,const char *string)
800 for (p=string; *p != '\0'; p++)
802 return((ssize_t) (p-string));
806 static void StoreToken(TokenInfo *token_info,char *string,
807 size_t max_token_length,int c)
812 if ((token_info->offset < 0) ||
813 ((size_t) token_info->offset >= (max_token_length-1)))
815 i=token_info->offset++;
817 if (token_info->state == IN_QUOTE)
819 switch (token_info->flag & 0x03)
823 string[i]=(char) toupper(c);
828 string[i]=(char) tolower(c);
836 MagickExport int Tokenizer(TokenInfo *token_info,const unsigned flag,
837 char *token,const size_t max_token_length,const char *line,const char *white,
838 const char *break_set,const char *quote,const char escape,char *breaker,
839 int *next,char *quoted)
849 if (line[*next] == '\0')
851 token_info->state=IN_WHITE;
852 token_info->quote=(char) MagickFalse;
853 token_info->flag=flag;
854 for (token_info->offset=0; (int) line[*next] != 0; (*next)++)
857 i=sindex(c,break_set);
860 switch (token_info->state)
867 *breaker=break_set[i];
868 token[token_info->offset]='\0';
873 StoreToken(token_info,token,max_token_length,c);
882 switch (token_info->state)
886 token_info->state=IN_QUOTE;
887 token_info->quote=quote[i];
888 *quoted=(char) MagickTrue;
893 if (quote[i] != token_info->quote)
894 StoreToken(token_info,token,max_token_length,c);
897 token_info->state=IN_OZONE;
898 token_info->quote='\0';
906 token[token_info->offset]='\0';
915 switch (token_info->state)
922 token_info->state=IN_OZONE;
927 StoreToken(token_info,token,max_token_length,c);
933 if (c == (int) escape)
935 if (line[(*next)+1] == '\0')
938 StoreToken(token_info,token,max_token_length,c);
940 token[token_info->offset]='\0';
943 switch (token_info->state)
948 token_info->state=IN_TOKEN;
956 StoreToken(token_info,token,max_token_length,c);
961 token[token_info->offset]='\0';
967 switch (token_info->state)
971 token_info->state=IN_TOKEN;
972 StoreToken(token_info,token,max_token_length,c);
978 StoreToken(token_info,token,max_token_length,c);
983 token[token_info->offset]='\0';
988 token[token_info->offset]='\0';