Report that an internal error happened when translating a specific source.
763442
public static void fatalError(Throwable error, String path) {
    StringWriter msg = new StringWriter();
    PrintWriter writer = new PrintWriter(msg);
    writer.println(String.format("internal error translating \"%s\"", path));
    error.printStackTrace(writer);
    writer.flush();
    error(msg.toString());
  }
1373002
function internalError(response, message, body) {
  var content = errorContent(ErrorType.server, message, body);
  send(response, content, StatusCode.internalServerError);
}
246923
private void error(final Element source, final String msg) {
        this.processingEnv.getMessager().printMessage(Kind.ERROR, msg, source);
    }
1295855
protected void handleInternalException(
        Throwable internalException,
        CompilationUnitDeclaration unit,
        CompilationResult result) {

        if (result == null && unit != null) {
            result = unit.compilationResult; // current unit being processed ?
        }
        // Lookup environment may be in middle of connecting types
        if (result == null && this.lookupEnvironment.unitBeingCompleted != null) {
            result = this.lookupEnvironment.unitBeingCompleted.compilationResult;
        }
        if (result == null) {
            synchronized (this) {
                if (this.unitsToProcess != null && this.totalUnits > 0)
                    result = this.unitsToProcess[this.totalUnits - 1].compilationResult;
            }
        }
        // last unit in beginToCompile ?

        boolean needToPrint = true;
        if (result != null) {
            /* create and record a compilation problem */
            // only keep leading portion of the trace
            String[] pbArguments = new String[] {
                Messages.bind(Messages.compilation_internalError, Util.getExceptionSummary(internalException)),
            };

            result
                .record(
                    this.problemReporter
                        .createProblem(
                            result.getFileName(),
                            IProblem.Unclassified,
                            pbArguments,
                            pbArguments,
                            Error, // severity
                            0, // source start
                            0, // source end
                            0, // line number
                            0),// column number
                    unit, true);

            /* hand back the compilation result */
            if (!result.hasBeenAccepted) {
                this.requestor.acceptResult(result.tagAsAccepted());
                needToPrint = false;
            }
        }
        if (needToPrint) {
            /* dump a stack trace to the console */
            internalException.printStackTrace();
        }
    }
391458
private void postImportHook() {
        Map<String, String> enMap = get("en").asMap();
        StringBuilder sb = new StringBuilder();
        for (Translation tr : translations.values()) {
            Map<String, String> trMap = tr.asMap();
            for (Entry<String, String> enEntry : enMap.entrySet()) {
                String value = trMap.get(enEntry.getKey());
                if (isEmpty(value)) {
                    trMap.put(enEntry.getKey(), enEntry.getValue());
                    continue;
                }

                int expectedCount = countOccurence(enEntry.getValue(), "\\%");
                if (expectedCount != countOccurence(value, "\\%")) {
                    sb.append(tr.getLocale()).append(" - error in ").
                            append(enEntry.getKey()).append("->").
                            append(value).append("\n");
                } else {
                    // try if formatting works, many times e.g. '%1$' instead of '%1$s'
                    Object[] strs = new String[expectedCount];
                    Arrays.fill(strs, "tmp");
                    try {
                        String.format(Locale.ROOT, value, strs);
                    } catch (Exception ex) {
                        sb.append(tr.getLocale()).append(" - error ").append(ex.getMessage()).append("in ").
                                append(enEntry.getKey()).append("->").
                                append(value).append("\n");
                    }
                }
            }
        }

        if (sb.length() > 0) {
            System.out.println(sb);
            throw new IllegalStateException(sb.toString());
        }
    }
1281151
def handle_error(self):
        """"""
        if self.server.can_ignore_error(self):
            return
        if thread_local.status_code is None:
            msg("ERROR: Cannot send error status code! " +
                "Header already sent!\n{0}", traceback.format_exc())
        else:
            msg("ERROR: Error while processing request:\n{0}",
                traceback.format_exc())
            try:
                self.send_error(500, "Internal Error")
            except:  # nopep8
                if self.server.can_ignore_error(self):
                    return
                msg("ERROR: Cannot send error status code:\n{0}",
                    traceback.format_exc())
