// ----------------------------------------------------------------------------
-// Basic ByteArray support
+// Basic byteArray support
-type ByteArray struct {
+type byteArray struct {
a []byte;
}
-func (b *ByteArray) Init(initial_size int) {
+func (b *byteArray) Init(initial_size int) {
b.a = make([]byte, initial_size)[0 : 0];
}
-func (b *ByteArray) Len() int {
+func (b *byteArray) Len() int {
return len(b.a);
}
-func (b *ByteArray) Clear() {
+func (b *byteArray) clear() {
b.a = b.a[0 : 0];
}
-func (b *ByteArray) Slice(i, j int) []byte {
+func (b *byteArray) slice(i, j int) []byte {
return b.a[i : j]; // BUG should really be &b.a[i : j]
}
-func (b *ByteArray) Append(s []byte) {
+func (b *byteArray) append(s []byte) {
a := b.a;
n := len(a);
m := n + len(s);
// current state
html_char byte; // terminating char of html tag/entity, or 0 ('>', ';', or 0)
- buf ByteArray; // collected text w/o tabs and newlines
+ buf byteArray; // collected text w/o tabs and newlines
size int; // size of incomplete cell in bytes
width int; // width of incomplete cell in runes up to buf[pos] w/o ignored sections
pos int; // buffer position up to which width of incomplete cell has been computed
// buf start of incomplete cell pos
-func (b *Writer) AddLine() {
+func (b *Writer) addLine() {
b.lines_size.Push(array.NewIntArray(0));
b.lines_width.Push(array.NewIntArray(0));
}
b.lines_size.Init(0);
b.lines_width.Init(0);
b.widths.Init(0);
- b.AddLine(); // the very first line
+ b.addLine(); // the very first line
return b;
}
-func (b *Writer) Line(i int) (*array.IntArray, *array.IntArray) {
+func (b *Writer) line(i int) (*array.IntArray, *array.IntArray) {
return
b.lines_size.At(i).(*array.IntArray),
b.lines_width.At(i).(*array.IntArray);
// debugging support
-func (b *Writer) Dump() {
+func (b *Writer) dump() {
pos := 0;
for i := 0; i < b.lines_size.Len(); i++ {
- line_size, line_width := b.Line(i);
+ line_size, line_width := b.line(i);
print("(", i, ") ");
for j := 0; j < line_size.Len(); j++ {
s := line_size.At(j);
- print("[", string(b.buf.Slice(pos, pos + s)), "]");
+ print("[", string(b.buf.slice(pos, pos + s)), "]");
pos += s;
}
print("\n");
}
-func (b *Writer) Write0(buf []byte) *os.Error {
+func (b *Writer) write0(buf []byte) *os.Error {
n, err := b.writer.Write(buf);
if n != len(buf) && err == nil {
err = os.EIO;
}
-var Newline = []byte{'\n'}
+var newline = []byte{'\n'}
-func (b *Writer) WritePadding(textw, cellw int) (err *os.Error) {
+func (b *Writer) writePadding(textw, cellw int) (err *os.Error) {
if b.padbytes[0] == '\t' {
// make cell width a multiple of cellwidth
cellw = ((cellw + b.cellwidth - 1) / b.cellwidth) * b.cellwidth;
}
for n > len(b.padbytes) {
- err = b.Write0(b.padbytes);
+ err = b.write0(b.padbytes);
if err != nil {
goto exit;
}
n -= len(b.padbytes);
}
- err = b.Write0(b.padbytes[0 : n]);
+ err = b.write0(b.padbytes[0 : n]);
exit:
return err;
}
-func (b *Writer) WriteLines(pos0 int, line0, line1 int) (pos int, err *os.Error) {
+func (b *Writer) writeLines(pos0 int, line0, line1 int) (pos int, err *os.Error) {
pos = pos0;
for i := line0; i < line1; i++ {
- line_size, line_width := b.Line(i);
+ line_size, line_width := b.line(i);
for j := 0; j < line_size.Len(); j++ {
s, w := line_size.At(j), line_width.At(j);
if b.align_left {
- err = b.Write0(b.buf.Slice(pos, pos + s));
+ err = b.write0(b.buf.slice(pos, pos + s));
if err != nil {
goto exit;
}
pos += s;
if j < b.widths.Len() {
- err = b.WritePadding(w, b.widths.At(j));
+ err = b.writePadding(w, b.widths.At(j));
if err != nil {
goto exit;
}
} else { // align right
if j < b.widths.Len() {
- err = b.WritePadding(w, b.widths.At(j));
+ err = b.writePadding(w, b.widths.At(j));
if err != nil {
goto exit;
}
}
- err = b.Write0(b.buf.Slice(pos, pos + s));
+ err = b.write0(b.buf.slice(pos, pos + s));
if err != nil {
goto exit;
}
if i+1 == b.lines_size.Len() {
// last buffered line - we don't have a newline, so just write
// any outstanding buffered data
- err = b.Write0(b.buf.Slice(pos, pos + b.size));
+ err = b.write0(b.buf.slice(pos, pos + b.size));
pos += b.size;
} else {
// not the last line - write newline
- err = b.Write0(Newline);
+ err = b.write0(newline);
}
if err != nil {
goto exit;
}
-func (b *Writer) Format(pos0 int, line0, line1 int) (pos int, err *os.Error) {
+func (b *Writer) format(pos0 int, line0, line1 int) (pos int, err *os.Error) {
pos = pos0;
column := b.widths.Len();
last := line0;
for this := line0; this < line1; this++ {
- line_size, line_width := b.Line(this);
+ line_size, line_width := b.line(this);
if column < line_size.Len() - 1 {
// cell exists in this column
// (note that the last cell per line is ignored)
// print unprinted lines until beginning of block
- pos, err = b.WriteLines(pos, last, this);
+ pos, err = b.writeLines(pos, last, this);
if err != nil {
goto exit;
}
// column block begin
width := b.cellwidth; // minimal width
for ; this < line1; this++ {
- line_size, line_width = b.Line(this);
+ line_size, line_width = b.line(this);
if column < line_size.Len() - 1 {
// cell exists in this column => update width
w := line_width.At(column) + b.padding;
// format and print all columns to the right of this column
// (we know the widths of this column and all columns to the left)
b.widths.Push(width);
- pos, err = b.Format(pos, last, this);
+ pos, err = b.format(pos, last, this);
b.widths.Pop();
last = this;
}
}
// print unprinted lines until end
- pos, err = b.WriteLines(pos, last, line1);
+ pos, err = b.writeLines(pos, last, line1);
exit:
return pos, err;
}
-/* export */ func (b *Writer) Flush() *os.Error {
- dummy, err := b.Format(0, 0, b.lines_size.Len());
+func (b *Writer) Flush() *os.Error {
+ dummy, err := b.format(0, 0, b.lines_size.Len());
// reset (even in the presence of errors)
- b.buf.Clear();
+ b.buf.clear();
b.size, b.width = 0, 0;
b.pos = 0;
b.lines_size.Init(0);
b.lines_width.Init(0);
- b.AddLine();
+ b.addLine();
return err;
}
-func UnicodeLen(buf []byte) int {
+func unicodeLen(buf []byte) int {
l := 0;
for i := 0; i < len(buf); {
if buf[i] < utf8.RuneSelf {
}
-func (b *Writer) Append(buf []byte) {
- b.buf.Append(buf);
+func (b *Writer) append(buf []byte) {
+ b.buf.append(buf);
b.size += len(buf);
}
// outside html tag/entity
switch ch {
case '\t', '\n':
- b.Append(buf[i0 : i]);
+ b.append(buf[i0 : i]);
i0 = i + 1; // exclude ch from (next) cell
- b.width += UnicodeLen(b.buf.Slice(b.pos, b.buf.Len()));
+ b.width += unicodeLen(b.buf.slice(b.pos, b.buf.Len()));
b.pos = b.buf.Len();
// terminate cell
- last_size, last_width := b.Line(b.lines_size.Len() - 1);
+ last_size, last_width := b.line(b.lines_size.Len() - 1);
last_size.Push(b.size);
last_width.Push(b.width);
b.size, b.width = 0, 0;
if ch == '\n' {
- b.AddLine();
+ b.addLine();
if last_size.Len() == 1 {
// The previous line has only one cell which does not have
// an impact on the formatting of the following lines (the
- // last cell per line is ignored by Format), thus we can
+ // last cell per line is ignored by format()), thus we can
// flush the Writer contents.
err = b.Flush();
if err != nil {
case '<', '&':
if b.filter_html {
- b.Append(buf[i0 : i]);
+ b.append(buf[i0 : i]);
i0 = i;
- b.width += UnicodeLen(b.buf.Slice(b.pos, b.buf.Len()));
+ b.width += unicodeLen(b.buf.slice(b.pos, b.buf.Len()));
b.pos = -1; // preventative - should not be used (will cause index out of bounds)
if ch == '<' {
b.html_char = '>';
// inside html tag/entity
if ch == b.html_char {
// reached the end of tag/entity
- b.Append(buf[i0 : i + 1]);
+ b.append(buf[i0 : i + 1]);
i0 = i + 1;
if b.html_char == ';' {
b.width++; // count as one char
}
// append leftover text
- b.Append(buf[i0 : n]);
+ b.append(buf[i0 : n]);
return n, nil;
}
)
-type Buffer struct {
+type buffer struct {
a []byte;
}
-func (b *Buffer) Init(n int) {
+func (b *buffer) init(n int) {
b.a = make([]byte, n)[0 : 0];
}
-func (b *Buffer) Clear() {
+func (b *buffer) clear() {
b.a = b.a[0 : 0];
}
-func (b *Buffer) Write(buf []byte) (written int, err *os.Error) {
+func (b *buffer) Write(buf []byte) (written int, err *os.Error) {
n := len(b.a);
m := len(buf);
if n + m <= cap(b.a) {
}
-func (b *Buffer) String() string {
+func (b *buffer) String() string {
return string(b.a);
}
-func Write(t *testing.T, w *tabwriter.Writer, src string) {
+func write(t *testing.T, w *tabwriter.Writer, src string) {
written, err := io.WriteString(w, src);
if err != nil {
t.Errorf("--- src:\n%s\n--- write error: %v\n", src, err);
}
-func Verify(t *testing.T, w *tabwriter.Writer, b *Buffer, src, expected string) {
+func verify(t *testing.T, w *tabwriter.Writer, b *buffer, src, expected string) {
err := w.Flush();
if err != nil {
t.Errorf("--- src:\n%s\n--- flush error: %v\n", src, err);
}
-func Check(t *testing.T, tabwidth, padding int, padchar byte, align_left, filter_html bool, src, expected string) {
- var b Buffer;
- b.Init(1000);
+func check(t *testing.T, tabwidth, padding int, padchar byte, align_left, filter_html bool, src, expected string) {
+ var b buffer;
+ b.init(1000);
var w tabwriter.Writer;
w.Init(&b, tabwidth, padding, padchar, align_left, filter_html);
// write all at once
- b.Clear();
- Write(t, &w, src);
- Verify(t, &w, &b, src, expected);
+ b.clear();
+ write(t, &w, src);
+ verify(t, &w, &b, src, expected);
// write byte-by-byte
- b.Clear();
+ b.clear();
for i := 0; i < len(src); i++ {
- Write(t, &w, src[i : i+1]);
+ write(t, &w, src[i : i+1]);
}
- Verify(t, &w, &b, src, expected);
+ verify(t, &w, &b, src, expected);
// write using Fibonacci slice sizes
- b.Clear();
+ b.clear();
for i, d := 0, 0; i < len(src); {
- Write(t, &w, src[i : i+d]);
+ write(t, &w, src[i : i+d]);
i, d = i+d, d+1;
if i+d > len(src) {
d = len(src) - i;
}
}
- Verify(t, &w, &b, src, expected);
+ verify(t, &w, &b, src, expected);
}
export func Test(t *testing.T) {
- Check(
+ check(
t, 8, 1, '.', true, false,
"",
""
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"\n\n\n",
"\n\n\n"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"a\nb\nc",
"a\nb\nc"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"\t", // '\t' terminates an empty cell on last line - nothing to print
""
);
- Check(
+ check(
t, 8, 1, '.', false, false,
"\t", // '\t' terminates an empty cell on last line - nothing to print
""
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"*\t*",
"**"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"*\t*\n",
"*.......*\n"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"*\t*\t",
"*.......*"
);
- Check(
+ check(
t, 8, 1, '.', false, false,
"*\t*\t",
".......**"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"\t\n",
"........\n"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"a) foo",
"a) foo"
);
- Check(
+ check(
t, 8, 1, ' ', true, false,
"b) foo\tbar", // "bar" is not in any cell - not formatted, just flushed
"b) foobar"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"c) foo\tbar\t",
"c) foo..bar"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"d) foo\tbar\n",
"d) foo..bar\n"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"e) foo\tbar\t\n",
"e) foo..bar.....\n"
);
- Check(
+ check(
t, 8, 1, '.', true, true,
"e) f<o\t<b>bar</b>\t\n",
"e) f<o..<b>bar</b>.....\n"
);
- Check(
+ check(
t, 8, 1, '*', true, false,
"Hello, world!\n",
"Hello, world!\n"
);
- Check(
+ check(
t, 0, 0, '.', true, false,
"1\t2\t3\t4\n"
"11\t222\t3333\t44444\n",
"11222333344444\n"
);
- Check(
+ check(
t, 5, 0, '.', true, false,
"1\t2\t3\t4\n",
"1....2....3....4\n"
);
- Check(
+ check(
t, 5, 0, '.', true, false,
"1\t2\t3\t4\t\n",
"1....2....3....4....\n"
);
- Check(
+ check(
t, 8, 1, '.', true, false,
"本\tb\tc\n"
"aa\t\u672c\u672c\u672c\tcccc\tddddd\n"
"aaa.....bbbb\n"
);
- Check(
+ check(
t, 8, 1, ' ', false, false,
"a\tè\tc\t\n"
"aa\tèèè\tcccc\tddddd\t\n"
" aaa èèèè\n"
);
- Check(
+ check(
t, 2, 0, ' ', true, false,
"a\tb\tc\n"
"aa\tbbb\tcccc\n"
"aaabbbb\n"
);
- Check(
+ check(
t, 8, 1, '_', true, false,
"a\tb\tc\n"
"aa\tbbb\tcccc\n"
"aaa_____bbbb\n"
);
- Check(
+ check(
t, 4, 1, '-', true, false,
"4444\t日本語\t22\t1\t333\n"
"999999999\t22\n"
"1------1------999999999-0000000000\n"
);
- Check(
+ check(
t, 4, 3, '.', true, false,
"4444\t333\t22\t1\t333\n"
"999999999\t22\n"
"1........1........999999999...0000000000\n"
);
- Check(
+ check(
t, 8, 1, '\t', true, true,
"4444\t333\t22\t1\t333\n"
"999999999\t22\n"
"1\t1\t<font color=red attr=日本語>999999999</font>\t0000000000\n"
);
- Check(
+ check(
t, 0, 2, ' ', false, false,
".0\t.3\t2.4\t-5.1\t\n"
"23.0\t12345678.9\t2.4\t-989.4\t\n"