@c DO NOT EDIT!  Generated automatically by munge-texi.pl.

@c Copyright (C) 1996-2022 The Octave Project Developers
@c
@c This file is part of Octave.
@c
@c Octave is free software: you can redistribute it and/or modify it
@c under the terms of the GNU General Public License as published by
@c the Free Software Foundation, either version 3 of the License, or
@c (at your option) any later version.
@c
@c Octave is distributed in the hope that it will be useful, but
@c WITHOUT ANY WARRANTY; without even the implied warranty of
@c MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@c GNU General Public License for more details.
@c
@c You should have received a copy of the GNU General Public License
@c along with Octave; see the file COPYING.  If not, see
@c <https://www.gnu.org/licenses/>.

@node Errors and Warnings
@chapter Errors and Warnings

Octave includes several functions for printing error and warning
messages.  When you write functions that need to take special action
when they encounter abnormal conditions, you should print the error
messages using the functions described in this chapter.

Since many of Octave's functions use these functions, it is also useful
to understand them, so that errors and warnings can be handled.

@menu
* Handling Errors::
* Handling Warnings::
@end menu

@node Handling Errors
@section Handling Errors

An error is something that occurs when a program is in a state where
it doesn't make sense to continue.  An example is when a function is
called with too few input arguments.  In this situation the function
should abort with an error message informing the user of the lacking
input arguments.

Since an error can occur during the evaluation of a program, it is
very convenient to be able to detect that an error occurred, so that
the error can be fixed.  This is possible with the @code{try} statement
described in @ref{The try Statement}.

@menu
* Raising Errors::
* Catching Errors::
* Recovering From Errors::
@end menu

@node Raising Errors
@subsection Raising Errors

The most common use of errors is for checking input arguments to
functions.  The following example calls the @code{error} function if
the function @code{f} is called without any input arguments.

@example
@group
function f (arg1)
  if (nargin == 0)
    error ("not enough input arguments");
  endif
endfunction
@end group
@end example

When the @code{error} function is called, it prints the given message
and returns to the Octave prompt.  This means that no code following
a call to @code{error} will be executed.

It is also possible to assign an identification string to an error.
If an error has such an ID the user can catch this error
as will be described in the next section.  To assign an ID to an error,
simply call @code{error} with two string arguments, where the first
is the identification string, and the second is the actual error.  Note
that error IDs are in the format @qcode{"NAMESPACE:ERROR-NAME"}.  The namespace
@qcode{"Octave"} is used for Octave's own errors.  Any other string is
available as a namespace for user's own errors.

@c error libinterp/corefcn/error.cc
@anchor{XREFerror}
@deftypefn  {} {} error (@var{template}, @dots{})
@deftypefnx {} {} error (@var{id}, @var{template}, @dots{})
Display an error message and stop m-file execution.

Format the optional arguments under the control of the template string
@var{template} using the same rules as the @code{printf} family of
functions (@pxref{Formatted Output}) and print the resulting message
on the @code{stderr} stream.  The message is prefixed by the character
string @samp{error: }.

Calling @code{error} also sets Octave's internal error state such that
control will return to the top level without evaluating any further
commands.  This is useful for aborting from functions or scripts.

If the error message does not end with a newline character, Octave will
print a traceback of all the function calls leading to the error.  For
example, given the following function definitions:

@example
@group
function f () g (); end
function g () h (); end
function h () nargin == 1 || error ("nargin != 1"); end
@end group
@end example

@noindent
calling the function @code{f} will result in a list of messages that
can help you to quickly find the exact location of the error:

@example
@group
f ()
error: nargin != 1
error: called from:
error:   h at line 1, column 27
error:   g at line 1, column 15
error:   f at line 1, column 15
@end group
@end example

If the error message ends in a newline character, Octave will print the
message but will not display any traceback messages as it returns
control to the top level.  For example, modifying the error message
in the previous example to end in a newline causes Octave to only print
a single message:

@example
@group
function h () nargin == 1 || error ("nargin != 1\n"); end
f ()
error: nargin != 1
@end group
@end example

A null string ("") input to @code{error} will be ignored and the code
will continue running as if the statement were a NOP@.  This is for
compatibility with @sc{matlab}.  It also makes it possible to write code
such as

@example
@group
err_msg = "";
if (CONDITION 1)
  err_msg = "CONDITION 1 found";
elseif (CONDITION2)
  err_msg = "CONDITION 2 found";
@dots{}
endif
error (err_msg);
@end group
@end example

@noindent
which will only stop execution if an error has been found.

Implementation Note: For compatibility with @sc{matlab}, escape
sequences in @var{template} (e.g., @qcode{"@backslashchar{}n"} =>
newline) are processed regardless of whether @var{template} has been defined
with single quotes, as long as there are two or more input arguments.  To
disable escape sequence expansion use a second backslash before the sequence
(e.g., @qcode{"@backslashchar{}@backslashchar{}n"}) or use the
@code{regexptranslate} function.
@xseealso{@ref{XREFwarning,,warning}, @ref{XREFlasterror,,lasterror}}
@end deftypefn


