/* \return an array of Atoms from the current frame.
* Assumes file has already been opened.
*/
std::vector<Atom> TinkerFile::ReadTinkerAtoms(double* XYZ, std::vector<int>& bonds)
{
std::vector<Atom> atoms;
if (XYZ == 0) {
mprinterr("Internal Error: No space allocated for reading Tinker atom coordinates.\n");
return atoms;
}
// Title line
if (file_.Line() == 0) return atoms;
if (CheckTitleLine()) return atoms;
// Box line
if (hasBox_) {
if (file_.Line() == 0) return atoms;
}
// Read atoms
atoms.reserve( natom_ );
for (int atidx = 0; atidx < natom_; atidx++) {
if (file_.Line() == 0) return std::vector<Atom>(0);
int ncol = file_.TokenizeLine(" ");
if (ncol < 6) {
mprinterr("Error: In Tinker file line %i expected at least 5 columns for atom, got %i\n",
file_.LineNumber(), ncol);
return std::vector<Atom>(0);
}
file_.NextToken(); // Atom index
NameType atom_name( file_.NextToken() );
XYZ[0] = atof( file_.NextToken() ); // X
XYZ[1] = atof( file_.NextToken() ); // Y
XYZ[2] = atof( file_.NextToken() ); // Z
XYZ += 3;
const char* at_type_ptr = file_.NextToken(); // Atom Type Index
int atom_type_index = atoi( at_type_ptr );
NameType atom_type( at_type_ptr );
// Read in any bonded partners.
for (int col = 6; col != ncol; col++) {
int bonded_atom = atoi(file_.NextToken()) - 1; // Tinker atoms start from 1
if (atidx < bonded_atom) {
bonds.push_back( atidx );
bonds.push_back( bonded_atom );
}
}
atoms.push_back( Atom(atom_name, atom_type, atom_type_index) );
}
return atoms;
}
bool binspector_parser_t::is_typedef()
{
adobe::name_t named_field_identifier;
atom_base_type_t atom_type(atom_unknown_k);
adobe::array_t bit_count_expression;
adobe::array_t is_big_endian_expression;
adobe::name_t new_type_identifier;
if (!is_keyword(key_typedef))
return false;
if (!is_field_type(named_field_identifier,
atom_type,
bit_count_expression,
is_big_endian_expression))
throw_exception("Field type expected");
require_identifier(new_type_identifier);
adobe::dictionary_t parameters;
parameters[key_field_name].assign(new_type_identifier);
parameters[key_field_size_type].assign(field_size_none_k); // intentionally fixed
parameters[key_field_size_expression].assign(adobe::array_t()); // intentionally fixed
parameters[key_field_offset_expression].assign(adobe::array_t()); // intentionally fixed
if (named_field_identifier != adobe::name_t())
{
parameters[key_field_type].assign(value_field_type_typedef_named);
parameters[key_named_type_name].assign(named_field_identifier);
}
else
{
parameters[key_field_type].assign(value_field_type_typedef_atom);
parameters[key_atom_base_type].assign(atom_type);
parameters[key_atom_bit_count_expression].assign(bit_count_expression);
parameters[key_atom_is_big_endian_expression].assign(is_big_endian_expression);
}
insert_parser_metadata(parameters);
add_typedef_proc_m(new_type_identifier, parameters);
return true;
}
sql_subtype *
exp_subtype( sql_exp *e )
{
switch(e->type) {
case e_atom: {
if (e->l) {
atom *a = e->l;
return atom_type(a);
} else if (e->tpe.type) { /* atom reference */
return &e->tpe;
}
break;
}
case e_convert:
case e_column:
if (e->tpe.type)
return &e->tpe;
break;
case e_aggr: {
sql_subaggr *a = e->f;
return &a->res;
}
case e_func: {
if (e->f) {
sql_subfunc *f = e->f;
return &f->res;
}
return NULL;
}
case e_cmp:
/* return bit */
default:
return NULL;
}
return NULL;
}
bool binspector_parser_t::is_field()
{
adobe::name_t named_field_identifier;
atom_base_type_t atom_type(atom_unknown_k);
adobe::array_t bit_count_expression;
adobe::array_t is_big_endian_expression;
bool named_field(is_named_field(named_field_identifier));
bool atom_field(!named_field &&
is_atom_field(atom_type,
bit_count_expression,
is_big_endian_expression));
if (!named_field && !atom_field)
return false;
adobe::name_t field_identifier;
require_identifier(field_identifier);
adobe::array_t field_size_expression;
field_size_t field_size_type(field_size_none_k);
adobe::array_t offset_expression;
adobe::array_t callback_expression;
bool shuffleable(false);
is_field_size(field_size_type, field_size_expression, shuffleable); // optional
is_offset(offset_expression); // optional
try
{
static const adobe::array_t empty_array_k;
adobe::dictionary_t parameters;
parameters[key_field_name].assign(field_identifier);
parameters[key_field_size_type].assign(field_size_type);
parameters[key_field_size_expression].assign(field_size_expression);
parameters[key_field_offset_expression].assign(offset_expression);
parameters[key_field_shuffle].assign(shuffleable);
// add the field to the current structure description
if (named_field)
{
parameters[key_field_type].assign(value_field_type_named);
parameters[key_named_type_name].assign(named_field_identifier);
}
else
{
parameters[key_field_type].assign(value_field_type_atom);
parameters[key_atom_base_type].assign(atom_type);
parameters[key_atom_bit_count_expression].assign(bit_count_expression);
parameters[key_atom_is_big_endian_expression].assign(is_big_endian_expression);
}
insert_parser_metadata(parameters);
add_field_proc_m(field_identifier, parameters);
}
catch (const std::exception& error)
{
putback();
throw adobe::stream_error_t(error, next_position());
}
return true;
}
/*
* Execution of the SQL program is delegated to the MALengine.
* Different cases should be distinguished. The default is to
* hand over the MAL block derived by the parser for execution.
* However, when we received an Execute call, we make a shortcut
* and prepare the stack for immediate execution
*/
str
SQLexecutePrepared(Client c, backend *be, cq *q)
{
mvc *m = be->mvc;
int argc, parc;
ValPtr *argv, argvbuffer[MAXARG], v;
ValRecord *argrec, argrecbuffer[MAXARG];
MalBlkPtr mb;
MalStkPtr glb;
InstrPtr pci;
int i;
str ret;
Symbol qcode = q->code;
if (!qcode || qcode->def->errors) {
if (!qcode && *m->errstr)
return createException(PARSE, "SQLparser", "%s", m->errstr);
throw(SQL, "SQLengine", "39000!program contains errors");
}
mb = qcode->def;
pci = getInstrPtr(mb, 0);
if (pci->argc >= MAXARG)
argv = (ValPtr *) GDKmalloc(sizeof(ValPtr) * pci->argc);
else
argv = argvbuffer;
if (pci->retc >= MAXARG)
argrec = (ValRecord *) GDKmalloc(sizeof(ValRecord) * pci->retc);
else
argrec = argrecbuffer;
/* prepare the target variables */
for (i = 0; i < pci->retc; i++) {
argv[i] = argrec + i;
argv[i]->vtype = getVarGDKType(mb, i);
}
argc = m->argc;
parc = q->paramlen;
if (argc != parc) {
if (pci->argc >= MAXARG)
GDKfree(argv);
if (pci->retc >= MAXARG)
GDKfree(argrec);
throw(SQL, "sql.prepare", "07001!EXEC: wrong number of arguments for prepared statement: %d, expected %d", argc, parc);
} else {
for (i = 0; i < m->argc; i++) {
atom *arg = m->args[i];
sql_subtype *pt = q->params + i;
if (!atom_cast(arg, pt)) {
/*sql_error(c, 003, buf); */
if (pci->argc >= MAXARG)
GDKfree(argv);
if (pci->retc >= MAXARG)
GDKfree(argrec);
throw(SQL, "sql.prepare", "07001!EXEC: wrong type for argument %d of " "prepared statement: %s, expected %s", i + 1, atom_type(arg)->type->sqlname, pt->type->sqlname);
}
argv[pci->retc + i] = &arg->data;
}
}
glb = (MalStkPtr) (q->stk);
ret = callMAL(c, mb, &glb, argv, (m->emod & mod_debug ? 'n' : 0));
/* cleanup the arguments */
for (i = pci->retc; i < pci->argc; i++) {
garbageElement(c, v = &glb->stk[pci->argv[i]]);
v->vtype = TYPE_int;
v->val.ival = int_nil;
}
if (glb && ret) /* error */
garbageCollector(c, mb, glb, glb != 0);
q->stk = (backend_stack) glb;
if (glb && SQLdebug & 1)
printStack(GDKstdout, mb, glb);
if (pci->argc >= MAXARG)
GDKfree(argv);
if (pci->retc >= MAXARG)
GDKfree(argrec);
return ret;
}
