/* error.h

 *

#ifndef CTAO_CRYPT_ERROR_H

#define CTAO_CRYPT_ERROR_H

/* error codes */

enum {

    MAX_ERROR_SZ       =  80,   /* max size of error string */

    MAX_CODE_E         = -100,  /* errors -101 - -199 */

    OPEN_RAN_E         = -101,  /* opening random device error */

    READ_RAN_E         = -102,  /* reading random device error */

    WINCRYPT_E         = -103,  /* windows crypt init error */

    CRYPTGEN_E         = -104,  /* windows crypt generation error */

/* error.c

 *

#include <cyassl/ctaocrypt/error.h>

void CTaoCryptErrorString(int error, char* buffer)

{

    const int max = MAX_ERROR_SZ;   /* shorthand */

#ifdef NO_ERROR_STRINGS

    (void)error;

    XSTRNCPY(buffer, "no support for error strings built in", max);

    switch (error) {

/* error.h

 *

#ifndef CYASSL_ERROR_H

#define CYASSL_ERROR_H

#include <cyassl/ctaocrypt/error.h>   /* pull in CTaoCrypt errors */

enum CyaSSL_ErrorCodes {

    INPUT_CASE_ERROR       = -201,            /* process input state error */

    PREFIX_ERROR           = -202,            /* bad index to key rounds  */

    MEMORY_ERROR           = -203,            /* out of memory            */

    VERIFY_FINISHED_ERROR  = -204,            /* verify problem on finished */

    VERIFY_MAC_ERROR       = -205,            /* verify mac problem       */

    PARSE_ERROR            = -206,            /* parse error on header    */

//

// error.cs: Error handling code for bmac/btouch

// Error allocation

// BI1xxx	code generation

//	BI10xx	errors

	public BindingException (int code, bool error, string message, params object[] args) : 

		this (code, error, null, message, args)

	{

	public BindingException (int code, bool error, Exception innerException, string message, params object[] args) : 

		Code = code;

		Error = error;

	public bool Error { get; private set; }

/*

 *  Error message information

#if defined(POLARSSL_ERROR_C)

void error_strerror( int ret, char *buf, size_t buflen )

        // High level error codes

            snprintf( buf, buflen, "MD - Failed to allocate memory" );

        if( use_ret == -(POLARSSL_ERR_MD_FILE_IO_ERROR) )

        if( use_ret == -(POLARSSL_ERR_SSL_HW_ACCEL_FAILED) )

            snprintf( buf, buflen, "SSL - Hardware acceleration function returned with error" );

#if defined(POLARSSL_BIGNUM_C)

    if( use_ret == -(POLARSSL_ERR_MPI_FILE_IO_ERROR) )

        snprintf( buf, buflen, "BIGNUM - An error occurred while reading from or writing to a file" );

    if( use_ret == -(POLARSSL_ERR_MPI_BAD_INPUT_DATA) )

/**

 * Error.java

public class Error implements java.io.Serializable {

    public Error() {

    public Error(

    /**

     * Gets the fields value for this Error.

    /**

     * Sets the fields value for this Error.

    private static org.apache.axis.description.TypeDesc typeDesc =

            new org.apache.axis.description.TypeDesc(Error.class, true);

    static {

        typeDesc.setXmlType(new javax.xml.namespace.QName("urn:partner.soap.sforce.com", "Error"));

% Error Handling

Like most programming languages, Rust encourages the programmer to handle

errors in a particular way. Generally speaking, error handling is divided into

In this chapter, we intend to provide a comprehensive treatment of how to deal

with errors in Rust. More than that, we will attempt to introduce error handling

When done naïvely, error handling in Rust can be verbose and annoying. This

chapter will explore those stumbling blocks and demonstrate how to use the

standard library to make error handling concise and ergonomic.

This chapter is very long, mostly because we start at the very beginning with

sum types and combinators, and try to motivate the way Rust does error handling

    * [A brief interlude: unwrapping isn't evil](#a-brief-interlude-unwrapping-isnt-evil)

* [Working with multiple error types](#working-with-multiple-error-types)

    * [The `try!` macro](#the-try-macro)

    * [Defining your own error type](#defining-your-own-error-type)

* [Standard library traits used for error handling](#standard-library-traits-used-for-error-handling)

  error.c -

{

#define defined_error(name, num) if (err == num) return name;

#define undefined_error(name) 

#include "known_errors.inc"

#undef defined_error

#undef undefined_error

    return NULL;

    buf[len++] = '\n';

    rb_write_error2(buf, len);

        if (errno_str)

            rb_bug("%s: %s (%s)", mesg, strerror(errno_arg), errno_str);

        else

            rb_bug("%s: %s (%d)", mesg, strerror(errno_arg), errno_arg);

  error.c -

{

#define defined_error(name, num) if (err == num) return name;

#define undefined_error(name) 

#include "known_errors.inc"

#undef defined_error

#undef undefined_error

    return NULL;

    buf[len++] = '\n';

    rb_write_error2(buf, len);

        if (errno_str)

            rb_bug("%s: %s (%s)", mesg, strerror(errno_arg), errno_str);

        else

            rb_bug("%s: %s (%d)", mesg, strerror(errno_arg), errno_arg);

  error.c -

#define defined_error(name, num) if (err == num) return name;

#define undefined_error(name)

#include "known_errors.inc"

#undef defined_error

#undef undefined_error

    buf[len++] = '\n';

    rb_write_error2(buf, len);

    if (errno_arg == 0)

        rb_bug("%s: errno == 0 (NOERROR)", mesg);

        if (errno_str)

            rb_bug("%s: %s (%s)", mesg, strerror(errno_arg), errno_str);

        else

            rb_bug("%s: %s (%d)", mesg, strerror(errno_arg), errno_arg);

  error.c -

#define defined_error(name, num) if (err == num) return name;

#define undefined_error(name)

#include "known_errors.inc"

    buf[len++] = '\n';

    rb_write_error2(buf, len);

    if (errno_arg == 0)

        rb_bug("%s: errno == 0 (NOERROR)", mesg);

        if (errno_str)

            rb_bug("%s: %s (%s)", mesg, strerror(errno_arg), errno_str);

        else

            rb_bug("%s: %s (%d)", mesg, strerror(errno_arg), errno_arg);

	etype = rb_obj_classname(obj);

	rb_raise(rb_eTypeError, mesg, etype, data_type->wrap_struct_name);

//

// Error.cs

	/// <summary>

	/// Enum that describes the type of an error.

	/// </summary>

	public enum ErrorType

		Unknown,

		Error,

	/// <summary>

	/// Descibes an error during parsing.

	[Serializable]

	public class Error

	{

		readonly ErrorType errorType;

		/// <summary>

		/// The type of the error.

		/// </summary>

/*

 *  Error message information

void error_strerror( int ret, char *buf, size_t buflen )

        // High level error codes

        if( strlen( buf ) == 0 )

            snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );

    // If high level code is present, make a concatenation between both

    // error strings.

    // Low level error codes

    snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );

#endif /* POLARSSL_ERROR_C */

/* error.h

 * Copyright (C) 2004 Mathieu Guindon, Julien Keable

#ifndef ERROR_INCLUDED

#define ERROR_INCLUDED

//! Only catch errors.

#define DEBUG_LEVEL_ERROR   0

//! Catch both errors and warnings.

//! Catch errors, warnings and notices.

#ifndef DEBUG_LEVEL

#define DEBUG_LEVEL DEBUG_LEVEL_ERROR

//

// Error.scala -- Scala object Error

//

// $Id: Error.scala 2933 2011-12-15 16:26:02Z jthywissen $

import orc.values.sites.TypedSite

import orc.error.runtime.ArgumentTypeMismatchException

import orc.error.runtime.ProgramSignalledError

import orc.types.Bot

/** The Error site throws an Orc runtime exception with a program supplied message.

  */

object Error extends TotalSite with TotalSite1 with TypedSite {

    x match {

      case s: String => throw new ProgramSignalledError(s)

% Error Handling

Sometimes, things just go wrong. It's important to have a plan for when the

inevitable happens. Rust has rich support for handling errors that may (let's

There are two main kinds of errors that can occur in your programs: failures,

Rust uses two terms to differentiate between two forms of error: failure, and

panic. A *failure* is an error that can be recovered from in some way. A

*panic* is an error that cannot be recovered from.

What do we mean by "recover"? Well, in most cases, the possibility of an error

This won't work. So we know that this function will only work properly for some

inputs. It's expected behavior. We call this kind of error a *failure*.

#[derive(Debug)]

enum ParseError { InvalidHeaderLength, InvalidVersion }

% Error Handling

Sometimes, things just go wrong. It's important to have a plan for when the

inevitable happens. Rust has rich support for handling errors that may (let's

There are two main kinds of errors that can occur in your programs: failures,

Rust uses two terms to differentiate between two forms of error: failure, and

panic. A *failure* is an error that can be recovered from in some way. A

*panic* is an error that cannot be recovered from.

What do we mean by "recover"? Well, in most cases, the possibility of an error

This won't work. So we know that this function will only work properly for some

inputs. It's expected behavior. We call this kind of error a *failure*.

#[derive(Debug)]

enum ParseError { InvalidHeaderLength, InvalidVersion }

/* Error handler for noninteractive utilities

   Copyright (C) 1990,91,92,93,94,95,96,97,98 Free Software Foundation, Inc.

#include "error.h"

/* If NULL, error will flush stdout, then print on stderr the program

   name, a colon and a space.  Otherwise, error will call this

   function without parameters instead.  */

void (*error_print_progname) (

/* This variable is incremented each time `error' is called.  */

unsigned int error_message_count;

/* In GNU libc we want do not want to use the common name `error' directly.

   Instead make it a weak alias.  */

/* Error handler for noninteractive utilities

   Copyright (C) 1990,91,92,93,94,95,96,97,98 Free Software Foundation, Inc.

#include "error.h"

/* If NULL, error will flush stdout, then print on stderr the program

   name, a colon and a space.  Otherwise, error will call this

   function without parameters instead.  */

void (*error_print_progname) (

/* This variable is incremented each time `error' is called.  */

unsigned int error_message_count;

/* In GNU libc we want do not want to use the common name `error' directly.

   Instead make it a weak alias.  */

/*

 *  Error message information

#if defined(POLARSSL_ERROR_C)

#include "polarssl/error.h"

void error_strerror( int ret, char *buf, size_t buflen )

        // High level error codes

            snprintf( buf, buflen, "X509 - Allocation of memory failed" );

        if( use_ret == -(POLARSSL_ERR_X509_FILE_IO_ERROR) )

        if( strlen( buf ) == 0 )

            snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );

    // If high level code is present, make a concatenation between both

    // error strings.