From b3c12e05cfeb661b724d2e9451ef2142d0af7a38 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 15 Jun 2017 11:50:48 +1000 Subject: [PATCH] Add a buf1.closed field. --- cmd/puffs-gen-c/base-header.h | 1 + cmd/puffs-gen-c/data.go | 2 +- cmd/puffs-gen-c/main.go | 20 +++++++++++++------- gen/c/gif.c | 24 +++++++++++++++--------- gen/h/gif.h | 5 +++-- std/gif/decode_lzw.puffs | 4 ++-- test/c/gif/basic.c | 9 +++------ test/c/gif/gif.c | 3 +-- test/c/testlib/testlib.c | 5 +++++ 9 files changed, 44 insertions(+), 29 deletions(-) diff --git a/cmd/puffs-gen-c/base-header.h b/cmd/puffs-gen-c/base-header.h index 2c65e9fc..0f5cebde 100644 --- a/cmd/puffs-gen-c/base-header.h +++ b/cmd/puffs-gen-c/base-header.h @@ -38,6 +38,7 @@ typedef struct { size_t len; // Length. size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. + bool closed; // No further writes are expected. } puffs_base_buf1; #endif // PUFFS_BASE_HEADER_H diff --git a/cmd/puffs-gen-c/data.go b/cmd/puffs-gen-c/data.go index 3fd347a1..9a70f567 100644 --- a/cmd/puffs-gen-c/data.go +++ b/cmd/puffs-gen-c/data.go @@ -7,7 +7,7 @@ package main const baseHeader = "" + "#ifndef PUFFS_BASE_HEADER_H\n#define PUFFS_BASE_HEADER_H\n\n// Use of this source code is governed by a BSD-style license that can be found\n// in the LICENSE file.\n\n#include \n#include \n#include \n\n// Puffs requires a word size of at least 32 bits because it assumes that\n// converting a u32 to usize will never overflow. For example, the size of a\n// decoded image is often represented, explicitly or implicitly in an image\n// file, as a u32, and it is convenient to compare that to a buffer size.\n#if __WORDSIZE < 32\n#error \"Puffs requires a word size of at least 32 bits\"\n#endif\n\n// PUFFS_VERSION is the major.minor version number as a uint32. The major\n// number is the high 16 bits. The minor number is the low 16 bits.\n//\n// The intention is to bump the version number at least on every API / ABI\n// backwards incompatible change.\n//\n// For now, the API and ABI are simply unstable and can change at any time.\n//\n// TODO: don't hard code this in base-header.h.\n#define PUFFS_VERSION (0x00001)" + - "\n\n// puffs_base_buf1 is a 1-dimensional buffer (a pointer and length) plus\n// additional indexes into that buffer.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n} puffs_base_buf1;\n\n#endif // PUFFS_BASE_HEADER_H\n" + + "\n\n// puffs_base_buf1 is a 1-dimensional buffer (a pointer and length) plus\n// additional indexes into that buffer.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n} puffs_base_buf1;\n\n#endif // PUFFS_BASE_HEADER_H\n" + "" const baseImpl = "" + diff --git a/cmd/puffs-gen-c/main.go b/cmd/puffs-gen-c/main.go index 16923f6b..d950d8c6 100644 --- a/cmd/puffs-gen-c/main.go +++ b/cmd/puffs-gen-c/main.go @@ -77,9 +77,10 @@ var builtInStatuses = [...]string{ "error bad receiver", "error bad argument", "error constructor not called", - "error unexpected EOF", // Used if read_foo passed final == true. - "status short read", // Used if read_foo passed final == false. + "error unexpected EOF", // Used if reading when closed == true. + "status short read", // Used if reading when closed == false. "status short write", + "error closed for writes", } func init() { @@ -945,11 +946,9 @@ func (g *gen) writeCallSuspendibles(n *a.Expr, depth uint32) error { // TODO: delete these hacks that only matches "in.src.read_u8?()" etc. if isInSrcReadU8(g.tm, n) { // TODO: suspend coroutine state. - // - // TODO: choose error_unexpected_eof versus status_short_read based on - // src_final. - g.printf("if (%ssrc->ri >= %ssrc->wi) { status = puffs_%s_status_short_read;", - aPrefix, aPrefix, g.pkgName) + g.printf("if (%ssrc->ri >= %ssrc->wi) { status = "+ + "%ssrc->closed ? puffs_%s_error_unexpected_eof : puffs_%s_status_short_read;", + aPrefix, aPrefix, aPrefix, g.pkgName, g.pkgName) if g.perFunc.public && g.perFunc.suspendible { g.writes("goto cleanup0;") } else { @@ -965,6 +964,13 @@ func (g *gen) writeCallSuspendibles(n *a.Expr, depth uint32) error { // TODO: suspend coroutine state. // // TODO: don't assume that the argument is "this.stack[s:]". + g.printf("if (%sdst->closed) { status = puffs_%s_error_closed_for_writes;", aPrefix, g.pkgName) + if g.perFunc.public && g.perFunc.suspendible { + g.writes("goto cleanup0;") + } else { + g.writes("return status;") + } + g.writes("}\n") g.printf("if ((%sdst->len - %sdst->wi) < (sizeof(self->private_impl.f_stack) - v_s)) {", aPrefix, aPrefix) g.printf("status = puffs_%s_status_short_write;", g.pkgName) if g.perFunc.public && g.perFunc.suspendible { diff --git a/gen/c/gif.c b/gen/c/gif.c index 0fc5f450..918c785e 100644 --- a/gen/c/gif.c +++ b/gen/c/gif.c @@ -41,6 +41,7 @@ typedef struct { size_t len; // Length. size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. + bool closed; // No further writes are expected. } puffs_base_buf1; #endif // PUFFS_BASE_HEADER_H @@ -63,6 +64,7 @@ typedef enum { puffs_gif_error_unexpected_eof = -10 + 1, puffs_gif_status_short_read = -12, puffs_gif_status_short_write = -14, + puffs_gif_error_closed_for_writes = -16 + 1, puffs_gif_error_lzw_code_is_out_of_range = -256 + 1, puffs_gif_error_lzw_prefix_chain_is_cyclical = -258 + 1, } puffs_gif_status; @@ -111,8 +113,7 @@ void puffs_gif_lzw_decoder_set_literal_width(puffs_gif_lzw_decoder* self, puffs_gif_status puffs_gif_lzw_decoder_decode(puffs_gif_lzw_decoder* self, puffs_base_buf1* a_dst, - puffs_base_buf1* a_src, - bool a_src_final); + puffs_base_buf1* a_src); #ifdef __cplusplus } // extern "C" @@ -135,7 +136,7 @@ bool puffs_gif_status_is_error(puffs_gif_status s) { return s & 1; } -const char* puffs_gif_status_strings[10] = { +const char* puffs_gif_status_strings[11] = { "gif: ok", "gif: bad version", "gif: bad receiver", @@ -144,6 +145,7 @@ const char* puffs_gif_status_strings[10] = { "gif: unexpected EOF", "gif: short read", "gif: short write", + "gif: closed for writes", "gif: LZW code is out of range", "gif: LZW prefix chain is cyclical", }; @@ -151,11 +153,11 @@ const char* puffs_gif_status_strings[10] = { const char* puffs_gif_status_string(puffs_gif_status s) { s = -(s >> 1); if (0 <= s) { - if (s < 8) { + if (s < 9) { return puffs_gif_status_strings[s]; } - s -= 120; - if ((8 <= s) && (s < 10)) { + s -= 119; + if ((9 <= s) && (s < 11)) { return puffs_gif_status_strings[s]; } } @@ -231,8 +233,7 @@ void puffs_gif_lzw_decoder_set_literal_width(puffs_gif_lzw_decoder* self, puffs_gif_status puffs_gif_lzw_decoder_decode(puffs_gif_lzw_decoder* self, puffs_base_buf1* a_dst, - puffs_base_buf1* a_src, - bool a_src_final) { + puffs_base_buf1* a_src) { if (!self) { return puffs_gif_error_bad_receiver; } @@ -273,7 +274,8 @@ label_0_continue:; while (true) { while (v_n_bits < v_width) { if (a_src->ri >= a_src->wi) { - status = puffs_gif_status_short_read; + status = a_src->closed ? puffs_gif_error_unexpected_eof + : puffs_gif_status_short_read; goto cleanup0; } uint8_t t_0 = a_src->ptr[a_src->ri++]; @@ -322,6 +324,10 @@ label_0_continue:; if ((v_code == v_save_code) && v_use_save_code) { self->private_impl.f_stack[4095] = ((uint8_t)(v_c)); } + if (a_dst->closed) { + status = puffs_gif_error_closed_for_writes; + goto cleanup0; + } if ((a_dst->len - a_dst->wi) < (sizeof(self->private_impl.f_stack) - v_s)) { status = puffs_gif_status_short_write; diff --git a/gen/h/gif.h b/gen/h/gif.h index 525874fa..aaedf324 100644 --- a/gen/h/gif.h +++ b/gen/h/gif.h @@ -41,6 +41,7 @@ typedef struct { size_t len; // Length. size_t wi; // Write index. Invariant: wi <= len. size_t ri; // Read index. Invariant: ri <= wi. + bool closed; // No further writes are expected. } puffs_base_buf1; #endif // PUFFS_BASE_HEADER_H @@ -63,6 +64,7 @@ typedef enum { puffs_gif_error_unexpected_eof = -10 + 1, puffs_gif_status_short_read = -12, puffs_gif_status_short_write = -14, + puffs_gif_error_closed_for_writes = -16 + 1, puffs_gif_error_lzw_code_is_out_of_range = -256 + 1, puffs_gif_error_lzw_prefix_chain_is_cyclical = -258 + 1, } puffs_gif_status; @@ -111,8 +113,7 @@ void puffs_gif_lzw_decoder_set_literal_width(puffs_gif_lzw_decoder* self, puffs_gif_status puffs_gif_lzw_decoder_decode(puffs_gif_lzw_decoder* self, puffs_base_buf1* a_dst, - puffs_base_buf1* a_src, - bool a_src_final); + puffs_base_buf1* a_src); #ifdef __cplusplus } // extern "C" diff --git a/std/gif/decode_lzw.puffs b/std/gif/decode_lzw.puffs index f878c5ea..5a22e7c3 100644 --- a/std/gif/decode_lzw.puffs +++ b/std/gif/decode_lzw.puffs @@ -17,7 +17,7 @@ pub func lzw_decoder.set_literal_width(lw u32[2..8] = 8)() { this.literal_width = in.lw } -pub func lzw_decoder.decode?(dst ptr buf1, src ptr buf1, src_final bool)() { +pub func lzw_decoder.decode?(dst ptr buf1, src ptr buf1)() { // These variables don't change over the lifetime of this func. var clear_code u32[4..256] = (1 as u32) << this.literal_width var end_code u32[5..257] = clear_code + 1 @@ -41,7 +41,7 @@ pub func lzw_decoder.decode?(dst ptr buf1, src ptr buf1, src_final bool)() { post n_bits >= width, { assert n_bits < 12 via "a < b: a < c; c <= b"(c:width) - bits |= (in.src.read_u8?() as u32) << n_bits // TODO: read_u8 should take src_final. + bits |= (in.src.read_u8?() as u32) << n_bits n_bits += 8 } var code u32[..4095] = bits.low_bits(n:width) diff --git a/test/c/gif/basic.c b/test/c/gif/basic.c index d7e47e0e..2984c53f 100644 --- a/test/c/gif/basic.c +++ b/test/c/gif/basic.c @@ -22,8 +22,7 @@ void test_constructor_not_called() { puffs_gif_lzw_decoder dec; puffs_base_buf1 dst = {0}; puffs_base_buf1 src = {0}; - puffs_gif_status status = - puffs_gif_lzw_decoder_decode(&dec, &dst, &src, false); + puffs_gif_status status = puffs_gif_lzw_decoder_decode(&dec, &dst, &src); if (status != puffs_gif_error_constructor_not_called) { FAIL("status: got %d, want %d", status, puffs_gif_error_constructor_not_called); @@ -34,8 +33,7 @@ void test_bad_argument_null() { test_funcname = __func__; puffs_gif_lzw_decoder dec; puffs_gif_lzw_decoder_constructor(&dec, PUFFS_VERSION, 0); - puffs_gif_status status = - puffs_gif_lzw_decoder_decode(&dec, NULL, NULL, false); + puffs_gif_status status = puffs_gif_lzw_decoder_decode(&dec, NULL, NULL); if (status != puffs_gif_error_bad_argument) { FAIL("status: got %d, want %d", status, puffs_gif_error_bad_argument); } @@ -72,8 +70,7 @@ void test_bad_receiver() { test_funcname = __func__; puffs_base_buf1 dst = {0}; puffs_base_buf1 src = {0}; - puffs_gif_status status = - puffs_gif_lzw_decoder_decode(NULL, &dst, &src, false); + puffs_gif_status status = puffs_gif_lzw_decoder_decode(NULL, &dst, &src); if (status != puffs_gif_error_bad_receiver) { FAIL("status: got %d, want %d", status, puffs_gif_error_bad_receiver); } diff --git a/test/c/gif/gif.c b/test/c/gif/gif.c index d0668238..0c538d28 100644 --- a/test/c/gif/gif.c +++ b/test/c/gif/gif.c @@ -58,8 +58,7 @@ void test_lzw_decode() { puffs_gif_lzw_decoder dec; puffs_gif_lzw_decoder_constructor(&dec, PUFFS_VERSION, 0); puffs_gif_lzw_decoder_set_literal_width(&dec, literal_width); - puffs_gif_status status = - puffs_gif_lzw_decoder_decode(&dec, &got, &src, false); + puffs_gif_status status = puffs_gif_lzw_decoder_decode(&dec, &got, &src); if (status != puffs_gif_status_ok) { FAIL("status: got %d, want %d", status, puffs_gif_status_ok); goto cleanup1; diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index da35b166..e623583f 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -54,6 +54,10 @@ bool read_file(puffs_base_buf1* dst, const char* path) { FAIL("read_file: NULL argument"); return false; } + if (dst->closed) { + FAIL("read_file: dst buffer closed for writes"); + return false; + } FILE* f = fopen(path, "r"); if (!f) { FAIL("read_file(\"%s\"): %s (errno=%d)", path, strerror(errno), errno); @@ -83,6 +87,7 @@ bool read_file(puffs_base_buf1* dst, const char* path) { return false; } fclose(f); + dst->closed = true; return true; }