Since it is common to use errors when there is something wrong with
the input to a function, Octave supports functions to simplify such code.
When the @code{print_usage} function is called, it reads the help text
of the function calling @code{print_usage}, and presents a useful error.
If the help text is written in Texinfo it is possible to present an
error message that only contains the function prototypes as described
by the @code{@@deftypefn} parts of the help text.  When the help text
isn't written in Texinfo, the error message contains the entire help
message.

Consider the following function.

@example
@group
## -*- texinfo -*-
## @@deftypefn @{@} f (@@var@{arg1@})
## Function help text goes here@dots{}
## @@end deftypefn
function f (arg1)
  if (nargin == 0)
    print_usage ();
  endif
endfunction
@end group
@end example

@noindent
When it is called with no input arguments it produces the following
error.

@example
@group
f ()

@print{}  error: Invalid call to f.  Correct usage is:
@print{}
@print{}   -- f (ARG1)
@print{}
@print{}
@print{}  Additional help for built-in functions and operators is
@print{}  available in the online version of the manual.  Use the command
@print{}  'doc <topic>' to search the manual index.
@print{}
@print{}  Help and information about Octave is also available on the WWW
@print{}  at https://www.octave.org and via the help@@octave.org
@print{}  mailing list.
@end group
@end example

@c print_usage scripts/help/print_usage.m
@anchor{XREFprint_usage}
@deftypefn  {} {} print_usage ()
@deftypefnx {} {} print_usage (@var{name})
Print the usage message for the function @var{name}.

When called with no input arguments the @code{print_usage} function displays
the usage message of the currently executing function.
@xseealso{@ref{XREFhelp,,help}}
@end deftypefn


@c beep scripts/io/beep.m
@anchor{XREFbeep}
@deftypefn {} {} beep ()
Produce a beep from the speaker (or visual bell).

This function sends the alarm character @qcode{"@backslashchar{}a"} to
the terminal.  Depending on the user's configuration this may produce an
audible beep, a visual bell, or nothing at all.
@xseealso{@ref{XREFputs,,puts}, @ref{XREFfputs,,fputs}, @ref{XREFprintf,,printf}, @ref{XREFfprintf,,fprintf}}
@end deftypefn


@c beep_on_error libinterp/corefcn/error.cc
@anchor{XREFbeep_on_error}
@deftypefn  {} {@var{val} =} beep_on_error ()
@deftypefnx {} {@var{old_val} =} beep_on_error (@var{new_val})
@deftypefnx {} {} beep_on_error (@var{new_val}, "local")
Query or set the internal variable that controls whether Octave will try
to ring the terminal bell before printing an error message.

When called from inside a function with the @qcode{"local"} option, the
variable is changed locally for the function and any subroutines it calls.
The original variable value is restored when exiting the function.
@end deftypefn


@node Catching Errors
@subsection Catching Errors

When an error occurs, it can be detected and handled using the
@code{try} statement as described in @ref{The try Statement}.
As an example, the following piece of code counts the number of errors
that occurs during a @code{for} loop.

@example
@group
number_of_errors = 0;
for n = 1:100
  try
    @dots{}
  catch
    number_of_errors++;
  end_try_catch
endfor
@end group
@end example

The above example treats all errors the same.  In many situations it
can however be necessary to discriminate between errors, and take
different actions depending on the error.  The @code{lasterror}
function returns a structure containing information about the last
error that occurred.  As an example, the code above could be changed
to count the number of errors related to the @samp{*} operator.

@example
@group
number_of_errors = 0;
for n = 1:100
  try
    @dots{}
  catch
    msg = lasterror.message;
    if (strfind (msg, "operator *"))
      number_of_errors++;
    endif
  end_try_catch
endfor
@end group
@end example

@noindent
Alternatively, the output of the @code{lasterror} function can be found
in a variable indicated immediately after the @code{catch} keyword, as
in the example below showing how to redirect an error as a warning:

@example
@group
try
  @dots{}
catch err
  warning(err.identifier, err.message);
  @dots{}
end_try_catch
@end group
@end example

@c lasterror libinterp/corefcn/error.cc
@anchor{XREFlasterror}
@deftypefn  {} {@var{lasterr} =} lasterror ()
@deftypefnx {} {} lasterror (@var{err})
@deftypefnx {} {} lasterror ("reset")
Query or set the last error message structure.

When called without arguments, return a structure containing the last error
message and other information related to this error.  The elements of the
structure are:

@table @code
@item message
The text of the last error message

@item identifier
The message identifier of this error message

@item stack
A structure containing information on where the message occurred.  This may
be an empty structure if the information cannot be obtained.  The fields of
the structure are:

@table @code
@item file
The name of the file where the error occurred

