lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.1.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2022-07-01 10:44:02 +02:00
parent b3bf75a2a1
commit c07cea1fe0
2172 changed files with 183300 additions and 123938 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/externals/g4tools/include/tools/xml/aidas
Vendored
+15 -15
View File
@@ -832,15 +832,15 @@ protected:
}
{for(unsigned int index=0;index<dimension;index++) {
std::string s = "binNum";
std::string _s = "binNum";
if(dimension!=1) {
if(index==0) s += "X";
else if(index==1) s += "Y";
else if(index==2) s += "Z";
if(index==0) _s += "X";
else if(index==1) _s += "Y";
else if(index==2) _s += "Z";
}
if(!_elem->attribute_value(s,svalue)) {
if(!_elem->attribute_value(_s,svalue)) {
a_out << "tools::xml::aidas::read_bins :"
<< " a <bin1d> has no " << s << std::endl;
<< " a <bin1d> has no " << _s << std::endl;
return false;
}
if(svalue=="UNDERFLOW") {
@@ -1055,11 +1055,11 @@ protected:
return false;
}
std::string s;
if(_elem->attribute_value(s_booking(),s)) {
a_booking.push_back(colbook(stype,sname,s,true));
} else if(_elem->attribute_value(s_default(),s)) {
a_booking.push_back(colbook(stype,sname,s,false));
std::string _s;
if(_elem->attribute_value(s_booking(),_s)) {
a_booking.push_back(colbook(stype,sname,_s,true));
} else if(_elem->attribute_value(s_default(),_s)) {
a_booking.push_back(colbook(stype,sname,_s,false));
} else {
a_booking.push_back(colbook(stype,sname,"",false));
}
@@ -1485,10 +1485,10 @@ protected:
if(!to<double>(svalue,errorMinus)) return false;
}
histo::measurement& m = point.coordinate(coord);
m.set_value(value);
m.set_error_plus(errorPlus);
m.set_error_minus(errorMinus);
histo::measurement& _m = point.coordinate(coord);
_m.set_value(value);
_m.set_error_plus(errorPlus);
_m.set_error_minus(errorMinus);
coord++;
}
source/externals/g4tools/include/tools/xml/loader
Vendored
-582
View File
@@ -1,582 +0,0 @@
// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.
#ifndef tools_xml_loader
#define tools_xml_loader
#include <tools/xml/tree>
#include <tools/file>
#include <tools/mnmx>
#include <cstdio>
#include <cctype> //iscntrl
#ifndef TOOLS_USE_OUREX_EXPAT
#include <expat.h>
#else
#include <ourex_expat.h>
#endif
#ifdef TOOLS_MEM
#include <tools/mem>
namespace tools {
extern "C" {
inline void* xml_malloc(size_t a_size){
tools::mem::increment(tools::s_malloc().c_str());
return ::malloc(a_size);
}
inline void* xml_realloc(void* a_ptr,size_t a_size){
if(a_ptr==NULL) tools::mem::increment(tools::s_malloc().c_str());
return ::realloc(a_ptr,a_size);
}
inline void xml_free(void* a_ptr){
if(a_ptr!=NULL) tools::mem::decrement(tools::s_malloc().c_str());
::free(a_ptr);
}
}}
#endif
namespace tools {
namespace xml {
class loader {
#ifdef TOOLS_MEM
TOOLS_SCLASS(tools::xml::loader)
#endif
public:
loader(tools::xml::factory& a_factory,
std::ostream& a_out,bool a_verbose = false)
:m_factory(a_factory)
,m_out(a_out)
,m_verbose(a_verbose)
,m_take_cntrl(false)
,m_errors(0)
,m_top(0) // Used to cleanup in case XML parsing failed.
,m_current(0)
,m_compressed_reader(0)
,m_depth(0)
,m_abort(false)
{
#ifdef TOOLS_MEM
tools::mem::increment(s_class().c_str());
#endif
}
virtual ~loader(){
delete m_compressed_reader;
clear();
#ifdef TOOLS_MEM
tools::mem::decrement(s_class().c_str());
#endif
}
protected:
loader(const loader& a_from)
:m_factory(a_from.m_factory)
,m_out(a_from.m_out)
,m_verbose(a_from.m_verbose)
,m_take_cntrl(a_from.m_take_cntrl)
,m_errors(0)
,m_top(0) // Used to cleanup in case XML parsing failed.
,m_current(0)
,m_compressed_reader(0)
,m_depth(0)
,m_abort(false)
{
#ifdef TOOLS_MEM
tools::mem::increment(s_class().c_str());
#endif
}
loader& operator=(const loader& a_from){
if(&a_from==this) return *this;
m_verbose = a_from.m_verbose;
m_take_cntrl = a_from.m_take_cntrl;
m_errors = 0;
m_top = 0;
m_current = 0;
m_compressed_reader = 0;
m_depth = 0;
m_abort = false;
return *this;
}
public:
virtual bool visit_end_element(tools::xml::tree&,bool& a_keep) {
a_keep = true;
return true;
}
public:
void set_take_cntrl_chars(bool a_value) {m_take_cntrl = a_value;}
std::ostream& out() const {return m_out;}
void set_compressed_reader(tools::file::reader* aReader){
delete m_compressed_reader;
m_compressed_reader = aReader; //take ownership.
}
unsigned int errors() const {return m_errors;}
void set_tags(const std::vector<std::string>& a_tags){m_tags=a_tags;}
void add_tag(const std::string& a_tag){m_tags.push_back(a_tag);}
bool load_file(const std::string& a_file,bool a_compressed) {
clear();
if(!parse_file(a_file,
(XML_StartElementHandler)start_element,
(XML_EndElementHandler)end_element,
this,a_compressed)) {
clear();
return false;
}
if(m_current) m_current->set_file(a_file);
return true;
}
bool load_string(const std::string& a_string){
clear();
if(!parse_buffer(a_string.size(),a_string.c_str(),
(XML_StartElementHandler)start_element,
(XML_EndElementHandler)end_element,
this)) {
clear();
return false;
}
return true;
}
bool load_buffer(size_t aSize,const char* aBuffer){
clear();
if(!parse_buffer(aSize,aBuffer,
(XML_StartElementHandler)start_element,
(XML_EndElementHandler)end_element,
this)) {
clear();
return false;
}
return true;
}
const tools::xml::tree* top_item() const {return m_current;}
tools::xml::tree* top_item(){return m_current;}
void empty(){m_top = 0;m_current = 0;}
bool is_tag(const std::string& a_string) const {
size_t number = m_tags.size();
for(size_t index=0;index<number;index++) {
if(a_string==m_tags[index]) return true;
}
return false;
}
protected:
void clear(){
// In case of problem, deleting m_current is not sufficient.
delete m_top;
m_top = 0;
m_current = 0;
}
bool parse_buffer(size_t aSize,const char* aBuffer,
XML_StartElementHandler a_start,XML_EndElementHandler a_end,
void* a_tag){
m_errors = 0;
if(!aSize) return true; //nothing to do.
m_depth = 0;
m_abort = false;
#ifdef TOOLS_MEM
XML_Memory_Handling_Suite mem;
mem.malloc_fcn = xml_malloc;
mem.realloc_fcn = xml_realloc;
mem.free_fcn = xml_free;
XML_Parser _parser = XML_ParserCreate_MM(NULL,&mem,NULL);
#else
XML_Parser _parser = XML_ParserCreate(NULL);
#endif
XML_SetUserData(_parser,a_tag);
XML_SetElementHandler(_parser,a_start,a_end);
XML_SetCharacterDataHandler(_parser,(XML_CharacterDataHandler)character_data_handler);
//XML_SetProcessingInstructionHandler(_parser,processingInstructionHandler);
char* buf = (char*)aBuffer;
size_t l = aSize;
int done = 0;
do {
size_t len = tools::mn<size_t>(l,BUFSIZ); //BUFSIZ in cstdio
done = len < BUFSIZ ? 1 : 0;
if(XML_Parse(_parser, buf, (int)len, done)==XML_STATUS_ERROR) {
m_out << "parse_buffer :"
<< " " << XML_ErrorString(XML_GetErrorCode(_parser))
<< " at line " << (int)XML_GetCurrentLineNumber(_parser)
<< " at byte index " << (int)XML_GetCurrentByteIndex(_parser)
<< std::endl;
{XML_Index pos = XML_GetCurrentByteIndex(_parser);
XML_Index pmn = tools::mx<XML_Index>(pos-10,0);
XML_Index pmx = tools::mn<XML_Index>(pos+10,XML_Index(aSize)-1);
std::string c = " ";
{for(XML_Index p=pmn;p<=pmx;p++) {c[0] = *(aBuffer+p);m_out << c;}
m_out << std::endl;}
{for(XML_Index p=pmn;p<pos;p++) m_out << " ";
m_out << "^" << std::endl;}}
XML_ParserFree(_parser);
return false;
}
if(m_abort) {
XML_ParserFree(_parser);
return false;
}
buf += len;
l -= len;
} while (!done);
XML_ParserFree(_parser);
return true;
}
bool parse_file(const std::string& a_file,
XML_StartElementHandler a_start,XML_EndElementHandler a_end,
void* a_tag,bool a_compressed){
if(m_verbose) {
m_out << "parse_file :"
<< " parse file " << tools::sout(a_file) << "..." << std::endl;
}
m_errors = 0;
bool use_zlib = false;
if(a_compressed) {
if(m_verbose) {
m_out << "parse_file :"
<< " uncompress requested for file "
<< tools::sout(a_file) << "."
<< std::endl;
}
use_zlib = true;
} else {
// may be compressed anyway :
bool compressed;
if(!tools::file::is_gzip(a_file,compressed)) {
m_out << "parse_file :"
<< " tools::file::is_gzip() failed for " << a_file << "."
<< std::endl;
return false;
}
if(compressed) use_zlib = true;
}
tools::file::reader* freader = 0;
bool delete_freader = false;
if(use_zlib) {
if(!m_compressed_reader) {
m_out << "parse_file :"
<< " no compressed reader given."
<< std::endl;
return false;
}
freader = m_compressed_reader;
} else {
freader = new tools::FILE_reader();
delete_freader = true;
}
if(!freader->open(a_file)) {
m_out << "parse_file :"
<< " can't open file " << a_file << std::endl;
if(delete_freader) delete freader;
return false;
}
m_depth = 0;
m_abort = false;
#ifdef TOOLS_MEM
XML_Memory_Handling_Suite mem;
mem.malloc_fcn = xml_malloc;
mem.realloc_fcn = xml_realloc;
mem.free_fcn = xml_free;
XML_Parser _parser = XML_ParserCreate_MM(NULL,&mem,NULL);
#else
XML_Parser _parser = XML_ParserCreate(NULL);
#endif
XML_SetUserData(_parser,a_tag);
XML_SetElementHandler(_parser,a_start,a_end);
XML_SetCharacterDataHandler(_parser,(XML_CharacterDataHandler)character_data_handler);
//XML_SetProcessingInstructionHandler(_parser,
// processingInstructionHandler);
//char buf[1024 * BUFSIZ];
char buf[BUFSIZ];
int done = 0;
do {
size_t len;
if(!freader->read(buf,sizeof(buf),len)) {
XML_ParserFree(_parser);
freader->close();
if(delete_freader) delete freader;
return false;
}
done = len < sizeof(buf) ? 1 : 0;
if(XML_Parse(_parser, buf, (int)len, done)==XML_STATUS_ERROR) {
m_out << "parse_file :"
<< " in file " << tools::sout(a_file)
<< " " << XML_ErrorString(XML_GetErrorCode(_parser))
<< " at line " << (int)XML_GetCurrentLineNumber(_parser)
<< std::endl;
XML_ParserFree(_parser);
freader->close();
if(delete_freader) delete freader;
return false;
}
if(m_abort) {
XML_ParserFree(_parser);
freader->close();
if(delete_freader) delete freader;
return false;
}
} while (!done);
XML_ParserFree(_parser);
freader->close();
if(m_verbose) {
m_out << "parse_file :"
<< " parse file " << tools::sout(a_file) << " done." << std::endl;
}
if(delete_freader) delete freader;
return true;
}
protected:
static void character_data_handler(void* aUserData,const XML_Char* a_string,int aLength){
loader* This = (loader*)aUserData;
std::string s;
s.resize(aLength);
size_t count = 0;
char* p = (char*)a_string;
for (int i = 0; i < aLength; i++, p++) {
if(This->m_take_cntrl || (!iscntrl(*p))) {
s[count] = *p;
count++;
}
}
if(count) {
s.resize(count);
This->m_value += s;
}
}
static void start_element(void* aUserData,const XML_Char* a_name,const XML_Char** a_atbs){
loader* This = (loader*)aUserData;
if(This->m_abort) return; //Do nothing.
This->m_depth++;
This->m_value = "";
std::string name = a_name; //Can't be empty
if(This->is_tag(name)) {
if(!This->m_current) {
if(This->m_depth==1) {
// Ok. Head.
} else {
This->m_out << "start_element :"
<< " no tag with a depth of " << This->m_depth
<< std::endl;
This->m_abort = true;
return;
}
} else {
int delta = This->m_current->depth() - This->m_depth;
if(delta>=1) {
This->m_out << "start_element :"
<< " for element " << tools::sout(name)
<< " tag with a delta depth of " << delta
<< std::endl;
This->m_abort = true;
return;
}
}
std::vector<tools::xml::tree::atb> atbs;
{const XML_Char** a_atts = a_atbs;
while((*a_atts)&&(*(a_atts+1))) {
atbs.push_back(tools::xml::tree::atb(*a_atts,*(a_atts+1)));
a_atts+=2;
}}
tools::xml::tree* parent = This->m_current;
tools::xml::tree* _tree = This->m_factory.create(name,atbs,parent);
if(!_tree) {
This->m_out << "start_element :"
<< " can't create a tree for tag " << tools::sout(name)
<< std::endl;
This->m_abort = true;
return;
}
//out << "start_element :" << std::endl;
//_tree->print_xml(*(This->m_printer),"debug : ");
if(parent) parent->add_child(_tree);
/*
if(This->m_current && !This->m_current->parent()) {
This->m_out << "start_element :"
<< " warning : current tree without parent."
<< " Potential mem leak."
<< std::endl;
}
*/
This->m_current = _tree;
_tree->set_depth(This->m_depth); // Internal only.
if(!This->m_top) This->m_top = _tree;
} else {
if(!This->m_current) {
// Can't be in a non-tag without a tag !
This->m_out << "start_element :"
<< " for element " << tools::sout(name)
<< " non-tag without some parent tag."
<< std::endl;
This->m_abort = true;
return;
} else {
int delta = This->m_depth - This->m_current->depth();
if(delta>1) {
This->m_out << "start_element :"
<< " for element " << tools::sout(name)
<< " grand child of a tag."
<< std::endl;
This->m_abort = true;
return;
} else if(delta==1) { //ok
This->m_atbs.clear();
{const XML_Char** a_atts = a_atbs;
while((*a_atts)&&(*(a_atts+1))) {
This->m_atbs.push_back(tools::xml::tree::atb(*a_atts,*(a_atts+1)));
a_atts+=2;
}}
} else {
This->m_out << "start_element :"
<< " for element " << tools::sout(name)
<< " non-tag with a delta depth of " << delta
<< std::endl;
This->m_abort = true;
return;
}
}
}
}
static void end_element(void* aUserData,const XML_Char* a_name){
loader* This = (loader*)aUserData;
if(This->m_abort) return; //Do nothing.
if(This->m_current) {
tools::xml::tree* tr = This->m_current;
int delta = This->m_depth - tr->depth();
if(delta==0) { //Back to a tag :
tools::xml::tree* parent = tr->parent();
bool keep = false;
bool cont = This->visit_end_element(*tr,keep);
if(keep) {
if(parent) {
/*
if(!This->m_current->parent()) {
This->m_out << "end_element :"
<< " warning : current tree without parent (1)."
<< " Potential mem leak."
<< std::endl;
}
*/
This->m_current = parent;
}
} else {
//FIXME : the top could be recreated !
if(This->m_top==tr) This->m_top = 0;
if(parent) {
parent->remove_child(tr); //delete the tr
} else {
delete tr;
}
/*
if(!This->m_current->parent()) {
This->m_out << "end_element :"
<< " warning : current tree without parent (2)."
<< " Potential mem leak."
<< std::endl;
}
*/
This->m_current = parent; //parent could be 0 : ok.
}
if(!cont) This->m_abort = true;
} else if(delta==1) { //Back to a child of tag :
//FIXME : correct m_value ? (Can we pick the one of a sub item ?)
tr->add_element(std::string(a_name),This->m_atbs,This->m_value);
//This->m_value = "";
} else {
This->m_out << "end_element :"
<< " problem for element " << tools::sout(std::string(a_name))
<< " : delta depth of " << delta
<< std::endl;
This->m_abort = true;
}
}
This->m_depth--;
}
protected:
tools::xml::factory& m_factory;
std::ostream& m_out;
protected:
bool m_verbose;
bool m_take_cntrl;
unsigned int m_errors;
std::vector<std::string> m_tags;
tools::xml::tree* m_top;
tools::xml::tree* m_current;
//std::vector<tools::xml::tree::atb> m_atbs;
std::vector< std::pair<std::string,std::string> > m_atbs;
std::string m_value;
tools::file::reader* m_compressed_reader;
unsigned int m_depth;
bool m_abort;
};
}}
#endif
source/externals/g4tools/include/tools/xml/styles
Vendored
+7 -7
View File
@@ -172,8 +172,8 @@ public:
bool res_color(const style_t& a_sty,const std::string& a_key,colorf& a_color,const std::string& a_msg) const {
//NOTE : if ret false, we do not set a_color to something.
std::string s;
if(!find(a_sty,a_key,s)) {
std::string _s;
if(!find(a_sty,a_key,_s)) {
if(a_msg.size()) {
m_out << "tools::xml::styles::res_color :"
<< " key " << sout(a_key) << " not found"
@@ -182,7 +182,7 @@ public:
}
return false;
}
if(!sg::find_color(m_cmaps,s,a_color)) {
if(!sg::find_color(m_cmaps,_s,a_color)) {
m_out << "tools::xml::styles::res_color :"
<< " key " << sout(a_key) << " is not a color"
<< " in style " << sout(a_msg) << "."
@@ -212,8 +212,8 @@ public:
bool res_bool(const style_t& a_sty,const std::string& a_key,bool& a_v,const std::string& a_msg) const {
//NOTE : if ret false, we do not set a_v to something.
std::string s;
if(!find(a_sty,a_key,s)) {
std::string _s;
if(!find(a_sty,a_key,_s)) {
if(a_msg.size()) {
m_out << "tools::xml::styles::res_bool :"
<< " key " << sout(a_key) << " not found"
@@ -223,11 +223,11 @@ public:
return false;
}
bool v;
if(!to(s,v)) {
if(!to(_s,v)) {
m_out << "tools::xml::styles::res_bool :"
<< " for key " << sout(a_key) << " not found"
<< " in style " << sout(a_msg) << "."
<< " can't convert " << sout(s) << " to bool."
<< " can't convert " << sout(_s) << " to bool."
<< std::endl;
return false;
}
source/externals/g4tools/include/tools/xml/tree
Vendored
+11 -11
View File
@@ -414,9 +414,9 @@ public:
tree* find_item_with_tag(const std::string& a_tag,
const std::string& a_name) const {
if(a_tag==tag_name()) {
std::string s;
attribute_value("name",s);
if(a_name==s) return const_cast<tree*>(this);
std::string _s;
attribute_value("name",_s);
if(a_name==_s) return const_cast<tree*>(this);
}
// Look children :
@@ -568,9 +568,9 @@ public:
tree* find_by_attribute(const std::string& a_atb,const std::string& a_value,
bool a_up_down = true,bool a_left_right = true) const {
if(a_up_down) {
std::string s;
attribute_value(a_atb,s);
if(s==a_value) return const_cast<tree*>(this);
std::string _s;
attribute_value(a_atb,_s);
if(_s==a_value) return const_cast<tree*>(this);
if(a_left_right) {
tools_lforcit(ielem*,m_childs,it) {
@@ -607,9 +607,9 @@ public:
}}
}
std::string s;
attribute_value(a_atb,s);
if(s==a_value) return const_cast<tree*>(this);
std::string _s;
attribute_value(a_atb,_s);
if(_s==a_value) return const_cast<tree*>(this);
}
return 0;
@@ -784,8 +784,8 @@ public:
// Look children :
tools_lforcit(ielem*,m_childs,it) {
if(tree* _tree = id_cast<ielem,tree>(*(*it))) {
std::string s;
if(_tree->element_value(a_name,s) && (a_value==s)) return _tree;
std::string _s;
if(_tree->element_value(a_name,_s) && (a_value==_s)) return _tree;
}}
return 0;
}
source/externals/g4tools/include/tools/xml/wrap_viewplot_fonts_google_style
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
//
// This file had been produced automatically
// by the inlib/wrap program from the file :
// by the tools/wrap program from the file :
// viewplot_fonts_google.style
//
source/externals/g4tools/include/tools/xml/xml_style
Vendored
-44
View File
@@ -1,44 +0,0 @@
// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.
#ifndef tools_xml_style
#define tools_xml_style
#include <tools/xml/styles>
#include "loader"
namespace tools {
namespace xml {
inline bool load_style_file(std::ostream&,const std::string& a_file,tools::xml::styles& a_styles) {
tools::xml::default_factory factory;
tools::xml::loader ml(factory,a_styles.out(),false);
std::vector<std::string> tags;
tags.push_back("styles");
tags.push_back("style");
tags.push_back("plotter_style");
ml.set_tags(tags);
if(!ml.load_file(a_file,false)) return false;
tools::xml::tree* top = ml.top_item();
if(!top) return true; //File could be empty.
return scan_style_tree(a_styles,*top);
}
inline bool load_style_string(tools::xml::styles& a_styles,const std::string& a_string) {
tools::xml::default_factory factory;
tools::xml::loader ml(factory,a_styles.out(),false);
std::vector<std::string> tags;
tags.push_back("styles");
tags.push_back("style");
tags.push_back("plotter_style");
ml.set_tags(tags);
if(!ml.load_string(a_string)) return false;
tools::xml::tree* top = ml.top_item();
if(!top) return true;
return scan_style_tree(a_styles,*top);
}
}}
#endif