/* \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; }