cmp.diff *** asn_src_0.9.21/asn1p_expr.c 2006-09-17 10:38:42.000000000 +0800 --- asn_modefy_0.9.21/asn1p_expr.c 2009-08-07 16:29:22.000000000 +0800 *************** *** 210,215 **** --- 210,249 ---- */ void asn1p_expr_add(asn1p_expr_t *to, asn1p_expr_t *what) { + if (((to->expr_type == ASN_CONSTR_SET_OF) || + (to->expr_type == ASN_CONSTR_SEQUENCE_OF)) + && + (((what->expr_type & ASN_CONSTR_MASK) != 0) && + (what->expr_type != A1TC_REFERENCE) && (what->Identifier == 0))) + { + /* we have a set of/sequence of an inline constructed type + Change the inline type to a generated type reference. + + A generated type name is an illegal type name, so we + don't have to worry about the typename showing up in the + original asn1. + */ + char buf[256]; + asn1p_expr_t* expr_ref; + + /* first change the inline type to a named type */ + snprintf(buf, 256, "asn1c_gentype_%u", asn1p_incr_gencounter()); + what->Identifier = strdup(buf); + + /* Add the type to the module */ + /* tq_add_expr(&TQ_TAILPTR(&(what->module->members)), what);*/ + TQ_ADD(&(what->module->members), what, next); + + + /* now create the reference */ + expr_ref = asn1p_expr_new(what->_lineno, what->module); + expr_ref->reference = asn1p_ref_new(what->_lineno); + expr_ref->expr_type = A1TC_REFERENCE; + expr_ref->meta_type = AMT_TYPEREF; + asn1p_ref_add_component(expr_ref->reference, what->Identifier, RLT_lowercase); + /* now set 'what' to the reference */ + what = expr_ref; + } TQ_ADD(&(to->members), what, next); what->parent_expr = to; } *** asn_src_0.9.21/asn1p_y.y 2006-09-17 10:37:22.000000000 +0800 --- asn_modefy_0.9.21/asn1p_y.y 2009-08-07 17:09:23.000000000 +0800 *************** *** 550,556 **** checkmem($$); assert($1->expr_type != A1TC_INVALID); assert($1->meta_type != AMT_INVALID); ! TQ_ADD(&($$->members), $1, next); } | ValueDefinition { $$ = asn1p_module_new(); --- 550,561 ---- checkmem($$); assert($1->expr_type != A1TC_INVALID); assert($1->meta_type != AMT_INVALID); ! /* In case we generated any types for SET OF or ! SEQUENCE OF */ ! //al_import_members($$, $1->module); ! AL_IMPORT($$, members, $1->module, next); ! TQ_ADD(&($$->members), $1, next); ! //tq_add_expr(&TQ_TAILPTR(&($$->members)), $1); } | ValueDefinition { $$ = asn1p_module_new(); *** asn_src_0.9.21/asn1parser.c 2006-09-17 10:31:30.000000000 +0800 --- asn_modefy_0.9.21/asn1parser.c 2009-08-07 16:06:33.000000000 +0800 *************** *** 9,14 **** --- 9,18 ---- #include "asn1parser.h" #include "asn1p_list.h" + /* A generic counter used to uniquify names. It only increases. It + will overflow if the more than 32 bits are needed */ + static unsigned sGenCounter = 0; + int asn1p_parse(void **param); void *asn1p__scan_bytes(const char *, int len); *************** *** 181,183 **** --- 185,191 ---- return errno == 0 ? 0 : -1; } + unsigned asn1p_incr_gencounter(void) + { + return sGenCounter++; + } *** asn_src_0.9.21/asn1parser.h 2006-03-21 11:40:38.000000000 +0800 --- asn_modefy_0.9.21/asn1parser.h 2009-08-07 16:07:36.000000000 +0800 *************** *** 71,74 **** --- 71,77 ---- int asn1p_atoi(const char *ptr, asn1c_integer_t *r_value); + /* returns the current value of the gen counter and increments the + internal counter. */ + unsigned asn1p_incr_gencounter(void); #endif /* ASN1PARSER_H */ asn_copy.h #ifndef _asn_copy_H #define _asn_copy_H #include <asn_codecs_prim.h> #ifdef __cplusplus extern "C" { #endif int jhxasncopy(void **des_struct_ptr,void *struct_ptr,asn_TYPE_descriptor_t *td); #ifdef __cplusplus } #endif #endif asn_copy.c #include <asn_copy.h> #include <der_encoder.h> #include <ber_decoder.h> #include <constr_TYPE.h> #include <asn_codecs.h> #include <constr_TYPE.h> #define copybuf 100000 int jhxasncopy(void **des_sptr,void *sptr,asn_TYPE_descriptor_t *td){ int i; asn_enc_rval_t ec; asn_dec_rval_t de; unsigned char buf[copybuf]; ec = der_encode_to_buffer(td,sptr,buf,sizeof(buf)); if(ec.encoded != -1) { printf("DER copy encoded successful."); /*printf("DER encoded in %d bytes: /n", ec.encoded); for (i = 0; i < ec.encoded; i++) { printf("%x ", buf[i]); }*/ printf("/n"); } else { printf("DER copy encoded failed. /n"); return -1; } de = ber_decode(NULL,td,des_sptr, buf, ec.encoded); if(de.code == RC_OK && des_sptr) { printf("BER copy decoded successful. /n"); } else { ASN_STRUCT_FREE(*td, des_sptr); printf("BER decode failed. /n"); return -1; } } xer_encode_to_buffer.h #ifndef _xer_encode_to_buffer_H_ #define _xer_encode_to_buffer_H_ #include <stdio.h> #include <stdlib.h> #include "INTEGER.h" #include "xer_encoder.h" #include "asn_codecs.h" #include "xer_decoder.h" #include "asn_system.h" typedef struct enc_to_buf_arg { void *buffer; size_t left; } enc_to_buf_arg_t; int encode_to_buffer_cb(const void *buffer, size_t size, void *key); asn_enc_rval_t xer_encode_to_buffer(asn_TYPE_descriptor_t *td, void *sptr, void *buffer, size_t buffer_size); #endif xer_encode_to_buffer.c #include "xer_encode_to_buffer.h" #include "constr_TYPE.h" int encode_to_buffer_cb(const void *buffer, size_t size, void *key){ enc_to_buf_arg_t *arg = (enc_to_buf_arg_t *)key; if(arg->left < size) return -1; /* Data exceeds the available buffer size */ memcpy(arg->buffer, buffer, size); arg->buffer = ((char *)arg->buffer) + size; arg->left -= size; return 0; } asn_enc_rval_t xer_encode_to_buffer(asn_TYPE_descriptor_t *td, void *sptr, void *buffer, size_t buffer_size){ enc_to_buf_arg_t arg; asn_enc_rval_t ec; arg.buffer = buffer; arg.left = buffer_size; if(!td || !sptr) { ec.encoded = -1; return ec; } ec = xer_encode(td, sptr, XER_F_BASIC, encode_to_buffer_cb, &arg); if(ec.encoded != -1){ // assert(ec.encoded == (ssize_t)(buffer_size - arg.left)); /* Return the encoded contents size */ } return ec; }