Displays warning message. Uses exshared for current location of parsing
769631
def warning(self, message, print_location=True):
        """"""
        msg = "Warning"
        if print_location and (exshared.location != None):
            wline = lineno(exshared.location, exshared.text)
            wcol = col(exshared.location, exshared.text)
            wtext = line(exshared.location, exshared.text)
            msg += " at line %d, col %d" % (wline, wcol)
        msg += ": %s" % message
        if print_location and (exshared.location != None):
            msg += "\n%s" % wtext
        print(msg)
1173494
def write_warning (self, url_data):
        """"""
        self.write(self.part("warning") + self.spaces("warning"))
        warning_msgs = [u"[%s] %s" % x for x in url_data.warnings]
        self.writeln(self.wrap(warning_msgs, 65), color=self.colorwarning)
866406
def flake(self, message):
        
        err_range = {
            'start': {'line': message.lineno - 1, 'character': message.col},
            'end': {'line': message.lineno - 1, 'character': len(self.lines[message.lineno - 1])},
        }

        severity = lsp.DiagnosticSeverity.Warning
        for message_type in PYFLAKES_ERROR_MESSAGES:
            if isinstance(message, message_type):
                severity = lsp.DiagnosticSeverity.Error
                break

        self.diagnostics.append({
            'source': 'pyflakes',
            'range': err_range,
            'message': message.message % message.message_args,
            'severity': severity
        })
799573
def exc_message(exc_info):
    """"""
    exc = exc_info[1]
    if exc is None:
        # str exception
        result = exc_info[0]
    else:
        try:
            result = str(exc)
        except UnicodeEncodeError:
            try:
                result = unicode(exc)  # flake8: noqa
            except UnicodeError:
                # Fallback to args as neither str nor
                # unicode(Exception(u'\xe6')) work in Python < 2.6
                result = exc.args[0]
    return result
819037
@Override
    public void warn( F0<String> msg )
    {
        if ( compilerLogger.isWarnEnabled() )
        {
            compilerLogger.warn( msg.apply() );
        }
    }
774259
def _emit_warning(cls, message):
        """"""
        sys.stderr.write('WARNING: {message}\n'.format(message=message))
        sys.stderr.flush()
68980
void apMessage(AnnotationProcessingError ex) {
        log.printLines(PrefixKind.JAVAC, "msg.proc.annotation.uncaught.exception");
        ex.getCause().printStackTrace(log.getWriter(WriterKind.NOTICE));
    }
928771
def warn(self, text):
		
		self.logger.warn("{}{}".format(self.message_prefix, text))
1079741
def print_warning(msg):
    
    if IS_POSIX:
        print(u"%s[WARN] %s%s" % (ANSI_WARNING, msg, ANSI_END))
    else:
        print(u"[WARN] %s" % (msg))
1210956
def warn(message, category=PsyPlotWarning, logger=None):
    """"""
    if logger is not None:
        message = "[Warning by %s]\n%s" % (logger.name, message)
    warnings.warn(message, category, stacklevel=3)
309731
def formatWarnings(self, warnings):
        
        lines = []
        for modulename in sorted(warnings):
            lines.append(self.prefixModuleName + modulename)
            lines.extend(sorted(warnings[modulename],
                         key=lambda x: x.split(":")[1]))

        return "\n".join(lines)
791434
def show_warnings(self):
        """"""
        if self._server_version < (4,1): return ()
        self.query("SHOW WARNINGS")
        r = self.store_result()
        warnings = r.fetch_row(0)
        return warnings
783422
public void printWarning(SourcePosition pos, String msg) {
        if (silent)
            return;
        messager.printWarning(pos, msg);
    }
1290198
def warn(message = nil, &block)
      logger.add(Logger::WARN, message, self.logging_prefix, &block)
    end
345682
def warn(message = nil, ex = nil, data = nil, &block)
      log(WARN, message, ex, data, block)
    end
1327474
def log_warning(self, msg):
        
        if self.__logger:
            self.__logger.warning(msg)

        if self.__raise_exception_on_warning:
            raise RuntimeError(msg)
1372143
def warning(message, code='WARNING'):
    

    now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    output = now + ' [' + torn.plugins.colors.WARNING + \
            code + torn.plugins.colors.ENDC + '] \t' + \
            message
    print(output)