thing_th *Primordial_Err(thing_th *messages, int shallReg) {
err_th *this_error=calloc(1, sizeof(err_th));
this_error->kind=error_k;
this_error->CAR=Atom("err");
this_error->CDR=messages;
return shallReg ? reg_thing((thing_th *)this_error) : (thing_th *)this_error;
}
thing_th *funky_def(thing_th *args) {
switch(th_kind(Car(args))) {
case atom_k:
return env_set(sym(Car(args)),
define_procedure(Cdr(args)));
case cons_k:
return define_procedure(args);
default:
return Err(Cons(Atom(ERRMSG_TYPES),
Cons(Atom(ERRMSG_BADDEF), NULL)));
}
if(th_kind(Car(args))==atom_k)
return env_set(sym(Car(args)),
define_procedure(Cdr(args)));
return define_procedure(args);
}
static thing_th *dup_cell(thing_th *thing) {
switch(th_kind(thing)) {
case number_k:
return Number(sym(thing));
case string_k:
return String(sym(thing));
case atom_k:
return Atom(sym(thing));
case cons_k:
return Cons(Car(thing), Cdr(thing));
case error_k:
return Err(Cdr(thing));
case procedure_k:
return Proc(Car(thing), Cdr(thing));
case macro_k:
return Mac(Car(thing), Cdr(thing));
case gen_k:
return Gen(Car(thing), Cdr(thing));
case routine_k:
return Routine(call_rt(thing));
case method_k:
return Method(call_rt(thing));
case grid_k:
return duplicate_grid(thing);
case null_k:
return NULL;
}
}
void CheckConnectorUsageMain( CgContext *cg, Symbol *program, Stmt *fStmt)
{
Symbol *outConn, *lSymb;
Type *cType;
int len, cid;
Binding *lBind;
outConn = cg->theHal->varyingOut;
if (!outConn || !outConn->type)
return;
cType = outConn->type;
cid = static_cast< TypeStruct * >( cType )->variety;
len = cg->theHal->GetConnectorRegister(cid, 1, Atom(), NULL);
ApplyToTopExpressions( cg, CheckConnectorUsage, fStmt, NULL, 0);
lSymb = static_cast< TypeStruct * >( cg->theHal->varyingOut->type )->members->symbols;
// This doesn't work! The output value is always written by the return statement! RSG
while (lSymb) {
lBind = lSymb->details.var.bind;
if (lBind) {
if ((lBind->properties & BIND_WRITE_REQUIRED) &&
!(lBind->properties & BIND_WAS_WRITTEN))
{
SemanticWarning( cg, &program->loc, WARNING_S_CMEMBER_NOT_WRITTEN,
cg->GetString( lBind->name ));
}
}
lSymb = lSymb->next;
}
} // CheckConnectorUsageMain
CAMLprim value caml_alloc_dummy_float (value size)
{
mlsize_t wosize = Int_val(size) * Double_wosize;
if (wosize == 0) return Atom(0);
return caml_alloc (wosize, 0);
}
value sys_remove(value name)
{
int ret;
ret = unlink(String_val(name));
if (ret != 0) sys_error(String_val(name));
return Atom(0);
}
HEADER_DECLARE
Term* Spec(atom_t atom, int size){
FRAME_ENTER;
FRAME_LOCAL(tatom) = Atom(atom);
FRAME_LOCAL(tsize) = Integer(size);
FRAME_RETURN(Term*, Functor2(atom_slash, tatom, tsize));
}
static value alloc_host_entry(struct hostent *entry)
{
value res;
value name = Val_unit, aliases = Val_unit;
value addr_list = Val_unit, adr = Val_unit;
Begin_roots4 (name, aliases, addr_list, adr);
name = copy_string((char *)(entry->h_name));
/* PR#4043: protect against buggy implementations of gethostbyname()
that return a NULL pointer in h_aliases */
if (entry->h_aliases)
aliases = copy_string_array((const char**)entry->h_aliases);
else
aliases = Atom(0);
entry_h_length = entry->h_length;
#ifdef h_addr
addr_list = alloc_array(alloc_one_addr, (const char**)entry->h_addr_list);
#else
adr = alloc_one_addr(entry->h_addr);
addr_list = alloc_small(1, 0);
Field(addr_list, 0) = adr;
#endif
res = alloc_small(4, 0);
Field(res, 0) = name;
Field(res, 1) = aliases;
switch (entry->h_addrtype) {
case PF_UNIX: Field(res, 2) = Val_int(0); break;
case PF_INET: Field(res, 2) = Val_int(1); break;
default: /*PF_INET6 */ Field(res, 2) = Val_int(2); break;
}
Field(res, 3) = addr_list;
End_roots();
return res;
}
value blit_string(value s1, value offset1, value s2, value offset2, value len) /* ML */
{
bcopy(&Byte(s1, Long_val(offset1)),
&Byte(s2, Long_val(offset2)),
Int_val(len));
return Atom(0);
}
CAMLprim value caml_alloc_dummy(value size)
{
mlsize_t wosize = Int_val(size);
if (wosize == 0) return Atom(0);
return caml_alloc (wosize, 0);
}
void Parser::atom() {
if (tokens[look].type == REGEX_) {
atoms.push_back(Atom(REG, 0, 0, tokens[look].value, Column()));
match(REGEX_);
} else {
match(LESSTHAN);
if (tokens[look].type == TOKEN) {
match(TOKEN);
} else {
column();
cols[col[1]] = col[0];
atoms.push_back(Atom(COLUMN, 0, 0, col[1], Column()));
}
match(GREATETHAN);
}
}
static inline value copy_string_option_array(const char** strs, int len)
{
if (!len) return Atom(0);
else {
CAMLparam0();
CAMLlocal2(v_str, v_res);
int i;
v_res = caml_alloc(len, 0);
for (i = 0; i < len; ++i) {
const char *str = strs[i];
if (str == NULL) Field(v_res, i) = Val_None;
else {
value v_opt;
v_str = caml_copy_string(str);
v_opt = caml_alloc_small(1, 0);
Field(v_opt, 0) = v_str;
Store_field(v_res, i, v_opt);
}
}
CAMLreturn(v_res);
}
}
CAMLprim value ml_gtk_init (value argv)
{
CAMLparam1 (argv);
int argc = Wosize_val(argv), i;
CAMLlocal1 (copy);
copy = (argc ? alloc (argc, Abstract_tag) : Atom(0));
for (i = 0; i < argc; i++) Field(copy,i) = Field(argv,i);
if( !gtk_init_check (&argc, (char ***)©) ){
ml_raise_gtk ("ml_gtk_init: initialization failed");
}
argv = (argc ? alloc (argc, 0) : Atom(0));
for (i = 0; i < argc; i++) modify(&Field(argv,i), Field(copy,i));
CAMLreturn (argv);
}
Molecule H3()
{
int nAtoms = 3;
Eigen::Vector3d H1( 0.735000, 0.000000, -1.333333);
Eigen::Vector3d H2(-0.735000, 0.000000, -1.333333);
Eigen::Vector3d H3( 0.000000, 0.000000, 2.666667);
Eigen::MatrixXd geom(3, nAtoms);
geom.col(0) = H1.transpose();
geom.col(1) = H2.transpose();
geom.col(2) = H3.transpose();
Eigen::Vector3d charges, masses;
charges << 1.0, 1.0, 1.0;
masses << 1.0078250, 1.0078250, 1.0078250;
std::vector<Atom> atoms;
double radiusH = (1.20 * 1.20) / convertBohrToAngstrom;
atoms.push_back( Atom("Hydrogen", "H", charges(0), masses(0), radiusH, H1, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(1), masses(1), radiusH, H2, 1.0) );
atoms.push_back( Atom("Hydrogen", "H", charges(2), masses(2), radiusH, H3, 1.0) );
std::vector<Sphere> spheres;
Sphere sph2(H1, radiusH);
Sphere sph3(H2, radiusH);
Sphere sph4(H3, radiusH);
spheres.push_back(sph2);
spheres.push_back(sph3);
spheres.push_back(sph4);
enum pointGroup { pgC1, pgC2, pgCs, pgCi, pgD2, pgC2v, pgC2h, pgD2h };
Symmetry pGroup;
switch(group) {
case(pgC1):
pGroup = buildGroup(0, 0, 0, 0);
break;
case(pgC2v):
// C2v as generated by Oyz and Oxz
pGroup = buildGroup(2, 1, 2, 0);
break;
default:
pGroup = buildGroup(0, 0, 0, 0);
break;
}
return Molecule(nAtoms, charges, masses, geom, atoms, spheres, pGroup);
};
value sys_close(value fd)
{
if (close(VAL_TO_INT(fd)) != 0) {
sys_error(NULL);
}
return Atom(0);
}
static thing_th *breakout_character(int inputChar) {
char *label;
thing_th *atom;
asprintf(&label, "%c", inputChar);
atom=Atom(label);
erase_string(label);
return atom;
}
/* ML type : dbconn_ -> dbresultstatus */
EXTERNML value db_resultstatus(value conn) {
MYSQL *mysql = DBconn_val(conn);
switch (mysql_errno(mysql)) {
case ER_EMPTY_QUERY:
return Atom(Empty_query);
case 0: /* No error */
{
/* If mysql_num_fields==0, query was a command */
if (mysql_num_fields(mysql) == 0)
return Atom(Command_ok);
else
return Atom(Tuples_ok);
}
default:
return Atom(Nonfatal_error);
}
}
Residue make_residue(const string &name, const Mat &coords) {
Residue residue;
residue.name = name;
for (int i = 0; i < coords.rows(); i++) {
residue.push_back(Atom(_atom_names[name][i], coords(i, 0), coords(i, 1), coords(i, 2)));
}
return residue;
}
static thing_th *rejigger_with_left_as_cons(thing_th *left,
thing_th *right,
thing_th *bacro) {
thing_th *arg1=Cons(Car(left), Cdr(left));
set_car(left, Atom(sym(bacro)));
set_cdr(left, Cons(arg1, Cons(right, NULL)));
return left;
}
value sys_catch_break(value onoff)
{
if (Tag_val(onoff))
mysignal(SIGINT, intr_handler);
else
mysignal(SIGINT, SIG_DFL);
return Atom(0);
}
/** @see molecule.h */
Molecule::Molecule(int numAtoms, int *Z, double *r3, double *Q) {
for (int i = 0; i < numAtoms; ++i) {
double q = (Q) ? Q[i] : double(Z[i]);
Center center = {{ r3[0+i*3], r3[1+i*3], r3[2+i*3] }};
_atoms.push_back(Atom(Z[i], q));
_centers.push_back(center);
}
}
CAMLprim value unix_environment(value unit)
{
if (environ != NULL) {
return copy_string_array((const char**)environ);
} else {
return Atom(0);
}
}
int AbstractXApplication::exec() {
/* Show window */
XMapWindow(_display, _window);
while(!(_flags & Flag::Exit)) {
XEvent event;
/* Closed window */
if(XCheckTypedWindowEvent(_display, _window, ClientMessage, &event) &&
Atom(event.xclient.data.l[0]) == _deleteWindow) {
return 0;
}
while(XCheckWindowEvent(_display, _window, INPUT_MASK, &event)) {
switch(event.type) {
/* Window resizing */
case ConfigureNotify: {
Vector2i size(event.xconfigure.width, event.xconfigure.height);
if(size != _viewportSize) {
_viewportSize = size;
viewportEvent(size);
_flags |= Flag::Redraw;
}
}
break;
/* Key/mouse events */
case KeyPress:
case KeyRelease: {
KeyEvent e(static_cast<KeyEvent::Key>(XLookupKeysym(&event.xkey, 0)), static_cast<InputEvent::Modifier>(event.xkey.state), {event.xkey.x, event.xkey.y});
event.type == KeyPress ? keyPressEvent(e) : keyReleaseEvent(e);
}
break;
case ButtonPress:
case ButtonRelease: {
MouseEvent e(static_cast<MouseEvent::Button>(event.xbutton.button), static_cast<InputEvent::Modifier>(event.xkey.state), {event.xbutton.x, event.xbutton.y});
event.type == ButtonPress ? mousePressEvent(e) : mouseReleaseEvent(e);
}
break;
/* Mouse move events */
case MotionNotify: {
MouseMoveEvent e(static_cast<InputEvent::Modifier>(event.xmotion.state), {event.xmotion.x, event.xmotion.y});
mouseMoveEvent(e);
}
break;
}
}
if(_flags & Flag::Redraw) {
_flags &= ~Flag::Redraw;
drawEvent();
} else Utility::sleep(5);
}
return 0;
}
Atom Atom::create_impl (T parent, const GAME::Xml::String & kind)
{
// Generate the relative id for the new folder.
size_t counter = parent.relid_counter ();
parent.relid_counter (counter + 1);
// Generate a unique id for the new folder.
return Atom (parent.ptr (), kind, counter);
}
/* ML type : dbconn_ -> dbresultstatus */
EXTERNML value db_resultstatus(value conn) {
MYSQL *mysql = DBconn_val(conn);
switch (mysql_errno(mysql)) {
case ER_EMPTY_QUERY:
return Atom(Empty_query);
case 0: /* No error */
{
/* If mysql_field_count==0, query was a command */
/* 2002-07-25: In MySQL 3.23 and later, must use mysql_field_count */
if (mysql_field_count(mysql) == 0)
return Atom(Command_ok);
else
return Atom(Tuples_ok);
}
default:
return Atom(Nonfatal_error);
}
}
static thing_th *grid_keys(grid_th *grid) {
char **keys=grid_keys_list(grid->data);
char **kw=keys;
thing_th *allKeys;
if(!keys)
return NULL;
if(!*keys) {
wipe_keys_list(keys);
return NULL;
}
allKeys=Cons(Atom(*kw++), NULL);
while(kw && *kw) {
append(allKeys, Cons(Atom(*kw), NULL));
kw++;
}
wipe_keys_list(keys);
return allKeys;
}
Atom get_atom(Residue rd, AtomType at) {
Hierarchy mhd(rd.get_particle());
for (unsigned int i=0; i< mhd.get_number_of_children(); ++i) {
Atom a(mhd.get_child(i));
if (a.get_atom_type() == at) return a;
}
IMP_LOG(VERBOSE, "Atom not found " << at << std::endl);
return Atom();
}
static thing_th *rejigger_with_left_as_atom(thing_th *left,
thing_th *right,
thing_th *bacro) {
thing_th *bcall=Cons(Atom(sym(bacro)),
Cons(Car(left),
Cons(right, NULL)));
set_car(left, bcall);
return left;
}
void
PatchPortModule::store_location()
{
const float x = static_cast<float>(property_x());
const float y = static_cast<float>(property_y());
const LV2URIMap& uris = App::instance().uris();
const Atom& existing_x = _model->get_property(uris.ingenui_canvas_x);
const Atom& existing_y = _model->get_property(uris.ingenui_canvas_y);
if (existing_x.type() != Atom::FLOAT || existing_y.type() != Atom::FLOAT
|| existing_x.get_float() != x || existing_y.get_float() != y) {
Resource::Properties props;
props.insert(make_pair(uris.ingenui_canvas_x, Atom(x)));
props.insert(make_pair(uris.ingenui_canvas_y, Atom(y)));
App::instance().engine()->put(_model->path(), props, Resource::INTERNAL);
}
}
static int establish_bacros(thing_th *bacroGrid) {
if(!bacroGrid) return 1;
Set(bacroGrid, "~>", Atom("rapply"));
Set(bacroGrid, "<~", Atom("safely-apply"));
Set(bacroGrid, "->", Atom("rcall"));
Set(bacroGrid, "<-", Atom("call"));
Set(bacroGrid, "<S", Atom("strict-apply"));
Set(bacroGrid, "S>", Atom("strict-rapply"));
Set(bacroGrid, ":", Atom("pair"));
Set(bacroGrid, ".", Atom("get"));
return 0;
}