Michael Davidsaver
1040 lines
29 KiB
C++
1040 lines
29 KiB
C++
/**
|
|
* Copyright - See the COPYRIGHT that is included with this distribution.
|
|
* pvxs is distributed subject to a Software License Agreement found
|
|
* in file LICENSE that is included with this distribution.
|
|
*/
|
|
|
|
#include <cstring>
|
|
#include <epicsAssert.h>
|
|
|
|
#include <epicsStdlib.h>
|
|
|
|
#include "dataimpl.h"
|
|
#include "utilpvt.h"
|
|
|
|
namespace pvxs {
|
|
|
|
bool TypeCode::valid() const
|
|
{
|
|
if((code&0x10) && code!=Null)
|
|
return false; // fixed size not supported
|
|
switch(scalarOf().code) {
|
|
#define CASE(CASE, LBL) case CASE:
|
|
CASE(Bool, "bool");
|
|
CASE(Int8, "int8_t");
|
|
CASE(Int16, "int16_t");
|
|
CASE(Int32, "int32_t");
|
|
CASE(Int64, "int64_t");
|
|
CASE(UInt8, "uint8_t");
|
|
CASE(UInt16, "uint16_t");
|
|
CASE(UInt32, "uint32_t");
|
|
CASE(UInt64, "uint64_t");
|
|
CASE(Float32,"float");
|
|
CASE(Float64,"double");
|
|
CASE(String, "string");
|
|
CASE(Any, "any");
|
|
CASE(Union, "union");
|
|
CASE(Struct, "struct");
|
|
CASE(Null, "null");
|
|
#undef CASE
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const char* TypeCode::name() const
|
|
{
|
|
switch(code) {
|
|
#define CASE(CASE, LBL) case TypeCode::CASE: return LBL
|
|
CASE(Bool, "bool");
|
|
CASE(Int8, "int8_t");
|
|
CASE(Int16, "int16_t");
|
|
CASE(Int32, "int32_t");
|
|
CASE(Int64, "int64_t");
|
|
CASE(UInt8, "uint8_t");
|
|
CASE(UInt16, "uint16_t");
|
|
CASE(UInt32, "uint32_t");
|
|
CASE(UInt64, "uint64_t");
|
|
CASE(Float32,"float");
|
|
CASE(Float64,"double");
|
|
CASE(String, "string");
|
|
CASE(Any, "any");
|
|
CASE(Union, "union");
|
|
CASE(Struct, "struct");
|
|
CASE(Null, "null");
|
|
#undef CASE
|
|
#define CASE(CASE, LBL) case TypeCode::CASE##A: return LBL "[]"
|
|
CASE(Bool, "bool");
|
|
CASE(Int8, "int8_t");
|
|
CASE(Int16, "int16_t");
|
|
CASE(Int32, "int32_t");
|
|
CASE(Int64, "int64_t");
|
|
CASE(UInt8, "uint8_t");
|
|
CASE(UInt16, "uint16_t");
|
|
CASE(UInt32, "uint32_t");
|
|
CASE(UInt64, "uint64_t");
|
|
CASE(Float32,"float");
|
|
CASE(Float64,"double");
|
|
CASE(String, "string");
|
|
CASE(Any, "any");
|
|
CASE(Union, "union");
|
|
CASE(Struct, "struct");
|
|
#undef CASE
|
|
}
|
|
return "\?\?\?_t";
|
|
}
|
|
|
|
struct TypeDef::Node {
|
|
Node * const parent;
|
|
std::string id;
|
|
TypeCode code;
|
|
std::vector<std::pair<std::string, decltype (TypeDef::root)>> children;
|
|
explicit Node(Node *parent) :parent(parent) {}
|
|
Node(Node* parent, const char *id, TypeCode code) :parent(parent), id(id?id:""), code(code) {}
|
|
|
|
decltype (TypeDef::root) clone(Node *new_parent) const {
|
|
decltype (TypeDef::root) ret{new Node(new_parent, id.c_str(), code)};
|
|
ret->children.reserve(children.size());
|
|
for(auto& pair : children) {
|
|
ret->children.emplace_back(pair.first, pair.second->clone(ret.get()));
|
|
}
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
void TypeDef::NodeDeletor::operator()(Node *p)
|
|
{
|
|
delete p;
|
|
}
|
|
|
|
static
|
|
void node_validate(const TypeDef::Node* parent, const char *id, TypeCode code)
|
|
{
|
|
if(id && code!=TypeCode::Struct && code!=TypeCode::Union)
|
|
throw std::runtime_error("Only Struct or Union may have an ID");
|
|
if(parent) {
|
|
auto c = parent->code.scalarOf();
|
|
if(c!=TypeCode::Struct && c!=TypeCode::Union)
|
|
throw std::runtime_error("Only (array of) Struct or Union may have members");
|
|
}
|
|
}
|
|
|
|
static
|
|
void name_validate(const char *name)
|
|
{
|
|
// [a-zA-Z_][a-zA-Z0-9_]*
|
|
|
|
if(!name || name[0]=='\0')
|
|
throw std::runtime_error("empty field name not allowed");
|
|
for(size_t i=0; name[i]; i++) {
|
|
char c = name[i];
|
|
if(c>='0' && c<='9' && i>0) {
|
|
// number ok after first
|
|
} else if((c>='a' && c<='z') || (c>='A' && c<='Z')) {
|
|
// alphas ok
|
|
} else {
|
|
switch(c) {
|
|
case '_':
|
|
break;
|
|
default:
|
|
throw std::runtime_error(SB()<<"invalid field name \""<<escape(name)<<"\"");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TypeDef::TypeDef(TypeCode code, const char *id)
|
|
:root{new Node(nullptr, id, code)}
|
|
{
|
|
node_validate(nullptr, id, code);
|
|
}
|
|
|
|
static
|
|
void copy_tree(const FieldDesc* desc, TypeDef::Node& node)
|
|
{
|
|
node.code = desc->code;
|
|
node.id = desc->id;
|
|
node.children.reserve(desc->miter.size());
|
|
for(auto& pair : desc->miter) {
|
|
node.children.emplace_back(pair.first,
|
|
decltype (node.children)::value_type::second_type{new TypeDef::Node(&node)});
|
|
copy_tree(desc+pair.second, *node.children.back().second);
|
|
}
|
|
}
|
|
|
|
TypeDef::TypeDef(const Value& o)
|
|
{
|
|
if(o.desc) {
|
|
root.reset(new Node(nullptr));
|
|
copy_tree(o.desc, *root);
|
|
}
|
|
}
|
|
|
|
TypeDef::~TypeDef() {}
|
|
|
|
TypeDef TypeDef::clone() const
|
|
{
|
|
TypeDef ret;
|
|
if(root) {
|
|
ret.root = root->clone(nullptr);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
TypeDef::Cursor TypeDef::begin()
|
|
{
|
|
if(!root)
|
|
throw std::runtime_error("Can't edit empty TypeDef");
|
|
Cursor ret;
|
|
ret.owner = this;
|
|
ret.reset();
|
|
return ret;
|
|
}
|
|
|
|
static
|
|
void build_tree(std::vector<FieldDesc>& desc, const TypeDef::Node& node)
|
|
{
|
|
auto code = node.code;
|
|
if(node.code==TypeCode::StructA || node.code==TypeCode::UnionA) {
|
|
|
|
desc.emplace_back();
|
|
auto& fld = desc.back();
|
|
fld.code = node.code;
|
|
// struct/union array have no ID
|
|
fld.hash = node.code.code;
|
|
code = code.scalarOf();
|
|
}
|
|
|
|
const auto index = desc.size();
|
|
desc.emplace_back();
|
|
|
|
{
|
|
auto& fld = desc.back();
|
|
fld.code = code;
|
|
fld.id = node.id;
|
|
fld.hash = code.code ^ std::hash<std::string>{}(fld.id);
|
|
}
|
|
|
|
|
|
for(auto& pair : node.children) {
|
|
const auto cindex = desc.size();
|
|
|
|
build_tree(desc, *pair.second); // recurse. may realloc desc
|
|
|
|
auto& fld = desc[index];
|
|
auto& child = desc[cindex];
|
|
|
|
fld.hash ^= std::hash<std::string>{}(pair.first) ^ child.hash;
|
|
|
|
fld.mlookup[pair.first] = cindex-index;
|
|
fld.miter.emplace_back(pair.first, cindex-index);
|
|
|
|
std::string cname = pair.first+".";
|
|
if(fld.code.code==TypeCode::Struct && fld.code==child.code) {
|
|
// propagate names from sub-struct
|
|
for(auto& cpair : child.mlookup) {
|
|
fld.mlookup[cname+cpair.first] = cindex-index+cpair.second;
|
|
}
|
|
}
|
|
}
|
|
|
|
desc[index].num_index = desc.size()-index;
|
|
|
|
if(node.code==TypeCode::StructA || node.code==TypeCode::UnionA)
|
|
{
|
|
desc[index-1].num_index = desc.size()-index+1;
|
|
}
|
|
}
|
|
|
|
Value TypeDef::create() const
|
|
{
|
|
if(!root)
|
|
throw std::logic_error("Empty TypeDef");
|
|
|
|
auto desc = std::make_shared<std::vector<FieldDesc>>();
|
|
build_tree(*desc, *root);
|
|
FieldDesc_calculate_offset(desc->data());
|
|
|
|
std::shared_ptr<const FieldDesc> type(desc, desc->data()); // alias
|
|
return Value(type);
|
|
}
|
|
|
|
TypeDef::Cursor& TypeDef::Cursor::seek(const char *name)
|
|
{
|
|
while(name && name[0]) {
|
|
auto sep = strchr(name, '.');
|
|
std::string fname;
|
|
if(sep) {
|
|
fname = std::string(name, sep-name);
|
|
name = sep+1;
|
|
} else {
|
|
fname = name;
|
|
name = nullptr;
|
|
}
|
|
|
|
for(auto i : range(parent->children.size())) {
|
|
auto& pair = parent->children[i];
|
|
if(pair.first==fname) {
|
|
auto code = pair.second->code.scalarOf();
|
|
if(code==TypeCode::Union || code==TypeCode::Struct) {
|
|
parent = pair.second.get();
|
|
index = parent->children.size();
|
|
|
|
} else if(sep) {
|
|
throw std::runtime_error("Can only seek through Struct/Union");
|
|
|
|
} else {
|
|
index = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
TypeDef::Cursor& TypeDef::Cursor::change(const char *id, TypeCode code)
|
|
{
|
|
node_validate(parent, id, code);
|
|
|
|
if(index>=parent->children.size()) {
|
|
throw std::runtime_error("Cursor does not select a field");
|
|
} else {
|
|
auto& fld = parent->children[index];
|
|
if(code.kind()!=Kind::Compound && !fld.second->children.empty())
|
|
throw std::runtime_error("May not change type of Compound field w/ sub-fields");
|
|
fld.second->id = id;
|
|
fld.second->code = code;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
TypeDef::Cursor& TypeDef::Cursor::insert(const char *name, const char *id, TypeCode code)
|
|
{
|
|
node_validate(parent, id, code);
|
|
name_validate(name);
|
|
|
|
decltype (owner->root) node{new Node(parent, id, code)};
|
|
|
|
parent->children.emplace(parent->children.begin()+index,
|
|
name, std::move(node));
|
|
index++;
|
|
return *this;
|
|
}
|
|
|
|
TypeDef::Cursor& TypeDef::Cursor::add(const char *name, const TypeDef& def)
|
|
{
|
|
name_validate(name);
|
|
|
|
if(!def.root)
|
|
throw std::runtime_error("Empty TypeDef");
|
|
|
|
node_validate(parent, def.root->id.c_str(), def.root->code);
|
|
|
|
parent->children.emplace(parent->children.begin()+index,
|
|
name, std::move(def.root->clone(parent)));
|
|
|
|
return *this;
|
|
}
|
|
|
|
TypeDef::Cursor& TypeDef::Cursor::up()
|
|
{
|
|
if(parent!=owner->root.get()) {
|
|
parent = parent->parent;
|
|
index = parent->children.size();
|
|
} else {
|
|
throw std::logic_error("Can't go up() from root");
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
TypeDef::Cursor& TypeDef::Cursor::reset()
|
|
{
|
|
parent = owner->root.get();
|
|
index = parent->children.size();
|
|
return *this;
|
|
}
|
|
|
|
static
|
|
void indent(std::ostream& strm, unsigned level) {
|
|
for(auto i : range(level)) {
|
|
(void)i;
|
|
strm<<" ";
|
|
}
|
|
}
|
|
|
|
static
|
|
void show_Node(std::ostream& strm, const std::string& name, const TypeDef::Node* node, unsigned level=0)
|
|
{
|
|
strm<<node->code;
|
|
if(!node->id.empty())
|
|
strm<<" \""<<node->id<<"\"";
|
|
if(!node->children.empty()) {
|
|
strm<<" {\n";
|
|
for(auto& pair : node->children) {
|
|
indent(strm, level+1);
|
|
show_Node(strm, pair.first, pair.second.get(), level+1);
|
|
}
|
|
indent(strm, level);
|
|
strm.put('}');
|
|
if(!name.empty())
|
|
strm<<" "<<name;
|
|
strm.put('\n');
|
|
} else {
|
|
if(!name.empty())
|
|
strm<<" "<<name;
|
|
strm<<"\n";
|
|
}
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& strm, const TypeDef& def)
|
|
{
|
|
if(!def.root) {
|
|
strm<<"<Empty>\n";
|
|
} else {
|
|
show_Node(strm, std::string(), def.root.get());
|
|
}
|
|
return strm;
|
|
}
|
|
|
|
NoConvert::NoConvert()
|
|
:std::runtime_error ("No conversion defined")
|
|
{}
|
|
|
|
NoConvert::~NoConvert() {}
|
|
|
|
Value::Value(const std::shared_ptr<const impl::FieldDesc>& desc)
|
|
:desc(nullptr)
|
|
{
|
|
if(!desc)
|
|
return;
|
|
|
|
auto top = std::make_shared<StructTop>();
|
|
|
|
top->desc = desc;
|
|
top->valid.resize(desc->next_offset-desc->offset, false);
|
|
top->members.resize(desc->next_offset-desc->offset);
|
|
{
|
|
auto& root = top->members[0];
|
|
root.init(desc.get());
|
|
root.top = top.get();
|
|
}
|
|
|
|
for(auto& pair : desc->mlookup) {
|
|
auto cfld = desc.get() + pair.second;
|
|
auto& mem = top->members.at(cfld->offset-desc->offset);
|
|
mem.top = top.get();
|
|
mem.init(cfld);
|
|
}
|
|
|
|
this->desc = desc.get();
|
|
decltype (store) val(top, top->members.data()); // alias
|
|
this->store = std::move(val);
|
|
}
|
|
|
|
Value::~Value() {}
|
|
|
|
Value Value::cloneEmpty() const
|
|
{
|
|
Value ret;
|
|
if(desc) {
|
|
decltype (store->top->desc) fld(store->top->desc, desc);
|
|
ret = Value(fld);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Value Value::clone() const
|
|
{
|
|
Value ret;
|
|
if(desc) {
|
|
decltype (store->top->desc) fld(store->top->desc, desc);
|
|
ret = Value(fld);
|
|
//ret.assign(*this);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//Value& Value::assign(const Value& o)
|
|
//{
|
|
// if(desc!=o.desc)
|
|
// throw std::runtime_error("Can only assign same TypeDef"); // TODO relax
|
|
|
|
// return *this;
|
|
//}
|
|
|
|
Value Value::allocMember() const
|
|
{
|
|
// allocate member type for Struct[] or Union[]
|
|
if(!desc || (desc->code!=TypeCode::UnionA && desc->code!=TypeCode::StructA))
|
|
throw std::runtime_error("allocMember() only meaningful for Struct[] or Union[]");
|
|
|
|
decltype (store->top->desc) fld(store->top->desc, desc+1);
|
|
return Value(fld);
|
|
}
|
|
|
|
bool Value::isMarked(bool parents, bool children) const
|
|
{
|
|
// TODO test parent and child mask
|
|
return desc ? store->top->valid[store->index()] : false;
|
|
}
|
|
|
|
void Value::mark(bool v)
|
|
{
|
|
if(desc)
|
|
store->top->valid[store->index()] = v;
|
|
}
|
|
|
|
void Value::unmark(bool parents, bool children)
|
|
{
|
|
// TODO clear parent and/or child mask
|
|
if(desc)
|
|
store->top->valid[store->index()] = false;
|
|
}
|
|
|
|
TypeCode Value::type() const
|
|
{
|
|
return desc ? desc->code : TypeCode::Null;
|
|
}
|
|
|
|
StoreType Value::storageType() const
|
|
{
|
|
return store ? store->code : StoreType::Null;
|
|
}
|
|
|
|
const std::string& Value::id() const
|
|
{
|
|
if(!desc)
|
|
throw std::runtime_error("Null Value");
|
|
return desc->id;
|
|
}
|
|
|
|
namespace {
|
|
// C-style cast between scalar storage types, and print to string (base 10)
|
|
template<typename Src>
|
|
bool copyOutScalar(const Src& src, void *ptr, StoreType type)
|
|
{
|
|
switch(type) {
|
|
case StoreType::Real: *reinterpret_cast<double*>(ptr) = src; return true;
|
|
case StoreType::Integer: *reinterpret_cast<int64_t*>(ptr) = src; return true;
|
|
case StoreType::UInteger: *reinterpret_cast<uint64_t*>(ptr) = src; return true;
|
|
case StoreType::String: *reinterpret_cast<std::string*>(ptr) = SB()<<src; return true;
|
|
case StoreType::Null:
|
|
case StoreType::Compound:
|
|
case StoreType::Array:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void Value::copyOut(void *ptr, StoreType type) const
|
|
{
|
|
if(!desc)
|
|
throw NoConvert();
|
|
|
|
switch(store->code) {
|
|
case StoreType::Real: if(copyOutScalar(store->as<double>(), ptr, type)) return; else break;
|
|
case StoreType::Integer: if(copyOutScalar(store->as<int64_t>(), ptr, type)) return; else break;
|
|
case StoreType::UInteger: if(copyOutScalar(store->as<uint64_t>(), ptr, type)) return; else break;
|
|
case StoreType::String: {
|
|
auto& src = store->as<std::string>();
|
|
|
|
switch(type) {
|
|
case StoreType::String: *reinterpret_cast<std::string*>(ptr) = src; return;
|
|
// TODO: parse Integer/Real
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case StoreType::Array: {
|
|
auto& src = store->as<shared_array<const void>>();
|
|
switch (type) {
|
|
case StoreType::Array: *reinterpret_cast<shared_array<const void>*>(ptr) = src; return;
|
|
// TODO: print array
|
|
// extract [0] as scalar?
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case StoreType::Compound: {
|
|
auto& src = store->as<Value>();
|
|
if(type==StoreType::Compound) {
|
|
// extract Value
|
|
*reinterpret_cast<Value*>(ptr) = src;
|
|
return;
|
|
|
|
} else if(src) {
|
|
// automagic deref and delegate assign
|
|
src.copyOut(ptr, type);
|
|
return;
|
|
|
|
} else {
|
|
throw NoConvert();
|
|
}
|
|
|
|
break;
|
|
}
|
|
case StoreType::Null:
|
|
break;
|
|
}
|
|
|
|
throw NoConvert();
|
|
}
|
|
|
|
namespace {
|
|
// C-style cast between scalar storage types, and print to string (base 10)
|
|
template<typename Dest>
|
|
bool copyInScalar(Dest& dest, const void *ptr, StoreType type)
|
|
{
|
|
switch(type) {
|
|
case StoreType::Real: dest = *reinterpret_cast<const double*>(ptr); return true;
|
|
case StoreType::Integer: dest = *reinterpret_cast<const int64_t*>(ptr); return true;
|
|
case StoreType::UInteger: dest = *reinterpret_cast<const uint64_t*>(ptr); return true;
|
|
case StoreType::String: // TODO: parse from string
|
|
case StoreType::Null:
|
|
case StoreType::Compound:
|
|
case StoreType::Array:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void Value::copyIn(const void *ptr, StoreType type)
|
|
{
|
|
if(!desc)
|
|
throw NoConvert();
|
|
|
|
switch(store->code) {
|
|
case StoreType::Real: if(!copyInScalar(store->as<double>(), ptr, type)) throw NoConvert(); break;
|
|
case StoreType::Integer: if(!copyInScalar(store->as<int64_t>(), ptr, type)) throw NoConvert(); break;
|
|
case StoreType::UInteger: if(!copyInScalar(store->as<uint64_t>(), ptr, type)) throw NoConvert(); break;
|
|
case StoreType::String: {
|
|
auto& dest = store->as<std::string>();
|
|
|
|
switch(type) {
|
|
case StoreType::String: dest = *reinterpret_cast<const std::string*>(ptr); break;
|
|
case StoreType::Integer: dest = SB()<<*reinterpret_cast<const int64_t*>(ptr); break;
|
|
case StoreType::UInteger: dest = SB()<<*reinterpret_cast<const uint64_t*>(ptr); break;
|
|
case StoreType::Real: dest = SB()<<*reinterpret_cast<const double*>(ptr); break;
|
|
default:
|
|
throw NoConvert();
|
|
}
|
|
break;
|
|
}
|
|
case StoreType::Array: {
|
|
auto& dest = store->as<shared_array<const void>>();
|
|
switch (type) {
|
|
case StoreType::Array: {
|
|
auto& src = *reinterpret_cast<const shared_array<const void>*>(ptr);
|
|
if(src.original_type()==ArrayType::Null || src.empty()) {
|
|
// assignment from untyped or empty
|
|
dest.clear();
|
|
|
|
} else if(src.original_type()==ArrayType::Value && desc->code.kind()==Kind::Compound) {
|
|
// assign array of Struct/Union/Any
|
|
auto tsrc = shared_array_static_cast<const Value>(src);
|
|
|
|
if(desc->code!=TypeCode::AnyA) {
|
|
// enforce member type for Struct[] and Union[]
|
|
for(auto& val : tsrc) {
|
|
if(val.desc && val.desc!=desc+1) {
|
|
throw NoConvert();
|
|
}
|
|
}
|
|
}
|
|
dest = src;
|
|
|
|
} else if(src.original_type()!=ArrayType::Value && uint8_t(desc->code.code)==uint8_t(src.original_type())) {
|
|
// assign array of scalar w/o convert
|
|
dest = src;
|
|
|
|
} else {
|
|
// TODO: alloc and convert
|
|
throw NoConvert();
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
throw NoConvert();
|
|
}
|
|
break;
|
|
}
|
|
case StoreType::Compound:
|
|
if(desc->code==TypeCode::Any) {
|
|
// assigning variant union.
|
|
if(type==StoreType::Compound) {
|
|
store->as<Value>() = *reinterpret_cast<const Value*>(ptr);
|
|
break;
|
|
}
|
|
}
|
|
// fall through
|
|
case StoreType::Null:
|
|
throw NoConvert();
|
|
}
|
|
|
|
store->top->valid[store->index()] = true;
|
|
}
|
|
|
|
void Value::traverse(const std::string &expr, bool modify)
|
|
{
|
|
size_t pos=0;
|
|
while(desc && pos<expr.size()) {
|
|
|
|
if(desc->code.code==TypeCode::Struct) {
|
|
// attempt traverse to member.
|
|
// expect: [0-9a-zA-Z_.]+[\[-$]
|
|
size_t sep = expr.find_first_of("[-", pos);
|
|
|
|
decltype (desc->mlookup)::const_iterator it;
|
|
|
|
if(sep>0 && (it=desc->mlookup.find(expr.substr(pos, sep-pos)))!=desc->mlookup.end()) {
|
|
// found it
|
|
auto next = desc+it->second;
|
|
auto offset = next->offset - desc->offset;
|
|
decltype(store) value(store, store.get()+offset);
|
|
store = std::move(value);
|
|
desc = next;
|
|
pos = sep;
|
|
|
|
} else {
|
|
// no such member
|
|
store.reset();
|
|
desc = nullptr;
|
|
}
|
|
|
|
} else if(desc->code.code==TypeCode::Union || desc->code.code==TypeCode::Any) {
|
|
// attempt to traverse to (and maybe select) member
|
|
// expect: ->[0-9a-zA-Z_]+[.\[-$]
|
|
|
|
if(expr.size()-pos >= 3 && expr[pos]=='-' && expr[pos+1]=='>') {
|
|
pos += 2; // skip past "->"
|
|
|
|
if(desc->code.code==TypeCode::Any) {
|
|
// select member of Any (may be Null)
|
|
*this = store->as<Value>();
|
|
|
|
} else {
|
|
// select member of Union
|
|
size_t sep = expr.find_first_of("[-.", pos);
|
|
|
|
decltype (desc->mlookup)::const_iterator it;
|
|
|
|
if(sep>0 && (it=desc->mlookup.find(expr.substr(pos, sep-pos)))!=desc->mlookup.end()) {
|
|
// found it.
|
|
auto& fld = store->as<Value>();
|
|
|
|
if(modify || fld.desc==desc+it->second) {
|
|
// will select, or already selected
|
|
if(fld.desc!=desc+it->second) {
|
|
// select
|
|
std::shared_ptr<const FieldDesc> mtype(store->top->desc, desc+it->second);
|
|
fld = Value(mtype);
|
|
}
|
|
pos = sep;
|
|
*this = fld;
|
|
|
|
} else {
|
|
// traversing const Value, can't select Union
|
|
store.reset();
|
|
desc = nullptr;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// expected "->"
|
|
store.reset();
|
|
desc = nullptr;
|
|
}
|
|
|
|
} else if(desc->code.isarray() && desc->code.kind()==Kind::Compound) {
|
|
// attempt to traverse into array of Struct, Union, or Any
|
|
// expect: \[[0-9]+\]
|
|
|
|
size_t sep = expr.find_first_of(']', pos);
|
|
unsigned long long index=0;
|
|
|
|
if(expr[pos]=='['
|
|
&& sep!=std::string::npos && sep-pos>=2
|
|
&& !epicsParseULLong(expr.substr(pos+1, sep-1-pos).c_str(), &index, 0, nullptr))
|
|
{
|
|
auto& varr = store->as<shared_array<const void>>();
|
|
shared_array<const Value> arr;
|
|
if((varr.original_type()==ArrayType::Value)
|
|
&& index < (arr = shared_array_static_cast<const Value>(varr)).size())
|
|
{
|
|
*this = arr[index];
|
|
pos = sep+1;
|
|
} else {
|
|
// wrong element type or out of range
|
|
store.reset();
|
|
desc = nullptr;
|
|
}
|
|
|
|
} else {
|
|
// syntax error
|
|
store.reset();
|
|
desc = nullptr;
|
|
}
|
|
|
|
} else {
|
|
// syntax error or wrong field type (can't index scalar array)
|
|
store.reset();
|
|
desc = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
Value Value::operator[](const char *name)
|
|
{
|
|
Value ret(*this);
|
|
ret.traverse(name, true);
|
|
return ret;
|
|
}
|
|
|
|
const Value Value::operator[](const char *name) const
|
|
{
|
|
Value ret(*this);
|
|
ret.traverse(name, false);
|
|
return ret;
|
|
}
|
|
|
|
static
|
|
void show_Value(std::ostream& strm,
|
|
const std::string& member,
|
|
const FieldDesc *desc,
|
|
const FieldStorage* store,
|
|
unsigned level=0)
|
|
{
|
|
indent(strm, level);
|
|
if(!desc) {
|
|
strm<<"null\n";
|
|
return;
|
|
}
|
|
|
|
strm<<desc->code;
|
|
if(!desc->id.empty())
|
|
strm<<" \""<<desc->id<<"\"";
|
|
if(!member.empty() && desc->code!=TypeCode::Struct)
|
|
strm<<" "<<member;
|
|
|
|
switch(store->code) {
|
|
case StoreType::Null:
|
|
if(desc->code==TypeCode::Struct) {
|
|
strm<<" {\n";
|
|
for(auto& pair : desc->miter) {
|
|
auto cdesc = desc + pair.second;
|
|
show_Value(strm, pair.first, cdesc, store - desc->offset + cdesc->offset, level+1);
|
|
}
|
|
indent(strm, level);
|
|
strm<<"}";
|
|
if(!member.empty())
|
|
strm<<" "<<member;
|
|
strm<<"\n";
|
|
} else {
|
|
strm<<"\n";
|
|
}
|
|
break;
|
|
case StoreType::Real: strm<<" = "<<store->as<double>()<<"\n"; break;
|
|
case StoreType::Integer: strm<<" = "<<store->as<int64_t>()<<"\n"; break;
|
|
case StoreType::UInteger: strm<<" = "<<store->as<uint64_t>()<<"\n"; break;
|
|
case StoreType::String: strm<<" = \""<<escape(store->as<std::string>())<<"\"\n"; break;
|
|
case StoreType::Compound: {
|
|
auto& fld = store->as<Value>();
|
|
if(fld.valid() && desc->code==TypeCode::Union) {
|
|
for(auto& pair : desc->miter) {
|
|
if(desc + pair.second == fld._desc()) {
|
|
strm<<"."<<pair.first;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
show_Value(strm, std::string(), fld._desc(), fld._store(), level+1);
|
|
}
|
|
break;
|
|
case StoreType::Array: {
|
|
auto& varr = store->as<shared_array<const void>>();
|
|
if(varr.original_type()!=ArrayType::Value) {
|
|
strm<<" = "<<varr<<"\n";
|
|
} else {
|
|
auto arr = shared_array_static_cast<const Value>(varr);
|
|
strm<<" [\n";
|
|
for(auto& val : arr) {
|
|
show_Value(strm, std::string(), val._desc(), val._store(), level+1);
|
|
}
|
|
indent(strm, level);
|
|
strm<<"]\n";
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
strm<<"!!Invalid StoreType!! "<<int(store->code)<<"\n";
|
|
break;
|
|
}
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& strm, const Value& val)
|
|
{
|
|
show_Value(strm, std::string(), val._desc(), val._store());
|
|
return strm;
|
|
}
|
|
|
|
namespace impl {
|
|
|
|
void FieldStorage::init(const FieldDesc *desc)
|
|
{
|
|
if(!desc || desc->code.kind()==Kind::Null || desc->code.code==TypeCode::Struct) {
|
|
this->code = StoreType::Null;
|
|
|
|
} else if(desc->code.isarray()) {
|
|
this->code = StoreType::Array;
|
|
new(&store) shared_array<void>();
|
|
|
|
} else {
|
|
switch(desc->code.kind()) {
|
|
case Kind::String:
|
|
new(&store) std::string();
|
|
this->code = StoreType::String;
|
|
break;
|
|
case Kind::Compound:
|
|
new(&store) std::shared_ptr<FieldStorage>();
|
|
this->code = StoreType::Compound;
|
|
break;
|
|
case Kind::Integer:
|
|
if(!desc->code.isunsigned()) {
|
|
as<int64_t>() = 0u;
|
|
this->code = StoreType::Integer;
|
|
break;
|
|
}
|
|
// fall trhough
|
|
case Kind::Bool:
|
|
as<uint64_t>() = 0u;
|
|
this->code = StoreType::UInteger;
|
|
break;
|
|
case Kind::Real:
|
|
as<double>() = 0.0;
|
|
this->code = StoreType::Real;
|
|
break;
|
|
default:
|
|
throw std::logic_error("FieldStore::init()");
|
|
}
|
|
}
|
|
}
|
|
|
|
void FieldStorage::deinit()
|
|
{
|
|
switch(code) {
|
|
case StoreType::Null:
|
|
case StoreType::Integer:
|
|
case StoreType::UInteger:
|
|
case StoreType::Real:
|
|
break;
|
|
case StoreType::Array:
|
|
as<shared_array<void>>().~shared_array();
|
|
break;
|
|
case StoreType::String:
|
|
as<std::string>().~basic_string();
|
|
break;
|
|
case StoreType::Compound:
|
|
as<Value>().~Value();
|
|
break;
|
|
default:
|
|
throw std::logic_error("FieldStore::deinit()");
|
|
}
|
|
code = StoreType::Null;
|
|
}
|
|
|
|
FieldStorage::~FieldStorage()
|
|
{
|
|
deinit();
|
|
}
|
|
|
|
size_t FieldStorage::index() const
|
|
{
|
|
const size_t ret = this-top->members.data();
|
|
assert(this==&top->members[ret]);
|
|
return ret;
|
|
}
|
|
|
|
void FieldDesc_calculate_offset(FieldDesc* const top)
|
|
{
|
|
top->offset = 0;
|
|
uint16_t offset = 1;
|
|
size_t index = 1;
|
|
while(index < top->size()) {
|
|
auto& fld = top[index];
|
|
|
|
switch (fld.code.code) {
|
|
case TypeCode::Struct:
|
|
if(top->code==fld.code) {
|
|
// sub-structure
|
|
fld.offset = offset++;
|
|
index++;
|
|
} else {
|
|
// structure inside union or array of struct
|
|
// new offset zero
|
|
FieldDesc_calculate_offset(top);
|
|
index+=top->size();
|
|
}
|
|
break;
|
|
case TypeCode::Union:
|
|
// number in parent structure/union
|
|
fld.offset = offset++;
|
|
// new offset zero for each child
|
|
for(auto& pair : fld.miter) {
|
|
FieldDesc_calculate_offset(top+index+pair.second);
|
|
}
|
|
index += fld.size();
|
|
break;
|
|
case TypeCode::StructA:
|
|
case TypeCode::UnionA:
|
|
// number in parent structure/union
|
|
fld.offset = offset++;
|
|
index++;
|
|
// new offset zero for child
|
|
FieldDesc_calculate_offset(top+index);
|
|
index += top[index].size();
|
|
break;
|
|
default:
|
|
fld.offset = offset++;
|
|
index++;
|
|
break;
|
|
}
|
|
fld.next_offset = offset;
|
|
}
|
|
top->next_offset = offset;
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& strm, const FieldDesc* desc)
|
|
{
|
|
for(auto idx : range(desc->size())) {
|
|
auto& fld = desc[idx];
|
|
strm<<"["<<idx<<"] "<<fld.code<<' '<<fld.id
|
|
<<" <"<<fld.offset<<":"<<fld.next_offset<<">"
|
|
" ["<<idx<<":"<<idx+fld.num_index<<")\n";
|
|
|
|
switch(fld.code.code) {
|
|
case TypeCode::Struct:
|
|
case TypeCode::Union: {
|
|
// note: need to ensure stable lexical iteration order if fld.mlookup ever becomes unordered_map
|
|
for(auto& pair : fld.mlookup) {
|
|
strm<<" "<<pair.first<<" -> "<<pair.second<<" ["<<(idx+pair.second)<<"]\n";
|
|
}
|
|
for(auto& pair : fld.miter) {
|
|
strm<<" "<<pair.first<<" : "<<pair.second<<" ["<<(idx+pair.second)<<"]\n";
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return strm;
|
|
}
|
|
|
|
}} // namespace pvxs::impl
|