*
* Returns: 0 on success. 1 on failure.
*/
-int mdb_find_pg_row(MdbHandle *mdb, int pg_row, char **buf, int *off, int *len)
+int mdb_find_pg_row(MdbHandle *mdb, int pg_row, unsigned char **buf, int *off, size_t *len)
{
unsigned int pg = pg_row >> 8;
unsigned int row = pg_row & 0xff;
return row_end;
#endif
}
-int mdb_is_null(unsigned char *null_mask, int col_num)
+#if 0
+static int mdb_is_null(unsigned char *null_mask, int col_num)
{
int byte_num = (col_num - 1) / 8;
int bit_num = (col_num - 1) % 8;
return 1;
}
}
+#endif
/* bool has to be handled specially because it uses the null bit to store its
** value*/
static int
}
return 1;
}
-int mdb_read_next_dpg(MdbTableDef *table)
+static int mdb_read_next_dpg(MdbTableDef *table)
{
MdbCatalogEntry *entry = table->entry;
MdbHandle *mdb = entry->mdb;
return text;
}
#endif
-int
+size_t
mdb_ole_read_next(MdbHandle *mdb, MdbColumn *col, void *ole_ptr)
{
guint16 ole_len;
guint16 ole_flags;
- char *buf;
+ unsigned char *buf;
int pg_row, row_start;
- int len;
+ size_t len;
ole_len = mdb_get_int16(ole_ptr, 0);
ole_flags = mdb_get_int16(ole_ptr, 2);
}
return 0;
}
-int
+size_t
mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size)
{
guint16 ole_len;
guint16 ole_flags;
- char *buf;
+ unsigned char *buf;
int pg_row, row_start;
- int len;
+ size_t len;
ole_len = mdb_get_int16(ole_ptr, 0);
ole_flags = mdb_get_int16(ole_ptr, 2);
{
guint16 ole_len;
guint16 ole_flags;
- guint32 row_start, pg_row;
- guint32 len;
- char *buf;
+ gint32 row_start, pg_row;
+ size_t len;
+ unsigned char *buf;
if (size<MDB_MEMO_OVERHEAD) {
return 0;
guint16 memo_len;
static char text[MDB_BIND_SIZE];
guint16 memo_flags;
- guint32 row_start, pg_row;
- guint32 len;
- char *buf;
+ gint32 row_start, pg_row;
+ size_t len;
+ unsigned char *buf;
if (size<MDB_MEMO_OVERHEAD) {
return "";
if (memo_flags & 0x8000) {
/* inline memo field */
- strncpy(text, &mdb->pg_buf[start + MDB_MEMO_OVERHEAD],
+ strncpy(text, (char *)&mdb->pg_buf[start + MDB_MEMO_OVERHEAD],
size - MDB_MEMO_OVERHEAD);
text[size - MDB_MEMO_OVERHEAD]='\0';
return text;
buffer_dump(mdb->pg_buf, row_start, row_start + len);
#endif
if (IS_JET3(mdb)) {
- strncpy(text, buf + row_start, len);
+ strncpy(text, (char*) buf + row_start, len);
text[len]='\0';
} else {
mdb_unicode2ascii(mdb, buf, row_start, len, text);
printf("row num %d start %d len %d\n",
pg_row & 0xff, row_start, len);
#endif
- strncat(text, buf + row_start + 4,
+ strncat(text, (char*) buf + row_start + 4,
strlen(text) + len - 4 > MDB_BIND_SIZE ?
MDB_BIND_SIZE - strlen(text) : len - 4);
*/
mdb_unicode2ascii(mdb, mdb->pg_buf, start, size, text);
} else {
- strncpy(text, &buf[start], size);
+ strncpy(text,(char*) &buf[start], size);
text[size]='\0';
}
return text;
#include <ctype.h>
#include <string.h>
#include <stdio.h>
+#include "mdbtools.h"
#ifdef DMALLOC
#include "dmalloc.h"
#endif
+
void buffer_dump(const unsigned char* buf, int start, int end)
{
char asc[20];
* freeing.
**/
-static gchar *mdb_find_file(char *file_name)
+static gchar *mdb_find_file(const char *file_name)
{
struct stat status;
gchar *mdbpath, **dir, *tmpfname;
*
* Return value: pointer to MdbHandle structure.
**/
-MdbHandle *mdb_open(char *filename, MdbFileFlags flags)
+MdbHandle *mdb_open(const char *filename, MdbFileFlags flags)
{
MdbHandle *mdb;
return mdb_get_double(mdb->pg_buf, offset);
}
-
+#if 0
int
mdb_set_pos(MdbHandle *mdb, int pos)
{
mdb->cur_pos=pos;
return pos;
}
+
int mdb_get_pos(MdbHandle *mdb)
{
return mdb->cur_pos;
}
+#endif
+
unsigned int i;
if (buf[offset]==0xff && buf[offset+1]==0xfe) {
- strncpy(dest, &buf[offset+2], len-2);
+ strncpy(dest, (char*) &buf[offset+2], len-2);
dest[len-2]='\0';
} else {
/* convert unicode to ascii, rather sloppily */
if (!buf) return 0;
if (IS_JET3(mdb)) {
- strncpy(dest, &buf[offset], len);
+ strncpy(dest, (char*) &buf[offset], len);
dest[len]='\0';
return strlen(dest);
}
- while (i<strlen(&buf[offset]) && (i*2+2)<len) {
+ while (i<strlen((char*)&buf[offset]) && (i*2+2)<len) {
dest[i*2] = buf[offset+i];
dest[i*2+1] = 0;
i++;
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
-
#ifndef _mdbtools_h_
#define _mdbtools_h_
+#ifdef __cplusplus
+ extern "C" {
+#endif
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
MDB_DEBUG_USAGE = 0x0004,
MDB_DEBUG_OLE = 0x0008,
MDB_DEBUG_ROW = 0x0010,
- MDB_USE_INDEX = 0x0020
+ MDB_USE_INDEX = 0x0020,
+ MDB_NO_MEMO = 0x0040 /* don't follow memo fields */
};
#define mdb_is_logical_op(x) (x == MDB_OR || \
/* offset to row count on data pages...version dependant */
typedef struct {
- int pg_size;
+ ssize_t pg_size;
guint16 row_count_offset;
guint16 tab_num_rows_offset;
guint16 tab_num_cols_offset;
MdbFormatConstants *fmt;
MdbStatistics *stats;
#ifdef HAVE_ICONV
+ iconv_t iconv_in;
iconv_t iconv_out;
#endif
} MdbHandle;
int cur_value_len;
/* MEMO/OLE readers */
guint32 cur_blob_pg;
- int cur_blob_row;
+ guint32 cur_blob_row;
int chunk_size;
/* numerics only */
int col_prec;
MdbProperties *props;
/* info needed for handling deleted/added columns */
int fixed_offset;
- int var_col_num;
+ unsigned int var_col_num;
/* row_col_num is the row column number order,
* including deleted columns */
int row_col_num;
unsigned char cache_value[256];
} MdbIndexPage;
-typedef int (*MdbSargTreeFunc)(MdbSargNode *, gpointer *data);
+typedef int (*MdbSargTreeFunc)(MdbSargNode *, gpointer data);
#define MDB_MAX_INDEX_DEPTH 10
extern float mdb_pg_get_single(MdbHandle *mdb, int offset);
extern double mdb_pg_get_double(MdbHandle *mdb, int offset);
extern gint32 mdb_pg_get_int24_msb(MdbHandle *mdb, int offset);
-extern MdbHandle *mdb_open(char *filename, MdbFileFlags flags);
+extern MdbHandle *mdb_open(const char *filename, MdbFileFlags flags);
extern void mdb_close(MdbHandle *mdb);
extern MdbHandle *mdb_clone_handle(MdbHandle *mdb);
extern void mdb_swap_pgbuf(MdbHandle *mdb);
extern int mdb_fetch_row(MdbTableDef *table);
extern int mdb_is_fixed_col(MdbColumn *col);
extern char *mdb_col_to_string(MdbHandle *mdb, unsigned char *buf, int start, int datatype, int size);
-extern int mdb_find_pg_row(MdbHandle *mdb, int pg_row, char **buf, int *off, int *len);
+extern int mdb_find_pg_row(MdbHandle *mdb, int pg_row, unsigned char **buf, int *off, size_t *len);
extern int mdb_find_end_of_row(MdbHandle *mdb, int row);
extern int mdb_col_fixed_size(MdbColumn *col);
extern int mdb_col_disp_size(MdbColumn *col);
extern void mdb_bind_len(MdbTableDef *table, int col_num, int *len_ptr);
-extern int mdb_ole_read_next(MdbHandle *mdb, MdbColumn *col, void *ole_ptr);
-extern int mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size);
+extern size_t mdb_ole_read_next(MdbHandle *mdb, MdbColumn *col, void *ole_ptr);
+extern size_t mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size);
extern void mdb_set_date_fmt(const char *);
extern int mdb_read_row(MdbTableDef *table, unsigned int row);
/* map.c */
extern guint32 mdb_map_find_next_freepage(MdbTableDef *table, int row_size);
-guint32 mdb_map_find_next(MdbHandle *mdb, unsigned char *map, unsigned int map_sz, guint32 start_pg);
+extern guint32 mdb_map_find_next(MdbHandle *mdb, unsigned char *map, unsigned int map_sz, guint32 start_pg);
/* props.c */
extern GPtrArray *mdb_read_props_list(gchar *kkd, int len);
extern int mdb_unicode2ascii(MdbHandle *mdb, unsigned char *buf, int offset, unsigned int len, char *dest);
extern int mdb_ascii2unicode(MdbHandle *mdb, unsigned char *buf, int offset, unsigned int len, char *dest);
+#ifdef __cplusplus
+ }
+#endif
+
#endif /* _mdbtools_h_ */
int idx_num, key_num, col_num;
int cur_pos, name_sz, idx2_sz, type_offset;
int index_start_pg = mdb->cur_pg;
- gchar *tmpbuf;
+ guchar *tmpbuf;
table->indices = g_ptr_array_new();
type_offset = 19;
}
- tmpbuf = (gchar *) g_malloc(idx2_sz);
+ tmpbuf = (guchar *) g_malloc(idx2_sz);
for (i=0;i<table->num_idxs;i++) {
read_pg_if_n(mdb, tmpbuf, &cur_pos, idx2_sz);
cur_pos += idx2_sz;
} else {
read_pg_if(mdb, &cur_pos, 0);
name_sz=mdb->pg_buf[cur_pos++];
- read_pg_if_n(mdb, pidx->name, &cur_pos, name_sz);
+ read_pg_if_n(mdb, (unsigned char *) pidx->name, &cur_pos, name_sz);
cur_pos += name_sz;
pidx->name[name_sz]='\0';
}
{
unsigned int k;
- for (k=0;k<strlen(text);k++) {
+ for (k=0;k<strlen((char*) text);k++) {
hash[k] = idx_to_text[text[k]];
if (!(hash[k])) fprintf(stderr,
"No translation available for %02x %d\n",
text[k],text[k]);
}
- hash[strlen(text)]=0;
+ hash[strlen((char*) text)]=0;
}
void
mdb_index_swap_n(unsigned char *src, int sz, unsigned char *dest)
dest[j++] = src[i];
}
}
-void
+static void
mdb_index_cache_sarg(MdbColumn *col, MdbSarg *sarg, MdbSarg *idx_sarg)
{
//guint32 cache_int;
switch (col->col_type) {
case MDB_TEXT:
- mdb_index_hash_text(sarg->value.s, idx_sarg->value.s);
+ mdb_index_hash_text((unsigned char*) sarg->value.s, (unsigned char*) idx_sarg->value.s);
break;
case MDB_LONGINT:
return 1;
}
#endif
-int
+static int
mdb_index_test_sargs(MdbHandle *mdb, MdbIndex *idx, unsigned char *buf, int len)
{
unsigned int i, j;
*/
if (col->col_type==MDB_TEXT) {
//c_len = strlen(&mdb->pg_buf[offset + c_offset]);
- c_len = strlen(buf);
+ c_len = strlen((char*) buf);
} else {
c_len = col->col_size;
//fprintf(stderr,"Only text types currently supported. How did we get here?\n");
}
return 1;
}
+#if 0
/*
* pack the pages bitmap
*/
}
return 0;
}
+#endif
/*
* unpack the pages bitmap
*/
-int
+static int
mdb_index_unpack_bitmap(MdbHandle *mdb, MdbIndexPage *ipg)
{
int mask_bit = 0;
* find the next leaf page if any given a chain. Assumes any exhausted leaf
* pages at the end of the chain have been peeled off before the call.
*/
-MdbIndexPage *
+static MdbIndexPage *
mdb_find_next_leaf(MdbHandle *mdb, MdbIndex *idx, MdbIndexChain *chain)
{
MdbIndexPage *ipg, *newipg;
return 1;
}
-void mdb_index_walk(MdbTableDef *table, MdbIndex *idx)
+static void mdb_index_walk(MdbTableDef *table, MdbIndex *idx)
{
MdbHandle *mdb = table->entry->mdb;
int cur_pos = 0;
* Unique indexes are preferred over non-uniques
* Operator preference is equal, like, isnull, others
*/
-int mdb_index_compute_cost(MdbTableDef *table, MdbIndex *idx)
+static int mdb_index_compute_cost(MdbTableDef *table, MdbIndex *idx)
{
unsigned int i;
MdbColumn *col;
*
* Returns strategy to use (table scan, or index scan)
*/
-MdbStrategy
+static MdbStrategy
mdb_choose_index(MdbTableDef *table, int *choice)
{
unsigned int i;
** KKD structures.
*/
-GArray *mdb_get_column_props(MdbCatalogEntry *entry, int start)
+#if 0
+static GArray *mdb_get_column_props(MdbCatalogEntry *entry, int start)
{
int pos, cnt=0;
int len, tmp, cplen;
return entry->props;
}
-GHashTable *mdb_get_column_def(MdbCatalogEntry *entry, int start)
+static GHashTable *mdb_get_column_def(MdbCatalogEntry *entry, int start)
{
GHashTable *hash = NULL;
MdbHandle *mdb = entry->mdb;
}
return hash;
}
-void mdb_kkd_dump(MdbCatalogEntry *entry)
+
+static void mdb_kkd_dump(MdbCatalogEntry *entry)
{
int rows;
int kkd_start, kkd_end;
mdb_get_column_def(entry, datapos);
}
}
-
+#endif
fprintf(stderr, "Warning: unrecognized usage map type: %d\n", map[0]);
return -1;
}
-guint32
+static guint32
mdb_alloc_page(MdbTableDef *table)
{
printf("Allocating new page\n");
static int multiply_byte(unsigned char *product, int num, unsigned char *multiplier);
static int do_carry(unsigned char *product);
static char *array_to_string(unsigned char *array, int unsigned scale, char *s);
+char *mdb_money_to_string(MdbHandle *mdb, int start, char *s);
/**
* mdb_money_to_string
static unsigned long opts;
static int optset;
-static void load_options();
+static void load_options(void);
void
mdb_debug(int klass, char *fmt, ...)
}
static void
-load_options()
+load_options(void)
{
char *opt;
char *s;
{
guint32 record_len;
int pos = 0;
- gchar *name;
+ guchar *name;
GPtrArray *names = NULL;
int i = 0;
names = g_ptr_array_new();
#ifdef MDB_DEBUG
- buffer_dump(kkd, 0, len - 1);
+ buffer_dump((const unsigned char*) kkd, 0, len - 1);
#endif
pos = 0;
while (pos < len) {
- record_len = mdb_get_int16(kkd, pos);
+ record_len = mdb_get_int16((unsigned char*)kkd, pos);
pos += 2;
#ifdef MDB_DEBUG
printf("%02d ",i++);
- buffer_dump(kkd, pos - 2, pos + record_len - 1);
+ buffer_dump((const unsigned char*)kkd, pos - 2, pos + record_len - 1);
#endif
name = g_malloc(record_len + 1);
- strncpy(name, &kkd[pos], record_len);
+ strncpy((char*)name, (char*)&kkd[pos], record_len);
name[record_len] = '\0';
pos += record_len;
g_ptr_array_add(names, name);
if (props->name) g_free(props->name);
g_free(props);
}
-MdbProperties *
-mdb_alloc_props()
+static MdbProperties *
+mdb_alloc_props(void)
{
MdbProperties *props;
int i = 0;
#ifdef MDB_DEBUG
- buffer_dump(kkd, 0, len - 1);
+ buffer_dump((const unsigned char*)kkd, 0, len - 1);
#endif
pos = 0;
/* skip the name record */
- record_len = mdb_get_int16(kkd, pos);
+ record_len = mdb_get_int16((unsigned char *)kkd, pos);
pos += 4;
- name_len = mdb_get_int16(kkd, pos);
+ name_len = mdb_get_int16((unsigned char *)kkd, pos);
pos += 2;
props = mdb_alloc_props();
if (name_len) {
props->name = g_malloc(name_len + 1);
- strncpy(props->name, &kkd[pos], name_len);
+ strncpy(props->name, (char*) &kkd[pos], name_len);
props->name[name_len]='\0';
}
pos += name_len;
props->hash = g_hash_table_new(g_str_hash, g_str_equal);
while (pos < len) {
- record_len = mdb_get_int16(kkd, pos);
- elem = mdb_get_int16(kkd, pos + 4);
+ record_len = mdb_get_int16((unsigned char *)kkd, pos);
+ elem = mdb_get_int16((unsigned char *)kkd, pos + 4);
dtype = kkd[pos + 3];
- dsize = mdb_get_int16(kkd, pos + 6);
+ dsize = mdb_get_int16((unsigned char *)kkd, pos + 6);
value = g_malloc(dsize + 1);
- strncpy(value, &kkd[pos + 8], dsize);
+ strncpy(value, (char*) &kkd[pos + 8], dsize);
value[dsize] = '\0';
name = g_ptr_array_index(names,elem);
#ifdef MDB_DEBUG
printf("%02d ",i++);
- buffer_dump(kkd, pos, pos + record_len - 1);
+ buffer_dump((const unsigned char *)kkd, pos, pos + record_len - 1);
printf("elem %d dsize %d dtype %d\n", elem, dsize, dtype);
#endif
if (dtype == MDB_MEMO) dtype = MDB_TEXT;
if (dtype == MDB_BOOL) {
g_hash_table_insert(props->hash, g_strdup(name), g_strdup(kkd[pos + 8] ? "yes" : "no"));
} else {
- g_hash_table_insert(props->hash, g_strdup(name), g_strdup(mdb_col_to_string(mdb, kkd, pos + 8, dtype, dsize)));
+ g_hash_table_insert(props->hash, g_strdup(name), g_strdup(mdb_col_to_string(mdb, (unsigned char *)kkd, pos + 8, dtype, dsize)));
}
g_free(value);
pos += record_len;
}
return 1;
}
-int
+static int
mdb_find_field(int col_num, MdbField *fields, int num_fields)
{
int i;
}
return -1;
}
-int
+static int
mdb_test_sarg_node(MdbHandle *mdb, MdbSargNode *node, MdbField *fields, int num_fields)
{
int elem;
MdbHandle *mdb = entry->mdb;
MdbFormatConstants *fmt = mdb->fmt;
int len, row_start, pg_row;
- char *buf;
+ unsigned char *buf;
table = mdb_alloc_tabledef(entry);
pcol = g_ptr_array_index(table->columns, i);
if (IS_JET4(mdb)) {
- char *tmp_buf;
+ unsigned char *tmp_buf;
name_sz = read_pg_if_16(mdb, &cur_pos);
cur_pos += 2;
- tmp_buf = (char *) g_malloc(name_sz);
+ tmp_buf = (unsigned char *) g_malloc(name_sz);
read_pg_if_n(mdb, tmp_buf, &cur_pos, name_sz);
mdb_unicode2ascii(mdb, tmp_buf, 0, name_sz, pcol->name);
g_free(tmp_buf);
read_pg_if(mdb, &cur_pos, 0);
name_sz = mdb->pg_buf[cur_pos];
cur_pos++;
- read_pg_if_n(mdb, pcol->name, &cur_pos, name_sz);
+ read_pg_if_n(mdb, (unsigned char*) pcol->name, &cur_pos, name_sz);
pcol->name[name_sz]='\0';
cur_pos += name_sz;
} else {
//static int mdb_copy_index_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg);
static int mdb_add_row_to_leaf_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg, MdbField *idx_fields);
-void
+static void
_mdb_put_int16(unsigned char *buf, guint32 offset, guint32 value)
{
buf[offset] = value % 256;
value /= 256;
buf[offset+1] = value % 256;
}
-void
+static void
_mdb_put_int32(unsigned char *buf, guint32 offset, guint32 value)
{
buf[offset] = value % 256;
value /= 256;
buf[offset+3] = value % 256;
}
-ssize_t
+static ssize_t
mdb_write_pg(MdbHandle *mdb, unsigned long pg)
{
ssize_t len;
/* read table of variable column locations */
if (table->num_var_cols > 0) {
row_var_cols = mdb_pg_get_int16(mdb, row_end - bitmask_sz - 1);
- var_col_offsets = (int *)g_malloc((row_var_cols+1)*sizeof(int));
+ var_col_offsets = (unsigned int *)g_malloc((row_var_cols+1)*sizeof(int));
for (i=0; i<row_var_cols+1; i++) {
var_col_offsets[i] = mdb_pg_get_int16(mdb,
row_end - bitmask_sz - 3 - (i*2));
if ((col_ptr-row_start-row_var_cols)/256 < num_jumps)
num_jumps--;
- var_col_offsets = (int *)g_malloc((row_var_cols+1)*sizeof(int));
+ var_col_offsets = (unsigned int *)g_malloc((row_var_cols+1)*sizeof(int));
jumps_used = 0;
for (i=0; i<row_var_cols+1; i++) {
if ((jumps_used < num_jumps)
mdb_debug(MDB_DEBUG_WRITE,"free space left on page = %d", free_end - free_start);
return (free_end - free_start);
}
-unsigned char *
+static unsigned char *
mdb_new_leaf_pg(MdbCatalogEntry *entry)
{
MdbHandle *mdb = entry->mdb;
return new_pg;
}
-int
+#if 0
+static int
mdb_update_indexes(MdbTableDef *table, int num_fields, MdbField *fields, guint32 pgnum, guint16 rownum)
{
unsigned int i;
return 1;
}
-int
+static int
mdb_init_index_chain(MdbTableDef *table, MdbIndex *idx)
{
MdbCatalogEntry *entry = table->entry;
return 1;
}
+#endif
int
mdb_update_index(MdbTableDef *table, MdbIndex *idx, unsigned int num_fields, MdbField *fields, guint32 pgnum, guint16 rownum)
return 1;
}
-int
+#if 0
+static int
mdb_insert_row(MdbTableDef *table, int num_fields, MdbField *fields)
{
int new_row_size;
return 1;
}
+#endif
+
/*
* Assumes caller has verfied space is available on page and adds the new
* row to the current pg_buf.
projects / profile / ivi / navit.git / commitdiff