/*
** p^n
*/
static int lp_star (lua_State *L) {
int size1;
int n = (int)luaL_checkinteger(L, 2);
TTree *tree1 = getpatt(L, 1, &size1);
if (n >= 0) { /* seq tree1 (seq tree1 ... (seq tree1 (rep tree1))) */
TTree *tree = newtree(L, (n + 1) * (size1 + 1));
if (nullable(tree1))
luaL_error(L, "loop body may accept empty string");
while (n--) /* repeat 'n' times */
tree = seqaux(tree, tree1, size1);
tree->tag = TRep;
memcpy(sib1(tree), tree1, size1 * sizeof(TTree));
}
else { /* choice (seq tree1 ... choice tree1 true ...) true */
TTree *tree;
n = -n;
/* size = (choice + seq + tree1 + true) * n, but the last has no seq */
tree = newtree(L, n * (size1 + 3) - 1);
for (; n > 1; n--) { /* repeat (n - 1) times */
tree->tag = TChoice; tree->u.ps = n * (size1 + 3) - 2;
sib2(tree)->tag = TTrue;
tree = sib1(tree);
tree = seqaux(tree, tree1, size1);
}
tree->tag = TChoice; tree->u.ps = size1 + 1;
sib2(tree)->tag = TTrue;
memcpy(sib1(tree), tree1, size1 * sizeof(TTree));
}
copyktable(L, 1);
return 1;
}
/*
** Constant capture
*/
static int lp_constcapture (lua_State *L) {
int i;
int n = lua_gettop(L); /* number of values */
if (n == 0) /* no values? */
newleaf(L, TTrue); /* no capture */
else if (n == 1)
newemptycapkey(L, Cconst, 1); /* single constant capture */
else { /* create a group capture with all values */
TTree *tree = newtree(L, 1 + 3 * (n - 1) + 2);
newktable(L, n); /* create a 'ktable' for new tree */
tree->tag = TCapture;
tree->cap = Cgroup;
tree->key = 0;
tree = sib1(tree);
for (i = 1; i <= n - 1; i++) {
tree->tag = TSeq;
tree->u.ps = 3; /* skip TCapture and its sibling */
auxemptycap(sib1(tree), Cconst);
sib1(tree)->key = addtoktable(L, i);
tree = sib2(tree);
}
auxemptycap(tree, Cconst);
tree->key = addtoktable(L, i);
}
return 1;
}
/*
** Numbers as patterns:
** 0 == true (always match); n == TAny repeated 'n' times;
** -n == not (TAny repeated 'n' times)
*/
static TTree *numtree (lua_State *L, int n) {
if (n == 0)
return newleaf(L, TTrue);
else {
TTree *tree, *nd;
if (n > 0)
tree = nd = newtree(L, 2 * n - 1);
else { /* negative: code it as !(-n) */
n = -n;
tree = newtree(L, 2 * n);
tree->tag = TNot;
nd = sib1(tree);
}
fillseq(nd, TAny, n, NULL); /* sequence of 'n' any's */
return tree;
}
}
tree*
token(char *str, int type)
{
tree *t = newtree();
t->type = type;
t->str = strdup(str);
return t;
}
/*
** create a new tree, whith a new root and one sibling.
** Sibling must be on the Lua stack, at index 1.
*/
static TTree *newroot1sib (lua_State *L, int tag) {
int s1;
TTree *tree1 = getpatt(L, 1, &s1);
TTree *tree = newtree(L, 1 + s1); /* create new tree */
tree->tag = tag;
memcpy(sib1(tree), tree1, s1 * sizeof(TTree));
copyktable(L, 1);
return tree;
}
/*
** Convert value at index 'idx' to a pattern
*/
static TTree *getpatt (lua_State *L, int idx, int *len) {
TTree *tree;
switch (lua_type(L, idx)) {
case LUA_TSTRING: {
size_t slen;
const char *s = lua_tolstring(L, idx, &slen); /* get string */
if (slen == 0) /* empty? */
tree = newleaf(L, TTrue); /* always match */
else {
tree = newtree(L, 2 * (slen - 1) + 1);
fillseq(tree, TChar, slen, s); /* sequence of 'slen' chars */
}
break;
}
case LUA_TNUMBER: {
int n = lua_tointeger(L, idx);
tree = numtree(L, n);
break;
}
case LUA_TBOOLEAN: {
tree = (lua_toboolean(L, idx) ? newleaf(L, TTrue) : newleaf(L, TFalse));
break;
}
case LUA_TTABLE: {
tree = newgrammar(L, idx);
break;
}
case LUA_TFUNCTION: {
tree = newtree(L, 2);
tree->tag = TRunTime;
tree->key = addtonewktable(L, 0, idx);
sib1(tree)->tag = TTrue;
break;
}
default: {
return gettree(L, idx, len);
}
}
lua_replace(L, idx); /* put new tree into 'idx' slot */
if (len)
*len = getsize(L, idx);
return tree;
}
/*
** create a new tree, whith a new root and 2 siblings.
** Siblings must be on the Lua stack, first one at index 1.
*/
static TTree *newroot2sib (lua_State *L, int tag) {
int s1, s2;
TTree *tree1 = getpatt(L, 1, &s1);
TTree *tree2 = getpatt(L, 2, &s2);
TTree *tree = newtree(L, 1 + s1 + s2); /* create new tree */
tree->tag = tag;
tree->u.ps = 1 + s1;
memcpy(sib1(tree), tree1, s1 * sizeof(TTree));
memcpy(sib2(tree), tree2, s2 * sizeof(TTree));
joinktables(L, 1, sib2(tree), 2);
return tree;
}
int read_input() {
failed = 0;
newtree();
for(;;) {
if(scanf("%s", s) != 1) return 0;
if(!strcmp(s, "()")) break;
int v;
sscanf(&s[1], "%d", &v);
addnode(v, strchr(s, ',')+1);
}
return 1;
}
void UpdateConformersFromTree(OBMol* mol, vector<double> &energies, OBDiversePoses* divposes, bool verbose) {
OBDiversePoses::Tree* poses = divposes->GetTree();
double cutoff = divposes->GetCutoff();
vector <OBDiversePoses::PosePair> confs, newconfs;
// The leaf iterator will (in effect) iterate over the nodes just at the loweset level
for (OBDiversePoses::Tree::leaf_iterator node = poses->begin(); node != poses->end(); ++node)
if (node->first.size() > 0) // Don't include the dummy head node
confs.push_back(*node);
// Sort the confs by energy (lowest first)
sort(confs.begin(), confs.end(), sortpred_b);
if(verbose)
cout << "....tree size = " << divposes->GetSize() << " confs = " << confs.size() << "\n";
typedef vector<OBDiversePoses::PosePair> vpp;
// Loop through the confs and filter using a tree
newconfs.clear();
OBDiversePoses newtree(*mol, cutoff, true);
for (vpp::iterator conf = confs.begin(); conf!=confs.end(); ++conf) {
if (newtree.AddPose(conf->first, conf->second)) {
newconfs.push_back(*conf);
}
}
if (verbose)
cout << "....new tree size = " << newtree.GetSize() << " confs = " << newconfs.size() << "\n";
// Add confs to the molecule's conformer data and add the energies to molecules's energies
for (vpp::iterator chosen = newconfs.begin(); chosen!=newconfs.end(); ++chosen) {
energies.push_back(chosen->second);
// To avoid making copies of vectors or vector3s, I am using pointers throughout
vector<vector3> *tmp = &(chosen->first);
double *confCoord = new double [mol->NumAtoms() * 3];
for(unsigned int a = 0; a<mol->NumAtoms(); ++a) {
vector3* pv3 = &(*tmp)[a];
confCoord[a*3] = pv3->x();
confCoord[a*3 + 1] = pv3->y();
confCoord[a*3 + 2] = pv3->z();
}
mol->AddConformer(confCoord);
}
}
tree*
tree3(int type, tree *c0, tree *c1, tree *c2)
{
tree *t;
if(type==';'){
if(c0==0)
return c1;
if(c1==0)
return c0;
}
t = newtree();
t->type = type;
t->child[0] = c0;
t->child[1] = c1;
t->child[2] = c2;
return t;
}
static TTree *newgrammar (lua_State *L, int arg) {
int treesize;
int frule = lua_gettop(L) + 2; /* position of first rule's key */
int n = collectrules(L, arg, &treesize);
TTree *g = newtree(L, treesize);
luaL_argcheck(L, n <= MAXRULES, arg, "grammar has too many rules");
g->tag = TGrammar; g->u.n = n;
lua_newtable(L); /* create 'ktable' */
lua_setfenv(L, -2);
buildgrammar(L, g, frule, n);
lua_getfenv(L, -1); /* get 'ktable' for new tree */
finalfix(L, frule - 1, g, sib1(g));
initialrulename(L, g, frule);
verifygrammar(L, g);
lua_pop(L, 1); /* remove 'ktable' */
lua_insert(L, -(n * 2 + 2)); /* move new table to proper position */
lua_pop(L, n * 2 + 1); /* remove position table + rule pairs */
return g; /* new table at the top of the stack */
}
/*
** [t1 - t2] == Seq (Not t2) t1
** If t1 and t2 are charsets, make their difference.
*/
static int lp_sub (lua_State *L) {
Charset st1, st2;
int s1, s2;
TTree *t1 = getpatt(L, 1, &s1);
TTree *t2 = getpatt(L, 2, &s2);
if (tocharset(t1, &st1) && tocharset(t2, &st2)) {
TTree *t = newcharset(L);
loopset(i, treebuffer(t)[i] = st1.cs[i] & ~st2.cs[i]);
}
else {
TTree *tree = newtree(L, 2 + s1 + s2);
tree->tag = TSeq; /* sequence of... */
tree->u.ps = 2 + s2;
sib1(tree)->tag = TNot; /* ...not... */
memcpy(sib1(sib1(tree)), t2, s2 * sizeof(TTree)); /* ...t2 */
memcpy(sib2(tree), t1, s1 * sizeof(TTree)); /* ... and t1 */
joinktables(L, 1, sib1(tree), 2);
}
return 1;
}
/*
** Create a tree for an empty capture with an associated Lua value
*/
static TTree *newemptycapkey (lua_State *L, int cap, int idx) {
TTree *tree = auxemptycap(newtree(L, 2), cap);
tree->key = addtonewktable(L, 0, idx);
return tree;
}
/*
** Create a tree for an empty capture
*/
static TTree *newemptycap (lua_State *L, int cap) {
return auxemptycap(newtree(L, 2), cap);
}
static TTree *newcharset (lua_State *L) {
TTree *tree = newtree(L, bytes2slots(CHARSETSIZE) + 1);
tree->tag = TSet;
loopset(i, treebuffer(tree)[i] = 0);
return tree;
}
static TTree *newleaf (lua_State *L, int tag) {
TTree *tree = newtree(L, 1);
tree->tag = tag;
return tree;
}
/*
** Create a tree for an empty capture
*/
static TTree *newemptycap (lua_State *L, int cap, int idx) {
return auxemptycap(L, newtree(L, 2), cap, idx);
}