@item name
The name of function in which the error occurred

@item line
The line number at which the error occurred

@item column
An optional field with the column number at which the error occurred
@end table
@end table

The last error structure may be set by passing a scalar structure,
@var{err}, as input.  Any fields of @var{err} that match those above are
set while any unspecified fields are initialized with default values.

If @code{lasterror} is called with the argument @qcode{"reset"}, all
fields are set to their default values.
@xseealso{@ref{XREFlasterr,,lasterr}, @ref{XREFerror,,error}, @ref{XREFlastwarn,,lastwarn}}
@end deftypefn


@c lasterr libinterp/corefcn/error.cc
@anchor{XREFlasterr}
@deftypefn  {} {[@var{msg}, @var{msgid}] =} lasterr ()
@deftypefnx {} {} lasterr (@var{msg})
@deftypefnx {} {} lasterr (@var{msg}, @var{msgid})
Query or set the last error message.

When called without input arguments, return the last error message and
message identifier.

With one argument, set the last error message to @var{msg}.

With two arguments, also set the last message identifier.
@xseealso{@ref{XREFlasterror,,lasterror}, @ref{XREFerror,,error}, @ref{XREFlastwarn,,lastwarn}}
@end deftypefn


The next example counts indexing errors.  The errors are caught using the
field identifier of the structure returned by the function @code{lasterror}.

@example
@group
number_of_errors = 0;
for n = 1:100
  try
    @dots{}
  catch
    id = lasterror.identifier;
    if (strcmp (id, "Octave:invalid-indexing"))
      number_of_errors++;
    endif
  end_try_catch
endfor
@end group
@end example

The functions distributed with Octave can issue one of the following
errors.

@c error_ids scripts/help/error_ids.m
@anchor{XREFerror_ids}
@cindex error ids

@table @code
@item Octave:bad-alloc
Indicates that memory couldn't be allocated.

@item Octave:invalid-context
Indicates the error was generated by an operation that cannot be executed in
the scope from which it was called.  For example, the function
@code{print_usage ()} when called from the Octave prompt raises this error.

@item Octave:invalid-fun-call
Indicates that a function was called in an incorrect way, e.g., wrong number
of input arguments.

@item Octave:invalid-indexing
Indicates that a data-type was indexed incorrectly, e.g., real-value index
for arrays, nonexistent field of a structure.

@item Octave:invalid-input-arg
Indicates that a function was called with invalid input arguments.

@item Octave:undefined-function
Indicates a call to a function that is not defined.  The function may exist
but Octave is unable to find it in the search path.

@end table



When an error has been handled it is possible to raise it again.  This
can be useful when an error needs to be detected, but the program should
still abort.  This is possible using the @code{rethrow} function.  The
previous example can now be changed to count the number of errors
related to the @samp{*} operator, but still abort if another kind of
error occurs.

@example
@group
number_of_errors = 0;
for n = 1:100
  try
    @dots{}
  catch
    msg = lasterror.message;
    if (strfind (msg, "operator *"))
      number_of_errors++;
    else
      rethrow (lasterror);
    endif
  end_try_catch
endfor
@end group
@end example

@c rethrow libinterp/corefcn/error.cc
@anchor{XREFrethrow}
@deftypefn {} {} rethrow (@var{err})
Reissue a previous error as defined by @var{err}.

@var{err} is a structure that must contain at least the @qcode{"message"}
and @qcode{"identifier"} fields.  @var{err} can also contain a field
@qcode{"stack"} that gives information on the assumed location of the
error.  Typically @var{err} is returned from @code{lasterror}.
@xseealso{@ref{XREFlasterror,,lasterror}, @ref{XREFlasterr,,lasterr}, @ref{XREFerror,,error}}
@end deftypefn


@c FIXME: I have no idea what the rest of the functions are used for...

@c errno libinterp/corefcn/utils.cc
@anchor{XREFerrno}
@deftypefn  {} {@var{err} =} errno ()
@deftypefnx {} {@var{err} =} errno (@var{val})
@deftypefnx {} {@var{err} =} errno (@var{name})
Query or set the system-dependent variable errno.

When called with no inputs, return the current value of errno.

When called with a numeric input @var{val}, set the current value of errno
to the specified value.  The previous value of errno is returned as @var{err}.

When called with a character string @var{name}, return the numeric value of
errno which corresponds to the specified error code.  If @var{name} is not
a recognized error code then -1 is returned.

@xseealso{@ref{XREFerrno_list,,errno_list}}
@end deftypefn


@c errno_list libinterp/corefcn/utils.cc
@anchor{XREFerrno_list}
@deftypefn {} {} errno_list ()
Return a structure containing the system-dependent errno values.
@xseealso{@ref{XREFerrno,,errno}}
@end deftypefn


@node Recovering From Errors
@subsection Recovering From Errors

