{

load_singular_library (lib);

idhdl h = ggetid (fun.c_str());

if (h == NULL)

{

throw std::runtime_error ("procedure " + fun + " not available in " + lib);

}

return h;

{

scoped_leftv (int c, void* data)

: _ (static_cast<leftv> (omAlloc0Bin (sleftv_bin))) // TODO check result

{

_->rtyp = c;

_->data = data;

}

scoped_leftv (scoped_leftv& parent, int c, void* data)

: scoped_leftv (c, data)

{

chained = true;

parent._->next = _;

}

~scoped_leftv()

{

if (!chained)

{

_->CleanUp();

omFreeBin (_, sleftv_bin);

}

};

scoped_leftv (scoped_leftv const&) = delete;

scoped_leftv (scoped_leftv&&) = delete;

scoped_leftv& operator= (scoped_leftv const&) = delete;

scoped_leftv& operator= (scoped_leftv&&) = delete;

leftv _;

bool chained = false;

{

BOOLEAN const res (iiMake_proc (h, NULL, arg._));

if (res)

{

throw std::runtime_error ("call to procedure " + std::string (h->id)

+ " failed");

}

R const r = static_cast<R> (iiRETURNEXPR.Data());

int const i = iiRETURNEXPR.Typ();

iiRETURNEXPR.data = NULL;

iiRETURNEXPR.CleanUp();

return std::make_pair (i, r);

{

if (currPack == NULL) // use this to check if this instance has already been

// initializied

{

mp_set_memory_functions (omMallocFunc, omReallocSizeFunc, omFreeSizeFunc);

siInit (const_cast<char*> (library_path.c_str()));

currentVoice = feInitStdin (NULL);

errorreported = 0;

myynest = 1;

}

{

char *s = omStrDup (library_name.c_str());

BOOLEAN res = iiGetLibStatus (s);

if (res == TRUE) // already loaded

{

omFree (s);

return;

}

res = iiLibCmd (s, TRUE, FALSE, FALSE); // also frees s

if (res)

{

throw std::runtime_error ("could not load library " + library_name);

}

{

int tok;

int cmd_result = blackboxIsCmd (name.c_str(), tok);

if (cmd_result == ROOT_DECL)

{

return true; // already exists

}

newstruct_desc d = newstructFromString (desc.c_str());

if (d == NULL)

{

return false;

}

newstruct_setup (name.c_str(), d); // is void function

return true;

{

si_link l = static_cast<si_link> (omAlloc0Bin (sip_link_bin));

l->name = omStrDup (ssi_filename.c_str());

l->mode = omStrDup ("r");

l->ref = 1;

si_link_extension ns = static_cast<si_link_extension>

(omAlloc0Bin (s_si_link_extension_bin));

ns = slInitSsiExtension (ns);

l->m = ns; // originally, Singular has a global list of "extensions"

// we use a private copy for now

BOOLEAN res = l->m->Open (l, SI_LINK_READ, NULL);

if (res)

{

throw std::runtime_error ("could not open ssi file " + ssi_filename);

}

ssiInfo *d = static_cast<ssiInfo*> (l->data);

int t = s_readint (d->f_read); // SSI version info in first line

if (t != 98)

{

std::string error_msg = "wrong token, got " + std::to_string (t);

throw std::runtime_error (error_msg);

}

int n98_v, n98_m;

BITSET n98_o1, n98_o2;

n98_v = s_readint (d->f_read);

n98_m = s_readint (d->f_read);

n98_o1 = s_readint (d->f_read);

n98_o2 = s_readint (d->f_read);

if ((n98_v != SSI_VERSION) || (n98_m != MAX_TOK))

{

std::string error_msg = "incompatible versions of ssi: expected "

+ std::to_string (SSI_VERSION) + '/' + std::to_string (MAX_TOK)

+ " got " + std::to_string (n98_v) + '/' + std::to_string (n98_m);

throw std::runtime_error (error_msg);

}

si_opt_1 = n98_o1; // do I want to set these global options?

si_opt_2 = n98_o2;

return l;

{

si_link l = static_cast<si_link> (omAlloc0Bin (sip_link_bin));

l->name = omStrDup (ssi_filename.c_str());

l->mode = omStrDup ("w");

l->ref = 1;

si_link_extension ns = static_cast<si_link_extension>

(omAlloc0Bin (s_si_link_extension_bin));

ns = slInitSsiExtension (ns);

l->m = ns;

BOOLEAN res = l->m->Open (l, SI_LINK_WRITE, NULL);

// this already writes the parameter line "98 ..."

if (res)

{

throw std::runtime_error ("could not open ssi file " + ssi_filename

+ " for write");

}

return l;

{

// it seems that PrepClose is not used (not set) for ssi links

BOOLEAN res = l->m->Close (l); // this frees l->d

if (res)

{

throw std::runtime_error ("closing ssi link failed");

}

omFree (static_cast<ADDRESS> (l->name));

omFree (static_cast<ADDRESS> (l->mode));

omFreeBin (l->m, s_si_link_extension_bin);

omFreeBin (l, sip_link_bin);

{

int type;

blackboxIsCmd (struct_name.c_str(), type); // TODO check for success

ssi_write_newstruct (l, type, lst);

{

ssiInfo *d = static_cast<ssiInfo*> (l->data);

blackbox *b = getBlackboxStuff (type); // TODO check for success

fputs ("20 ", d->f_write);

newstruct_serialize (b, lst, l);

{

ssiInfo *d = static_cast<ssiInfo*> (l->data);

int t = s_readint (d->f_read);

if (t != 20)

{

std::string error_msg = "wrong token, expected 20 got "

+ std::to_string (t);

throw std::runtime_error (error_msg);

}

/*int ignore =*/ s_readint (d->f_read);

char* name = ssiReadString (d);

if (struct_name.compare (name) != 0)

{

std::string error_msg = "wrong blackbox name, expected " + struct_name

+ " got " + std::string (name);

throw std::runtime_error (error_msg);

}

int tok;

blackboxIsCmd (name, tok);

omFree(name);

if (tok <= MAX_TOK)

{

std::string error_msg = "token " + std::to_string (tok)

+ " is not larger than MAX_TOX " + std::to_string (MAX_TOK);

throw std::runtime_error (error_msg);

}

lists li;

newstruct_deserialize (NULL, reinterpret_cast<void**> (&li), l);

return li;

std::string const& needed_library, int in_type, lists in_lst)

{

scoped_leftv arg (in_type, lCopy (in_lst));

return proc<lists> (symbol (needed_library, function_name), arg);

{

ssiInfo *d = static_cast<ssiInfo*> (l->data);

int res = is_setring ? fputs ("15 ", d->f_write) : fputs ("5 ", d->f_write);

if (res <= 0)

{

throw std::runtime_error ("ssi write of ring failed");

}

ssiWriteRing_R (d, r); // void function

fputc ('\n', d->f_write);

fflush (d->f_write);

{

// does not write ring first

ssiInfo *d = static_cast<ssiInfo*> (l->data);

int res = fputs ("7 ", d->f_write);

if (res <= 0)

{

throw std::runtime_error ("ssi write of ideal failed");

}

ssiWriteIdeal_R (d, IDEAL_CMD, I, r); // is void function

fputc ('\n', d->f_write);

fflush (d->f_write);

{

// for non-ring-dependent list

ssiInfo *d = static_cast<ssiInfo*> (l->data);

int res = fputs ("14 ", d->f_write);

if (res <= 0)

{

throw std::runtime_error ("ssi write of list failed");

}

ssiWriteList (l, lst),

//fputc ('\n', d->f_write);

fflush (d->f_write);

{

ssiInfo *d = static_cast<ssiInfo*> (l->data);

int res = fputs ("18 ", d->f_write);

if (res <= 0)

{

throw std::runtime_error ("ssi write of intmat failed");

}

ssiWriteIntmat (d, iv); // is void function

fputc ('\n', d->f_write);

fflush (d->f_write);