Add position information to errors.
548719
function addPosition (error, message) {
        error.message = (
          message + ' at ' +
          'line ' + token.position.line + ', ' +
          'column ' + token.position.column
        )
        error.position = token.position
        return error
      }
217170
def handle_error(self, error, req, schema, error_status_code, error_headers):
        """"""
        status = status_map.get(error_status_code or self.DEFAULT_VALIDATION_STATUS)
        if status is None:
            raise LookupError("Status code {0} not supported".format(error_status_code))
        raise HTTPError(status, errors=error.messages, headers=error_headers)
786304
function formErrorText (info, msg) {
  const hr = '----------'

  return addPlatformInformation(info)
  .then((obj) => {
    const formatted = []

    function add (msg) {
      formatted.push(
        stripIndents(msg)
      )
    }

    add(`
      ${obj.description}

      ${obj.solution}

    `)

    if (msg) {
      add(`
        ${hr}

        ${msg}

      `)
    }

    add(`
      ${hr}

      ${obj.platform}
    `)

    if (obj.footer) {
      add(`

        ${hr}

        ${obj.footer}
      `)
    }

    return formatted.join('\n\n')
  })
}
1318067
def add_alignment_errors(self,ae):
    """"""
    self._target_context_errors = None
    self._query_context_errors = None
    self._alignment_errors.append(ae)
    self._general_errors.add_alignment_errors(ae)
760536
def _add_error(self, message):
        """"""
        error_line = Result(False, None, message, Directive(""))
        self._suite.addTest(Adapter(self._filename, error_line))
1288828
def _add(self, error: "Err"):
        
        if self.trace_errs is True:
            self.errors.append(error)
39287
def add_errors(self, *errors: Union[BaseSchemaError, List[BaseSchemaError]]) -> None:
        
        self.schema_loader.add_errors(*errors)
1340590
def error(self, line_number, offset, text, check):
        """"""
        code = super(StandardReport, self).error(line_number, offset,
                                                 text, check)
        if code and (self.counters[code] == 1 or self._repeat):
            self._deferred_print.append(
                (line_number, offset, code, text[5:], check.__doc__))
        return code
342156
def error(request, message, extra_tags='', fail_silently=False):
    """"""
    add_message(request, constants.ERROR, message, extra_tags=extra_tags,
                fail_silently=fail_silently)
719577
def error(self, request, message, extra_tags='', fail_silently=False):
        """"""
        add(self.target_name, request, constants.ERROR, message, extra_tags=extra_tags,
            fail_silently=fail_silently)
1273050
def error(self, msg, n):
        """"""
        raise SyntaxError(msg, n.lineno, n.col_offset,
                          filename=self.compile_info.filename)
922405
def addError(self, test, err, capt=None):
        
        self.__insert_test_result(constants.State.ERROR, test, err)
670284
def add_info(self, key, val, ignore_errors=False):
    """"""
    self.add_infos((key, val), ignore_errors=ignore_errors)
866166
def set_position(self, position):
        """"""
        if position < 0:
            position += len(self.checkdefs)
        while position >= len(self.checkdefs):
            self.checkdefs.append(([], []))
        self.position = position
167711
def onerror(self, message, source, lineno, colno):
        """"""
        return (message, source, lineno, colno)
853759
def lazy_display_error(self, filename):
        """"""
        position = self.cursor()
        error = self.get_error_at(position)
        if error:
            report = error.get_truncated_message(position, self.width() - 1)
            self.raw_message(report)
9553
def make_err(self, errtype, message, original, loc, ln=None, reformat=True, *args, **kwargs):
        """"""
        if ln is None:
            ln = self.adjust(lineno(loc, original))
        errstr, index = getline(loc, original), col(loc, original) - 1
        if reformat:
            errstr, index = self.reformat(errstr, index)
        return errtype(message, errstr, index, ln, *args, **kwargs)