Octave provides several ways of recovering from errors.  There are
@code{try}/@code{catch} blocks,
@code{unwind_protect}/@code{unwind_protect_cleanup} blocks,
and finally the @code{onCleanup} command.

The @code{onCleanup} command associates an ordinary Octave variable (the
trigger) with an arbitrary function (the action).  Whenever the Octave variable
ceases to exist---whether due to a function return, an error, or simply because
the variable has been removed with @code{clear}---then the assigned function
is executed.

The function can do anything necessary for cleanup such as closing open file
handles, printing an error message, or restoring global variables to their
initial values.  The last example is a very convenient idiom for Octave code.
For example:

@example
@group
function rand42
  old_state = rand ("state");
  restore_state = onCleanup (@@() rand ("state", old_state));
  rand ("state", 42);
  @dots{}
endfunction  # rand generator state restored by onCleanup
@end group
@end example

@c onCleanup libinterp/octave-value/ov-oncleanup.cc
@anchor{XREFonCleanup}
@deftypefn {} {@var{obj} =} onCleanup (@var{function})
Create a special object that executes a given function upon destruction.

If the object is copied to multiple variables (or cell or struct array
elements) or returned from a function, @var{function} will be executed after
clearing the last copy of the object.  Note that if multiple local onCleanup
variables are created, the order in which they are called is unspecified.
For similar functionality @xref{The unwind_protect Statement}.
@end deftypefn


@node Handling Warnings
@section Handling Warnings

Like an error, a warning is issued when something unexpected happens.
Unlike an error, a warning doesn't abort the currently running program.
A simple example of a warning is when a number is divided by zero.  In
this case Octave will issue a warning and assign the value @code{Inf}
to the result.

@example
@group
a = 1/0
     @print{} warning: division by zero
     @result{} a = Inf
@end group
@end example

@menu
* Issuing Warnings::
* Enabling and Disabling Warnings::
@end menu

@node Issuing Warnings
@subsection Issuing Warnings

It is possible to issue warnings from any code using the @code{warning}
function.  In its most simple form, the @code{warning} function takes a
string describing the warning as its input argument.  As an example,
the following code controls if the variable @samp{a} is non-negative,
and if not issues a warning and sets @samp{a} to zero.

@example
@group
a = -1;
if (a < 0)
  warning ("'a' must be non-negative.  Setting 'a' to zero.");
  a = 0;
endif
     @print{} 'a' must be non-negative.  Setting 'a' to zero.
@end group
@end example

Since warnings aren't fatal to a running program, it is not possible
to catch a warning using the @code{try} statement or something similar.
It is however possible to access the last warning as a string using the
@code{lastwarn} function.

It is also possible to assign an identification string to a warning.
If a warning has such an ID the user can enable and disable this warning
as will be described in the next section.  To assign an ID to a warning,
simply call @code{warning} with two string arguments, where the first
is the identification string, and the second is the actual warning.  Note
that warning IDs are in the format @qcode{"NAMESPACE:WARNING-NAME"}.  The
namespace @qcode{"Octave"} is used for Octave's own warnings.  Any other string
is available as a namespace for user's own warnings.

@c warning libinterp/corefcn/error.cc
@anchor{XREFwarning}
@deftypefn  {} {} warning (@var{template}, @dots{})
@deftypefnx {} {} warning (@var{id}, @var{template}, @dots{})
@deftypefnx {} {} warning ("on", @var{id})
@deftypefnx {} {} warning ("off", @var{id})
@deftypefnx {} {} warning ("error", @var{id})
@deftypefnx {} {} warning ("query", @var{id})
@deftypefnx {} {} warning (@var{state}, @var{id}, "local")
@deftypefnx {} {} warning (@var{warning_struct})
@deftypefnx {} {@var{warning_struct} =} warning (@dots{})
@deftypefnx {} {} warning (@var{state}, @var{mode})

Display a warning message or control the behavior of Octave's warning system.

The first call form uses a template @var{template} and optional additional
arguments to display a message on the @code{stderr} stream.  The message is
formatted using the same rules as the @code{printf} family of functions
(@pxref{Formatted Output}) and prefixed by the character string
@w{@samp{warning: }}.  You should use this function when you want to notify the
user of an unusual condition, but only when it makes sense for your program to
go on.  For example:

@example
@group
warning ("foo: maybe something wrong here");
@end group
@end example

If the warning message does not end with a newline character, Octave will
print a traceback of all the function calls leading to the warning.  If the
warning message does end in a newline character, Octave will suppress the
traceback messages as it returns control to the top level.  For more details
and examples, @pxref{XREFerror,,@code{error}}.

The optional warning identifier @var{id} allows users to enable or disable
warnings tagged by this identifier.  A message identifier is a string of the
form @qcode{"NAMESPACE:WARNING-NAME"}.  Octave's own warnings use the
@qcode{"Octave"} namespace (@pxref{XREFwarning_ids,,@code{warning_ids}}).  For
example:

