487 lines
17 KiB
C
487 lines
17 KiB
C
/*
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
% %
|
||
% %
|
||
% SSS CCC RRRR III PPPP TTTTT TTTTT OOO K K EEEE N N %
|
||
% S C R R I P P T T O O K K E NN N %
|
||
% SSS C RRRR I PPPP T T O O KK EEE N N N %
|
||
% S C R R I P T T O O K K E N NN %
|
||
% SSSS CCC R RR III P T T OOO K K EEEE N N %
|
||
% %
|
||
% Tokenize Magick Script into Options %
|
||
% %
|
||
% Dragon Computing %
|
||
% Anthony Thyssen %
|
||
% January 2012 %
|
||
% %
|
||
% %
|
||
% Copyright 1999-2021 ImageMagick Studio LLC, a non-profit organization %
|
||
% dedicated to making software imaging solutions freely available. %
|
||
% %
|
||
% You may not use this file except in compliance with the License. You may %
|
||
% obtain a copy of the License at %
|
||
% %
|
||
% https://imagemagick.org/script/license.php %
|
||
% %
|
||
% Unless required by applicable law or agreed to in writing, software %
|
||
% distributed under the License is distributed on an "AS IS" BASIS, %
|
||
% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
|
||
% See the License for the specific language governing permissions and %
|
||
% limitations under the License. %
|
||
% %
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%
|
||
% Read a stream of characters and return tokens one at a time.
|
||
%
|
||
% The input stream is divided into individual 'tokens' (representing 'words'
|
||
% or 'options'), in a way that is as close to a UNIX shell, as is feasable.
|
||
% Only shell variable, and command substitutions will not be performed.
|
||
% Tokens can be any length.
|
||
%
|
||
% The main function call is GetScriptToken() (see below) whcih returns one
|
||
% and only one token at a time. The other functions provide support to this
|
||
% function, opening scripts, and seting up the required structures.
|
||
%
|
||
% More specifically...
|
||
%
|
||
% Tokens are white space separated, and may be quoted, or even partially
|
||
% quoted by either single or double quotes, or the use of backslashes,
|
||
% or any mix of the three.
|
||
%
|
||
% For example: This\ is' a 'single" token"
|
||
%
|
||
% A token is returned immediatally the end of token is found. That is as soon
|
||
% as a unquoted white-space or EOF condition has been found. That is to say
|
||
% the file stream is parsed purely character-by-character, regardless any
|
||
% buffering constraints set by the system. It is not parsed line-by-line.
|
||
%
|
||
% The function will return 'MagickTrue' if a valid token was found, while
|
||
% the token status will be set accordingally to 'OK' or 'EOF', according to
|
||
% the cause of the end of token. The token may be an empty string if the
|
||
% input was a quoted empty string. Other error conditions return a value of
|
||
% MagickFalse, indicating any token found but was incomplete due to some
|
||
% error condition.
|
||
%
|
||
% Single quotes will preserve all characters including backslashes. Double
|
||
% quotes will also preserve backslashes unless escaping a double quote,
|
||
% or another backslashes. Other shell meta-characters are not treated as
|
||
% special by this tokenizer.
|
||
%
|
||
% For example Quoting the quote chars:
|
||
% \' "'" \" '"' "\"" \\ '\' "\\"
|
||
%
|
||
% Outside quotes, backslash characters will make spaces, tabs and quotes part
|
||
% of a token returned. However a backslash at the end of a line (and outside
|
||
% quotes) will cause the newline to be completely ignored (as per the shell
|
||
% line continuation).
|
||
%
|
||
% Comments start with a '#' character at the start of a new token, will be
|
||
% completely ignored upto the end of line, regardless of any backslash at the
|
||
% end of the line. You can escape a comment '#', using quotes or backlsashes
|
||
% just as you can in a shell.
|
||
%
|
||
% The parser will accept both newlines, returns, or return-newlines to mark
|
||
% the EOL. Though this is technically breaking (or perhaps adding to) the
|
||
% 'BASH' syntax that is being followed.
|
||
%
|
||
%
|
||
% UNIX script Launcher...
|
||
%
|
||
% The use of '#' comments allow normal UNIX 'scripting' to be used to call on
|
||
% the "magick" command to parse the tokens from a file
|
||
%
|
||
% #!/path/to/command/magick -script
|
||
%
|
||
%
|
||
% UNIX 'env' command launcher...
|
||
%
|
||
% If "magick" is renamed "magick-script" you can use a 'env' UNIX launcher
|
||
%
|
||
% #!/usr/bin/env magick-script
|
||
%
|
||
%
|
||
% Shell script launcher...
|
||
%
|
||
% As a special case a ':' at the start of a line is also treated as a comment
|
||
% This allows a magick script to ignore a line that can be parsed by the shell
|
||
% and not by the magick script (tokenizer). This allows for an alternative
|
||
% script 'launcher' to be used for magick scripts.
|
||
%
|
||
% #!/bin/sh
|
||
% :; exec magick -script "$0" "$@"; exit 10
|
||
% #
|
||
% # The rest of the file is magick script
|
||
% -read label:"This is a Magick Script!"
|
||
% -write show: -exit
|
||
%
|
||
% Or with some shell pre/post processing...
|
||
%
|
||
% #!/bin/sh
|
||
% :; echo "This part is run in the shell, but ignored by Magick"
|
||
% :; magick -script "$0" "$@"
|
||
% :; echo "This is run after the "magick" script is finished!"
|
||
% :; exit 10
|
||
% #
|
||
% # The rest of the file is magick script
|
||
% -read label:"This is a Magick Script!"
|
||
% -write show: -exit
|
||
%
|
||
%
|
||
% DOS script launcher...
|
||
%
|
||
% Similarly any '@' at the start of the line (outside of quotes) will also be
|
||
% treated as comment. This allow you to create a DOS script launcher, to
|
||
% allow a ".bat" DOS scripts to run as "magick" scripts instead.
|
||
%
|
||
% @echo This line is DOS executed but ignored by Magick
|
||
% @magick -script %~dpnx0 %*
|
||
% @echo This line is processed after the Magick script is finished
|
||
% @GOTO :EOF
|
||
% #
|
||
% # The rest of the file is magick script
|
||
% -read label:"This is a Magick Script!"
|
||
% -write show: -exit
|
||
%
|
||
% But this can also be used as a shell script launcher as well!
|
||
% Though is more restrictive and less free-form than using ':'.
|
||
%
|
||
% #!/bin/sh
|
||
% @() { exec magick -script "$@"; }
|
||
% @ "$0" "$@"; exit
|
||
% #
|
||
% # The rest of the file is magick script
|
||
% -read label:"This is a Magick Script!"
|
||
% -write show: -exit
|
||
%
|
||
% Or even like this...
|
||
%
|
||
% #!/bin/sh
|
||
% @() { }
|
||
% @; exec magick -script "$0" "$@"; exit
|
||
% #
|
||
% # The rest of the file is magick script
|
||
% -read label:"This is a Magick Script!"
|
||
% -write show: -exit
|
||
%
|
||
*/
|
||
|
||
/*
|
||
Include declarations.
|
||
|
||
NOTE: Do not include if being compiled into the "test/script-token-test.c"
|
||
module, for low level token testing.
|
||
*/
|
||
#ifndef SCRIPT_TOKEN_TESTING
|
||
# include "MagickWand/studio.h"
|
||
# include "MagickWand/MagickWand.h"
|
||
# include "MagickWand/script-token.h"
|
||
# include "MagickCore/string-private.h"
|
||
# include "MagickCore/utility-private.h"
|
||
#endif
|
||
|
||
/*
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
% %
|
||
% %
|
||
% %
|
||
% A c q u i r e S c r i p t T o k e n I n f o %
|
||
% %
|
||
% %
|
||
% %
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%
|
||
% AcquireScriptTokenInfo() allocated, initializes and opens the given
|
||
% file stream from which tokens are to be extracted.
|
||
%
|
||
% The format of the AcquireScriptTokenInfo method is:
|
||
%
|
||
% ScriptTokenInfo *AcquireScriptTokenInfo(char *filename)
|
||
%
|
||
% A description of each parameter follows:
|
||
%
|
||
% o filename the filename to open ("-" means stdin)
|
||
%
|
||
*/
|
||
WandExport ScriptTokenInfo *AcquireScriptTokenInfo(const char *filename)
|
||
{
|
||
ScriptTokenInfo
|
||
*token_info;
|
||
|
||
token_info=(ScriptTokenInfo *) AcquireMagickMemory(sizeof(*token_info));
|
||
if (token_info == (ScriptTokenInfo *) NULL)
|
||
return token_info;
|
||
(void) memset(token_info,0,sizeof(*token_info));
|
||
|
||
token_info->opened=MagickFalse;
|
||
if ( LocaleCompare(filename,"-") == 0 ) {
|
||
token_info->stream=stdin;
|
||
token_info->opened=MagickFalse;
|
||
}
|
||
else if ( LocaleNCompare(filename,"fd:",3) == 0 ) {
|
||
token_info->stream=fdopen(StringToLong(filename+3),"r");
|
||
token_info->opened=MagickFalse;
|
||
}
|
||
else {
|
||
token_info->stream=fopen_utf8(filename, "r");
|
||
}
|
||
if ( token_info->stream == (FILE *) NULL ) {
|
||
token_info=(ScriptTokenInfo *) RelinquishMagickMemory(token_info);
|
||
return(token_info);
|
||
}
|
||
|
||
token_info->curr_line=1;
|
||
token_info->length=INITAL_TOKEN_LENGTH;
|
||
token_info->token=(char *) AcquireQuantumMemory(1,token_info->length);
|
||
|
||
token_info->status=(token_info->token != (char *) NULL)
|
||
? TokenStatusOK : TokenStatusMemoryFailed;
|
||
token_info->signature=MagickWandSignature;
|
||
|
||
return token_info;
|
||
}
|
||
|
||
/*
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
% %
|
||
% %
|
||
% %
|
||
% D e s t r o y S c r i p t T o k e n I n f o %
|
||
% %
|
||
% %
|
||
% %
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%
|
||
% DestroyScriptTokenInfo() allocated, initializes and opens the given
|
||
% file stream from which tokens are to be extracted.
|
||
%
|
||
% The format of the DestroyScriptTokenInfo method is:
|
||
%
|
||
% ScriptTokenInfo *DestroyScriptTokenInfo(ScriptTokenInfo *token_info)
|
||
%
|
||
% A description of each parameter follows:
|
||
%
|
||
% o token_info The ScriptTokenInfo structure to be destroyed
|
||
%
|
||
*/
|
||
WandExport ScriptTokenInfo * DestroyScriptTokenInfo(ScriptTokenInfo *token_info)
|
||
{
|
||
assert(token_info != (ScriptTokenInfo *) NULL);
|
||
assert(token_info->signature == MagickWandSignature);
|
||
|
||
if ( token_info->opened != MagickFalse )
|
||
fclose(token_info->stream);
|
||
|
||
if (token_info->token != (char *) NULL )
|
||
token_info->token=(char *) RelinquishMagickMemory(token_info->token);
|
||
token_info=(ScriptTokenInfo *) RelinquishMagickMemory(token_info);
|
||
return(token_info);
|
||
}
|
||
|
||
/*
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
% %
|
||
% %
|
||
% %
|
||
% G e t S c r i p t T o k e n %
|
||
% %
|
||
% %
|
||
% %
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%
|
||
% GetScriptToken() a fairly general, finite state token parser. That returns
|
||
% tokens one at a time, as soon as posible.
|
||
%
|
||
%
|
||
% The format of the GetScriptToken method is:
|
||
%
|
||
% MagickBooleanType GetScriptToken(ScriptTokenInfo *token_info)
|
||
%
|
||
% A description of each parameter follows:
|
||
%
|
||
% o token_info pointer to a structure holding token details
|
||
%
|
||
*/
|
||
/* States of the parser */
|
||
#define IN_WHITE 0
|
||
#define IN_TOKEN 1
|
||
#define IN_QUOTE 2
|
||
#define IN_COMMENT 3
|
||
|
||
/* Macro to read character from stream
|
||
|
||
This also keeps track of the line and column counts.
|
||
The EOL is defined as either '\r\n', or '\r', or '\n'.
|
||
A '\r' on its own is converted into a '\n' to correctly handle
|
||
raw input, typically due to 'copy-n-paste' of text files.
|
||
But a '\r\n' sequence is left ASIS for string handling
|
||
*/
|
||
#define GetChar(c) \
|
||
{ \
|
||
c=fgetc(token_info->stream); \
|
||
token_info->curr_column++; \
|
||
if ( c == '\r' ) { \
|
||
c=fgetc(token_info->stream); \
|
||
ungetc(c,token_info->stream); \
|
||
c = (c!='\n')?'\n':'\r'; \
|
||
} \
|
||
if ( c == '\n' ) \
|
||
token_info->curr_line++, token_info->curr_column=0; \
|
||
if (c == EOF ) \
|
||
break; \
|
||
if ( (c>='\0' && c<'\a') || (c>'\r' && c<' ' && c!='\033') ) { \
|
||
token_info->status=TokenStatusBinary; \
|
||
break; \
|
||
} \
|
||
}
|
||
/* macro to collect the token characters */
|
||
#define SaveChar(c) \
|
||
{ \
|
||
if ((size_t) offset >= (token_info->length-1)) { \
|
||
if ( token_info->length >= MagickPathExtent ) \
|
||
token_info->length += MagickPathExtent; \
|
||
else \
|
||
token_info->length *= 4; \
|
||
token_info->token=(char *) ResizeQuantumMemory(token_info->token, \
|
||
token_info->length,sizeof(*token_info->token)); \
|
||
if ( token_info->token == (char *) NULL ) { \
|
||
token_info->status=TokenStatusMemoryFailed; \
|
||
break; \
|
||
} \
|
||
} \
|
||
token_info->token[offset++]=(char) (c); \
|
||
}
|
||
|
||
WandExport MagickBooleanType GetScriptToken(ScriptTokenInfo *token_info)
|
||
{
|
||
int
|
||
quote,
|
||
c;
|
||
|
||
int
|
||
state;
|
||
|
||
ssize_t
|
||
offset;
|
||
|
||
/* EOF - no more tokens! */
|
||
if (token_info == (ScriptTokenInfo *) NULL)
|
||
return(MagickFalse);
|
||
if (token_info->status != TokenStatusOK)
|
||
{
|
||
token_info->token[0]='\0';
|
||
return(MagickFalse);
|
||
}
|
||
state=IN_WHITE;
|
||
quote='\0';
|
||
offset=0;
|
||
DisableMSCWarning(4127)
|
||
while(1)
|
||
RestoreMSCWarning
|
||
{
|
||
/* get character */
|
||
GetChar(c);
|
||
|
||
/* hash comment handling */
|
||
if ( state == IN_COMMENT ) {
|
||
if ( c == '\n' )
|
||
state=IN_WHITE;
|
||
continue;
|
||
}
|
||
/* comment lines start with '#' anywhere, or ':' or '@' at start of line */
|
||
if ( state == IN_WHITE )
|
||
if ( ( c == '#' ) ||
|
||
( token_info->curr_column==1 && (c == ':' || c == '@' ) ) )
|
||
state=IN_COMMENT;
|
||
/* whitespace token separator character */
|
||
if (strchr(" \n\r\t",c) != (char *) NULL) {
|
||
switch (state) {
|
||
case IN_TOKEN:
|
||
token_info->token[offset]='\0';
|
||
return(MagickTrue);
|
||
case IN_QUOTE:
|
||
SaveChar(c);
|
||
break;
|
||
}
|
||
continue;
|
||
}
|
||
/* quote character */
|
||
if ( c=='\'' || c =='"' ) {
|
||
switch (state) {
|
||
case IN_WHITE:
|
||
token_info->token_line=token_info->curr_line;
|
||
token_info->token_column=token_info->curr_column;
|
||
case IN_TOKEN:
|
||
state=IN_QUOTE;
|
||
quote=c;
|
||
break;
|
||
case IN_QUOTE:
|
||
if (c == quote)
|
||
{
|
||
state=IN_TOKEN;
|
||
quote='\0';
|
||
}
|
||
else
|
||
SaveChar(c);
|
||
break;
|
||
}
|
||
continue;
|
||
}
|
||
/* escape char (preserve in quotes - unless escaping the same quote) */
|
||
if (c == '\\')
|
||
{
|
||
if ( state==IN_QUOTE && quote == '\'' ) {
|
||
SaveChar('\\');
|
||
continue;
|
||
}
|
||
GetChar(c);
|
||
if (c == '\n')
|
||
switch (state) {
|
||
case IN_COMMENT:
|
||
state=IN_WHITE; /* end comment */
|
||
case IN_QUOTE:
|
||
if (quote != '"')
|
||
break; /* in double quotes only */
|
||
case IN_WHITE:
|
||
case IN_TOKEN:
|
||
continue; /* line continuation - remove line feed */
|
||
}
|
||
switch (state) {
|
||
case IN_WHITE:
|
||
token_info->token_line=token_info->curr_line;
|
||
token_info->token_column=token_info->curr_column;
|
||
state=IN_TOKEN;
|
||
break;
|
||
case IN_QUOTE:
|
||
if (c != quote && c != '\\')
|
||
SaveChar('\\');
|
||
break;
|
||
}
|
||
SaveChar(c);
|
||
continue;
|
||
}
|
||
/* ordinary character */
|
||
switch (state) {
|
||
case IN_WHITE:
|
||
token_info->token_line=token_info->curr_line;
|
||
token_info->token_column=token_info->curr_column;
|
||
state=IN_TOKEN;
|
||
case IN_TOKEN:
|
||
case IN_QUOTE:
|
||
SaveChar(c);
|
||
break;
|
||
case IN_COMMENT:
|
||
break;
|
||
}
|
||
}
|
||
/* input stream has EOF or produced a fatal error */
|
||
token_info->token[offset]='\0';
|
||
if ( token_info->status != TokenStatusOK )
|
||
return(MagickFalse); /* fatal condition - no valid token */
|
||
token_info->status = TokenStatusEOF;
|
||
if ( state == IN_QUOTE)
|
||
token_info->status = TokenStatusBadQuotes;
|
||
if ( state == IN_TOKEN)
|
||
return(MagickTrue); /* token with EOF at end - no problem */
|
||
return(MagickFalse); /* in white space or in quotes - invalid token */
|
||
}
|