Returns the message's rcode (error code).  This incorporates the EDNS
extended rcode.
504668
public int
getRcode() {
	int rcode = header.getRcode();
	OPTRecord opt = getOPT();
	if (opt != null)
		rcode += (opt.getExtendedRcode() << 4);
	return rcode;
}
466328
function E(sym, val, def, ...otherClasses) {
  // Special case for SystemError that formats the error message differently
  // The SystemErrors only have SystemError as their base classes.
  messages.set(sym, val);
  if (def === SystemError) {
    def = makeSystemErrorWithCode(sym);
  } else {
    def = makeNodeErrorWithCode(def, sym);
  }

  if (otherClasses.length !== 0) {
    otherClasses.forEach((clazz) => {
      def[clazz.name] = makeNodeErrorWithCode(clazz, sym);
    });
  }
  codes[sym] = def;
}
70457
def bnode_id(self):
        
        if self.subject.type != 'bnode':
            return self.subject
        rtn_list = []
        for prop in sorted(self):
            for value in sorted(self[prop]):
                rtn_list.append("%s%s" % (prop, value))
        return sha1("".join(rtn_list).encode()).hexdigest()
641301
def get_error_code_msg(cls, full_error_message):
        
        for pattern in cls.ERROR_PATTERNS:
            match = pattern.match(full_error_message)
            if match:
                # assert match.group('type1') == match.group('type2')
                return int(match.group('code')), match.group('msg').strip()

        return 0, full_error_message
501258
@JsonIgnore
    public String getErrorMessage() {
        return (params.length == 0) ? exceptionCode.getMessageTemplate() :
                String.format(exceptionCode.getMessageTemplate(), params);
    }
289290
def rustcall(func, *args):
    """"""
    lib.semaphore_err_clear()
    rv = func(*args)
    err = lib.semaphore_err_get_last_code()
    if not err:
        return rv
    msg = lib.semaphore_err_get_last_message()
    cls = exceptions_by_code.get(err, SemaphoreError)
    exc = cls(decode_str(msg))
    backtrace = decode_str(lib.semaphore_err_get_backtrace())
    if backtrace:
        exc.rust_info = backtrace
    raise exc
146305
def get_error(self):
        """"""
        col_offset = -1
        if self.node is not None:
            try:
                col_offset = self.node.col_offset
            except AttributeError:
                pass
        try:
            exc_name = self.exc.__name__
        except AttributeError:
            exc_name = str(self.exc)
        if exc_name in (None, 'None'):
            exc_name = 'UnknownError'

        out = ["   %s" % self.expr]
        if col_offset > 0:
            out.append("    %s^^^" % ((col_offset)*' '))
        out.append(str(self.msg))
        return (exc_name, '\n'.join(out))
218124
def exception(self, ncode):
        
        error = self.error_dictionary[ncode]
        error_msg = self._buffer[self._index - 1].split(None, 3)[3]
        exec('raise self.%s("%s: %s")' % (error, error, error_msg))
232124
private String getErrorCode(SQLException ex) {
        String result = null;
        SQLException nestedEx = null;

        if (ex.getErrorCode() != 0) {
            result = Integer.toString(ex.getErrorCode());
        }

        if (result == null) {
            nestedEx = ex.getNextException();
            if (nestedEx != null) {
                result = Integer.toString(nestedEx.getErrorCode());
            }
        }

        return result;
    }
1339225
function decodeError(errorCode) {
    switch (errorCode) {
        case enums.ERROR_MODULE_NOT_EXIST:
            return { status: 404, error: enums.ERROR_MODULE_NOT_EXIST, message: 'This module does not exists.' };
        case enums.ERROR_MODULE_UNREACHABLE:
            return { status: 500, error: enums.ERROR_MODULE_UNREACHABLE, message: 'This module can not be reached.' };
        case enums.ERROR_MODULE_FORBIDDEN:
            return { status: 403, error: enums.ERROR_MODULE_FORBIDDEN, message: 'This module can not be accessed (forbidden).' };
    }
    return { status: 0, error: '', message: '' };
}
601247
def gotResolverError(self, failure, protocol, message, address):
        '''
        
        '''
        if failure.check(dns.DomainError, dns.AuthoritativeDomainError):
            message.rCode = dns.ENAME
        else:
            message.rCode = dns.ESERVER
            log.msg(failure.getErrorMessage())

        self.sendReply(protocol, message, address)
        if self.verbose:
            log.msg("Lookup failed")
294866
def getPropErrorNameFromEnum(self, error):
        

        fn = self.function_table.getPropErrorNameFromEnum
        result = fn(error)
        return result
1129803
private String getErrorCode(String errorShapeName) {
        ErrorTrait errorTrait = getServiceModel().getShapes().get(errorShapeName).getErrorTrait();
        if (isErrorCodeOverridden(errorTrait)) {
            return errorTrait.getErrorCode();
        } else {
            return errorShapeName;
        }
    }
