.createError(name)
764356
function(name) {
    var cls = new Class(name,{
      inherits: Error,
      constructor: function(message) {
        this.name = name;
        this.message = message;
      },
    });
    return cls.toFunction();
  }
32061
function (error) {
        if (!this.started) {
            return;
        }

        var errorHandlers = this.errorHandlers,
            length = errorHandlers.length,
            errorHandler,
            errorHandled = false,
            errorString,
            i;

        //Exit handling
        if (error instanceof SystemExit) {
            this._exit(error.code);
            return;
        }

        try {
            for (i = 0; i < length; i += 1) {
                errorHandler = errorHandlers[i];
                errorHandled = !!errorHandler(error);

                if (errorHandled) {
                    return;
                }
            }
        } catch (e) {
            this._printError(e);
            this._exit(1);
        }

        //Default error handling
        errorString = '' + (error.stack || error);
        this._printError(errorString);
        this._exit(1);
    }
833698
function ZookeeperError(rc, error) {
  Error.call(this, error);
  Error.captureStackTrace(this, this.constructor);
  this.rc = rc;
  this.message = error;
}
1064013
function JModelError(obj) {
    this.message = obj['message'];
    this.propertyName = obj['propertyName'];

    Error.call(this);
    Error.captureStackTrace(this, this.constructor);
}
316892
def create(self, instance, errors):
        
        if errors:
            return self.errors(errors)
        return self.created(instance)
845452
function makeError(id, msg, err, requireModules) {
      var e = new Error(msg + "\nhttp://requirejs.org/docs/errors.html#" + id);
      e.requireType = id;
      e.requireModules = requireModules;
      if (err) {
        e.originalError = err;
      }
      return e;
    }
1138325
function createImportError(rule) {
	var url = rule.import ? rule.import.replace(/\r?\n/g, '\\n') : '<no url>';
	var err = ['Bad import url: @import ' + url];

	if (rule.position) {
		err.push('  starting at line ' + rule.position.start.line + ' column ' + rule.position.start.column);
		err.push('    ending at line ' + rule.position.end.line + ' column ' + rule.position.end.column);

		if (rule.position.source) {
			err.push('  in ' + rule.position.source);
		}
	}

	return err.join('\n');
 }
1086218
function createError(file, src, paths) {
	var err = ['Failed to find ' + file];

	if (src) {
		err.push('from ' + src);
	}

	err.push([
		'in [',
		'    ' + paths.join(',\n    '),
		']'
	].join('\n'));

	return err.join(' ');
}
702199
protected void setError(int newPosition, String error,
      boolean currentExisting) {
    if (!currentExisting) {
      newFullValueList[newPosition] = operations.createVector1(0);
    }
    newErrorNumber[newPosition]++;
    if (newErrorList[newPosition].containsKey(error)) {
      newErrorList[newPosition].put(error,
          newErrorList[newPosition].get(error) + 1);
    } else {
      newErrorList[newPosition].put(error, 1);
    }
  }
1141446
function APAError(message){
 	Error.call(this);
 	Error.captureStackTrace(this,arguments.callee);
 	this.name = 'APAError';
 	this.message = message;
 }
991874
function setupError(obj, name, message) {
  if (obj) {
    Error.call(obj);
    Object.defineProperty(obj, 'name', {
      value: name,
      enumerable: false
    });
    Object.defineProperty(obj, 'message', {
      value: message,
      enumerable: false
    });
  } else {
    logger.ffdc('setupError', 'ffdc001', null, 'Client object not provided');
  }
}
469292
function InjectionError(name, cause) {
    var message = name ? "Error instantiating '" + name + "' module" : "Injection failed";
    this.$$message = message;
    if (cause) {
      this.originalCause = cause.originalCause || cause;
      this.cause = cause;
    }
    for (var error = cause; error != null; error = error.cause) {
      message += "\n- Cause: " + (error.$$message || error.message || "[no message]");
    }
    EsquireError.call(this, message);
  }
49749
function (message, err) {
  if(!(this instanceof )) {
    return new (message, err);
  }
  BaseError.call(this, message, err);
}
700013
function RequestError(err, url) {
	VError.call(this, err, 'for url %s', url);
	this.name = RequestError.name;
}
434111
function createError(code, type, desc) {
	errors[code] = function (msg, meta) {
		const err = new type(msg);

		if (desc) {
			if (!meta) {
				meta = {};
			}
			meta.desc = desc;
		}

		return Object.defineProperties(err, {
			code: {
				configurable: true,
				enumerable: true,
				writable: true,
				value: `ERR_${code}`
			},
			meta: {
				configurable: true,
				value: meta || undefined,
				writable: true
			}
		});
	};

	Object.defineProperties(errors[code], {
		name: {
			configurable: true,
			value: code,
			writable: true
		},
		toString: {
			configurable: true,
			value: function toString() {
				return `ERR_${code}`;
			},
			writable: true
		}
	});
}
826620
function makeError(code, message, data = {}) {
  const error = new Error(message);
  return Object.assign(error, {code, data});
}
954316
function throwError(messageFormat) {
        var args, msg;

        args = Array.prototype.slice.call(arguments, 1);
        msg = messageFormat.replace(/%(\d)/g,
            function (whole, idx) {
                assert(idx < args.length, 'Message reference must be in range');
                return args[idx];
            }
        );

        throw createError(lastLineNumber, lastIndex, msg);
    }