Source code: com/port80/util/sprint.java
1 /*
2 ckleung 01/25/2001
3
4 Class to provide sprintf functions.
5
6 */
7
8 //
9 // Copyright(c) 2002, Chris Leung
10 //
11
12 package com.port80.util;
13
14 import java.util.ArrayList;
15 import java.util.Date;
16 import java.util.List;
17
18 /** Formatted print like one in C.
19 *
20 * . Addition date formats:
21 *
22 Now(T0)=|185743|
23 Now(TT)=|18:57:43|
24 Now(TH)=|18:57|
25 Now(TM)=|57:43|
26 Now(YY)=|2002|
27 Now(MM)=|3|
28 Now(WW)=|Fri|
29 Now(D0)=|20020308|
30 Now(DD)=|2002-03-08|
31 Now(DM)=|3-8|
32 Now(Dm)=|3-8|
33 Now(Ds)=|3|
34 Now(DH)=|18:57 3-8|
35 Now(Dh)=|3-8 18:57|
36 Now(DY)=|2002-3|
37 Now(Dy)=|2002-3|
38 Now(DT)=|2002-03-08 18:57:43|
39 Now(U0)=|03082002|
40 Now(UD)=|03/08/2002|
41 Now(UM)=|3/8|
42 Now(Um)=|3/8|
43 Now(Us)=|3|
44 Now(UH)=|18:57 3/8|
45 Now(Uh)=|3/8 18:57|
46 Now(UY)=|3/2002|
47 Now(Uy)=|3/2002|
48 Now(UT)=|03/08/2002 18:57:43|
49 Now(D0 T0)=|20020308 185743|
50 *
51 */
52
53 public class sprint {
54
55 // Static fields ///////////////////////////////////////////////////////
56 //
57
58 static private String hexTable = "0123456789abcdef";
59
60 static public final String INTFORMATS = "d|x|X";
61 static public final String FLOATFORMATS = "f";
62 static public final String DOUBLEFORMATS = "g";
63 static public final String STRINGFORMATS = "s";
64 static public final String DATEFORMATS =
65 "T0|TT|TH|TM|YY|MM|WW|D0|DD|DM|Dm|Ds|DH|Dh|DY|Dy|DT|U0|UD|UM|Um|Us|UH|Uh|UY|Uy|UT";
66
67 static public final String RE_DEC = "/%([\\-])*([0-9]+)*l?d/";
68 static public final String RE_HEX = "/%([\\-])*([0-9]+)*([xX])/";
69 static public final String RE_FLOAT = "/%([\\-]+)*([0-9]+)*(\\.)*([0-9]+)*[fg]/";
70 static public final String RE_STRING = "/%([\\-])*([0-9]+)*s/";
71 static public final String RE_DATE = "/%([\\-])*([0-9]+)*(" + DATEFORMATS + ")/";
72
73 public static boolean DEBUG = false;
74
75 // Instance fields /////////////////////////////////////////////////////
76 //
77
78 static class Format {
79 char type = '?';
80 String prefix = null;
81 String[] groups = null;
82 //
83 Format(String prefix) {
84 this.prefix = (prefix == null) ? "" : prefix;
85 }
86 public String toString() {
87 return type + ": " + prefix + ": " + groups;
88 }
89 }
90
91 private String formatString = null;
92 private List formats = new ArrayList();
93 private int argn = 0;
94 private StringBuffer ret = new StringBuffer("");
95
96 // Static methods //////////////////////////////////////////////////////
97 //
98
99 public static synchronized sprint f(String fmt) {
100 return new sprint().init(fmt);
101 }
102
103 /**
104 * @return Dump the array in a block format with given indent.
105 */
106 public static synchronized String array(String indent, String format, int[] a) {
107 StringBuffer buf = new StringBuffer("\n");
108 int offset=0;
109 for (int i = 0; i < a.length; ++i) {
110 offset = i % 8;
111 if (offset == 0)
112 buf.append(indent);
113 buf.append(sprint.f(format).a(a[i]).end());
114 if (offset== 7)
115 buf.append("\n");
116 }
117 if (offset != 0)
118 buf.append("\n");
119 return buf.toString();
120 }
121
122 ////////////////////////////////////////////////////////////////////////
123
124 private sprint() {}
125
126 private sprint init(String format) {
127 // FIXME: Doing the perl quick and dirty way here.
128 // NOTE:
129 // . Perl5Util.split put the separator (that match the pattern) into the result array too !
130 // . If patthen match at the start and end, there is a null string at the start and end of the
131 // result array correspondingly.
132 formatString = format;
133 List a =
134 msg.split(
135 "/(%[\\-]*[0-9\\.]*l?(?:"
136 + INTFORMATS
137 + "|"
138 + FLOATFORMATS
139 + "|"
140 + DOUBLEFORMATS
141 + "|"
142 + STRINGFORMATS
143 + "|"
144 + DATEFORMATS
145 + "))/",
146 format);
147 for (int i = 0, max = a.size(); i < max;) {
148 Format f = new Format((String) a.get(i++));
149 if (i < max) {
150 String fmt = (String) a.get(i++);
151 if ((f.groups = msg.groups(RE_DEC, fmt)) != null) {
152 f.type = 'd';
153 } else if ((f.groups = msg.groups(RE_HEX, fmt)) != null) {
154 f.type = 'x';
155 } else if ((f.groups = msg.groups(RE_STRING, fmt)) != null) {
156 f.type = 's';
157 } else if ((f.groups = msg.groups(RE_FLOAT, fmt)) != null) {
158 f.type = 'f';
159 } else if ((f.groups = msg.groups(RE_DATE, fmt)) != null) {
160 f.type = 't';
161 } else
162 msg.warn("sprint.f(): invalid format: " + fmt);
163 }
164 formats.add(f);
165 }
166 if (DEBUG)
167 for (int i = 0; i < formats.size(); i++) {
168 msg.println("DEBUG: sprint.f(): field[" + i + "]= " + (String) formats.get(i));
169 }
170 return this;
171 }
172
173 // Instance methods ////////////////////////////////////////////////////
174 //
175
176 public sprint a(int value) {
177 final String FUNC = "sprint.a(int)";
178 if (argn >= formats.size()) {
179 msg.println(
180 FUNC
181 + ": more argument than format spec."
182 + ": argn="
183 + argn
184 + ": formatString="
185 + formatString);
186 return null;
187 }
188 Format f = (Format) formats.get(argn);
189 ret.append(f.prefix);
190 switch (f.type) {
191 case 'd' :
192 printDec(f, (long) value);
193 break;
194 case 'x' :
195 printHex(f, (long) value);
196 break;
197 case 'f' :
198 printDouble(f, (double) value);
199 break;
200 case 's' :
201 printString(f, "" + value);
202 break;
203 default :
204 msg.err(
205 FUNC
206 + ": Invalid value for format"
207 + ": type="
208 + f.type
209 + ": argn="
210 + argn
211 + ": formatString="
212 + formatString
213 + ": value="
214 + value);
215 return null;
216 }
217 argn++;
218 return this;
219 }
220
221 public sprint a(long value) {
222 final String FUNC = "sprint.a(long)";
223 if (argn >= formats.size()) {
224 msg.println(
225 FUNC
226 + ": more argument than format spec."
227 + ": argn="
228 + argn
229 + ": formatString="
230 + formatString);
231 return null;
232 }
233 Format f = (Format) formats.get(argn);
234 ret.append(f.prefix);
235 switch (f.type) {
236 case 'd' :
237 printDec(f, value);
238 break;
239 case 'x' :
240 printHex(f, value);
241 break;
242 case 'f' :
243 printDouble(f, (double) value);
244 break;
245 case 's' :
246 printString(f, "" + value);
247 break;
248 case 't' :
249 printDate(f, value);
250 break;
251 default :
252 msg.err(
253 FUNC
254 + ": Invalid value for format"
255 + ": type="
256 + f.type
257 + ": argn="
258 + argn
259 + ": formatString="
260 + formatString
261 + ": value="
262 + value);
263 return null;
264 }
265 argn++;
266 return this;
267 }
268
269 public sprint a(float value) {
270 final String FUNC = "sprint.a(float)";
271 if (argn >= formats.size()) {
272 msg.println(
273 FUNC
274 + ": more argument than format spec."
275 + ": argn="
276 + argn
277 + ": formatString="
278 + formatString);
279 return null;
280 }
281 Format f = (Format) formats.get(argn);
282 ret.append(f.prefix);
283 switch (f.type) {
284 case 'd' :
285 printDec(f, (long) value);
286 break;
287 case 'x' :
288 printHex(f, (long) value);
289 break;
290 case 'f' :
291 printDouble(f, (double) value);
292 break;
293 case 's' :
294 printString(f, "" + value);
295 break;
296 default :
297 msg.err(
298 FUNC
299 + ": Invalid value for format"
300 + ": type="
301 + f.type
302 + ": argn="
303 + argn
304 + ": formatString="
305 + formatString
306 + ": value="
307 + value);
308 return null;
309 }
310 argn++;
311 return this;
312 }
313
314 public sprint a(double value) {
315 final String FUNC = "sprint.a(double)";
316 if (argn >= formats.size()) {
317 msg.println(
318 FUNC
319 + ": more argument than format spec."
320 + ": argn="
321 + argn
322 + ": formatString="
323 + formatString);
324
325 return null;
326 }
327 Format f = (Format) formats.get(argn);
328 ret.append(f.prefix);
329 switch (f.type) {
330 case 'd' :
331 printDec(f, (long) value);
332 break;
333 case 'x' :
334 printHex(f, (long) value);
335 break;
336 case 'f' :
337 printDouble(f, value);
338 break;
339 case 's' :
340 printString(f, "" + value);
341 break;
342 default :
343 msg.err(
344 FUNC
345 + ": Invalid value for format"
346 + ": type="
347 + f.type
348 + ": argn="
349 + argn
350 + ": formatString="
351 + formatString
352 + ": value="
353 + value);
354 return null;
355 }
356 argn++;
357 return this;
358 }
359
360 public sprint a(String value) {
361 final String FUNC = "sprint.a(String)";
362 if (argn >= formats.size()) {
363 msg.println(
364 FUNC
365 + ": more argument than format spec."
366 + ": argn="
367 + argn
368 + ": formatString="
369 + formatString);
370 return null;
371 }
372 Format f = (Format) formats.get(argn);
373 ret.append(f.prefix);
374 switch (f.type) {
375 case 's' :
376 printString(f, value);
377 break;
378 default :
379 msg.err(
380 FUNC
381 + ": Invalid value for format"
382 + ": type="
383 + f.type
384 + ": argn="
385 + argn
386 + ": formatString="
387 + formatString
388 + ": value="
389 + value);
390 return null;
391 }
392 argn++;
393 return this;
394 }
395
396 /** Print a date as formatted date/time string.
397 %D=yyyy-mm-dd
398 %U=mm/dd/yyyy
399 %T=hh:mm:ss
400 */
401 public sprint a(Date value) {
402 final String FUNC = "sprint.a(Date)";
403 if (argn >= formats.size()) {
404 msg.println(
405 FUNC
406 + ": more argument than format spec."
407 + ": argn="
408 + argn
409 + ": formatString="
410 + formatString);
411 return null;
412 }
413 Format f = (Format) formats.get(argn);
414 ret.append(f.prefix);
415 switch (f.type) {
416 case 't' :
417 printDate(f, value);
418 break;
419 default :
420 msg.err(
421 FUNC
422 + ": Invalid value for format"
423 + ": type="
424 + f.type
425 + ": argn="
426 + argn
427 + ": formatString="
428 + formatString
429 + ": value="
430 + value);
431 return null;
432 }
433 argn++;
434 return this;
435 }
436
437 public String end() {
438 while (argn < formats.size()) {
439 Format f = (Format) formats.get(argn++);
440 ret.append(f.prefix);
441 }
442 return ret.toString();
443 }
444
445 // Helper methods //////////////////////////////////////////////////////
446 //
447
448 /** Print value in decimal format: /%([\\-])*([0-9]+)*[l]d/
449 */
450 private void printDec(Format f, long value) {
451 boolean left = f.groups[0] != null; // Left justify.
452 boolean zero = false; // Zero padded.
453 int width = 0;
454 String wstr = f.groups[1];
455 if (wstr != null) {
456 if (wstr.charAt(0) == '0')
457 zero = true;
458 try {
459 width = Integer.parseInt(wstr);
460 } catch (Exception e) {
461 msg.err("sprint.printDec(): " + f, e);
462 }
463 }
464 StringBuffer s = new StringBuffer("" + value);
465 // Pad 0/space.
466 padding(s, width, left, zero);
467 ret.append(s);
468 }
469
470 /** Print value in hex format: /%([\\-])*([0-9]+)*([xX])/
471 */
472 private void printHex(Format f, long value) {
473 boolean left = f.groups[0] != null;
474 boolean zero = false;
475 int width = 0;
476 String wstr = f.groups[1];
477 if (wstr != null) {
478 if (wstr.charAt(0) == '0')
479 zero = true;
480 try {
481 width = Integer.parseInt(wstr);
482 } catch (Exception e) {
483 msg.err("sprint.printHex(): " + f, e);
484 }
485 }
486 boolean upper = f.groups[2].charAt(0) == 'X';
487 StringBuffer s = new StringBuffer(toHexString(value, upper, width));
488 padding(s, width, left, zero);
489 ret.append(s);
490 }
491
492 /** Print value in floating point format: /%([\\-]+)*([0-9]+)*(\\.)*([0-9]+)*[fg]/
493 */
494 private void printDouble(Format f, double value) {
495 boolean left = f.groups[0] != null;
496 boolean zero = false;
497 int width = 0;
498 int decimals = 0;
499 try {
500 String wstr = f.groups[1];
501 if (wstr != null) {
502 if (wstr.charAt(0) == '0')
503 zero = true;
504 width = Integer.parseInt(wstr);
505 }
506 wstr = f.groups[3];
507 if (wstr != null) {
508 decimals = Integer.parseInt(wstr);
509 }
510 } catch (Exception e) {
511 msg.err("sprint.printDouble(): " + f, e);
512 }
513 StringBuffer s = new StringBuffer(toDoubleString(value, width, decimals));
514 padding(s, width, left, zero);
515 ret.append(s);
516 }
517
518 /** Print value in string format: /%([\\-])*([0-9]+)*s/
519 */
520 private void printString(Format f, String value) {
521 boolean left = f.groups[0] != null;
522 int width = 0;
523 String wstr = f.groups[1];
524 if (wstr != null) {
525 try {
526 width = Integer.parseInt(wstr);
527 } catch (Exception e) {
528 msg.err("sprint.printString(): " + f, e);
529 }
530 }
531 StringBuffer s = new StringBuffer(value);
532 padding(s, width, left, false);
533 ret.append(s);
534 }
535
536 /** Print value in date format: "/%([\\-])*([0-9]+)*("+DATEFORMATS+")/"
537 */
538 private void printDate(Format f, long value) {
539 printDate(f, new Date(value));
540 }
541
542 private void printDate(Format f, Date date) {
543 boolean left = f.groups[0] != null;
544 int width = 0;
545 String wstr = f.groups[1];
546 if (wstr != null) {
547 try {
548 width = Integer.parseInt(wstr);
549 } catch (Exception e) {
550 msg.err("sprint.printDate(): " + f, e);
551 }
552 }
553 StringBuffer s = new StringBuffer();
554 String fmt = f.groups[2];
555 if (fmt.equals("T0"))
556 s.append(DateTime.getInstance(date).getNumericTimeString());
557 else if (fmt.equals("TT"))
558 s.append(DateTime.getInstance(date).getTimeString());
559 else if (fmt.equals("TH"))
560 s.append(DateTime.getInstance(date).getHourMinuteString());
561 else if (fmt.equals("TM"))
562 s.append(DateTime.getInstance(date).getMinuteSecondString());
563 else if (fmt.equals("YY"))
564 s.append(DateTime.getInstance(date).getYearString());
565 else if (fmt.equals("MM"))
566 s.append(DateTime.getInstance(date).getMonthString());
567 else if (fmt.equals("WW"))
568 s.append(DateTime.getInstance(date).getWeekdayString());
569 else if (fmt.equals("D0"))
570 s.append(DateTime.getInstance(date).getNumericDateString());
571 else if (fmt.equals("DD"))
572 s.append(DateTime.getInstance(date).getDateString());
573 else if (fmt.equals("DM"))
574 s.append(DateTime.getInstance(date).getMonthDayString());
575 else if (fmt.equals("Dm"))
576 s.append(DateTime.getInstance(date).getStartOfMonthString());
577 else if (fmt.equals("Ds"))
578 s.append(DateTime.getInstance(date).getStartOfYearStartOfMonthString());
579 else if (fmt.equals("DH"))
580 s.append(DateTime.getInstance(date).getHourMinuteMonthDayString());
581 else if (fmt.equals("Dh"))
582 s.append(DateTime.getInstance(date).getMonthDayHourMinuteString());
583 else if (fmt.equals("DY"))
584 s.append(DateTime.getInstance(date).getYearMonthString());
585 else if (fmt.equals("Dy"))
586 s.append(DateTime.getInstance(date).getYearStartOfMonthString());
587 else if (fmt.equals("DT"))
588 s.append(DateTime.getInstance(date).getDateTimeString());
589 else if (fmt.equals("U0"))
590 s.append(DateTime.getInstance(date, "US").getNumericDateString());
591 else if (fmt.equals("UD"))
592 s.append(DateTime.getInstance(date, "US").getDateString());
593 else if (fmt.equals("UM"))
594 s.append(DateTime.getInstance(date, "US").getMonthDayString());
595 else if (fmt.equals("Um"))
596 s.append(DateTime.getInstance(date, "US").getStartOfMonthString());
597 else if (fmt.equals("Us"))
598 s.append(DateTime.getInstance(date, "US").getStartOfYearStartOfMonthString());
599 else if (fmt.equals("UH"))
600 s.append(DateTime.getInstance(date, "US").getHourMinuteMonthDayString());
601 else if (fmt.equals("Uh"))
602 s.append(DateTime.getInstance(date, "US").getMonthDayHourMinuteString());
603 else if (fmt.equals("UY"))
604 s.append(DateTime.getInstance(date, "US").getYearMonthString());
605 else if (fmt.equals("Uy"))
606 s.append(DateTime.getInstance(date, "US").getYearStartOfMonthString());
607 else if (fmt.equals("UT"))
608 s.append(DateTime.getInstance(date, "US").getDateTimeString());
609 padding(s, width, left, false);
610 ret.append(s);
611 }
612
613 ////////////////////////////////////////////////////////////////////////
614
615 private StringBuffer padding(StringBuffer s, int width, boolean leftJustify, boolean zeroPadded) {
616 width -= s.length();
617 for (; width > 0; width--) {
618 if (zeroPadded) {
619 s.insert(0, '0');
620 } else if (leftJustify) {
621 s.append(' ');
622 } else {
623 s.insert(0, ' ');
624 }
625 }
626 return s;
627 }
628
629 private String toHexString(int value, boolean uppercase, int width) {
630 StringBuffer ret = new StringBuffer("");
631 for (int i = 0; i < width; i++) {
632 int v = value & 0xf;
633 ret.insert(0, hexTable.charAt(v));
634 value >>>= 4;
635 }
636 for (int i = 0; i < width - 1; i++) {
637 if (ret.charAt(0) == '0')
638 ret.deleteCharAt(0);
639 else
640 break;
641 }
642 return (uppercase) ? ret.toString().toUpperCase() : ret.toString();
643 }
644
645 private String toHexString(long value, boolean uppercase, int width) {
646 StringBuffer ret = new StringBuffer("");
647 for (int i = 0; i < width; i++) {
648 int v = (int) value & 0xf;
649 ret.insert(0, hexTable.charAt(v));
650 value >>>= 4;
651 }
652 for (int i = 0; i < width - 1; i++) {
653 if (ret.charAt(0) == '0')
654 ret.deleteCharAt(0);
655 else
656 break;
657 }
658 return (uppercase) ? ret.toString().toUpperCase() : ret.toString();
659 }
660
661 private String toFloatString(float value, int width, int decimal) {
662 return toDoubleString((double) value, width, decimal);
663 }
664
665 private String toDoubleString(double value, int width, int decimal) {
666 if (DEBUG)
667 msg.debug("sprint.toDoubleString(): " + value + ": " + width + ": " + decimal);
668 StringBuffer ret = new StringBuffer();
669 String s = "" + (long) value;
670 for (int i = 0; i < s.length(); i++) {
671 char c = s.charAt(i);
672 ret.append(c);
673 //if(c=='.') {i++; break;}
674 if (DEBUG)
675 msg.debug("sprint.toDoubleString(): 1: " + ret.toString());
676 }
677 if (decimal > 0) {
678 ret.append('.');
679 if (value < 0)
680 value = -value;
681 double f = value - (long) value;
682 for (int i = decimal; i > 0; --i) {
683 f = f * 10;
684 int d = (int) f;
685 f -= d;
686 ret.append("" + d);
687 if (DEBUG)
688 msg.debug("sprint.toDoubleString(): 2: " + ret.toString());
689 }
690 }
691 if (DEBUG)
692 msg.debug("sprint.toDoubleString(): 3: " + ret.toString());
693 return ret.toString();
694 }
695
696 ////////////////////////////////////////////////////////////////////////
697
698 public static void main(String[] args) throws Exception {
699 // Test routines for the class.
700 List result;
701 msg.println("### regex tests:");
702 result = msg.split("/abc/", "111abc222abc333");
703 msg.print("result 1=");
704 for (int i = 0; i < result.size(); i++)
705 msg.print((String) result.get(i) + " ");
706 msg.println("");
707 result = msg.split("/a(b)(c)/", "111abc222abc333");
708 msg.print("result 2=");
709 for (int i = 0; i < result.size(); i++)
710 msg.print((String) result.get(i) + " ");
711 msg.println("");
712 result = msg.split("/(abc)/", "111abc222abc333");
713 msg.print("result 3=");
714 for (int i = 0; i < result.size(); i++)
715 msg.print((String) result.get(i) + " ");
716 msg.println("");
717 //
718 msg.println("### Number format tests:");
719 msg.println(sprint.f("%.2f").a(123.2342384028e1).end());
720 msg.println(sprint.f("%8.2f").a(123.2342384028e10).end());
721 msg.println(sprint.f("%8.4f").a(0.01232342384028).end());
722 msg.println(sprint.f("%8.2f").a(0.01232342384028).end());
723 msg.println(sprint.f("%8.0f").a(0.01232342384028).end());
724 msg.println(sprint.f("%-8f").a(0.01232342384028).end());
725 //
726 msg.println("### Date format tests:");
727 Date now = new Date();
728 long timenow = now.getTime();
729 msg.println("");
730 msg.println(sprint.f("|%02x,%06x|").a(0xa).a(0x1234).end());
731 msg.println(sprint.f("|%-10d,%10d|").a(123).a(456).end());
732 msg.println(sprint.f("|%-10d,%10d|").a(-123).a(+456).end());
733 msg.println(sprint.f("|%-2d,%2d|").a(123).a(456).end());
734 msg.println(sprint.f("|%-s,%s|").a("string1").a("string2").end());
735 msg.println(sprint.f("|ssss|%-10s,%10s|xxxx|").a("string1").a("string2").end());
736 msg.println(sprint.f("Now(T0)=|%T0|").a(now).end());
737 msg.println(sprint.f("Now(TT)=|%TT|").a(now).end());
738 msg.println(sprint.f("Now(TH)=|%TH|").a(now).end());
739 msg.println(sprint.f("Now(TM)=|%TM|").a(now).end());
740 msg.println(sprint.f("Now(YY)=|%YY|").a(now).end());
741 msg.println(sprint.f("Now(MM)=|%MM|").a(now).end());
742 msg.println(sprint.f("Now(WW)=|%WW|").a(now).end());
743 msg.println(sprint.f("Now(D0)=|%D0|").a(now).end());
744 msg.println(sprint.f("Now(DD)=|%DD|").a(now).end());
745 msg.println(sprint.f("Now(DM)=|%DM|").a(now).end());
746 msg.println(sprint.f("Now(Dm)=|%Dm|").a(now).end());
747 msg.println(sprint.f("Now(Ds)=|%Ds|").a(now).end());
748 msg.println(sprint.f("Now(DH)=|%DH|").a(now).end());
749 msg.println(sprint.f("Now(Dh)=|%Dh|").a(now).end());
750 msg.println(sprint.f("Now(DY)=|%DY|").a(now).end());
751 msg.println(sprint.f("Now(Dy)=|%Dy|").a(now).end());
752 msg.println(sprint.f("Now(DT)=|%DT|").a(now).end());
753 msg.println(sprint.f("Now(U0)=|%U0|").a(now).end());
754 msg.println(sprint.f("Now(UD)=|%UD|").a(now).end());
755 msg.println(sprint.f("Now(UM)=|%UM|").a(now).end());
756 msg.println(sprint.f("Now(Um)=|%Um|").a(now).end());
757 msg.println(sprint.f("Now(Us)=|%Us|").a(now).end());
758 msg.println(sprint.f("Now(UH)=|%UH|").a(now).end());
759 msg.println(sprint.f("Now(Uh)=|%Uh|").a(now).end());
760 msg.println(sprint.f("Now(UY)=|%UY|").a(now).end());
761 msg.println(sprint.f("Now(Uy)=|%Uy|").a(now).end());
762 msg.println(sprint.f("Now(UT)=|%UT|").a(now).end());
763 msg.println(sprint.f("Now(D0T0)=|%D0 %T0|").a(timenow).a(timenow).end());
764 try {
765 msg.println(sprint.f("|%-2d,2d|").a(123).a(456).end()); // Intentional error here.
766 } catch (Exception e) {
767 msg.println("\n### Above is an intentional format error.");
768 }
769 }
770
771 ////////////////////////////////////////////////////////////////////////
772
773 }