static mapping_t * fetch_into_mapping( hDBC * handle ) { int i; mapping_t * map; svalue_t * key, * value; STORE_DOUBLE_USED; map = allocate_mapping( handle->colcnt, 1 ); MEM_CHECK( map ); for( i = 0; i < handle->colcnt; ++i ) { if ( !handle->columns[ i ] ) continue; //printf( " fetch_into_mapping[%2d] ", i ); key = pxalloc( sizeof( svalue_t ) ); MEM_CHECK( key ); put_malloced_string( key, string_copy( handle->columns[ i ]->name ) ); value = get_map_lvalue( map, key ); MEM_CHECK( value ); switch( handle->columns[ i ]->type ){ case T_FLOAT: //printf( "float=%f\n", handle->columns[ i ]->data.double_v ); STORE_DOUBLE( value, *handle->columns[ i ]->data.double_v ); value->type = T_FLOAT; break; case T_NUMBER: //printf( "number=%d\n", *handle->columns[ i ]->data.number_v ); put_number( value, *handle->columns[ i ]->data.number_v ); break; case T_STRING: default : //printf( "string=%s\n", handle->columns[ i ]->data.string_v ); put_malloced_string( value, string_copy( handle->columns[ i ]->data.string_v ) ); break; } } return( map ); }
void f_db_fetch (void) { db_t *db; array_t *ret; valid_database("fetch", &the_null_array); db = find_db_conn((sp-1)->u.number); if (!db) { error("Attempt to fetch from an invalid database handle\n"); } if (db->type->fetch) { ret = db->type->fetch(&(db->c), sp->u.number); } else { ret = &the_null_array; } pop_stack(); if (!ret) { if (db->type->error) { char *errormsg; errormsg = db->type->error(&(db->c)); put_malloced_string(errormsg); } else { sp->u.number = 0; } } else { put_array(ret); } }
void f_socket_address (void) { char *str; int local, port; char addr[ADDR_BUF_SIZE]; char buf[2 * ADDR_BUF_SIZE]; /* a bit of overkill to be safe */ /* * Ok, we will add in a cute little check thing here to see if it is * an object or not... */ local = (sp--)->u.number; if (sp->type & T_OBJECT) { char *tmp; /* This is so we can get the address of interactives as well. */ if (!sp->u.ob->interactive) { free_object(sp->u.ob, "f_socket_address:1"); *sp = const0u; return; } tmp = inet_ntoa(sp->u.ob->interactive->addr.sin_addr); sprintf(buf, "%s %d", tmp, ntohs(sp->u.ob->interactive->addr.sin_port)); str = string_copy(buf, "f_socket_address"); free_object(sp->u.ob, "f_socket_address:2"); put_malloced_string(str); return; } get_socket_address(sp->u.number, addr, &port, local); sprintf(buf, "%s %d", addr, port); str = string_copy(buf, "f_socket_address"); put_malloced_string(str); } /* f_socket_address() */
void f_db_exec (void) { int ret = 0; db_t *db; array_t *info; info = allocate_empty_array(1); info->item[0].type = T_STRING; info->item[0].subtype = STRING_MALLOC; info->item[0].u.string = string_copy(sp->u.string, "f_db_exec"); valid_database("exec", info); db = find_db_conn((sp-1)->u.number); if (!db) { error("Attempt to exec on an invalid database handle\n"); } #ifdef PACKAGE_ASYNC if(!db_mut){ db_mut = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); pthread_mutex_init(db_mut, NULL); } pthread_mutex_lock(db_mut); #endif if (db->type->cleanup) { db->type->cleanup(&(db->c)); } if (db->type->execute) { ret = db->type->execute(&(db->c), sp->u.string); } pop_stack(); if (ret == -1) { if (db->type->error) { char *errormsg; errormsg = db->type->error(&(db->c)); put_malloced_string(errormsg); } else { put_constant_string("Unknown error"); } } else { sp->u.number = ret; } #ifdef PACKAGE_ASYNC pthread_mutex_unlock(db_mut); #endif }
/************************************************************************* * f_sql_column_names( int handle ) * * returns the returned column names of the last executed statement *************************************************************************/ svalue_t * f_sql_column_names( svalue_t * argv, int argc ) { #if ODBC_DEBUG & DEBUG_FUNC printf( "call f_sql_column_names( )\n" ); #endif int id, cnt, i; hDBC * handle; vector_t * vec; TYPE_TEST1( argv, T_NUMBER ); id = argv->u.number; free_svalue( argv ); if ( !(handle = get_db_connection_by_id( id )) ) { errorf( "Illegal handle for database.\n" ); return( NULL ); } if ( !handle->columns ) { vec = allocate_array( 0 ); MEM_CHECK( vec ); put_array( argv, vec ); return( argv ); } cnt = handle->colcnt; vec = allocate_array( cnt ); MEM_CHECK( vec ); for ( i = 0; i < cnt; ++i ) { if ( handle->columns[ i ] ) put_malloced_string(vec->item + i, string_copy( handle->columns[ i ]->name ) ); } put_array( argv, vec ); #if ODBC_DEBUG & DEBUG_FUNC printf( "ret f_sql_column_names( )\n" ); #endif return( argv ); }
void f_B2G () { int i; char *istr, *ostr; istr = (char *)sp->u.string; i = SVALUE_STRLEN(sp); if(i == 0) { push_number(0); free_string_svalue(sp); return; } ostr = new_string(i, "f_B2G"); Big2GB(istr, ostr, i); free_string_svalue(sp); put_malloced_string(ostr); }
static vector_t * fetch_into_vector( hDBC * handle ) { int i; vector_t * vec; STORE_DOUBLE_USED; vec = allocate_array( handle->colcnt ); MEM_CHECK( vec ); for( i = 0; i < handle->colcnt; ++i ) { if ( !handle->columns[ i ] ) continue; //printf( " fetch_into_vector[%2d] ", i ); switch( handle->columns[ i ]->type ){ case T_FLOAT: //printf( "float=%f\n", handle->columns[ i ]->data.double_v ); STORE_DOUBLE( vec->item + i, *handle->columns[ i ]->data.double_v ); ( vec->item + i)->type = T_FLOAT; break; case T_NUMBER: //printf( "number=%d\n", *handle->columns[ i ]->data.number_v ); put_number( vec->item + i, *handle->columns[ i ]->data.number_v ); break; case T_STRING: default : //printf( "string=%s\n", handle->columns[ i ]->data.string_v ); put_malloced_string( vec->item + i, string_copy( handle->columns[ i ]->data.string_v ) ); break; } } return( vec ); }
void f_traceprefix (void) { char *old = 0; if (command_giver && command_giver->interactive) { old = command_giver->interactive->trace_prefix; if (sp->type & T_STRING) { const char *p = sp->u.string; if (*p == '/') p++; command_giver->interactive->trace_prefix = make_shared_string(p); free_string_svalue(sp); } else command_giver->interactive->trace_prefix = 0; } if (old) { put_malloced_string(add_slash(old)); free_string(old); } else *sp = const0; }
/************************************************************************* * string f_sql_error( int handle ) * * returns the last encountered error *************************************************************************/ svalue_t * f_sql_error( svalue_t * argv, int argc ) { #if ODBC_DEBUG & DEBUG_FUNC printf( "call f_sql_error( )\n" ); #endif int id, cnt, i; hDBC * handle; char * err; TYPE_TEST1( argv, T_NUMBER ); id = argv->u.number; free_svalue( argv ); if ( !(handle = get_db_connection_by_id( id )) ) { errorf( "Illegal handle for database.\n" ); return( NULL ); } if ( handle->hStmt ) { err = extract_diagnostics_info( SQL_HANDLE_STMT, handle->hStmt ); } else { err = extract_diagnostics_info( SQL_HANDLE_DBC, handle->hDBCon ); } if ( err ) { put_malloced_string( argv, err ); } else { put_number( argv, 0 ); } #if ODBC_DEBUG & DEBUG_FUNC printf( "ret f_sql_error( )\n" ); #endif return( argv ); }
void f_bg5cc () { char *istr, *ostr, *ret; unsigned char s; istr = (char *)sp->u.string; if(SVALUE_STRLEN(sp) == 0) push_number(0); if(!strchr(istr, '\\')) { ret = string_copy(istr, "f_bg5cc"); } else { ostr = ret = new_string(max_string_length, "f_bg5cc"); while(*istr) { *ostr++ = s = *istr++; if(is_B51(s)) { *ostr++ = s = *istr++; if(s == '\\' && *istr != '\\') *ostr++ = s; } } *ostr = '\0'; } free_string_svalue(sp); put_malloced_string(ret); }
void f_cwrap () { register int i, j; int width, slen, blanks; register char *istr, *ostr, *ret; if(st_num_arg >= 2) { if(st_num_arg == 3) { blanks = sp->u.number; pop_stack(); if(blanks < 0) blanks = 0; } else blanks = 4; width = sp->u.number; pop_stack(); if(width < 2) width = 64; if(width - blanks < 2) { width = 64; blanks = 4; } } else { blanks = 4; width = 64; } istr = (char *)sp->u.string; slen = SVALUE_STRLEN(sp); if(slen < blanks) blanks = 0; i = blanks; ostr = ret = new_string(slen+slen/width+blanks, "f_cwrap"); while(blanks--) *ostr++ = ' '; while(*istr) { if(*istr == '\n') { istr++; continue; } if(istr[0] == 27 && istr[1] == '[') { j=2; while(istr[j] && (isdigit(istr[j]) || istr[j]==';')) j++; if(istr[j++] == 'm') { while(j--) *ostr++ = *istr++; continue; } } i++; *ostr++ = *istr++; if(is_B51((unsigned char)*(istr-1))) { i++; *ostr++ = *istr++; } else if((unsigned char)*(istr-1) == '\t') i += 4; if(i >= width) { *ostr++ = '\n'; i = 0; } } *ostr = '\0'; ostr = string_copy(ret, "f_cwrap"); FREE_MSTR(ret); free_string_svalue(sp); put_malloced_string(ostr); }
/************************************************************************* * f_sql_odbc_datasources( void ) * * returns a mapping of all defined datasources. * ([ name : description ]) *************************************************************************/ svalue_t * f_sql_odbc_datasources( svalue_t * argv, int argc ) { #if ODBC_DEBUG & DEBUG_FUNC printf( "call f_sql_odbc_datasources( )\n" ); #endif SQLRETURN ret; char * err; char dsName[ 256 ], dsDescription[ 256 ]; SQLSMALLINT dsNameLen, dsDescriptionLen; mapping_t * map; svalue_t * key; svalue_t * value; argv++; err = init_odbc_environment(); if ( err ) { errorf( err ); return( NULL ); } map = allocate_mapping( 0, 1 ); MEM_CHECK( map ); do { ret = SQLDataSources( hODBCEnv->hODBCEnv, SQL_FETCH_NEXT, dsName, 256, &dsNameLen, dsDescription, 256, &dsDescriptionLen ); if ( SQL_SUCCEEDED( ret ) ) { key = pxalloc( sizeof( svalue_t ) ); put_malloced_string( key, string_copy( dsName ) ); value = get_map_lvalue( map, key ); MEM_CHECK( value ); put_malloced_string( value, string_copy( dsDescription ) ); } } while( SQL_SUCCEEDED( ret ) ); if ( ret != SQL_NO_DATA ) { char * err; err = extract_diagnostics_info( SQL_HANDLE_ENV, hODBCEnv->hODBCEnv ); free_mapping( map ); errorf( (err?err:"Failed to fetch datasource information.\n") ); return( NULL ); } put_mapping( argv, map ); #if ODBC_DEBUG & DEBUG_FUNC printf( "ret f_sql_odbc_datasources( )\n" ); #endif return( argv ); }