Generic warning error routine
969964
def warning(lineno, msg):
    
    msg = "%s:%i: warning: %s" % (global_.FILENAME, lineno, msg)
    msg_output(msg)
    global_.has_warnings += 1
1073302
def _default_warning_handler(library_msg, _):
    """"""
    library_msg = library_msg.decode('utf-8').rstrip()
    msg = "OpenJPEG library warning:  {0}".format(library_msg)
    warnings.warn(msg, UserWarning)
676364
function error() {
    var _console3;

    if (LatticeLogs.failFast(LatticeLogs.ERROR)) return;

    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
      args[_key5] = arguments[_key5];
    }

    (_console3 = console).error.apply(_console3, (0, _toConsumableArray2.default)(args.map(LatticeLogs.argMapper)));
  }
1284203
function printWarning(context, kind, err)
{
	if (context !== null) {
		console.error('warn: %s: %s', context.label(), err.message);
	} else {
		console.error('warn: %s', err.message);
	}
}
912908
function WError(options)
{
	Error.call(this);

	var args, cause, ctor;
	if (typeof (options) === 'object') {
		args = Array.prototype.slice.call(arguments, 1);
	} else {
		args = Array.prototype.slice.call(arguments, 0);
		options = undefined;
	}

	if (args.length > 0) {
		this.message = mod_extsprintf.sprintf.apply(null, args);
	} else {
		this.message = '';
	}

	if (options) {
		if (options instanceof Error) {
			cause = options;
		} else {
			cause = options.cause;
			ctor = options.constructorOpt;
		}
	}

	Error.captureStackTrace(this, ctor || this.constructor);
	if (cause)
		this.cause(cause);

}
795899
function writeError () {
  if (mocking) {
    cli.stderr += stripAnsi(concatArguments(arguments))
  } else {
    process.stderr.write.apply(process.stderr, arguments)
  }
}
835124
def warning(self_, msg,*args,**kw):
        
        if not warnings_as_exceptions:
            global warning_count
            warning_count+=1
            self_.__db_print(WARNING,msg,*args,**kw)
        else:
            raise Exception("Warning: " + msg % args)
797750
def error(*args):
    """"""
    if sys.stdin.isatty():
        print('ERROR:', *args, file=sys.stderr)
    else:
        notify_error(*args)
179587
public void warning(Throwable error, Map<String, Object> custom, String description) {
    log(error, custom, description, Level.WARNING);
  }
6196
def warn( callingClass, astr_key, **kwargs ):
    '''
    
    '''
    kwargs['exitToOS']  = False
    report( callingClass, astr_key, **kwargs )
16106
def on_error(e):  # pragma: no cover
    
    exname = {'RuntimeError': 'Runtime error', 'Value Error': 'Value error'}
    sys.stderr.write('{}: {}\n'.format(exname[e.__class__.__name__], str(e)))
    sys.stderr.write('See file slam_error.log for additional details.\n')
    sys.exit(1)
1066611
function AbstractCliError(message, statusCode) {
	Error.call(this, message, statusCode);
	Error.captureStackTrace(this, AbstractCliError);

	this.message = message || this.message
}
1263787
function TypeError (msg, spec, value) {
  const e = Error(msg)
  return Object.assign(e, { spec, value })
}
364972
def _warning_handler(self, code: int):
        
        if code == 300:
            warnings.warn(
                "ExpireWarning",
                RuntimeWarning,
                stacklevel=3
            )
        elif code == 301:
            warnings.warn(
                "ExpireStreamWarning",
                RuntimeWarning,
                stacklevel=3
            )
        else:
            if self.debug:
                print("unknow code {}".format(code))
            return False
        return True
645606
function error () {
  if (mocking) {
    cli.stderr += stripAnsi(concatArguments(arguments) + '\n')
  } else {
    console.error.apply(null, arguments)
  }
}
988165
function warn() {
	var msg = util.format.apply(null, Array.prototype.slice.call(arguments, 0));
	write(msg, clc.yellow);
}
640356
def error_handler(_, err, arg):
    """"""
    arg.value = err.error
    return libnl.handlers.NL_STOP