void endObject()
{
const char *curname = tagname();
if (!isEmpty())
{
xml.appendf("</%s>", tagname());
if (!isArray())
pop();
}
}
QString SimpleDBStorage::GetSetClause(MSqlBindings &bindings) const
{
QString tagname(":SET" + GetColumnName().toUpper());
QString clause(GetColumnName() + " = " + tagname);
bindings.insert(tagname, user->GetDBValue());
return clause;
}
QString SimpleDBStorage::setClause(MSqlBindings &bindings)
{
QString tagname(":SET" + column.upper());
QString clause(column + " = " + tagname);
bindings.insert(tagname, setting->getValue().utf8());
return clause;
}
void startKey(const char *name)
{
const char *curname = tagname();
if (tail.length() && isEmpty())
{
StringBuffer fullname(name);
push(fullname.append(tail).str());
}
else
push(name);
}
void gui_filterbar_c::ctx_rename_tag(const ts::str_c &tis)
{
int ti = tis.as_int();
ts::wstr_c hint = TTT("Rename tag $", 218) / ts::wstr_c(CONSTWSTR("<b>")).append(tagname(ti)).append(CONSTWSTR("</b>"));
if (ti < BIT_count)
hint.append(CONSTWSTR("<br>")).append( TTT("Empty - set default",249) );
SUMMON_DIALOG<dialog_entertext_c>(UD_RENTAG, dialog_entertext_c::params(
UD_RENTAG,
gui_isodialog_c::title(title_rentag),
hint,
tagname(ti),
tis,
DELEGATE(this, renamed),
nullptr,
ti < BIT_count ? check_always_ok : check_always_ok_except_empty,
getrid()));
}
void gui_filterbar_c::fill_tags()
{
int lnki = 0;
auto make_ht = [&]( const ts::wsptr &htt ) -> ts::wstr_c
{
ts::wstr_c x( CONSTWSTR("<cstm=a\1>"), htt );
x.append( CONSTWSTR("<cstm=b\1>, ") );
x.replace_all( CONSTWSTR("\1"), ts::wmake<int>( lnki++ ) );
return x;
};
ts::wstr_c t;
for (int i = 0; i < BIT_count; ++i)
t.append( make_ht(tagname(i)) );
for(const ts::str_c &ht : contacts().get_all_tags())
t.append(make_ht(from_utf8(ht)));
t.trunc_length(2);
set_text(t);
}
shared_ptr<mw::Component> LinearEyeCalibratorFactory::createObject(std::map<std::string, std::string> parameters,
ComponentRegistry *reg) {
REQUIRE_ATTRIBUTES(parameters, "tag", "eyeh_raw", "eyeh_calibrated", "eyev_raw", "eyev_calibrated");
std::string tagname(parameters.find("tag")->second);
shared_ptr<Variable> eyeh_raw = reg->getVariable(parameters.find("eyeh_raw")->second);
shared_ptr<Variable> eyev_raw = reg->getVariable(parameters.find("eyev_raw")->second);
shared_ptr<Variable> eyeh_calibrated = reg->getVariable(parameters.find("eyeh_calibrated")->second);
shared_ptr<Variable> eyev_calibrated = reg->getVariable(parameters.find("eyev_calibrated")->second);
checkAttribute(eyeh_raw, parameters["reference_id"], "eyeh_raw", parameters.find("eyeh_raw")->second);
checkAttribute(eyev_raw, parameters["reference_id"], "eyev_raw", parameters.find("eyev_raw")->second);
checkAttribute(eyeh_calibrated, parameters["reference_id"], "eyeh_calibrated", parameters.find("eyeh_calibrated")->second);
checkAttribute(eyev_calibrated, parameters["reference_id"], "eyev_calibrated", parameters.find("eyev_calibrated")->second);
shared_ptr <mw::Component> newEyeCalibrator = shared_ptr<mw::Component>(new EyeCalibrator(tagname,
eyeh_raw,
eyev_raw,
eyeh_calibrated,
eyev_calibrated,
1));
return newEyeCalibrator;
}
void setValueInt(int val){xml.appendf("<%s>%d</%s>", tagname(), val, tagname()); if (!isArray()) pop();}
void startObject()
{
const char *curname = tagname();
if (!isEmpty())
xml.appendf("<%s>", tagname());
}
void endKey()
{
const char *curname = tagname();
pop();
}
// parses the header, ie processing instructions and doctype tag
/// \todo parse <!doctype> tag
bool Parser::parseHeader(Document& doc, ContextPtr& context)
{
while(true)
{
++mTokenizer;
Token token1 = *mTokenizer;
if (token1 != '<')
{
throw CPPDOM_ERROR(xml_opentag_expected, "");
}
// token after opening < is a literal?
mTokenizer++;
Token token2 = *mTokenizer;
if (!token2.isLiteral())
{
// generic string encountered: assume no pi and doctype tags
mTokenizer.putBack();
mTokenizer.putBack(token1);
return false;
}
// now check for the literal
switch(token2.getLiteral())
{
// comment or doctype tag
case '!':
{
++mTokenizer;
Token token3 = *mTokenizer;
if (!token3.isLiteral())
{
// now a doctype tag or a comment may follow
if (token3.getGeneric().at(0) == '-' &&
token3.getGeneric().at(1) == '-')
{
// needed to correctly handle <!---->
Token temp_token(token3.getGeneric().substr(2));
mTokenizer.putBack(temp_token);
parseComment(context);
}
else
{
std::string doctypestr(token3.getGeneric());
std::transform(doctypestr.begin(), doctypestr.end(), doctypestr.begin(), toupper);
if (doctypestr == "DOCTYPE")
{
// \todo parse doctype tag
// read the complete tag till the closing >
while (*(mTokenizer++) != '>');
}
else
{
throw CPPDOM_ERROR(xml_unknown, "");
}
}
}
else
{
throw CPPDOM_ERROR(xml_pi_doctype_expected, "");
}
break;
}
case '?':
{
++mTokenizer;
Token token3 = *mTokenizer;
if (token3.isLiteral())
{
throw CPPDOM_ERROR(xml_pi_doctype_expected, "");
}
// parse processing instruction
Node pinode(context);
std::string tagname(token3.getGeneric());
pinode.mNodeNameHandle = context->insertTagname(tagname);
#ifdef CPPDOM_DEBUG
pinode.mNodeName_debug = tagname;
#endif
parseAttributes(pinode.attrib());
NodePtr nodeptr(new Node(pinode));
doc.mProcInstructions.push_back(nodeptr);
if (context->hasEventHandler())
{
context->getEventHandler().processingInstruction(pinode);
}
++mTokenizer;
if (*mTokenizer != '?')
{
throw CPPDOM_ERROR(xml_pi_doctype_expected, "");
}
++mTokenizer;
if (*mTokenizer != '>')
{
throw CPPDOM_ERROR(xml_closetag_expected, "");
}
break;
}
default:
// unknown literal encountered
throw CPPDOM_ERROR(xml_pi_doctype_expected, "");
} // end switch
} // end while
}
static void
print_label(struct sun_disklabel *sl, const char *disk, FILE *out)
{
int i, j;
int havevtoc;
uintmax_t secpercyl;
/* Long enough to hex-encode each character. */
char volname[4 * SUN_VOLNAME_LEN + 1];
havevtoc = sl->sl_vtoc_sane == SUN_VTOC_SANE;
secpercyl = sl->sl_nsectors * sl->sl_ntracks;
fprintf(out,
"# /dev/%s:\n"
"text: %s\n"
"bytes/sector: %d\n"
"sectors/cylinder: %ju\n",
disk,
sl->sl_text,
sectorsize,
secpercyl);
if (eflag)
fprintf(out,
"# max sectors/unit (including alt cylinders): %ju\n",
(uintmax_t)mediasize / sectorsize);
fprintf(out,
"sectors/unit: %ju\n",
secpercyl * sl->sl_ncylinders);
if (havevtoc && sl->sl_vtoc_volname[0] != '\0') {
for (i = j = 0; i < SUN_VOLNAME_LEN; i++) {
if (sl->sl_vtoc_volname[i] == '\0')
break;
if (isprint(sl->sl_vtoc_volname[i]))
volname[j++] = sl->sl_vtoc_volname[i];
else
j += sprintf(volname + j, "\\x%02X",
sl->sl_vtoc_volname[i]);
}
volname[j] = '\0';
fprintf(out, "volume name: %s\n", volname);
}
fprintf(out,
"\n"
"%d partitions:\n"
"#\n",
SUN_NPART);
if (!hflag) {
fprintf(out, "# Size is in %s.", cflag? "cylinders": "sectors");
if (eflag)
fprintf(out,
" Use %%d%c, %%dK, %%dM or %%dG to specify in %s,\n"
"# kilobytes, megabytes or gigabytes respectively, or '*' to specify rest of\n"
"# disk.\n",
cflag? 's': 'c',
cflag? "sectors": "cylinders");
else
putc('\n', out);
fprintf(out, "# Offset is in cylinders.");
if (eflag)
fprintf(out,
" Use '*' to calculate offsets automatically.\n"
"#\n");
else
putc('\n', out);
}
if (havevtoc)
fprintf(out,
"# size offset tag flag\n"
"# ---------- ---------- ---------- ----\n"
);
else
fprintf(out,
"# size offset\n"
"# ---------- ----------\n"
);
for (i = 0; i < SUN_NPART; i++) {
if (sl->sl_part[i].sdkp_nsectors == 0)
continue;
if (hflag) {
fprintf(out, " %c: %10s",
'a' + i,
make_h_number((uintmax_t)
sl->sl_part[i].sdkp_nsectors * 512));
fprintf(out, " %10s",
make_h_number((uintmax_t)
sl->sl_part[i].sdkp_cyloffset * 512
* secpercyl));
} else {
fprintf(out, " %c: %10ju %10u",
'a' + i,
sl->sl_part[i].sdkp_nsectors / (cflag? secpercyl: 1),
sl->sl_part[i].sdkp_cyloffset);
}
if (havevtoc)
fprintf(out, " %11s %5s",
tagname(sl->sl_vtoc_map[i].svtoc_tag),
flagname(sl->sl_vtoc_map[i].svtoc_flag));
putc('\n', out);
}
}
//--------------------------------------------------------
void ModbusControlRfqAndBuncherClass::write_class_property()
{
// First time, check if database used
if (Tango::Util::_UseDb == false)
return;
Tango::DbData data;
string classname = get_name();
string header;
string::size_type start, end;
// Put title
Tango::DbDatum title("ProjectTitle");
string str_title("Control panel for modbus-tcp communication with PLC (DELTA-DVP28SR11R)");
title << str_title;
data.push_back(title);
// Put Description
Tango::DbDatum description("Description");
vector<string> str_desc;
str_desc.push_back("Control panel for modbus-tcp communication with PLC (DELTA-DVP28SR11R)");
str_desc.push_back("This device server read registers and read/write flags from PLC.");
description << str_desc;
data.push_back(description);
// put cvs or svn location
string filename("ModbusControlRfqAndBuncher");
filename += "Class.cpp";
// check for cvs information
string src_path(CvsPath);
start = src_path.find("/");
if (start!=string::npos)
{
end = src_path.find(filename);
if (end>start)
{
string strloc = src_path.substr(start, end-start);
// Check if specific repository
start = strloc.find("/cvsroot/");
if (start!=string::npos && start>0)
{
string repository = strloc.substr(0, start);
if (repository.find("/segfs/")!=string::npos)
strloc = "ESRF:" + strloc.substr(start, strloc.length()-start);
}
Tango::DbDatum cvs_loc("cvs_location");
cvs_loc << strloc;
data.push_back(cvs_loc);
}
}
// check for svn information
else
{
string src_path(SvnPath);
start = src_path.find("://");
if (start!=string::npos)
{
end = src_path.find(filename);
if (end>start)
{
header = "$HeadURL: ";
start = header.length();
string strloc = src_path.substr(start, (end-start));
Tango::DbDatum svn_loc("svn_location");
svn_loc << strloc;
data.push_back(svn_loc);
}
}
}
// Get CVS or SVN revision tag
// CVS tag
string tagname(TagName);
header = "$Name: ";
start = header.length();
string endstr(" $");
end = tagname.find(endstr);
if (end!=string::npos && end>start)
{
string strtag = tagname.substr(start, end-start);
Tango::DbDatum cvs_tag("cvs_tag");
cvs_tag << strtag;
data.push_back(cvs_tag);
}
// SVN tag
string svnpath(SvnPath);
header = "$HeadURL: ";
start = header.length();
end = svnpath.find(endstr);
if (end!=string::npos && end>start)
{
string strloc = svnpath.substr(start, end-start);
string tagstr ("/tags/");
start = strloc.find(tagstr);
if ( start!=string::npos )
{
start = start + tagstr.length();
end = strloc.find(filename);
string strtag = strloc.substr(start, end-start-1);
Tango::DbDatum svn_tag("svn_tag");
svn_tag << strtag;
data.push_back(svn_tag);
}
}
// Get URL location
string httpServ(HttpServer);
if (httpServ.length()>0)
{
Tango::DbDatum db_doc_url("doc_url");
db_doc_url << httpServ;
data.push_back(db_doc_url);
}
// Put inheritance
Tango::DbDatum inher_datum("InheritedFrom");
vector<string> inheritance;
inheritance.push_back("TANGO_BASE_CLASS");
inher_datum << inheritance;
data.push_back(inher_datum);
// Call database and and values
get_db_class()->put_property(data);
}
// parses the contents of the current node
bool Parser::parseNode(Node& node, ContextPtr& context)
{
node.mContext = context;
bool handle = context->hasEventHandler();
++mTokenizer;
Token token1 = *mTokenizer;
if (token1.isEndOfStream())
{
return false;
}
Token token2;
// loop when we encounter a comment
bool again;
do
{
again = false;
// check if we have cdata
if (!token1.isLiteral())
{
std::string cdataname("cdata");
node.mNodeNameHandle = context->insertTagname(cdataname);
#ifdef CPPDOM_DEBUG
node.mNodeName_debug = cdataname;
#endif
// parse cdata section(s) and return
node.mNodeType = Node::xml_nt_cdata;
node.mCdata.empty();
while(!token1.isLiteral())
{
node.mCdata += token1.getGeneric();
++mTokenizer;
token1 = *mTokenizer;
}
mTokenizer.putBack();
// Clean up the cdata escaping
if(textContainsXmlEscaping(node.mCdata))
{ node.mCdata = removeXmlEscaping(node.mCdata, true); }
if (handle)
{
context->getEventHandler().gotCdata( node.mCdata );
}
return true;
}
// no cdata, try to continue parsing node content
// Must be a start of a node (ie. < literal)
if (token1 != '<')
{
throw CPPDOM_ERROR(xml_opentag_cdata_expected, "");
}
// get node name
++mTokenizer;
token2 = *mTokenizer;
if (token2.isLiteral())
{
// check the following literal
switch(token2.getLiteral())
{
// closing '</...>' follows
case '/':
// return, we have a closing node with no more content
mTokenizer.putBack();
mTokenizer.putBack(token1);
return false;
// comment follows
case '!':
{
// Consume the -- part of the comment opening string.
++mTokenizer;
// needed to correctly handle <!---->
Token temp_token(mTokenizer->getGeneric().substr(2));
mTokenizer.putBack(temp_token);
this->parseComment(context);
// get next token
++mTokenizer;
token1 = *mTokenizer;
// parse again, until we encounter some useful data
again = true;
}
break;
default:
throw CPPDOM_ERROR(xml_tagname_expected, "");
}
}
} while (again);
// insert tag name and set handle for it
std::string tagname(token2.getGeneric());
node.mNodeNameHandle = context->insertTagname(tagname);
#ifdef CPPDOM_DEBUG
node.mNodeName_debug = tagname;
#endif
// notify event handler
if (handle)
{
context->getEventHandler().startNode(tagname);
}
// parse attributes
this->parseAttributes(node.attrib());
if (handle)
{
context->getEventHandler().parsedAttributes(node.attrib());
}
// check for leaf
++mTokenizer;
Token token3 = *mTokenizer;
if (token3 == '/' )
{
// node has finished
++mTokenizer;
Token token4 = *mTokenizer;
if (token4 != '>' )
{
throw CPPDOM_ERROR(xml_closetag_expected, "");
}
node.mNodeType = Node::xml_nt_leaf;
// return, let the caller continue to parse
return true;
}
// now a closing bracket must follow
if (token3 != '>')
{
throw CPPDOM_ERROR(xml_closetag_expected, "");
}
// loop to parse all subnodes
while (true)
{
// create subnode
NodePtr new_subnode(new Node(context));
// try to parse possible sub nodes
if (this->parseNode(*new_subnode, context))
{
// if successful, put node into nodelist
// NodePtr nodeptr( new Node(subnode) );
node.addChild(new_subnode);
}
else
{
break;
}
}
// parse end tag
Token token5 = *mTokenizer++;
++mTokenizer;
if (token5 != '<' && *mTokenizer != '/')
{
throw CPPDOM_ERROR(xml_opentag_expected, "");
}
++mTokenizer;
token1 = *mTokenizer;
if (token1.isLiteral())
{
throw CPPDOM_ERROR(xml_tagname_expected, "");
}
// check if open and close tag names are identical
if (token1.getGeneric() != token2.getGeneric())
{
throw CPPDOM_ERROR(xml_tagname_close_mismatch, "");
}
++mTokenizer;
if (*mTokenizer != '>')
{
throw CPPDOM_ERROR(xml_opentag_expected, "");
}
if (handle)
{
context->getEventHandler().endNode(node);
}
return true;
}
void startArray()
{
const char *curname = tagname();
setIsArray();
}
int cli_scanswf(cli_ctx *ctx)
{
struct swf_file_hdr file_hdr;
fmap_t *map = *ctx->fmap;
unsigned int bitpos, bitbuf, getbits_n, nbits, getword_1, getword_2, getdword_1, getdword_2;
const char *pt;
unsigned char get_c;
size_t offset = 0;
unsigned int val, foo, tag_hdr, tag_type, tag_len;
unsigned long int bits;
cli_dbgmsg("in cli_scanswf()\n");
if(fmap_readn(map, &file_hdr, offset, sizeof(file_hdr)) != sizeof(file_hdr)) {
cli_dbgmsg("SWF: Can't read file header\n");
return CL_CLEAN;
}
offset += sizeof(file_hdr);
if(!strncmp(file_hdr.signature, "CWS", 3)) {
cli_dbgmsg("SWF: zlib compressed file\n");
return scancws(ctx, &file_hdr);
} else if(!strncmp(file_hdr.signature, "ZWS", 3)) {
cli_dbgmsg("SWF: LZMA compressed file\n");
return scanzws(ctx, &file_hdr);
} else if(!strncmp(file_hdr.signature, "FWS", 3)) {
cli_dbgmsg("SWF: Uncompressed file\n");
} else {
cli_dbgmsg("SWF: Not a SWF file\n");
return CL_CLEAN;
}
cli_dbgmsg("SWF: Version: %u\n", file_hdr.version);
cli_dbgmsg("SWF: File size: %u\n", EC32(file_hdr.filesize));
INITBITS;
GETBITS(nbits, 5);
cli_dbgmsg("SWF: FrameSize RECT size bits: %u\n", nbits);
{
uint32_t xMin = 0, xMax = 0, yMin = 0, yMax = 0;
GETBITS(xMin, nbits); /* Should be zero */
GETBITS(xMax, nbits);
GETBITS(yMin, nbits); /* Should be zero */
GETBITS(yMax, nbits);
cli_dbgmsg("SWF: FrameSize xMin %u xMax %u yMin %u yMax %u\n", xMin, xMax, yMin, yMax);
}
GETWORD(foo);
GETWORD(val);
cli_dbgmsg("SWF: Frames total: %d\n", val);
/* Skip Flash tag walk unless debug mode */
if(!cli_debug_flag) {
return CL_CLEAN;
}
while(offset < map->len) {
GETWORD(tag_hdr);
tag_type = tag_hdr >> 6;
if(tag_type == 0)
break;
tag_len = tag_hdr & 0x3f;
if(tag_len == 0x3f)
GETDWORD(tag_len);
pt = tagname(tag_type);
cli_dbgmsg("SWF: %s\n", pt ? pt : "UNKNOWN TAG");
cli_dbgmsg("SWF: Tag length: %u\n", tag_len);
if (tag_len > map->len) {
cli_dbgmsg("SWF: Invalid tag length.\n");
return CL_EFORMAT;
}
if ((offset + tag_len) < offset) {
cli_warnmsg("SWF: Tag length too large.\n");
break;
}
if(!pt) {
offset += tag_len;
continue;
}
switch(tag_type) {
case TAG_SCRIPTLIMITS: {
unsigned int recursion, timeout;
GETWORD(recursion);
GETWORD(timeout);
cli_dbgmsg("SWF: scriptLimits recursion %u timeout %u\n", recursion, timeout);
break;
}
case TAG_FILEATTRIBUTES:
GETDWORD(val);
cli_dbgmsg("SWF: File attributes:\n");
if(val & SWF_ATTR_USENETWORK)
cli_dbgmsg(" * Use network\n");
if(val & SWF_ATTR_RELATIVEURLS)
cli_dbgmsg(" * Relative URLs\n");
if(val & SWF_ATTR_SUPPRESSCROSSDOMAINCACHE)
cli_dbgmsg(" * Suppress cross domain cache\n");
if(val & SWF_ATTR_ACTIONSCRIPT3)
cli_dbgmsg(" * ActionScript 3.0\n");
if(val & SWF_ATTR_HASMETADATA)
cli_dbgmsg(" * Has metadata\n");
if(val & SWF_ATTR_USEDIRECTBLIT)
cli_dbgmsg(" * Use hardware acceleration\n");
if(val & SWF_ATTR_USEGPU)
cli_dbgmsg(" * Use GPU\n");
break;
default:
offset += tag_len;
continue;
}
}
return CL_CLEAN;
}
//--------------------------------------------------------
void WebSocketDSClass::write_class_property()
{
// First time, check if database used
if (Tango::Util::_UseDb == false)
return;
Tango::DbData data;
string classname = get_name();
string header;
string::size_type start, end;
// Put title
Tango::DbDatum title("ProjectTitle");
string str_title("WebSocket access to tango device-server attributes, pipes and commands");
title << str_title;
data.push_back(title);
// Put Description
Tango::DbDatum description("Description");
vector<string> str_desc;
str_desc.push_back("WebSocket access to tango device-server attributes.");
str_desc.push_back("");
str_desc.push_back("Configuration should be done via properties:");
str_desc.push_back("");
str_desc.push_back("Port - port to listen incoming ws connections;");
str_desc.push_back("DeviceServer - tango id of a required device server;");
str_desc.push_back("Attributes - list of required DS attributes, you wish to read via WS;");
str_desc.push_back("Commands - list of required DS commandes, you wish to executed via WS;");
str_desc.push_back("AuthDS - Tango web authentication device server (TangoWebAuth ) name.");
str_desc.push_back("Secure - It will be used wss connection (websocket secure). (true if you want)");
str_desc.push_back("Certificate - Certificate file name (crt) with full path (if Secure = true)");
str_desc.push_back("Key - Private key file name (if Secure = true)");
str_desc.push_back("Options - Various options for the device server");
str_desc.push_back("");
str_desc.push_back("Then you should set polling to the UpdateData command. (1000 means that all connected clients would read attributes once per second).");
str_desc.push_back("");
str_desc.push_back("Data format: JSON string with array of attrubute objects {atrrtibute name, attribute value, quality, timestamp};");
str_desc.push_back("");
str_desc.push_back("if you want to record in the logs, define uselog in Property ``Options``.");
str_desc.push_back("The database (defined in AuthDS) must contain a table `command_history` with columns:");
str_desc.push_back(" // id - autoincrement");
str_desc.push_back(" // argin[0] = timestamp_string UNIX_TIMESTAMP");
str_desc.push_back(" // argin[1] = login");
str_desc.push_back(" // argin[2] = deviceName");
str_desc.push_back(" // argin[3] = IP");
str_desc.push_back(" // argin[4] = commandName");
str_desc.push_back(" // argin[5] = commandJson");
str_desc.push_back(" // argin[6] = statusBool");
str_desc.push_back(" // argin[7] = isGroup");
description << str_desc;
data.push_back(description);
// put cvs or svn location
string filename("WebSocketDS");
filename += "Class.cpp";
// check for cvs information
string src_path(CvsPath);
start = src_path.find("/");
if (start!=string::npos)
{
end = src_path.find(filename);
if (end>start)
{
string strloc = src_path.substr(start, end-start);
// Check if specific repository
start = strloc.find("/cvsroot/");
if (start!=string::npos && start>0)
{
string repository = strloc.substr(0, start);
if (repository.find("/segfs/")!=string::npos)
strloc = "ESRF:" + strloc.substr(start, strloc.length()-start);
}
Tango::DbDatum cvs_loc("cvs_location");
cvs_loc << strloc;
data.push_back(cvs_loc);
}
}
// check for svn information
else
{
string src_path(SvnPath);
start = src_path.find("://");
if (start!=string::npos)
{
end = src_path.find(filename);
if (end>start)
{
header = "$HeadURL: ";
start = header.length();
string strloc = src_path.substr(start, (end-start));
Tango::DbDatum svn_loc("svn_location");
svn_loc << strloc;
data.push_back(svn_loc);
}
}
}
// Get CVS or SVN revision tag
// CVS tag
string tagname(TagName);
header = "$Name: ";
start = header.length();
string endstr(" $");
end = tagname.find(endstr);
if (end!=string::npos && end>start)
{
string strtag = tagname.substr(start, end-start);
Tango::DbDatum cvs_tag("cvs_tag");
cvs_tag << strtag;
data.push_back(cvs_tag);
}
// SVN tag
string svnpath(SvnPath);
header = "$HeadURL: ";
start = header.length();
end = svnpath.find(endstr);
if (end!=string::npos && end>start)
{
string strloc = svnpath.substr(start, end-start);
string tagstr ("/tags/");
start = strloc.find(tagstr);
if ( start!=string::npos )
{
start = start + tagstr.length();
end = strloc.find(filename);
string strtag = strloc.substr(start, end-start-1);
Tango::DbDatum svn_tag("svn_tag");
svn_tag << strtag;
data.push_back(svn_tag);
}
}
// Get URL location
string httpServ(HttpServer);
if (httpServ.length()>0)
{
Tango::DbDatum db_doc_url("doc_url");
db_doc_url << httpServ;
data.push_back(db_doc_url);
}
// Put inheritance
Tango::DbDatum inher_datum("InheritedFrom");
vector<string> inheritance;
inheritance.push_back("TANGO_BASE_CLASS");
inher_datum << inheritance;
data.push_back(inher_datum);
// Call database and and values
get_db_class()->put_property(data);
}
//+----------------------------------------------------------------------------
//
// method : GalilSlitClass::write_class_property
//
// description : Set class description as property in database
//
//-----------------------------------------------------------------------------
void GalilSlitClass::write_class_property()
{
// First time, check if database used
//--------------------------------------------
if (Tango::Util::_UseDb == false)
return;
Tango::DbData data;
string classname = get_name();
string header;
string::size_type start, end;
// Put title
Tango::DbDatum title("ProjectTitle");
string str_title("GalilSlit");
title << str_title;
data.push_back(title);
// Put Description
Tango::DbDatum description("Description");
vector<string> str_desc;
str_desc.push_back("handles generic slits");
str_desc.push_back("type independant blades");
str_desc.push_back("type 1 motor for gap plus 1 motor for translation");
str_desc.push_back("ETC");
description << str_desc;
data.push_back(description);
// put cvs location
string rcsId(RcsId);
string filename(classname);
start = rcsId.find("/");
if (start!=string::npos)
{
filename += "Class.cpp";
end = rcsId.find(filename);
if (end>start)
{
string strloc = rcsId.substr(start, end-start);
// Check if specific repository
start = strloc.find("/cvsroot/");
if (start!=string::npos && start>0)
{
string repository = strloc.substr(0, start);
if (repository.find("/segfs/")!=string::npos)
strloc = "ESRF:" + strloc.substr(start, strloc.length()-start);
}
Tango::DbDatum cvs_loc("cvs_location");
cvs_loc << strloc;
data.push_back(cvs_loc);
}
}
// Get CVS tag revision
string tagname(TagName);
header = "$Name: ";
start = header.length();
string endstr(" $");
end = tagname.find(endstr);
if (end!=string::npos && end>start)
{
string strtag = tagname.substr(start, end-start);
Tango::DbDatum cvs_tag("cvs_tag");
cvs_tag << strtag;
data.push_back(cvs_tag);
}
// Get URL location
string httpServ(HttpServer);
if (httpServ.length()>0)
{
Tango::DbDatum db_doc_url("doc_url");
db_doc_url << httpServ;
data.push_back(db_doc_url);
}
// Put inheritance
Tango::DbDatum inher_datum("InheritedFrom");
vector<string> inheritance;
inheritance.push_back("Device_4Impl");
inher_datum << inheritance;
data.push_back(inher_datum);
// Call database and and values
//--------------------------------------------
get_db_class()->put_property(data);
}
void setValueBool(bool val){xml.appendf("<%s>%s</%s>", tagname(), val ? "true" : "false", tagname()); if (!isArray()) pop();}
void setValueStr(const char *val){xml.appendf("<%s>%s</%s>", tagname(), val, tagname()); if (!isArray()) pop();}
void endArray()
{
const char *curname = tagname();
pop();
}
//+----------------------------------------------------------------------------
//
// method : SimulatorCCDClass::write_class_property
//
// description : Set class description as property in database
//
//-----------------------------------------------------------------------------
void SimulatorCCDClass::write_class_property()
{
// First time, check if database used
//--------------------------------------------
if (Tango::Util::_UseDb == false)
return;
Tango::DbData data;
string classname = get_name();
string header;
string::size_type start, end;
// Put title
Tango::DbDatum title("ProjectTitle");
string str_title("");
title << str_title;
data.push_back(title);
// Put Description
Tango::DbDatum description("Description");
vector<string> str_desc;
str_desc.push_back(" ");
description << str_desc;
data.push_back(description);
// put cvs or svn location
string filename(classname);
filename += "Class.cpp";
// Create a string with the class ID to
// get the string into the binary
string class_id(ClassId);
// check for cvs information
string src_path(CvsPath);
start = src_path.find("/");
if (start!=string::npos)
{
end = src_path.find(filename);
if (end>start)
{
string strloc = src_path.substr(start, end-start);
// Check if specific repository
start = strloc.find("/cvsroot/");
if (start!=string::npos && start>0)
{
string repository = strloc.substr(0, start);
if (repository.find("/segfs/")!=string::npos)
strloc = "ESRF:" + strloc.substr(start, strloc.length()-start);
}
Tango::DbDatum cvs_loc("cvs_location");
cvs_loc << strloc;
data.push_back(cvs_loc);
}
}
// check for svn information
else
{
string src_path(SvnPath);
start = src_path.find("://");
if (start!=string::npos)
{
end = src_path.find(filename);
if (end>start)
{
header = "$HeadURL: ";
start = header.length();
string strloc = src_path.substr(start, (end-start));
Tango::DbDatum svn_loc("svn_location");
svn_loc << strloc;
data.push_back(svn_loc);
}
}
}
// Get CVS or SVN revision tag
// CVS tag
string tagname(TagName);
header = "$Name: ";
start = header.length();
string endstr(" $");
end = tagname.find(endstr);
if (end!=string::npos && end>start)
{
string strtag = tagname.substr(start, end-start);
Tango::DbDatum cvs_tag("cvs_tag");
cvs_tag << strtag;
data.push_back(cvs_tag);
}
// SVN tag
string svnpath(SvnPath);
header = "$HeadURL: ";
start = header.length();
end = svnpath.find(endstr);
if (end!=string::npos && end>start)
{
string strloc = svnpath.substr(start, end-start);
string tagstr ("/tags/");
start = strloc.find(tagstr);
if ( start!=string::npos )
{
start = start + tagstr.length();
end = strloc.find(filename);
string strtag = strloc.substr(start, end-start-1);
Tango::DbDatum svn_tag("svn_tag");
svn_tag << strtag;
data.push_back(svn_tag);
}
}
// Get URL location
string httpServ(HttpServer);
if (httpServ.length()>0)
{
Tango::DbDatum db_doc_url("doc_url");
db_doc_url << httpServ;
data.push_back(db_doc_url);
}
// Put inheritance
Tango::DbDatum inher_datum("InheritedFrom");
vector<string> inheritance;
inheritance.push_back("Device_4Impl");
inher_datum << inheritance;
data.push_back(inher_datum);
// Call database and and values
//--------------------------------------------
get_db_class()->put_property(data);
}
void setValueDouble(double val){xml.appendf("<%s>%f</%s>", tagname(), val, tagname()); if (!isArray()) pop();}
void setNULL(){xml.appendf("<%s></%s>", tagname(), tagname()); if (!isArray()) pop();}
static void dump_blob(void *blob, bool debug)
{
uintptr_t blob_off = (uintptr_t)blob;
struct fdt_header *bph = blob;
uint32_t off_mem_rsvmap = fdt32_to_cpu(bph->off_mem_rsvmap);
uint32_t off_dt = fdt32_to_cpu(bph->off_dt_struct);
uint32_t off_str = fdt32_to_cpu(bph->off_dt_strings);
struct fdt_reserve_entry *p_rsvmap =
(struct fdt_reserve_entry *)((char *)blob + off_mem_rsvmap);
const char *p_struct = (const char *)blob + off_dt;
/* Get offset to the strings */
const char *p_strings = (const char *)blob + off_str;
uint32_t version = fdt32_to_cpu(bph->version);
uint32_t totalsize = fdt32_to_cpu(bph->totalsize);
uint32_t tag;
const char *p, *s, *t;
int depth, sz, shift;
int i;
uint64_t addr, size;
char *buffer;
buffer = (char *)malloc(MAX_LEN);
depth = 0;
shift = 4;
uint32_t off_total_size = fdt32_to_cpu(bph->totalsize);
/* TODO: Remove this additional info. Do I need it? */
dprintf(buffer, "totalsize: %d\n", off_total_size);
dprintf(buffer, "// magic:\t\t0x%x\n", fdt32_to_cpu(bph->magic));
dprintf(buffer, "// totalsize:\t\t0x%x (%d)\n", totalsize, totalsize);
dprintf(buffer, "// off_dt_struct:\t0x%x\n", off_dt);
dprintf(buffer, "// off_dt_strings:\t0x%x\n", off_str);
dprintf(buffer, "// off_mem_rsvmap:\t0x%x\n", off_mem_rsvmap);
dprintf(buffer, "// version:\t\t%d\n", version);
dprintf(buffer, "// last_comp_version:\t%d\n",
fdt32_to_cpu(bph->last_comp_version));
if (version >= 2)
dprintf(buffer, "// boot_cpuid_phys:\t0x%x\n",
fdt32_to_cpu(bph->boot_cpuid_phys));
if (version >= 3)
dprintf(buffer, "// size_dt_strings:\t0x%x\n",
fdt32_to_cpu(bph->size_dt_strings));
if (version >= 17)
dprintf(buffer, "// size_dt_struct:\t0x%x\n",
fdt32_to_cpu(bph->size_dt_struct));
dprintf(buffer, "\n");
for (i = 0; ; i++) {
addr = fdt64_to_cpu(p_rsvmap[i].address);
size = fdt64_to_cpu(p_rsvmap[i].size);
if (addr == 0 && size == 0)
break;
dprintf(buffer, "/memreserve/ %#llx %#llx;\n",
(unsigned long long)addr, (unsigned long long)size);
}
p = p_struct;
while ((tag = fdt32_to_cpu(GET_CELL(p))) != FDT_END) {
dumpf("%04zx: tag: 0x%08x (%s)\n",
(uintptr_t)p - blob_off - 4, tag, tagname(tag));
if (tag == FDT_BEGIN_NODE) {
s = p;
p = PALIGN(p + strlen(s) + 1, 4);
if (*s == '\0')
s = "/";
dprintf(buffer, "%*s%s {\n", depth * shift, "", s);
depth++;
continue;
}
if (tag == FDT_END_NODE) {
depth--;
dprintf(buffer, "%*s};\n", depth * shift, "");
continue;
}
if (tag == FDT_NOP) {
dprintf(buffer, "%*s// [NOP]\n", depth * shift, "");
continue;
}
if (tag != FDT_PROP) {
fprintf(stderr, "%*s ** Unknown tag 0x%08x\n", depth * shift, "", tag);
break;
}
/* sz - length of the returned values in bytes */
sz = fdt32_to_cpu(GET_CELL(p));
/* s - pointer to the property name */
s = p_strings + fdt32_to_cpu(GET_CELL(p));
if (version < 16 && sz >= 8)
p = PALIGN(p, 8);
t = p;
p = PALIGN(p + sz, 4);
dumpf("%04zx: string: %s\n", (uintptr_t)s - blob_off, s);
dumpf("%04zx: value\n", (uintptr_t)t - blob_off);
dprintf(buffer, "%*s%s", depth * shift, "", s);
my_utilfdt_print_data(t, sz, buffer);
dprintf(buffer, ";\n");
}
printf("%s", buffer);
}