@example
@group
warning ("MyNameSpace:check-something",
         "foo: maybe something wrong here");
@end group
@end example

The second call form is meant to change and/or query the state of warnings.
The first input argument must be a string @var{state} (@qcode{"on"},
@qcode{"off"}, @qcode{"error"}, or @qcode{"query"}) followed by an optional
warning identifier @var{id} or @qcode{"all"} (default).

The optional output argument @var{warning_struct} is a structure or structure
array with fields @qcode{"state"} and @qcode{"identifier"}.  The @var{state}
argument may have the following values:

@table @asis
@item @qcode{"on"}|@qcode{"off"}:
Enable or disable the display of warnings identified by @var{id} and optionally
return their previous state @var{stout}.

@item @qcode{"error"}:
Turn warnings identified by @var{id} into errors and optionally return their
previous state @var{stout}.

@item @qcode{"query"}:
Return the current state of warnings identified by @var{id}.
@end table

A structure or structure array @var{warning_struct}, with fields
@qcode{"state"} and @qcode{"identifier"}, may be given as an input to achieve
equivalent results.  The following example shows how to temporarily disable a
warning and then restore its original state:

@example
@group
loglog (-1:10);
## Disable the previous warning and save its original state
[~, id] = lastwarn ();
warnstate = warning ("off", id);
loglog (-1:10);
## Restore its original state
warning (warnstate);
@end group
@end example

If a final argument @qcode{"local"} is provided then the warning state will be
set temporarily until the end of the current function.  Changes to warning
states that are set locally affect the current function and all functions
called from the current scope.  The previous warning state is restored on
return from the current function.  The @qcode{"local"} option is ignored if
used in the top-level workspace.

With no input argument @code{warning ()} is equivalent to
@code{warning ("query", "all")} except that in the absence of an output
argument, the state of warnings is displayed on @code{stderr}.

The level of verbosity of the warning system may also be controlled by two
modes @var{mode}:

@table @asis
@item @qcode{"backtrace"}:
enable/disable the display of the stack trace after the warning message

@item @qcode{"verbose"}:
enable/disable the display of additional information after the warning message
@end table

In this case the @var{state} argument may only be @qcode{"on"} or
@qcode{"off"}.

Implementation Note: For compatibility with @sc{matlab}, escape sequences in
@var{template} (e.g., @qcode{"@backslashchar{}n"} => newline) are processed
regardless of whether @var{template} has been defined with single quotes, as
long as there are two or more input arguments.  To disable escape sequence
expansion use a second backslash before the sequence (e.g.,
@qcode{"@backslashchar{}@backslashchar{}n"}) or use the
@code{regexptranslate} function.
@xseealso{@ref{XREFwarning_ids,,warning_ids}, @ref{XREFlastwarn,,lastwarn}, @ref{XREFerror,,error}}
@end deftypefn


@c lastwarn libinterp/corefcn/error.cc
@anchor{XREFlastwarn}
@deftypefn  {} {[@var{msg}, @var{msgid}] =} lastwarn ()
@deftypefnx {} {} lastwarn (@var{msg})
@deftypefnx {} {} lastwarn (@var{msg}, @var{msgid})
Query or set the last warning message.

When called without input arguments, return the last warning message and
message identifier.

With one argument, set the last warning message to @var{msg}.

With two arguments, also set the last message identifier.
@xseealso{@ref{XREFwarning,,warning}, @ref{XREFlasterror,,lasterror}, @ref{XREFlasterr,,lasterr}}
@end deftypefn


The functions distributed with Octave can issue one of the following
warnings.

@c warning_ids scripts/help/warning_ids.m
@anchor{XREFwarning_ids}
@cindex warning ids

@table @code
@item Octave:abbreviated-property-match
If the @code{Octave:abbreviated-property-match} warning is enabled, a
warning is printed if a non-exact or ambiguous match is being used for a
operation specifying an object property.  For example, for a graphics
object, @var{fig}, with the property @qcode{'displayname'},
@code{get (@var{fig}, 'dis')} elicits a warning if the
@code{Octave:abbreviated-property-match} warning is enabled.
By default, the @code{Octave:abbreviated-property-match} warning is enabled.

@item Octave:addpath-pkg
If the @code{Octave:addpath-pkg} warning is enabled,
Octave will warn when a package directory (i.e., +package_name) is added
to the @code{path}.  Typically, only the parent directory which contains the
package directory should be added to the load path.
By default, the @code{Octave:addpath-pkg} warning is enabled.

@item Octave:array-as-logical
If the @code{Octave:array-as-logical} warning is enabled,
Octave will warn when an array of size greater than 1x1 is used
as a truth value in an if, while, or until statement.
By default, the @code{Octave:array-as-logical} warning is disabled.

@item Octave:array-to-scalar
If the @code{Octave:array-to-scalar} warning is enabled, Octave will
warn when an implicit conversion from an array to a scalar value is
attempted.
By default, the @code{Octave:array-to-scalar} warning is disabled.

