bool search(iterator first_, iterator second_, const lsm &lsm_,
const sm_type &gsm_)
{
typedef lexertl::iterator<iterator, lsm, lexertl::
match_results<iterator> > lex_iterator;
lex_iterator iter_(first_, second_, lsm_);
lex_iterator end_;
return search(gsm_, iter_, end_);
}
void lex_prop_list()
{
lexertl::rules rules_;
lexertl::state_machine state_machine_;
std::ifstream if_("PropList.txt");
lexertl::stream_shared_iterator iter_(if_);
lexertl::stream_shared_iterator end_;
lexertl::match_results<lexertl::stream_shared_iterator>
results_(iter_, end_);
enum {eRange = 1, eName, eShortName};
rules_.push_state("RANGE");
rules_.push_state("WS");
rules_.push_state("NAME");
rules_.push_state("SHORT_NAME");
rules_.push_state("FINISH");
rules_.push("^#.*", rules_.skip());
rules_.push("\n", rules_.skip());
rules_.push("INITIAL", "^[0-9A-F]+(\\.\\.[0-9A-F]+)?", eRange, "RANGE");
rules_.push("RANGE", " *; ", rules_.skip(), "NAME");
rules_.push("NAME", "[A-Z][a-zA-Z_]+", eName, "WS");
rules_.push("WS", " # ", rules_.skip(), "SHORT_NAME");
rules_.push("SHORT_NAME", "[A-Z][a-z&]", eShortName, "FINISH");
rules_.push("FINISH", ".*\n", rules_.skip(), "INITIAL");
lexertl::generator::build(rules_, state_machine_);
do
{
lexertl::lookup(state_machine_, results_);
std::cout << "Id: " << results_.id << ", Token: '" <<
std::string(results_.start, results_.end) << "'\n";
if (results_.id > eShortName)
{
// int i = 0;
}
} while (results_.id != 0);
}
void case_mapping()
{
lexertl::rules rules_;
lexertl::state_machine sm_;
std::ifstream if_("UnicodeData.txt");
lexertl::stream_shared_iterator iter_(if_);
lexertl::stream_shared_iterator end_;
lexertl::match_results<lexertl::stream_shared_iterator>
results_(iter_, end_);
enum e_Token {eEOF, eCodeValue, eName, eLl, eLu, eNeither, eMapping, eEmpty};
e_Token eToken = eEOF;
std::string code_;
std::string mapping_;
int count_ = 0;
rules_.push_state("NAME");
rules_.push_state("TYPE");
rules_.push_state("Ll");
rules_.push_state("Lu");
rules_.push_state("MAPPING");
rules_.push_state("END");
rules_.push("INITIAL", "^[0-9A-F]{4,6};", eCodeValue, "NAME");
rules_.push("NAME", "[^;]*;", sm_.skip(), "TYPE");
rules_.push("TYPE", "Ll;", eLl, "Ll");
rules_.push("Ll", "([^;]*;){9}", sm_.skip(), "MAPPING");
rules_.push("TYPE", "Lu;", eLu, "Lu");
rules_.push("Lu", "([^;]*;){10}", sm_.skip(), "MAPPING");
rules_.push("TYPE", "[^;]*;", eNeither, "END");
rules_.push("MAPPING", ";", eEmpty, "END");
rules_.push("MAPPING", "[0-9A-F]{4,6};", eMapping, "END");
rules_.push("END", "[^\n]*\n", sm_.skip(), "INITIAL");
lexertl::generator::build(rules_, sm_);
do
{
lexertl::lookup(sm_, results_);
eToken = static_cast<e_Token>(results_.id);
if (eToken == eEOF)
{
break;
}
else if (eToken != eCodeValue)
{
throw std::runtime_error("Syntax error");
}
code_.assign(results_.start, results_.end);
lexertl::lookup(sm_, results_);
eToken = static_cast<e_Token>(results_.id);
if (eToken != eLl && eToken != eLu && eToken != eNeither)
{
throw std::runtime_error("Syntax error");
}
if (eToken != eNeither)
{
lexertl::lookup(sm_, results_);
eToken = static_cast<e_Token>(results_.id);
if (eToken == eMapping)
{
mapping_.assign(results_.start, results_.end);
std::cout << "(0x" << code_.substr(0, code_.size() - 1) << ", " <<
"0x" << mapping_.substr(0, mapping_.size() - 1) << "), ";
code_.clear();
mapping_.clear();
++count_;
if (count_ > 2)
{
count_ = 0;
std::cout << '\n';
}
}
}
} while (results_.id != 0);
}
/* Subroutine */ int deritr_(doublereal *errfn, doublereal *geo)
{
/* Initialized data */
static integer icalcn = 0;
/* System generated locals */
integer i__1, i__2, i__3, i__4;
/* Builtin functions */
integer i_indx(char *, char *, ftnlen, ftnlen);
double pow_di(doublereal *, integer *);
integer s_wsfe(cilist *), e_wsfe(void), do_fio(integer *, char *, ftnlen);
/* Local variables */
static integer i__, j, k, l;
#define w ((doublereal *)&wmatrx_1)
static doublereal aa, ee;
static integer ij, ii, il, jl, kl, ll;
extern /* Subroutine */ int iter_(doublereal *, doublereal *, doublereal *
, doublereal *, doublereal *, logical *, logical *);
static doublereal xjuc[3];
static logical debug;
extern /* Subroutine */ int hcore_(doublereal *, doublereal *, doublereal
*, doublereal *, doublereal *, doublereal *);
static doublereal coord[360] /* was [3][120] */, change[3];
static integer idelta, linear;
static doublereal xparam[360], xderiv[3];
extern /* Subroutine */ int gmetry_(doublereal *, doublereal *);
static doublereal xstore;
extern /* Subroutine */ int symtry_(void);
/* Fortran I/O blocks */
static cilist io___24 = { 0, 6, 0, "(' ERROR FUNCTION')", 0 };
static cilist io___25 = { 0, 6, 0, "(10F8.3)", 0 };
/* COMDECK SIZES */
/* *********************************************************************** */
/* THIS FILE CONTAINS ALL THE ARRAY SIZES FOR USE IN MOPAC. */
/* THERE ARE ONLY 5 PARAMETERS THAT THE PROGRAMMER NEED SET: */
/* MAXHEV = MAXIMUM NUMBER OF HEAVY ATOMS (HEAVY: NON-HYDROGEN ATOMS) */
/* MAXLIT = MAXIMUM NUMBER OF HYDROGEN ATOMS. */
/* MAXTIM = DEFAULT TIME FOR A JOB. (SECONDS) */
/* MAXDMP = DEFAULT TIME FOR AUTOMATIC RESTART FILE GENERATION (SECS) */
/* ISYBYL = 1 IF MOPAC IS TO BE USED IN THE SYBYL PACKAGE, =0 OTHERWISE */
/* SEE ALSO NMECI, NPULAY AND MESP AT THE END OF THIS FILE */
/* *********************************************************************** */
/* THE FOLLOWING CODE DOES NOT NEED TO BE ALTERED BY THE PROGRAMMER */
/* *********************************************************************** */
/* ALL OTHER PARAMETERS ARE DERIVED FUNCTIONS OF THESE TWO PARAMETERS */
/* NAME DEFINITION */
/* NUMATM MAXIMUM NUMBER OF ATOMS ALLOWED. */
/* MAXORB MAXIMUM NUMBER OF ORBITALS ALLOWED. */
/* MAXPAR MAXIMUM NUMBER OF PARAMETERS FOR OPTIMISATION. */
/* N2ELEC MAXIMUM NUMBER OF TWO ELECTRON INTEGRALS ALLOWED. */
/* MPACK AREA OF LOWER HALF TRIANGLE OF DENSITY MATRIX. */
/* MORB2 SQUARE OF THE MAXIMUM NUMBER OF ORBITALS ALLOWED. */
/* MAXHES AREA OF HESSIAN MATRIX */
/* MAXALL LARGER THAN MAXORB OR MAXPAR. */
/* *********************************************************************** */
/* *********************************************************************** */
/* DECK MOPAC */
/* *********************************************************************** */
/* DERITR CALCULATES THE DERIVATIVES OF THE ENERGY WITH RESPECT TO THE */
/* INTERNAL COORDINATES. THIS IS DONE BY FINITE DIFFERENCES */
/* USING FULL SCF CALCULATIONS. */
/* THIS IS VERY TIME-CONSUMING, AND SHOULD ONLY BE USED WHEN */
/* NO OTHER DERIVATIVE CALCULATION WILL DO. */
/* THE MAIN ARRAYS IN DERIV ARE: */
/* LOC INTEGER ARRAY, LOC(1,I) CONTAINS THE ADDRESS OF THE ATOM */
/* INTERNAL COORDINATE LOC(2,I) IS TO BE USED IN THE */
/* DERIVATIVE CALCULATION. */
/* GEO ARRAY \GEO\ HOLDS THE INTERNAL COORDINATES. */
/* *********************************************************************** */
/* Parameter adjustments */
geo -= 4;
--errfn;
/* Function Body */
if (icalcn != numcal_1.numcal) {
debug = i_indx(keywrd_1.keywrd, "DERITR", (ftnlen)241, (ftnlen)6) !=
0;
icalcn = numcal_1.numcal;
/* IDELTA IS A MACHINE-PRECISION DEPENDANT INTEGER */
idelta = -3;
change[0] = pow_di(&c_b3, &idelta);
change[1] = pow_di(&c_b3, &idelta);
change[2] = pow_di(&c_b3, &idelta);
/* CHANGE(I) IS THE STEP SIZE USED IN CALCULATING THE DERIVATIVES. */
/* BECAUSE FULL SCF CALCULATIONS ARE BEING DONE QUITE LARGE STEPS */
/* ARE NEEDED. ON THE OTHER HAND, THE STEP CANNOT BE VERY LARGE, */
/* AS THE SECOND DERIVITIVE IN FLEPO IS CALCULATED FROM THE */
/* DIFFERENCES OF TWO FIRST DERIVATIVES. CHANGE(1) IS FOR CHANGE IN */
/* BOND LENGTH, (2) FOR ANGLE, AND (3) FOR DIHEDRAL. */
xderiv[0] = .5 / change[0];
xderiv[1] = .5 / change[1];
xderiv[2] = .5 / change[2];
}
i__1 = geovar_1.nvar;
for (i__ = 1; i__ <= i__1; ++i__) {
/* L10: */
xparam[i__ - 1] = geo[geovar_1.loc[(i__ << 1) - 1] + geovar_1.loc[(
i__ << 1) - 2] * 3];
}
if (geosym_1.ndep != 0) {
symtry_();
}
gmetry_(&geo[4], coord);
/* ESTABLISH THE ENERGY AT THE CURRENT POINT */
hcore_(coord, hmatrx_1.h__, w, wmatrx_1.wj, wmatrx_1.wk, &enuclr_1.enuclr)
;
if (molkst_1.norbs * molkst_1.nelecs > 0) {
iter_(hmatrx_1.h__, w, wmatrx_1.wj, wmatrx_1.wk, &aa, &c_true, &
c_false);
} else {
aa = 0.;
}
linear = molkst_1.norbs * (molkst_1.norbs + 1) / 2;
/* RESTORE THE DENSITY MATRIX (WHY?) */
i__1 = linear;
for (i__ = 1; i__ <= i__1; ++i__) {
/* L20: */
densty_1.p[i__ - 1] = densty_1.pa[i__ - 1] * 2.;
}
aa += enuclr_1.enuclr;
ij = 0;
i__1 = molkst_1.numat;
for (ii = 1; ii <= i__1; ++ii) {
i__2 = ucell_1.l1u;
for (il = ucell_1.l1l; il <= i__2; ++il) {
i__3 = ucell_1.l2u;
for (jl = ucell_1.l2l; jl <= i__3; ++jl) {
i__4 = ucell_1.l3u;
for (kl = ucell_1.l3l; kl <= i__4; ++kl) {
for (ll = 1; ll <= 3; ++ll) {
/* L30: */
xjuc[ll - 1] = coord[ll + ii * 3 - 4] + euler_1.tvec[
ll - 1] * il + euler_1.tvec[ll + 2] * jl +
euler_1.tvec[ll + 5] * kl;
}
++ij;
/* L50: */
}
}
}
/* L60: */
}
i__1 = geovar_1.nvar;
for (i__ = 1; i__ <= i__1; ++i__) {
k = geovar_1.loc[(i__ << 1) - 2];
l = geovar_1.loc[(i__ << 1) - 1];
xstore = xparam[i__ - 1];
i__4 = geovar_1.nvar;
for (j = 1; j <= i__4; ++j) {
/* L70: */
geo[geovar_1.loc[(j << 1) - 1] + geovar_1.loc[(j << 1) - 2] * 3] =
xparam[j - 1];
}
geo[l + k * 3] = xstore - change[l - 1];
if (geosym_1.ndep != 0) {
symtry_();
}
gmetry_(&geo[4], coord);
/* IF NEEDED, CALCULATE "EXACT" DERIVITIVES. */
hcore_(coord, hmatrx_1.h__, w, wmatrx_1.wj, wmatrx_1.wk, &
enuclr_1.enuclr);
if (molkst_1.norbs * molkst_1.nelecs > 0) {
iter_(hmatrx_1.h__, w, wmatrx_1.wj, wmatrx_1.wk, &ee, &c_true, &
c_false);
} else {
ee = 0.;
}
i__4 = linear;
for (ii = 1; ii <= i__4; ++ii) {
/* L80: */
densty_1.p[ii - 1] = densty_1.pa[ii - 1] * 2.;
}
ee += enuclr_1.enuclr;
errfn[i__] = (aa - ee) * 23.061 * xderiv[l - 1] * 2.;
/* L90: */
}
if (debug) {
s_wsfe(&io___24);
e_wsfe();
s_wsfe(&io___25);
i__1 = geovar_1.nvar;
for (i__ = 1; i__ <= i__1; ++i__) {
do_fio(&c__1, (char *)&errfn[i__], (ftnlen)sizeof(doublereal));
}
e_wsfe();
}
return 0;
} /* deritr_ */
bool search(iterator first_, iterator second_, captures &captures_,
lsm &lsm_, const sm_type &gsm_)
{
typedef lexertl::iterator<iterator, lsm, lexertl::
match_results<iterator> > lex_iterator;
lex_iterator iter_(first_, second_, lsm_);
lex_iterator end_;
basic_match_results<sm_type> results_(iter_->id, gsm_);
typedef parsertl::token<lex_iterator> token;
typedef typename token::token_vector token_vector;
typedef std::multimap<typename sm_type::id_type, token_vector> prod_map;
prod_map prod_map_;
bool success_ = search(gsm_, iter_, end_, &prod_map_);
captures_.clear();
if (success_)
{
iterator last_ = iter_->first;
typename prod_map::const_iterator pi_ = prod_map_.begin();
typename prod_map::const_iterator pe_ = prod_map_.end();
captures_.resize((gsm_._captures.empty() ? 0 :
gsm_._captures.back().first +
gsm_._captures.back().second.size()) + 1);
captures_[0].push_back(std::make_pair(iter_->first, iter_->first));
for (; pi_ != pe_; ++pi_)
{
if (gsm_._captures.size() > pi_->first)
{
const typename sm_type::capture_vec_pair &row_ =
gsm_._captures[pi_->first];
if (!row_.second.empty())
{
typedef typename sm_type::capture_vector capture_vector;
typename capture_vector::const_iterator ti_ =
row_.second.begin();
typename capture_vector::const_iterator te_ =
row_.second.end();
std::size_t index_ = 0;
for (; ti_ != te_; ++ti_)
{
const token &token1_ = pi_->second[ti_->first];
const token &token2_ = pi_->second[ti_->second];
captures_[row_.first + index_ + 1].
push_back(std::make_pair(token1_.first,
token2_.second));
++index_;
}
}
}
}
pi_ = prod_map_.begin();
pe_ = prod_map_.end();
for (; pi_ != pe_; ++pi_)
{
typename token::iter_type second_ = pi_->second.back().second;
if (second_ > last_)
{
last_ = second_;
}
}
captures_.front().back().second = last_;
}
return success_;
}
std::string rev_regex(const std::string &rx_, const lexertl::state_machine &sm_)
{
std::string str_;
std::string curr_;
token_stack stack_;
lexertl::citerator iter_(rx_.c_str(), rx_.c_str() + rx_.length(), sm_);
lexertl::citerator end_;
std::size_t parens_ = 0;
for (; iter_ != end_; ++iter_)
{
switch (iter_->id)
{
case eCharset:
case eMacro:
case eComment:
stack_.push(token_pair((eToken)iter_->id, iter_->str()));
break;
case eString:
{
lexertl::citerator i_(iter_->start + 1, iter_->end - 1, sm_);
lexertl::citerator e_;
std::string str_;
for (; i_ != e_; ++i_)
{
str_ = i_->str() + str_;
}
str_ = '"' + str_ + '"';
stack_.push(token_pair((eToken)iter_->id, str_));
break;
}
case eQuantifier:
if (stack_.empty())
{
throw std::runtime_error("Quantifier without regex.");
}
stack_.top().second += iter_->str();
break;
case eDifference:
if (stack_.empty())
{
throw std::runtime_error("Difference without regex.");
}
stack_.top().second += iter_->str();
++iter_;
stack_.top().second += iter_->str();
break;
case eBOL:
// Reverse to eEOL
stack_.push(token_pair(eEOL, std::string(1, '$')));
break;
case eEOL:
// Reverse to eBOL
stack_.push(token_pair(eBOL, std::string(1, '^')));
break;
case eOr:
reduce_stack(stack_);
stack_.push(token_pair((eToken)iter_->id, iter_->str()));
break;
case eOpen:
stack_.push(token_pair((eToken)iter_->id, iter_->str()));
++parens_;
break;
case eClose:
{
if (parens_ < 1)
{
throw std::runtime_error("Unbalanced parens in regex.");
}
std::string str_;
reduce_stack(stack_);
str_ = stack_.top().second;
str_ += iter_->str();
stack_.pop();
stack_.top().second += str_;
stack_.top().first = eCharset;
--parens_;
break;
}
default:
throw std::runtime_error("Unknown regex token.");
break;
}
}
for (; !stack_.empty(); stack_.pop())
{
str_ += stack_.top().second;
}
return str_;
}
