From 4910a8564de42193243e6926985abd7117cb3d9b Mon Sep 17 00:00:00 2001 From: Zoltan Somogyi Date: Tue, 26 Jan 2021 14:33:09 +1100 Subject: [PATCH] Update programming style. --- benchmarks/progs/compress/bitbuf2.m | 31 ++-- benchmarks/progs/compress/bmio.m | 187 +++++++++++------------- benchmarks/progs/compress/code_table4.m | 32 ++-- benchmarks/progs/compress/compress5.m | 36 +++-- benchmarks/progs/compress/harness.m | 35 +++-- benchmarks/progs/compress/util.m | 21 ++- 6 files changed, 168 insertions(+), 174 deletions(-) diff --git a/benchmarks/progs/compress/bitbuf2.m b/benchmarks/progs/compress/bitbuf2.m index 1308789dd..4ff451187 100644 --- a/benchmarks/progs/compress/bitbuf2.m +++ b/benchmarks/progs/compress/bitbuf2.m @@ -1,10 +1,9 @@ -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% % vim: ts=4 sw=4 et tw=0 wm=0 ff=unix % bitbuf2.m % Ralph Becket % Fri Nov 10 18:03:25 GMT 2000 -% -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- module bitbuf2. :- interface. @@ -14,7 +13,7 @@ :- import_module io. :- import_module store. -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- type bitbuf(S). @@ -35,15 +34,15 @@ :- pred flush_buffer(bitbuf(S)::in, S::di, S::uo, io::di, io::uo) is det <= store(S). -%-----------------------------------------------------------------------------% -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- implementation. :- import_module bmio. :- import_module util. -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- type bitbuf(S) ---> bitbuf( @@ -54,7 +53,7 @@ size :: generic_mutvar(int, S) % Number of bits in buffer. ). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% new_bitbuf(bitbuf(A,B,C,D,E), !:S) :- store.init(!:S), @@ -64,14 +63,14 @@ new_bitbuf(bitbuf(A,B,C,D,E), !:S) :- store.new_mutvar(0, D, !S), store.new_mutvar(0, E, !S). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% read_byte(Result, Buf, !S, !IO) :- store.get_mutvar(Buf ^ bits_in, BitsIn, !S), bmio.read_byte(Result, !IO), store.set_mutvar(Buf ^ bits_in, BitsIn + 8, !S). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% write_code(C, BPC, Buf, !S, !IO) :- store.get_mutvar(Buf ^ bits_in, BitsIn, !S), @@ -87,7 +86,7 @@ write_code(C, BPC, Buf, !S, !IO) :- store.set_mutvar(Buf ^ data, Data, !S), store.set_mutvar(Buf ^ size, Size, !S). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- pred write_full_bytes(int::in, int::out, int::in, int::out, io::di, io::uo) is det. @@ -100,7 +99,7 @@ write_full_bytes(!Data, !Size, !IO) :- true ). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% compression_ratio_fallen(Buf, Result, !S) :- store.get_mutvar(Buf ^ bits_in, BitsIn, !S), @@ -108,19 +107,19 @@ compression_ratio_fallen(Buf, Result, !S) :- store.get_mutvar(Buf ^ ratio, Ratio, !S), Result = ( if ratio(BitsIn, BitsOut) < Ratio then yes else no ). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% reset_compression_ratio(Buf, !S) :- store.set_mutvar(Buf ^ bits_in, 0, !S), store.set_mutvar(Buf ^ bits_out, 0, !S), store.set_mutvar(Buf ^ ratio, 0, !S). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% flush_buffer(Buf, !S, !IO) :- store.get_mutvar(Buf ^ data, Data, !S), bmio.write_byte(Data, !IO). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- end_module bitbuf2. -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% diff --git a/benchmarks/progs/compress/bmio.m b/benchmarks/progs/compress/bmio.m index d1e06eba3..d1592082e 100644 --- a/benchmarks/progs/compress/bmio.m +++ b/benchmarks/progs/compress/bmio.m @@ -1,10 +1,11 @@ -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% +% vim: ft=mercury ts=4 sw=4 et +%---------------------------------------------------------------------------% +% % bmio.m +% Simple test harness for 129.compress benchmark. Uses C because it's easier... % -% Simple test harness for 129.compress benchmark. Uses C because it's -% easier... -% -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% :- module bmio. @@ -12,38 +13,30 @@ :- import_module io. -:- type bmio.state == io.state. +:- type state == io.state. -:- pred bmio.init(string, int, bmio.state, bmio.state). -:- mode bmio.init(in, in, di, uo) is det. +:- pred init(string::in, int::in, bmio.state::di, bmio.state::uo) is det. -:- pred bmio.use_compression_io(bmio.state, bmio.state). -:- mode bmio.use_compression_io(di, uo) is det. +:- pred use_compression_io(bmio.state::di, bmio.state::uo) is det. -:- pred bmio.use_decompression_io(bmio.state, bmio.state). -:- mode bmio.use_decompression_io(di, uo) is det. +:- pred use_decompression_io(bmio.state::di, bmio.state::uo) is det. -:- pred bmio.read_byte(io.result(int), bmio.state, bmio.state). -:- mode bmio.read_byte(out, di, uo) is det. +:- pred read_byte(io.result(int)::out, bmio.state::di, bmio.state::uo) is det. -:- pred bmio.write_byte(int, bmio.state, bmio.state). -:- mode bmio.write_byte(in, di, uo) is det. +:- pred write_byte(int::in, bmio.state::di, bmio.state::uo) is det. -:- pred bmio.mark_decompression_eof(bmio.state, bmio.state). -:- mode bmio.mark_decompression_eof(di, uo) is det. +:- pred write_byte_checked(int::in, bmio.state::di, bmio.state::uo) is det. -:- pred bmio.write_byte_checked(int, bmio.state, bmio.state). -:- mode bmio.write_byte_checked(in, di, uo) is det. +:- pred mark_decompression_eof(bmio.state::di, bmio.state::uo) is det. -:- pred bmio.report_stats(bmio.state, bmio.state). -:- mode bmio.report_stats(di, uo) is det. +:- pred report_stats(bmio.state::di, bmio.state::uo) is det. :- implementation. :- import_module list, string. -:- pragma foreign_decl("C", " - +:- pragma foreign_decl("C", +" #include #include #include @@ -59,51 +52,42 @@ unsigned char *bmio__rd_eof; unsigned char *bmio__wr_buf; unsigned char *bmio__wr_ptr; unsigned char *bmio__wr_eof; -FILE *bmio__fp; +FILE *bmio__fp; "). % :- pragma no_inline(bmio.init/4). :- pragma foreign_proc("C", - bmio.init(FileName::in, NumBytes::in, _IO0::di, _IO::uo), + init(FileName::in, NumBytes::in, _IO0::di, _IO::uo), [promise_pure, will_not_call_mercury], " - - /* printf(""starting bmio__init\n""); */ + /* printf(""starting bmio__init\n""); */ assert(NumBytes > 0); bmio__buf_size = NumBytes; - assert(( - bmio__plain_buf = malloc(NumBytes * sizeof(char)) - ) != NULL); - bmio__plain_buf_eof = bmio__plain_buf + NumBytes; + assert((bmio__plain_buf = malloc(NumBytes * sizeof(char))) != NULL); + bmio__plain_buf_eof = bmio__plain_buf + NumBytes; - assert(( - bmio__fp = fopen(FileName, ""rb"") - ) != NULL); - assert(( - fread(bmio__plain_buf, sizeof(char), NumBytes, bmio__fp) - ) == NumBytes); + assert((bmio__fp = fopen(FileName, ""rb"")) != NULL); + assert((fread(bmio__plain_buf, sizeof(char), NumBytes, bmio__fp)) + == NumBytes); fclose(bmio__fp); - assert(( - bmio__zipped_buf = malloc(NumBytes * sizeof(char)) - ) != NULL); + assert((bmio__zipped_buf = malloc(NumBytes * sizeof(char))) != NULL); bmio__zipped_buf_eof = bmio__zipped_buf + NumBytes; - /* printf(""finished bmio__init\n""); */ + /* printf(""finished bmio__init\n""); */ "). % :- pragma no_inline(bmio.use_compression_io/2). :- pragma foreign_proc("C", - bmio.use_compression_io(_IO0::di, _IO::uo), + use_compression_io(_IO0::di, _IO::uo), [promise_pure, will_not_call_mercury], " - bmio__rd_buf = bmio__plain_buf; bmio__rd_ptr = bmio__plain_buf; bmio__rd_eof = bmio__plain_buf_eof; @@ -116,7 +100,7 @@ FILE *bmio__fp; % :- pragma no_inline(bmio.use_decompression_io/2). :- pragma foreign_proc("C", - bmio.use_decompression_io(_IO0::di, _IO::uo), + use_decompression_io(_IO0::di, _IO::uo), [promise_pure, will_not_call_mercury], " bmio__rd_buf = bmio__zipped_buf; @@ -130,24 +114,19 @@ FILE *bmio__fp; :- pragma inline(bmio.read_byte/3). -bmio.read_byte(Result) --> - rd(Byte), - { if Byte = -1 then Result = eof else Result = ok(Byte) }. +read_byte(Result, !IO) :- + rd(Byte, !IO), + ( if Byte = -1 then + Result = eof + else + Result = ok(Byte) + ). -bmio.write_byte(Byte) --> - wr(Byte). +write_byte(Byte, !IO) :- + wr(Byte, !IO). -% :- pragma no_inline(bmio.mark_decompression_eof/2). - -:- pragma foreign_proc("C", - bmio.mark_decompression_eof(_IO0::di, _IO::uo), - [promise_pure, will_not_call_mercury], -" - bmio__zipped_buf_eof = bmio__wr_ptr; -"). - -bmio.write_byte_checked(Byte) --> - chk_wr(Byte). +write_byte_checked(Byte, !IO) :- + chk_wr(Byte, !IO). % :- pragma no_inline(rd/3). @@ -157,13 +136,23 @@ bmio.write_byte_checked(Byte) --> rd(Byte::out, _IO0::di, _IO::uo), [promise_pure, will_not_call_mercury], " - /* assert(bmio__rd_buf <= bmio__rd_ptr); */ - /* assert(bmio__rd_ptr <= bmio__rd_eof); */ + /* assert(bmio__rd_buf <= bmio__rd_ptr); */ + /* assert(bmio__rd_ptr <= bmio__rd_eof); */ - if(bmio__rd_ptr < bmio__rd_eof) - Byte = (unsigned char)(*bmio__rd_ptr++); - else + if (bmio__rd_ptr < bmio__rd_eof) { + Byte = (unsigned char) (*bmio__rd_ptr++); + } else { Byte = -1; + } +"). + +:- pred rd_bytes(int::out, bmio.state::di, bmio.state::uo) is det. + +:- pragma foreign_proc("C", + rd_bytes(R::out, _IO0::di, _IO::uo), + [promise_pure, will_not_call_mercury], +" + R = bmio__rd_ptr - bmio__rd_buf; "). % :- pragma no_inline(wr/3). @@ -174,17 +163,18 @@ bmio.write_byte_checked(Byte) --> wr(Byte::in, _IO0::di, _IO::uo), [promise_pure, will_not_call_mercury], " + /* + if(bmio__wr_buf > bmio__wr_ptr || bmio__wr_ptr >= bmio__wr_eof) { + fprintf(stderr, ""bmio__wr_buf = %p\n"", bmio__wr_buf); + fprintf(stderr, ""bmio__wr_ptr = %p\n"", bmio__wr_ptr); + fprintf(stderr, ""bmio__wr_eof = %p\n"", bmio__wr_eof); + } + */ - /* if(bmio__wr_buf > bmio__wr_ptr || bmio__wr_ptr >= bmio__wr_eof) { - fprintf(stderr, ""bmio__wr_buf = %p\n"", bmio__wr_buf); - fprintf(stderr, ""bmio__wr_ptr = %p\n"", bmio__wr_ptr); - fprintf(stderr, ""bmio__wr_eof = %p\n"", bmio__wr_eof); - } */ + /* assert(bmio__wr_buf <= bmio__wr_ptr); */ + /* assert(bmio__wr_ptr < bmio__wr_eof); */ - /* assert(bmio__wr_buf <= bmio__wr_ptr); */ - /* assert(bmio__wr_ptr < bmio__wr_eof); */ - - *bmio__wr_ptr++ = Byte; + *bmio__wr_ptr++ = Byte; "). % :- pragma no_inline(chk_wr/3). @@ -195,37 +185,32 @@ bmio.write_byte_checked(Byte) --> chk_wr(Byte::in, _IO0::di, _IO::uo), [promise_pure, will_not_call_mercury], " - - /* assert(bmio__wr_buf <= bmio__wr_ptr); */ - /* assert(bmio__wr_ptr < bmio__wr_eof); */ - - assert(( - *bmio__wr_ptr++ - ) == Byte); -"). - -bmio.report_stats --> - rd_bytes(R), - wr_bytes(W), - io.stderr_stream(E), - io.write_many(E, [s("bmio: read "), i(R), s(" bytes\n")]), - io.write_many(E, [s("bmio: written "), i(W), s(" bytes\n")]). - -:- pred rd_bytes(int::out, bmio.state::di, bmio.state::uo) is det. - -:- pragma foreign_proc("C", - rd_bytes(R::out, _IO0::di, _IO::uo), - [promise_pure, will_not_call_mercury], -" - - R = bmio__rd_ptr - bmio__rd_buf; + /* assert(bmio__wr_buf <= bmio__wr_ptr); */ + /* assert(bmio__wr_ptr < bmio__wr_eof); */ + assert((*bmio__wr_ptr++) == Byte); "). :- pred wr_bytes(int::out, bmio.state::di, bmio.state::uo) is det. :- pragma foreign_proc("C", wr_bytes(W::out, _IO0::di, _IO::uo), - [promise_pure, will_not_call_mercury], " - + [promise_pure, will_not_call_mercury], +" W = bmio__wr_ptr - bmio__wr_buf; "). + +% :- pragma no_inline(bmio.mark_decompression_eof/2). + +:- pragma foreign_proc("C", + mark_decompression_eof(_IO0::di, _IO::uo), + [promise_pure, will_not_call_mercury], +" + bmio__zipped_buf_eof = bmio__wr_ptr; +"). + +report_stats(!IO) :- + rd_bytes(R, !IO), + wr_bytes(W, !IO), + io.stderr_stream(E, !IO), + io.write_many(E, [s("bmio: read "), i(R), s(" bytes\n")], !IO), + io.write_many(E, [s("bmio: written "), i(W), s(" bytes\n")], !IO). diff --git a/benchmarks/progs/compress/code_table4.m b/benchmarks/progs/compress/code_table4.m index 9e30a223d..46e586b73 100644 --- a/benchmarks/progs/compress/code_table4.m +++ b/benchmarks/progs/compress/code_table4.m @@ -1,10 +1,9 @@ -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% +% vim: ts=4 sw=4 et tw=0 wm=0 ff=unix % code_table4.m % Ralph Becket % Thu Nov 9 15:01:55 GMT 2000 -% vim: ts=4 sw=4 et tw=0 wm=0 ff=unix -% -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% :- module code_table4. @@ -13,9 +12,7 @@ :- import_module util, array. :- type code_table. - :- type hash. - :- type key. :- func key(code, byte) = key. @@ -29,12 +26,13 @@ :- func set(code_table, hash, key, code) = code_table. :- mode set(array_di, in, in, in) = array_uo is det. -% ---------------------------------------------------------------------------- % -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- implementation. -:- import_module assoc_list, int. +:- import_module assoc_list. +:- import_module int. :- type hash == int. @@ -60,15 +58,15 @@ hash(C, B) = C `xor` (B `lshift` 8). :- func hash_delta(hash) = int. hash_delta(H) = ( if H = 0 then 1 else table_size - H ). -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% key(C, B) = (C `lshift` 8) \/ B. -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% new_code_table = array.init(array_size, empty_code). -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% lookup(C, B, T, H, K, Code) :- H0 = hash(C, B), @@ -77,11 +75,11 @@ lookup(C, B, T, H, K, Code) :- ( if (K0 = K ; K0 = empty_code) then H = H0, Code = array.lookup(T, code_idx(H0)) - else + else lookup_0(H0, hash_delta(H0), K, T, H, Code) ). -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% :- pred lookup_0(hash, int, key, code_table, hash, code). :- mode lookup_0(in, in, in, array_ui, out, out) is det. @@ -92,14 +90,14 @@ lookup_0(H0, DH, K, T, H, Code) :- ( if (K0 = K ; K0 = empty_code) then H = H1, Code = array.lookup(T, code_idx(H1)) - else + else lookup_0(H1, DH, K, T, H, Code) ). -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% set(T0, H, K, C) = T :- T1 = array.set(T0, key_idx(H), K), T = array.set(T1, code_idx(H), C). -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% diff --git a/benchmarks/progs/compress/compress5.m b/benchmarks/progs/compress/compress5.m index 9fc41c51d..f42342d0f 100644 --- a/benchmarks/progs/compress/compress5.m +++ b/benchmarks/progs/compress/compress5.m @@ -1,10 +1,9 @@ -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% % vim: ts=4 sw=4 et tw=0 wm=0 ff=unix % compress5.m % Ralph Becket % Thu Nov 9 16:52:58 GMT 2000 -% -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- module compress5. :- interface. @@ -13,22 +12,29 @@ :- pred go(io::di, io::uo) is det. -%-----------------------------------------------------------------------------% -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- implementation. -:- import_module bitbuf2, code_table4, util, int, array, require, store, bool. - :- import_module bmio. % XXX to get better intermodule optimization -%-----------------------------------------------------------------------------% +:- import_module array. +:- import_module bitbuf2. +:- import_module bool. +:- import_module code_table4. +:- import_module int. +:- import_module require. +:- import_module store. +:- import_module util. + +%---------------------------------------------------------------------------% go(!IO) :- new_bitbuf(Buf, S), start(Buf, S, !IO). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- pragma inline(start/4). :- pred start(bitbuf(T)::in, T::di, io::di, io::uo) is det <= store(T). @@ -46,7 +52,7 @@ start(Buf, !.S, !IO) :- error(io.error_message(ErrNo)) ). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- pred main_loop(code::in, code::in, code_table::array_di, int::in, bitbuf(T)::in, T::di, io::di, io::uo) is det <= store(T). @@ -58,16 +64,16 @@ main_loop(C, N, T, BPC, Buf, !.S, !IO) :- lookup(C, B, T, H, K, C0), ( if C0 \= empty_code then main_loop(C0, N, T, BPC, Buf, !.S, !IO) - else if N =< max_code then + else if N =< max_code then write_code(C, BPC, Buf, !S, !IO), main_loop(B, N + 1, set(T, H, K, N), update_bpc(N, BPC), Buf, !.S, !IO) - else + else compression_ratio_fallen(Buf, Fallen, !S), ( if Fallen = no then write_code(C, BPC, Buf, !S, !IO), main_loop(B, N, T, BPC, Buf, !.S, !IO) - else + else write_code(C, BPC, Buf, !S, !IO), write_code(B, BPC, Buf, !S, !IO), write_code(clear_code, BPC, Buf, !S, !IO), @@ -84,6 +90,6 @@ main_loop(C, N, T, BPC, Buf, !.S, !IO) :- error(io.error_message(ErrNo)) ). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- end_module compress5. -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% diff --git a/benchmarks/progs/compress/harness.m b/benchmarks/progs/compress/harness.m index c04f889a6..256be933a 100644 --- a/benchmarks/progs/compress/harness.m +++ b/benchmarks/progs/compress/harness.m @@ -1,10 +1,9 @@ -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% % vim: ts=4 sw=4 et tw=0 wm=0 ff=unix % harness.m % Ralph Becket % Mon Nov 13 13:12:09 GMT 2000 -% -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- module harness. :- interface. @@ -13,25 +12,32 @@ :- pred main(io::di, io::uo) is det. -%-----------------------------------------------------------------------------% -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- implementation. -:- import_module bmio, int, list, string, require. -% :- import_module compress1, compress2, compress3, compress4, compress5. +:- import_module bmio. +% :- import_module compress1. +% :- import_module compress2. +% :- import_module compress3. +% :- import_module compress4. :- import_module compress5. +:- import_module int. +:- import_module list. +:- import_module require. +:- import_module string. :- func num_iterations = int. num_iterations = 10. -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% main(!IO) :- io.command_line_arguments(ArgV, !IO), ( if ArgV = [FileName, NumBytesStr], - string.to_int(NumBytesStr, NumBytes) + string.to_int(NumBytesStr, NumBytes) then bmio.init(FileName, NumBytes, !IO), %test("compress1", compress1.go), @@ -43,18 +49,19 @@ main(!IO) :- error("usage: compress ") ). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- pred test(string::in, pred(io, io)::in(pred(di, uo) is det), io::di, io::uo) is det. test(_Name, Go, !IO) :- - % io.format("\n\n******* %s x %d *******\n", [s(Name), i(num_iterations)], !IO), + % io.format("\n\n******* %s x %d *******\n", + % [s(Name), i(num_iterations)], !IO), % io.report_stats(!IO), test_loop(num_iterations, Go, !IO). % io.report_stats(!IO). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- pred test_loop(int::in, pred(io, io)::in(pred(di, uo) is det), io::di, io::uo) is det. @@ -68,6 +75,6 @@ test_loop(N, Go, !IO) :- true ). -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- end_module harness. -%-----------------------------------------------------------------------------% +%---------------------------------------------------------------------------% diff --git a/benchmarks/progs/compress/util.m b/benchmarks/progs/compress/util.m index 4dd34ee1f..02694038e 100644 --- a/benchmarks/progs/compress/util.m +++ b/benchmarks/progs/compress/util.m @@ -1,10 +1,9 @@ -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% +% vim: ts=4 sw=4 et tw=0 wm=0 ff=unix % util.m % Ralph Becket % Thu Nov 9 15:14:21 GMT 2000 -% vim: ts=4 sw=4 et tw=0 wm=0 ff=unix -% -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% :- module util. @@ -34,12 +33,12 @@ :- func ratio(int, int) = int. -% ---------------------------------------------------------------------------- % -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% +%---------------------------------------------------------------------------% :- implementation. -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% first_new_code = 257. @@ -51,18 +50,18 @@ max_code = 65535. initial_bpc = 9. -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% update_bpc(N, BPC) = BPC + ( if N >= (1 `lshift` BPC) then 1 else 0 ). -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% X `lshift` N = unchecked_left_shift(X, N). X `rshift` N = unchecked_right_shift(X, N). -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------% ratio(BitsIn, BitsOut) = (BitsIn - BitsOut) `rshift` 11. -% ---------------------------------------------------------------------------- % +%---------------------------------------------------------------------------%