@item Octave:array-to-vector
If the @code{Octave:array-to-vector} warning is enabled, Octave will
warn when an implicit conversion from an array to a vector value is
attempted.
By default, the @code{Octave:array-to-vector} warning is disabled.

@item Octave:assign-as-truth-value
If the @code{Octave:assign-as-truth-value} warning is
enabled, a warning is issued for statements like

@example
@group
if (s = t)
  @dots{}
@end group
@end example

@noindent
since such statements are not common, and it is likely that the intent
was to write

@example
@group
if (s == t)
  @dots{}
@end group
@end example

@noindent
instead.

There are times when it is useful to write code that contains
assignments within the condition of a @code{while} or @code{if}
statement.  For example, statements like

@example
@group
while (c = getc ())
  @dots{}
@end group
@end example

@noindent
are common in C programming.

It is possible to avoid all warnings about such statements by
disabling the @code{Octave:assign-as-truth-value} warning,
but that may also let real errors like

@example
@group
if (x = 1)  # intended to test (x == 1)!
  @dots{}
@end group
@end example

@noindent
slip by.

In such cases, it is possible suppress errors for specific statements by
writing them with an extra set of parentheses.  For example, writing the
previous example as

@example
@group
while ((c = getc ()))
  @dots{}
@end group
@end example

@noindent
will prevent the warning from being printed for this statement, while
allowing Octave to warn about other assignments used in conditional
contexts.

By default, the @code{Octave:assign-as-truth-value} warning is enabled.

@item Octave:autoload-relative-file-name
If the @code{Octave:autoload-relative-file-name} is enabled,
Octave will warn when parsing autoload() function calls with relative
paths to function files.  This usually happens when using autoload()
calls in PKG_ADD files, when the PKG_ADD file is not in the same
directory as the .oct file referred to by the autoload() command.
By default, the @code{Octave:autoload-relative-file-name} warning is
enabled.

@item Octave:charmat-truncated
If the @code{Octave:charmat-truncated} warning is enabled, a warning is
printed when a character matrix with multiple rows is converted to a string.
In this case, the Octave interpreter keeps only the first row and discards
the others.
By default, the @code{Octave:charmat-truncated} warning is enabled.

@item Octave:classdef-to-struct
If the @code{Octave:classdef-to-struct} warning is enabled, a warning
is issued when a classdef object is forcibly converted into a struct with
@code{struct (@var{CLASSDEF_OBJ})}.  Conversion removes the access
restrictions from the object and makes private and protected properties
visible.
By default, the @code{Octave:classdef-to-struct} warning is enabled.

@item Octave:colon-complex-argument
If the @code{Octave:colon-complex-argument} warning is enabled, a warning
is issued when one of the three arguments to the colon operator (base,
increment, limit) is a complex value.  For example, @code{1:3*i} will
cause a warning to be emitted.
By default, the @code{Octave:colon-complex-argument} warning is enabled.

@item Octave:colon-nonscalar-argument
If the @code{Octave:colon-nonscalar-argument} warning is enabled, a warning
is issued when one of the three arguments to the colon operator (base,
increment, limit) is not a scalar.  For example, @code{1:[3, 5]} will
cause a warning to be emitted.
By default, the @code{Octave:colon-nonscalar-argument} warning is enabled.

@item Octave:data-file-in-path
If the @code{Octave:data-file-in-path} warning is enabled, a warning is
issued when Octave does not find the target of a file operation such as
@code{load} or @code{fopen} directly, but is able to locate the file in
Octave's search @code{path} for files.  The warning could indicate that a
different file target than the programmer intended is being used.
By default, the @code{Octave:data-file-in-path} warning is enabled.

@item Octave:deprecated-function
If the @code{Octave:deprecated-function} warning is enabled, a
warning is issued when Octave encounters a function that is obsolete and
scheduled for removal from Octave.
By default, the @code{Octave:deprecated-function} warning is enabled.

@item Octave:deprecated-keyword
If the @code{Octave:deprecated-keyword} warning is enabled, a
warning is issued when Octave encounters a keyword that is obsolete and
scheduled for removal from Octave.
By default, the @code{Octave:deprecated-keyword} warning is enabled.

@item Octave:deprecated-option
If the @code{Octave:deprecated-option} warning is enabled, a
warning is issued when an obsolete option or input to a function is used.
By default, the @code{Octave:deprecated-option} warning is enabled.

@item Octave:deprecated-property
If the @code{Octave:deprecated-property} warning is enabled, a
warning is issued when Octave encounters a graphics property that
is obsolete and scheduled for removal from Octave.
By default, the @code{Octave:deprecated-property} warning is enabled.

@item Octave:eigs:UnconvergedEigenvalues
If the @code{Octave:eigs:UnconvergedEigenvalues} warning is enabled then
the eigs function will issue a warning if the number of calculated
eigenvalues is less than the number of requested eigenvalues.
By default, the @code{Octave:eigs:UnconvergedEigenvalues} warning is
enabled.