1246185
def set_rcode(self, rcode):
        
        (value, evalue) = dns.rcode.to_flags(rcode)
        self.flags &= 0xFFF0
        self.flags |= value
        self.ednsflags &= 0x00FFFFFFL
        self.ednsflags |= evalue
        if self.ednsflags != 0 and self.edns < 0:
            self.edns = 0
255818
protected String getStringFromNode(Object inNode)
  {
    if (tc.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(cclass, "getStringFromNode", inNode);
    
    String strValue = null;

    if (tc.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(cclass, "getStringFromNode", strValue);    
    return strValue;
  }
1056481
public MAPErrorMessage createMessageFromErrorCode(Long errorCode) {
        long ec = (long) errorCode;
        switch ((int) ec) {
            case MAPErrorCode.unexpectedDataValue:
            case MAPErrorCode.dataMissing:
            case MAPErrorCode.unidentifiedSubscriber:
            case MAPErrorCode.illegalSubscriber:
            case MAPErrorCode.illegalEquipment:
            case MAPErrorCode.teleserviceNotProvisioned:
            case MAPErrorCode.messageWaitingListFull:
            case MAPErrorCode.unauthorizedRequestingNetwork:
            case MAPErrorCode.resourceLimitation:
            case MAPErrorCode.unknownOrUnreachableLCSClient:
            case MAPErrorCode.incompatibleTerminal:
            case MAPErrorCode.noRoamingNumberAvailable:
            case MAPErrorCode.noSubscriberReply:
            case MAPErrorCode.forwardingFailed:
            case MAPErrorCode.orNotAllowed:
            case MAPErrorCode.forwardingViolation:
            case MAPErrorCode.numberChanged:
            case MAPErrorCode.unknownMSC:
            case MAPErrorCode.unknownEquipment:
            case MAPErrorCode.bearerServiceNotProvisioned:
            case MAPErrorCode.mmEventNotSupported:
            case MAPErrorCode.illegalSSOperation:
            case MAPErrorCode.ssNotAvailable:
            case MAPErrorCode.ssSubscriptionViolation:
            case MAPErrorCode.unknownAlphabet:
            case MAPErrorCode.ussdBusy:
            case MAPErrorCode.negativePWCheck:
            case MAPErrorCode.numberOfPWAttemptsViolation:
            case MAPErrorCode.shortTermDenial:
            case MAPErrorCode.longTermDenial:
                return new MAPErrorMessageExtensionContainerImpl(errorCode);

            case MAPErrorCode.smDeliveryFailure:
                return new MAPErrorMessageSMDeliveryFailureImpl();

            case MAPErrorCode.absentSubscriberSM:
                return new MAPErrorMessageAbsentSubscriberSMImpl();

            case MAPErrorCode.systemFailure:
                return new MAPErrorMessageSystemFailureImpl();

            case MAPErrorCode.callBarred:
                return new MAPErrorMessageCallBarredImpl();

            case MAPErrorCode.facilityNotSupported:
                return new MAPErrorMessageFacilityNotSupImpl();

            case MAPErrorCode.unknownSubscriber:
                return new MAPErrorMessageUnknownSubscriberImpl();

            case MAPErrorCode.subscriberBusyForMTSMS:
                return new MAPErrorMessageSubscriberBusyForMtSmsImpl();

            case MAPErrorCode.absentSubscriber:
                return new MAPErrorMessageAbsentSubscriberImpl();

            case MAPErrorCode.unauthorizedLCSClient:
                return new MAPErrorMessageUnauthorizedLCSClientImpl();

            case MAPErrorCode.positionMethodFailure:
                return new MAPErrorMessagePositionMethodFailureImpl();

            case MAPErrorCode.busySubscriber:
                return new MAPErrorMessageBusySubscriberImpl();

            case MAPErrorCode.cugReject:
                return new MAPErrorMessageCUGRejectImpl();

            case MAPErrorCode.roamingNotAllowed:
                return new MAPErrorMessageRoamingNotAllowedImpl();

            case MAPErrorCode.ssErrorStatus:
                return new MAPErrorMessageSsErrorStatusImpl();

            case MAPErrorCode.ssIncompatibility:
                return new MAPErrorMessageSsIncompatibilityImpl();

            case MAPErrorCode.pwRegistrationFailure:
                return new MAPErrorMessagePwRegistrationFailureImpl();

            default:
                return new MAPErrorMessageParameterlessImpl(errorCode);
        }

    }
59684
@Override
    public String getMessage() {
        // In case the immediate child has the same msgCode, it must be
        // duplicated
        if (childException != null) {
            if (msgKey.equals(childException.getMsgKey())) {
                return childException.getMessage();
            }
        }
        if (message == null && msgKey != null) {
            message = Tr.formatMessage(tc, msgKey, objs);
        }
        if (message != null) {
            return message;
        } else {
            return this.getClass().getName();
        }
    }