\sic\ may output a number of error messages. These are
usually self explanatory, and most of them refer to typing 
errors, or to an unanticipated degree of complexity reached
during the program execution (too many loops, macros, complex
mathematic formulas, etc...). More severe errors may appear,
usually due to internal logic errors in the calling program. 
SIC is a relatively safe program. However, its very flexible
possibilities, and in particular the possibility of calling
it as a command monitor in multi-language application, possibly
written independently by different programmers, make it very difficult
to be error free. This section list all the error messages written
by SIC, and some (but not all) information messages. The format
of  a SIC message is the following
\begin{verbatim}
        C-FACILITY,  Explanation text
\end{verbatim}
C is a letter indicating the severity of the message, and may be :
\begin{description}
\item{\tt I} for Information
\item{\tt W} for Warning. Normal execution can proceed, but the operation
was not completed.
\item{\tt E} for Error. Something really went wrong, and a corrective
action should (usually) take place. Suggested actions are mentioned.
\item{\tt F} for Fatal Error. This is a programming error, either in SIC,
or in the calling program, or an unrecoverable error causing
a program abort (such as a {\tt PAUSE} in batch sessions).
\end{description} 

{\tt FACILITY} is a mnemonic of the subroutine or of the command where the 
error occured.

{\tt "Explanation text"} is a concise but usually self explanatory message.

In case of Fatal errors, the ``recovery procedure'' usually indicates
to ``Submit an SPR''. An SPR is a {\em Software Performance Report}, and
it should be sent to the \sic\ authors, by E-Mail at
\begin{verbatim}
          gildas@iram.fr
\end{verbatim}
({\tt GILDAS} is a reserved account for all \gildas\ software).

\newpage
\begin{center}
List of Error Messages
\end{center}


%AAA
%BBB
%CCC
\subsection{A through C}
\begin{description}

\item{\tt E-COMPUTE, TRANSPOSE not implemented}\\
{\tt SIC,} \com{COMPUTE} command. Self explanatory...
\action\ If your variables are images, use the {\tt 
VECTOR$\backslash$TRANSPOSE} command instead.

\item{\tt E-COMPUTE,  Variable cannot be written}\\
{\tt SIC,} \com{COMPUTE} command. The output variable is defined
ReadOnly.
\action\ Probably a user error. Check your variable name. If it is
what you wanted, it means you are trying to overwrite a protected 
program defined variable, and this is forbidden of course.

\item{\tt E-COMPUTE,  Variable must be Real}\\
{\tt SIC,} \com{COMPUTE} command. The required actions operate
only on Real variables.
\action\ Define intermediate variables if necessary.

\item{\tt E-COMPUTE,  Invalid OUTPUT variable dimensions}\\
{\tt SIC,} \com{COMPUTE} command on Fast Fourier Transform action.
\action\ See Help.

%DDD
\end{description}
\subsection{D}
\begin{description}
\item{\tt E-DECODE,  Invalid arithmetic expression}\\
{\tt SIC,} Argument decoding routines. An arithmetic expression
used as argument is invalid. The message is usually preceded by
more detailed explanation.
\action\  correct the expression. If a message "Internal
logic error" appeared, submit an SPR.

\item{\tt E-DECODE,  Invalid logical expression}\\
{\tt SIC,} Argument decoding routines. A logical expression
used as argument is invalid. The message is usually preceded by
more detailed explanation.
\action\  correct the expression. If a message ``Internal
logic error'' appeared, submit an SPR.

\item{\tt E-DECODE,  Error computing <String>}\\
{\tt SIC}, Argument decoding routines. Some error occured during
evaluation of a valid arithmetic expression. A more detailed text
precedes this message. This is usually due to undefined variables,
or arithmetic errors like square root of negative values.
\action\  correct any typing error. Check values of
variables if an arithmetic error occured.

\item{\tt E-DECODE,  Option <Integer> or argument <Integer> out of bounds}\\
{\tt SIC}, Argument decoding routines. This is a programming error :
a command required too many arguments or options.
\action\  Notify the programmer who should consult the
\sic\ programming manual.

\item{\tt E-DECODE,  You have overwritten the command line pointers.}\\
{\tt SIC}, Argument decoding routines. This is a programming error:
the program tries retrieving an argument after another command line 
has been analysed. This frequently occurs when \greg\ is called in library
mode by another program. This should only be done AFTER all arguments
have been retrieved.
\action\  Notify the programmer who should retrieve all needed
arguments before he starts analysing another line.

\item{\tt E-DECODE,  Missing argument number <Integer> of Command <String>}
\item{\tt E-DECODE,  Missing argument number <Integer> of Option <String>}\\
{\tt SIC}, Argument decoding routines. The specified argument is mandatory
for the command or option.
\action\  specify the missing argument.

\item{\tt E-DEFINE,  Cannot specify dimension for existing images}\\
{\tt SIC, DEFINE or LET /NEW} commands. Dimensions can only be specified when
creating an image.
\action\  Don't specify a dimension for existing images.

\item{\tt E-DEFINE,  Invalid variable name <String>}\\
{\tt SIC, DEFINE or LET /NEW} commands. Variable names must be less
than 15 characters and begin with a letter.
\action\  choose a valid name.

\item{\tt E-DEFINE,  Invalid status <String>}\\
{\tt SIC, DEFINE HEADER} command. The header status can only be Read or
Write.
\action\  May be you confused {\tt DEFINE IMAGE} and {DEFINE HEADER}.
Correct your typing.

\item{\tt E-DEFINE,  Memory allocation failure}\\
{\tt SIC, DEFINE or LET /NEW} commands. The memory needed to create the
variable could not be obtained from the operating system, due to a
shortage of system resources or quota. This message is may be preceded
by an operating system error message. On a typical site, this error
will only occur if you are using (very) big arrays.
\action\  delete any unused variable, clear the plot if any, and
then retry. Try to use {\em images} instead of {\em arrays}. If this does not
work, exit the program, reenter it and retry. If this is not sufficient,
consider whether you {\em really} need such big arrays. If the answer is yes,
you might consider asking your system manager to increase the relevant quota. 

\item{\tt E-DEFINE,  Missing dimension of new image}\\
{\tt SIC, DEFINE} command. The dimension of a new image must be specified
\action\  specify the dimension.