@item Octave:empty-index
If the @code{Octave:empty-index} warning is enabled then Octave will emit a
warning whenever indexing operators are used without an index, for example
@code{@var{x}()}.
By default, the @code{Octave:empty-index} warning is enabled.

@item Octave:erase:chararray
If the @code{Octave:erase:chararray} warning is enabled then the erase
function will issue a warning if the input pattern is a character array
rather than a string or cell array of strings.
By default, the @code{Octave:erase:chararray} warning is enabled.

@item Octave:function-name-clash
If the @code{Octave:function-name-clash} warning is enabled, a
warning is issued when Octave finds that the name of a function
defined in a function file differs from the name of the file.  (If
the names disagree, the name declared inside the file is ignored.)
By default, the @code{Octave:function-name-clash} warning is enabled.

@item Octave:future-time-stamp
If the @code{Octave:future-time-stamp} warning is enabled, Octave
will print a warning if it finds a function file with a time stamp
that is in the future.
By default, the @code{Octave:future-time-stamp} warning is enabled.

@item Octave:glyph-render
If the @code{Octave:glyph-render} warning is enabled, Octave will
print a warning if the glyph for a character couldn't be rendered with
the current font.
By default, the @code{Octave:glyph-render} warning is enabled.

@item Octave:imag-to-real
If the @code{Octave:imag-to-real} warning is enabled, a warning is
printed for implicit conversions of complex numbers to real numbers.
By default, the @code{Octave:imag-to-real} warning is disabled.

@item Octave:infinite-loop
If the @code{Octave:infinite-loop} warning is enabled, a warning is
printed when an infinite loop is detected such as @code{for i = 1:Inf} or
@code{while (1)}.
By default, the @code{Octave:infinite-loop} warning is enabled.

@item Octave:language-extension
Print warnings when using features that are unique to the Octave
language and that may still be missing in @sc{matlab}.
By default, the @code{Octave:language-extension} warning is disabled.
The @option{--traditional} or @option{--braindead} startup options for
Octave may also be of use, @pxref{Command Line Options}.

@item Octave:legacy-function
If the @code{Octave:legacy-function} warning is enabled, a
warning is issued when Octave encounters a function that @sc{matlab} has
suggested should be avoided.  The function may become obsolete at some
point in the future and removed, in which case the warning will change to
@code{Octave:deprecated-function}, and the function will continue to exist
for two further versions of Octave before being removed.
By default, the @code{Octave:legacy-function} warning is enabled.

@item Octave:logical-conversion
If the @code{Octave:logical-conversion} warning is enabled, a warning is
printed if an implicit conversion of an array from numerical to boolean
occurs and any of the elements in the array are not equal to zero or one.
By default, the @code{Octave:logical-conversion} warning is enabled.

@item Octave:lu:sparse_input
If the @code{Octave:lu:sparse_input} warning is enabled, Octave
will warn when the lu function is called with a sparse input and less than
four output arguments.  In this case, sparsity-preserving column
permutations are not performed and the result may be inaccurate.
By default, the @code{Octave:lu:sparse_input} warning is enabled.

@item Octave:missing-glyph
If the @code{Octave:glyph-render} warning is enabled, Octave will
print a warning if the current font doesn't provide a glyph for a
used character.
By default, the @code{Octave:missing-glyph} warning is enabled.

@item Octave:missing-semicolon
If the @code{Octave:missing-semicolon} warning is enabled, Octave
will warn when statements in function definitions don't end in
semicolons.
By default the @code{Octave:missing-semicolon} warning is disabled.

@item Octave:mixed-string-concat
If the @code{Octave:mixed-string-concat} warning is enabled, print a
warning when concatenating a mixture of double and single quoted strings.
By default, the @code{Octave:mixed-string-concat} warning is disabled.

@item  Octave:nearly-singular-matrix
@itemx Octave:singular-matrix
These warnings are emitted if a (nearly) singular matrix is inverted.
By default, the @code{Octave:nearly-singular-matrix} and
@code{Octave:singular-matrix} warnings are enabled.

@item Octave:neg-dim-as-zero
If the @code{Octave:neg-dim-as-zero} warning is enabled, print a warning
for expressions like

@example
eye (-1)
@end example

@noindent
By default, the @code{Octave:neg-dim-as-zero} warning is disabled.

@item Octave:noninteger-range-as-index
If the @code{Octave:noninteger-range-as-index} warning is enabled, a warning
is printed if an array is indexed with a range that contains non-integer
values.  For example,

@example
@group
a = [1 2 3 4 5];
b = 2.2:4.2
@result{} 1.2  2.2  3.2
a(b)
@result{} 2 3 4
@end group
@end example