1356569
def _report_lint_error(error, file_path):
    """"""
    line = error[1].line
    code = error[0]
    description = error[1].description
    sys.stdout.write("{0}:{1} [{2}] {3}\n".format(file_path,
                                                  line,
                                                  code,
                                                  description))
954367
def error(bot, update, error):
    """"""
    logger.error('Update {} caused error {}'.format(update, error), extra={"tag": "err"})
922597
function ErroneousError(e, additional) {
    additional = additional || {};
    this.line = e.lineno || e.lineNumber || additional.lineno;
    this.file = e.filename || e.fileName || additional.filename;
    this.msg = e.message || additional.message;
    this.time = e.timestamp || additional.timestamp || Date.now();
    this.type = (this.parseMessage(this.msg) || e.type || e.name).toLowerCase();

    // If it's a DOM node, let's figure out which
    if (e.target) {
      this.target = this.getTargetIdentifier(e.target);

      if (e.target.nodeName) {
        this.type = 'resource';
        if (e.target.href) {
          this.file = e.target.href;
        } else if (e.target.src) {
          this.file = e.target.src;
        }
      }
    }

    // Parse the stack if any
    this.stack = e.stack;
    this.parseStack(e.stack);
  }
1188
def _set_internal_compiler_error(self):
        
        self.severity = "Low"
        self.description_tail += (
            " This issue is reported for internal compiler generated code."
        )
        self.description = "%s\n%s" % (self.description_head, self.description_tail)
        self.code = ""
369571
def __analizar_errores(self, ret):
        ""
        errores = []
        if 'errores' in ret:
            errores.extend(ret['errores'])
        if errores:
            self.Errores = ["%(codigo)s: %(descripcion)s" % err['error'][0]
                            for err in errores]
            self.errores = [
                {'codigo': err['error'][0]['codigo'],
                 'descripcion': err['error'][0]['descripcion'].replace("\n", "")
                                .replace("\r", "")} 
                             for err in errores]
            self.ErrCode = ' '.join(self.Errores)
            self.ErrMsg = '\n'.join(self.Errores)
281683
private Context translateFail(WyilFile.Stmt.Fail stmt, Context context) {
		Expr condition = new Expr.Constant(new Value.Bool(false));
		//
		VerificationCondition verificationCondition = new VerificationCondition("possible panic", context.assumptions,
				condition, stmt.getParent(WyilFile.Attribute.Span.class));
		context.emit(verificationCondition);
		//
		return null;
	}
611764
def format_error(module, error):
    """"""
    logging.error(module)
    # Beautify JSON error
    print error.message
    print json.dumps(error.error, sort_keys=True, indent=4, separators=(',', ': '))
    exit(1)
1163367
private void handleErrorCode() {
		String msg = I18nUtilities
				.format(UIContextHolder.getCurrent().getLocale(),
						InternalMessages.DEFAULT_STEP_ERROR);
		throw new ErrorCodeEscape(HttpServletResponse.SC_BAD_REQUEST, msg);
	}
376613
def __analizar_errores(self, ret):
        ""
        self.Errores = [err['codigoDescripcion'] for err in ret.get('arrayErrores', [])]
        self.ErroresFormato = [err['codigoDescripcionString'] for err in ret.get('arrayErroresFormato', [])]
        errores = self.Errores + self.ErroresFormato
        self.ErrCode = ' '.join(["%(codigo)s" % err for err in errores])
        self.ErrMsg = '\n'.join(["%(codigo)s: %(descripcion)s" % err for err in errores])
167711
def onerror(self, message, source, lineno, colno):
        """"""
        return (message, source, lineno, colno)
1193883
function getErrorSource (err) {
  let result

  try {
    const { fileName, lineNumber, columnNumber } = errorStackParser.parse(err).shift()
    result = `${fileName}:${lineNumber}:${columnNumber}`
  } catch (err) {}

  return result
}