int dbtcp_fetch(ClipMachine* cm,SQLROWSET* rs,int recs,ClipVar* eval,int every,ClipVar* ors){
DBTCP_ROWSET* rowset = (DBTCP_ROWSET*)rs;
DBTCP_CONN* conn = rowset->conn;
DBTCP_STMT* stmt = rowset->stmt;
int i,j,er = 0,r;
void **rec;
if(rowset->done)
return 0;
if(!recs)
recs = 0x7fffffff;
for(j=0;j<recs;j++){
r = dbftp_fetch_row(conn->conn);
if(r == FETCH_EOF)
goto done;
else if(r == FETCH_ERROR){
dbtcp_error(cm,conn->loc,ER_FETCH,conn->conn,NULL);
er = 1;
goto done;
}
rowset->loaded++;
rec = calloc(rowset->nfields,sizeof(void*));
for(i=0;i<rowset->nfields;i++){
char* tmp = dbftp_fetch_value(conn->conn,i);
int len = strlen(tmp);
rec[i] = calloc(1,len+sizeof(int));
*(int*)rec[i] = len;
memcpy((char*)rec[i]+4,tmp,len);
}
rowset->data = realloc(rowset->data,rowset->loaded*sizeof(void*));
rowset->data[rowset->loaded - 1] = rec;
if(eval && (eval->t.type == CCODE_t || eval->t.type == PCODE_t) && !(rowset->loaded % every)){
ClipVar var,*v;
if(_clip_eval(cm,eval,1,ors,&var)){
_clip_destroy(cm,&var);
er = 1;
goto done;
}
v = _clip_vptr(&var);
if(v->t.type == LOGICAL_t && !v->l.val){
_clip_destroy(cm,&var);
goto done;
}
_clip_destroy(cm,&var);
}
}
return 0;
done:
rowset->lastrec = rowset->loaded;
rowset->done = 1;
if(!rowset->lastrec){
rowset->bof = rowset->eof = 1;
rowset->recno = 0;
}
_clip_destroy_c_item(cm,stmt->stmt_item,_C_ITEM_TYPE_SQL);
return er;
}
int
clip_EVALA(ClipMachine * ClipMachineMemory)
{
int parcount;
ClipVar *params;
ClipVar *bp = _clip_par(ClipMachineMemory, 1);
ClipVar *ap = _clip_par(ClipMachineMemory, 2);
if (!bp || (bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != CCODE_type_of_ClipVarType && bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != PCODE_type_of_ClipVarType))
return 0;
if (!ap || ap->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != ARRAY_type_of_ClipVarType)
{
int r;
r = _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "EVALA");
return _clip_call_errblock(ClipMachineMemory, r);
}
parcount = ap->ClipArrVar_a_of_ClipVar.count_of_ClipArrVar;
params = ap->ClipArrVar_a_of_ClipVar.ClipVar_items_of_ClipArrVar;
//_clip_clip(ClipMachineMemory, funcname, parcount, params, retVal);
return _clip_eval(ClipMachineMemory, bp, parcount, params, RETPTR(ClipMachineMemory));
}
/* Common signal handlers. It called from signal handler in C and passes it to CLIP */
CLIP_DLLEXPORT gint
handle_signals( GtkWidget *widget, C_signal *cs, ClipVar *cv )
{
ClipVar stack[2];
ClipVar res;
int ret = TRUE;
if (!cs) return ret;
if (!cs->cw) return ret;
memset( stack, 0, sizeof(stack) );
_clip_mclone(cs->cw->cmachine, &stack[0], &cs->cw->obj);
//stack[0] = cs->cw->obj;
if (!cs->cw->sigenabled) return FALSE;
if (cv && cv->t.type==MAP_t)
stack[1] = *cv;
else
_clip_map(cs->cw->cmachine,&stack[1]);
_clip_mputn(cs->cw->cmachine,&stack[1], HASH_EVENT, (double)cs->sigid);
memset( &res, 0, sizeof(ClipVar) );
if ( _clip_eval( cs->cw->cmachine, &(cs->cfunc), 2, stack, &res ) == 0 )
ret = res.t.type == LOGICAL_t ? res.l.val : ret;
_clip_destroy(cs->cw->cmachine, &res);
//_clip_destroy(cw->cmachine, &stack[0]);
//_clip_destroy(cw->cmachine, &stack[1]);
return TRUE;
//return ret;
}
static gchar *
translate_func(const gchar * path, gpointer data)
{
C_var *c = (C_var *) data;
ClipVar stack[2];
ClipVar str;
ClipVar res;
memset(&stack, 0, sizeof(stack));
memset(&res, 0, sizeof(ClipVar));
_clip_mclone(c->ClipMachineMemory, &stack[0], &c->co->obj);
_clip_var_str(path, strlen(path), &str);
_clip_mclone(c->ClipMachineMemory, &stack[1], &str);
_clip_eval(c->ClipMachineMemory, &c->cfunc, 2, stack, &res);
_clip_destroy(c->ClipMachineMemory, &res);
_clip_destroy(c->ClipMachineMemory, &str);
_clip_destroy(c->ClipMachineMemory, &stack[0]);
if (res.ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == CHARACTER_type_of_ClipVarType)
return res.ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf;
else
return NULL;
}
int
clip_MAPEVAL(ClipMachine * ClipMachineMemory)
{
ClipVar *obj = _clip_par(ClipMachineMemory, 1);
ClipVar *bp = _clip_par(ClipMachineMemory, 2);
ClipVar *sobj;
int ret;
if (!obj || (obj->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != MAP_type_of_ClipVarType))
return EG_ARG;
if (!bp
|| (bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != CCODE_type_of_ClipVarType
&& bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != PCODE_type_of_ClipVarType && bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != CHARACTER_type_of_ClipVarType))
return EG_ARG;
sobj = ClipMachineMemory->obj;
ClipMachineMemory->obj = obj;
if (bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == CHARACTER_type_of_ClipVarType)
ret =
_clip_eval_macro(ClipMachineMemory, bp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf,
bp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf, RETPTR(ClipMachineMemory));
else
ret = _clip_eval(ClipMachineMemory, bp, ClipMachineMemory->argc - 2, ARGPTR(ClipMachineMemory, 3), RETPTR(ClipMachineMemory));
ClipMachineMemory->obj = sobj;
return ret;
}
int ms_fetch(ClipMachine* mp,SQLROWSET* rs,int recs,ClipVar* eval,int every,ClipVar* ors){
MS_ROWSET* rowset = (MS_ROWSET*)rs;
MS_STMT* stmt = rowset->stmt;
MYSQL_ROW row;
int i,j,er = 0;
unsigned long *lens;
void **rec;
if(rowset->done)
return 0;
if(!recs)
recs = 0x7fffffff;
for(j=0;j<recs;j++){
row = mysql_fetch_row(stmt->res);
if(!row)
goto done;
rowset->loaded++;
rec = calloc(rowset->nfields,sizeof(void*));
lens = mysql_fetch_lengths(stmt->res);
for(i=0;i<rowset->nfields;i++){
if(row[i]){
rec[i] = malloc(lens[i] + 4);
*((int *) (rec[i])) = (int) lens[i];
memcpy(((char *) rec[i]) + 4, row[i], lens[i]);
} else {
rec[i] = NULL;
}
}
rowset->data = realloc(rowset->data,rowset->loaded*sizeof(void*));
rowset->data[rowset->loaded - 1] = rec;
if(eval && (eval->t.type == CCODE_t || eval->t.type == PCODE_t) && !(rowset->loaded % every)){
ClipVar var,*v;
if(_clip_eval(mp,eval,1,ors,&var)){
_clip_destroy(mp,&var);
er = 1;
goto done;
}
v = _clip_vptr(&var);
if(v->t.type == LOGICAL_t && !v->l.val){
_clip_destroy(mp,&var);
goto done;
}
_clip_destroy(mp,&var);
}
}
return 0;
done:
rowset->lastrec = rowset->loaded;
rowset->done = 1;
if(!rowset->lastrec){
rowset->bof = rowset->eof = 1;
rowset->recno = 0;
}
_clip_destroy_c_item(mp,stmt->stmt_item,_C_ITEM_TYPE_SQL);
return er;
}
int
clip_EVAL(ClipMachine * ClipMachineMemory)
{
ClipVar *bp = _clip_par(ClipMachineMemory, 1);
if (!bp || (bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != CCODE_type_of_ClipVarType && bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != PCODE_type_of_ClipVarType))
return 0;
return _clip_eval(ClipMachineMemory, bp, ClipMachineMemory->argc - 1, ARGPTR(ClipMachineMemory, 2), RETPTR(ClipMachineMemory));
}
static gint
__func(void* data)
{
ClipVar res;
C_var *c = (C_var*)data;
int ret = TRUE;
memset( &res, 0, sizeof(ClipVar) );
_clip_eval( c->cm, &(c->cfunc), 0, NULL, &res );
if (res.t.type == LOGICAL_t)
ret = res.l.val;
_clip_destroy(c->cm, &res);
return ret;
}
void
_ctree_func(GtkCTree *ctree, GtkCTreeNode *node, Ctree_var *c)
{
C_object *cnode = _list_get_cobject(c->cm,node);
ClipVar stack[2];
ClipVar res;
if (!cnode) cnode = _register_object(c->cm,node,GTK_TYPE_CTREE_NODE,NULL,NULL);
memset(&stack,0,sizeof(stack)); memset( &res, 0, sizeof(ClipVar) );
_clip_mclone(c->cm, &stack[0], &c->cw->obj);
_clip_mclone(c->cm, &stack[1], &cnode->obj);
//stack[0] = c->cw->obj;
//stack[1] = cnode->obj;
_clip_eval( c->cm, c->cfunc, 2, stack, &res );
_clip_destroy(c->cm, &res);
_clip_destroy(c->cm, &stack[0]);
_clip_destroy(c->cm, &stack[1]);
}
static int
sql_searchtree(ClipMachine * ClipMachineMemory, SQLROWSET * rowset, SQLORDER * order)
{
ClipVar var;
void *k = calloc(1, order->len);
int found;
*(int *) k = rowset->recno;
if (_clip_eval(ClipMachineMemory, order->block, 1, order->rmap, &var))
return 1;
switch (var.ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType)
{
case CHARACTER_type_of_ClipVarType:
if (var.ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf > order->len)
{
free(k);
return 0;
}
memcpy((char *) k + sizeof(int), var.ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, var.ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf);
break;
case NUMERIC_type_of_ClipVarType:
*(double *) ((char *) k + sizeof(int)) = var.ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
break;
case DATE_type_of_ClipVarType:
*(long *) ((char *) k + sizeof(int)) = var.ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar;
break;
case DATETIME_type_of_ClipVarType:
*(long *) ((char *) k + sizeof(int)) = var.ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar;
*(long *) ((char *) k + sizeof(int) + sizeof(long)) = var.ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar;
break;
default:
break;
}
_clip_destroy(ClipMachineMemory, &var);
found = bt_seek(order->bt, order, k);
free(k);
if (!found)
{
_clip_trap_err(ClipMachineMemory, 0, 0, 0, subsys, ER_INTERNAL, er_internal);
return 1;
}
return 0;
}
/*
static gint
__timeout__func(void* data)
{
ClipVar res;
C_var *c = (C_var*)data;
int ret = TRUE;
memset( &res, 0, sizeof(ClipVar) );
_clip_eval( c->cm, &(c->cfunc), 0, NULL, &res );
if (res.t.type == LOGICAL_t)
ret = res.l.val;
_clip_destroy(c->cm, &res);
if (!ret)
_destroy__func(c);
return ret;
}
*/
static gint
__timeout__func(void* data)
{
ClipVar res;
C_var *c = (C_var*)data;
ClipVar stack[1];
int ret = TRUE;
memset( &stack, 0, sizeof(stack) );memset( &res, 0, sizeof(ClipVar) );
_clip_mclone(c->cm, &stack[0], c->cv);
_clip_eval( c->cm, &c->cfunc, 1, stack, &res );
if (res.t.type == LOGICAL_t)
ret = res.l.val;
_clip_destroy(c->cm, &res);
_clip_destroy(c->cm, &stack[0]);
// if (!ret)
// _destroy__func(c);
return ret;
}
static void
_item_factory_callback2(GtkWidget *wid, gpointer data, guint callback_action)
{
C_var *c = (C_var*)data;
C_widget *c_wid = _list_get_cwidget(c->cm, wid);
ClipVar stack[2];
ClipVar res;
if (!c_wid)
c_wid = _register_widget(c->cm,wid, NULL);
if (c_wid)
{
memset(&stack,0,sizeof(stack)); memset( &res, 0, sizeof(ClipVar) );
_clip_mclone(c->co->cmachine, &stack[0], &c->co->obj);
stack[1] = c_wid->obj;
_clip_eval( c->cm, &(c->cfunc), 2, stack, &res );
_clip_destroy(c->cm, &res);
}
}
static void
destroy_notify(gpointer data)
{
C_var *c = (C_var *) data;
ClipVar stack[1];
ClipVar res;
memset(&stack, 0, sizeof(stack));
memset(&res, 0, sizeof(ClipVar));
_clip_mclone(c->ClipMachineMemory, &stack[0], &c->co->obj);
_clip_eval(c->ClipMachineMemory, &c->cfunc, 1, stack, &res);
_clip_destroy(c->ClipMachineMemory, &res);
_clip_destroy(c->ClipMachineMemory, &stack[0]);
}
static void
_container_for_each_func(GtkWidget *wid, gpointer data)
{
C_var *c = (C_var*)data;
C_widget *c_wid = _list_get_cwidget(c->cm, wid);
ClipVar stack[2];
ClipVar res;
if (!c_wid)
c_wid = _register_widget(c->cm,wid,NULL);
if (c_wid)
{
memset(&stack,0,sizeof(stack)); memset( &res, 0, sizeof(ClipVar) );
_clip_mclone(c->cw->cmachine, &stack[0], &c->cw->obj);
//stack[0] = c->cw->obj;
stack[1] = c_wid->obj;
_clip_eval( c->cm, &(c->cfunc), 2, stack, &res );
_clip_destroy(c->cm, &res);
}
}
static void callback_action(GtkAction *action, gpointer data)
{
C_var *c = (C_var *)data;
ClipVar *cfunc = _list_get_action(c->cm, action);
ClipVar stack[1];
ClipVar res;
if (cfunc)
{
memset(&stack,0,sizeof(stack)); memset( &res, 0, sizeof(ClipVar) );
_clip_mclone(c->cm, &stack[0], &c->co->obj);
_clip_eval( c->cm, cfunc, 1, stack, &res );
_clip_destroy(c->cm, &res);
_clip_destroy(c->cm, &stack[0]);
}
}
static void
_accel_map_foreach_func(gpointer data, const gchar * accel_path, guint accel_key, GdkModifierType accel_mods, gboolean changed)
{
C_var *c = (C_var *) data;
ClipVar stack[5];
ClipVar res;
memset(&stack, 0, sizeof(stack));
memset(&res, 0, sizeof(ClipVar));
_clip_mclone(c->cw->cmachine, &stack[0], &c->cw->obj);
_clip_var_str(accel_path, strlen(accel_path), &stack[1]);
_clip_var_num((double) accel_key, &stack[2]);
_clip_var_num((double) accel_mods, &stack[3]);
_clip_var_log((int) changed, &stack[4]);
_clip_eval(c->ClipMachineMemory, &(c->cfunc), 5, stack, &res);
_clip_destroy(c->ClipMachineMemory, &res);
_clip_destroy(c->ClipMachineMemory, &stack[0]);
}
static void *
task_run(void *data)
{
start_data *sp = (start_data*) data;
ClipMachine *mp = sp->mp;
int r;
void *ret;
sp->mp = new_ClipMachine(mp->screen);
if (sp->name)
r = _clip_clip(sp->mp, sp->name, sp->argc, sp->stack, 0);
else
r = _clip_eval(sp->mp, &sp->block, sp->argc, sp->stack, 0);
if (r)
_clip_logg(0, "task_run: cannot start function '%s'", sp->name);
/*printf("\ntask_run done\n");*/
return ret;
}
static void
test_modify(ClipMachine * ClipMachineMemory, ClipVar * map, long hash)
{
int ind;
/* try run `modify` member */
if (search_map(map->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar, map->ClipMapVar_m_of_ClipVar.count_of_ClipMapVar, HASH_modify, &ind))
{
ClipVar *ep;
map->ClipType_t_of_ClipVar.memo_of_ClipType = 0;
ep = _clip_vptr(&(map->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar[ind].ClipVar_var_of_ClipVarEl));
if (ep->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == PCODE_type_of_ClipVarType || ep->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == CCODE_type_of_ClipVarType)
{
int i;
ClipVar stack[3];
ClipVar *rval = ClipMachineMemory->fp->ClipVar_sp_of_ClipFrame - 1;
memset(stack, 0, sizeof(stack));
stack[0].ClipType_t_of_ClipVar = map->ClipType_t_of_ClipVar;
stack[0].ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_MPTR_ClipFlags;
stack[0].ClipRefVar_p_of_ClipVar.ClipVar_of_ClipRefVar = map;
map->ClipType_t_of_ClipVar.count_of_ClipType++;
_clip_var_num(hash, stack + 1);
_clip_clone(ClipMachineMemory, stack + 2, rval);
_clip_eval(ClipMachineMemory, _clip_vptr(ep), 3, stack, rval);
for (i = 0; i < 3; i++)
_clip_destroy(ClipMachineMemory, stack + i);
}
map->ClipType_t_of_ClipVar.memo_of_ClipType = 1;
}
}
static gboolean
_match_func(GtkEntryCompletion * completion, const gchar * key, GtkTreeIter * iter, gpointer data)
{
C_var *c = (C_var *) data;
C_object *ccomp = _list_get_cobject(c->ClipMachineMemory, completion);
C_object *citer = _list_get_cobject(c->ClipMachineMemory, iter);
ClipVar stack[4];
ClipVar res;
gboolean ret = TRUE;
if (!ccomp)
ccomp = _register_object(c->ClipMachineMemory, completion, GTK_TYPE_ENTRY_COMPLETION, NULL, NULL);
if (!citer)
citer = _register_object(c->ClipMachineMemory, iter, GTK_TYPE_TREE_ITER, NULL, NULL);
memset(&stack, 0, sizeof(stack));
memset(&res, 0, sizeof(ClipVar));
_clip_mclone(c->cw->cmachine, &stack[0], &c->co->obj);
_clip_mclone(c->cw->cmachine, &stack[1], &ccomp->obj);
_clip_var_str((gchar *) key, strlen(key), &stack[2]);
_clip_mclone(c->cw->cmachine, &stack[3], &citer->obj);
if (_clip_eval(c->ClipMachineMemory, &(c->cfunc), 4, stack, &res) == 0)
ret =
res.ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType ==
LOGICAL_type_of_ClipVarType ? res.ClipLogVar_l_of_ClipVar.value_of_ClipLogVar : ret;
_clip_destroy(c->ClipMachineMemory, &res);
_clip_destroy(c->ClipMachineMemory, &stack[0]);
_clip_destroy(c->ClipMachineMemory, &stack[1]);
_clip_destroy(c->ClipMachineMemory, &stack[2]);
_clip_destroy(c->ClipMachineMemory, &stack[3]);
return ret;
}
static
gboolean _file_filter_func(GtkFileFilterInfo *info, gpointer data)
{
C_var *c = (C_var*)data;
ClipVar stack[2];
ClipVar cv;
ClipVar res;
gboolean ret = TRUE;
memset(&stack,0,sizeof(stack)); memset( &res, 0, sizeof(ClipVar) );
memset( &cv, 0, sizeof(ClipVar) );
_clip_map(c->cm, &cv);
_file_filter_info_to_map(c->cm, info, &cv);
_clip_mclone(c->cm, &stack[0], &c->co->obj);
_clip_mclone(c->cm, &stack[1], &cv);
if ( _clip_eval( c->cm, &(c->cfunc), 2, stack, &res ) == 0 )
ret = res.t.type == LOGICAL_t ? res.l.val : ret;
_clip_destroy(c->cm, &res);
_clip_destroy(c->cm, &cv);
_clip_destroy(c->cm, &stack[0]);
_clip_destroy(c->cm, &stack[1]);
return ret;
}
int pg_fetch(ClipMachine* mp,SQLROWSET* rs,int recs,ClipVar* eval,int every,ClipVar* ors){
PG_ROWSET* rowset = (PG_ROWSET*)rs;
PG_STMT* stmt = rowset->stmt;
int i,j,er = 0,len;
void **rec;
if(rowset->done)
return 0;
if(!recs)
recs = 0x7fffffff;
for(i=0;i<recs;i++){
if(rowset->loaded == rowset->lastrec)
goto done;
rec = calloc(rowset->nfields,sizeof(void*));
for(j=0;j<rowset->nfields;j++){
if(!PQgetisnull(stmt->res,rowset->loaded,j)){
len = PQgetlength(stmt->res,rowset->loaded,j);
if(rowset->binary){
rec[j] = malloc(len+4);
*((int*)(rec[j])) = len;
memcpy(((char*)rec[j])+4,
PQgetvalue(stmt->res,rowset->loaded,j),len);
} else {
rec[j] = malloc(len+1);
memcpy(rec[j],PQgetvalue(stmt->res,rowset->loaded,j),len);
((char*)(rec[j]))[len] = 0;
}
} else {
rec[j] = NULL;
}
}
rowset->data[rowset->loaded] = rec;
rowset->loaded++;
if(eval && (eval->t.type == CCODE_t || eval->t.type == PCODE_t) && !(rowset->loaded % every)){
ClipVar var,*v;
if(_clip_eval(mp,eval,1,ors,&var)){
_clip_destroy(mp,&var);
er = 1;
goto done;
}
v = _clip_vptr(&var);
if(v->t.type == LOGICAL_t && !v->l.val){
_clip_destroy(mp,&var);
goto done;
}
_clip_destroy(mp,&var);
}
}
return 0;
done:
rowset->lastrec = rowset->loaded;
rowset->done = 1;
if(!rowset->lastrec){
rowset->bof = rowset->eof = 1;
rowset->recno = 0;
}
_clip_destroy_c_item(mp,stmt->stmt_item,_C_ITEM_TYPE_SQL);
return er;
}
int
clip_ASCAN(ClipMachine * ClipMachineMemory)
{
ClipVar *ap = _clip_par(ClipMachineMemory, 1);
ClipVar *bp = _clip_par(ClipMachineMemory, 2);
int start = _clip_parni(ClipMachineMemory, 3) - 1;
int count = _clip_parni(ClipMachineMemory, 4);
int back = _clip_parl(ClipMachineMemory, 5);
int c, i, r, code = 0, no = 0, end;
if (!ap || ap->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType != ARRAY_type_of_ClipVarType || !bp)
{
#if 0
return EG_ARG;
#else
_clip_retni(ClipMachineMemory, 0);
return 0;
#endif
}
if (bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == CCODE_type_of_ClipVarType || bp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == PCODE_type_of_ClipVarType)
code = 1;
if (ap->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == ARRAY_type_of_ClipVarType)
{
c = ap->ClipArrVar_a_of_ClipVar.count_of_ClipArrVar;
if (start >= c)
goto _ret;
if (start < 0)
start = 0;
if (count <= 0 || count > (c - start))
count = c - start;
end = start + count;
if (code)
{
if (back)
i = end - 1;
else
i = start;
for (;;)
{
ClipVar res, *app;
if (back)
{
if (i <= start)
break;
}
else
{
if (i >= end)
break;
}
app = ap->ClipArrVar_a_of_ClipVar.ClipVar_items_of_ClipArrVar + i;
memset(&res, 0, sizeof(res));
r = _clip_eval(ClipMachineMemory, bp, 1, app, &res);
/*
if (app->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType != F_MREF)
app->ClipRefVar_p_of_ClipVar.vp->ClipType_t_of_ClipVar.count_of_ClipType --;
*/
if (!r && res.ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == LOGICAL_type_of_ClipVarType && res.ClipLogVar_l_of_ClipVar.value_of_ClipLogVar)
no = i + 1;
_clip_destroy(ClipMachineMemory, &res);
if (r)
return r;
if (no)
break;
if (back)
i--;
else
i++;
}
}
else
{
if (back)
i = end - 1;
else
i = start;
for (;;)
{
ClipVar *app;
int res = 0;
if (back)
{
if (i <= start)
break;
}
else
{
if (i >= end)
break;
}
app = ap->ClipArrVar_a_of_ClipVar.ClipVar_items_of_ClipArrVar + i;
r = _clip_cmp(ClipMachineMemory, app, bp, &res, 1);
if (r)
return r;
if (!res)
{
no = i + 1;
break;
}
if (back)
i--;
else
i++;
}
}
}
else if (ap->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == MAP_type_of_ClipVarType)
{
c = ap->ClipMapVar_m_of_ClipVar.count_of_ClipMapVar;
if (start >= c)
goto _ret;
if (start < 0)
start = 0;
if (count <= 0 || count > (c - start))
count = c - start;
end = start + count;
if (code)
{
if (back)
i = end - 1;
else
i = start;
for (;;)
{
ClipVar res, *app;
if (back)
{
if (i <= start)
break;
}
else
{
if (i >= end)
break;
}
app = &ap->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar[i].ClipVar_var_of_ClipVarEl;
memset(&res, 0, sizeof(res));
r = _clip_eval(ClipMachineMemory, bp, 1, app, &res);
if (!r && res.ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == LOGICAL_type_of_ClipVarType && res.ClipLogVar_l_of_ClipVar.value_of_ClipLogVar)
no = i + 1;
_clip_destroy(ClipMachineMemory, &res);
if (r)
return r;
if (no)
break;
if (back)
i--;
else
i++;
}
}
else
{
end = start + count;
if (code)
{
if (back)
i = end - 1;
else
i = start;
for (;;)
{
ClipVar *app;
int res = 0;
if (back)
{
if (i <= start)
break;
}
else
{
if (i >= end)
break;
}
app = &ap->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar[i].ClipVar_var_of_ClipVarEl;
r = _clip_cmp(ClipMachineMemory, app, bp, &res, 1);
if (r)
return r;
if (!res)
{
no = i + 1;
break;
}
if (back)
i--;
else
i++;
}
}
}
}
_ret:
_clip_retni(ClipMachineMemory, no);
return 0;
}
CLIP_DLLEXPORT void
_clip_destroy(ClipMachine * ClipMachineMemory, ClipVar * vp)
{
if (!vp)
return;
switch (vp->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType)
{
case F_MPTR_ClipFlags:
case F_MREF_ClipFlags:
if ((--(vp->ClipRefVar_p_of_ClipVar.ClipVar_of_ClipRefVar->ClipType_t_of_ClipVar.count_of_ClipType)) <= 0)
{
_clip_destroy(ClipMachineMemory, vp->ClipRefVar_p_of_ClipVar.ClipVar_of_ClipRefVar);
free(vp->ClipRefVar_p_of_ClipVar.ClipVar_of_ClipRefVar);
}
CLEAR_CLIPVAR(vp);
return;
case F_MSTAT_ClipFlags:
return;
case F_NONE_ClipFlags:
break;
}
switch (vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType)
{
case CHARACTER_type_of_ClipVarType:
free(vp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf);
break;
case NUMERIC_type_of_ClipVarType:
if (vp->ClipType_t_of_ClipVar.memo_of_ClipType)
{
rational_destroy(vp->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
}
break;
case ARRAY_type_of_ClipVarType:
{
int i;
for (i = vp->ClipArrVar_a_of_ClipVar.count_of_ClipArrVar - 1; i >= 0; --i)
_clip_destroy(ClipMachineMemory, vp->ClipArrVar_a_of_ClipVar.ClipVar_items_of_ClipArrVar + i);
free(vp->ClipArrVar_a_of_ClipVar.ClipVar_items_of_ClipArrVar);
}
break;
case MAP_type_of_ClipVarType:
{
int i;
#if 1
int ind;
/* try run `destroy` member */
if (search_map(vp->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar, vp->ClipMapVar_m_of_ClipVar.count_of_ClipMapVar, HASH_destroy, &ind))
{
ClipVar *ep;
int type;
ep = &(vp->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar[ind].ClipVar_var_of_ClipVarEl);
type = _clip_type(ep);
if (type == PCODE_type_of_ClipVarType || type == CCODE_type_of_ClipVarType)
{
ClipVar vpp;
memset(&vpp, 0, sizeof(vpp));
vpp.ClipType_t_of_ClipVar = vp->ClipType_t_of_ClipVar;
vpp.ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_MPTR_ClipFlags;
vpp.ClipRefVar_p_of_ClipVar.ClipVar_of_ClipRefVar = vp;
vp->ClipType_t_of_ClipVar.count_of_ClipType++;
_clip_eval(ClipMachineMemory, _clip_vptr(ep), 1, &vpp, 0);
}
}
#endif
for (i = vp->ClipMapVar_m_of_ClipVar.count_of_ClipMapVar - 1; i >= 0; --i)
_clip_destroy(ClipMachineMemory, &(vp->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar[i].ClipVar_var_of_ClipVarEl));
free(vp->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar);
}
break;
case CCODE_type_of_ClipVarType:
delete_ClipVarFrame(ClipMachineMemory, vp->ClipCodeVar_c_of_ClipVar.ClipVarFrame_uplocals_of_ClipCodeVar);
break;
case PCODE_type_of_ClipVarType:
delete_ClipVarFrame(ClipMachineMemory, vp->ClipCodeVar_c_of_ClipVar.ClipVarFrame_uplocals_of_ClipCodeVar);
destroy_Block(ClipMachineMemory, vp->ClipCodeVar_c_of_ClipVar.union_of_ClipCodeVar.ClipBlock_block_of_ClipCodeVar);
free(vp->ClipCodeVar_c_of_ClipVar.union_of_ClipCodeVar.ClipBlock_block_of_ClipCodeVar);
break;
default:
break;
}
CLEAR_CLIPVAR(vp);
}
static int
cdx_wildskip(ClipMachine * ClipMachineMemory, RDD_DATA * rd, RDD_ORDER * ro, const char *pattern, int regular, const char *s, ClipVar * block, int *found, const char *__PROC__)
{
CDX_HEADER hdr;
CDX_PAGE page;
CDX_LEAF *leaf = (CDX_LEAF *) & page;
ClipVar v, *vp, r;
char *key = calloc(1, ro->bufsize + 1);
char *lockey = calloc(1, ro->bufsize + 1);
char *p = (char *) (leaf) + sizeof(CDX_LEAF);
unsigned long long item;
unsigned int rec = 0;
int dup = 0, trail = 0;
int ok, fok;
int fnd, out = 0, i, er;
#ifdef HAVE_REGEX_H
regex_t reg;
#endif
*found = 1;
#ifdef HAVE_REGEX_H
if (regular)
regcomp(®, pattern, REG_EXTENDED | REG_NOSUB);
#else
regular = 0;
#endif
if (rd->shared || !ro->valid_stack)
{
char cntcdx[4];
if ((er = rdd_read(ClipMachineMemory, &ro->index->file, 8, 4, cntcdx, __PROC__)))
return er;
if (!ro->valid_stack || ro->cntcdx != _rdd_backuint((unsigned char *) cntcdx))
{
if ((er = rdd_calc(ClipMachineMemory, rd->area, &ro->block, &v, 0)))
goto err;
vp = _clip_vptr(&v);
if ((er = cdx_formatkey(ClipMachineMemory, ro, vp, key, __PROC__)))
goto err;
_clip_destroy(ClipMachineMemory, &v);
ro->curoffs = 0;
_CDX_HEADER(ro, &hdr);
ro->stack[0].page = _rdd_uint(hdr.root);
ro->level = 0;
if (!ro->descend)
{
if ((er = _cdx_search_tree(ClipMachineMemory, ro, key, ro->bufsize, rd->recno, &fnd, NULL, __PROC__)))
goto err;
}
else
{
if ((er = _cdx_back_search_tree(ClipMachineMemory, ro, key, ro->bufsize, rd->recno, &fnd, NULL, __PROC__)))
goto err;
}
_clip_destroy(ClipMachineMemory, &v);
}
}
if ((er = rdd_read(ClipMachineMemory, &ro->index->file, ro->stack[ro->level].page, sizeof(CDX_LEAF), leaf, __PROC__)))
goto err;
for (i = 0; i <= ro->stack[ro->level].pos; i++)
{
memcpy(&item, leaf->keys + i * leaf->bytes, leaf->bytes);
_CDX_LEAF_ITEM(item, rec, dup, trail);
p -= ro->bufsize - (dup + trail);
memcpy(key + dup, p, ro->bufsize - (dup + trail));
}
memset(key + dup + ro->bufsize - (dup + trail), (int) (block ? 0x20 : 0x00), trail);
if (block)
memset(&v, 0, sizeof(ClipVar));
*found = 0;
while (!out && ((block || regular) ? 1 : (memcmp(key, pattern, s - pattern) == 0)))
{
if (!block)
{
if (regular)
{
#ifdef HAVE_REGEX_H
*found = !regexec(®, key, 0, NULL, 0);
#else
*found = 0;
#endif
}
else
{
*found = (_clip_glob_match(key + (s - pattern), s, 1) != -1);
}
if (*found)
{
if ((er = rd->vtbl->rawgo(ClipMachineMemory, rd, rec, 1, __PROC__)))
goto err;
if (!ro->scopetop && !ro->scopebottom && !rd->filter && !(ClipMachineMemory->flags & DELETED_FLAG))
break;
if ((er = _cdx_checkscope(ClipMachineMemory, rd, ro, key, &ok, __PROC__)))
goto err;
if (ok > 0)
{
*found = 0;
break;
}
if ((er = rdd_checkfilter(ClipMachineMemory, rd, &fok, __PROC__)))
goto err;
if (!ok && fok)
break;
}
}
else
{
if ((er = rd->vtbl->rawgo(ClipMachineMemory, rd, rec, 1, __PROC__)))
goto err;
ok = 0;
fok = 1;
if (!(!ro->scopetop && !ro->scopebottom && !rd->filter && !(ClipMachineMemory->flags & DELETED_FLAG)))
{
if ((er = _cdx_checkscope(ClipMachineMemory, rd, ro, key, &ok, __PROC__)))
goto err;
if (ok > 0)
{
*found = 0;
break;
}
if ((er = rdd_checkfilter(ClipMachineMemory, rd, &fok, __PROC__)))
goto err;
}
if (!ok && fok)
{
_cdx_keyvar(ro, key, lockey, &v);
if ((er = _clip_eval(ClipMachineMemory, block, 1, &v, &r)))
goto err;
*found = r.ClipLogVar_l_of_ClipVar.value_of_ClipLogVar;
if (*found)
break;
}
}
ro->stack[ro->level].pos++;
if (ro->stack[ro->level].pos >= _rdd_ushort(leaf->nkeys))
{
if (_rdd_uint(leaf->right) != 0xffffffff)
{
ro->stack[ro->level].page = _rdd_uint(leaf->right);
if ((er = rdd_read(ClipMachineMemory, &ro->index->file, ro->stack[ro->level].page, sizeof(CDX_LEAF), leaf, __PROC__)))
goto err;
p = (char *) leaf + sizeof(CDX_LEAF);
memcpy(&item, leaf->keys, leaf->bytes);
_CDX_LEAF_ITEM(item, rec, dup, trail);
p -= ro->bufsize - (dup + trail);
memcpy(key + dup, p, ro->bufsize - (dup + trail));
memset(key + dup + ro->bufsize - (dup + trail), (int) (block ? 0x20 : 0x00), trail);
if (_rdd_ushort(leaf->nkeys) == 0)
return rdd_err(ClipMachineMemory, EG_CORRUPTION, 0, __FILE__, __LINE__, __PROC__, er_nokeys);
ro->stack[ro->level].pos = 0;
}
else
{
out = 1;
}
}
else
{
memcpy(&item, leaf->keys + ro->stack[ro->level].pos * leaf->bytes, leaf->bytes);
_CDX_LEAF_ITEM(item, rec, dup, trail);
p -= ro->bufsize - (dup + trail);
memcpy(key + dup, p, ro->bufsize - (dup + trail));
memset(key + dup + ro->bufsize - (dup + trail), (int) (block ? 0x20 : 0x00), trail);
}
*found = 0;
}
if (out)
{
*found = 0;
ro->valid_stack = 0;
}
else
{
ro->valid_stack = 1;
}
#ifdef HAVE_REGEX_H
if (regular)
regfree(®);
#endif
free(lockey);
free(key);
return 0;
err:
#ifdef HAVE_REGEX_H
if (regular)
regfree(®);
#endif
free(lockey);
free(key);
return er;
}
/* Common event handlers. It called from event handler in C and passes it to CLIP */
CLIP_DLLEXPORT gint
handle_events(GtkWidget *widget, GdkEvent *event, C_signal *cs)
{
ClipVar stack[2];
ClipVar *cfunc = NULL;
int ret = TRUE;
ClipMachine *cm;
double keycode;
/*printf("Widget name: %s, event: %d \n",gtk_widget_get_name(widget), event->type);*/
if (!cs) return ret;
if (!cs->cw) return ret;
if (event->type != cs->sigid && cs->sigid != GTK_EVENT) return ret;
cm = cs->cw->cmachine;
memset( stack, 0, sizeof(stack) );
//stack[0] = cs->cw->obj;
_clip_mclone(cs->cw->cmachine, &stack[0], &cs->cw->obj);
if (!cs->cw->evntenabled) return FALSE;
_clip_map(cs->cw->cmachine,&stack[1]);
//_clip_mputn(cs->cw->cmachine,&stack[1], HASH_EVENT, cs->sigid);
_clip_mputn(cs->cw->cmachine,&stack[1], HASH_EVENT, event->type);
cfunc = &cs->cfunc;
switch( event->type )
{
case GDK_CONFIGURE:
/*printf("Widget name: %s, event: GDK_CONFIGURE \n",gtk_widget_get_name(widget));*/
_clip_mputn(cm, &stack[1], HASH_X, event->configure.x);
_clip_mputn(cm, &stack[1], HASH_Y, event->configure.y);
_clip_mputn(cm, &stack[1], HASH_WIDTH, event->configure.width);
_clip_mputn(cm, &stack[1], HASH_HEIGHT, event->configure.height);
break;
case GDK_EXPOSE:
{
ClipVar area;
memset(&area,0,sizeof(area)); _clip_map(cm,&area);
/*printf("Widget name: %s, event: GDK_EXPOSE \n",gtk_widget_get_name(widget));*/
_clip_mputn(cm, &area, HASH_X, event->expose.area.x);
_clip_mputn(cm, &area, HASH_Y, event->expose.area.y);
_clip_mputn(cm, &area, HASH_WIDTH, event->expose.area.width);
_clip_mputn(cm, &area, HASH_HEIGHT, event->expose.area.height);
_clip_madd(cm, &stack[1], HASH_AREA, &area);
_clip_mputn(cm, &stack[1], HASH_COUNT, event->expose.count);
break;
}
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
_clip_mputn(cm, &stack[1], HASH_BUTTON, event->button.button);
_clip_mputn(cm, &stack[1], HASH_X, event->button.x);
_clip_mputn(cm, &stack[1], HASH_Y, event->button.y);
_clip_mputn(cm, &stack[1], HASH_XROOT, event->button.x_root);
_clip_mputn(cm, &stack[1], HASH_YROOT, event->button.y_root);
_clip_mputn(cm, &stack[1], HASH_PRESSURE, event->button.pressure);
_clip_mputn(cm, &stack[1], HASH_XTILT, event->button.xtilt);
_clip_mputn(cm, &stack[1], HASH_YTILT, event->button.ytilt);
_clip_mputn(cm, &stack[1], HASH_STATE, event->button.state);
_clip_mputn(cm, &stack[1], HASH_SOURCE, event->button.source);
_clip_mputn(cm, &stack[1], HASH_TYPE, event->button.type);
_clip_mputn(cm, &stack[1], HASH_TIME, event->button.time);
_clip_mputn(cm, &stack[1], HASH_DEVICIED, event->button.deviceid);
break;
case GDK_MOTION_NOTIFY:
_clip_mputn(cm, &stack[1], HASH_X, event->motion.x);
_clip_mputn(cm, &stack[1], HASH_Y, event->motion.y);
_clip_mputn(cm, &stack[1], HASH_XROOT, event->motion.x_root);
_clip_mputn(cm, &stack[1], HASH_YROOT, event->motion.y_root);
_clip_mputn(cm, &stack[1], HASH_PRESSURE, event->motion.pressure);
_clip_mputn(cm, &stack[1], HASH_XTILT, event->motion.xtilt);
_clip_mputn(cm, &stack[1], HASH_YTILT, event->motion.ytilt);
_clip_mputn(cm, &stack[1], HASH_SOURCE, event->motion.source);
_clip_mputn(cm, &stack[1], HASH_DEVICIED, event->motion.deviceid);
//last_motion_event = *(GdkEventMotion*)event;
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
if ( x_inkey( (GdkEventKey*)event, &keycode ) )
cfunc = NULL;
else
{
_clip_mputn(cm, &stack[1], HASH_KEYVAL, keycode);
_clip_mputn(cm, &stack[1], HASH_STATE, event->key.state);
_clip_mputn(cm, &stack[1], HASH_LENGTH, event->key.length);
_clip_mputc(cm, &stack[1], HASH_STRING, event->key.string, event->key.length);
}
break;
default:
break;
}
if ( cfunc )
{
ClipVar res;
memset( &res, 0, sizeof(ClipVar) );
if ( _clip_eval( cs->cw->cmachine, cfunc, 2, stack, &res ) == 0 )
ret = res.t.type == LOGICAL_t ? res.l.val : ret;
_clip_destroy(cs->cw->cmachine, &res);
}
//_clip_destroy(cw->cmachine, &stack[0]);
//_clip_destroy(cw->cmachine, &stack[1]);
//return TRUE;
return ret;
}
static int
do_assign(ClipMachine * ClipMachineMemory, ClipVar * lval, ClipVar * rval, int op)
{
int ret = 0;
int l;
ClipVar *Rval = rval, *Lval = lval;
int ltype, rtype;
Rval = _clip_vptr(Rval);
Lval = _clip_vptr(Lval);
ltype = _clip_type(Lval);
rtype = _clip_type(Rval);
if (ltype == MAP_type_of_ClipVarType)
{
int ind;
long hash = 0;
switch (op)
{
case '+':
hash = HASH_operator_add;
break;
case '-':
hash = HASH_operator_sub;
break;
case '*':
hash = HASH_operator_mul;
break;
case '/':
hash = HASH_operator_div;
break;
case '%':
hash = HASH_operator_mod;
break;
case '^':
hash = HASH_operator_pow;
break;
case '|':
hash = HASH_operator_or;
break;
case '&':
hash = HASH_operator_and;
break;
case '$':
hash = HASH_operator_in;
break;
case 'e':
hash = HASH_operator_eq;
break;
case 'E':
hash = HASH_operator_eeq;
break;
case 'N':
hash = HASH_operator_neq;
break;
case '<':
hash = HASH_operator_lt;
break;
case '>':
hash = HASH_operator_gt;
break;
case 'L':
hash = HASH_operator_le;
break;
case 'G':
hash = HASH_operator_ge;
break;
}
if (hash)
{
ClipVar *vp = Lval;
/* try run `destroy` member */
if (search_map(vp->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar, vp->ClipMapVar_m_of_ClipVar.count_of_ClipMapVar, hash, &ind))
{
ClipVar *ep;
int type;
ep = &(vp->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar[ind].ClipVar_var_of_ClipVarEl);
type = _clip_type(ep);
if (type == PCODE_type_of_ClipVarType || type == CCODE_type_of_ClipVarType)
{
int i;
ClipVar stack[2], res;
memset(stack, 0, sizeof(stack));
memset(&res, 0, sizeof(res));
stack[0].ClipType_t_of_ClipVar = vp->ClipType_t_of_ClipVar;
stack[0].ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_MPTR_ClipFlags;
stack[0].ClipRefVar_p_of_ClipVar.ClipVar_of_ClipRefVar = vp;
vp->ClipType_t_of_ClipVar.count_of_ClipType++;
_clip_clone(ClipMachineMemory, stack + 1, rval);
ret = _clip_eval(ClipMachineMemory, _clip_vptr(ep), 2, stack, &res);
_clip_clone(ClipMachineMemory, lval, &res);
for (i = 0; i < 2; i++)
_clip_destroy(ClipMachineMemory, stack + i);
_clip_destroy(ClipMachineMemory, &res);
}
return ret;
}
}
}
switch (op)
{
case '+':
if (ltype == CHARACTER_type_of_ClipVarType && rtype == CHARACTER_type_of_ClipVarType)
{
int len = Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf + Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf;
if (Lval->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType == F_MSTAT_ClipFlags)
{
char *s = (char *) malloc(len + 1);
Lval->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_NONE_ClipFlags;
memcpy(s, Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf);
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf = s;
}
else
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf = (char *) realloc(Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, len + 1);
memcpy(Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf +
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf,
Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf + 1);
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf = len;
Lval->ClipType_t_of_ClipVar.len_of_ClipType = Rval->ClipType_t_of_ClipVar.len_of_ClipType;
}
else if (ltype == NUMERIC_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
_clip_math_operation(ClipMachineMemory, op, Lval, Rval);
}
else if (ltype == DATE_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
if (Rval->ClipType_t_of_ClipVar.memo_of_ClipType)
Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar += rational_toDouble(Rval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar += Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
}
else if (ltype == NUMERIC_type_of_ClipVarType && rtype == DATE_type_of_ClipVarType)
{
double tmp;
if (Lval->ClipType_t_of_ClipVar.memo_of_ClipType)
tmp = rational_toDouble(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
tmp = Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
Lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = DATE_type_of_ClipVarType;
Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar = Rval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar;
Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar += tmp;
}
else if (ltype == DATETIME_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
long tmp;
if (Rval->ClipType_t_of_ClipVar.memo_of_ClipType)
tmp = (long) rational_toDouble(Rval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
tmp = (long) Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
Lval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar += tmp / (24 * 60 * 60);
Lval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar += (tmp % (24 * 60 * 60)) * 1000;
}
else if (ltype == NUMERIC_type_of_ClipVarType && rtype == DATETIME_type_of_ClipVarType)
{
long tmp;
if (Lval->ClipType_t_of_ClipVar.memo_of_ClipType)
tmp = (long) rational_toDouble(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
tmp = (long) Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
Lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = DATETIME_type_of_ClipVarType;
Lval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar = Rval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar + tmp / (24 * 60 * 60);
Lval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar = Rval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar + (tmp % (24 * 60 * 60)) * 1000;
}
else
{
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "+", Lval);
/*return 1; */
}
break;
case '-':
if (ltype == CHARACTER_type_of_ClipVarType && rtype == CHARACTER_type_of_ClipVarType)
{
int llen = Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf;
int len, slen = 0;
char *s;
for (s = Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf + llen - 1; llen; --llen, --s, ++slen)
if (*s != ' ' && *s != '\t')
break;
len = llen + Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf;
if (Lval->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType == F_MSTAT_ClipFlags)
{
char *s = (char *) malloc(len + 1);
Lval->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_NONE_ClipFlags;
memcpy(s, Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf);
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf = s;
}
else
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf = (char *) realloc(Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, len + slen + 1);
memcpy(Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf + llen,
Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf + 1);
memset(Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf + len, ' ', slen);
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf[len + slen] = 0;
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf = len + slen;
Lval->ClipType_t_of_ClipVar.len_of_ClipType = Rval->ClipType_t_of_ClipVar.len_of_ClipType;
}
else if (ltype == NUMERIC_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
_clip_math_operation(ClipMachineMemory, op, Lval, Rval);
}
else if (ltype == DATE_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
if (Rval->ClipType_t_of_ClipVar.memo_of_ClipType)
Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar -= rational_toDouble(Rval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar -= Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
}
else if (ltype == DATETIME_type_of_ClipVarType && rtype == DATETIME_type_of_ClipVarType)
{
long tmp = (Lval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar - Rval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar) * 24 * 60 * 60;
tmp += (Lval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar - Rval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar) / 1000;
Lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = NUMERIC_type_of_ClipVarType;
Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar = tmp;
}
else if (ltype == DATETIME_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
long tmp;
if (Rval->ClipType_t_of_ClipVar.memo_of_ClipType)
tmp = (long) rational_toDouble(Rval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
tmp = (long) Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
Lval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar -= tmp / (24 * 60 * 60);
Lval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar -= (tmp % (24 * 60 * 60)) * 1000;
if (Lval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar < 0)
{
Lval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar--;
Lval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar = (24 * 60 * 60 * 1000) + Lval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar;
}
}
else if (ltype == NUMERIC_type_of_ClipVarType && rtype == DATE_type_of_ClipVarType)
{
double tmp;
if (Lval->ClipType_t_of_ClipVar.memo_of_ClipType)
tmp = rational_toDouble(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
tmp = Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
Lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = DATE_type_of_ClipVarType;
Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar = Rval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar;
Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar -= tmp;
}
else if (ltype == DATE_type_of_ClipVarType && rtype == DATE_type_of_ClipVarType)
{
Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar = Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar - Rval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar;
Lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = NUMERIC_type_of_ClipVarType;
Lval->ClipType_t_of_ClipVar.len_of_ClipType = 0;
Lval->ClipType_t_of_ClipVar.dec_of_ClipType = 0;
Lval->ClipType_t_of_ClipVar.memo_of_ClipType = 0;
}
else
{
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "-", Lval);
/*return 1; */
}
break;
case '*':
if (ltype == NUMERIC_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
_clip_math_operation(ClipMachineMemory, op, Lval, Rval);
}
else
{
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "*", Lval);
/*return 1; */
}
break;
case '/':
if (ltype == NUMERIC_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
_clip_math_operation(ClipMachineMemory, op, Lval, Rval);
}
else
{
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "/", Lval);
/*return 1; */
}
break;
case '%':
if (ltype == NUMERIC_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
if (!Lval->ClipType_t_of_ClipVar.memo_of_ClipType && !Rval->ClipType_t_of_ClipVar.memo_of_ClipType)
{
Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar = fmod(Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar, Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
Lval->ClipType_t_of_ClipVar.len_of_ClipType = 0;
Lval->ClipType_t_of_ClipVar.dec_of_ClipType = 0;
Lval->ClipType_t_of_ClipVar.memo_of_ClipType = 0;
}
else
{
rational *tmp = 0;
if (Lval->ClipType_t_of_ClipVar.memo_of_ClipType && Rval->ClipType_t_of_ClipVar.memo_of_ClipType)
{
tmp = rational_fmod(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar, Rval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
}
else
{
if (Lval->ClipType_t_of_ClipVar.memo_of_ClipType)
{
rational *tmp1;
tmp1 = rational_double_init(Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
tmp = rational_fmod(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar, tmp1);
rational_destroy(tmp1);
}
else
{
rational *tmp1;
tmp1 = rational_double_init(Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
tmp = rational_fmod(tmp1, Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
rational_destroy(tmp1);
}
}
rational_destroy(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar = tmp;
}
}
else
{
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "%", Lval);
/*return 1; */
}
break;
case '^':
if (ltype == NUMERIC_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
if (Lval->ClipType_t_of_ClipVar.memo_of_ClipType)
{
long tmp;
if (Rval->ClipType_t_of_ClipVar.memo_of_ClipType)
tmp = (long) rational_toDouble(Rval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
tmp = (long) Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
rational_powa(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar, tmp);
}
else
{
Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar = pow(Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar, Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
if (!finite(Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar))
Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar = 0;
Lval->ClipType_t_of_ClipVar.len_of_ClipType = 0;
Lval->ClipType_t_of_ClipVar.dec_of_ClipType = 0;
}
}
else
{
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "**", Lval);
/*return 1; */
}
break;
case '$':
if (ltype == CHARACTER_type_of_ClipVarType && rtype == CHARACTER_type_of_ClipVarType)
{
const char *s = _clip_strstr(Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf,
Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf,
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf,
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf);
_clip_destroy(ClipMachineMemory, lval);
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = (s ? 1 : 0);
lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = LOGICAL_type_of_ClipVarType;
}
else if (rtype == MAP_type_of_ClipVarType)
{
int ind, r;
long no;
switch (ltype)
{
case NUMERIC_type_of_ClipVarType:
if (Lval->ClipType_t_of_ClipVar.memo_of_ClipType)
no = rational_toDouble(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
no = Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar;
break;
case CHARACTER_type_of_ClipVarType:
/*no = _clip_casehashbytes(0, Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf); */
no = _clip_hashbytes(0, Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf);
break;
default:
goto inv_in_arg;
}
r = search_map(Rval->ClipMapVar_m_of_ClipVar.ClipVarEl_items_of_ClipMapVar, Rval->ClipMapVar_m_of_ClipVar.count_of_ClipMapVar, no, &ind);
_clip_destroy(ClipMachineMemory, lval);
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = (r ? 1 : 0);
lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = LOGICAL_type_of_ClipVarType;
}
else if (rtype == ARRAY_type_of_ClipVarType)
{
int i, c, r, res = 0;
c = Rval->ClipArrVar_a_of_ClipVar.count_of_ClipArrVar;
for (i = 0; i < c; ++i)
{
ClipVar *vp = Rval->ClipArrVar_a_of_ClipVar.ClipVar_items_of_ClipArrVar + i;
r = _clip_cmp(ClipMachineMemory, Lval, vp, &res, 1);
if (r)
continue;
if (res)
break;
}
_clip_destroy(ClipMachineMemory, lval);
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = (!res ? 1 : 0);
lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = LOGICAL_type_of_ClipVarType;
}
else
{
inv_in_arg:
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "$", Lval);
/*return 1; */
}
break;
case 'E':
case 'e':
case 'N':
#if 1 /* uri added : oper != work as =, not == */
if ((op == 'E') && (ltype == CHARACTER_type_of_ClipVarType && rtype == CHARACTER_type_of_ClipVarType))
#else
if ((op == 'E' || op == 'N') && (ltype == CHARACTER_type_of_ClipVarType && rtype == CHARACTER_type_of_ClipVarType))
#endif
#if 1
/*l = !strcmp(Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf, Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf); */
{
int ll, lr;
ll = Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf;
lr = Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf;
if (ll != lr)
l = 0;
else
l = !memcmp(Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, ll);
}
#else
/*Rust begin */
{
int len =
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len <
Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len ? Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf : Rval->
ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf;
l = !_clip_strncmp(Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, len);
}
/*Rust end */
#endif
else
{
if ((ret = _clip_cmp(ClipMachineMemory, lval, rval, &l, 0)))
return ret;
l = !l;
}
_clip_destroy(ClipMachineMemory, lval);
switch (op)
{
case 'E':
case 'e':
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = l;
break;
default:
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = !l;
break;
}
lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = LOGICAL_type_of_ClipVarType;
break;
case '|':
if (ltype == LOGICAL_type_of_ClipVarType && rtype == LOGICAL_type_of_ClipVarType)
{
l = (Lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar || Rval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar);
}
else
{
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "OR", lval);
/*return 1; */
}
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = l;
lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = LOGICAL_type_of_ClipVarType;
break;
case '&':
if (ltype == LOGICAL_type_of_ClipVarType && rtype == LOGICAL_type_of_ClipVarType)
{
l = (Lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar && Rval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar);
}
else
{
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "AND", lval);
/*return 1; */
}
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = l;
lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = LOGICAL_type_of_ClipVarType;
break;
case '<':
case '>':
case 'L':
case 'G':
if (ltype == CHARACTER_type_of_ClipVarType && rtype == CHARACTER_type_of_ClipVarType)
{
l = _clip_strnncmp(Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf,
Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf,
Lval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf, Rval->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf);
#if 1 /* added 20030118 for test '? "" <="0"' */
ret = _clip_cmp(ClipMachineMemory, lval, rval, &l, 0);
#endif
//printf("\nl=%d,ret=%d\n",l,ret);
_clip_destroy(ClipMachineMemory, lval);
}
else if (ltype == DATE_type_of_ClipVarType && rtype == DATE_type_of_ClipVarType)
{
if (Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar < Rval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar)
l = -1;
else if (Lval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar > Rval->ClipDateVar_d_of_ClipVar.julian_of_ClipDateVar)
l = 1;
else
l = 0;
}
else if (ltype == DATETIME_type_of_ClipVarType && rtype == DATETIME_type_of_ClipVarType)
{
if (Lval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar < Rval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar)
l = -1;
else if (Lval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar > Rval->ClipDateTimeVar_dt_of_ClipVar.julian_of_ClipDateTimeVar)
l = 1;
else
l = 0;
if (l == 0)
{
if (Lval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar < Rval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar)
l = -1;
else if (Lval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar > Rval->ClipDateTimeVar_dt_of_ClipVar.time_of_ClipDateTimeVar)
l = 1;
else
l = 0;
}
}
else if (ltype == NUMERIC_type_of_ClipVarType && rtype == NUMERIC_type_of_ClipVarType)
{
if (!Lval->ClipType_t_of_ClipVar.memo_of_ClipType && !Rval->ClipType_t_of_ClipVar.memo_of_ClipType)
{
double diff;
diff = fabs(Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar - Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
if (diff < (Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar * MIN_NUMERIC_DIFF))
l = 0;
else if (Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar < Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar)
l = -1;
else if (Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar > Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar)
l = 1;
else
l = 0;
}
else
{
if (Lval->ClipType_t_of_ClipVar.memo_of_ClipType && Rval->ClipType_t_of_ClipVar.memo_of_ClipType)
l = rational_cmp(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar, Rval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
else
{
rational *tmp = NULL;
if (Lval->ClipType_t_of_ClipVar.memo_of_ClipType)
{
tmp = rational_double_init(Rval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
l = rational_cmp(Lval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar, tmp);
}
else
{
tmp = rational_double_init(Lval->ClipNumVar_n_of_ClipVar.double_of_ClipNumVar);
l = rational_cmp(tmp, Rval->ClipRationalVar_r_of_ClipVar.Struc_rational_of_ClipRationalVar);
}
rational_destroy(tmp);
}
}
_clip_destroy(ClipMachineMemory, lval);
}
else if (ltype == LOGICAL_type_of_ClipVarType && rtype == LOGICAL_type_of_ClipVarType)
{
if (Lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar && !Rval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar)
l = -1;
else if (!Lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar && Rval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar)
l = 1;
else
l = 0;
}
else if (ltype == OBJECT_type_of_ClipVarType && rtype == OBJECT_type_of_ClipVarType)
{
l = Lval->ClipObjVar_o_of_ClipVar.rtti_of_ClipObjVar->cmp_of_ClipObjRtti(ClipMachineMemory,
Lval->ClipObjVar_o_of_ClipVar.obj_of_ClipObjVar, Lval->ClipObjVar_o_of_ClipVar.rtti_of_ClipObjVar, Rval);
_clip_destroy(ClipMachineMemory, lval);
}
else
{
return _clip_trap_operation(ClipMachineMemory, __file__, __LINE__, "==", lval);
/*return 1; */
}
switch (op)
{
case 'L':
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = (l <= 0 ? 1 : 0);
break;
case 'G':
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = (l >= 0 ? 1 : 0);
break;
case '>':
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = (l > 0 ? 1 : 0);
break;
case '<':
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = (l < 0 ? 1 : 0);
break;
default:
lval->ClipLogVar_l_of_ClipVar.value_of_ClipLogVar = l;
}
lval->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = LOGICAL_type_of_ClipVarType;
lval->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_NONE_ClipFlags;
break;
}
int
clip_DBSELECTAREA(ClipMachine * ClipMachineMemory)
{
ClipVar *vp = _clip_par(ClipMachineMemory, 1);
ClipVar *data;
int ret = -1, er;
if (!vp)
{
_clip_retni(ClipMachineMemory, ClipMachineMemory->curArea + 1);
return 0;
}
data = NEW(ClipVar);
if (vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == CCODE_type_of_ClipVarType || vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == PCODE_type_of_ClipVarType)
{
_clip_eval(ClipMachineMemory, _clip_vptr(vp), 0, 0, data);
vp = data;
}
else if (vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == CHARACTER_type_of_ClipVarType)
{
char ch = toupper(vp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf[0]);
if (ch >= '0' && ch <= '9')
ret = atol(vp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf);
else if ((vp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf == 1) && (ch >= 'A') && (ch <= 'L'))
ret = ch - 'A' + 1;
}
if (ret >= 0 || vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == NUMERIC_type_of_ClipVarType)
{
int n;
if (ret >= 0)
n = ret;
else
n = _clip_double(vp);
if (n)
{
ret = n - 1;
if (n > ClipMachineMemory->areas->count_of_ClipVect)
{
n -= ClipMachineMemory->areas->count_of_ClipVect;
while (n--)
add_ClipVect(ClipMachineMemory->areas, NULL);
}
}
else
{
for (; n < ClipMachineMemory->areas->count_of_ClipVect; n++)
{
DBWorkArea *wa;
wa = (DBWorkArea *) ClipMachineMemory->areas->items_of_ClipVect[n];
if (wa == NULL || !wa->used)
break;
}
ret = n;
if (ret == ClipMachineMemory->areas->count_of_ClipVect)
add_ClipVect(ClipMachineMemory->areas, NULL);
}
ClipMachineMemory->curArea = ret;
}
else if (vp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == CHARACTER_type_of_ClipVarType)
{
int len;
long hash;
DBWorkArea *wa;
len = vp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf > 10 ? 10 : vp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf;
hash = _clip_casehashword(vp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, len);
wa = HashTable_fetch(ClipMachineMemory->aliases, hash);
if (wa)
ClipMachineMemory->curArea = wa->no;
else
{
er = rdd_err(ClipMachineMemory, EG_NOALIAS, 0, __FILE__, __LINE__, vp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf, er_noalias);
goto err;
}
}
_clip_retni(ClipMachineMemory, ret + 1);
_clip_destroy(ClipMachineMemory, data);
free(data);
return 0;
err:
_clip_destroy(ClipMachineMemory, data);
free(data);
return er;
}
static unsigned int *
rm_prim(ClipMachine * ClipMachineMemory, RDD_DATA * rd, RDD_FILTER * fp, int bytes, int *optimize, int npseudo, RDD_PSEUDO * pseudo, int test, unsigned int *obm, const char *__PROC__)
{
unsigned int *bm;
int oper;
char *lval;
char *rval;
char *p;
if (!obm)
bm = calloc(sizeof(unsigned int), bytes);
else
bm = obm;
rd->curlex = rm_yylex(rd, 0);
switch (rd->curlex)
{
case RM_NOT:
{
unsigned int *tm;
ADDLEX("!");
tm = rm_prim(ClipMachineMemory, rd, fp, bytes, optimize, npseudo, pseudo, test, NULL, __PROC__);
if (!tm)
{
free(bm);
return NULL;
}
if (*optimize)
rm_not(bm, tm, bytes);
else
{
memcpy(bm, tm, bytes * 4);
free(tm);
}
return bm;
}
case RM_LP:
ADDLEX("(");
free(bm);
bm = rm_expr(ClipMachineMemory, rd, fp, bytes, optimize, npseudo, pseudo, test, __PROC__);
if (rd->curlex != RM_RP)
{
free(bm); // Right bracket expected
return NULL;
}
ADDLEX(")");
break;
case RM_WORD:
{
ClipVar lb, rb, lv, rv;
char expr[1024];
int er;
p = lval = rm_alias2name(npseudo, pseudo, rd->yylval);
oper = rd->curlex = rm_yylex(rd, 0);
while (*p)
{
if (*p == RM_AL)
*p = '>';
p++;
}
if (oper != RM_EQU && oper != RM_EEQU && oper != RM_NEQU && oper != RM_LAR && oper != RM_LARE && oper != RM_LES && oper != RM_LESE)
{
rdd_expandmacro(rd->area, rd->rdhandle, lval, expr);
er = _clip_eval_macro(ClipMachineMemory, expr, strlen(expr), &lb);
if (er)
{
ClipMachineMemory->m6_error = 2219;
_clip_destroy(ClipMachineMemory, &lb);
free(lval);
free(bm);
return NULL;
}
ClipMachineMemory->noerrblock++;
er = _clip_eval(ClipMachineMemory, _clip_vptr(&lb), 0, NULL, &lv);
ClipMachineMemory->noerrblock--;
_clip_destroy(ClipMachineMemory, &lb);
_clip_destroy(ClipMachineMemory, &lv);
if (er)
{
ClipMachineMemory->m6_error = 2221;
ADDLEX(".T.");
if (!obm)
memset(bm, 0xff, bytes << 2);
}
else
{
ADDLEX(lval);
if (obm)
{
if (rm_intersectscope(ClipMachineMemory, rd, fp, bm, RM_EEQU, lval, ".T.", bytes, optimize, test, NULL, __PROC__))
return NULL;
}
else
{
if (rm_setscope(ClipMachineMemory, rd, fp, bm, RM_EEQU, lval, ".T.", bytes, optimize, test, NULL, __PROC__))
return NULL;
}
}
free(lval);
return bm;
}
rd->curlex = rm_yylex(rd, 0);
if (rd->curlex != RM_WORD)
{
rdd_err(ClipMachineMemory, EG_ARG, 0, __FILE__, __LINE__, __PROC__, "Expression expected");
return NULL;
}
p = rval = rm_alias2name(npseudo, pseudo, rd->yylval);
while (*p)
{
if (*p == RM_AL)
*p = '>';
p++;
}
rdd_expandmacro(rd->area, rd->rdhandle, lval, expr);
if ((er = _clip_eval_macro(ClipMachineMemory, expr, strlen(expr), &lb)))
{
ClipMachineMemory->m6_error = 2219;
_clip_destroy(ClipMachineMemory, &lb);
free(lval);
free(rval);
free(bm);
return NULL;
}
ClipMachineMemory->noerrblock++;
er = _clip_eval(ClipMachineMemory, _clip_vptr(&lb), 0, NULL, &lv);
ClipMachineMemory->noerrblock--;
_clip_destroy(ClipMachineMemory, &lb);
_clip_destroy(ClipMachineMemory, &lv);
if (!er)
{
rdd_expandmacro(rd->area, rd->rdhandle, rval, expr);
if ((er = _clip_eval_macro(ClipMachineMemory, expr, strlen(expr), &rb)))
{
ClipMachineMemory->m6_error = 2219;
_clip_destroy(ClipMachineMemory, &rb);
free(lval);
free(rval);
free(bm);
return NULL;
}
ClipMachineMemory->noerrblock++;
er = _clip_eval(ClipMachineMemory, _clip_vptr(&rb), 0, NULL, &rv);
ClipMachineMemory->noerrblock--;
_clip_destroy(ClipMachineMemory, &rb);
_clip_destroy(ClipMachineMemory, &rv);
}
if (er)
{
ClipMachineMemory->m6_error = 2221;
ADDLEX(".T.");
if (!obm)
memset(bm, 0xff, bytes << 2);
}
else
{
int ic = 0;
if (obm)
{
if (rm_intersectscope(ClipMachineMemory, rd, fp, bm, oper, lval, rval, bytes, optimize, test, &ic, __PROC__))
return NULL;
}
else
{
if (rm_setscope(ClipMachineMemory, rd, fp, bm, oper, lval, rval, bytes, optimize, test, &ic, __PROC__))
return NULL;
}
if (ic)
ADDLEX("xupper(");
ADDLEX(lval);
if (ic)
ADDLEX(")");
switch (oper)
{
case RM_EQU:
ADDLEX("=");
break;
case RM_EEQU:
ADDLEX("==");
break;
case RM_NEQU:
ADDLEX("!=");
break;
case RM_LAR:
ADDLEX(">");
break;
case RM_LARE:
ADDLEX(">=");
break;
case RM_LES:
ADDLEX("<");
break;
case RM_LESE:
ADDLEX("<=");
break;
}
if (ic)
ADDLEX("xupper(");
ADDLEX(rval);
if (ic)
ADDLEX(")");
}
free(lval);
free(rval);
break;
}
default:
return NULL;
}
rd->curlex = rm_yylex(rd, 0);
return bm;
}
