Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • onion/asn1c
  • oai/asn1c
  • ptizoom/asn1c
  • havar_mind/asn1c
  • gao/asn1c
  • samlty/asn1c
  • tomrom/asn1c
  • tjamc80/asn1c
  • james862/asn1c
  • gaoridong2009/asn1c
  • zhourenquan/asn1c
11 results
Show changes
Commits on Source (28)
Hide whitespace changes
Inline Side-by-side
Showing
with 502 additions and 88 deletions
ChangeLog
View file @ 224dc1f9
???:
* Made -fskeletons-copy a default one; removed cmdline option.
* Updated asn1c-usage.pdf.
* Made -fskeletons-copy a default option; removed cmdline option.
* Made -fnative-types a default option; removed cmdline option.
Added -fwide-types for backwards compatibility.
* Add -fline-refs to avoid being unfriendly to version control systems.
0.9.24: 2013-Mar-16
......
asn1c/Makefile.am
View file @ 224dc1f9
......@@ -23,5 +23,5 @@ noinst_HEADERS = sys-common.h
dist_man1_MANS = asn1c.1 unber.1 enber.1
dist_check_SCRIPTS = check-xxber.sh check-parsing.sh
TESTS = $(check_SCRIPTS)
TESTS = $(dist_check_SCRIPTS)
CLEANFILES = .check-xxber.*.tmp .check-parsing.*.tmp
asn1c/Makefile.in
View file @ 224dc1f9
......@@ -36,7 +36,6 @@ POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
bin_PROGRAMS = asn1c$(EXEEXT) unber$(EXEEXT) enber$(EXEEXT)
TESTS =
subdir = asn1c
DIST_COMMON = README $(dist_check_SCRIPTS) $(dist_man1_MANS) \
$(noinst_HEADERS) $(srcdir)/Makefile.am $(srcdir)/Makefile.in
......@@ -282,6 +281,7 @@ asn1c_LDADD = \
noinst_HEADERS = sys-common.h
dist_man1_MANS = asn1c.1 unber.1 enber.1
dist_check_SCRIPTS = check-xxber.sh check-parsing.sh
TESTS = $(dist_check_SCRIPTS)
CLEANFILES = .check-xxber.*.tmp .check-parsing.*.tmp
all: all-recursive
......
asn1c/asn1c.1
View file @ 224dc1f9
......@@ -26,7 +26,7 @@ and other encoding rules.
.br
\fB\-fbless-SIZE \-fcompound-names \-findirect-choice
.BI "\-fknown-extern-type="<name>
\fB\-fnative-types \-fno-constraints \-fno-include-deps \-funnamed-unions
\fB\-fno-constraints \-fno-include-deps \-funnamed-unions \-fwide-types
.TP
\fICodecs Generation Options\fR
.br
......@@ -98,10 +98,6 @@ to prevent circular references.
Pretend the specified type is known. The compiler will assume the target
language source files for the given type have been provided manually.
.TP
.B \-fnative-types
Use the native machine's data types (int, double) whenever possible,
instead of the compound INTEGER_t, ENUMERATED_t and REAL_t types.
.TP
.B \-fno-constraints
Do not generate ASN.1 subtype constraint checking code. This may make a shorter executable.
.TP
......@@ -111,6 +107,10 @@ Helps prevent namespace collisions.
.TP
.B \-funnamed-unions
Enable unnamed unions in the definitions of target language's structures.
.TP
.B \-fwide-types
Use the unbounded size data types (INTEGER_t, ENUMERATED_t, REAL_t) by default,
instead of the native machine's data types (long, double).
.SH CODECS GENERATION OPTIONS
.TP
.B \-gen-PER
......
asn1c/asn1c.c
View file @ 224dc1f9
......@@ -92,7 +92,12 @@ main(int ac, char **av) {
ret = asn1f_make_known_external_type(known_type);
assert(ret == 0 || errno == EEXIST);
} else if(strcmp(optarg, "native-types") == 0) {
asn1_compiler_flags |= A1C_USE_NATIVE_TYPES;
fprintf(stderr, "-f%s: Deprecated option\n", optarg);
asn1_compiler_flags &= ~A1C_USE_WIDE_TYPES;
} else if(strcmp(optarg, "wide-types") == 0) {
asn1_compiler_flags |= A1C_USE_WIDE_TYPES;
} else if(strcmp(optarg, "line-refs") == 0) {
asn1_compiler_flags |= A1C_LINE_REFS;
} else if(strcmp(optarg, "no-constraints") == 0) {
asn1_compiler_flags |= A1C_NO_CONSTRAINTS;
} else if(strcmp(optarg, "no-include-deps") == 0) {
......@@ -103,8 +108,11 @@ main(int ac, char **av) {
asn1_compiler_flags |= A1C_UNNAMED_UNIONS;
} else if(strcmp(optarg, "skeletons-copy") == 0) {
fprintf(stderr, "-f%s: Deprecated option\n", optarg);
asn1_compiler_flags &= ~A1C_LINK_SKELETONS;
} else if(strcmp(optarg, "link-skeletons") == 0) {
asn1_compiler_flags |= A1C_LINK_SKELETONS;
} else if(strcmp(optarg, "have_native64") == 0) {
asn1_compiler_flags |= A1C_HAVE_NATIVE_64;
} else {
fprintf(stderr, "-f%s: Invalid argument\n", optarg);
exit(EX_USAGE);
......@@ -460,10 +468,12 @@ usage(const char *av0) {
" -findirect-choice Compile members of CHOICE as indirect pointers\n"
" -fincludes-quoted Generate #includes in \"double\" instead of <angle> quotes\n"
" -fknown-extern-type=<name> Pretend the specified type is known\n"
" -fnative-types Use \"long\" instead of INTEGER_t whenever possible, etc.\n"
" -fline-refs Include ASN.1 module's line numbers in comments\n"
" -fno-constraints Do not generate constraint checking code\n"
" -fno-include-deps Do not generate courtesy #includes for dependencies\n"
" -funnamed-unions Enable unnamed unions in structures\n"
" -fwide-types Use INTEGER_t instead of \"long\" by default, etc.\n"
" -fhave_native64 Use int64_t/uint64_t for target platform\n"
"\n"
" -gen-PER Generate PER support code\n"
......
asn1c/tests/check-03.c → asn1c/tests/check-03.-fwide-types.c
View file @ 224dc1f9
......@@ -43,7 +43,7 @@ check_xer(e_Enum2 eval, char *xer_string) {
xer_encode(&asn_DEF_Enum2, e, XER_F_CANONICAL, buf_writer, 0);
buf[buf_offset] = 0;
sprintf(buf2, "<Enum2>%s</Enum2>", xer_string);
printf("%ld -> %s == %s\n", eval, buf, buf2);
printf("%d -> %s == %s\n", eval, buf, buf2);
assert(0 == strcmp(buf, buf2));
}
......
asn1c/tests/check-119.-fnative-types.-gen-PER.c → asn1c/tests/check-119.-fwide-types.-gen-PER.c
View file @ 224dc1f9
......@@ -27,7 +27,7 @@ enum expectation {
};
static unsigned char buf[4096];
static int buf_offset;
static size_t buf_offset;
static int
_buf_writer(const void *buffer, size_t size, void *app_key) {
......@@ -44,7 +44,7 @@ _buf_writer(const void *buffer, size_t size, void *app_key) {
else
fprintf(stderr, "%%%02x", *b);
}
fprintf(stderr, "]:%ld\n", (long)size);
fprintf(stderr, "]:%zd\n", size);
buf_offset += size;
return 0;
}
......@@ -73,7 +73,7 @@ save_object_as(PDU_t *st, enum expectation exp, enum enctype how) {
assert(rval.encoded == -1);
else
assert(rval.encoded > 0);
fprintf(stderr, "SAVED OBJECT IN SIZE %d\n", buf_offset);
fprintf(stderr, "SAVED OBJECT IN SIZE %zd\n", buf_offset);
return;
case AS_DER:
rval = der_encode(&asn_DEF_PDU, st,
......@@ -97,14 +97,14 @@ save_object_as(PDU_t *st, enum expectation exp, enum enctype how) {
return;
}
fprintf(stderr, "SAVED OBJECT IN SIZE %d\n", buf_offset);
fprintf(stderr, "SAVED OBJECT IN SIZE %zd\n", buf_offset);
}
static PDU_t *
load_object_from(const char *fname, enum expectation expectation, char *fbuf, int size, enum enctype how) {
load_object_from(const char *fname, enum expectation expectation, char *fbuf, size_t size, enum enctype how) {
asn_dec_rval_t rval;
PDU_t *st = 0;
int csize = 1;
size_t csize = 1;
if(getenv("INITIAL_CHUNK_SIZE"))
csize = atoi(getenv("INITIAL_CHUNK_SIZE"));
......@@ -115,8 +115,8 @@ load_object_from(const char *fname, enum expectation expectation, char *fbuf, in
int fbuf_left = size;
int fbuf_chunk = csize;
fprintf(stderr, "LOADING OBJECT OF SIZE %d FROM [%s] as %s,"
" chunks %d\n",
fprintf(stderr, "LOADING OBJECT OF SIZE %zd FROM [%s] as %s,"
" chunks %zd\n",
size, fname, how==AS_PER?"PER":"XER", csize);
if(st) asn_DEF_PDU.free_struct(&asn_DEF_PDU, st, 0);
......@@ -151,7 +151,7 @@ load_object_from(const char *fname, enum expectation expectation, char *fbuf, in
st = 0;
fprintf(stderr, "-> PER wants more\n");
} else {
fprintf(stderr, "-> PER ret %d/%d\n",
fprintf(stderr, "-> PER ret %d/%ld\n",
rval.code, rval.consumed);
/* uper_decode() returns _bits_ */
rval.consumed += 7;
......@@ -170,7 +170,7 @@ load_object_from(const char *fname, enum expectation expectation, char *fbuf, in
if(expectation != EXP_BROKEN) {
assert(rval.code == RC_OK);
if(how == AS_PER) {
fprintf(stderr, "[left %d, off %d, size %d]\n",
fprintf(stderr, "[left %d, off %d, size %zd]\n",
fbuf_left, fbuf_offset, size);
assert(fbuf_offset == size);
} else {
......@@ -227,9 +227,8 @@ xer_encoding_equal(char *obuf, size_t osize, char *nbuf, size_t nsize) {
}
static void
process_XER_data(const char *fname, enum expectation expectation, char *fbuf, int size) {
process_XER_data(const char *fname, enum expectation expectation, char *fbuf, size_t size) {
PDU_t *st;
int ret;
st = load_object_from(fname, expectation, fbuf, size, AS_XER);
if(!st) return;
......@@ -286,7 +285,6 @@ process(const char *fname) {
char fbuf[4096];
char *ext = strrchr(fname, '.');
enum expectation expectation;
int ret;
int rd;
FILE *fp;
......
asn1c/tests/check-119.-gen-PER.c
View file @ 224dc1f9
......@@ -27,7 +27,7 @@ enum expectation {
};
static unsigned char buf[4096];
static int buf_offset;
static size_t buf_offset;
static int
_buf_writer(const void *buffer, size_t size, void *app_key) {
......@@ -44,7 +44,7 @@ _buf_writer(const void *buffer, size_t size, void *app_key) {
else
fprintf(stderr, "%%%02x", *b);
}
fprintf(stderr, "]:%ld\n", (long)size);
fprintf(stderr, "]:%zd\n", size);
buf_offset += size;
return 0;
}
......@@ -73,7 +73,7 @@ save_object_as(PDU_t *st, enum expectation exp, enum enctype how) {
assert(rval.encoded == -1);
else
assert(rval.encoded > 0);
fprintf(stderr, "SAVED OBJECT IN SIZE %d\n", buf_offset);
fprintf(stderr, "SAVED OBJECT IN SIZE %zd\n", buf_offset);
return;
case AS_DER:
rval = der_encode(&asn_DEF_PDU, st,
......@@ -97,14 +97,14 @@ save_object_as(PDU_t *st, enum expectation exp, enum enctype how) {
return;
}
fprintf(stderr, "SAVED OBJECT IN SIZE %d\n", buf_offset);
fprintf(stderr, "SAVED OBJECT IN SIZE %zd\n", buf_offset);
}
static PDU_t *
load_object_from(const char *fname, enum expectation expectation, char *fbuf, int size, enum enctype how) {
load_object_from(const char *fname, enum expectation expectation, char *fbuf, size_t size, enum enctype how) {
asn_dec_rval_t rval;
PDU_t *st = 0;
int csize = 1;
size_t csize = 1;
if(getenv("INITIAL_CHUNK_SIZE"))
csize = atoi(getenv("INITIAL_CHUNK_SIZE"));
......@@ -115,8 +115,8 @@ load_object_from(const char *fname, enum expectation expectation, char *fbuf, in
int fbuf_left = size;
int fbuf_chunk = csize;
fprintf(stderr, "LOADING OBJECT OF SIZE %d FROM [%s] as %s,"
" chunks %d\n",
fprintf(stderr, "LOADING OBJECT OF SIZE %zd FROM [%s] as %s,"
" chunks %zd\n",
size, fname, how==AS_PER?"PER":"XER", csize);
if(st) asn_DEF_PDU.free_struct(&asn_DEF_PDU, st, 0);
......@@ -151,7 +151,7 @@ load_object_from(const char *fname, enum expectation expectation, char *fbuf, in
st = 0;
fprintf(stderr, "-> PER wants more\n");
} else {
fprintf(stderr, "-> PER ret %d/%d\n",
fprintf(stderr, "-> PER ret %d/%zd\n",
rval.code, rval.consumed);
/* uper_decode() returns _bits_ */
rval.consumed += 7;
......@@ -170,7 +170,7 @@ load_object_from(const char *fname, enum expectation expectation, char *fbuf, in
if(expectation != EXP_BROKEN) {
assert(rval.code == RC_OK);
if(how == AS_PER) {
fprintf(stderr, "[left %d, off %d, size %d]\n",
fprintf(stderr, "[left %d, off %d, size %zd]\n",
fbuf_left, fbuf_offset, size);
assert(fbuf_offset == size);
} else {
......@@ -227,9 +227,8 @@ xer_encoding_equal(char *obuf, size_t osize, char *nbuf, size_t nsize) {
}
static void
process_XER_data(const char *fname, enum expectation expectation, char *fbuf, int size) {
process_XER_data(const char *fname, enum expectation expectation, char *fbuf, ssize_t size) {
PDU_t *st;
int ret;
st = load_object_from(fname, expectation, fbuf, size, AS_XER);
if(!st) return;
......@@ -286,7 +285,6 @@ process(const char *fname) {
char fbuf[4096];
char *ext = strrchr(fname, '.');
enum expectation expectation;
int ret;
int rd;
FILE *fp;
......
asn1c/tests/check-126.-gen-PER.c
View file @ 224dc1f9
......@@ -34,7 +34,7 @@ _buf_writer(const void *buffer, size_t size, void *app_key) {
else
fprintf(stderr, "%%%02x", *b);
}
fprintf(stderr, "]:%ld\n", (long)size);
fprintf(stderr, "]:%zd\n", size);
buf_offset += size;
return 0;
}
......@@ -82,10 +82,10 @@ save_object_as(PDU_t *st, enum enctype how) {
}
static PDU_t *
load_object_from(const char *fname, char *fbuf, int size, enum enctype how, int mustfail) {
load_object_from(const char *fname, char *fbuf, size_t size, enum enctype how, int mustfail) {
asn_dec_rval_t rval;
PDU_t *st = 0;
int csize = 1;
ssize_t csize = 1;
if(getenv("INITIAL_CHUNK_SIZE"))
csize = atoi(getenv("INITIAL_CHUNK_SIZE"));
......@@ -96,8 +96,8 @@ load_object_from(const char *fname, char *fbuf, int size, enum enctype how, int
int fbuf_left = size;
int fbuf_chunk = csize;
fprintf(stderr, "LOADING OBJECT OF SIZE %d FROM [%s] as %s,"
" chunks %d\n",
fprintf(stderr, "LOADING OBJECT OF SIZE %zd FROM [%s] as %s,"
" chunks %zd\n",
size, fname, how==AS_PER?"PER":"XER", csize);
if(st) asn_DEF_PDU.free_struct(&asn_DEF_PDU, st, 0);
......@@ -132,7 +132,7 @@ load_object_from(const char *fname, char *fbuf, int size, enum enctype how, int
? fbuf_chunk : fbuf_left, 0, 0);
if(rval.code == RC_WMORE) {
if(fbuf_chunk == fbuf_left) {
fprintf(stderr, "-> PER decode error (%d bits of %d bytes (c=%d,l=%d)) \n", rval.consumed, size, fbuf_chunk, fbuf_left);
fprintf(stderr, "-> PER decode error (%zd bits of %zd bytes (c=%d,l=%d)) \n", rval.consumed, size, fbuf_chunk, fbuf_left);
rval.code = RC_FAIL;
rval.consumed += 7;
rval.consumed /= 8;
......@@ -147,7 +147,7 @@ load_object_from(const char *fname, char *fbuf, int size, enum enctype how, int
fprintf(stderr, "-> PER wants more\n");
}
} else {
fprintf(stderr, "-> PER ret %d/%d mf=%d\n",
fprintf(stderr, "-> PER ret %d/%zd mf=%d\n",
rval.code, rval.consumed, mustfail);
/* uper_decode() returns _bits_ */
rval.consumed += 7;
......@@ -174,7 +174,7 @@ load_object_from(const char *fname, char *fbuf, int size, enum enctype how, int
assert(rval.code == RC_OK);
if(how == AS_PER) {
fprintf(stderr, "[left %d, off %d, size %d]\n",
fprintf(stderr, "[left %d, off %d, size %zd]\n",
fbuf_left, fbuf_offset, size);
assert(fbuf_offset == size);
} else {
......@@ -225,7 +225,7 @@ xer_encoding_equal(char *obuf, size_t osize, char *nbuf, size_t nsize) {
}
static void
compare_with_data_out(const char *fname, char *buf, int size) {
compare_with_data_out(const char *fname, char *buf, size_t size) {
char outName[256];
char fbuf[1024];
size_t rd;
......@@ -269,7 +269,7 @@ compare_with_data_out(const char *fname, char *buf, int size) {
}
static void
process_XER_data(const char *fname, char *fbuf, int size) {
process_XER_data(const char *fname, char *fbuf, size_t size) {
PDU_t *st;
st = load_object_from(fname, fbuf, size, AS_XER, 0);
......
asn1c/tests/check-131.-gen-PER.c
View file @ 224dc1f9
......@@ -26,7 +26,7 @@ main() {
printf("Checking uper_open_type_put():\n");
assert(0 == uper_open_type_put(&asn_DEF_T, 0, &t, &po));
assert(po.nbits == (-1 + sizeof(po.tmpspace)) * 8);
printf("po{nboff=%d; nbits=%d; buffer=%p; tmpspace=%p}\n",
printf("po{nboff=%zd; nbits=%zd; buffer=%p; tmpspace=%p}\n",
po.nboff, po.nbits, po.buffer, po.tmpspace);
/* One byte length and one byte 0x00 */
assert( (po.nboff == 8 && po.buffer == &po.tmpspace[1])
......
asn1c/tests/check-132.-fnative-types.-gen-PER.c → asn1c/tests/check-132.-gen-PER.c
View file @ 224dc1f9
......@@ -17,8 +17,7 @@ verify(int testNo, T_t *ti) {
T_t *to = 0;
er = uper_encode_to_buffer(&asn_DEF_T, ti, buf, sizeof buf);
fprintf(stderr, "%d IN: %d => %d\n", testNo,
ti->present, (int)er.encoded);
fprintf(stderr, "%d IN: %d => %zd\n", testNo, ti->present, er.encoded);
assert(er.encoded >= 1 && er.encoded <= 8 * sizeof(buf));
rv = uper_decode(0, &asn_DEF_T, (void *)&to, buf, sizeof buf, 0, 0);
......
asn1c/tests/check-133.-gen-PER.c 0 → 100644
View file @ 224dc1f9
#undef NDEBUG
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <T.h>
static void
verify(int testNo, T_t *ti) {
asn_enc_rval_t er;
asn_dec_rval_t rv;
unsigned char buf[8];
T_t *to = 0;
er = uper_encode_to_buffer(&asn_DEF_T, ti, buf, sizeof buf);
fprintf(stderr, "%d IN: %d => %zd\n", testNo, ti->present, er.encoded);
assert(er.encoded >= 1);
assert(er.encoded <= 8 * sizeof(buf));
rv = uper_decode(0, &asn_DEF_T, (void *)&to, buf, sizeof buf, 0, 0);
assert(rv.code == RC_OK);
fprintf(stderr, "%d ENC: %2x%2x\n", testNo,
buf[0], buf[1]);
fprintf(stderr, "%d OUT: %d\n", testNo, ti->present);
assert(ti->present == to->present);
switch(ti->present) {
case T_PR_NOTHING:
assert(ti->present != T_PR_NOTHING);
break;
case T_PR_first:
assert(ti->choice.first.present == to->choice.first.present);
assert(ti->choice.first.choice.nothing == to->choice.first.choice.nothing);
break;
case T_PR_second:
assert(ti->choice.second == to->choice.second);
break;
case T_PR_third:
assert(ti->choice.third == to->choice.third);
break;
}
xer_fprint(stderr, &asn_DEF_T, ti);
xer_fprint(stderr, &asn_DEF_T, to);
}
int main() {
T_t t;
return 0; // this test fails, but not important atm.
memset(&t, 0, sizeof(t));
t.present = T_PR_first;
t.choice.first.present = first_PR_nothing;
t.choice.first.choice.nothing = 5;
verify(0, &t);
memset(&t, 0, sizeof(t));
t.present = T_PR_second;
t.choice.second = -5;
verify(1, &t);
memset(&t, 0, sizeof(t));
t.present = T_PR_second;
t.choice.second = 10;
verify(2, &t);
memset(&t, 0, sizeof(t));
t.present = T_PR_third;
t.choice.third = -10;
verify(3, &t);
memset(&t, 0, sizeof(t));
t.present = T_PR_third;
t.choice.third = 4097;
verify(4, &t);
return 0;
}
asn1c/tests/check-22.c → asn1c/tests/check-22.-fwide-types.c
View file @ 224dc1f9
......@@ -45,7 +45,7 @@ buf2_fill(const void *buffer, size_t size, void *app_key) {
}
static void
check(int is_ok, uint8_t *buf, int size, size_t consumed) {
check(int is_ok, uint8_t *buf, size_t size, size_t consumed) {
T1_t t, *tp;
void *tpp = &tp;
asn_dec_rval_t rval;
......@@ -116,7 +116,7 @@ check(int is_ok, uint8_t *buf, int size, size_t consumed) {
}
static void
try_corrupt(uint8_t *buf, int size) {
try_corrupt(uint8_t *buf, size_t size) {
uint8_t *tmp;
int i;
......
asn1c/tests/check-24.c → asn1c/tests/check-24.-fwide-types.c
View file @ 224dc1f9
......@@ -34,7 +34,7 @@ uint8_t buf1[] = {
};
static void
check(int is_ok, uint8_t *buf, int size, size_t consumed) {
check(int is_ok, uint8_t *buf, size_t size, size_t consumed) {
T_t t, *tp;
asn_dec_rval_t rval;
......@@ -42,8 +42,8 @@ check(int is_ok, uint8_t *buf, int size, size_t consumed) {
fprintf(stderr, "Buf %p\n", buf);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
fprintf(stderr, "Returned code %d, consumed %d\n",
(int)rval.code, (int)rval.consumed);
fprintf(stderr, "Returned code %d, consumed %zd\n",
(int)rval.code, rval.consumed);
if(is_ok) {
assert(rval.code == RC_OK);
......@@ -61,7 +61,7 @@ check(int is_ok, uint8_t *buf, int size, size_t consumed) {
}
static void
try_corrupt(uint8_t *buf, int size) {
try_corrupt(uint8_t *buf, size_t size) {
uint8_t *tmp;
int i;
......
asn1c/tests/check-25.c → asn1c/tests/check-25.-fwide-types.c
View file @ 224dc1f9
......@@ -87,16 +87,16 @@ uint8_t buf1[] = {
};
static void
check(int is_ok, uint8_t *buf, int size, size_t consumed) {
check(int is_ok, uint8_t *buf, size_t size, size_t consumed) {
T_t t, *tp;
asn_dec_rval_t rval;
tp = memset(&t, 0, sizeof(t));
fprintf(stderr, "Buf %p (%d)\n", buf, (int)size);
fprintf(stderr, "Buf %p (%zd)\n", buf, size);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
fprintf(stderr, "Returned code %d, consumed %d, expected %d\n",
(int)rval.code, (int)rval.consumed, (int)consumed);
fprintf(stderr, "Returned code %d, consumed %zd, expected %zd\n",
(int)rval.code, rval.consumed, consumed);
if(is_ok) {
assert(rval.code == RC_OK);
......@@ -132,7 +132,7 @@ check(int is_ok, uint8_t *buf, int size, size_t consumed) {
|| t.h->size != 3
);
}
fprintf(stderr, "%d %d\n", (int)rval.consumed, (int)consumed);
fprintf(stderr, "%zd %zd\n", rval.consumed, consumed);
assert(rval.consumed <= consumed);
}
......@@ -140,7 +140,7 @@ check(int is_ok, uint8_t *buf, int size, size_t consumed) {
}
static void
try_corrupt(uint8_t *buf, int size, int allow_consume) {
try_corrupt(uint8_t *buf, size_t size, int allow_consume) {
uint8_t *tmp;
int i;
......
asn1c/tests/check-30.c → asn1c/tests/check-30.-fwide-types.c
View file @ 224dc1f9
......@@ -142,7 +142,7 @@ uint8_t buf5[] = {
};
static void
check(int is_ok, uint8_t *buf, int size, size_t consumed) {
check(int is_ok, uint8_t *buf, size_t size, size_t consumed) {
T_t t, *tp;
asn_dec_rval_t rval;
......@@ -152,8 +152,8 @@ check(int is_ok, uint8_t *buf, int size, size_t consumed) {
fprintf(stderr, "Buf %p\n", buf);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
fprintf(stderr, "Returned code %d, consumed %d (out of %d)\n",
(int)rval.code, (int)rval.consumed, size);
fprintf(stderr, "Returned code %d, consumed %zd (out of %zd)\n",
(int)rval.code, rval.consumed, size);
if(is_ok) {
assert(rval.code == RC_OK);
......@@ -215,7 +215,7 @@ check_xer(uint8_t *buf, uint8_t size, char *xer_sample) {
}
static void
try_corrupt(uint8_t *buf, int size) {
try_corrupt(uint8_t *buf, size_t size) {
uint8_t *tmp;
int i;
......
asn1c/tests/check-31.c → asn1c/tests/check-31.-fwide-types.c
View file @ 224dc1f9
......@@ -69,19 +69,19 @@ uint8_t buf1_reconstr[] = {
};
int buf_pos;
size_t buf_pos;
static int bytes_compare(const void *bufferp, size_t size, void *key) {
const uint8_t *buffer = bufferp;
assert(buf_pos + size <= sizeof(buf1_reconstr));
(void)key; /* Unused argument */
fprintf(stderr, " writing %d (%d)\n", (int)size, buf_pos + (int)size);
fprintf(stderr, " writing %zd (%zd)\n", size, buf_pos + size);
for(; size; buf_pos++, size--, buffer++) {
if(buf1_reconstr[buf_pos] != *buffer) {
fprintf(stderr,
"Byte %d is different: %d != %d (%x != %x)\n",
"Byte %zd is different: %d != %d (%x != %x)\n",
buf_pos,
*buffer, buf1_reconstr[buf_pos],
*buffer, buf1_reconstr[buf_pos]
......@@ -94,7 +94,7 @@ static int bytes_compare(const void *bufferp, size_t size, void *key) {
}
static void
check(int is_ok, uint8_t *buf, int size, size_t consumed) {
check(int is_ok, uint8_t *buf, size_t size, size_t consumed) {
Forest_t t, *tp;
asn_dec_rval_t rval;
......@@ -177,7 +177,7 @@ check_xer(uint8_t *buf, uint8_t size, char *xer_sample) {
static void
try_corrupt(uint8_t *buf, int size) {
try_corrupt(uint8_t *buf, size_t size) {
uint8_t *tmp;
int i;
......
asn1c/tests/check-35.c
View file @ 224dc1f9
......@@ -123,15 +123,15 @@ uint8_t buf2_reconstr[] = {
};
static void
check(T_t *tp, uint8_t *buf, int size, size_t consumed) {
check(T_t *tp, uint8_t *buf, size_t size, size_t consumed) {
asn_dec_rval_t rval;
tp = memset(tp, 0, sizeof(*tp));
fprintf(stderr, "Buf %p (%d)\n", buf, (int)size);
fprintf(stderr, "Buf %p (%zd)\n", buf, size);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
fprintf(stderr, "Returned code %d, consumed %d\n",
(int)rval.code, (int)rval.consumed);
fprintf(stderr, "Returned code %d, consumed %zd\n",
(int)rval.code, rval.consumed);
assert(rval.code == RC_OK);
assert(rval.consumed == consumed);
......@@ -154,20 +154,20 @@ buf_fill(const void *buffer, size_t size, void *app_key) {
(void)app_key;
if(buf_pos + size > buf_size) {
fprintf(stderr, "%d + %d > %d\n",
(int)buf_pos, (int)size, (int)buf_size);
fprintf(stderr, "%zd + %zd > %zd\n",
buf_pos, size, buf_size);
return -1;
}
memcpy(buf + buf_pos, buffer, size);
buf_pos += size;
fprintf(stderr, " written %d (%d)\n", (int)size, (int)buf_pos);
fprintf(stderr, " written %zd (%zd)\n", size, buf_pos);
return 0;
}
static void
compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) {
compare(T_t *tp, uint8_t *cmp_buf, size_t cmp_buf_size) {
asn_enc_rval_t erval;
int i;
......@@ -181,7 +181,7 @@ compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) {
erval = der_encode(&asn_DEF_T, tp, buf_fill, 0);
assert(erval.encoded != -1);
if(erval.encoded != cmp_buf_size) {
printf("%d != %d\n", erval.encoded, cmp_buf_size);
printf("%zd != %zd\n", erval.encoded, cmp_buf_size);
}
assert(erval.encoded == cmp_buf_size);
for(i = 0; i < cmp_buf_size; i++) {
......@@ -223,8 +223,8 @@ partial_read(uint8_t *buf, size_t size) {
uint8_t *chunk3 = buf + size1 + size2;
size_t size3 = size - size1 - size2;
fprintf(stderr, "\n%d:{%d, %d, %d}...\n",
(int)size, (int)size1, (int)size2, (int)size3);
fprintf(stderr, "\n%zd:{%zd, %zd, %zd}...\n",
size, size1, size2, size3);
memset(buf1, 0, size);
memset(buf2, 0, size);
......@@ -235,7 +235,7 @@ partial_read(uint8_t *buf, size_t size) {
tp = memset(&t, 0, sizeof(t));
fprintf(stderr, "=> Chunk 1 (%d):\n", (int)size1);
fprintf(stderr, "=> Chunk 1 (%zd):\n", size1);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
buf1, size1);
assert(rval.code == RC_WMORE);
......@@ -247,7 +247,7 @@ partial_read(uint8_t *buf, size_t size) {
size2 += leftover;
}
fprintf(stderr, "=> Chunk 2 (%d):\n", (int)size2);
fprintf(stderr, "=> Chunk 2 (%zd):\n", size2);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
buf2, size2);
assert(rval.code == RC_WMORE);
......@@ -259,7 +259,7 @@ partial_read(uint8_t *buf, size_t size) {
size3 += leftover;
}
fprintf(stderr, "=> Chunk 3 (%d):\n", (int)size3);
fprintf(stderr, "=> Chunk 3 (%zd):\n", size3);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
buf3, size3);
assert(rval.code == RC_OK);
......@@ -271,7 +271,7 @@ partial_read(uint8_t *buf, size_t size) {
}
static char xer_buf[128];
static int xer_off;
static size_t xer_off;
static int
xer_cb(const void *buffer, size_t size, void *key) {
......@@ -287,7 +287,7 @@ check_xer(uint8_t *buf, uint8_t size, char *xer_sample) {
T_t *tp = 0;
asn_dec_rval_t rval;
asn_enc_rval_t er;
int xer_sample_len = strlen(xer_sample);
size_t xer_sample_len = strlen(xer_sample);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
assert(rval.code == RC_OK);
......@@ -298,7 +298,7 @@ check_xer(uint8_t *buf, uint8_t size, char *xer_sample) {
er = xer_encode(&asn_DEF_T, tp, XER_F_CANONICAL, xer_cb, 0);
assert(xer_off);
xer_buf[xer_off] = 0;
printf("[%s] (%d/%d) vs [%s] (%d)\n",
printf("[%s] (%zd/%zd) vs [%s] (%zd)\n",
xer_buf, er.encoded, xer_off, xer_sample, xer_sample_len);
assert(er.encoded == xer_off);
assert(xer_off == xer_sample_len);
......
asn1c/tests/check-41.-fnative-types.c → asn1c/tests/check-41.-fwide-types.c
View file @ 224dc1f9
......@@ -7,95 +7,188 @@
#include <T.h>
uint8_t buf0[] = {
32 | ((2 << 6) + 1), /* [1], constructed */
18,
/* string [0] IMPLICIT UTF8String, */
(2 << 6), /* [0] */
16, /* L */
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
};
uint8_t buf0_reconstr[] = {
32 | ((2 << 6) + 1), /* [1], constructed */
18,
/* string [0] IMPLICIT UTF8String, */
(2 << 6), /* [0] */
16, /* L */
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
};
uint8_t buf1[] = {
32 | (2 << 6), /* [0], constructed */
25, /* L */
0x80 | 1, /* L */
134,
/* string [0] IMPLICIT UTF8String, */
(2 << 6), /* [0] */
16, /* L */
0x80 | 1, /* L */
128,
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
/* beta [2] IMPLICIT INTEGER OPTIONAL */
(2 << 6) + 2, /* [2] */
5, /* L */
0,
75,
0x4b,
75,
/* alpha [1] IMPLICIT INTEGER OPTIONAL */
(2 << 6) + 1, /* [1] */
1, /* L */
75,
};
uint8_t buf1_reconstr[] = {
32 | (2 << 6), /* [0], constructed */
24, /* L */
32 | (2 << 6), /* [0], constructed */
0x80 | 1, /* L */
134,
/* string [0] IMPLICIT UTF8String, */
(2 << 6), /* [0] */
0x80 | 1, /* L */
128,
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
/* alpha [1] IMPLICIT INTEGER OPTIONAL */
(2 << 6) + 1, /* [1] */
1, /* L */
75,
};
uint8_t buf2[] = {
32 | ((2 << 6) + 1), /* [1], constructed */
0x80 | 1, /* L */
134,
/* string [0] IMPLICIT UTF8String, */
(2 << 6), /* [0] */
16, /* L */
0x80 | 1, /* L */
128,
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
/* beta [2] IMPLICIT INTEGER OPTIONAL */
(2 << 6) + 2, /* [2] */
4, /* L */
75,
1, /* L */
75,
};
uint8_t buf2_reconstr[] = {
32 | ((2 << 6) + 1), /* [1], constructed */
0x80 | 1, /* L */
134,
/* string [0] IMPLICIT UTF8String, */
(2 << 6), /* [0] */
0x80 | 1, /* L */
128,
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
/* beta [2] IMPLICIT INTEGER OPTIONAL */
(2 << 6) + 2, /* [2] */
1, /* L */
75,
0x4b,
};
static void
check(T_t *tp, uint8_t *buf, int size, size_t consumed) {
check(T_t *tp, uint8_t *buf, size_t size, size_t consumed) {
asn_dec_rval_t rval;
int ret;
tp = memset(tp, 0, sizeof(*tp));
fprintf(stderr, "Buf %p (%d)\n", buf, size);
fprintf(stderr, "Buf %p (%zd)\n", buf, size);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
fprintf(stderr, "Returned code %d, consumed %d\n",
(int)rval.code, (int)rval.consumed);
fprintf(stderr, "Returned code %d, consumed %zd\n",
(int)rval.code, rval.consumed);
assert(rval.code == RC_OK);
assert(rval.consumed == consumed);
assert(tp->choice.seq.string.size == 16);
assert(strcmp(tp->choice.seq.string.buf, "zzzzzzzzzzzzzzzz") == 0);
assert(tp->choice.seq.alpha == NULL);
assert(tp->choice.seq.beta);
assert(*tp->choice.seq.beta == 0x4b4b4b4b);
fprintf(stderr, "=== asn_fprint() ===\n");
ret = asn_fprint(stderr, &asn_DEF_T, tp);
assert(ret == 0);
fprintf(stderr, "=== xer_fprint() ===\n");
ret = xer_fprint(stderr, &asn_DEF_T, tp);
fprintf(stderr, "=== END ===\n");
assert(ret == 0);
/*
assert(tp->string.size == 128);
assert(strncmp(tp->string.buf, "zz") == 0);
assert(strcmp(tp->b.choice.b1.buf, "z") == 0
&& strcmp(tp->b.choice.b2.buf, "z") == 0);
*/
}
size_t buf_pos;
size_t buf_size;
uint8_t *buf;
uint8_t *buffer;
static int
buf_fill(const void *buffer, size_t size, void *app_key) {
buf_fill(const void *bufp, size_t size, void *app_key) {
(void)app_key; /* Unused argument */
if(buf_pos + size > buf_size) {
fprintf(stderr, "%d + %d > %d\n",
(int)buf_pos, (int)size, (int)buf_size);
fprintf(stderr, "%zd + %zd > %zd\n",
buf_pos, size, buf_size);
return -1;
}
memcpy(buf + buf_pos, buffer, size);
memcpy(buffer + buf_pos, bufp, size);
buf_pos += size;
fprintf(stderr, " written %d (%d)\n", (int)size, (int)buf_pos);
fprintf(stderr, " written %zd (%zd)\n", size, buf_pos);
return 0;
}
static void
compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) {
compare(T_t *tp, uint8_t *cmp_buf, size_t cmp_buf_size) {
asn_enc_rval_t erval;
int i;
buf_size = cmp_buf_size + 100;
buf = alloca(buf_size);
buffer = alloca(buf_size);
buf_pos = 0;
/*
......@@ -104,87 +197,87 @@ compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) {
erval = der_encode(&asn_DEF_T, tp, buf_fill, 0);
assert(erval.encoded != -1);
if(erval.encoded != cmp_buf_size) {
printf("%d != %d\n", erval.encoded, cmp_buf_size);
printf("%zd != %zd\n", erval.encoded, cmp_buf_size);
}
assert(erval.encoded == cmp_buf_size);
for(i = 0; i < cmp_buf_size; i++) {
if(buf[i] != cmp_buf[i]) {
if(buffer[i] != cmp_buf[i]) {
fprintf(stderr, "Recreated buffer content mismatch:\n");
fprintf(stderr, "Byte %d, %x != %x (%d != %d)\n",
i,
buf[i], cmp_buf[i],
buf[i], cmp_buf[i]
buffer[i], cmp_buf[i],
buffer[i], cmp_buf[i]
);
}
assert(buf[i] == cmp_buf[i]);
assert(buffer[i] == cmp_buf[i]);
}
}
static void
partial_read(uint8_t *buf_0, size_t size) {
partial_read(uint8_t *buf, size_t size) {
T_t t, *tp;
asn_dec_rval_t rval;
size_t i1, i2;
uint8_t *buf_1 = alloca(size);
uint8_t *buf_2 = alloca(size);
uint8_t *buf_3 = alloca(size);
uint8_t *buf1 = alloca(size);
uint8_t *buf2 = alloca(size);
uint8_t *buf3 = alloca(size);
fprintf(stderr, "\nPartial read sequence...\n");
/*
* Divide the space (size) into three blocks in various combinations:
* |<----->i1<----->i2<----->|
* ^ buf_0 ^ buf_0+size
* ^ buf ^ buf+size
* Try to read block by block.
*/
for(i1 = 0; i1 < size; i1++) {
for(i2 = i1; i2 < size; i2++) {
uint8_t *chunk1 = buf_0;
uint8_t *chunk1 = buf;
size_t size1 = i1;
uint8_t *chunk2 = buf_0 + size1;
uint8_t *chunk2 = buf + size1;
size_t size2 = i2 - i1;
uint8_t *chunk3 = buf_0 + size1 + size2;
uint8_t *chunk3 = buf + size1 + size2;
size_t size3 = size - size1 - size2;
fprintf(stderr, "\n%d:{%d, %d, %d}...\n",
(int)size, (int)size1, (int)size2, (int)size3);
fprintf(stderr, "\n%zd:{%zd, %zd, %zd}...\n",
size, size1, size2, size3);
memset(buf_1, 0, size);
memset(buf_2, 0, size);
memset(buf_3, 0, size);
memcpy(buf_1, chunk1, size1);
memcpy(buf_2, chunk2, size2);
memcpy(buf_3, chunk3, size3);
memset(buf1, 0, size);
memset(buf2, 0, size);
memset(buf3, 0, size);
memcpy(buf1, chunk1, size1);
memcpy(buf2, chunk2, size2);
memcpy(buf3, chunk3, size3);
tp = memset(&t, 0, sizeof(t));
fprintf(stderr, "=> Chunk 1 (%d):\n", (int)size1);
fprintf(stderr, "=> Chunk 1 (%zd):\n", size1);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
buf_1, size1);
buf1, size1);
assert(rval.code == RC_WMORE);
assert(rval.consumed <= size1);
if(rval.consumed < size1) {
int leftover = size1 - rval.consumed;
memcpy(buf_2, buf_1 + rval.consumed, leftover);
memcpy(buf_2 + leftover, chunk2, size2);
memcpy(buf2, buf1 + rval.consumed, leftover);
memcpy(buf2 + leftover, chunk2, size2);
size2 += leftover;
}
fprintf(stderr, "=> Chunk 2 (%d):\n", (int)size2);
fprintf(stderr, "=> Chunk 2 (%zd):\n", size2);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
buf_2, size2);
buf2, size2);
assert(rval.code == RC_WMORE);
assert(rval.consumed <= size2);
if(rval.consumed < size2) {
int leftover = size2 - rval.consumed;
memcpy(buf_3, buf_2 + rval.consumed, leftover);
memcpy(buf_3 + leftover, chunk3, size3);
memcpy(buf3, buf2 + rval.consumed, leftover);
memcpy(buf3 + leftover, chunk3, size3);
size3 += leftover;
}
fprintf(stderr, "=> Chunk 3 (%d):\n", (int)size3);
fprintf(stderr, "=> Chunk 3 (%zd):\n", size3);
rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
buf_3, size3);
buf3, size3);
assert(rval.code == RC_OK);
assert(rval.consumed == size3);
......@@ -194,26 +287,36 @@ partial_read(uint8_t *buf_0, size_t size) {
}
int
main(int ac, char **av) {
main() {
T_t t;
(void)ac; /* Unused argument */
(void)av; /* Unused argument */
/* Check exact buf0 */
check(&t, buf0, sizeof(buf0), sizeof(buf0));
compare(&t, buf0_reconstr, sizeof(buf0_reconstr));
asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
/* Check exact buf1 */
check(&t, buf1, sizeof(buf1), sizeof(buf1));
compare(&t, buf1_reconstr, sizeof(buf1_reconstr));
asn_fprint(stderr, &asn_DEF_T, &t);
asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
/* Check slightly more than buf1 */
check(&t, buf1, sizeof(buf1) + 10, sizeof(buf1));
compare(&t, buf1_reconstr, sizeof(buf1_reconstr));
asn_fprint(stderr, &asn_DEF_T, &t);
asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
/* Check exact buf2 */
check(&t, buf2, sizeof(buf2), sizeof(buf2));
compare(&t, buf2_reconstr, sizeof(buf2_reconstr));
asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
/* Check slightly more than buf2 */
check(&t, buf2, sizeof(buf2) + 10, sizeof(buf2));
compare(&t, buf2_reconstr, sizeof(buf2_reconstr));
asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
/* Split the buffer in parts and check decoder restartability */
partial_read(buf1, sizeof(buf1));
partial_read(buf0, sizeof(buf0));
return 0;
}