void
loop(int toplevel)
{
List list;
#ifdef DEBUG
int oasp = toplevel ? 0 : alloc_stackp;
#endif
pushheap();
for (;;) {
freeheap();
errflag = 0;
if (interact && isset(SHINSTDIN))
preprompt();
hbegin(); /* init history mech */
intr(); /* interrupts on */
lexinit(); /* initialize lexical state */
if (!(list = parse_event())) { /* if we couldn't parse a list */
hend();
if (tok == ENDINPUT && !errflag)
break;
continue;
}
if (hend()) {
int toksav = tok;
if (stopmsg) /* unset 'you have stopped jobs' flag */
stopmsg--;
execlist(list, 0, 0);
tok = toksav;
if (toplevel)
noexitct = 0;
}
DPUTS(alloc_stackp != oasp, "BUG: alloc_stackp changed in loop()");
if (ferror(stderr)) {
zerr("write error", NULL, 0);
clearerr(stderr);
}
if (subsh) /* how'd we get this far in a subshell? */
exit(lastval);
if (((!interact || sourcelevel) && errflag) || retflag)
break;
if (trapreturn) {
lastval = trapreturn;
trapreturn = 0;
}
if (isset(SINGLECOMMAND) && toplevel) {
if (sigtrapped[SIGEXIT])
dotrap(SIGEXIT);
exit(lastval);
}
}
popheap();
}
enum loop_return
loop(int toplevel, int justonce)
{
Eprog prog;
int err, non_empty = 0;
queue_signals();
pushheap();
if (!toplevel)
zcontext_save();
for (;;) {
freeheap();
if (stophist == 3) /* re-entry via preprompt() */
hend(NULL);
hbegin(1); /* init history mech */
if (isset(SHINSTDIN)) {
setblock_stdin();
if (interact && toplevel) {
int hstop = stophist;
stophist = 3;
/*
* Reset all errors including the interrupt error status
* immediately, so preprompt runs regardless of what
* just happened. We'll reset again below as a
* precaution to ensure we get back to the command line
* no matter what.
*/
errflag = 0;
preprompt();
if (stophist != 3)
hbegin(1);
else
stophist = hstop;
/*
* Reset all errors, including user interupts.
* This is what allows ^C in an interactive shell
* to return us to the command line.
*/
errflag = 0;
}
}
use_exit_printed = 0;
intr(); /* interrupts on */
lexinit(); /* initialize lexical state */
if (!(prog = parse_event(ENDINPUT))) {
/* if we couldn't parse a list */
hend(NULL);
if ((tok == ENDINPUT && !errflag) ||
(tok == LEXERR && (!isset(SHINSTDIN) || !toplevel)) ||
justonce)
break;
if (exit_pending) {
/*
* Something down there (a ZLE function?) decided
* to exit when there was stuff to clear up.
* Handle that now.
*/
stopmsg = 1;
zexit(exit_pending >> 1, 0);
}
if (tok == LEXERR && !lastval)
lastval = 1;
continue;
}
if (hend(prog)) {
enum lextok toksav = tok;
non_empty = 1;
if (toplevel &&
(getshfunc("preexec") ||
paramtab->getnode(paramtab, "preexec" HOOK_SUFFIX))) {
LinkList args;
char *cmdstr;
/*
* As we're about to freeheap() or popheap()
* anyway, there's no gain in using permanent
* storage here.
*/
args = newlinklist();
addlinknode(args, "preexec");
/* If curline got dumped from the history, we don't know
* what the user typed. */
if (hist_ring && curline.histnum == curhist)
addlinknode(args, hist_ring->node.nam);
else
addlinknode(args, "");
addlinknode(args, dupstring(getjobtext(prog, NULL)));
addlinknode(args, cmdstr = getpermtext(prog, NULL, 0));
callhookfunc("preexec", args, 1, NULL);
/* The only permanent storage is from getpermtext() */
zsfree(cmdstr);
/*
* Note this does *not* remove a user interrupt error
* condition, even though we're at the top level loop:
* that would be inconsistent with the case where
* we didn't execute a preexec function. This is
* an implementation detail that an interrupting user
* does't care about.
*/
errflag &= ~ERRFLAG_ERROR;
}
if (stopmsg) /* unset 'you have stopped jobs' flag */
stopmsg--;
execode(prog, 0, 0, toplevel ? "toplevel" : "file");
tok = toksav;
if (toplevel)
noexitct = 0;
}
if (ferror(stderr)) {
zerr("write error");
clearerr(stderr);
}
if (subsh) /* how'd we get this far in a subshell? */
exit(lastval);
if (((!interact || sourcelevel) && errflag) || retflag)
break;
if (isset(SINGLECOMMAND) && toplevel) {
dont_queue_signals();
if (sigtrapped[SIGEXIT])
dotrap(SIGEXIT);
exit(lastval);
}
if (justonce)
break;
}
static int
bin_vared(char *name, char **args, Options ops, UNUSED(int func))
{
char *s, *t, *ova = varedarg;
struct value vbuf;
Value v;
Param pm = 0;
int ifl;
int type = PM_SCALAR, obreaks = breaks, haso = 0, oSHTTY = 0;
char *p1, *p2, *main_keymapname, *vicmd_keymapname, *init, *finish;
Keymap main_keymapsave = NULL, vicmd_keymapsave = NULL;
FILE *oshout = NULL;
if ((interact && unset(USEZLE)) || !strcmp(term, "emacs")) {
zwarnnam(name, "ZLE not enabled");
return 1;
}
if (zleactive) {
zwarnnam(name, "ZLE cannot be used recursively (yet)");
return 1;
}
if (OPT_ISSET(ops,'A'))
{
if (OPT_ISSET(ops, 'a'))
{
zwarnnam(name, "specify only one of -a and -A");
return 1;
}
type = PM_HASHED;
}
else if (OPT_ISSET(ops,'a'))
type = PM_ARRAY;
p1 = OPT_ARG_SAFE(ops,'p');
p2 = OPT_ARG_SAFE(ops,'r');
main_keymapname = OPT_ARG_SAFE(ops,'M');
vicmd_keymapname = OPT_ARG_SAFE(ops,'m');
init = OPT_ARG_SAFE(ops,'i');
finish = OPT_ARG_SAFE(ops,'f');
if (type != PM_SCALAR && !OPT_ISSET(ops,'c')) {
zwarnnam(name, "-%s ignored", type == PM_ARRAY ? "a" : "A");
}
/* handle non-existent parameter */
s = args[0];
queue_signals();
v = fetchvalue(&vbuf, &s, (!OPT_ISSET(ops,'c') || type == PM_SCALAR),
SCANPM_WANTKEYS|SCANPM_WANTVALS|SCANPM_MATCHMANY);
if (!v && !OPT_ISSET(ops,'c')) {
unqueue_signals();
zwarnnam(name, "no such variable: %s", args[0]);
return 1;
} else if (v) {
if (*s) {
zwarnnam(name, "not an identifier: `%s'", args[0]);
return 1;
}
if (v->isarr) {
/* Array: check for separators and quote them. */
char **arr = getarrvalue(v), **aptr, **tmparr, **tptr;
tptr = tmparr = (char **)zhalloc(sizeof(char *)*(arrlen(arr)+1));
for (aptr = arr; *aptr; aptr++) {
int sepcount = 0, clen;
convchar_t c;
/*
* See if this word contains a separator character
* or backslash
*/
MB_METACHARINIT();
for (t = *aptr; *t; ) {
if (*t == '\\') {
t++;
sepcount++;
} else {
t += MB_METACHARLENCONV(t, &c);
if (WC_ZISTYPE(c, ISEP))
sepcount++;
}
}
if (sepcount) {
/* Yes, so allocate enough space to quote it. */
char *newstr, *nptr;
newstr = zhalloc(strlen(*aptr)+sepcount+1);
/* Go through string quoting separators */
MB_METACHARINIT();
for (t = *aptr, nptr = newstr; *t; ) {
if (*t == '\\') {
*nptr++ = '\\';
*nptr++ = *t++;
} else {
clen = MB_METACHARLENCONV(t, &c);
if (WC_ZISTYPE(c, ISEP))
*nptr++ = '\\';
while (clen--)
*nptr++ = *t++;
}
}
*nptr = '\0';
/* Stick this into the array of words to join up */
*tptr++ = newstr;
} else
*tptr++ = *aptr; /* No, keep original array element */
}
*tptr = NULL;
s = sepjoin(tmparr, NULL, 0);
} else {
s = ztrdup(getstrvalue(v));
}
unqueue_signals();
} else if (*s) {
unqueue_signals();
zwarnnam(name, "invalid parameter name: %s", args[0]);
return 1;
} else {
unqueue_signals();
s = ztrdup(s);
}
if (SHTTY == -1 || OPT_ISSET(ops,'t')) {
/* need to open /dev/tty specially */
oSHTTY = SHTTY;
if ((SHTTY = open(OPT_ISSET(ops,'t') ? OPT_ARG(ops,'t') : "/dev/tty",
O_RDWR|O_NOCTTY)) == -1) {
zwarnnam(name, "can't access terminal");
zsfree(s);
return 1;
}
if (!isatty(SHTTY)) {
zwarnnam(name, "%s: not a terminal", OPT_ARG(ops,'t'));
close(SHTTY);
SHTTY = oSHTTY;
zsfree(s);
return 1;
}
oshout = shout;
init_shout();
haso = 1;
}
/* edit the parameter value */
zpushnode(bufstack, s);
if (main_keymapname &&
savekeymap(name, "main", main_keymapname, &main_keymapsave))
main_keymapname = NULL;
if (vicmd_keymapname &&
savekeymap(name, "vicmd", vicmd_keymapname, &vicmd_keymapsave))
vicmd_keymapname = NULL;
varedarg = *args;
ifl = isfirstln;
if (OPT_ISSET(ops,'h'))
hbegin(2);
isfirstln = OPT_ISSET(ops,'e');
t = zleread(&p1, &p2, OPT_ISSET(ops,'h') ? ZLRF_HISTORY : 0, ZLCON_VARED,
init ? init : "zle-line-init",
finish ? finish : "zle-line-finish");
if (OPT_ISSET(ops,'h'))
hend(NULL);
isfirstln = ifl;
varedarg = ova;
restorekeymap(name, "main", main_keymapname, main_keymapsave);
restorekeymap(name, "vicmd", vicmd_keymapname, vicmd_keymapsave);
if (haso) {
fclose(shout); /* close(SHTTY) */
shout = oshout;
SHTTY = oSHTTY;
}
if (!t || errflag) {
/* error in editing */
errflag &= ~ERRFLAG_ERROR;
breaks = obreaks;
if (t)
zsfree(t);
return 1;
}
/* strip off trailing newline, if any */
if (t[strlen(t) - 1] == '\n')
t[strlen(t) - 1] = '\0';
/* final assignment of parameter value */
if (OPT_ISSET(ops,'c')) {
unsetparam(args[0]);
createparam(args[0], type);
}
queue_signals();
pm = (Param) paramtab->getnode(paramtab, args[0]);
if (pm && (PM_TYPE(pm->node.flags) & (PM_ARRAY|PM_HASHED))) {
char **a;
/*
* Use spacesplit with fourth argument 1: identify quoted separators,
* and unquote. This duplicates the string, so we still need to free.
*/
a = spacesplit(t, 1, 0, 1);
zsfree(t);
if (PM_TYPE(pm->node.flags) == PM_ARRAY)
setaparam(args[0], a);
else
sethparam(args[0], a);
} else
setsparam(args[0], t);
unqueue_signals();
return 0;
}
void
loop(int toplevel, int justonce)
{
List list;
#ifdef DEBUG
int oasp = toplevel ? 0 : alloc_stackp;
#endif
pushheap();
for (;;) {
freeheap();
errflag = 0;
if (isset(SHINSTDIN)) {
setblock_stdin();
if (interact)
preprompt();
}
hbegin(); /* init history mech */
intr(); /* interrupts on */
lexinit(); /* initialize lexical state */
if (!(list = parse_event())) { /* if we couldn't parse a list */
hend();
if ((tok == ENDINPUT && !errflag) || justonce)
break;
continue;
}
if (hend()) {
int toksav = tok;
List prelist;
if (toplevel && (prelist = getshfunc("preexec")) != &dummy_list) {
Histent he = gethistent(curhist);
LinkList args;
PERMALLOC {
args = newlinklist();
addlinknode(args, "preexec");
if (he && he->text)
addlinknode(args, he->text);
} LASTALLOC;
doshfunc(prelist, args, 0, 1);
freelinklist(args, (FreeFunc) NULL);
errflag = 0;
}
if (stopmsg) /* unset 'you have stopped jobs' flag */
stopmsg--;
execlist(list, 0, 0);
tok = toksav;
if (toplevel)
noexitct = 0;
}
DPUTS(alloc_stackp != oasp, "BUG: alloc_stackp changed in loop()");
if (ferror(stderr)) {
zerr("write error", NULL, 0);
clearerr(stderr);
}
if (subsh) /* how'd we get this far in a subshell? */
exit(lastval);
if (((!interact || sourcelevel) && errflag) || retflag)
break;
if (trapreturn) {
lastval = trapreturn;
trapreturn = 0;
}
if (isset(SINGLECOMMAND) && toplevel) {
if (sigtrapped[SIGEXIT])
dotrap(SIGEXIT);
exit(lastval);
}
if (justonce)
break;
}
enum loop_return
loop(int toplevel, int justonce)
{
Eprog prog;
int err, non_empty = 0;
pushheap();
if (!toplevel)
lexsave();
for (;;) {
freeheap();
if (stophist == 3) /* re-entry via preprompt() */
hend(NULL);
hbegin(1); /* init history mech */
if (isset(SHINSTDIN)) {
setblock_stdin();
if (interact && toplevel) {
int hstop = stophist;
stophist = 3;
preprompt();
if (stophist != 3)
hbegin(1);
else
stophist = hstop;
errflag = 0;
}
}
use_exit_printed = 0;
intr(); /* interrupts on */
lexinit(); /* initialize lexical state */
if (!(prog = parse_event())) { /* if we couldn't parse a list */
hend(NULL);
if ((tok == ENDINPUT && !errflag) ||
(tok == LEXERR && (!isset(SHINSTDIN) || !toplevel)) ||
justonce)
break;
if (exit_pending) {
/*
* Something down there (a ZLE function?) decided
* to exit when there was stuff to clear up.
* Handle that now.
*/
stopmsg = 1;
zexit(exit_pending >> 1, 0);
}
if (tok == LEXERR && !lastval)
lastval = 1;
continue;
}
if (hend(prog)) {
int toksav = tok;
non_empty = 1;
if (toplevel &&
(getshfunc("preexec") ||
paramtab->getnode(paramtab, "preexec" HOOK_SUFFIX))) {
LinkList args;
char *cmdstr;
/*
* As we're about to freeheap() or popheap()
* anyway, there's no gain in using permanent
* storage here.
*/
args = newlinklist();
addlinknode(args, "preexec");
/* If curline got dumped from the history, we don't know
* what the user typed. */
if (hist_ring && curline.histnum == curhist)
addlinknode(args, hist_ring->node.nam);
else
addlinknode(args, "");
addlinknode(args, dupstring(getjobtext(prog, NULL)));
addlinknode(args, cmdstr = getpermtext(prog, NULL, 0));
callhookfunc("preexec", args, 1, NULL);
/* The only permanent storage is from getpermtext() */
zsfree(cmdstr);
errflag = 0;
}
if (stopmsg) /* unset 'you have stopped jobs' flag */
stopmsg--;
execode(prog, 0, 0, toplevel ? "toplevel" : "file");
tok = toksav;
if (toplevel)
noexitct = 0;
}
if (ferror(stderr)) {
zerr("write error");
clearerr(stderr);
}
if (subsh) /* how'd we get this far in a subshell? */
exit(lastval);
if (((!interact || sourcelevel) && errflag) || retflag)
break;
if (isset(SINGLECOMMAND) && toplevel) {
if (sigtrapped[SIGEXIT])
dotrap(SIGEXIT);
exit(lastval);
}
if (justonce)
break;
}
TrianglesList meshSimplification(TrianglesList &triangles, int stopPredicate) {
#ifdef MESHSIMPLIFICATION_LOG
CGAL::Timer timer;
timer.start();
#endif
TrianglesList result;
try
{
Polyhedron P;
#ifdef MESHSIMPLIFICATION_LOG
std::cout << "Start Building Polyhedron surface... " << std::endl;
#endif
Build_triangle_mesh_coherent_surface<HalfedgeDS> triangle(triangles);
P.delegate(triangle);
P.normalize_border();
#ifdef MESHSIMPLIFICATION_LOG
std::cout << "Completed Building Polyhedron surface:" << std::endl;
std::cout << "Polyhedron is_pure_triangle: " << P.is_pure_triangle() << std::endl;
std::cout << "Polyhedron is_closed: " << P.is_closed() << std::endl;
std::cout << "Polyhedron is_pure_bivalent : " << P.is_pure_bivalent () << std::endl;
std::cout << "Polyhedron is_pure_trivalent: " << P.is_pure_trivalent() << std::endl;
std::cout << "Polyhedron is_valid 0: " << P.is_valid(false, 0) << std::endl;
std::cout << "Polyhedron is_valid 1: " << P.is_valid(false, 1) << std::endl;
std::cout << "Polyhedron is_valid 2: " << P.is_valid(false, 2) << std::endl;
std::cout << "Polyhedron is_valid 3: " << P.is_valid(false, 3) << std::endl;
std::cout << "Polyhedron is_valid 4: " << P.is_valid(false, 4) << std::endl;
std::cout << "Polyhedron normalized_border_is_valid : " << P.normalized_border_is_valid(false) << std::endl;
#endif
#ifdef MESHSIMPLIFICATION_LOG
std::cout << "Start edge_collapse... " << std::endl;
#endif
SMS::Count_stop_predicate<Polyhedron> stop(stopPredicate);
int removedEdges = SMS::edge_collapse(P, stop,
CGAL::vertex_index_map(boost::get(CGAL::vertex_external_index, P)).edge_index_map(boost::get(CGAL::edge_external_index ,P))
);
#ifdef MESHSIMPLIFICATION_LOG
std::cout << "Completed edge_collapse:" << std::endl;
std::cout << "Finished with: " << removedEdges << " edges removed and " << (P.size_of_halfedges()/2) << " final edges." << std::endl;
#endif
//Build output result
for ( Polyhedron::Facet_iterator fit( P.facets_begin() ), fend( P.facets_end() ); fit != fend; ++fit )
{
if ( fit->is_triangle() )
{
PointCGAL verts[3];
int tick = 0;
Polyhedron::Halfedge_around_facet_circulator hit( fit->facet_begin() ), hend( hit );
do
{
if ( tick < 3 )
{
verts[tick++] = PointCGAL( hit->vertex()->point().x(), hit->vertex()->point().y(), hit->vertex()->point().z() );
}
else
{
std::cout << "meshSimplification: We've got facets with more than 3 vertices even though the facet reported to be triangular..." << std::endl;
}
} while( ++hit != hend );
result.push_back( Triangle(verts[0], verts[1], verts[2]) );
}
else
{
std::cout << "meshSimplification: Skipping non-triangular facet" << std::endl;
}
}
}
catch (CGAL::Assertion_exception e)
{
std::cout << "ERROR: meshSimplification CGAL::Assertion_exception" << e.message() << std::endl;
}
#ifdef MESHSIMPLIFICATION_LOG
timer.stop();
std::cout << "meshSimplification result with: " << result.size() << " triangles." << std::endl;
std::cout << "Total meshSimplification time: " << timer.time() << std::endl;
#endif
return result;
}