bool CODBC_RPCCmd::xCheck4MoreResults()
{
// int rc = CheckSIE(SQLMoreResults(GetHandle()),
// "SQLMoreResults failed", 420015);
//
// return (rc == SQL_SUCCESS_WITH_INFO || rc == SQL_SUCCESS);
switch(SQLMoreResults(GetHandle())) {
case SQL_SUCCESS_WITH_INFO: ReportErrors();
case SQL_SUCCESS: return true;
case SQL_NO_DATA: return false;
case SQL_ERROR:
ReportErrors();
{
string err_message = "SQLMoreResults failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 420014 );
}
default:
{
string err_message = "SQLMoreResults failed (memory corruption suspected)." +
GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 420015 );
}
}
}
bool CODBC_RowResult::Fetch()
{
m_CurrItem = -1;
m_LastReadData.resize(0);
m_HasMoreData = false;
if (!m_EOR) {
switch (SQLFetch(GetHandle())) {
case SQL_SUCCESS_WITH_INFO:
ReportErrors();
case SQL_SUCCESS:
m_CurrItem = 0;
m_HasMoreData = true;
if ( m_RowCountPtr != NULL ) {
++(*m_RowCountPtr);
}
return true;
case SQL_NO_DATA:
m_EOR = true;
break;
case SQL_ERROR:
ReportErrors();
{
string err_message = "SQLFetch failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430003 );
}
default:
{
string err_message = "SQLFetch failed (memory corruption suspected)." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430004 );
}
}
}
return false;
}
bool CODBC_RowResult::CheckSIENoD_Binary(CDB_Stream* val)
{
SQLLEN f = 0;
char buffer[8*1024];
switch(SQLGetData(GetHandle(), m_CurrItem+1, SQL_C_BINARY, buffer, sizeof(buffer), &f)) {
case SQL_SUCCESS_WITH_INFO:
if(f == SQL_NO_TOTAL || f > SQLLEN(sizeof(buffer))) f = sizeof(buffer);
else ReportErrors();
case SQL_SUCCESS:
if(f > 0) {
if(f > SQLLEN(sizeof(buffer))) f = sizeof(buffer);
val->Append(buffer, f);
}
return true;
case SQL_NO_DATA:
break;
case SQL_ERROR:
ReportErrors();
default:
{
DATABASE_DRIVER_ERROR(
string("SQLGetData failed while retrieving BLOB into C") +
CDB_Object::GetTypeName(val->GetType()) + '.',
430022);
}
}
return false;
}
int CODBC_RowResult::xGetData(SQLSMALLINT target_type, SQLPOINTER buffer,
SQLINTEGER buffer_size)
{
SQLLEN f;
switch(SQLGetData(GetHandle(), m_CurrItem+1, target_type, buffer, buffer_size, &f)) {
case SQL_SUCCESS_WITH_INFO:
switch(f) {
case SQL_NO_TOTAL:
return buffer_size;
case SQL_NULL_DATA:
return 0;
default:
if(f < 0)
ReportErrors();
return (int)f;
}
case SQL_SUCCESS:
if(target_type == SQL_C_CHAR) buffer_size--;
return (f > buffer_size)? buffer_size : (int)f;
case SQL_NO_DATA:
return 0;
case SQL_ERROR:
ReportErrors();
default:
{
string err_message = "SQLGetData failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430027 );
}
}
}
CODBC_RowResult::CODBC_RowResult(
CStatementBase& stmt,
SQLSMALLINT nof_cols,
SQLLEN* row_count
)
: m_Stmt(stmt)
, m_CurrItem(-1)
, m_EOR(false)
, m_RowCountPtr( row_count )
, m_HasMoreData(false)
{
odbc::TSqlChar column_name_buff[eODBC_Column_Name_Size];
if(m_RowCountPtr) *m_RowCountPtr = 0;
SQLSMALLINT actual_name_size;
SQLSMALLINT nullable;
m_ColFmt = new SODBC_ColDescr[nof_cols];
for (unsigned int n = 0; n < (unsigned int)nof_cols; ++n) {
// SQLDescribeCol takes a pointer to a buffer.
switch(SQLDescribeCol(GetHandle(),
n + 1,
column_name_buff,
eODBC_Column_Name_Size * sizeof(odbc::TSqlChar),
&actual_name_size,
&m_ColFmt[n].DataType,
&m_ColFmt[n].ColumnSize,
&m_ColFmt[n].DecimalDigits,
&nullable)) {
case SQL_SUCCESS_WITH_INFO:
ReportErrors();
case SQL_SUCCESS:
m_ColFmt[n].ColumnName =
CODBCString(column_name_buff,
actual_name_size).ConvertTo(GetClientEncoding());
break;
case SQL_ERROR:
ReportErrors();
{
string err_message = "SQLDescribeCol failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 420020 );
}
default:
{
string err_message = "SQLDescribeCol failed (memory corruption suspected)." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 420021 );
}
}
m_CachedRowInfo.Add(
m_ColFmt[n].ColumnName,
m_ColFmt[n].ColumnSize,
s_GetDataType(m_ColFmt[n].DataType,
m_ColFmt[n].DecimalDigits,
m_ColFmt[n].ColumnSize)
);
}
}
BEGIN_NCBI_SCOPE
#define DBDATETIME4_days(x) ((x)->numdays)
#define DBDATETIME4_mins(x) ((x)->nummins)
#define DBNUMERIC_val(x) ((x)->val)
#define SQL_VARLEN_DATA (-10)
/////////////////////////////////////////////////////////////////////////////
//
// CODBC_BCPInCmd::
//
CODBC_BCPInCmd::CODBC_BCPInCmd(CODBC_Connection& conn,
SQLHDBC cmd,
const string& table_name) :
CStatementBase(conn, table_name),
m_Cmd(cmd),
m_HasTextImage(false),
m_WasBound(false)
{
string extra_msg = "Table Name: " + table_name;
SetDbgInfo( extra_msg );
if (bcp_init(cmd,
CODBCString(table_name, GetClientEncoding()).AsCWString(),
0, 0, DB_IN) != SUCCEED) {
ReportErrors();
string err_message = "bcp_init failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 423001 );
}
++m_RowCount;
}
int cLuaState::CallFunctionWithForeignParams(
const AString & a_FunctionName,
cLuaState & a_SrcLuaState,
int a_SrcParamStart,
int a_SrcParamEnd
)
{
ASSERT(IsValid());
ASSERT(a_SrcLuaState.IsValid());
// Store the stack position before any changes
int OldTop = lua_gettop(m_LuaState);
// Push the function to call, including the error handler:
if (!PushFunction(a_FunctionName.c_str()))
{
LOGWARNING("Function '%s' not found", a_FunctionName.c_str());
lua_settop(m_LuaState, OldTop);
return -1;
}
// Copy the function parameters to the target state
if (CopyStackFrom(a_SrcLuaState, a_SrcParamStart, a_SrcParamEnd) < 0)
{
// Something went wrong, fix the stack and exit
lua_settop(m_LuaState, OldTop);
m_NumCurrentFunctionArgs = -1;
m_CurrentFunctionName.clear();
return -1;
}
// Call the function, with an error handler:
int s = lua_pcall(m_LuaState, a_SrcParamEnd - a_SrcParamStart + 1, LUA_MULTRET, OldTop + 1);
if (ReportErrors(s))
{
LOGWARN("Error while calling function '%s' in '%s'", a_FunctionName.c_str(), m_SubsystemName.c_str());
// Reset the stack:
lua_settop(m_LuaState, OldTop);
// Reset the internal checking mechanisms:
m_NumCurrentFunctionArgs = -1;
m_CurrentFunctionName.clear();
// Make Lua think everything is okay and return 0 values, so that plugins continue executing.
// The failure is indicated by the zero return values.
return 0;
}
// Reset the internal checking mechanisms:
m_NumCurrentFunctionArgs = -1;
m_CurrentFunctionName.clear();
// Remove the error handler from the stack:
lua_remove(m_LuaState, OldTop + 1);
// Return the number of return values:
return lua_gettop(m_LuaState) - OldTop;
}
void LuaState::Execute(const char* command)
{
auto status = luaL_loadstring(_state, command);
if (status)
ReportErrors();
else
Execute();
}
bool CODBC_RowResult::CheckSIENoD_WText(CDB_Stream* val)
{
int rc = 0;
SQLLEN f = 0;
wchar_t buffer[4*1024];
rc = SQLGetData(GetHandle(), m_CurrItem + 1, SQL_C_WCHAR, buffer, sizeof(buffer), &f);
switch( rc ) {
case SQL_SUCCESS_WITH_INFO:
if(f == SQL_NO_TOTAL) {
f = sizeof(buffer) - 1;
} else if(f < 0) {
ReportErrors();
}
case SQL_SUCCESS:
if(f > 0) {
if(f > SQLLEN(sizeof(buffer) - 1)) {
f = sizeof(buffer)-1;
}
f = f / sizeof(wchar_t);
string encoded_value = CODBCString(buffer, f).ConvertTo(GetClientEncoding());
val->Append(encoded_value.data(), encoded_value.size());
}
return true;
case SQL_NO_DATA:
break;
case SQL_ERROR:
ReportErrors();
default:
{
DATABASE_DRIVER_ERROR(
string("SQLGetData failed while retrieving BLOB into C") +
CDB_Object::GetTypeName(val->GetType()) + '.',
430021);
}
}
return false;
}
void ExecCommonFile(char *File) // WORK
{
lua_State *L = lua_open();
luaL_openlibs(L);
RegisterBasicFunctions(L);
int s = luaL_loadfile(L, File);
if (s == 0)
s = lua_pcall(L, 0, LUA_MULTRET, 0);
ReportErrors(L, s);
lua_close(L);
}
// ASyn task
TASKTYPE TASKMOD ASyn_Task(void * p)
{
ASyn *asp = (ASyn *)p;
APacket pkt,mkr;
char buf[100],cname[100];
HEventRec e;
try{
strcpy(cname,asp->cname.c_str());
asp->ackbuf->RequestBufferEvents(ACKBUFID);
asp->RequestMessageEvents();
while (!asp->IsTerminated()){
e = HGetEvent(0,0);
switch(e.event){
case HTBUFFER:
switch(e.c){
case MSGEVENTID:
asp->ChkMessage();
while (asp->IsSuspended()) asp->ChkMessage(TRUE);
break;
case ACKBUFID:
asp->ChkAckBuf();
break;
} /* switch(e.c) */
break;
case HWINCLOSE:
sprintf(buf, "terminating");
HPostMessage(HThreadSelf(),buf);
asp->terminated = TRUE;
break;
}
}
if (asp->trace&T_TOP) printf("%s synthesiser exiting\n",asp->cname.c_str());
HExitThread(0);
return 0;
}
catch (ATK_Error e){ ReportErrors("ATK",e.i); return 0;}
catch (HTK_Error e){ ReportErrors("HTK",e.i); return 0;}
}
bool cLuaState::LoadFile(const AString & a_FileName)
{
ASSERT(IsValid());
// Load the file:
int s = luaL_loadfile(m_LuaState, a_FileName.c_str());
if (ReportErrors(s))
{
LOGWARNING("Can't load %s because of an error in file %s", m_SubsystemName.c_str(), a_FileName.c_str());
return false;
}
// Execute the globals:
s = lua_pcall(m_LuaState, 0, LUA_MULTRET, 0);
if (ReportErrors(s))
{
LOGWARNING("Error in %s in file %s", m_SubsystemName.c_str(), a_FileName.c_str());
return false;
}
return true;
}
bool CODBC_BCPInCmd::CommitBCPTrans(void)
{
if(WasSent()) {
Int4 outrow = bcp_batch(GetHandle());
if(outrow == -1) {
SetHasFailed();
ReportErrors();
DATABASE_DRIVER_ERROR( "bcp_batch failed." + GetDbgInfo(), 423006 );
return false;
}
return true;
}
return false;
}
bool CODBC_BCPInCmd::EndBCP(void)
{
if(WasSent()) {
Int4 outrow = bcp_done(GetHandle());
if(outrow == -1) {
SetHasFailed();
ReportErrors();
DATABASE_DRIVER_ERROR( "bcp_done failed." + GetDbgInfo(), 423007 );
return false;
}
SetWasSent(false);
return true;
}
return false;
}
TASKTYPE TASKMOD CopyFe(void *p)
{
ATee *acp = (ATee *)p;
APacket pkt;
HEventRec e;
try{
acp->in->RequestBufferEvents(INBUFID);
acp->RequestMessageEvents();
while(!acp->IsTerminated()){
e = HGetEvent(0,0);
switch(e.event){
case HTBUFFER:
switch(e.c) {
case MSGEVENTID:
acp->ChkMessage();
while (acp->IsSuspended()) acp->ChkMessage(TRUE);
break;
case INBUFID:
if (! acp->in->IsEmpty()) {
while (! acp->in->IsEmpty()) {
pkt=acp->in->GetPacket();
acp->out1->PutPacket(pkt);
acp->out2->PutPacket(pkt);
}
}
break;
}
}
}
HExitThread(0);
return 0;
}
catch (ATK_Error e){ReportErrors("ATK",e.i); return 0;}
catch (HTK_Error e){ReportErrors("HTK",e.i); return 0;}
}
bool cLuaState::CallFunction(int a_NumResults)
{
ASSERT (m_NumCurrentFunctionArgs >= 0); // A function must be pushed to stack first
ASSERT(lua_isfunction(m_LuaState, -m_NumCurrentFunctionArgs - 1));
int s = lua_pcall(m_LuaState, m_NumCurrentFunctionArgs, a_NumResults, 0);
if (ReportErrors(s))
{
LOGWARNING("Error in %s calling function %s()", m_SubsystemName.c_str(), m_CurrentFunctionName.c_str());
m_NumCurrentFunctionArgs = -1;
m_CurrentFunctionName.clear();
return false;
}
m_NumCurrentFunctionArgs = -1;
m_CurrentFunctionName.clear();
return true;
}
void ModelViewController::RunLua(char* script)
{
#ifdef ENABLE_LUA
try{
lua_State *myLuaState = lua_open(); // Create a new lua state
luabind::open(myLuaState); // Connect LuaBind to this lua state
luaL_openlibs(myLuaState);
// Add our function to the state's global scope
luabind::module(myLuaState) [
luabind::def("print_hello", print_hello)
];
luabind::module(myLuaState)
[
luabind::class_<ModelViewController>("ModelViewController")
.def("ReadStl", &ModelViewController::ReadStl) // To use: base:ReadStl("c:/Vertex.stl")
.def("ConvertToGCode", &ModelViewController::ConvertToGCode) // To use: base:ConvertToGCode()
.def("ClearGCode", &ModelViewController::ClearGcode) // To use: base:ClearGcode()
.def("AddText", &ModelViewController::AddText) // To use: base:AddText("text\n")
.def("Print", &ModelViewController::SimplePrint) // To use: base:Print()
];
luabind::globals(myLuaState)["base"] = this;
// Now call our function in a lua script, such as "print_hello(5)"
if luaL_dostring( myLuaState, script)
ReportErrors(myLuaState);
lua_close(myLuaState);
}// try
catch(const std::exception &TheError)
{
cerr << TheError.what() << endl;
}
refreshGraphicsView (this);
#endif // ENABLE_LUA
}
// ARec task
TASKTYPE TASKMOD ARec_Task(void * p)
{
ARec *avp = (ARec *)p;
char buf[100],cname[100];
HEventRec e;
try{
strcpy(cname,avp->cname.c_str());
if (avp->showRD){
avp->win = MakeHWin(cname,avp->rdx0,avp->rdy0,avp->width,avp->height,1);
avp->InitDrawRD();
}
// Initialise Recogniser
avp->InitRecogniser();
avp->in->RequestBufferEvents(INBUFID);
avp->RequestMessageEvents();
while (!avp->IsTerminated()){
e = HGetEvent(0,0);
if (avp->trace&T_RST)
printf(" ARec event=%d ev.c=%d state=%d mode=%o\n",
e.event,e.c,(int)avp->runstate,(int)avp->runmode);
switch(e.event){
case HTBUFFER:
switch(e.c){
case MSGEVENTID:
avp->ChkMessage();
while (avp->IsSuspended()) avp->ChkMessage(TRUE);
if (avp->runstate==ANS_STATE){
avp->ComputeAnswer();
avp->runstate = (avp->runmode&CONTINUOUS_MODE)?PRIME_STATE:WAIT_STATE;
}
break;
case INBUFID:
switch (avp->runstate) {
case PRIME_STATE:
avp->PrimeRecogniser();
avp->runstate = FLUSH_STATE;
case FLUSH_STATE:
if (avp->FlushObservation()) {
if (avp->terminated) break; // only possible if file input
avp->runstate = RUN_STATE;
} else
break;
case RUN_STATE:
if (avp->RecObservation())
avp->runstate = ANS_STATE;
else
break;
case ANS_STATE:
avp->ComputeAnswer();
avp->runstate = (avp->runmode&CONTINUOUS_MODE)?PRIME_STATE:WAIT_STATE;
break;
}
// update display
if (avp->showRD) avp->DrawStatus();
break;
}
break;
case HWINCLOSE:
sprintf(buf, "Terminating\n");
HPostMessage(HThreadSelf(),buf);
avp->terminated = TRUE;
break;
}
}
// forward a terminated message to output buffer
if (avp->trace&T_TOP) printf("%s recogniser exiting\n",avp->cname.c_str());
avp->SendMarkerPkt("TERMINATED");
HExitThread(0);
return 0;
}
catch (ATK_Error e){ ReportErrors("ATK",e.i); return 0;}
catch (HTK_Error e){ ReportErrors("HTK",e.i); return 0;}
}
bool cLuaState::ReportErrors(int a_Status)
{
return ReportErrors(m_LuaState, a_Status);
}
void LuaState::Call(int nargs, int nresults)
{
auto status = lua_pcall(_state, nargs, nresults, 0);
if (status) ReportErrors();
}
void LuaState::ExecuteFile(const char* path)
{
auto status = luaL_dofile(_state, path);
if (status) ReportErrors();
}
int cTumkwsaSink::setupATK()
{
try {
// ------- load HTK config......
int argc=3;
const char* argv[3] = {"ASR","-C",NULL};
if (configfile != NULL)
argv[2]=configfile;
else
argv[2]="asr.cfg";
if (InitHTK(argc,(char**)argv,version,TRUE)<SUCCESS){
COMP_ERR("failed to initialise ASR subsystem!");
}
ConfParam *cParm[MAXGLOBS]; /* config parameters */
int numParm,i;
char ngramFN[100],buf[100];
ngramFN[0] = '\0';
// Read configuration parms for ANGRAM to see if NGram used
numParm = GetConfig((char *)"ANGRAM", TRUE, cParm, MAXGLOBS);
if (numParm>0){
if (GetConfStr(cParm,numParm,(char *)"NGRAMFILE",buf)) strcpy(ngramFN,buf);
}
// Create Buffers
feChan = new ABuffer("feChan");
ansChan = new ABuffer("ansChan");
// create a resource manager
rman = new ARMan();
arec = new ARec("ARec",feChan,ansChan,rman,0);
// create global resources
hset = new AHmms("HmmSet"); // load info in config
dict = new ADict("ADict");
gram = new AGram("AGram");
rman->StoreHMMs(hset);
rman->StoreDict(dict);
rman->StoreGram(gram);
ResourceGroup *main = rman->NewGroup("main");
main->AddHMMs(hset);
main->AddDict(dict);
main->AddGram(gram);
if (strlen(ngramFN)>0){
ANGram * ngram = new ANGram("ANGram");
rman->StoreNGram(ngram);
main->AddNGram(ngram);
}
arec->Start();
arec->SendMessage("usegrp(main)");
arec->SendMessage("start()");
terminated = FALSE;
}
catch (ATK_Error e){ ReportErrors((char*)"ATK",e.i); return 0;}
catch (HTK_Error e){ ReportErrors((char*)"HTK",e.i); return 0;}
HThread t = HCreateThread("resultThread", 0, HPRIO_NORM, ATKresultThreadRunner, this);
ATKresThread = t->thread;
//smileThreadCreate( ATKresThread, ATKresultThreadRunner, this );
atkIsSetup=1;
return 1;
}
size_t CODBC_RowResult::ReadItem(void* buffer,size_t buffer_size,bool* is_null)
{
if ((unsigned int) m_CurrItem >= GetDefineParams().GetNum() || m_CurrItem == -1 ||
buffer == 0 || buffer_size == 0) {
return 0;
}
SQLLEN f = 0;
if(is_null) *is_null= false;
SQLSMALLINT data_type = m_ColFmt[m_CurrItem].DataType;
while (m_HasMoreData && m_LastReadData.size() < buffer_size) {
m_HasMoreData = false;
string next_data;
size_t next_len = 0;
switch(SQLGetData(GetHandle(), m_CurrItem + 1, SQL_C_BINARY, buffer, buffer_size, &f)) {
case SQL_SUCCESS_WITH_INFO:
switch(f) {
case SQL_NO_TOTAL:
next_data.append((char*) buffer, buffer_size);
m_HasMoreData = true;
break;
case SQL_NULL_DATA:
if(is_null) *is_null= true;
break;
default:
if ( f < 0 ) {
ReportErrors();
return 0;
}
m_HasMoreData = true;
next_len = static_cast<size_t>(f);
if (next_len >= buffer_size) {
next_len = buffer_size;
}
next_data.append((char*) buffer, next_len);
break;
}
break;
case SQL_SUCCESS:
if(f == SQL_NULL_DATA) {
if(is_null) *is_null= true;
}
else {
next_len = (f >= 0)? ((size_t)f) : 0;
next_data.append((char*) buffer, next_len);
}
break;
case SQL_NO_DATA:
if(f == SQL_NULL_DATA) {
if(is_null) *is_null= true;
}
break;
case SQL_ERROR:
ReportErrors();
return 0;
default:
{
string err_message = "SQLGetData failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430026 );
}
}
#ifdef HAVE_WSTRING
if (data_type == SQL_WCHAR || data_type == SQL_WVARCHAR || data_type == SQL_WLONGVARCHAR) {
string conv_data
= (CODBCString((wchar_t*) next_data.data(),
next_data.size() / sizeof(wchar_t))
.ConvertTo(GetClientEncoding()));
m_LastReadData += conv_data;
}
else
#endif
{
m_LastReadData += next_data;
}
}
size_t return_len = m_LastReadData.size();
if (return_len > buffer_size) {
return_len = buffer_size;
}
memcpy(buffer, m_LastReadData.data(), return_len);
m_LastReadData = m_LastReadData.substr(return_len);
if (!m_HasMoreData && return_len <= buffer_size) {
++m_CurrItem;
m_HasMoreData = true;
}
return return_len;
}
void LuaState::Execute()
{
auto status = lua_pcall(_state, 0, LUA_MULTRET, 0);
if (status) ReportErrors();
}
~CLogListenerForFileImpl()
{
if( myLogErrors )
ReportErrors();
}
int main(int argc, char *argv[])
{
char *s,*fn;
cst_voice *voice; // synthesis voice
cst_utterance *utt; // current utterance
cst_wave *cstwave; // synthesised wave
Wave w; // HTK wave
short *p;
HTime sampPeriod = 625.0;
int n;
MemHeap mem;
AudioOut a;
try {
if (InitHTK(argc,argv,version)<SUCCESS){
ReportErrors("Main",0); exit(-1);
}
if (NumArgs() !=2) {
printf("SFliteTest synthstring file\n"); exit(0);
}
CreateHeap(&mem,"heap",MSTAK,1,0.0,10000,100000);
s = GetStrArg();
fn = GetStrArg();
printf("Synth: %s -> %s\n",s,fn);
// initialise Edinburgh cst lib
cst_regex_init();
// setup the voice
voice = register_cmu_us_kal16(NULL);
// convert text to waveform
utt = flite_synth_text(s,voice);
if (utt==NULL) {
HRError(12001,"SFliteTest: cant synthesise %s\n",s);
throw ATK_Error(12001);
}
cstwave = utt_wave(utt);
p = cstwave->samples; n = cstwave->num_samples;
w = OpenWaveOutput(&mem,&sampPeriod,n);
printf("%d samples created\n",n);
PutWaveSample(w,n,p);
if (CloseWaveOutput(w,WAV,fn)<SUCCESS){
ReportErrors("Main",0); exit(-1);
}
// explore structure
const cst_item *it, *itlast = NULL;
float x,y;
int i;
string lastword="0"; x = 0;
for (i=1,it = relation_head(utt_relation(utt, "Segment")); it!=NULL; it = item_next(it),i++)
{
printf("Segment %d\n",i);
y = item_feat_float(it,"end");
string ph = string(ffeature_string(it,"p.name"));
string wd = string(ffeature_string(it,"R:SylStructure.parent.parent.name"));
//printf("end = %f ph=%s wd=%s\n",y,ph.c_str(),wd.c_str());
if (wd != lastword){
printf("**** end of %s = %f\n",lastword.c_str(),x);
lastword=wd;
}
x = y;
}
//if (itlast!=NULL) {
// word = string(ffeature_string(itlast,"R:SylStructure.parent.parent.name"));
// idx = text.find(word);
//}
return 0;
}
catch (ATK_Error e){ ReportErrors("ATK",e.i); }
catch (HTK_Error e){ ReportErrors("HTK",e.i); }
return 0;
}
CDB_BlobDescriptor* CODBC_RowResult::GetBlobDescriptor(int item_no,
const string& cond)
{
enum {eNameStrLen = 128};
SQLSMALLINT slp;
odbc::TSqlChar buffer[eNameStrLen];
switch(SQLColAttribute(GetHandle(), item_no + 1,
SQL_DESC_BASE_TABLE_NAME,
(SQLPOINTER)buffer, sizeof(buffer),
&slp, 0)) {
case SQL_SUCCESS_WITH_INFO:
ReportErrors();
case SQL_SUCCESS:
break;
case SQL_ERROR:
ReportErrors();
return 0;
default:
{
string err_message = "SQLColAttribute failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430027 );
}
}
string base_table = CODBCString(buffer, GetClientEncoding()).ConvertTo(GetClientEncoding());
switch(SQLColAttribute(GetHandle(), item_no + 1,
SQL_DESC_BASE_COLUMN_NAME,
(SQLPOINTER)buffer, sizeof(buffer),
&slp, 0)) {
case SQL_SUCCESS_WITH_INFO:
ReportErrors();
case SQL_SUCCESS:
break;
case SQL_ERROR:
ReportErrors();
return 0;
default:
{
string err_message = "SQLColAttribute failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430027 );
}
}
string base_column = CODBCString(buffer, GetClientEncoding()).ConvertTo(GetClientEncoding());
SQLLEN column_type = 0;
switch(SQLColAttribute(GetHandle(), item_no + 1,
SQL_COLUMN_TYPE,
NULL, sizeof(column_type),
&slp, &column_type)) {
case SQL_SUCCESS_WITH_INFO:
ReportErrors();
case SQL_SUCCESS:
break;
case SQL_ERROR:
ReportErrors();
return 0;
default:
{
string err_message = "SQLColAttribute failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430027 );
}
}
CDB_BlobDescriptor::ETDescriptorType type = CDB_BlobDescriptor::eUnknown;
switch (column_type) {
case SQL_BINARY:
case SQL_VARBINARY:
case SQL_LONGVARBINARY:
type = CDB_BlobDescriptor::eBinary;
break;
case SQL_LONGVARCHAR:
type = CDB_BlobDescriptor::eText;
break;
};
return new CDB_BlobDescriptor(base_table, base_column, cond, type);
}
/* LogError : `log' an error at the given position and of the given type, file and lineNo
should contain the __FILE__ and __LINE__ values at point of invocation of LOG_ERROR.
Function can also (optionally, NULL == don't bother) print out the function name of
the error */
void LogError (ErrorType error, tIdent str, tPosition position, char *file, const char *function, int lineNo)
{
static int lastContextNumber = -1;
bool printErrorContext = true;
if (SourceDecorateErrorMessages) /* Decorate error messages with balsa-c source position */
{
if (function)
fprintf (stderr, "[%s:%s:%d] ", file, function, lineNo);
else
fprintf (stderr, "[%s:%d] ", file, lineNo);
}
WriteErrorPosition (stderr, position);
switch (BalsacErrors[error].errorClass)
{
case ReportErrorClass:
fprintf (stderr, " report: ");
printErrorContext = false;
break;
case NoteErrorClass:
fprintf (stderr, " note: ");
break;
case WarningErrorClass:
fprintf (stderr, " warning: ");
WarningCount++;
break;
case DeprecatedFeatureErrorClass:
fprintf (stderr, " deprecation: ");
WarningCount++;
break;
case FatalErrorClass:
fprintf (stderr, " fatal: ");
ErrorCount++;
break;
default:
putc (' ', stderr);
ErrorCount++;
break;
}
if (str == NoIdent)
fprintf (stderr, "%s\n", BalsacErrors[error].prefixString);
else
{
if (*(BalsacErrors[error].prefixString) != '\0')
fprintf (stderr, "%s ", BalsacErrors[error].prefixString);
fprintf (stderr, "`%s' %s\n", PeekString (str), BalsacErrors[error].postfixString);
}
if (printErrorContext)
{
if (!GlobalErrorContext || lastContextNumber != CAR (GlobalErrorContext)->contextNumber)
{
PtrErrorContextList context = GlobalErrorContext;
while (context)
{
fprintf (stderr, " ");
WriteErrorPosition (stderr, context->body->position);
fprintf (stderr, " ");
fprintf (stderr, "%s", context->body->str);
context = CDR (context);
fprintf (stderr, "\n");
}
} else
{
fprintf (stderr, " (same context as previous message)\n");
}
if (GlobalErrorContext)
lastContextNumber = CAR (GlobalErrorContext)->contextNumber;
}
if (BalsacErrors[error].errorClass == FatalErrorClass)
ReportErrors ();
}
int main(int argc, char *argv[])
{
APacket p;
try {
// if (NCInitHTK("TRec.cfg",version)<SUCCESS){
if (InitHTK(argc,argv,version)<SUCCESS){
ReportErrors("Main",0); exit(-1);
}
printf("TRec: Basic Recogniser Test\n");
ConfParam *cParm[MAXGLOBS]; /* config parameters */
int numParm,i;
char ngramFN[100],buf[100];
ngramFN[0] = '\0';
// Read configuration parms for ANGRAM to see if NGram used
numParm = GetConfig("ANGRAM", TRUE, cParm, MAXGLOBS);
if (numParm>0){
if (GetConfStr(cParm,numParm,"NGRAMFILE",buf)) strcpy(ngramFN,buf);
}
printf("TRec: HTK initialised: %s\n",ngramFN);
// Create Buffers
ABuffer auChan("auChan");
ABuffer feChan("feChan");
ABuffer ansChan("ansChan");
printf("TRec: Buffers initialised\n");
// create a resource manager
ARMan rman;
// Create Audio Source and Coder
ASource ain("AIn",&auChan);
ACode acode("ACode",&auChan,&feChan);
ARec arec("ARec",&feChan,&ansChan,&rman,0);
printf("TRec: Components initialised\n");
// create global resources
AHmms hset("HmmSet"); // load info in config
ADict dict("ADict");
AGram gram("AGram");
rman.StoreHMMs(&hset);
rman.StoreDict(&dict);
rman.StoreGram(&gram);
ResourceGroup *main = rman.NewGroup("main");
main->AddHMMs(&hset);
main->AddDict(&dict);
main->AddGram(&gram);
if (strlen(ngramFN)>0){
ANGram * ngram = new ANGram("ANGram");
rman.StoreNGram(ngram);
main->AddNGram(ngram);
}
#ifdef WITHMON
// Create Monitor and Start it
AMonitor amon;
amon.AddComponent(&ain);
amon.AddComponent(&acode);
amon.AddComponent(&arec);
amon.Start();
#endif
// Start components executing
ain.Start();
acode.Start();
arec.Start();
arec.SendMessage("usegrp(main)");
arec.SendMessage("start()");
Boolean terminated = FALSE;
while (!terminated) {
APacket p = ansChan.GetPacket();
if (p.GetKind() == StringPacket){
AStringData * sd = (AStringData *)p.GetData();
if (sd->data.find("TERMINATED") != string::npos) {
terminated = TRUE;
}
}
p.Show();
}
// Shutdown
printf("Waiting for ain\n");
ain.Join();
printf("Waiting for acode\n");
acode.Join();
printf("Waiting for arec\n");
arec.Join();
#ifdef WITHMON
printf("Waiting for monitor\n");
amon.Terminate();
HJoinMonitor();
#endif
return 0;
}
catch (ATK_Error e){ ReportErrors("ATK",e.i); return 0;}
catch (HTK_Error e){ ReportErrors("HTK",e.i); return 0;}
}
bool CODBC_RPCCmd::Send()
{
Cancel();
SetHasFailed(false);
m_HasStatus = false;
// make a language command
string main_exec_query("declare @STpROCrETURNsTATUS int;\nexec @STpROCrETURNsTATUS=");
main_exec_query += GetQuery();
string param_result_query;
CMemPot bindGuard;
string q_str;
if(GetBindParamsImpl().NofParams() > 0) {
SQLLEN* indicator = (SQLLEN*)
bindGuard.Alloc(GetBindParamsImpl().NofParams() * sizeof(SQLLEN));
if (!x_AssignParams(q_str, main_exec_query, param_result_query,
bindGuard, indicator)) {
ResetParams();
SetHasFailed();
string err_message = "Cannot assign params." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 420003 );
}
}
if(NeedToRecompile()) main_exec_query += " with recompile";
q_str += main_exec_query + ";\nselect STpROCrETURNsTATUS=@STpROCrETURNsTATUS";
if(!param_result_query.empty()) {
q_str += ";\nselect " + param_result_query;
}
switch(SQLExecDirect(GetHandle(), CODBCString(q_str, GetClientEncoding()), SQL_NTS)) {
case SQL_SUCCESS:
m_HasMoreResults = true;
break;
case SQL_NO_DATA:
m_HasMoreResults = true; /* this is a bug in SQLExecDirect it returns SQL_NO_DATA if
status result is the only result of RPC */
m_RowCount = 0;
break;
case SQL_ERROR:
ReportErrors();
ResetParams();
SetHasFailed();
{
string err_message = "SQLExecDirect failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 420001 );
}
case SQL_SUCCESS_WITH_INFO:
ReportErrors();
m_HasMoreResults = true;
break;
case SQL_STILL_EXECUTING:
ReportErrors();
ResetParams();
SetHasFailed();
{
string err_message = "Some other query is executing on this connection." +
GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 420002 );
}
case SQL_INVALID_HANDLE:
SetHasFailed();
{
string err_message = "The statement handler is invalid (memory corruption suspected)." +
GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 420004 );
}
default:
ReportErrors();
ResetParams();
SetHasFailed();
{
string err_message = "Unexpected error." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 420005 );
}
}
SetWasSent();
return true;
}
