91 void print_raw_cr(const char* str, int len){ write(str, len); cr(); }
92 void print_data(void* data, size_t len, bool with_ascii);
93 void put(char ch);
94 void sp(int count = 1);
95 void cr();
96 void bol() { if (_position > 0) cr(); }
97
98 // Time stamp
99 TimeStamp& time_stamp() { return _stamp; }
100 void stamp();
101 void stamp(bool guard, const char* prefix, const char* suffix);
102 void stamp(bool guard) {
103 stamp(guard, "", ": ");
104 }
105 // Date stamp
106 void date_stamp(bool guard, const char* prefix, const char* suffix);
107 // A simplified call that includes a suffix of ": "
108 void date_stamp(bool guard) {
109 date_stamp(guard, "", ": ");
110 }
111 void gclog_stamp();
112
113 // portable printing of 64 bit integers
114 void print_jlong(jlong value);
115 void print_julong(julong value);
116
117 // flushing
118 virtual void flush() {}
119 virtual void write(const char* str, size_t len) = 0;
120 virtual void rotate_log(bool force, outputStream* out = NULL) {} // GC log rotation
121 virtual ~outputStream() {} // close properly on deletion
122
123 void dec_cr() { dec(); cr(); }
124 void inc_cr() { inc(); cr(); }
125 };
126
127 // standard output
128 // ANSI C++ name collision
129 extern outputStream* tty; // tty output
130 extern outputStream* gclog_or_tty; // stream for gc log if -Xloggc:<f>, or tty
131
132 class streamIndentor : public StackObj {
133 private:
134 outputStream* _str;
135 int _amount;
136
137 public:
138 streamIndentor(outputStream* str, int amt = 2) : _str(str), _amount(amt) {
139 _str->inc(_amount);
140 }
141 ~streamIndentor() { _str->dec(_amount); }
142 };
143
144
145 // advisory locking for the shared tty stream:
146 class ttyLocker: StackObj {
147 friend class ttyUnlocker;
148 private:
149 intx _holder;
150
229 fdStream(int fd = -1) { _fd = fd; _need_close = false; }
230 ~fdStream();
231 bool is_open() const { return _fd != -1; }
232 void set_fd(int fd) { _fd = fd; _need_close = false; }
233 int fd() const { return _fd; }
234 virtual void write(const char* c, size_t len);
235 void flush() {};
236 };
237
238 class logStream : public outputStream {
239 private:
240 stringStream _current_line;
241 void (*_log_func)(const char* fmt, ...);
242 public:
243 void write(const char* s, size_t len);
244 logStream(void (*log_func)(const char* fmt, ...)) : _log_func(log_func) {}
245 ~logStream() {
246 guarantee(_current_line.size() == 0, "Buffer not flushed. Missing call to print_cr()?");
247 }
248 };
249
250 class gcLogFileStream : public fileStream {
251 protected:
252 const char* _file_name;
253 jlong _bytes_written;
254 uintx _cur_file_num; // current logfile rotation number, from 0 to NumberOfGCLogFiles-1
255 public:
256 gcLogFileStream(const char* file_name);
257 ~gcLogFileStream();
258 virtual void write(const char* c, size_t len);
259 virtual void rotate_log(bool force, outputStream* out = NULL);
260 void dump_loggc_header();
261
262 /* If "force" sets true, force log file rotation from outside JVM */
263 bool should_rotate(bool force) {
264 return force ||
265 ((GCLogFileSize != 0) && (_bytes_written >= (jlong)GCLogFileSize));
266 }
267 };
268
269 #ifndef PRODUCT
270 // unit test for checking -Xloggc:<filename> parsing result
271 void test_loggc_filename();
272 #endif
273
274 void ostream_init();
275 void ostream_init_log();
276 void ostream_exit();
277 void ostream_abort();
278
279 // staticBufferStream uses a user-supplied buffer for all formatting.
280 // Used for safe formatting during fatal error handling. Not MT safe.
281 // Do not share the stream between multiple threads.
282 class staticBufferStream : public outputStream {
283 private:
284 char* _buffer;
285 size_t _buflen;
286 outputStream* _outer_stream;
287 public:
288 staticBufferStream(char* buffer, size_t buflen,
289 outputStream *outer_stream);
290 ~staticBufferStream() {};
291 virtual void write(const char* c, size_t len);
292 void flush();
|
91 void print_raw_cr(const char* str, int len){ write(str, len); cr(); }
92 void print_data(void* data, size_t len, bool with_ascii);
93 void put(char ch);
94 void sp(int count = 1);
95 void cr();
96 void bol() { if (_position > 0) cr(); }
97
98 // Time stamp
99 TimeStamp& time_stamp() { return _stamp; }
100 void stamp();
101 void stamp(bool guard, const char* prefix, const char* suffix);
102 void stamp(bool guard) {
103 stamp(guard, "", ": ");
104 }
105 // Date stamp
106 void date_stamp(bool guard, const char* prefix, const char* suffix);
107 // A simplified call that includes a suffix of ": "
108 void date_stamp(bool guard) {
109 date_stamp(guard, "", ": ");
110 }
111
112 // portable printing of 64 bit integers
113 void print_jlong(jlong value);
114 void print_julong(julong value);
115
116 // flushing
117 virtual void flush() {}
118 virtual void write(const char* str, size_t len) = 0;
119 virtual void rotate_log(bool force, outputStream* out = NULL) {} // GC log rotation
120 virtual ~outputStream() {} // close properly on deletion
121
122 void dec_cr() { dec(); cr(); }
123 void inc_cr() { inc(); cr(); }
124 };
125
126 // standard output
127 // ANSI C++ name collision
128 extern outputStream* tty; // tty output
129
130 class streamIndentor : public StackObj {
131 private:
132 outputStream* _str;
133 int _amount;
134
135 public:
136 streamIndentor(outputStream* str, int amt = 2) : _str(str), _amount(amt) {
137 _str->inc(_amount);
138 }
139 ~streamIndentor() { _str->dec(_amount); }
140 };
141
142
143 // advisory locking for the shared tty stream:
144 class ttyLocker: StackObj {
145 friend class ttyUnlocker;
146 private:
147 intx _holder;
148
227 fdStream(int fd = -1) { _fd = fd; _need_close = false; }
228 ~fdStream();
229 bool is_open() const { return _fd != -1; }
230 void set_fd(int fd) { _fd = fd; _need_close = false; }
231 int fd() const { return _fd; }
232 virtual void write(const char* c, size_t len);
233 void flush() {};
234 };
235
236 class logStream : public outputStream {
237 private:
238 stringStream _current_line;
239 void (*_log_func)(const char* fmt, ...);
240 public:
241 void write(const char* s, size_t len);
242 logStream(void (*log_func)(const char* fmt, ...)) : _log_func(log_func) {}
243 ~logStream() {
244 guarantee(_current_line.size() == 0, "Buffer not flushed. Missing call to print_cr()?");
245 }
246 };
247
248 void ostream_init();
249 void ostream_init_log();
250 void ostream_exit();
251 void ostream_abort();
252
253 // staticBufferStream uses a user-supplied buffer for all formatting.
254 // Used for safe formatting during fatal error handling. Not MT safe.
255 // Do not share the stream between multiple threads.
256 class staticBufferStream : public outputStream {
257 private:
258 char* _buffer;
259 size_t _buflen;
260 outputStream* _outer_stream;
261 public:
262 staticBufferStream(char* buffer, size_t buflen,
263 outputStream *outer_stream);
264 ~staticBufferStream() {};
265 virtual void write(const char* c, size_t len);
266 void flush();
|