void
db_bus_write_cmd(db_expr_t addr, bool have_addr, db_expr_t count,
const char *modif)
{
db_expr_t datum;
bus_space_tag_t iot = &iobus_bs_tag; /* XXX */
bus_space_handle_t ioh;
if (!have_addr)
db_error("target address must be specified");
bus_space_map(iot, addr, 1, 0, &ioh);
while (db_expression(&datum)) {
switch (*modif) {
case 'b':
bus_space_write_1(iot, ioh, 0, datum);
break;
case '\0':
case 'h':
bus_space_write_2(iot, ioh, 0, datum);
break;
default:
db_error("bad modifier");
}
}
bus_space_unmap(iot, ioh, 1);
db_skip_to_eol();
}
void
db_def_macro_cmd(void)
{
register char *p;
register int c;
register struct db_user_macro *mp, *ep;
if (db_read_token() != tIDENT) {
db_printf("Bad macro name \"%s\"\n", db_tok_string);
db_error(0);
/* NOTREACHED */
}
if ((mp = db_lookup_macro(db_tok_string)) == 0) {
if (db_macro_free <= 0)
db_error("Too many macros\n");
/* NOTREACHED */
ep = &db_user_macro[DB_NUSER_MACRO];
for (mp = db_user_macro; mp < ep && mp->m_name[0]; mp++);
if (mp >= ep)
db_error("ddb: internal error(macro)\n");
/* NOTREACHED */
db_macro_free--;
strlcpy(mp->m_name, db_tok_string, TOK_STRING_SIZE);
}
for (c = db_read_char(); c == ' ' || c == '\t'; c = db_read_char());
for (p = mp->m_lbuf; c > 0; c = db_read_char())
*p++ = c;
*p = 0;
mp->m_size = p - mp->m_lbuf;
}
boolean_t
db_shift_expr(db_expr_t *valuep)
{
db_expr_t lhs, rhs;
int t;
if (!db_add_expr(&lhs))
return (FALSE);
t = db_read_token();
while (t == tSHIFT_L || t == tSHIFT_R) {
if (!db_add_expr(&rhs)) {
db_error("Syntax error\n");
/*NOTREACHED*/
}
if (rhs < 0) {
db_error("Negative shift amount\n");
/*NOTREACHED*/
}
if (t == tSHIFT_L)
lhs <<= rhs;
else {
/* Shift right is unsigned */
lhs = (unsigned) lhs >> rhs;
}
t = db_read_token();
}
db_unread_token(t);
*valuep = lhs;
return (TRUE);
}
static const char *readline()
{
int count;
db_msg("prepare to readline\n");
do{
count = read(device_fd, s_ATBuffer,MAX_AT_RESPONSE);
db_msg("readline count=%d\n",count);
} while (count < 0 && errno == EINTR);
if (count > 0){
s_ATBuffer[count] = '\0';//mark the string end
}
else if (count<=0) {
/* read error encountered or EOF reached */
if(count == 0) {
db_error("ATchannel: EOF reached\n");
} else {
db_error("ATchannel: read error %s\n", strerror(errno));
}
return NULL;
}
return s_ATBuffer;
}
void
db_check_interrupt(void)
{
int c;
c = cnmaygetc();
switch (c) {
case -1: /* no character */
return;
case CTRL('c'):
db_error(NULL);
/*NOTREACHED*/
case CTRL('s'):
do {
c = cnmaygetc();
if (c == CTRL('c'))
db_error(NULL);
} while (c != CTRL('q'));
break;
default:
/* drop on floor */
break;
}
}
void
db_set_cmd(db_expr_t dummy1, bool dummy2, db_expr_t dummy3, char *dummy4)
{
struct db_variable *vp;
db_expr_t value;
int t;
t = db_read_token();
if (t != tDOLLAR) {
db_error("Unknown variable\n");
return;
}
if (!db_find_variable(&vp)) {
db_error("Unknown variable\n");
return;
}
t = db_read_token();
if (t != tEQ)
db_unread_token(t);
if (!db_expression(&value)) {
db_error("No value\n");
return;
}
if (db_read_token() != tEOL)
db_error("?\n");
db_write_variable(vp, value);
}
boolean_t
db_unary(db_expr_t *valuep)
{
int t;
t = db_read_token();
if (t == tMINUS) {
if (!db_unary(valuep)) {
db_error("Syntax error\n");
/*NOTREACHED*/
}
*valuep = -*valuep;
return (TRUE);
}
if (t == tSTAR) {
/* indirection */
if (!db_unary(valuep)) {
db_error("Syntax error\n");
/*NOTREACHED*/
}
*valuep = db_get_value((db_addr_t)*valuep, sizeof(int), FALSE);
return (TRUE);
}
db_unread_token(t);
return (db_term(valuep));
}
boolean_t
db_mult_expr(db_expr_t *valuep)
{
db_expr_t lhs, rhs;
int t;
if (!db_unary(&lhs))
return (FALSE);
t = db_read_token();
while (t == tSTAR || t == tSLASH || t == tPCT || t == tHASH) {
if (!db_term(&rhs)) {
db_error("Syntax error\n");
/*NOTREACHED*/
}
if (t == tSTAR)
lhs *= rhs;
else {
if (rhs == 0) {
db_error("Divide by 0\n");
/*NOTREACHED*/
}
if (t == tSLASH)
lhs /= rhs;
else if (t == tPCT)
lhs %= rhs;
else
lhs = ((lhs+rhs-1)/rhs)*rhs;
}
t = db_read_token();
}
db_unread_token(t);
*valuep = lhs;
return (TRUE);
}
void PlayBack::cdrplaybackicon(HWND hWnd,ResourceID mId,int iCmdShow)
{
int retval;
CDR_RECT rect;
ResourceManager* rm;
HWND retWnd;
rm = ResourceManager::getInstance();
retval = rm->getResBmp(mId, BMPTYPE_BASE, bmpIcon);
if(retval < 0) {
db_error("get current playback icon bmp failed\n");
//return -1;
}
rm->getResRect(mId, rect);
db_msg("luo rect.x=%d rect.y=%d rect.w=%d rect.h=%d \n ",rect.x,rect.y,rect.w,rect.h);
retWnd = CreateWindowEx(CTRL_STATIC, "",
WS_VISIBLE | WS_CHILD | SS_BITMAP | SS_CENTERIMAGE,
WS_EX_TRANSPARENT,
mId,
rect.x, rect.y,rect.w,rect.h,
hWnd, (DWORD)&bmpIcon);
if(retWnd == HWND_INVALID) {
db_error("create playback icon label failed\n");
//return -1;
}
ShowWindow(retWnd, iCmdShow);
// return 0;
}
static int setup_device(char *device_node_path,int setup_delay)
{
struct termios ios;
device_fd= open (device_node_path, O_RDWR);
if(device_fd<0){
db_error("2glooptester:open device error\n");
}
/* disable echo on serial ports */
tcgetattr( device_fd, &ios );
ios.c_lflag = 0;
tcflush(device_fd, TCIFLUSH);
cfsetospeed(&ios,B115200);
if(tcsetattr( device_fd, TCSANOW, &ios )){
db_error("set tty attr fail\n");
return -1;
}
db_msg("sleep %d s to wait for hardware ready\n",setup_delay);
sleep(setup_delay);//sleep befor hardware get ready
return 0;
}
int
scan_db(DB *dbp)
{
DBC *cursor;
int ret, num_recs = 0;
DBT key, data;
ret = dbp->cursor(dbp, 0, &cursor, 0);
if(ret)
{
db_error("DB->cursor", ret);
return ret;
}
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
while( (ret = cursor->c_get(cursor, &key, &data, DB_NEXT)) == 0)
num_recs++;
if(ret == DB_NOTFOUND)
printf("Scan of %s completed successfully. Scanned %d records\n",
dbp->fname, num_recs);
else
{
db_error("DBC->get", ret);
return ret;
}
cursor->c_close(cursor);
return 0;
}
/*
* Create new db handle.
*/
int
create_db(DB_ENV *db_envp, DB **dbp, int PAGE_SIZE, int add_flags)
{
int err;
if(( err = db_create(dbp, db_envp, 0)))
{
db_error("db_create", err);
return err;
}
if((err = (*dbp)->set_pagesize(*dbp, PAGE_SIZE)))
{
db_error("DB->set_pagesize", err);
return err;
}
if(add_flags)
{
if ((err = (*dbp)->set_flags(*dbp, add_flags)) != 0)
{
db_error("DB->set_flags", err);
return err;
}
}
return 0;
}
/*ARGSUSED*/
void
db_set_cmd(db_expr_t addr, int have_addr, db_expr_t count, char *modif)
{
db_expr_t value;
struct db_variable *vp;
int t;
t = db_read_token();
if (t != tDOLLAR) {
db_error("Unknown variable\n");
/*NOTREACHED*/
}
if (!db_find_variable(&vp)) {
db_error("Unknown variable\n");
/*NOTREACHED*/
}
t = db_read_token();
if (t != tEQ)
db_unread_token(t);
if (!db_expression(&value)) {
db_error("No value\n");
/*NOTREACHED*/
}
if (db_read_token() != tEOL) {
db_error("?\n");
/*NOTREACHED*/
}
db_write_variable(vp, &value);
}
///
/// @param name Table name to check for
/// @return True if table name exists
///
/// Return whether a table with the specified name exists in the current database.
bool sqlite::table_exists(const std::string& name)
{
assert(db_);
// check the master table first
std::string sql = "select name from sqlite_master where type IN ('table','view') AND name=?";
sqlite3_stmt* stmt;
if(sqlite3_prepare(db_, sql.c_str(), sql.length(), &stmt, 0) != SQLITE_OK)
throw db_error(sqlite3_errmsg(db_));
sqlite3_bind_text(stmt, 1, name.c_str(), name.length(), SQLITE_TRANSIENT);
int result = sqlite3_step(stmt);
sqlite3_finalize(stmt);
if(result == SQLITE_ROW)
return true;
// check the temp_master table last
sql = "select name from sqlite_temp_master where type IN ('table','view') AND name=?";
if(sqlite3_prepare(db_, sql.c_str(), sql.length(), &stmt, 0) != SQLITE_OK)
throw db_error(sqlite3_errmsg(db_));
sqlite3_bind_text(stmt, 1, name.c_str(), name.length(), SQLITE_TRANSIENT);
result = sqlite3_step(stmt);
sqlite3_finalize(stmt);
return result == SQLITE_ROW;
}
void
db_kill_proc(db_expr_t addr, bool haddr,
db_expr_t count, const char *modif)
{
#ifdef _KERNEL /* XXX CRASH(8) */
struct proc *p;
ksiginfo_t ksi;
db_expr_t pid, sig;
int t;
/* What pid? */
if (!db_expression(&pid)) {
db_error("pid?\n");
/*NOTREACHED*/
}
/* What sig? */
t = db_read_token();
if (t == tCOMMA) {
if (!db_expression(&sig)) {
db_error("sig?\n");
/*NOTREACHED*/
}
} else {
db_unread_token(t);
sig = 15;
}
if (db_read_token() != tEOL) {
db_error("?\n");
/*NOTREACHED*/
}
/* We might stop when the mutex is held or when not */
t = mutex_tryenter(proc_lock);
#ifdef DIAGNOSTIC
if (!t) {
db_error("could not acquire proc_lock mutex\n");
/*NOTREACHED*/
}
#endif
p = proc_find((pid_t)pid);
if (p == NULL) {
if (t)
mutex_exit(proc_lock);
db_error("no such proc\n");
/*NOTREACHED*/
}
KSI_INIT(&ksi);
ksi.ksi_signo = sig;
ksi.ksi_code = SI_USER;
ksi.ksi_pid = 0;
ksi.ksi_uid = 0;
mutex_enter(p->p_lock);
kpsignal2(p, &ksi);
mutex_exit(p->p_lock);
if (t)
mutex_exit(proc_lock);
#else
db_printf("This command is not currently supported.\n");
#endif
}
/*ARGSUSED*/
void
db_write_cmd(db_expr_t address, boolean_t have_addr, db_expr_t count,
char *modif)
{
db_addr_t addr;
db_expr_t old_value;
db_expr_t new_value;
int size;
boolean_t wrote_one = FALSE;
char tmpfmt[28];
addr = (db_addr_t) address;
switch (modif[0]) {
case 'b':
size = 1;
break;
case 'h':
size = 2;
break;
case 'l':
case '\0':
size = 4;
break;
#ifdef __LP64__
case 'q':
size = 8;
break;
#endif
default:
size = -1;
db_error("Unknown size\n");
/*NOTREACHED*/
}
while (db_expression(&new_value)) {
old_value = db_get_value(addr, size, FALSE);
db_printsym(addr, DB_STGY_ANY, db_printf);
db_printf("\t\t%s\t", db_format(tmpfmt, sizeof tmpfmt,
old_value, DB_FORMAT_N, 0, 8));
db_printf("=\t%s\n", db_format(tmpfmt, sizeof tmpfmt,
new_value, DB_FORMAT_N, 0, 8));
db_put_value(addr, size, new_value);
addr += size;
wrote_one = TRUE;
}
if (!wrote_one) {
db_error("Nothing written.\n");
/*NOTREACHED*/
}
db_next = addr;
db_prev = addr - size;
db_skip_to_eol();
}
void
db_cond_cmd(void)
{
register int c;
register struct db_cond *cp;
register char *p;
db_expr_t value;
db_thread_breakpoint_t bkpt;
if (db_read_token() != tHASH || db_read_token() != tNUMBER) {
db_printf("#<number> expected instead of \"%s\"\n", db_tok_string);
db_error(0);
return;
}
if ((bkpt = db_find_breakpoint_number(db_tok_number, 0)) == 0) {
db_printf("No such break point #%d\n", db_tok_number);
db_error(0);
return;
}
/*
* if the break point already has a condition, free it first
*/
if (bkpt->tb_cond > 0) {
cp = &db_cond[bkpt->tb_cond - 1];
db_cond_free(bkpt);
} else {
if (db_ncond_free <= 0) {
db_error("Too many conditions\n");
return;
}
for (cp = db_cond; cp < &db_cond[DB_MAX_COND]; cp++)
if (cp->c_size == 0)
break;
if (cp >= &db_cond[DB_MAX_COND])
panic("bad db_cond_free");
}
for (c = db_read_char(); c == ' ' || c == '\t'; c = db_read_char());
for (p = cp->c_cond_cmd; c >= 0; c = db_read_char())
*p++ = c;
/*
* switch to saved data and call db_expression to check the condition.
* If no condition is supplied, db_expression will return false.
* In this case, clear previous condition of the break point.
* If condition is supplied, set the condition to the permanent area.
* Note: db_expression will not return here, if the condition
* expression is wrong.
*/
db_switch_input(cp->c_cond_cmd, p - cp->c_cond_cmd);
if (!db_expression(&value)) {
/* since condition is already freed, do nothing */
db_flush_lex();
return;
}
db_flush_lex();
db_ncond_free--;
cp->c_size = p - cp->c_cond_cmd;
bkpt->tb_cond = (cp - db_cond) + 1;
}
/*ARGSUSED*/
void
db_write_cmd(db_expr_t address, bool have_addr,
db_expr_t count, const char *modif)
{
db_addr_t addr;
db_expr_t old_value;
db_expr_t new_value;
int size;
bool wrote_one;
bool show_old_val;
addr = (db_addr_t) address;
wrote_one = false;
show_old_val = islower((unsigned char)modif[0]);
switch (tolower((unsigned char)modif[0])) {
case 'b':
size = 1;
break;
case 'h':
size = 2;
break;
case 'l':
case '\0':
size = 4;
break;
default:
size = -1;
db_error("Unknown size\n");
/*NOTREACHED*/
}
while (db_expression(&new_value)) {
db_printsym(addr, DB_STGY_ANY, db_printf);
if (show_old_val) {
old_value = db_get_value(addr, size, false);
db_printf("\t\t%s = ", db_num_to_str(old_value));
db_printf("%s\n", db_num_to_str(new_value));
}
else
db_printf("\t\t= %s\n", db_num_to_str(new_value));
db_put_value(addr, size, new_value);
addr += size;
wrote_one = true;
}
if (!wrote_one) {
db_error("Nothing written.\n");
/*NOTREACHED*/
}
db_next = addr;
db_prev = addr - size;
db_skip_to_eol();
}
static boolean_t
db_term(db_expr_t *valuep)
{
int t;
t = db_read_token();
if (t == tIDENT) {
if (!db_value_of_name(db_tok_string, valuep) &&
!db_value_of_name_pcpu(db_tok_string, valuep) &&
!db_value_of_name_vnet(db_tok_string, valuep)) {
db_error("Symbol not found\n");
/*NOTREACHED*/
}
return (TRUE);
}
if (t == tNUMBER) {
*valuep = (db_expr_t)db_tok_number;
return (TRUE);
}
if (t == tDOT) {
*valuep = (db_expr_t)db_dot;
return (TRUE);
}
if (t == tDOTDOT) {
*valuep = (db_expr_t)db_prev;
return (TRUE);
}
if (t == tPLUS) {
*valuep = (db_expr_t) db_next;
return (TRUE);
}
if (t == tDITTO) {
*valuep = (db_expr_t)db_last_addr;
return (TRUE);
}
if (t == tDOLLAR) {
if (!db_get_variable(valuep))
return (FALSE);
return (TRUE);
}
if (t == tLPAREN) {
if (!db_expression(valuep)) {
db_error("Syntax error\n");
/*NOTREACHED*/
}
t = db_read_token();
if (t != tRPAREN) {
db_error("Syntax error\n");
/*NOTREACHED*/
}
return (TRUE);
}
db_unread_token(t);
return (FALSE);
}
int setup_2g_device(char *device_node_path,int setup_delay)
{
char *p_cur;
int sl;
struct termios ios;
device_fd= open (device_node_path, O_RDWR);
if(device_fd<0)
{
db_error("2gtester:open device error\n");
}
/* disable echo on serial ports */
tcgetattr( device_fd, &ios );
ios.c_lflag = 0;
tcflush(device_fd, TCIFLUSH);
cfsetospeed(&ios,B115200);
if(tcsetattr( device_fd, TCSANOW, &ios ))
{
db_error("set tty attr fail\n");
return 0;
}
db_msg("sleep %d s to wait for hardware ready\n",setup_delay);
sleep(setup_delay);//sleep befor hardware get ready
readline(); //dump the msg
db_msg("2gtester dump readline: %s\n",s_ATBuffer);
if(writeline("AT+CSQ")){ //WRITE single query command
return 0;
}
sleep(1);
if(!readline()){
db_error("2gtester:no correct response for the AT+CSQ\n");
return 0;
}
db_msg("2gtester AT+CSQ readline: %s\n",s_ATBuffer);
p_cur=strstr(s_ATBuffer,"+CSQ:");
if (*p_cur == NULL) {
return 0;
}
p_cur+=5; //point to the rssi start position
db_msg("p_cur=%s\n",p_cur);
sl=atoi(p_cur);
sl=(sl*2)-113;
db_msg("sl=%d\n",sl);
return sl;
}
long
db_i386_reg_value(
struct db_variable *vp,
db_expr_t *valuep,
int flag,
db_var_aux_param_t ap)
{
long *dp = 0;
db_expr_t null_reg = 0;
register thread_t thread = ap->thread;
extern unsigned int_stack_high;
if (db_option(ap->modif, 'u')) {
if (thread == THREAD_NULL) {
if ((thread = current_thread()) == THREAD_NULL)
db_error("no user registers\n");
}
if (thread == current_thread()) {
if (ddb_regs.cs & 0x3)
dp = vp->valuep;
else if (ddb_regs.ebp < int_stack_high)
db_error("cannot get/set user registers in nested interrupt\n");
}
} else {
if (thread == THREAD_NULL || thread == current_thread()) {
dp = vp->valuep;
} else if ((thread->state & TH_SWAPPED) == 0 &&
thread->kernel_stack) {
dp = db_lookup_i386_kreg(vp->name,
(long *)(STACK_IKS(thread->kernel_stack)));
if (dp == 0)
dp = &null_reg;
} else if ((thread->state & TH_SWAPPED) &&
thread->swap_func != thread_exception_return) {
/*.....this breaks t/t $taskN.0...*/
/* only EIP is valid */
if (vp->valuep == (long *) &ddb_regs.eip) {
dp = (long *)(&thread->swap_func);
} else {
dp = &null_reg;
}
}
}
if (dp == 0) {
if (thread->pcb == 0)
db_error("no pcb\n");
dp = (long *)((long)(&thread->pcb->iss) +
((long)vp->valuep - (long)&ddb_regs));
}
if (flag == DB_VAR_SET)
*dp = *valuep;
else
*valuep = *dp;
}
///
/// @param path Path to sqlite database file
///
/// Close any previous connection and open a new connection to the
/// sqlite database in the specified file.
void sqlite::open(const std::string& path)
{
const int c_busy_timeout = 5000;
if(sqlite3_open(path.c_str(), &db_) != SQLITE_OK)
throw db_error(sqlite3_errmsg(db_));
if(!db_)
throw db_error(std::string("can't open database: ") + path);
sqlite3_busy_timeout(db_, c_busy_timeout);
}
/*
* Write bytes to task address space for debugger.
*/
void
db_write_bytes(
vm_offset_t addr,
int size,
char *data,
task_t task)
{
int n,max;
addr64_t phys_dst;
addr64_t phys_src;
pmap_t pmap;
while (size > 0) {
phys_src = db_vtophys(kernel_pmap, (vm_offset_t)data);
if (phys_src == 0) {
db_printf("\nno memory is assigned to src address %08x\n",
data);
db_error(0);
/* NOTREACHED */
}
/* space stays as kernel space unless in another task */
if (task == NULL) pmap = kernel_pmap;
else pmap = task->map->pmap;
phys_dst = db_vtophys(pmap, (vm_offset_t)addr);
if (phys_dst == 0) {
db_printf("\nno memory is assigned to dst address %08x\n",
addr);
db_error(0);
/* NOTREACHED */
}
/* don't over-run any page boundaries - check src range */
max = round_page_64(phys_src + 1) - phys_src;
if (max > size)
max = size;
/* Check destination won't run over boundary either */
n = round_page_64(phys_dst + 1) - phys_dst;
if (n < max)
max = n;
size -= max;
addr += max;
phys_copy(phys_src, phys_dst, max);
/* resync I+D caches */
sync_cache64(phys_dst, max);
phys_src += max;
phys_dst += max;
}
}
/*
* Loads the Customer Table
*/
void
LoadCust(void)
{
long w_id;
long d_id;
char *name = CUSTOMER_INDEX_NAME;
char *sec_name = CUSTOMER_SECONDARY_NAME;
char *hist_name = HISTORY_INDEX_NAME;
DB *dbp_sec;
int err;
if(create_db(db_env, &dbp_customer,DB_COMMON_PAGE_SIZE, 0) || open_db(dbp_customer, name, 0))
return;
if(create_db(db_env, &dbp_sec, DB_COMMON_PAGE_SIZE, DB_DUP | DB_DUPSORT))
return;
if((err = dbp_sec->set_bt_compare(dbp_sec, customer_secondary_comparison_func)))
{
db_error("DB->set_bt_compare", err);
goto done;
}
if(open_db(dbp_sec, sec_name, 0))
return;
if ((err = dbp_customer->associate(dbp_customer, 0, dbp_sec, get_customer_sec_key, 0)) != 0)
{
db_error("DB->associate failed: %s\n", err);
goto done;
}
if(create_db(db_env, &dbp_history, DB_COMMON_PAGE_SIZE, 0) || open_db(dbp_history, hist_name, 0))
return;
for (w_id=1L; w_id<=count_ware; w_id++)
for (d_id=1L; d_id<=DIST_PER_WARE; d_id++)
{
if(Customer(d_id,w_id))
goto done;
}
done:
if(dbp_customer)
dbp_customer->close(dbp_customer, 0);
if(dbp_sec)
dbp_sec->close(dbp_sec, 0);
if(dbp_history)
dbp_history->close(dbp_history, 0);
}
int
db_user_to_kernel_address(
const task_t task,
vm_offset_t addr,
vm_offset_t *kaddr,
int flag)
{
pt_entry_t *ptp;
boolean_t faulted = FALSE;
retry:
ptp = pmap_pte(task->map->pmap, addr);
if (ptp == PT_ENTRY_NULL || (*ptp & INTEL_PTE_VALID) == 0) {
if (!faulted && !db_no_vm_fault) {
kern_return_t err;
faulted = TRUE;
err = vm_fault( task->map,
trunc_page(addr),
VM_PROT_READ,
FALSE, FALSE, 0);
if (err == KERN_SUCCESS)
goto retry;
}
if (flag) {
db_printf("\nno memory is assigned to address %08x\n", addr);
db_error(0);
/* NOTREACHED */
}
return(-1);
}
*kaddr = ptetokv(*ptp) + (addr & (INTEL_PGBYTES-1));
return(0);
}
int
db_find_variable(struct db_variable **varp)
{
int t;
struct db_variable *vp;
t = db_read_token();
if (t == tIDENT) {
for (vp = db_vars; vp < db_evars; vp++) {
if (!strcmp(db_tok_string, vp->name)) {
*varp = vp;
return (1);
}
}
for (vp = db_regs; vp < db_eregs; vp++) {
if (!strcmp(db_tok_string, vp->name)) {
*varp = vp;
return (1);
}
}
}
db_error("Unknown variable\n");
/*NOTREACHED*/
return 0;
}
/*
* kdb_trap - field a TRACE or BPT trap
*/
int
kdb_trap(int type, db_regs_t *regs)
{
int s;
switch (type) {
case T_BREAKPOINT: /* breakpoint */
case -1: /* keyboard interrupt */
break;
default:
if (db_recover != 0) {
/* This will longjmp back into db_command_loop() */
db_error("Faulted in DDB; continuing...\n");
/*NOTREACHED*/
}
}
/* Should switch to kdb`s own stack here. */
ddb_regs = *regs;
s = splhigh();
db_active++;
cnpollc(TRUE);
db_trap(type, 0/*code*/);
cnpollc(FALSE);
db_active--;
splx(s);
*regs = ddb_regs;
return (1);
}
static int DBClosureLua(lua_State* l)
{
if (! lins_database) lins_database = new_database();
int n = lua_gettop(l);
str qry = lua2str(lua_upvalueindex(1));
for (int i = 1; i <= n; ++i)
qry = append(qry,_("'%s'%s", lua2str(i), i < n ? _(","): _("")));
lua_pop(l,n);
qry = append(qry,_(")"));
int res = query(qry);
if (res < 0) {
str2lua(db_error());
return 1;
}
lua_newtable(l);
n = lua_gettop(l);
for (int i = 0; i < res; ++i) {
lua_pushnumber(l,i+1);
lua_newtable(l);
for (int j = 0; j < fields(); ++j) {
str2lua(field(j));
str2lua(fetch(i,j));
lua_settable(l,n+2);
}
lua_settable(l,n);
}
return 1;
}
/*!
\fn
\brief
\return
\param
*/
int
db_convert_value_to_string(dbValue * value, int sqltype, dbString * string)
{
char buf[64];
const char *bp = buf;
if (db_test_value_isnull(value)) {
*buf = 0;
}
else {
switch (db_sqltype_to_Ctype(sqltype)) {
case DB_C_TYPE_INT:
sprintf(buf, "%d", db_get_value_int(value));
break;
case DB_C_TYPE_DOUBLE:
sprintf(buf, "%.15g", db_get_value_double(value));
G_trim_decimal(buf);
break;
case DB_C_TYPE_STRING:
bp = db_get_value_string(value);
break;
case DB_C_TYPE_DATETIME:
return db_convert_value_datetime_into_string(value, sqltype,
string);
default:
db_error
("db_convert_value_into_string(): unrecongized sqltype-type");
return DB_FAILED;
}
}
return db_set_string(string, bp);
}
/*!
\fn
\brief
\return
\param
*/
int
db_convert_Cstring_to_value(const char *Cstring, int sqltype, dbValue * value)
{
int i;
double d;
switch (db_sqltype_to_Ctype(sqltype)) {
case DB_C_TYPE_STRING:
return db_set_value_string(value, Cstring);
case DB_C_TYPE_INT:
i = 0;
sscanf(Cstring, "%d", &i);
db_set_value_int(value, i);
break;
case DB_C_TYPE_DOUBLE:
d = 0.0;
sscanf(Cstring, "%lf", &d);
db_set_value_double(value, d);
break;
case DB_C_TYPE_DATETIME:
return db_convert_Cstring_to_value_datetime(Cstring, sqltype, value);
default:
db_error("db_convert_Cstring_to_value(): unrecognized sqltype");
return DB_FAILED;
}
return DB_OK;
}
