JNIEXPORT void JNICALL Java_LocalDataProvider_SetEnvironmentSpecific(JNIEnv *env, jobject obj,
jstring in, jstring jdefNode)
{
int status, nid;
const char *in_char = (*env)->GetStringUTFChars(env, in, 0);
const char *defNode;
struct descriptor in_d = {0,DTYPE_T,CLASS_S,0};
EMPTYXD(xd);
error_message[0] = 0;
if(in_char && *in_char)
{
in_d.length = strlen(in_char);
in_d.pointer = (char *)in_char;
status = TdiCompile(&in_d, &xd MDS_END_ARG);
if(status & 1)
status = TdiData(&xd, &xd MDS_END_ARG);
if(!(status & 1))
strncpy(error_message, MdsGetMsg(status), 512);
MdsFree1Dx(&xd, NULL);
(*env)->ReleaseStringUTFChars(env, in, in_char);
}
if(jdefNode)
{
defNode = (*env)->GetStringUTFChars(env, jdefNode, 0);
status = TreeFindNode((char *)defNode, &nid);
if(status & 1)
TreeSetDefaultNid(nid);
(*env)->ReleaseStringUTFChars(env, jdefNode, defNode);
}
}
static char *MdsGetString(char *in)
{
char *out = NULL;
int status;
struct descriptor in_d = {0,DTYPE_T,CLASS_S,0};
EMPTYXD(xd);
in_d.length = strlen(in);
in_d.pointer = in;
status = TdiCompile(&in_d, &xd MDS_END_ARG);
if(status & 1)
status = TdiData(&xd, &xd MDS_END_ARG);
if(!(status & 1))
{
strncpy(error_message, MdsGetMsg(status), 512);
return NULL;
}
if(!xd.pointer)
{
strcpy(error_message, "Missing data");
return NULL;
}
if(xd.pointer->dtype != DTYPE_T)
{
MdsFree1Dx(&xd, NULL);
strcpy(error_message, "Not a string");
return NULL;
}
out = (char *)malloc(xd.pointer->length + 1);
memcpy(out, xd.pointer->pointer, xd.pointer->length);
out[xd.pointer->length] = 0;
MdsFree1Dx(&xd, NULL);
error_message[0] = 0;
return out;
}
int deleteTreeData(void *dbid, int nid)
{
EMPTYXD(xd);
int status;
status = _TreePutRecord(dbid, nid, (struct descriptor *)&xd, 0);
return status;
}
int deleteTreeData(void *dbid, int nid, int isCached, int cachePolicy)
{
EMPTYXD(xd);
int status;
if(isCached)
status = _RTreePutRecord(dbid, nid, (struct descriptor *)&xd, cachePolicy);
else
status = _TreePutRecord(dbid, nid, (struct descriptor *)&xd, 0);
return status;
}
int getTreeData(void *dbid, int nid, void **data, void *tree)
{
EMPTYXD(xd);
int status;
status = _TreeGetRecord(dbid, nid, &xd);
if(!(status & 1)) return status;
*data = convertFromDsc(&xd, tree);
MdsFree1Dx(&xd, 0);
return status;
}
int getTreeSegment(void *dbid, int nid, int segIdx, void **dataDsc, void **timeDsc)
{
EMPTYXD(emptyXd);
struct descriptor_xd *dataXd = (struct descriptor_xd *)malloc(sizeof(struct descriptor_xd));
struct descriptor_xd *timeXd = (struct descriptor_xd *)malloc(sizeof(struct descriptor_xd));
*dataXd = emptyXd;
*dataDsc = dataXd;
*timeXd = emptyXd;
*timeDsc = timeXd;
return _TreeGetSegment(dbid, nid, segIdx, dataXd, timeXd);
}
int getTreeSegmentLimits(void *dbid, int nid, int idx, void **startPtr, void **endPtr)
{
struct descriptor_xd *startXd, *endXd;
EMPTYXD(emptyXd);
startXd = (struct descriptor_xd *)malloc(sizeof(struct descriptor_xd));
*startXd = emptyXd;
endXd = (struct descriptor_xd *)malloc(sizeof(struct descriptor_xd));
*endXd = emptyXd;
*startPtr = startXd;
*endPtr = endXd;
return _TreeGetSegmentLimits(dbid, nid, idx, startXd, endXd);
}
static float MdsGetFloat(char *in)
{
float ris = 0;
int status;
struct descriptor in_d = {0,DTYPE_T,CLASS_S,0};
EMPTYXD(xd);
in_d.length = strlen(in);
in_d.pointer = in;
status = TdiCompile(&in_d, &xd MDS_END_ARG);
if(status & 1)
status = TdiData(&xd, &xd MDS_END_ARG);
if(status & 1)
status = TdiFloat(&xd, &xd MDS_END_ARG);
if(!(status & 1))
{
strncpy(error_message, MdsGetMsg(status), 512);
return 0;
}
if(!xd.pointer)
{
strcpy(error_message, "Missing data");
return 0;
}
if(xd.pointer->class != CLASS_S)
{
strcpy(error_message, "Not a scalar");
return 0;
}
switch(xd.pointer->dtype) {
case DTYPE_BU:
case DTYPE_B : ris = (float)(*(char *)xd.pointer->pointer); break;
case DTYPE_WU:
case DTYPE_W : ris = (float)(*(short *)xd.pointer->pointer); break;
case DTYPE_LU:
case DTYPE_L : ris = (float)(*(int *)xd.pointer->pointer); break;
case DTYPE_F : ris = *(float *)xd.pointer->pointer; break;
case DTYPE_FS: ris = *(float *)xd.pointer->pointer; break;
case DTYPE_D :
case DTYPE_G : ris = *(float *)xd.pointer->pointer; break;
default: sprintf(error_message, "Not a supported type %d", xd.pointer->dtype);
return 0;
}
MdsFree1Dx(&xd, NULL);
error_message[0] = 0;
return ris;
}
int getTreeSegmentLimits(void *dbid, int nid, void **startPtr, void **endPtr, int isCached)
{
struct descriptor_xd *startXd, *endXd;
EMPTYXD(emptyXd);
startXd = (struct descriptor_xd *)malloc(sizeof(struct descriptor_xd));
*startXd = emptyXd;
endXd = (struct descriptor_xd *)malloc(sizeof(struct descriptor_xd));
*endXd = emptyXd;
*startPtr = startXd;
*endPtr = endXd;
if(isCached)
return _RTreeGetSegmentLimits(dbid, nid, -1, startXd, endXd);
else
return _TreeGetSegmentLimits(dbid, nid, -1, startXd, endXd);
}
/***************************************************************
* TclShowAttribute:
***************************************************************/
int TclShowAttribute() {
int status;
int nid;
EMPTYXD(xd);
static DYNAMIC_DESCRIPTOR(dsc_node);
static DYNAMIC_DESCRIPTOR(dsc_attr);
static DYNAMIC_DESCRIPTOR(dsc_string);
cli_get_value("NODE",&dsc_node);
status = TreeFindNode(dsc_node.dscA_pointer,&nid);
if (status & 1) {
status = cli_get_value("NAME",&dsc_attr);
if (status & 1) {
status = TreeGetXNci(nid,dsc_attr.dscA_pointer,&xd);
if (status & 1) {
status = TdiDecompile(&xd,&dsc_string MDS_END_ARG);
if (status & 1) {
char *p = malloc(dsc_string.dscW_length+1);
strncpy(p,dsc_string.dscA_pointer,dsc_string.dscW_length);
p[dsc_string.dscW_length]='\0';
TclTextOut(p);
free(p);
}
StrFree1Dx(&dsc_string);
MdsFree1Dx(&xd,0);
}
} else {
if (TreeGetXNci(nid,"attributenames",&xd)&1) {
TdiSortVal(&xd,&xd MDS_END_ARG);
if (xd.dscA_pointer && xd.dscA_pointer->dscB_class == CLASS_A) {
typedef ARRAY(char) ARRAY_DSC;
ARRAY_DSC *array=(ARRAY_DSC *)xd.dscA_pointer;
char *name=array->dscA_pointer;
TclTextOut("Defined attributes for this node:");
for (name=array->dscA_pointer;name<array->dscA_pointer+array->dscL_arsize;name+=array->dscW_length) {
char *out=malloc(array->dscW_length+6);
sprintf(out," %.*s",array->dscW_length,name);
TclTextOut(out);
free(out);
}
} else {
TclTextOut("No attributes defined for this node");
}
MdsFree1Dx(&xd,0);
} else {
STATIC_ROUTINE int RewriteDatafile(void **dbid, char *tree, int shot, int compress)
{
int status;
void *dbid1 = 0, *dbid2 = 0;
char *from_c = NULL;
char *to_c = NULL;
char *from_d = NULL;
char *to_d = NULL;
int lstatus;
status = _TreeOpenEdit(&dbid1, tree, shot);
if (status & 1)
{
int stv;
PINO_DATABASE *dblist1 = (PINO_DATABASE *)dbid1;
TREE_INFO *info1 = dblist1->tree_info;
status = TreeOpenNciW(dblist1->tree_info, 0);
if (status & 1)
{
status = TreeOpenDatafileW(dblist1->tree_info, &stv, 0);
if (status & 1)
{
status = _TreeOpenEdit(&dbid2, tree, shot);
if (status & 1)
{
PINO_DATABASE *dblist2 = (PINO_DATABASE *)dbid2;
TREE_INFO *info2 = dblist2->tree_info;
status = TreeOpenNciW(dblist2->tree_info, 1);
if (status & 1)
{
dblist2->tree_info->edit->first_in_mem = dblist1->tree_info->edit->first_in_mem;
status = TreeOpenDatafileW(dblist2->tree_info, &stv, 1);
if (status & 1)
{
int i;
for (i=0;i<info1->header->nodes;i++)
{
EMPTYXD(xd);
EMPTYXD(mtxd);
NCI nci;
TreeGetNciW(info1, i, &nci);
TreePutNci(info2, i, &nci, 1);
lstatus = _TreeGetRecord(dbid1, i, &xd);
if (lstatus & 1)
lstatus = _TreePutRecord(dbid2, i, (struct descriptor *)&xd, compress ? 2 : 1);
else if (lstatus == TreeBADRECORD || lstatus == TreeINVDFFCLASS)
{
fprintf(stderr,"TreeBADRECORD, Clearing nid %d\n",i);
lstatus = _TreePutRecord(dbid2, i, (struct descriptor *)&mtxd, compress ? 2 : 1);
}
MdsFree1Dx(&xd,NULL);
}
from_c = strcpy(malloc(strlen(info1->filespec)+20),info1->filespec);
strcpy(from_c+strlen(info1->filespec)-4,"characteristics#");
to_c = strcpy(malloc(strlen(info1->filespec)+20),info1->filespec);
strcpy(to_c+strlen(info1->filespec)-4,"characteristics");
from_d = strcpy(malloc(strlen(info1->filespec)+20),from_c);
strcpy(from_d+strlen(info1->filespec)-4,"datafile#");
to_d = strcpy(malloc(strlen(info1->filespec)+20),to_c);
strcpy(to_d+strlen(info1->filespec)-4,"datafile");
}
}
_TreeClose(&dbid2, 0, 0);
}
}
}
_TreeClose(&dbid1, 0, 0);
if (status & 1)
{
status = remove(to_c) == 0 ? TreeNORMAL : TreeFAILURE;
if (status & 1)
status = remove(to_d) == 0 ? TreeNORMAL : TreeFAILURE;
if (status & 1)
status = ((rename(from_c,to_c) == 0) && (rename(from_d,to_d) == 0)) ? TreeNORMAL : TreeFAILURE;
}
if (from_c) free(from_c);
if (to_c) free(to_c);
if (from_d) free(from_d);
if (to_d) free(to_d);
}
return status;
}
static void *MdsGetArray(char *in, int *out_dim, int is_float, int is_byte, int is_double)
{
float *float_ris = NULL;
double *double_ris = NULL;
int *int_ris = NULL;
char *byte_ris = NULL;
int status, dim, i;
struct descriptor in_d = {0,DTYPE_T,CLASS_S,0};
EMPTYXD(xd);
struct descriptor_a *arr_ptr;
char *expanded_in;
error_message[0] = 0;
*out_dim = 0;
if(is_float)
{
expanded_in = malloc(strlen(in) + 16);
sprintf(expanded_in, "fs_float((%s))", in);
in_d.length = strlen(expanded_in);
in_d.pointer = expanded_in;
}
else if(is_double)
{
expanded_in = malloc(strlen(in) + 16);
sprintf(expanded_in, "ft_float((%s))", in);
in_d.length = strlen(expanded_in);
in_d.pointer = expanded_in;
}
else
{
expanded_in = malloc(strlen(in) + 16);
sprintf(expanded_in, "long((%s))", in);
in_d.length = strlen(expanded_in);
in_d.pointer = expanded_in;
/* in_d.length = strlen(in);
in_d.pointer = in;*/
}
status = TdiCompile(&in_d, &xd MDS_END_ARG);
if(is_float) free(expanded_in);
if(status & 1)
status = TdiData(&xd, &xd MDS_END_ARG);
if(!(status & 1))
{
strncpy(error_message, MdsGetMsg(status), 512);
return 0;
}
if(!xd.pointer)
{
strcpy(error_message, "Missing data");
return 0;
}
if(xd.pointer->class != CLASS_A)
{
if(!is_float && !is_double) /*Legal only if used to retrieve the shot number*/
{
int_ris = malloc(sizeof(int));
switch(xd.pointer->dtype)
{
case DTYPE_BU:
case DTYPE_B : int_ris[0] = *((char *)xd.pointer->pointer); break;
case DTYPE_WU:
case DTYPE_W : int_ris[0] = *((short *)xd.pointer->pointer); break;
case DTYPE_LU:
case DTYPE_L : int_ris[0] = *((int *)xd.pointer->pointer); break;
case DTYPE_F :
case DTYPE_FS : int_ris[0] = *((int *)xd.pointer->pointer); break;
}
*out_dim = 1;
return int_ris;
}
strcpy(error_message, "Not an array");
return 0;
}
arr_ptr = (struct descriptor_a *)xd.pointer;
/* if(arr_ptr->dtype == DTYPE_F ||
arr_ptr->dtype == DTYPE_D ||
arr_ptr->dtype == DTYPE_G ||
arr_ptr->dtype == DTYPE_H)
{
status = TdiFloat(&xd, &xd MDS_END_ARG);
arr_ptr = (struct descriptor_a *)xd.pointer;
}
*/
*out_dim = dim = arr_ptr->arsize/arr_ptr->length;
if(is_float)
float_ris = (float *)malloc(sizeof(float) * dim);
else if(is_double)
double_ris = (double *)malloc(sizeof(double) * dim);
else if(is_byte)
byte_ris = malloc(dim);
else
int_ris = (int *)malloc(sizeof(int) * dim);
switch(arr_ptr->dtype) {
case DTYPE_BU:
case DTYPE_B :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = ((char *)arr_ptr->pointer)[i];
else if(is_double)
double_ris[i] = ((char *)arr_ptr->pointer)[i];
else if(is_byte)
byte_ris[i] = ((char *)arr_ptr->pointer)[i];
else
int_ris[i] = ((char *)arr_ptr->pointer)[i];
break;
case DTYPE_WU:
case DTYPE_W :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = ((short *)arr_ptr->pointer)[i];
else if(is_double)
double_ris[i] = ((char *)arr_ptr->pointer)[i];
else if(is_byte)
byte_ris[i] = (char)(((short *)arr_ptr->pointer)[i]);
else
int_ris[i] = ((short *)arr_ptr->pointer)[i];
break;
case DTYPE_LU:
case DTYPE_L :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = (float)(((int *)arr_ptr->pointer)[i]);
if(is_double)
double_ris[i] = (double)(((int *)arr_ptr->pointer)[i]);
else if(is_byte)
byte_ris[i] = ((int *)arr_ptr->pointer)[i];
else
int_ris[i] = ((int *)arr_ptr->pointer)[i];
break;
case DTYPE_F :
case DTYPE_FS :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = ((float *)arr_ptr->pointer)[i];
else if(is_double)
double_ris[i] = (double)((float *)arr_ptr->pointer)[i];
else if(is_byte)
byte_ris[i] = (char)(((float *)arr_ptr->pointer)[i]);
else
int_ris[i] = (int)(((float *)arr_ptr->pointer)[i]);
break;
case DTYPE_FT :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = (float)((double *)arr_ptr->pointer)[i];
else if(is_double)
{
double_ris[i] = ((double *)arr_ptr->pointer)[i];
}
else if(is_byte)
byte_ris[i] = (char)(((double *)arr_ptr->pointer)[i]);
else
int_ris[i] = (int)(((double *)arr_ptr->pointer)[i]);
break;
case DTYPE_D :
case DTYPE_G :
default: strcpy(error_message, "Not a supported type");
return NULL;
}
MdsFree1Dx(&xd, NULL);
error_message[0] = 0;
if(is_float)
return float_ris;
else if(is_double)
return double_ris;
else if(is_byte)
return byte_ris;
return int_ris;
}
int main(int argc, char **argv)
{
int len;
char data[MAXDATA];
int opt;
int showdata=0;
int timeout=0;
char *event;
int status;
int serialized=0;
int i;
#ifdef HAVE_WINDOWS_H
int optind=argc;
for (i=1;i<argc;i++) {
if (argv[i][0]=='/') {
switch (argv[i][1]) {
case '?': printhelp(argv[0]); return 0; break;
case 'd': showdata=1; break;
case 'D': showdata=1;serialized=1; break;
case 't': if (strlen(argv[i])>3 && argv[i][2]==':') timeout=atoi(&argv[i][3]); break;
default: printhelp(argv[0]); return 1; break;
}
} else {
if (optind==argc)
optind=i;
else {
printhelp(argv[0]);
return 1;
}
}
}
#else
struct option longopts[]={{"data",0,0,'d'},
{"timeout",1,0,'t'},
{"help",0,0,'h'},
{"serialized",0,0,'D'},
{0,0,0,0}};
while ((opt=getopt_long(argc,argv,"dDht:",longopts,0)) > -1) {
switch(opt) {
case 'h': printhelp(argv[0]); return 0;
case 'd': showdata=1; break;
case 't': timeout=atoi(optarg); break;
case 'D': showdata=1; serialized=1; break;
default: printhelp(argv[0]); return 1;
}
}
#endif
if (optind==argc) {
printf("Missing event-name\n");
printhelp(argv[0]);
return 1;
}
event=argv[optind];
status=MDSWfeventTimed(event, MAXDATA, data, &len,timeout);
if (status & 1) {
if (showdata && len)
{
int i,istext=1;
if (serialized) {
EMPTYXD(xd);
struct descriptor ans = {0,DTYPE_T,CLASS_D,0};
status=MdsSerializeDscIn(data,&xd);
if (status & 1) {
TdiDecompile(&xd,&ans MDS_END_ARG);
if (ans.pointer) {
printf("Event %s occurred with data = %.*s\n",event,ans.length,ans.pointer);
return 0;
}
}
else {
printf("Event %s occurred with invalid serialized data\n",event);
return 1;
}
}
if (len > MAXDATA) len=MAXDATA;
for (;data[len-1]==0 && len > 0;len--) {;}
for (i=0;i<len;i++) {
if (data[i] < 32 || data[i] >= 127) {
istext=0;
break;
}
}
if (istext)
printf("Event %s occurred with data = \\%.*s\\\n",event,len,data);
else {
printf("Event %s occured with data = [",event);
for (i=0;i<len-1;i++) {
printf("%0dB,",(int)data[i]);
}
printf("%dB]\n",(int)data[i]);
}
}
return(0);
} else if (timeout>0) {
printf("Event %s timed out.\n",event);
return 1;
} else {
printf("Unknown error occurred\n");
return 1;
}
}