@noindent
elicits a warning if the @code{Octave:noninteger-range-as-index} warning is
enabled.
By default, the @code{Octave:noninteger-range-as-index} warning is enabled.

@item Octave:num-to-str
If the @code{Octave:num-to-str} warning is enabled, a warning is
printed for implicit conversions of numbers to their UTF-8 encoded character
equivalents when strings are constructed using a mixture of strings and
numbers in matrix notation.  For example,

@example
@group
[ "f", 111, 111 ]
@result{} "foo"
@end group
@end example

@noindent
elicits a warning if the @code{Octave:num-to-str} warning is
enabled.  By default, the @code{Octave:num-to-str} warning is enabled.

@item Octave:possible-matlab-short-circuit-operator
If the @code{Octave:possible-matlab-short-circuit-operator} warning
is enabled, Octave will warn about using the not short circuiting
operators @code{&} and @code{|} inside @code{if} or @code{while}
conditions.  They normally never short circuit, but they do short
circuit when used in a condition.
By default, the @code{Octave:possible-matlab-short-circuit-operator} warning
is enabled.

@item Octave:recursive-path-search
If the @code{Octave:recursive-path-search} warning is enabled, Octave
will issue a warning if @code{addpath} is used with double trailing
slashes.
By default, the @code{Octave:recursive-path-search} warning is enabled.

@item Octave:remove-init-dir
The @code{path} function changes the search path that Octave uses
to find functions.  It is possible to set the path to a value which
excludes Octave's own built-in functions.  If the
@code{Octave:remove-init-dir} warning is enabled then Octave will warn
when the @code{path} function has been used in a way that may render
Octave unworkable.
By default, the @code{Octave:remove-init-dir} warning is enabled.

@item Octave:reload-forces-clear
If several functions have been loaded from the same file, Octave must
clear all the functions before any one of them can be reloaded.  If
the @code{Octave:reload-forces-clear} warning is enabled, Octave will
warn you when this happens, and print a list of the additional
functions that it is forced to clear.
By default, the @code{Octave:reload-forces-clear} warning is enabled.

@item Octave:separator-insert
Print warning if commas or semicolons might be inserted
automatically in literal matrices.
By default, the @code{Octave:separator-insert} warning is disabled.

@item Octave:shadowed-function
If the @code{Octave:shadowed-function} warning is enabled, Octave will
warn if a path is added to the search path that contains functions
that shadow core functions.
By default, the @code{Octave:shadowed-function} warning is enabled.

@item Octave:single-quote-string
Print warning if a single quote character is used to introduce a
string constant.
By default, the @code{Octave:single-quote-string} warning is disabled.

@item Octave:sqrtm:SingularMatrix
If the @code{Octave:sqrtm:SingularMatrix} warning is enabled, a warning is
printed if the matrix square root function @code{sqrtm} is called with an
input matrix that is singular.
By default, the @code{Octave:sqrtm:SingularMatrix} warning is enabled.

@item Octave:str-to-num
If the @code{Octave:str-to-num} warning is enabled, a warning is printed
for implicit conversions of strings to their numeric UTF-8 encoded byte
sequences.  For example,

@example
@group
"abc" + 0
@result{} 97 98 99
@end group
@end example

@noindent
elicits a warning if the @code{Octave:str-to-num} warning is enabled.
By default, the @code{Octave:str-to-num} warning is disabled.

@item Octave:LaTeX:internal-error
If the @code{Octave:LaTeX:internal-error} warning is enabled, a warning is
printed whenever the LaTeX renderer for text in plots encounters an issue.
By default, the @code{Octave:LaTeX:internal-error} warning is enabled.

@item Octave:unimplemented-matlab-functionality
If the @code{Octave:unimplemented-matlab-functionality} warning is enabled,
a warning is printed when a @sc{matlab} code construct is used which the
Octave interpreter parses as valid, but for which Octave does not yet
implement the functionality.
By default, the @code{Octave:unimplemented-matlab-functionality} warning is
enabled.

@item Octave:variable-switch-label
If the @code{Octave:variable-switch-label} warning is enabled, Octave
will print a warning if a switch label is not a constant or constant
expression.
By default, the @code{Octave:variable-switch-label} warning is disabled.
@end table



@node Enabling and Disabling Warnings
@subsection Enabling and Disabling Warnings

The @code{warning} function also allows you to control which warnings
are actually printed to the screen.  If the @code{warning} function
is called with a string argument that is either @qcode{"on"} or @qcode{"off"}
all warnings will be enabled or disabled.

It is also possible to enable and disable individual warnings through
their string identifications.  The following code will issue a warning

@example
@group
warning ("example:non-negative-variable",
         "'a' must be non-negative.  Setting 'a' to zero.");
@end group
@end example

@noindent
while the following won't issue a warning

@example
@group
warning ("off", "example:non-negative-variable");
warning ("example:non-negative-variable",
         "'a' must be non-negative.  Setting 'a' to zero.");
@end group
@end example
