static int
dump_rite_header(mrb_state *mrb, int top, FILE* fp, uint32_t rbds)
{
rite_binary_header binary_header;
rite_file_header file_header;
uint16_t crc;
int type;
if (fseek(fp, 0, SEEK_SET) != 0)
return MRB_DUMP_GENERAL_FAILURE;
/* calc crc */
memcpy( &binary_header, def_rite_binary_header, sizeof(binary_header));
type = DUMP_TYPE_BIN;
uint32_dump(rbds, (char*)&binary_header.rbds, type);
uint16_dump((uint16_t)mrb->irep_len, (char*)&binary_header.nirep, type);
uint16_dump((uint16_t)top, (char*)&binary_header.sirep, type);
crc = calc_crc_16_ccitt((unsigned char*)&binary_header, sizeof(binary_header));
/* dump rbc header */
memcpy( &file_header, def_rite_file_header, sizeof(file_header));
type = DUMP_TYPE_HEX;
uint32_dump(rbds, (char*)&file_header.rbds, type);
uint16_dump((uint16_t)mrb->irep_len, (char*)&file_header.nirep, type);
uint16_dump((uint16_t)top, (char*)&file_header.sirep, type);
uint16_dump(crc, (char*)&file_header.hcrc, type);
if (fwrite(&file_header, sizeof(file_header), 1, fp) != 1)
return MRB_DUMP_WRITE_FAULT;
return MRB_DUMP_OK;
}
static uint16_t
calc_rite_header_crc(mrb_state *mrb, int top, rite_binary_header *binary_header, uint32_t rbds, int type)
{
memcpy( binary_header, def_rite_binary_header, sizeof(*binary_header));
uint32_dump(rbds, (char*)binary_header->rbds, type);
uint16_dump((uint16_t)mrb->irep_len, (char*)binary_header->nirep, type);
uint16_dump((uint16_t)top, (char*)binary_header->sirep, type);
return calc_crc_16_ccitt((unsigned char*)binary_header, sizeof(*binary_header));
}
static int
write_irep_header(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
{
char *buf_top = buf;
*buf++ = RITE_IREP_IDENFIFIER; /* record identifier */
*buf++ = RITE_IREP_TYPE_CLASS; /* class or module */
buf += uint16_dump((uint16_t)irep->nlocals, buf, type); /* number of local variable */
buf += uint16_dump((uint16_t)irep->nregs, buf, type); /* number of register variable */
buf += uint16_dump(DUMP_SIZE(MRB_DUMP_SIZE_OF_SHORT, type)/* crc */, buf, type); /* offset of isec block */
return (int)(buf - buf_top);
}
static int
write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
{
int sym_no;
char *buf_top = buf;
char *char_buf;
uint16_t buf_size =0;
buf_size = MRB_DUMP_DEFAULT_STR_LEN;
char_buf = (char *)mrb_malloc(mrb, buf_size);
if (char_buf == NULL)
goto error_exit;
buf += uint32_dump((uint32_t)irep->slen, buf, type); /* number of symbol */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
const char * name;
uint16_t nlen =0;
if (irep->syms[sym_no] != 0) {
size_t len;
name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
if (len > UINT16_MAX) goto error_exit;
nlen = str_dump_len((char*)name, len, type);
if ( nlen > buf_size - 1) {
buf_size = nlen + 1;
char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size);
if (char_buf == NULL)
goto error_exit;
}
memset(char_buf, 0, buf_size);
str_dump((char*)name, char_buf, len, type);
buf += uint16_dump(nlen, buf, type); /* length of symbol name */
memcpy(buf, char_buf, nlen); /* symbol name */
buf += nlen;
}
else {
buf += uint16_dump(MRB_DUMP_NULL_SYM_LEN, buf, type); /* length of symbol name */
}
}
error_exit:
mrb_free(mrb, char_buf);
return (int)(buf - buf_top);
}
static int
write_rite_header(mrb_state *mrb, int top, char* bin, uint32_t rbds)
{
rite_binary_header *binary_header;
uint16_t crc;
int type = DUMP_TYPE_BIN;
binary_header = (rite_binary_header*)bin;
memcpy( binary_header, def_rite_binary_header, sizeof(*binary_header));
uint32_dump(rbds, (char*)binary_header->rbds, type);
uint16_dump((uint16_t)mrb->irep_len, (char*)binary_header->nirep, type);
uint16_dump((uint16_t)top, (char*)binary_header->sirep, type);
crc = calc_crc_16_ccitt((unsigned char*)binary_header, sizeof(*binary_header));
bin += sizeof(*binary_header);
uint16_dump(crc, bin, type);
return MRB_DUMP_OK;
}
static int
calc_rite_file_header(mrb_state *mrb, int top, uint32_t rbds, rite_file_header *file_header)
{
rite_binary_header *binary_header, b_header;
uint16_t crc;
int type;
/* calc crc */
type = DUMP_TYPE_BIN;
binary_header = &b_header;
crc = calc_rite_header_crc(mrb, top, binary_header, rbds, type);
/* dump rbc header */
memcpy( file_header, def_rite_file_header, sizeof(*file_header));
type = DUMP_TYPE_HEX;
uint32_dump(rbds, (char*)file_header->rbds, type);
uint16_dump((uint16_t)mrb->irep_len, (char*)file_header->nirep, type);
uint16_dump((uint16_t)top, (char*)file_header->sirep, type);
uint16_dump(crc, (char*)file_header->hcrc, type);
return MRB_DUMP_OK;
}
static int
write_rite_header(mrb_state *mrb, int top, char* bin, uint32_t rbds)
{
rite_binary_header *binary_header;
uint16_t crc;
int type = DUMP_TYPE_BIN;
binary_header = (rite_binary_header*)bin;
crc = calc_rite_header_crc(mrb, top, binary_header, rbds, type);
bin += sizeof(*binary_header);
uint16_dump(crc, bin, type);
return MRB_DUMP_OK;
}
static int
write_irep_record(mrb_state *mrb, int irep_no, char* bin, uint32_t *rlen, int type)
{
uint32_t irep_record_size;
mrb_irep *irep = mrb->irep[irep_no];
int section;
if (irep == NULL)
return MRB_DUMP_INVALID_IREP;
/* buf alloc */
irep_record_size = get_irep_record_size(mrb, irep_no, type);
if (irep_record_size == 0)
return MRB_DUMP_GENERAL_FAILURE;
memset( bin, 0, irep_record_size);
/* rlen */
*rlen = irep_record_size - DUMP_SIZE(MRB_DUMP_SIZE_OF_LONG, type);
bin += uint32_dump(*rlen, bin, type);
for (section = 0; section < DUMP_SECTION_NUM; section++) {
int rc;
uint16_t crc;
switch (section) {
case DUMP_IREP_HEADER: bin += write_irep_header(mrb, irep, bin, type); break;
case DUMP_ISEQ_BLOCK: bin += write_iseq_block(mrb, irep, bin, type); break;
case DUMP_POOL_BLOCK: bin += write_pool_block(mrb, irep, bin, type); break;
case DUMP_SYMS_BLOCK: bin += write_syms_block(mrb, irep, bin, type); break;
default: break;
}
rc = calc_crc_section(mrb, irep, &crc, section);
if (rc != MRB_DUMP_OK)
return rc;
bin += uint16_dump(crc, bin, type); /* crc */
}
return MRB_DUMP_OK;
}
static int
write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
{
int pool_no;
mrb_value str;
char *buf_top = buf;
char *char_buf;
uint16_t buf_size =0;
uint16_t len =0;
int result;
buf_size = MRB_DUMP_DEFAULT_STR_LEN;
char_buf = (char *)mrb_malloc(mrb, buf_size);
if (char_buf == NULL) {
result = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
buf += uint32_dump((uint32_t)irep->plen, buf, type); /* number of pool */
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
buf += uint8_dump(mrb_type(irep->pool[pool_no]), buf, type); /* data type */
memset(char_buf, 0, buf_size);
switch (mrb_type(irep->pool[pool_no])) {
case MRB_TT_FIXNUM:
str = mrb_fix2str(mrb, irep->pool[pool_no], 10);
memcpy(char_buf, RSTRING_PTR(str), RSTRING_LEN(str));
len = RSTRING_LEN(str);
break;
case MRB_TT_FLOAT:
len = mrb_float_to_str(char_buf, mrb_float(irep->pool[pool_no]));
break;
case MRB_TT_STRING:
str = irep->pool[pool_no];
len = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
if (len > buf_size - 1) {
buf_size = len + 1;
char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size);
if (char_buf == NULL) {
result = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
memset(char_buf, 0, buf_size);
}
str_dump(RSTRING_PTR(str), char_buf, RSTRING_LEN(str), type);
break;
default:
buf += uint16_dump(0, buf, type); /* data length = 0 */
continue;
}
buf += uint16_dump(len, buf, type); /* data length */
memcpy(buf, char_buf, len);
buf += len;
}
result = (int)(buf - buf_top);
error_exit:
mrb_free(mrb, char_buf);
return result;
}
static inline void bccmd_dump(int level, struct frame *frm)
{
uint16_t type, length, seqno, varid, status;
type = CSR_U16(frm);
length = CSR_U16(frm);
seqno = CSR_U16(frm);
varid = CSR_U16(frm);
status = CSR_U16(frm);
p_indent(level, frm);
printf("BCCMD: %s: len %d seqno %d varid 0x%4.4x status %d\n",
type2str(type), length, seqno, varid, status);
if (!(parser.flags & DUMP_VERBOSE)) {
raw_dump(level + 1, frm);
return;
}
switch (varid) {
case 0x000b:
valueless_dump(level + 1, "PS_CLR_ALL", frm);
break;
case 0x000c:
valueless_dump(level + 1, "PS_FACTORY_SET", frm);
break;
case 0x082d:
uint16_dump(level + 1, "PS_CLR_ALL_STORES", frm);
break;
case 0x2801:
uint16_dump(level + 1, "BC01_STATUS", frm);
break;
case 0x2819:
uint16_dump(level + 1, "BUILDID", frm);
break;
case 0x281a:
uint16_dump(level + 1, "CHIPVER", frm);
break;
case 0x281b:
uint16_dump(level + 1, "CHIPREV", frm);
break;
case 0x2825:
uint16_dump(level + 1, "INTERFACE_VERSION", frm);
break;
case 0x282a:
uint16_dump(level + 1, "RAND", frm);
break;
case 0x282c:
uint16_dump(level + 1, "MAX_CRYPT_KEY_LENGTH", frm);
break;
case 0x2833:
uint16_dump(level + 1, "E2_APP_SIZE", frm);
break;
case 0x2836:
uint16_dump(level + 1, "CHIPANAREV", frm);
break;
case 0x2838:
uint16_dump(level + 1, "BUILDID_LOADER", frm);
break;
case 0x2c00:
uint32_dump(level + 1, "BT_CLOCK", frm);
break;
case 0x3005:
psnext_dump(level + 1, "PS_NEXT", frm);
break;
case 0x3006:
pssize_dump(level + 1, "PS_SIZE", frm);
break;
case 0x3008:
handle_length_dump(level + 1, "CRYPT_KEY_LENGTH", frm);
break;
case 0x3009:
handle_clock_dump(level + 1, "PICONET_INSTANCE", frm);
break;
case 0x300a:
complex_dump(level + 1, "GET_CLR_EVT", frm);
break;
case 0x300b:
complex_dump(level + 1, "GET_NEXT_BUILDDEF", frm);
break;
case 0x300e:
complex_dump(level + 1, "E2_DEVICE", frm);
break;
case 0x300f:
complex_dump(level + 1, "E2_APP_DATA", frm);
break;
case 0x3012:
psmemtype_dump(level + 1, "PS_MEMORY_TYPE", frm);
break;
case 0x301c:
complex_dump(level + 1, "READ_BUILD_NAME", frm);
break;
case 0x4001:
valueless_dump(level + 1, "COLD_RESET", frm);
break;
case 0x4002:
valueless_dump(level + 1, "WARM_RESET", frm);
break;
case 0x4003:
valueless_dump(level + 1, "COLD_HALT", frm);
break;
case 0x4004:
valueless_dump(level + 1, "WARM_HALT", frm);
break;
case 0x4005:
valueless_dump(level + 1, "INIT_BT_STACK", frm);
break;
case 0x4006:
valueless_dump(level + 1, "ACTIVATE_BT_STACK", frm);
break;
case 0x4007:
valueless_dump(level + 1, "ENABLE_TX", frm);
break;
case 0x4008:
valueless_dump(level + 1, "DISABLE_TX", frm);
break;
case 0x4009:
valueless_dump(level + 1, "RECAL", frm);
break;
case 0x400d:
valueless_dump(level + 1, "PS_FACTORY_RESTORE", frm);
break;
case 0x400e:
valueless_dump(level + 1, "PS_FACTORY_RESTORE_ALL", frm);
break;
case 0x400f:
valueless_dump(level + 1, "PS_DEFRAG_RESET", frm);
break;
case 0x4011:
valueless_dump(level + 1, "HOPPING_ON", frm);
break;
case 0x4012:
valueless_dump(level + 1, "CANCEL_PAGE", frm);
break;
case 0x4818:
uint16_dump(level + 1, "PS_CLR", frm);
break;
case 0x481c:
uint16_dump(level + 1, "MAP_SCO_PCM", frm);
break;
case 0x482e:
uint16_dump(level + 1, "SINGLE_CHAN", frm);
break;
case 0x5004:
radiotest_dump(level + 1, "RADIOTEST", frm);
break;
case 0x500c:
psstores_dump(level + 1, "PS_CLR_STORES", frm);
break;
case 0x6000:
valueless_dump(level + 1, "NO_VARIABLE", frm);
break;
case 0x6802:
uint16_dump(level + 1, "CONFIG_UART", frm);
break;
case 0x6805:
uint16_dump(level + 1, "PANIC_ARG", frm);
break;
case 0x6806:
uint16_dump(level + 1, "FAULT_ARG", frm);
break;
case 0x6827:
int8_dump(level + 1, "MAX_TX_POWER", frm);
break;
case 0x682b:
int8_dump(level + 1, "DEFAULT_TX_POWER", frm);
break;
case 0x7003:
pskey_dump(level + 1, frm);
break;
default:
raw_dump(level + 1, frm);
break;
}
}
static inline void pskey_dump(int level, struct frame *frm)
{
uint16_t key, length, stores;
key = CSR_U16(frm);
length = CSR_U16(frm);
stores = CSR_U16(frm);
p_indent(level, frm);
printf("PSKEY: key 0x%4.4x len %d stores 0x%4.4x\n", key, length, stores);
switch (key) {
case 0x0001:
bdaddr_dump(level + 1, "BDADDR", frm);
break;
case 0x0002:
uint16_dump(level + 1, "COUNTRYCODE", frm);
break;
case 0x0003:
uint32_dump(level + 1, "CLASSOFDEVICE", frm);
break;
case 0x0004:
uint16_dump(level + 1, "DEVICE_DRIFT", frm);
break;
case 0x0005:
uint16_dump(level + 1, "DEVICE_JITTER", frm);
break;
case 0x000d:
uint16_dump(level + 1, "MAX_ACLS", frm);
break;
case 0x000e:
uint16_dump(level + 1, "MAX_SCOS", frm);
break;
case 0x000f:
uint16_dump(level + 1, "MAX_REMOTE_MASTERS", frm);
break;
case 0x00da:
uint16_dump(level + 1, "ENC_KEY_LMIN", frm);
break;
case 0x00db:
uint16_dump(level + 1, "ENC_KEY_LMAX", frm);
break;
case 0x00ef:
features_dump(level + 1, "LOCAL_SUPPORTED_FEATURES", frm);
break;
case 0x0106:
commands_dump(level + 1, "LOCAL_SUPPORTED_COMMANDS", frm);
break;
case 0x010d:
uint16_dump(level + 1, "HCI_LMP_LOCAL_VERSION", frm);
break;
case 0x010e:
uint16_dump(level + 1, "LMP_REMOTE_VERSION", frm);
break;
case 0x01a5:
bool_dump(level + 1, "HOSTIO_USE_HCI_EXTN", frm);
break;
case 0x01ab:
bool_dump(level + 1, "HOSTIO_MAP_SCO_PCM", frm);
break;
case 0x01be:
uint16_dump(level + 1, "UART_BAUDRATE", frm);
break;
case 0x01f6:
uint16_dump(level + 1, "ANA_FTRIM", frm);
break;
case 0x01f9:
uint16_dump(level + 1, "HOST_INTERFACE", frm);
break;
case 0x01fe:
uint16_dump(level + 1, "ANA_FREQ", frm);
break;
case 0x02be:
uint16_dump(level + 1, "USB_VENDOR_ID", frm);
break;
case 0x02bf:
uint16_dump(level + 1, "USB_PRODUCT_ID", frm);
break;
case 0x02cb:
uint16_dump(level + 1, "USB_DFU_PRODUCT_ID", frm);
break;
case 0x03cd:
int16_dump(level + 1, "INITIAL_BOOTMODE", frm);
break;
default:
raw_dump(level + 1, frm);
break;
}
}
static int
write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
{
int pool_no;
mrb_value str;
char *buf_top = buf;
char *char_buf;
uint16_t buf_size =0;
buf_size = MRB_DUMP_DEFAULT_STR_LEN;
if ((char_buf = mrb_malloc(mrb, buf_size)) == 0)
goto error_exit;
buf += uint32_dump((uint32_t)irep->plen, buf, type); /* number of pool */
for (pool_no = 0; pool_no < irep->plen; pool_no++) {
uint16_t nlen =0;
buf += uint8_dump(irep->pool[pool_no].tt, buf, type); /* data type */
memset(char_buf, 0, buf_size);
switch (irep->pool[pool_no].tt) {
case MRB_TT_FIXNUM:
sprintf(char_buf, "%d", irep->pool[pool_no].value.i);
break;
case MRB_TT_FLOAT:
sprintf(char_buf, "%.16e", irep->pool[pool_no].value.f);
break;
case MRB_TT_STRING:
str = mrb_string_value( mrb, &irep->pool[pool_no]);
nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
if ( nlen > buf_size - 1) {
buf_size = nlen + 1;
if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
goto error_exit;
memset(char_buf, 0, buf_size);
}
str_dump(RSTRING_PTR(str), char_buf, RSTRING_LEN(str), type);
break;
#ifdef INCLUDE_REGEXP
case MRB_TT_REGEX:
str = mrb_reg_to_s(mrb, irep->pool[pool_no]);
nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
if ( nlen > buf_size - 1) {
buf_size = nlen + 1;
if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
goto error_exit;
memset(char_buf, 0, buf_size);
}
str_dump(RSTRING_PTR(str), char_buf, RSTRING_LEN(str), type);
break;
#endif
default:
buf += uint16_dump(0, buf, type); /* data length = 0 */
continue;
}
buf += uint16_dump((uint16_t)strlen(char_buf), buf, type); /* data length */
memcpy(buf, char_buf, strlen(char_buf));
buf += strlen(char_buf);
}
error_exit:
if (char_buf)
mrb_free(mrb, char_buf);
return (int)(buf - buf_top);
}
