damaris-backends/core/xml_states.cpp
2014-06-26 11:10:51 +00:00

370 lines
12 KiB
C++

/* **************************************************************************
Author: Achim Gaedke
Created: June 2004
****************************************************************************/
#include "states.h"
#include "xml_states.h"
#include <fcntl.h>
#include <unistd.h>
#include <stdarg.h>
#include <cstring>
#ifndef SIZETPRINTFLETTER
# ifndef __LP64__
# define SIZETPRINTFLETTER "u"
# else
# define SIZETPRINTFLETTER "lu"
# endif
#endif
void xml_state_reader_startelement_handler(xml_state_reader* self,
const XML_Char *name,
const XML_Char **atts ) {
self->start_element(name,atts);
}
void xml_state_reader_endelement_handler(xml_state_reader* self,
const XML_Char *name) {
self->end_element(name);
}
const XML_Char* xml_state_reader::search_attribute(const XML_Char** atts,const XML_Char* attr_name) const {
if (atts==NULL || atts[0]==NULL) return NULL;
size_t attr_idx=0;
while (strcmp(atts[attr_idx],attr_name)!=0) {
attr_idx+=2;
if (atts[attr_idx]==NULL) return NULL;
}
return atts[attr_idx+1];
}
const XML_Char* xml_state_reader::search_attributes(const XML_Char** atts, ...) const {
if (atts==NULL || atts[0]==NULL) return NULL;
va_list names;
va_start(names,atts);
const XML_Char* attr_name=va_arg(names, const XML_Char*);
while (attr_name!=NULL) {
size_t attr_idx=0;
while (atts[attr_idx]!=NULL && strcmp(atts[attr_idx],attr_name)!=0)
attr_idx+=2;
if (atts[attr_idx]!=NULL) {
va_end(names);
return atts[attr_idx+1];
}
attr_name=va_arg(names, const XML_Char*);
}
va_end(names);
return NULL;
}
state_atom* xml_state_reader::state_factory(const XML_Char *name,
const XML_Char **atts) const {
if (strcmp(name,"state")==0) {
state* s=new state(1);
const XML_Char* length=search_attributes(atts,"length","time",(XML_Char*)NULL);
if (length!=NULL) s->length=strtod(length,NULL);
return s;
}
if (strcmp(name,"sequent")==0) {
state_sequent* s=new state_sequent();
const XML_Char* repeat=search_attribute(atts,"repeat");
if (repeat!=NULL)
s->repeat=strtoul(repeat,0,0);
else
s->repeat=1;
return s;
}
if (strcmp(name,"parallel")==0) {
return new state_parallel();
}
if (strcmp(name,"ttlout")==0) {
ttlout* ttls=new ttlout();
const XML_Char* id=search_attributes(atts,"id","i",(XML_Char*)NULL);
if (id!=NULL) ttls->id=strtol(id,NULL,0);
const XML_Char* value=search_attribute(atts,"value");
if (value!=NULL) ttls->ttls=strtoul(value,NULL,0);
const XML_Char* channel=search_attribute(atts,"channel");
if (channel!=NULL) {
const XML_Char* state=search_attribute(atts,"state");
if (state!=NULL) {
size_t number=strtoul(channel,0,0);
char state_char=(state)[0];
if (state_char=='h' || state_char=='1')
ttls->ttls.set(number,1);
else
ttls->ttls.set(number,0);
}
else {
fprintf(stderr,"found invalid ttl state: ignoring\n");
delete ttls;
ttls=NULL;
}
}
return (state_atom*)ttls;
}
if (strcmp(name,"analogout")==0) {
analogout* aout=new analogout();
const XML_Char* channel=search_attributes(atts,"channel","c","id","i",(XML_Char*)NULL);
const XML_Char* frequency=search_attributes(atts,"frequency","f",(XML_Char*)NULL);
const XML_Char* phase=search_attributes(atts,"phase","p",(XML_Char*)NULL);
const XML_Char* amplitude=search_attributes(atts,"amplitude","a",(XML_Char*)NULL);
const XML_Char* dac_value=search_attributes(atts,"dac_value","d",(XML_Char*)NULL);
if (dac_value!=NULL) aout->dac_value=strtol(dac_value,NULL,0);
if (channel!=NULL) aout->id=strtoul(channel,NULL,0);
if (frequency!=NULL) aout->frequency=strtod(frequency,NULL);
if (phase!=NULL) aout->phase=strtod(phase,NULL);
if (amplitude!=NULL)
aout->amplitude=strtod(amplitude,NULL);
else
aout->amplitude=1.0;
return (state_atom*)aout;
}
if (strcmp(name,"analogin")==0) {
analogin* ain=new analogin();
const XML_Char* id=search_attributes(atts,"id","i",(XML_Char*)NULL);
const XML_Char* frequency=search_attributes(atts,"f","frequency",(XML_Char*)NULL);
const XML_Char* samples=search_attributes(atts,"s","samples",(XML_Char*)NULL);
const XML_Char* channels=search_attributes(atts,"c","channels",(XML_Char*)NULL);
const XML_Char* resolution = search_attributes(atts,"r","res","resolution",(XML_Char*)NULL);
if (resolution!=NULL)
ain->resolution=strtoul(resolution,NULL,0);
else
ain->resolution=14; // was 12
if (frequency!=NULL) ain->sample_frequency=strtod(frequency,NULL);
if (samples!=NULL) ain->samples=strtoul(samples,NULL,0);
if (id!=NULL) ain->id=strtoul(id,NULL,0);
if (channels!=NULL) {
ain->channels = channel_array(strtoul(channels,NULL,0));
ain->nchannels = ain->channels.count();
} else {
ain->channels = channel_array(3);
ain->nchannels = ain->channels.count();
}
// set parameters for each channel
for (int i = 0; i < ain->nchannels; i++) {
if (ain->channels[i] == true) {
char buffer1[100];
char buffer2[100];
sprintf(buffer1, "sen%i", i);
sprintf(buffer2, "sensitivity%i", i - 1);
// read sensitivity
const XML_Char* sensitivity = search_attributes(atts, buffer1, buffer2,(XML_Char*)NULL);
if (sensitivity != NULL) {
if (ain->sensitivity == NULL) {
ain->sensitivity = new double[ain->nchannels];
}
ain->sensitivity[i] = strtod(sensitivity, NULL);
} else {
ain->sensitivity[i] = ADC_M2I_DEFAULT_SENSITIVITY;
}
delete sensitivity;
// read offset
sprintf(buffer1, "offset%i", i);
const XML_Char* offset = search_attributes(atts, buffer1, (XML_Char*)NULL);
if (offset != NULL) {
if (ain->offset == NULL) {
ain->offset = new int[ain->nchannels];
}
ain->offset[i] = strtol(offset, NULL, 0);
} else {
ain->offset[i] = ADC_M2I_DEFAULT_OFFSET;
}
delete offset;
// read impedance
sprintf(buffer1, "impedance%i", i);
const XML_Char* impedance = search_attributes(atts, buffer1, (XML_Char*)NULL);
if (impedance != NULL) {
if (ain->impedance == NULL) {
ain->impedance = new double[ain->nchannels];
}
ain->impedance[i] = strtol(impedance, NULL, 0);
} else {
ain->impedance[i] = ADC_M2I_DEFAULT_IMPEDANCE;
}
delete impedance;
}
}
return (state_atom*)ain;
}
fprintf(stderr,"unknown tag %s found\n",name);
return NULL;
}
void xml_state_reader::start_element(const XML_Char *name,
const XML_Char **atts) {
state_atom* new_element=state_factory(name,atts);
if (root==NULL)
root=new_element;
if (new_element!=NULL && !pending_elements.empty()) {
state* container=dynamic_cast<state*>(pending_elements.back());
if (container!=NULL)
container->push_back(new_element);
else
fprintf(stderr,"found invalid nested element %s\n",name);
}
pending_elements.push_back(new_element);
}
void xml_state_reader::end_element(const XML_Char *name) {
pending_elements.pop_back();
}
xml_state_reader::xml_state_reader() {
fprintf(stderr, "xml_state_reader class is decrepated, please shift to xerces supporting classes.\n");
root=(state_atom*)NULL;
parser=XML_ParserCreate((XML_Char*)NULL);
XML_SetUserData(parser,(void*)this);
XML_SetElementHandler(parser,
(XML_StartElementHandler)xml_state_reader_startelement_handler,
(XML_EndElementHandler)xml_state_reader_endelement_handler);
}
state_atom* xml_state_reader::read_from_string(const std::string& data) {
if (!XML_Parse(parser,data.c_str(), data.size(),1)) {
/* handle parse error */
fprintf(stderr,"error while parsing\n");
delete root;
root=NULL;
return NULL;
}
state_atom* return_value=root;
root=NULL;
return return_value;
}
state_atom* xml_state_reader::read_from_file(const std::string& filename) {
int docfd=open(filename.c_str(),O_RDONLY);
for (;;) {
const size_t BUFF_SIZE=1<<12;
int bytes_read;
void *buff = XML_GetBuffer(parser, BUFF_SIZE);
if (buff == NULL) {
fprintf(stderr, "could not get the buffer from XML Parser\n");
close(docfd);
return NULL;
}
bytes_read = read(docfd, buff, BUFF_SIZE);
if (bytes_read < 0) {
/* handle error */
fprintf(stderr,"error while reading\n");
if (root!=NULL) delete root;
root=NULL;
break;
}
if (! XML_ParseBuffer(parser, bytes_read, bytes_read == 0)) {
/* handle parse error */
fprintf(stderr,"error while parsing\n");
if (root!=NULL) delete root;
root=NULL;
break;
}
// peaceful end
if (bytes_read == 0) break;
};
close(docfd);
state_atom* return_value=root;
root=NULL;
return return_value;
}
xml_state_reader::~xml_state_reader(){
XML_ParserFree(parser);
if (root!=NULL) delete root;
}
int xml_state_writer::write_states(FILE* output, const state_atom& states_to_write, int add_header, int indent_size) {
if (add_header) {
fprintf(output,"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
}
std::string indent_string(indent_size,' ');
const state_sequent* ss=dynamic_cast<const state_sequent*>(&states_to_write);
if (ss!=NULL) {
if (ss->repeat==1)
fprintf(output,"%s<sequent>\n",indent_string.c_str());
else
fprintf(output,"%s<sequent repeat=\"%" SIZETPRINTFLETTER "\">\n",indent_string.c_str(),ss->repeat);
for (state::const_iterator i=ss->begin();i!=ss->end(); i++) {
write_states(output,**i,0,indent_size+indent_increase);
}
fprintf(output,"%s</sequent>\n",indent_string.c_str());
return 1;
}
const state_parallel* sp=dynamic_cast<const state_parallel*>(&states_to_write);
if (sp!=NULL){
fprintf(output,"%s<parallel>\n",indent_string.c_str());
for (state::const_iterator i=sp->begin();i!=sp->end(); i++) {
write_states(output,**i,0,indent_size+indent_increase);
}
fprintf(output,"%s</parallel>\n",indent_string.c_str());
return 1;
}
const state* st=dynamic_cast<const state*>(&states_to_write);
if (st!=NULL) {
fprintf(output,"%s<state length=\"%g\">\n",indent_string.c_str(),st->length);
for (state::const_iterator i=st->begin();i!=st->end(); i++) {
write_states(output,**i,0,indent_size+indent_increase);
}
fprintf(output,"%s</state>\n",indent_string.c_str());
return 1;
}
const ttlout* ttlo=dynamic_cast<const ttlout*>(&states_to_write);
if (ttlo!=NULL) {
fprintf(output,"%s<ttlout value=\"0x%lx\"/>\n",
indent_string.c_str(),
ttlo->ttls.to_ulong());
return 1;
}
const analogout* ao=dynamic_cast<const analogout*>(&states_to_write);
if (ao!=NULL) {
fprintf(output,
"%s<analogout id=\"%d\" frequency=\"%g\" amplitude=\"%g\" phase=\"%g\" dac_value=\"%d\"/>\n",
indent_string.c_str(),
ao->id,
ao->frequency,
ao->amplitude,
ao->phase,
ao->dac_value);
return 1;
}
const analogin* ai=dynamic_cast<const analogin*>(&states_to_write);
if (ai!=NULL) {
char args[2000];
char buffer[1000];
sprintf(args, "%s<analogin id=\"%d\" samples=\"%" SIZETPRINTFLETTER "\" sample_frequency=\"%g\" channels=\"%lu\" resolution=\"%" SIZETPRINTFLETTER "\"",
indent_string.c_str(),
ai->id,
ai->samples,
ai->sample_frequency,
ai->channels.to_ulong(),
ai->resolution);
for (int i = 0; i < ai->nchannels; i++) {
sprintf(buffer, "sensitivity%d=\"%g\" offset%d=\"%d\" impedance%d=\"%g\"", i, ai->sensitivity[i], i, ai->offset[i], i, ai->impedance[i]);
strcat(args, buffer);
}
strcat(args, "/>\n");
fprintf(output, args);
return 1;
}
fprintf(output,"%s<!-- something missing -->\n",indent_string.c_str());
return 0;
}