\item{\tt E-DEFINE,  Only last dimension can be extended}\\
{\tt SIC, DEFINE} command. The {\tt EXTEND} request is not acceptable.
\action\  see \comm{DEFINE}{IMAGE} internal help.

\item{\tt E-DEFINE,  Syntax error}\\
{\tt SIC, DEFINE FUNCTION} command. The function definition is invalid.

\item{\tt E-DEFINE,  Too many variables}\\
{\tt SIC, DEFINE or LET /NEW} commands.
\action\  delete some existing variables, or use them instead
of defining a new one. If you cannot, ask your system manager about
increas \sic\ workspace.

\item{\tt E-DEFINE,  Too many arguments}\\
{\tt SIC, DEFINE FUNCTION} command. Invalid syntax: only one
function definition at a time is possible
\action\  use several {\tt DEFINE FUNCTION} commands if necessary.

\item{\tt E-DEFINE,  Variable <String> already exists}\\
{\tt SIC, DEFINE or LET /NEW} commands. The specified name already is
a known variable.
\action\  use another name, or use (with command {\tt LET} the already 
defined variable if you believe you may do so.


\item{\tt E-DELETE,  Incompatible options}\\
{\tt SIC, DELETE} command. The options {{\tt /FUNCTION},
\tt /SYMBOL} and {\tt /VARIABLE} are mutually exclusive.

\item{\tt E-DELETE,  Missing option}\\
{\tt SIC, DELETE} command. One of the options {\tt /FUNCTION} {\tt /SYMBOL} 
and {\tt /VARIABLE} must be present.

\item{\tt E-DELETE,  No such variable <String>}\
{\tt SIC, DELETE} command. The specified variable cannot be deleted
because it does not exist.

\item{\tt E-DELETE,  Variable <String> not deleted}\
{\tt SIC, DELETE} command. The variable could not be deleted, because
it is program defined
\action\ May be a typing error. Check the variable name.

\item{\tt E-DIMENSION,  Invalid dimension  <string>}\\
Any command with a numerical argument. In the present version of \sic\,
indexes of arrays can only be constants or scalar numerical variables.
Complex numerical expressions are not allowed.
\action\  use an intermediate variable.

\item{\tt E-DIMENSION,  Invalid mixture of implicit and explicit dimensions}\\
{\tt SIC, LET} command. Implicit loops on arrays cannot be mixed with explicit
indexes for other dimensions.
\action\  either use an explicit {\tt FOR-NEXT} loop, or rearrange your 
expression to use the implicit loop (which is {\em much} faster).

\item{\tt E-DIMENSION,  Invalid string length <Number>}\\
{\tt SIC, DEFINE or LET /NEW} commands. Character variable is not
positive.

\item{\tt E-DIMENSION,  Invalid variable name <string>}\\
{\tt SIC, DEFINE or LET /NEW} commands. Variable names must be less
than 15 characters and begin with a letter.
\action\  choose a valid name.

\item{\tt E-DIMENSION,  Missing character size}\\
{\tt SIC, DEFINE or LET /NEW} commands. The size of character string must be
specified.
\action\  specify a length.

\item{\tt E-DIMENSION,  Missing closing bracket}\\
Any command with a numerical argument. An opening bracket is not matched
with the corresponding closing bracket.
\action\  add the appropriate closing bracket.

\item{\tt E-DIMENSION,  Too many dimensions}\\
{\tt SIC, DEFINE or LET /NEW} commands. Only 4 dimensions are supported.
\action\  decrease the number of dimensions.

%EEE
\end{description}
\subsection{E}
\begin{description}
\item{\tt I-EDIT,  Using <String> editor}\\
{\tt SIC, EDIT} command with argument, information message.
The specified editor is called to edit the file specified as argument. 
Control will return to \sic\ after the editing session.

\item{\tt I-EDIT,  Writing stack content on STACK.Ext}\\
{\tt SIC, EDIT} command without argument, information message. {\tt STACK.Ext},
where {\tt Ext} is the current macro extension, will be edited using current
editor. 

\item{\tt E-EDIT,  File name too long}\\
{\tt SIC, EDIT} command. The corresponding file cannot be edited.

\item{\tt E-ELSE,  Invalid argument <String>}\\
{\tt SIC, ELSE} command was followed by an invalid first argument.
\action\  correct typing error. {\tt ELSE} can only have no argument
or {\tt IF} as first argument.

\item{\tt E-ELSE IF,  Invalid syntax}\\
{\tt SIC, ELSE} command with argument {\tt IF}. The only accepted syntaxes 
for {\tt ELSE IF}
are:\\
{\tt ELSE IF <logical expression>}\\
and\\
{\tt ELSE IF <logical expression> THEN}

\item{\tt I-ERROR,  occured in <String> at line <Integer>}
\item{\tt I-ERROR,  occured in Loop <Integer> (<Real>) at Line <Integer>}\\
{\tt SIC}, error traceback facility. The message contains traceback of an 
execution error while executing nested macros, stack or loops. Macro
names, loop number and index values are given together with the lines
being executed.
\action\  If a {\tt PAUSE} occurred correct the erroneous line, 
execute it and continue the nested macros execution by command {\tt
CONTINUE}, or abort execution by command {\tt SIC$\backslash$QUIT}. If
an error recovery command is active, it has been automatically
executed before resuming the nested macros execution.

\item{\tt I-ERROR,  occured in Program}\\
{\tt SIC}, error traceback facility. An error occurred in subroutine mode.
\action\  signal the error to the programmer.

\item{\tt I-ERROR,  occured in Error recovery mode}\\
{\tt SIC}, error traceback facility. An error occurred in the error
recovery command or procedure. A {\tt PAUSE} is issued.
\action\  correct the erroneous recovery procedure and resume
execution.

\item{\tt F-EVALUATE,  Invalid precision <Integer>}\\
Any command with a numerical argument. This is an internal logic 
error in the arithmetic processor (or a memory error on your machine!). 
\action\  Please submit an SPR. If you need the result, try toF
modify your expression (reorder, use intermediate variables...).

\item{\tt F-EVALUATE,  Internal logic error}\\
Any command with a numerical argument. This is an internal error
in SIC.
\action\  submit an SPR. You can try going around the error by
modifying your expression. 

\item{\tt E-EXAMINE,  Undefined variable <String>}\\
{\tt SIC, EXAMINE} command with an argument. The specified variable does not 
exist.
\action\  check for typing errors.

\item{\tt F-EXAMINE,  Invalid data format, internal logic error}\\
{\tt SIC, EXAMINE} command.
\action\  Submit an SPR.

\item{\tt W-EXAMINE,  No known variable}\\
{\tt SIC, EXAMINE} command without argument. No variable has been defined yet.

%FFF
\end{description}
\subsection{F}
\begin{description}
\item{\tt E-FOR,  Empty list}\\
{\tt SIC, FOR} command. The compilation mode is not entered.
\action\  Reenter {\tt FOR} command with a list of values.

\item{\tt E-FOR,  Incomplete list :}\\
{\tt SIC, FOR} command. The invalid list is typed with a pointer
to the error.
\action\  correct the error.

\item{\tt E-FOR,  Input level too deep}\\
{\tt SIC, FOR} command. The execution level is too high,
too many macros or loops are nested, the loop
cannot be executed.
\action\  avoid so deeply nested situations by concatenating
all macros in a single one instead of nesting them. Deep nesting
(more than 8 execution levels) is almost invariably unnecessary.

\item{\tt E-FOR,  Invalid loop :}\\
{\tt SIC, FOR} command. The invalid list is typed with a pointer
to the error.
\action\  correct the error.

\item{\tt E-FOR,  Logical expression is too long}\\
{\tt SIC, FOR} command with {\tt /WHILE} option. The logical expression
specified in the {\tt /WHILE} option is too long to be stored and evaluated. 
\action\  make it simpler using intermediate variables.

\item{\tt I-FOR,  Loop <Integer> has finished}\\
{\tt SIC, VERIFY} mode. Information message

\item{\tt I-FOR,  Loop <Integer> is running with index <Real>}\\
{\tt SIC, VERIFY} mode. Information message.

\item{\tt W-FOR,  Loop <Integer> compilation aborted}\\
{\tt SIC}, loop compilation mode. This message is typed after a {\tt QUIT}
command has been typed to abort a loop compilation.

\item{\tt E-FOR,  Loop buffer overflow}\\
{\tt SIC}, loop compilation mode. Too many commands were entered in
the loop buffers. Loop compilation failed.
\action\  Put the remaining commands in a macro, and
execute the macro within the loop. 

\item{\tt W-FOR,  Line not valid in this context, ignored}\\
{\tt SIC}, loop compilation. The user attempted to insert an invalid
command (such as {\tt HELP, EDIT}) into a loop buffer.
\action\  such commands cannot be placed in loops.

\item{\tt W-FOR,  No variable or list}\\
{\tt SIC, FOR} command. Either the loop variable or the
list of values is missing. 
\action\  Correct the command line.

\item{\tt E-FOR,  Only <Integer> levels of FOR - NEXT loops}\\
{\tt SIC, FOR} command. The user attempt to nest too many loops.
\action\  find another solution to your problem than
nesting so many loops.

\item{\tt E-FOR,  Syntax error in list :}\\
{\tt SIC, FOR} command. The invalid list is typed with a pointer
to the error.
\action\  correct the error.

\item{\tt E-FOR,  Too many arguments in list}\\
{\tt SIC, FOR} command. The {\tt FOR} list is too long.
\action\  Run two (or more) consecutive loops with part
of the list to span all values in your original list.

\item{\tt E-FUNCTION,  Invalid function name <string>}\\
{\tt SIC}, function definition routine. A user program defined function has
an invalid name. Function names are limited to 15 characters and must begin
with a letter. This is a programming error.
\action\  notify the programmer.

\item{\tt F-FUNCTION,  SIC is not loaded}\\
{\tt SIC}, function definition routine. The program tries to define a function
before \sic\ has been initialized. This is a programming error.
\action\  notify the programmer.

\item{\tt E-FUNCTION,  Too many arguments to function}\\
{\tt SIC}, function definition routine. A user program defined function has
too many arguments. Function cannot have more than 4 arguments. This is a 
programming error.
\action\  notify the programmer.

\item{\tt E-FUNCTION,  Too many functions}\\
{\tt SIC}, function definition routine. The program attempts to define too many
user functions. This is a programming error.
\action\  notify the programmer who should contact the authors if he
really needs so many functions.

\item{\tt E-FUNCTION,  <Integer> arguments to function <String>}\\
{\tt SIC}, function definition routine. A user defined function has a negative 
number of arguments. This is a programming error.
\action\  notify the programmer.

%GGG
\end{description}
\subsection{G}
\begin{description}
\item{\tt E-GETCOM,  Line too long, buffer overflow}\\
{\tt SIC}, command reading routine. The command line is too long for
the internal buffer.
\action\  make it shorter if possible. If not, ask the
programmer to increase the line buffer size and relink the program.
(Maximum line length in \sic\ is 2048 characters, so we hardly think
you may be limited by this).

\item{\tt E-GETCOM,  Read error on macro file, unit <Number>}\\
{\tt SIC}, command reading routine. An error occured while reading
command from a macro.
\action\  this is most likely due to a hardware problem,
unless you are attempting to read a binary file\ldots\ Check the macro.
Type the macro to see what command could not be read, execute it
and resume macro execution.

\end{description}
\subsection{H}
\begin{description}
\item{\tt W-HELP,  Error opening <String>}\\
{\tt SIC, HELP} command. The Help file for a language does not exist.
\action\  check with the programmer or system manager that
all logical names have been correctly defined.

\item{\tt W-HELP,  Language <String> is in library only mode}\\
{\tt SIC, HELP} command. The specified language is in library mode, no
help is available for it.
\action\  commands from this language cannot be accessed
interactively, except by specifying the full language name.

\item{\tt W-HELP,  No help for <String>}\\
{\tt SIC, HELP} command. The specified command <String> is not documented.
\action\  unless you are quite sure of their behaviour (or you like
risks) avoid using those undocumented commands.

\end{description}
\subsection{I}
\begin{description}
%III
\item{\tt E-IF,  Invalid syntax}\\
{\tt SIC, IF} command. The second argument of the
command (if present) was not {\tt THEN}.

\item{\tt E-IMPLICIT,  Invalid variable name <string>}\\
{\tt SIC, LET} command. A variable used in the implicit loop has an
invalid name. Variable names must be shorter than 15 characters and
begin with a letter.
\action\  Use a valid variable name.

\item{\tt E-IMPLICIT,  Too many variables}\\
{\tt SIC, LET} command. The total number of variables defined exceeds the
SIC limit. Temporary variables used in implicit loops are included in this 
count.
\action\  Delete a few useless variables and retry.

\item{\tt E-IMPLICIT,  Variable already exist}\\
{\tt SIC, LET} command. This is an internal logic error.
\action\  Submit an SPR. While waiting for the correction, you may
try modifying your expression.

\item{\tt E-INCARNATE,  Bad incarnation type}\\
{\tt SIC}, type conversion routine. The type conversion routine was called with
a non numeric output type. This is a programming error.
\action\  Notify the programmer.

\item{\tt E-INCARNATE,  Bad variable type}\\
{\tt SIC}, type conversion routine. The type conversion routine was called with
a non numeric input type. This is a programming error.
\action\  Notify the programmer.

\item{\tt E-INTER,  Ambiguous command, could be : }\\
{\tt SIC}, monitor routine. The command name is ambiguous.
\action\  specify more characters or specify language to avoid
ambiguities.

%\item{\tt E-INTER,  Ambiguous keyword, choices are : <List>}\\
%{\tt SIC}, monitor routine. The name is ambiguous among the following
%list.
%\action\  specify more characters to resolve ambiguities.

\item{\tt E-INTER,  Ambiguous option, could be :}\\
{\tt SIC}, monitor routine. The option name is ambiguous.
\action\  specify more characters. 

\item{\tt W-INTER,  No command on line}\\
{\tt SIC}, monitor routine. A command line only contained the language field.

\item{\tt E-INTER,  Too many words in line}\\
{\tt SIC}, monitor routine. The user program tried to access more than 100
arguments. This is a programming error.
\action\  if you really need so many arguments, submit an SPR.

\item{\tt E-INTER,  No options allowed for command <String>}\\
{\tt SIC}, monitor routine. The command has no options.
\action\  Suppress options from the command line.

\item{\tt E-INTER,  Unbalanced quote count}\\
{\tt SIC}, monitor routine. A command line has an odd number of double 
quotes.
\action\  Correct typing mistake and reenter command.

\item{\tt E-INTER,  Unknown command }\\
{\tt SIC}, monitor routine. The command does not exist in any active language.
\action\  check spelling or bring more languages in the active
scope (Command {\tt SIC$\backslash$SIC}).

\item{\tt E-INTER,  Unknown command <String> for language <String>}\\
{\tt SIC}, monitor routine. The command does not exist in the specified
language.
\action\  check spelling.

%\item{\tt W-INTER,  Unknown keyword <String>}\\
%{\tt SIC}, monitor routine. The name is not known.
%\action\  Check spelling and reenter command.

\item{\tt E-INTER,  Unknown language <String>}\\
{\tt SIC}, monitor routine. The specified language is not known.
\action\  Check spelling. If good, verify you are using
the right program.

\item{\tt E-INTER,  Unknown option <String> for command <String>}\\
{\tt SIC}, monitor routine. The command has no such option
\action\  check spelling.


%JJJ
%LLL
\end{description}
\subsection{J trough L}
\begin{description}
\item{\tt F-LET,  Cannot assign arrays}\\
{\tt SIC}, calling program. This is a programming error. The program attempts
to assign values to an array through a call to {\tt SIC\_LET\_REAL} (or 
{\tt SIC\_LET\_INTE}\ldots ). This is not allowed.
\action\  notify the programmer. If you need to assign values to 
an array, call {\tt SIC\_DESCRIPTOR} and do the assignment in your program.


\item{\tt E-LET,  Header structures cannot be assigned}\\
{\tt SIC, LET} command. The variable to be assigned is a generic header
name.
\action\ Add the \% symbol after the generic header name to
assign a header structure.

\item{\tt E-LET,  Invalid attribute <string>}\\
{\tt SIC, LET /NEW} command. The only recognised attributes for a variable
are {\tt GLOBAL} and {\tt LOCAL}.

\item{\tt E-LET,  Memory allocation failure}\\
{\tt SIC, LET} commands. The memory needed as work space
could not be obtained from the operating system, due to a shortage of system 
resources or quota. This message is preceded by the VMS error message. On a 
typical site, this error will only occur if you are using (very) big arrays 
or images.
\action\  delete any unused variable, and then retry. 
If this does not work, exit the program, reenter it and retry. If this is not
sufficient, consider whether you {\em really} need such big arrays. If the
answer is yes, you might consider asking your system manager to increase the
relevant quota. 

\item{\tt E-LET,  Operation not supported on string arrays}\\
{\tt SIC, LET} command. String arrays cannot be assigned directly.
\action\ Define the string arrays element by element, using a loop.

\item{\tt E-LET,  Readonly variables cannot be modified}\\
{\tt SIC, LET} command. You are attempting to modify a protected variable 
declared by the program.
\action\  this is not allowed. Define another variable if you
need temporary storage.

\item{\tt E-LET,  Readonly headers cannot be modified}\\
{\tt SIC, LET} command. You are attempting to modify a protected 
header.
\action\  This is not allowed. Redefine the header with write access
if needed.

\item{\tt E-LET,  Trailing arguments in assignement}\\
{\tt SIC, LET} command. While trying to use the element by element
{\tt LET} command, you omitted or added one argument.
\action\ Check the array size, and count the number of arguments.

\item{\tt E-LET,  Undefined header <String>}\\
{\tt SIC, LET} command. The assigned header is not defined.
\action\ Check variable name for typing error.

\item{\tt E-LET,  Undefined variable <String>}\\
{\tt SIC, LET} command. The assigned variable is not defined.
\action\  first check variable name for typing error.
If you want to assign a new variable, use
{\tt DEFINE} command or option {\tt /NEW} of command {\tt LET} to define it.

\item{\tt E-LET,  Variable type does not match declaration}\\
{\tt SIC, SIC\_LET\_xxx} subroutine. This is a programming error. The
program attempted to assign a value of wrong type to a defined
variable.
\action\  notify the programmer.

\item{\tt E-LOGICAL,  Error evaluating <String>}\\
{\tt SIC}, argument decoding routine. Evaluation of a logical expression
failed. This message is usually preceded by a more detailed text indicating
why the expression could not be evaluated.
\action\  check for undefined variables.

\item{\tt E-LOGICAL,  Invalid logical expression}\\
{\tt SIC}, argument decoding routine. An invalid logical expression
was found (most likely in an {\tt IF, FOR /WHILE or ELSE IF} command).
This message is usually preceded by a more detailed text indicating
why the expression is invalid.
\action\  correct the expression. 

%MMM
\end{description}
\subsection{M}
\begin{description}
\item{\tt E-MACRO,  Input level too deep}\\
{\tt SIC, @} command. A macro could not be executed due to an execution
level too high. 
\action\  finish some macro execution before activating this
one. Eventually, you may need to rearrange your macros to avoid
so many execution levels.

\item{\tt E-MACRO,  Recursive call to macro <String>}\\
{\tt SIC, @} command. A recursive call occurred to the specified macro.
\action\  correct the macros which are causing this problem,
recursive calls are prohibited.

\item{\tt E-MACRO,  Unable to open macro <String>}\\
{\tt SIC, @} command. The macro file could not be opened for read.
\action\  check for typing error, and possibly for privilege
violation. This message is followed by a second line of text indicating
a more precise reason.

\item{\tt E-MATH, Unmatch Closing bracket}\\
{\tt SIC}, Mathematic and logical expression analysis modules. 
\action\ Correct the typing error.

\item{\tt E-MATH,  Missing operator after string}\\
{\tt SIC}, function definition module. The expression is incorrect.
\action\ Correct the typing error (misplaced parenthesis normally).

%%%%
\item{\tt E-MTH,  Arithmetic expression is too complex}\\
{\tt SIC}, Mathematic and logical expression analysis modules. 
The expression could not be analyzed because of complexity.
\action\ break it in several expression, using intermediate variables.

\item{\tt E-MTH,  Error in FIND\_OPERATOR}\\
\item{\tt E-MTH,  Error in READ\_OPERAND}\\
{\tt SIC}, Mathematic and logical expression analysis modules. These
message usually follows more specific ones. 
\action\ In case the other messages
require to submit an SPR, please indicate the complete list of
error messages from MTH.

%\item{\tt F-MTH,  Call to Unary PLUS operation}\\
%{\tt SIC}, Mathematic and logical expression analysis modules. This is 
%an internal logic error. An
%expression was successfully analyzed, but could not be evaluated
%because of an internal error in the analysis modules.
%\action\  Submit an SPR, with
%the faulty mathematic formula. Simplify your formula, or add
%parenthesis to avoid possible ambiguities and try again. Eventually
%break your formula into several consecutive ones.

\item{\tt E-MTH,  Comparing arrays of inconsistent dimensions}\\
{\tt SIC}, Mathematic and logical expression analysis modules. An
expression contains an illegal mix of arrays with different dimensions.
\action\  You probably got confused with variable names.
Correct the expression.

\item{\tt E-MTH,  Comparing non scalar variables}\\
{\tt SIC}, Mathematic and logical expression analysis modules. A logical
expression attempts to compare by order (.GT. .LT. .GE. and .LE.)
two arrays. Such comparisons are invalid.
\action\  You probably got confused with variable names.
Correct the expression.

\item{\tt E-MTH,  Error reading operand <String>}\\
{\tt SIC}, Mathematic and logical expression analysis modules. The
corresponding string could not be analyzed.
\action\ Correct anay (likely) typing error.

\item{\tt W-MTH,  Free operand in BUILD\_TREE}\\
{\tt SIC}, Mathematic and logical expression analysis modules. This is 
an internal logic error. Some work space allocated during evaluation has not
been freed correctly. The result is nonetheless correct.
\action\  Submit an SPR, with the faulty mathematic formula. 

\item{\tt E-MTH, Inconsistent mixture of Arithmeti, Logical and Character
expression}\\
{\tt SIC}, Mathematic and logical expression analysis modules. The
expression is invalid.
\action\  Correct your expression (you got confused about variable types,
most likely).

\item{\tt F-MTH,  Internal logic error in <String>}\\
{\tt SIC}, Mathematic and logical expression analysis modules. An
expression was successfully analyzed, but could not be evaluated
because of an internal error in the analysis modules.
\action\  Submit an SPR, with
the faulty mathematic formula. Simplify your formula, or add
parenthesis to avoid possible ambiguities and try again. Eventually
break your formula into several consecutive ones.

\item{\tt F-MTH,  Invalid arithmetic formula}\\
{\tt SIC}, Mathematic and logical expression analysis modules. The
formula is invalid.
\action\  Correct it. You may have confused some operators or variables.


\item{\tt F-MTH,  Invalid character string <String>}\\
{\tt SIC}, Mathematic and logical expression analysis modules. The
character string is invalid (empty string, or missing closing
quote ($''$)
\action\  Correct it. You may have confused some operators or variables.

\item{\tt F-MTH,  Invalid number of arguments in call to <String> }\\
{\tt SIC}, Mathematic and logical expression analysis modules. The
function call list is incorrect.
\action\  Correct it. 

\item{\tt F-MTH,  Invalid syntax}\\
{\tt SIC}, Mathematic and logical expression analysis modules. This is an
internal logic error. An expression contained only opening
parenthesis.
\action\  Submit an SPR with the faulty expression.

\item{\tt E-MTH,  Level <Number> should already have been evaluated}\\
{\tt SIC}, Mathematic and logical expression analysis modules. This is an
internal logic error. 
\action\  Submit an SPR with the faulty expression.


\item{\tt E-MTH,  Mathematics on arrays of inconsistent dimensions}\\
{\tt SIC}, Mathematic and logical expression analysis modules. You are
trying to combine arrays with inconsistent dimensions.
\action\  Correct the expression.

\item{\tt E-MTH,  Memory allocation failure}\\
{\tt SIC, LET} command. Memory needed as work space could not be
obtained from the operating system, due to a shortage of system
resources or quota. On a typical site, this error will only occur if
you are using (very) big arrays.
\action\  delete any unused variable, clear the plot if any, and then retry. If
this does not work, exit the program, reenter it and retry. If this
does not work, try using {\em images} instead of {\em arrays}. If this
is not sufficient, consider whether you {\em really} need such big
arrays. If the answer is yes, you might consider asking your system
manager to increase the relevant quota.

\item{\tt W-MTH,  Missing operand in formula <String>}\\
{\tt SIC}, Mathematic and logical expression analysis modules. One
operator or function is left without operand after parsing.
\action\  Correct the expression.

\item{\tt E-MTH,  Missing operator after closing bracket}\\
{\tt SIC}, Mathematic and logical expression analysis modules. 
\action\  Correct the expression.

\item{\tt E-MTH,  Result type mismatch}\\
{\tt SIC}, Mathematic and logical expression analysis modules. You are
trying to assign a logical value to a numerical variable or so.
\action\  Correct the expression.

\item{\tt W-MTH,  Result was not yet assigned }\\
{\tt SIC}, Mathematic and logical expression analysis modules. This is an
internal logic error. An expression was successfully analyzed, but could not 
be evaluated because of an internal error.
\action\  Submit an SPR, with the faulty mathematic formula. 
This is only a warning, and in principle the result should be correct.
If not, simplify your formula, or add
parenthesis to avoid possible ambiguities and try again. Eventually
break your formula into several consecutive ones.

\item{\tt W-MTH,  Scratch operand remaining <integer>}\\
{\tt SIC}, Mathematic and logical expression analysis modules. This is an
internal logic error. An expression was successfully analyzed, but could not 
be evaluated because of an internal error.
\action\  Submit an SPR, with the faulty mathematic formula. 
This is only a warning, and in principle the result should be correct.
If not, simplify your formula, or add
parenthesis to avoid possible ambiguities and try again. Eventually
break your formula into several consecutive ones.

\item{\tt E-MTH,  Too many operands}\\
{\tt SIC}, Mathematic and logical expression analysis modules. Formula is too
complex, and does not fit in the internal buffer.
\action\  Simplify your formula, and try again. Use intermediate
variables to break your formula into several smaller pieces. If this is a
serious limitation to you, submit an SPR, and we will increase the buffer size.

\item{\tt E-MTH,  Too many operands in function call}\\
{\tt SIC}, Mathematic and logical expression analysis modules. A
function was called with the wrong number of arguments.
\action\  Correct the call

\item{\tt E-MTH,  Unknown variable <String>}\\
{\tt SIC}, Mathematic and logical expression analysis modules. The
parsing module was expecting a variable.
\action\ This is presumably due to a typing mistake. Correct your expression.

\item{\tt E-MTH,  Unknown function  <String>}\\
{\tt SIC}, Mathematic and logical expression analysis modules. The
parsing module was expecting a user defined function.
\action\ This is presumably due to a typing mistake. Correct your expression.

\item{\tt E-MTH,  Unknown logical or relational operator <String>}\\
{\tt SIC}, Mathematic and logical expression analysis modules. The
parsing module was expecting an operator.
\action\ This is presumably due to a typing mistake. Correct your expression.

%OOO
\end{description}
\subsection{O through R}
\begin{description}
\item{\tt E-ON,  Unknown argument <String>}\\
{\tt SIC}, ON command.
\action\ See {\tt HELP ON}.

%PPP
\item{\tt E-PARSE,  Implicit transposition not yet supported }\\
{\tt SIC}, Array dimension parser. The specified array subset
is invalid, because it requires an implicit transposition of the
array variable.
\action\ Read the section upon what array variables.

\item{\tt E-PARSE,  Index <Integer> exceeds dimension <Integer> of <String>}\\
{\tt SIC}, Array dimension parser. The specified array subset
is invalid, because the arrays size is exceeded
\action\ Correct your error.

\item{\tt E-PARSE,  Variable <String> has only '<Integer> dimensions }\\
{\tt SIC}, Array dimension parser. The specified array subset
is invalid, because the dimension does not exist in the array.
\action\ Correct your (typing) error.

\item{\tt W-PAUSE,  <\^{}C> ignored, level too deep}\\
{\tt SIC}, monitor routine. The user pressed {\tt <\^{}C>} during a command 
execution, but the execution level is too high to allow a {\tt PAUSE}
to be delivered. The execution continues normally.
\action\  None, unless a definite interruption is needed
in which case the user might consider typing {\tt <\^{}Y>}\dots

\item{\tt W-PAUSE,  Error returned by aborted command ignored}\\
{\tt SIC}, monitor routine. A {\tt PAUSE} was generated as the result of
pressing {\tt <\^{}C>} during a command execution, but the command
completed with an error status. The {\tt <\^{}C>} takes precedence over
the error to avoid using the error recovery procedure. This message
follows a {\tt "I-PAUSE,  Generated by pressing <\^{}C>"} message.
\action\  As for any pause.

\item{\tt I-PAUSE,  Generated by pressing <\^{}C>}\\
{\tt SIC}, monitor routine. A {\tt PAUSE} was generated as the result of
pressing {\tt <\^{}C>} during a command execution. The previous command
completed normally.
\action\  Type any command you want. The interrupted execution
level will be restarted by command {\tt CONTINUE}.

\item{\tt F-PAUSE,  Level depth too large}\\
{\tt SIC}, monitor routine. An error occured, but no {\tt PAUSE} could be
delivered because the input level is already too deep.
The program aborts execution with a symbolic stack dump. This
error can (in principle) only occur if you are using a set of 
nested macros as error recovery procedure, and with an invalid
command in one of the macros...
\action\  Correct error and restart the program. Avoid
using such complex error recovery systems.

\item{\tt F-PAUSE,  Session is not interactive}\\
{\tt SIC}, monitor routine. An error occured, but no {\tt PAUSE} could be
delivered because the session is a batch mode. The program aborts
execution with a symbolic stack dump.
\action\  correct the invalid command which caused the error
and resubmit the job.

\end{description}
\subsection{S}
\begin{description}
\item{\tt E-SEXA,  Invalid minute field}\\
{\tt SIC}, Sexagesimal decoding routine. The minute field is negative, or
greater than 60.
\action\  Correct typing errors.

\item{\tt E-SEXA,  Invalid second field}\\
{\tt SIC}, Sexagesimal decoding routine. The minute field is negative, or
greater than 60.
\action\  Correct typing errors.

\item{\tt E-SEXA,  Syntax error}\\
{\tt SIC}, Sexagesimal decoding routine. Valid syntaxes for
sexagesimal arguments are {\tt +DD.DDD, +DD:MM.MMM, and +DD:MM:SS.SSS}.
\action\  Correct typing errors.

\item{\tt W-SIC,  Ambiguous keyword, choices are :}\\
{\tt SIC, SIC} command. The first argument is ambiguous.
\action\  specify more characters.

\item{\tt W-SIC,  Cannot change SIC$\backslash$ language status}\\
{\tt SIC, SIC} command. Information message : language 
{\tt SIC$\backslash$} cannot be removed from the active scope.

\item{\tt W-SIC,  Cannot set HELP mode <String>}\\
{\tt SIC, SIC} command. The user requested an invalid mode for {\tt HELP}.
\action\  specify a valid mode. Valid modes are {\tt PAGE} and {\tt SCROLL}.

\item{\tt W-SIC,  Cannot set <String> language <String2>}\\
{\tt SIC, SIC} command. Information message : languages can only be 
{\tt ON} or {\tt OFF}. Library only languages cannot be brought into the active
scope.

\item{\tt E-SIC,  Cannot set <String> switch <String2>}\\
{\tt SIC, SIC} command. The status {\tt <String2>} does not exist for
the switch {\tt <String>}
\action\  check for typing errors.

\item{\tt E-SIC,  Command invalid in this context <string>}\\
{\tt SIC}, monitor routine. Command {\tt IF}, {\tt ELSE} and {\tt ENDIF} can 
only be used in procedures.
\action\  use a procedure.

\item{\tt F-SIC,  Commands must be character*12}\\
{\tt SIC}, initialization routine. The command names are too long or too
short. Execution aborts.
\action\  notify the programmer.

\item{\tt F-SIC,  Demonstration period exhausted, Call your system manager}\\
\action\ ask your system manager to buy an authorized copy.

\item{\tt F-SIC,  Duplicate language name}\\
{\tt SIC}, initialization routine. The language name is already used.
Execution aborts.
\action\  notify the programmer.

\item{\tt W-SIC,  Edit mode requires an ANSII terminal}\\
{\tt SIC, SIC} command. Information message : the user requested the {\tt EDIT}
mode, but is not logged on a {\tt ANSII} (or compatible) video terminal. 
{\tt EDIT} mode is left {\tt OFF}. 

\item{\tt I-SIC,  Editor is <String>}\\
{\tt SIC, SIC} command. Information message specifying 
which text editor is used by command {\tt EDIT}.

\item{\tt I-SIC,  HELP mode is <String>}\\
{\tt SIC, SIC} command. Information message specifying the {\tt HELP} mode.

\item{\tt W-SIC,  Incorrect nesting of IF blocks}\\
{\tt SIC}, monitor routine. Some {\tt IF} blocks were not properly nested
and are still opened when a macro or loop terminates. The opened
blocks are closed by \sic.
\action\  although this is only a warning, it may be wise
to check the current macro for possible error(s).

\item{\tt F-SIC,  Initialization error number <Integer>}\\
{\tt SIC}, initialization routine. An undocumented initialization error
occurred. Execution aborts.
\action\  notify the programmer, who should submit an SPR.

\item{\tt F-SIC,  Internal logic error LIRE = -1}\\
{\tt SIC}, command reading routine. This is a fatal bug check.
\action\  Submit an SPR, with as much
information as you can (log file, program listing, etc...).

\item{\tt E-SIC,  Invalid nesting of loops and IF blocks}\\
{\tt SIC}, monitor routine. Some {\tt FOR} loops were not properly nested
and are still opened when an {\tt IF} block terminates. 
\action\  Check the current macro for error(s).

\item{\tt W-SIC,  Invalid precision <string>}\\
{\tt SIC, SIC} command. The only supported precisions are {\tt SINGLE} (or {\tt
REAL}) and {\tt DOUBLE}. Previous precision is kept. 
\action\  specify a valid precision.

\item{\tt F-SIC,  Language initialization failure}\\
{\tt SIC}, initialization routine. This message is preceded by a more detailed 
account of the problems. This is a fatal error, and the program execution 
aborts with a symbolic stack dump.
\action\  notify the programmer.

\item{\tt F-SIC,  Programming error: recursive call to SIC}\\
{\tt SIC}, monitor routine. The programmer made a recursive call to \sic .
This is a fatal error, and the program execution aborts with a 
symbolic stack dump.
\action\  notify the programmer.

\item{\tt W-SIC,  Session is not interactive, EDIT and MEMORY Off}\\
{\tt SIC}, monitor routine. Information message. This message appears
at the beginning of the program (usually when nobody is available
to read it...).

\item{\tt F-SIC,  SIC is not loaded}\\
{\tt SIC}, monitor routine. The program attempted to use \sic\ before 
initializing the interpreter. This is a programming error.
\action\  notify the programmer.

\item{\tt I-SIC,  <String> switch is <String2>}\\
{\tt SIC, SIC} command. Information message.

\item{\tt I-SIC,  <String> language is <String>}\\
{\tt SIC, SIC} command. Information message.

\item{\tt W-SIC,  Sub-process <String> is still active}\\
{\tt SIC}, exit routine. A sub-process has been created earlier by the
{\tt SYSTEM} command. The sub-process is not deleted.
\action\  You can attach to this sub-process at any time by
the VMS command {\tt ATTACH}, or delete it by the VMS command {\tt
STOP}.

\item{\tt E-SIC,  Too many IF blocks}\\
{\tt SIC}, monitor routine. You are attempting to nest {\tt IF} blocks too
deeply.
\action\  Do not. Find another way to solve your problem.

\item{\tt F-SIC,  Too many commands and options. This program is only\\
dimensioned for <Integer> user-defined commands.}\\
{\tt SIC}, initialization routine. The program has too many commands and
options. Execution aborts. 
\action\  notify the programmer, who may submit an SPR (even
though this is no an error in \sic\, just a limitation).

\item{\tt F-SIC,  Too many languages}\\
{\tt SIC}, initialization routine. The program has too many languages.
Execution aborts.
\action\  notify the programmer.

\item{\tt W-SIC,  Undefined character expression <string>}\\
Formatting routine. The specified string is not a valid character string.
This message is usually preceded by other ones that give additional information.
\action\  Correct typing mistake(s)

\item{\tt W-SIC,  You are using a demonstration version}\\
{\tt SIC}. The version of \sic\ you are using is a demonstration version with a
limited validity period (usually 3 to 6 months). Contact the authors
about a permanent licence (available at no cost for academic institutions).
\action\  Beware that the validity period will expire...

\item{\tt E-SYMBOL,  Invalid symbol name <String>}\\
{\tt SIC, SYMBOL} routine. A symbol name must begin with an alphabetic
uppercase character.
\action\  use a valid name.

\item{\tt F-SYMBOL,  SIC is not loaded}\\
{\tt SIC, DEFINE\_SYMBOL} routine. The program attempts to define a symbol
before SIC has been initialized. This is a programming error.
\action\  notify the programmer.

\item{\tt E-SYMBOL,  String too long, translation failed}\\
{\tt SIC}, monitor routine. The line buffer is too short to accomodate
the symbol translation. The command is not executed, and an error
occurs.
\action\ : If possible shorten your command or symbol translation.
Eventually contact the programmer.

\item{\tt E-SYMBOL,  Symbol definition too long}\\
{\tt SIC, SYMBOL} command. The equivalence name is too long. The
symbol is undefined.
\action\  cut the definition in two symbols and use
concatenation when translation is required.

\item{\tt W-SYMBOL,  Symbol name too long <String>}\\
{\tt SIC, SYMBOL} command. Symbol names must be shorter than 12 characters.
\action\  use shorter symbol names.

\item{\tt W-SYMBOL,  Symbol truncated to <String>}\\
{\tt SIC, SYMBOL} command. A symbol name contained more than 12 characters
and has been truncated.

\item{\tt E-SYMBOL,  Too many symbols}\\
{\tt SIC, SYMBOL} routine. There are too many symbols, the new definition
has not been added.
\action\  delete unwanted symbols before adding a new one.

\item{\tt I-SYMBOL,  Table is empty}\\
{\tt SIC, SYMBOL} command. Information message, there are no symbols
defined.

\item{\tt I-SYMBOL,  Table contains : }\\
{\tt SIC, SYMBOL} command. Information message, followed by the list
of symbols and equivalence strings.

\item{\tt W-SYMBOL,  Undefined symbol <String>}\\
{\tt SIC, SYMBOL} command. The specified symbol is undefined.

\item{\tt E-SYSTEM,  Sub-process cannot be activated}\\
{\tt SIC, SYSTEM} command with or without arguments. The sub-process
could not be created because of lack of system resources. The VMS
error message follows this error.
\action\  If the command had an argument, retry it without
as you may connect to an existing subprocess. If this fails,
it is generally due to an exceeded quota of subprocesses.
If you have other subprocesses running, the {\tt SYSTEM} command lists the
current subprocesses and prompts you to which one you want to attach.
If none is available, the {\tt SYSTEM} command will return you an error.

\item{\tt E-SYSTEM,  Sub-process <String> could not be attached}\\
{\tt SIC, SYSTEM} command without argument, or with option {\tt
/PROCESS.} The programs failed to attach to an existing sub-process,
previously created by the {\tt SIC$\backslash$SYSTEM} command, or by
another program. If the option {\tt /PROCESS} was not present, the
command will try to create a new one.
\action\  Check process name in case you used the {\tt /PROCESS}
option.

\item{\tt W-SYSTEM,  More than <number> sub-processes active}\\
{\tt SIC, SYSTEM} command with or without arguments. You have reached
the maximum number of sub-processes allowed within \sic\. 
\action\ If the command had an argument, retry it without as you may 
connect to an existing subprocess. If this fails, the {\tt SYSTEM}
command lists the current subprocesses and prompts you to which one
you want to attach.  If none is available, the {\tt SYSTEM} command
will return you an error.

\item{\tt E-SYSTEM,  Sub-process cannot be created}\\
{\tt SIC, SYSTEM} command with or without arguments. The sub-process cannot be
created, usually because of lack of system resources. The VMS error message
follows this error. 
\action\  If the command had an argument, retry it without
as you may connect to an existing subprocess. If this fails, it is
generally due to an exceeded quota of subprocesses. If you have other
subprocesses running, the {\tt SYSTEM} command lists the current
subprocesses and prompts you to which one you want to attach. If none
is available, the {\tt SYSTEM} command will return you an error.

%TTT
\end{description}
\subsection{T}
\begin{description}
\item{\tt E-TYPE,  Cannot open <String>}\\
{\tt SIC, TYPE} command. The specified file or macro could not be opened.
This message is followed by a more precise reason.
\action\  check for typing errors.

\item{\tt E-TYPE,  Error reading <String>}\\
{\tt SIC, TYPE} command. A read error occured during the typing of a file
or macro. The {\tt TYPE} command aborts.
\action\  most likely you are trying to type a binary
file or something like this... Otherwise, it is a hardware problem.
Notify your system manager.

%UUU
\end{description}
\subsection{U through Z}
\begin{description}
\item{\tt E-VARIABLE,  Internal error, no back pointer}\\
{\tt SIC, DELETE /VARIABLE} command. This is an internal logic error.
\action\  Submit an SPR.

\item{\tt E-VARIABLE,  Invalid variable name <String>}\\
{\tt SIC, DEFINE LET /NEW or FOR} commands. Variable names must be at
most 15 characters and begin with a letter.
\action\  use a valid name.

\item{\tt E-VARIABLE,  Program defined variables are protected}\\
{\tt SIC, DELETE /VARIABLE} command. You attempt to delete a variable that has
been created by program. This is not allowed. 

\item{\tt F-VARIABLE,  SIC is not loaded}\\
Calling program. The program attempts to define variables before the 
interpreter has been initialized. This is a programming error.
\action\  notify the programmer.

\item{\tt E-VARIABLE,  Too many variables}\\
{\tt SIC, SIC, DEFINE LET /NEW or FOR} commands. You attempted to
define too many variables.
\action\  Delete unused variables and retry. If this is not 
sufficient, submit an SPR, and we will increase the buffer size.


\item{\tt E-VARIABLE,  Variable <String> already exists}\\
{\tt SIC, DEFINE or LET /NEW}. The specified name is already 
a known variable.
\action\  use a different name, or delete the variable before.

\item{\tt E-VARIABLE,  Variable name too long}\\
{\tt SIC, DEFINE LET /NEW or FOR} commands. Variable names must be at
most 15 characters.
\action\  use a shorter name.

\item{\tt E-ZCRONGNEUGNEU, j'y arrive pas}\\
Congratulations, {\bf you got a free bottle of champagne} if\ldots \\
you can reproduce the error.
\action\  Contact the authors.

\end{description}

