Arg Arg::operator -() const noexcept{
return Arg(-value);
}
int EvaluationThread::Start(void * arg)
{
Arg(arg); // store user data
int code = pthread_create( &ThreadId_, NULL, EvaluationThread::EntryPoint, (void*) this );
return code;
}
int Thread::Start(void * arg)
{
Arg(arg); // store user data
int code = thread_create(Thread::EntryPoint, this, & ThreadId_);
return code;
}
named_creation_functor(create_enum_t type, Arg arg = Arg())
: m_creation_type(type), m_arg(arg){}
void parseProcMaps(pid_t pid, std::vector<Libpair>& libA, double& t_maps, double& t_sha1)
{
std::string path;
char * buf = NULL;
size_t sz = 0;
char * fn;
double t1 = epoch();
asprintf(&fn,"/proc/%d/maps",pid);
FILE* fp = fopen(fn,"r");
if (!fp) return;
Set soSet;
while(xalt_fgets_alloc(fp, &buf, &sz))
{
// Step a:
// find the start of the file name
char *p = strstr(buf," /");
if (p == NULL)
continue;
p += 4; // move to the leading slash
// Step b: Remove all lines that have "(deleted)" in them
const char *q = strstr(p,"(deleted)");
if (q)
continue;
// Step c: find the filename in the directory
q = strrchr(p,'/');
if (q == NULL)
continue;
// Step d: Find the .so in the file
const char * so = strstr(++q,".so");
if (so == NULL)
continue;
// Step e: make sure that any trailing chars are numbers or a period
so += 3;
size_t tail = strspn(so,"1234567890.");
if (0 < tail && tail < 2)
continue;
// Step f: remove libxalt_init.so
const char *xalt_so = strstr(q,"libxalt_init.so");
if (xalt_so)
continue;
path.assign(p);
soSet.insert(path);
}
for ( auto const & it : soSet)
argV.push_back(Arg(it));
long fnSzG = argV.size();
double t2 = epoch();
t_maps = t2 - t1;
compute_sha1_master(fnSzG); // compute sha1sum for all files.
for (long i = 0; i < fnSzG; ++i)
{
Libpair libpair(argV[i].fn, argV[i].sha1);
libA.push_back(libpair);
}
t_sha1 = epoch() - t2;
free(buf); sz = 0; buf = NULL;
fclose(fp);
}
/*-------------------------------------------------------------------------*
* PL_BLT_UNIV *
* *
*-------------------------------------------------------------------------*/
Bool FC
Pl_Blt_Univ(WamWord term_word, WamWord list_word)
{
WamWord word, tag_mask;
WamWord *adr;
WamWord car_word;
int lst_length;
WamWord *arg1_adr;
WamWord *term_adr, *lst_adr, *stc_adr;
WamWord functor_word, functor_tag;
int functor;
int arity;
Pl_Set_C_Bip_Name("=..", 2);
DEREF(term_word, word, tag_mask);
if (tag_mask == TAG_REF_MASK)
goto list_to_term;
/* from term to list functor+args */
if (tag_mask == TAG_LST_MASK)
{
adr = UnTag_LST(word);
car_word = Tag_ATM(ATOM_CHAR('.'));
lst_length = 1 + 2;
arg1_adr = &Car(adr);
}
else if (tag_mask == TAG_STC_MASK)
{
adr = UnTag_STC(word);
car_word = Tag_ATM(Functor(adr));
lst_length = 1 + Arity(adr);
arg1_adr = &Arg(adr, 0);
}
#ifndef NO_USE_FD_SOLVER
else if (tag_mask == TAG_FDV_MASK)
{
adr = UnTag_FDV(word);
car_word = Tag_REF(adr); /* since Dont_Separate_Tag */
lst_length = 1 + 0;
}
#endif
else /* TAG_ATM/INT/FLT_MASK */
{
car_word = word;
lst_length = 1 + 0;
}
Pl_Check_For_Un_List(list_word);
Pl_Unset_C_Bip_Name();
for (;;)
{
if (!Pl_Get_List(list_word) || !Pl_Unify_Value(car_word))
return FALSE;
list_word = Pl_Unify_Variable();
if (--lst_length == 0)
break;
car_word = *arg1_adr++;
}
return Pl_Get_Nil(list_word);
/* from list functor+args to term */
list_to_term:
term_adr = UnTag_REF(word);
DEREF(list_word, word, tag_mask);
if (tag_mask == TAG_REF_MASK)
Pl_Err_Instantiation();
if (word == NIL_WORD)
Pl_Err_Domain(pl_domain_non_empty_list, list_word);
if (tag_mask != TAG_LST_MASK)
Pl_Err_Type(pl_type_list, list_word);
lst_adr = UnTag_LST(word);
DEREF(Car(lst_adr), functor_word, functor_tag);
if (functor_tag == TAG_REF_MASK)
Pl_Err_Instantiation();
DEREF(Cdr(lst_adr), word, tag_mask);
if (word == NIL_WORD)
{
if (functor_tag != TAG_ATM_MASK && functor_tag != TAG_INT_MASK &&
functor_tag != TAG_FLT_MASK)
Pl_Err_Type(pl_type_atomic, functor_word);
term_word = functor_word;
goto finish;
}
if (functor_tag != TAG_ATM_MASK)
Pl_Err_Type(pl_type_atom, functor_word);
if (tag_mask == TAG_REF_MASK)
Pl_Err_Instantiation();
if (tag_mask != TAG_LST_MASK)
Pl_Err_Type(pl_type_list, list_word);
functor = UnTag_ATM(functor_word);
stc_adr = H;
H++; /* space for f/n maybe lost if a list */
arity = 0;
for (;;)
{
arity++;
lst_adr = UnTag_LST(word);
DEREF(Car(lst_adr), word, tag_mask);
Do_Copy_Of_Word(tag_mask, word); /* since Dont_Separate_Tag */
Global_Push(word);
DEREF(Cdr(lst_adr), word, tag_mask);
if (word == NIL_WORD)
break;
if (tag_mask == TAG_REF_MASK)
Pl_Err_Instantiation();
if (tag_mask != TAG_LST_MASK)
Pl_Err_Type(pl_type_list, list_word);
}
if (arity > MAX_ARITY)
Pl_Err_Representation(pl_representation_max_arity);
if (functor == ATOM_CHAR('.') && arity == 2) /* a list */
term_word = Tag_LST(stc_adr + 1);
else
{
*stc_adr = Functor_Arity(functor, arity);
term_word = Tag_STC(stc_adr);
}
finish:
Bind_UV(term_adr, term_word);
Pl_Unset_C_Bip_Name();
return TRUE;
}
inline const std::vector<double>& Im() const { return Arg(0); }
/*-------------------------------------------------------------------------*
* COPY_TERM_REC *
* *
* p is the next address to use to store the rest of a term. *
*-------------------------------------------------------------------------*/
static void
Copy_Term_Rec(WamWord *dst_adr, WamWord *src_adr, WamWord **p)
{
WamWord word, tag_mask;
WamWord *adr;
WamWord *q;
int i;
terminal_rec:
DEREF(*src_adr, word, tag_mask);
switch (Tag_From_Tag_Mask(tag_mask))
{
case REF:
adr = UnTag_REF(word);
q = *p;
if (adr < q && adr >= base_copy) /* already a copy */
{
*dst_adr = word;
return;
}
if (top_vars >= end_vars)
Pl_Err_Representation(pl_representation_too_many_variables);
*top_vars++ = word; /* word to restore */
*top_vars++ = (WamWord) adr; /* address to restore */
*adr = *dst_adr = Tag_REF(dst_adr); /* bind to a new copy */
return;
#ifndef NO_USE_FD_SOLVER
case FDV:
adr = UnTag_FDV(word);
q = *p;
if (adr < q && adr >= base_copy) /* already a copy */
{
*dst_adr = Tag_REF(adr); /* since Dont_Separate_Tag */
return;
}
if (top_vars >= end_vars)
Pl_Err_Representation(pl_representation_too_many_variables);
*top_vars++ = word; /* word to restore */
*top_vars++ = (WamWord) adr; /* address to restore */
q = *p;
*p = q + Fd_Copy_Variable(q, adr);
*adr = *dst_adr = Tag_REF(q); /* bind to a new copy */
return;
#endif
case FLT:
adr = UnTag_FLT(word);
q = *p;
q[0] = adr[0];
#if WORD_SIZE == 32
q[1] = adr[1];
*p = q + 2;
#else
*p = q + 1;
#endif
*dst_adr = Tag_FLT(q);
return;
case LST:
adr = UnTag_LST(word);
q = *p;
*dst_adr = Tag_LST(q);
*p = &Cdr(q) + 1;
q = &Car(q);
adr = &Car(adr);
Copy_Term_Rec(q++, adr++, p);
dst_adr = q;
src_adr = adr;
goto terminal_rec;
case STC:
adr = UnTag_STC(word);
q = *p;
*dst_adr = Tag_STC(q);
Functor_And_Arity(q) = Functor_And_Arity(adr);
i = Arity(adr);
*p = &Arg(q, i - 1) + 1;
q = &Arg(q, 0);
adr = &Arg(adr, 0);
while (--i)
Copy_Term_Rec(q++, adr++, p);
dst_adr = q;
src_adr = adr;
goto terminal_rec;
default:
*dst_adr = word;
return;
}
}
/*-------------------------------------------------------------------------*
* PL_COPY_CONTIGUOUS_TERM *
* *
* Copy a contiguous term (dereferenced), the result is a contiguous term. *
*-------------------------------------------------------------------------*/
void
Pl_Copy_Contiguous_Term(WamWord *dst_adr, WamWord *src_adr)
#define Old_Adr_To_New_Adr(adr) ((dst_adr)+((adr)-(src_adr)))
{
WamWord word, *adr;
WamWord *q;
int i;
terminal_rec:
word = *src_adr;
switch (Tag_Of(word))
{
case REF:
adr = UnTag_REF(word);
q = Old_Adr_To_New_Adr(adr);
*dst_adr = Tag_REF(q);
if (adr > src_adr) /* only useful for Dont_Separate_Tag */
Pl_Copy_Contiguous_Term(q, adr);
return;
#ifndef NO_USE_FD_SOLVER
case FDV:
adr = UnTag_FDV(word);
Fd_Copy_Variable(dst_adr, adr);
return;
#endif
case FLT:
adr = UnTag_FLT(word);
q = Old_Adr_To_New_Adr(adr);
q[0] = adr[0];
#if WORD_SIZE == 32
q[1] = adr[1];
#endif
*dst_adr = Tag_FLT(q);
return;
case LST:
adr = UnTag_LST(word);
q = Old_Adr_To_New_Adr(adr);
*dst_adr = Tag_LST(q);
q = &Car(q);
adr = &Car(adr);
Pl_Copy_Contiguous_Term(q++, adr++);
dst_adr = q;
src_adr = adr;
goto terminal_rec;
case STC:
adr = UnTag_STC(word);
q = Old_Adr_To_New_Adr(adr);
*dst_adr = Tag_STC(q);
Functor_And_Arity(q) = Functor_And_Arity(adr);
i = Arity(adr);
q = &Arg(q, 0);
adr = &Arg(adr, 0);
while (--i)
Pl_Copy_Contiguous_Term(q++, adr++);
dst_adr = q;
src_adr = adr;
goto terminal_rec;
default:
*dst_adr = word;
return;
}
}
int Thread::Start(void * arg)
{
Arg(arg); // store user data
int code = pthread_create(&(m_id), NULL, Thread::EntryPoint, this);
return code;
}
int CmdMerge::execute (std::string& output)
{
context.footnote ("The 'merge' command is deprecated, and will be removed in a subsequent release.");
// invoke gc and commit before merging in order to update data files
context.tdb2.gc ();
context.tdb2.commit ();
std::vector <std::string> words = context.a3.extract_words ();
std::string file;
if (words.size ())
file = words[0];
std::string pushfile = "";
std::string tmpfile = "";
std::string sAutopush = lowerCase (context.config.get ("merge.autopush"));
bool bAutopush = context.config.getBoolean ("merge.autopush");
Uri uri (file, "merge");
uri.parse();
if (uri._data.length ())
{
Directory location (context.config.get ("data.location"));
// be sure that uri points to a file
uri.append ("undo.data");
Transport* transport;
if ((transport = Transport::getTransport (uri)) != NULL )
{
tmpfile = location._data + "/undo_remote.data";
transport->recv (tmpfile);
delete transport;
file = tmpfile;
}
else
file = uri._path;
// XXX the following function could indicate whether a modification was
// performed without an exception (by returning a boolean, within a status
// object or with a specific function)
try
{
context.tdb2.merge (file);
}
catch (const std::string& e) {
if (e == STRING_TDB2_UP_TO_DATE)
{
output += e + "\n";
return 0;
}
else
throw e;
}
output += std::string (STRING_CMD_MERGE_COMPLETE) + "\n";
if (tmpfile != "")
remove (tmpfile.c_str ());
if (((sAutopush == "ask") && (confirm (format (STRING_CMD_MERGE_CONFIRM, uri.ToString ()))))
|| (bAutopush))
{
// Derive autopush uri from merge.default.uri? otherwise: change prompt above
// Change the "merge" command to "push".
std::vector <Arg>::iterator i;
for (i = context.a3.begin (); i != context.a3.end (); ++i)
{
if (i->_category == Arg::cat_command)
{
i->_raw = "push";
break;
}
}
// Append the URI argument.
context.a3.push_back (Arg (uri._data, Arg::cat_literal));
std::string out;
assert (context.commands["push"]);
context.commands["push"]->execute (out);
}
}
else
throw std::string (STRING_CMD_MERGE_NO_URI);
return 0;
}
Arg operator /(const Arg& arg1, double b) noexcept{
return Arg(arg1.value/b);
}
Arg operator *(double a, const Arg& arg2) noexcept{
return Arg(a*arg2.value);
}
Arg operator -(const Arg& arg1, const Arg& arg2) noexcept{
return Arg(arg1.value-arg2.value);
}
QVariant MethodCaller::onMethodCalled(QVariantList arguments)
{
QVariant returnValue;
qDebug() << "MethodCaller::onMethodCalled: Method called for object" << m_objectName << "with arguments" << arguments;
if (m_method.parameterCount() != arguments.length())
{
qDebug() << "MethodCaller::onMethodCalled: Invalid number of parameters for call; expected:" << m_method.parameterCount() << "got" << arguments.length();
}
else
{
if (m_method.returnType() == QMetaType::Void) //method has no return value
{
m_method.invoke(m_pTargetObject,
Arg(0, arguments),
Arg(1, arguments),
Arg(2, arguments),
Arg(3, arguments),
Arg(4, arguments),
Arg(5, arguments),
Arg(6, arguments),
Arg(7, arguments),
Arg(8, arguments));
}
else
{
void *retVal = QMetaType::create(m_method.returnType());
if (retVal)
{
m_method.invoke(m_pTargetObject,
QGenericReturnArgument(m_method.typeName(), retVal),
Arg(0, arguments),
Arg(1, arguments),
Arg(2, arguments),
Arg(3, arguments),
Arg(4, arguments),
Arg(5, arguments),
Arg(6, arguments),
Arg(7, arguments),
Arg(8, arguments));
returnValue = QVariant(m_method.returnType(), retVal);
QMetaType::destroy(m_method.returnType(), retVal);
}
else
{
qDebug() << "MethodCaller::onMethodCalled:" << m_method.typeName() << "is a non-supported value type.";
}
}
}
return returnValue;
}
/*-------------------------------------------------------------------------*
* NORMALIZE *
* *
* This functions normalizes a term. *
* Input: *
* e_word: term to normalize *
* sign : current sign of the term (-1 or +1) *
* *
* Output: *
* p : the associated polynomial term *
* *
* Normalizes the term and loads it into p. *
* Non-Linear operations are simplified and loaded into a stack to be *
* executed later. *
* *
* T1*T2 : T1 and T2 are normalized to give the polynomials p1 and p2, with*
* p1 = c1 + a1X1 + a2X2 + ... + anXn *
* p2 = c2 + b1X1 + b2X2 + ... + bmXm *
* and replaced by c1*c2 + *
* a1X1 * c2 + a1X1 * b1X1 + ... + a1X1 * bmXm *
* ... *
* anX1 * c2 + anXn * b1X1 + ... + anXn * bmXm *
* *
* T1**T2: T1 and T2 are loaded into 2 new words word1 and word2 that can *
* be integers or variables (tagged words). The code emitted *
* depends on 3 possibilities (var**var is not allowed) *
* (+ optim 1**T2, 0**T2, T1**0, T1**1), NB 0**0=1 *
*-------------------------------------------------------------------------*/
static Bool
Normalize(WamWord e_word, int sign, Poly *p)
{
WamWord word, tag_mask;
WamWord *adr;
WamWord *fdv_adr;
WamWord word1, word2, word3;
WamWord f_n, le_word, re_word;
int i;
PlLong n1, n2, n3;
terminal_rec:
DEREF(e_word, word, tag_mask);
if (tag_mask == TAG_FDV_MASK)
{
fdv_adr = UnTag_FDV(word);
Add_Monom(p, sign, 1, Tag_REF(fdv_adr));
return TRUE;
}
if (tag_mask == TAG_INT_MASK)
{
n1 = UnTag_INT(word);
if (n1 > MAX_COEF_FOR_SORT)
sort = TRUE;
Add_Cst_To_Poly(p, sign, n1);
return TRUE;
}
if (tag_mask == TAG_REF_MASK)
{
if (vars_sp - vars_tbl >= VARS_STACK_SIZE)
Pl_Err_Resource(pl_resource_too_big_fd_constraint);
*vars_sp++ = word;
Add_Monom(p, sign, 1, word);
return TRUE;
}
if (tag_mask == TAG_ATM_MASK)
{
word = Pl_Put_Structure(ATOM_CHAR('/'), 2);
Pl_Unify_Value(e_word);
Pl_Unify_Integer(0);
type_error:
Pl_Err_Type(pl_type_fd_evaluable, word);
}
if (tag_mask != TAG_STC_MASK)
goto type_error;
adr = UnTag_STC(word);
f_n = Functor_And_Arity(adr);
for (i = 0; i < NB_OF_OP; i++)
if (arith_tbl[i] == f_n)
break;
le_word = Arg(adr, 0);
re_word = Arg(adr, 1);
switch (i)
{
case PLUS_1:
e_word = le_word;
goto terminal_rec;
case PLUS_2:
if (!Normalize(le_word, sign, p))
return FALSE;
e_word = re_word;
goto terminal_rec;
case MINUS_2:
if (!Normalize(le_word, sign, p))
return FALSE;
e_word = re_word;
sign = -sign;
goto terminal_rec;
case MINUS_1:
e_word = le_word;
sign = -sign;
goto terminal_rec;
case TIMES_2:
#ifdef DEVELOP_TIMES_2
#if 1 /* optimize frequent use: INT*VAR */
DEREF(le_word, word, tag_mask);
if (tag_mask != TAG_INT_MASK)
goto any;
n1 = UnTag_INT(word);
if (n1 > MAX_COEF_FOR_SORT)
sort = TRUE;
DEREF(re_word, word, tag_mask);
if (tag_mask != TAG_REF_MASK)
{
if (tag_mask != TAG_FDV_MASK)
goto any;
else
{
fdv_adr = UnTag_FDV(word);
word = Tag_REF(fdv_adr);
}
}
Add_Monom(p, sign, n1, word);
return TRUE;
any:
#endif
{
Poly p1, p2;
int i1, i2;
New_Poly(p1);
New_Poly(p2);
if (!Normalize(le_word, 1, &p1) || !Normalize(re_word, 1, &p2))
return FALSE;
Add_Cst_To_Poly(p, sign, p1.c * p2.c);
for (i1 = 0; i1 < p1.nb_monom; i1++)
{
Add_Monom(p, sign, p1.m[i1].a * p2.c, p1.m[i1].x_word);
for (i2 = 0; i2 < p2.nb_monom; i2++)
if (!Add_Multiply_Monom(p, sign, p1.m + i1, p2.m + i2))
return FALSE;
}
for (i2 = 0; i2 < p2.nb_monom; i2++)
Add_Monom(p, sign, p2.m[i2].a * p1.c, p2.m[i2].x_word);
return TRUE;
}
#else
if (!Load_Term_Into_Word(le_word, &word1) ||
!Load_Term_Into_Word(re_word, &word2))
return FALSE;
if (Tag_Is_INT(word1))
{
n1 = UnTag_INT(word1);
if (Tag_Is_INT(word2))
{
n2 = UnTag_INT(word2);
n1 = n1 * n2;
Add_Cst_To_Poly(p, sign, n1);
return TRUE;
}
Add_Monom(p, sign, n1, word2);
return TRUE;
}
if (Tag_Is_INT(word2))
{
n2 = UnTag_INT(word2);
Add_Monom(p, sign, n2, word1);
return TRUE;
}
word1 = (word1 == word2)
? Push_Delayed_Cstr(DC_X2_EQ_Y, word1, 0, 0)
: Push_Delayed_Cstr(DC_XY_EQ_Z, word1, word2, 0);
Add_Monom(p, sign, 1, word1);
return TRUE;
#endif
case POWER_2:
if (!Load_Term_Into_Word(le_word, &word1) ||
!Load_Term_Into_Word(re_word, &word2))
return FALSE;
if (Tag_Is_INT(word1))
{
n1 = UnTag_INT(word1);
if (Tag_Is_INT(word2))
{
n2 = UnTag_INT(word2);
if ((n1 = Pl_Power(n1, n2)) < 0)
return FALSE;
Add_Cst_To_Poly(p, sign, n1);
return TRUE;
}
if (n1 == 1)
{
Add_Cst_To_Poly(p, sign, 1);
return TRUE;
}
word = (n1 == 0)
? Push_Delayed_Cstr(DC_ZERO_POWER_N_EQ_Y, word2, 0, 0)
: Push_Delayed_Cstr(DC_A_POWER_N_EQ_Y, word1, word2, 0);
goto end_power;
}
if (Tag_Mask_Of(word2) != TAG_INT_MASK)
Pl_Err_Instantiation();
else
{
n2 = UnTag_INT(word2);
if (n2 == 0)
{
Add_Cst_To_Poly(p, sign, 1);
return TRUE;
}
word = (n2 == 1)
? word1
: (n2 == 2)
? Push_Delayed_Cstr(DC_X2_EQ_Y, word1, 0, 0)
: Push_Delayed_Cstr(DC_X_POWER_A_EQ_Y, word1, word2, 0);
}
end_power:
Add_Monom(p, sign, 1, word);
return TRUE;
case MIN_2:
if (!Load_Term_Into_Word(le_word, &word1) ||
!Load_Term_Into_Word(re_word, &word2))
return FALSE;
if (Tag_Is_INT(word1))
{
n1 = UnTag_INT(word1);
if (Tag_Is_INT(word2))
{
n2 = UnTag_INT(word2);
n1 = math_min(n1, n2);
Add_Cst_To_Poly(p, sign, n1);
return TRUE;
}
word = Push_Delayed_Cstr(DC_MIN_X_A_EQ_Z, word2, word1, 0);
goto end_min;
}
if (Tag_Is_INT(word2))
word = Push_Delayed_Cstr(DC_MIN_X_A_EQ_Z, word1, word2, 0);
else
word = Push_Delayed_Cstr(DC_MIN_X_Y_EQ_Z, word1, word2, 0);
end_min:
Add_Monom(p, sign, 1, word);
return TRUE;
case MAX_2:
if (!Load_Term_Into_Word(le_word, &word1) ||
!Load_Term_Into_Word(re_word, &word2))
return FALSE;
if (Tag_Is_INT(word1))
{
n1 = UnTag_INT(word1);
if (Tag_Is_INT(word2))
{
n2 = UnTag_INT(word2);
n1 = math_max(n1, n2);
Add_Cst_To_Poly(p, sign, n1);
return TRUE;
}
word = Push_Delayed_Cstr(DC_MAX_X_A_EQ_Z, word2, word1, 0);
goto end_max;
}
if (Tag_Is_INT(word2))
word = Push_Delayed_Cstr(DC_MAX_X_A_EQ_Z, word1, word2, 0);
else
word = Push_Delayed_Cstr(DC_MAX_X_Y_EQ_Z, word1, word2, 0);
end_max:
Add_Monom(p, sign, 1, word);
return TRUE;
case DIST_2:
if (!Load_Term_Into_Word(le_word, &word1) ||
!Load_Term_Into_Word(re_word, &word2))
return FALSE;
if (Tag_Is_INT(word1))
{
n1 = UnTag_INT(word1);
if (Tag_Is_INT(word2))
{
n2 = UnTag_INT(word2);
n1 = (n1 >= n2) ? n1 - n2 : n2 - n1;
Add_Cst_To_Poly(p, sign, n1);
return TRUE;
}
word = Push_Delayed_Cstr(DC_ABS_X_MINUS_A_EQ_Z, word2, word1, 0);
goto end_dist;
}
if (Tag_Is_INT(word2))
word = Push_Delayed_Cstr(DC_ABS_X_MINUS_A_EQ_Z, word1, word2, 0);
else
word = Push_Delayed_Cstr(DC_ABS_X_MINUS_Y_EQ_Z, word1, word2, 0);
end_dist:
Add_Monom(p, sign, 1, word);
return TRUE;
case QUOT_2:
word3 = Make_Self_Ref(H); /* word3 = remainder */
Global_Push(word3);
goto quot_rem;
case REM_2:
word3 = Make_Self_Ref(H); /* word3 = remainder */
Global_Push(word3);
goto quot_rem;
case QUOT_REM_3:
quot_rem:
if (!Load_Term_Into_Word(le_word, &word1) ||
!Load_Term_Into_Word(re_word, &word2) ||
(i == QUOT_REM_3 && !Load_Term_Into_Word(Arg(adr, 2), &word3)))
return FALSE;
if (Tag_Is_INT(word1))
{
n1 = UnTag_INT(word1);
if (Tag_Is_INT(word2))
{
n2 = UnTag_INT(word2);
if (n2 == 0)
return FALSE;
n3 = n1 % n2;
if (i == QUOT_2 || i == QUOT_REM_3)
{
if (i == QUOT_REM_3)
PRIM_CSTR_2(pl_x_eq_c, word3, word);
else
H--; /* recover word3 space */
n3 = n1 / n2;
}
Add_Cst_To_Poly(p, sign, n3);
return TRUE;
}
word = Push_Delayed_Cstr(DC_QUOT_REM_A_Y_R_EQ_Z, word1, word2,
word3);
goto end_quot_rem;
}
if (Tag_Is_INT(word2))
word = Push_Delayed_Cstr(DC_QUOT_REM_X_A_R_EQ_Z, word1, word2,
word3);
else
word = Push_Delayed_Cstr(DC_QUOT_REM_X_Y_R_EQ_Z, word1, word2,
word3);
end_quot_rem:
Add_Monom(p, sign, 1, (i == REM_2) ? word3 : word);
return TRUE;
case DIV_2:
if (!Load_Term_Into_Word(le_word, &word1) ||
!Load_Term_Into_Word(re_word, &word2))
return FALSE;
if (Tag_Is_INT(word1))
{
n1 = UnTag_INT(word1);
if (Tag_Is_INT(word2))
{
n2 = UnTag_INT(word2);
if (n2 == 0 || n1 % n2 != 0)
return FALSE;
n1 /= n2;
Add_Cst_To_Poly(p, sign, n1);
return TRUE;
}
word = Push_Delayed_Cstr(DC_DIV_A_Y_EQ_Z, word1, word2, 0);
goto end_div;
}
if (Tag_Is_INT(word2))
word = Push_Delayed_Cstr(DC_DIV_X_A_EQ_Z, word1, word2, 0);
else
word = Push_Delayed_Cstr(DC_DIV_X_Y_EQ_Z, word1, word2, 0);
end_div:
Add_Monom(p, sign, 1, word);
return TRUE;
default:
word = Pl_Put_Structure(ATOM_CHAR('/'), 2);
Pl_Unify_Atom(Functor(adr));
Pl_Unify_Integer(Arity(adr));
goto type_error;
}
return TRUE;
}
// Here is the test Eval function specialization. Here the CallExpr to the
// function is created.
CallExpr*
EvaluateTSynthesizer::BuildEvalCallExpr(const QualType InstTy,
Expr* SubTree,
llvm::SmallVector<Expr*, 2>& CallArgs) {
// Set up new context for the new FunctionDecl
DeclContext* PrevContext = m_Sema->CurContext;
m_Sema->CurContext = m_EvalDecl->getDeclContext();
// Create template arguments
Sema::InstantiatingTemplate Inst(*m_Sema, m_NoSLoc, m_EvalDecl);
// Before instantiation we need the canonical type
TemplateArgument Arg(InstTy.getCanonicalType());
TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, &Arg, 1U);
// Substitute the declaration of the templated function, with the
// specified template argument
Decl* D = m_Sema->SubstDecl(m_EvalDecl,
m_EvalDecl->getDeclContext(),
MultiLevelTemplateArgumentList(TemplateArgs));
FunctionDecl* Fn = dyn_cast<FunctionDecl>(D);
// We expect incoming declarations (instantiations) and we
// need to open the transaction to collect them.
Transaction::State oldState = getTransaction()->getState();
getTransaction()->setState(Transaction::kCollecting);
// Creates new body of the substituted declaration
m_Sema->InstantiateFunctionDefinition(Fn->getLocation(), Fn, true, true);
m_Sema->CurContext = PrevContext;
const FunctionProtoType* FPT = Fn->getType()->getAs<FunctionProtoType>();
FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
llvm::ArrayRef<QualType> ArgTypes(FPT->arg_type_begin(),
FPT->getNumArgs());
QualType FnTy = m_Context->getFunctionType(Fn->getResultType(),
ArgTypes,
EPI);
DeclRefExpr* DRE = m_Sema->BuildDeclRefExpr(Fn,
FnTy,
VK_RValue,
m_NoSLoc
).takeAs<DeclRefExpr>();
getTransaction()->setState(oldState);
// TODO: Figure out a way to avoid passing in wrong source locations
// of the symbol being replaced. This is important when we calculate the
// size of the memory buffers and may lead to creation of wrong wrappers.
Scope* S = m_Sema->getScopeForContext(m_Sema->CurContext);
CallExpr* EvalCall = m_Sema->ActOnCallExpr(S,
DRE,
SubTree->getLocStart(),
CallArgs,
SubTree->getLocEnd()
).takeAs<CallExpr>();
assert (EvalCall && "Cannot create call to Eval");
return EvalCall;
}
/*-------------------------------------------------------------------------*
* This file is not compiled separately but included twice by wam_inst.c: *
* - to define the Unify function (classical unification). *
* - to define the Unify_Occurs_Check function (+ occurs check). *
*-------------------------------------------------------------------------*/
Bool FC
UNIFY_FCT_NAME(WamWord start_u_word, WamWord start_v_word)
{
WamWord u_word, u_tag_mask;
WamWord v_word, v_tag_mask;
WamWord *u_adr, *v_adr;
int i;
terminal_rec:
DEREF(start_u_word, u_word, u_tag_mask);
DEREF(start_v_word, v_word, v_tag_mask);
if (u_tag_mask == TAG_REF_MASK)
{
u_adr = UnTag_REF(u_word);
if (v_tag_mask == TAG_REF_MASK)
{
v_adr = UnTag_REF(v_word);
if (u_adr > v_adr)
Bind_UV(u_adr, Tag_REF(v_adr));
else if (v_adr > u_adr)
Bind_UV(v_adr, Tag_REF(u_adr));
}
else
{
#ifdef OCCURS_CHECK
if (!Is_A_Local_Adr(u_adr) && /* no binding from heap to local */
Check_If_Var_Occurs(u_adr, v_word))
return FALSE;
#endif
Do_Copy_Of_Word(v_tag_mask, v_word);
Bind_UV(u_adr, v_word);
}
return TRUE;
}
if (v_tag_mask == TAG_REF_MASK)
{
v_adr = UnTag_REF(v_word);
#ifdef OCCURS_CHECK
if (!Is_A_Local_Adr(v_adr) && /* no binding from heap to local */
Check_If_Var_Occurs(v_adr, u_word))
return FALSE;
#endif
Do_Copy_Of_Word(u_tag_mask, u_word);
Bind_UV(v_adr, u_word);
return TRUE;
}
if (u_word == v_word)
return TRUE;
if (v_tag_mask == TAG_LST_MASK)
{
if (u_tag_mask != v_tag_mask)
return FALSE;
u_adr = UnTag_LST(u_word);
v_adr = UnTag_LST(v_word);
u_adr = &Car(u_adr);
v_adr = &Car(v_adr);
if (!UNIFY_FCT_NAME(*u_adr++, *v_adr++))
return FALSE;
start_u_word = *u_adr;
start_v_word = *v_adr;
goto terminal_rec;
}
if (v_tag_mask == TAG_STC_MASK)
{
if (u_tag_mask != v_tag_mask)
return FALSE;
u_adr = UnTag_STC(u_word);
v_adr = UnTag_STC(v_word);
if (Functor_And_Arity(u_adr) != Functor_And_Arity(v_adr))
return FALSE;
i = Arity(u_adr);
u_adr = &Arg(u_adr, 0);
v_adr = &Arg(v_adr, 0);
while (--i)
if (!UNIFY_FCT_NAME(*u_adr++, *v_adr++))
return FALSE;
start_u_word = *u_adr;
start_v_word = *v_adr;
goto terminal_rec;
}
#ifndef NO_USE_FD_SOLVER
if (v_tag_mask == TAG_INT_MASK && u_tag_mask == TAG_FDV_MASK)
return Fd_Unify_With_Integer(UnTag_FDV(u_word), UnTag_INT(v_word));
if (v_tag_mask == TAG_FDV_MASK)
{
v_adr = UnTag_FDV(v_word);
if (u_tag_mask == TAG_INT_MASK)
return Fd_Unify_With_Integer(v_adr, UnTag_INT(u_word));
if (u_tag_mask != v_tag_mask) /* i.e. TAG_FDV_MASK */
return FALSE;
return Fd_Unify_With_Fd_Var(UnTag_FDV(u_word), v_adr);
}
#endif
if (v_tag_mask == TAG_FLT_MASK)
return (u_tag_mask == v_tag_mask &&
Pl_Obtain_Float(UnTag_FLT(u_word)) ==
Pl_Obtain_Float(UnTag_FLT(v_word)));
return FALSE;
}
inline const double Im(const unsigned int i) const { return Arg(0,i); }
static const Type *getFullyQualifiedTemplateType(const ASTContext &Ctx,
const Type *TypePtr) {
// DependentTemplateTypes exist within template declarations and
// definitions. Therefore we shouldn't encounter them at the end of
// a translation unit. If we do, the caller has made an error.
assert(!isa<DependentTemplateSpecializationType>(TypePtr));
// In case of template specializations, iterate over the arguments
// and fully qualify them as well.
if (const auto *TST = dyn_cast<const TemplateSpecializationType>(TypePtr)) {
bool MightHaveChanged = false;
SmallVector<TemplateArgument, 4> FQArgs;
for (TemplateSpecializationType::iterator I = TST->begin(), E = TST->end();
I != E; ++I) {
// Cheap to copy and potentially modified by
// getFullyQualifedTemplateArgument.
TemplateArgument Arg(*I);
MightHaveChanged |= getFullyQualifiedTemplateArgument(Ctx, Arg);
FQArgs.push_back(Arg);
}
// If a fully qualified arg is different from the unqualified arg,
// allocate new type in the AST.
if (MightHaveChanged) {
QualType QT = Ctx.getTemplateSpecializationType(
TST->getTemplateName(), FQArgs.data(), FQArgs.size(),
TST->getCanonicalTypeInternal());
// getTemplateSpecializationType returns a fully qualified
// version of the specialization itself, so no need to qualify
// it.
return QT.getTypePtr();
}
} else if (const auto *TSTRecord = dyn_cast<const RecordType>(TypePtr)) {
// We are asked to fully qualify and we have a Record Type,
// which can point to a template instantiation with no sugar in any of
// its template argument, however we still need to fully qualify them.
if (const auto *TSTDecl =
dyn_cast<ClassTemplateSpecializationDecl>(TSTRecord->getDecl())) {
const TemplateArgumentList &TemplateArgs = TSTDecl->getTemplateArgs();
bool MightHaveChanged = false;
SmallVector<TemplateArgument, 4> FQArgs;
for (unsigned int I = 0, E = TemplateArgs.size(); I != E; ++I) {
// cheap to copy and potentially modified by
// getFullyQualifedTemplateArgument
TemplateArgument Arg(TemplateArgs[I]);
MightHaveChanged |= getFullyQualifiedTemplateArgument(Ctx, Arg);
FQArgs.push_back(Arg);
}
// If a fully qualified arg is different from the unqualified arg,
// allocate new type in the AST.
if (MightHaveChanged) {
TemplateName TN(TSTDecl->getSpecializedTemplate());
QualType QT = Ctx.getTemplateSpecializationType(
TN, FQArgs.data(), FQArgs.size(),
TSTRecord->getCanonicalTypeInternal());
// getTemplateSpecializationType returns a fully qualified
// version of the specialization itself, so no need to qualify
// it.
return QT.getTypePtr();
}
}
}
return TypePtr;
}
int main( int argc, char **argv )
{
UNUSED(argc);
UNUSED(argv);
#if defined(_MSC_VER) && defined(_DEBUG) && defined(ENABLE_LEAK_FINDER)
InitLeakFinder();
#endif
// Magic code to produce dump-files on Windows if the server crashes:
#if defined(_WIN32) && !defined(_WIN64) && defined(_MSC_VER)
HINSTANCE hDbgHelp = LoadLibrary("DBGHELP.DLL");
g_WriteMiniDump = (pMiniDumpWriteDump)GetProcAddress(hDbgHelp, "MiniDumpWriteDump");
if (g_WriteMiniDump != NULL)
{
_snprintf_s(g_DumpFileName, ARRAYCOUNT(g_DumpFileName), _TRUNCATE, "crash_mcs_%x.dmp", GetCurrentProcessId());
SetUnhandledExceptionFilter(LastChanceExceptionFilter);
// Parse arguments for minidump flags:
for (int i = 0; i < argc; i++)
{
if (_stricmp(argv[i], "/cdg") == 0)
{
// Add globals to the dump
g_DumpFlags = (MINIDUMP_TYPE)(g_DumpFlags | MiniDumpWithDataSegs);
}
else if (_stricmp(argv[i], "/cdf") == 0)
{
// Add full memory to the dump (HUUUGE file)
g_DumpFlags = (MINIDUMP_TYPE)(g_DumpFlags | MiniDumpWithFullMemory);
}
} // for i - argv[]
}
#endif // _WIN32 && !_WIN64
// End of dump-file magic
#ifdef _WIN32
if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)CtrlHandler, TRUE))
{
LOGERROR("Could not install the Windows CTRL handler!");
}
#endif
#if defined(_DEBUG) && defined(_MSC_VER)
_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
// _X: The simple built-in CRT leak finder - simply break when allocating the Nth block ({N} is listed in the leak output)
// Only useful when the leak is in the same sequence all the time
// _CrtSetBreakAlloc(85950);
#endif // _DEBUG && _MSC_VER
#ifndef _DEBUG
std::signal(SIGSEGV, NonCtrlHandler);
std::signal(SIGTERM, NonCtrlHandler);
std::signal(SIGINT, NonCtrlHandler);
std::signal(SIGABRT, NonCtrlHandler);
#ifdef SIGABRT_COMPAT
std::signal(SIGABRT_COMPAT, NonCtrlHandler);
#endif // SIGABRT_COMPAT
#endif
// DEBUG: test the dumpfile creation:
// *((int *)0) = 0;
// Check if comm logging is to be enabled:
for (int i = 0; i < argc; i++)
{
AString Arg(argv[i]);
if (
(NoCaseCompare(Arg, "/commlog") == 0) ||
(NoCaseCompare(Arg, "/logcomm") == 0)
)
{
g_ShouldLogCommIn = true;
g_ShouldLogCommOut = true;
}
else if (
(NoCaseCompare(Arg, "/commlogin") == 0) ||
(NoCaseCompare(Arg, "/comminlog") == 0) ||
(NoCaseCompare(Arg, "/logcommin") == 0)
)
{
g_ShouldLogCommIn = true;
}
else if (
(NoCaseCompare(Arg, "/commlogout") == 0) ||
(NoCaseCompare(Arg, "/commoutlog") == 0) ||
(NoCaseCompare(Arg, "/logcommout") == 0)
)
{
g_ShouldLogCommOut = true;
}
else if (NoCaseCompare(Arg, "nooutbuf") == 0)
{
setvbuf(stdout, NULL, _IONBF, 0);
}
} // for i - argv[]
#if !defined(ANDROID_NDK)
try
#endif
{
cRoot Root;
Root.Start();
}
#if !defined(ANDROID_NDK)
catch( std::exception& e )
{
LOGERROR("Standard exception: %s", e.what() );
}
catch( ... )
{
LOGERROR("Unknown exception!");
}
#endif
#if defined(_MSC_VER) && defined(_DEBUG) && defined(ENABLE_LEAK_FINDER)
DeinitLeakFinder();
#endif
g_SERVER_TERMINATED = true;
return EXIT_SUCCESS;
}
void Eval(EvaluationContext& EC)
{
NumberToken Arg(Utilities::GetNumberToken(m_LocalScope[0]));
EC.EvalStack.push_back(Types::Object(boost::apply_visitor(Sqrt(),Arg)));
}
/*-------------------------------------------------------------------------*
* LOAD_MATH_EXPRESSION *
* *
*-------------------------------------------------------------------------*/
static WamWord
Load_Math_Expression(WamWord exp)
{
WamWord word, tag_mask;
WamWord *adr;
WamWord *lst_adr;
ArithInf *arith;
DEREF(exp, word, tag_mask);
if (tag_mask == TAG_INT_MASK || tag_mask == TAG_FLT_MASK)
return word;
if (tag_mask == TAG_LST_MASK)
{
lst_adr = UnTag_LST(word);
DEREF(Cdr(lst_adr), word, tag_mask);
if (word != NIL_WORD)
{
word = Pl_Put_Structure(ATOM_CHAR('/'), 2);
Pl_Unify_Atom(ATOM_CHAR('.'));
Pl_Unify_Integer(2);
Pl_Err_Type(pl_type_evaluable, word);
}
DEREF(Car(lst_adr), word, tag_mask);
if (tag_mask == TAG_REF_MASK)
Pl_Err_Instantiation();
if (tag_mask != TAG_INT_MASK)
{
Pl_Err_Type(pl_type_integer, word);
}
return word;
}
if (tag_mask == TAG_STC_MASK)
{
adr = UnTag_STC(word);
arith = (ArithInf *) Pl_Hash_Find(arith_tbl, Functor_And_Arity(adr));
if (arith == NULL)
{
word = Pl_Put_Structure(ATOM_CHAR('/'), 2);
Pl_Unify_Atom(Functor(adr));
Pl_Unify_Integer(Arity(adr));
Pl_Err_Type(pl_type_evaluable, word);
}
if (Arity(adr) == 1)
return (*(arith->fct)) (Load_Math_Expression(Arg(adr, 0)));
return (*(arith->fct)) (Load_Math_Expression(Arg(adr, 0)),
Load_Math_Expression(Arg(adr, 1)));
}
if (tag_mask == TAG_REF_MASK)
Pl_Err_Instantiation();
if (tag_mask == TAG_ATM_MASK)
{
word = Pl_Put_Structure(ATOM_CHAR('/'), 2);
Pl_Unify_Value(exp);
Pl_Unify_Integer(0); /* then type_error */
}
Pl_Err_Type(pl_type_evaluable, word);
return word;
}
int LightmassMain(int argc, ANSICHAR* argv[])
{
GStartupTime = FPlatformTime::Seconds();
// Create lightmass log file
GLog->AddOutputDevice( FLightmassLog::Get() );
// Initialize FCommandLine
InitCommandLine(argc, argv);
// Output devices.
GError = FPlatformOutputDevices::GetError();
GWarn = FPlatformOutputDevices::GetWarn();
#if USE_LOCAL_SWARM_INTERFACE
FString CommandLine = FCommandLine::Get();
if (!FParse::Param(*CommandLine, TEXT("-Messaging")))
{
CommandLine += TEXT(" -Messaging");
}
GEngineLoop.PreInit(*CommandLine);
// Tell the module manager is may now process newly-loaded UObjects when new C++ modules are loaded
FModuleManager::Get().StartProcessingNewlyLoadedObjects();
FModuleManager::LoadModuleChecked<IMessagingModule>("Messaging");
FModuleManager::Get().LoadModule(TEXT("Settings"));
IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PreDefault);
#endif
UE_LOG(LogLightmass, Display, TEXT("Lightmass %s started on: %s. Command-line: %s"), FPlatformMisc::GetUBTPlatform(), FPlatformProcess::ComputerName(), FCommandLine::Get() );
// parse commandline options
bool bRunUnitTest = false;
bool bDumpTextures = false;
FGuid SceneGuid(0x0123, 0x4567, 0x89AB, 0xCDEF); // default scene guid if none specified
int32 NumThreads = FPlatformMisc::NumberOfCoresIncludingHyperthreads(); // default to the number of processors
bool bCompareFiles = false;
FString File1;
FString File2;
float ErrorThreshold = 0.000001f; // default error tolerance to allow in lighting comparisons
// Override 'NumThreads' with the environment variable, if it's set.
{
TCHAR* SwarmMaxCoresVariable = new TCHAR[32768];
FPlatformMisc::GetEnvironmentVariable( TEXT("Swarm_MaxCores"), SwarmMaxCoresVariable, 32768 );
int32 SwarmMaxCores = FCString::Atoi( SwarmMaxCoresVariable );
if ( SwarmMaxCores >= 1 && SwarmMaxCores < 128 )
{
NumThreads = SwarmMaxCores;
}
delete [] SwarmMaxCoresVariable;
}
for (int32 ArgIndex = 1; ArgIndex < argc; ArgIndex++)
{
if ((FCStringAnsi::Stricmp(argv[ArgIndex], "-help") == 0) || (FCStringAnsi::Stricmp(argv[ArgIndex], "-?") == 0))
{
UE_LOG(LogLightmass, Display, TEXT("Usage:\n UnrealLightmass\n\t[SceneGuid]\n\t[-debug]\n\t[-unittest]\n\t[-dumptex]\n\t[-numthreads N]\n\t[-compare Dir1 Dir2 [-error N]]"));
UE_LOG(LogLightmass, Display, TEXT(""));
UE_LOG(LogLightmass, Display, TEXT(" SceneGuid : Guid of a scene file. 0x0000012300004567000089AB0000CDEF is the default"));
UE_LOG(LogLightmass, Display, TEXT(" -debug : Processes all mappings in the scene, instead of getting tasks from Swarm Coordinator"));
UE_LOG(LogLightmass, Display, TEXT(" -unittest : Runs a series of validations, then quits"));
UE_LOG(LogLightmass, Display, TEXT(" -dumptex : Outputs .bmp files to the current directory of 2D lightmap/shadowmap results"));
UE_LOG(LogLightmass, Display, TEXT(" -compare : Compares the binary dumps created by UnrealEd to compare Unreal vs LM lighting runs"));
UE_LOG(LogLightmass, Display, TEXT(" -error : Controls the threshold that an error is counted when comparing with -compare"));
return 0;
}
else if (FCStringAnsi::Stricmp(argv[ArgIndex], "-unittest") == 0)
{
bRunUnitTest = true;
}
else if (FCStringAnsi::Stricmp(argv[ArgIndex], "-dumptex") == 0)
{
bDumpTextures = true;
}
else if (FCStringAnsi::Stricmp(argv[ArgIndex], "-usedebug") == 0)
{
// Warning! This will only process mapping tasks and will skip other types of tasks.
GDebugMode = true;
}
else if (FCStringAnsi::Stricmp(argv[ArgIndex], "-stats") == 0)
{
GReportDetailedStats = true;
}
else if (FCStringAnsi::Stricmp(argv[ArgIndex], "-numthreads") == 0)
{
// use the next parameter as the number of threads (it must exist, or we fail)
NumThreads = 0;
if (ArgIndex < argc - 1)
{
NumThreads = FCString::Atoi(*FString(argv[++ArgIndex]));
}
// validate it
if (NumThreads == 0)
{
UE_LOG(LogLightmass, Display, TEXT("The number of threads was not specified properly, use \"-numthreads N\""));
return 1;
}
}
else if (FCStringAnsi::Stricmp(argv[ArgIndex], "-compare") == 0)
{
bCompareFiles = true;
if (ArgIndex >= argc - 2)
{
UE_LOG(LogLightmass, Display, TEXT("-compare requires two directories to compare (-compare Dir1 Dir2)"));
return 1;
}
// cache the files to compare
File1 = *FString(argv[++ArgIndex]);
File2 = *FString(argv[++ArgIndex]);
}
else if (FCStringAnsi::Stricmp(argv[ArgIndex], "-error") == 0)
{
// use the next parameter as the number of threads (it must exist, or we fail)
if (ArgIndex >= argc - 1)
{
UE_LOG(LogLightmass, Display, TEXT("-error requires an error value following (-error N)"));
return 1;
}
ErrorThreshold = FCString::Atof(*FString(argv[++ArgIndex]));
}
// look for just a Guid on the commandline
else if (FCStringAnsi::Strlen(argv[ArgIndex]) == 32)
{
// break up the string into 4 components
FString Arg(argv[ArgIndex]);
// we use _tcstoul to import base 16
#if PLATFORM_USES_MICROSOFT_LIBC_FUNCTIONS
SceneGuid.A = _tcstoul(*Arg.Mid(0, 8), NULL, 16);
SceneGuid.B = _tcstoul(*Arg.Mid(8, 8), NULL, 16);
SceneGuid.C = _tcstoul(*Arg.Mid(16, 8), NULL, 16);
SceneGuid.D = _tcstoul(*Arg.Mid(24, 8), NULL, 16);
#else
SceneGuid.A = wcstoul(*Arg.Mid(0, 8), NULL, 16);
SceneGuid.B = wcstoul(*Arg.Mid(8, 8), NULL, 16);
SceneGuid.C = wcstoul(*Arg.Mid(16, 8), NULL, 16);
SceneGuid.D = wcstoul(*Arg.Mid(24, 8), NULL, 16);
#endif
}
}
// if we want to run the unit test, do that, then nothing else
if (bRunUnitTest)
{
// this is an ongoing compiler/runtime test for all templates and whatnot
TestLightmass();
return 0;
}
if (bCompareFiles)
{
CompareLightingResults(*File1, *File2, ErrorThreshold);
return 0;
}
// Start the static lighting processing
UE_LOG(LogLightmass, Display, TEXT("Processing scene GUID: %08X%08X%08X%08X with %d threads"), SceneGuid.A, SceneGuid.B, SceneGuid.C, SceneGuid.D, NumThreads );
BuildStaticLighting(SceneGuid, NumThreads, bDumpTextures);
#if USE_LOCAL_SWARM_INTERFACE
FEngineLoop::AppPreExit();
FModuleManager::Get().UnloadModulesAtShutdown();
FTaskGraphInterface::Shutdown();
FEngineLoop::AppExit();
#endif
return 0;
}
/* The bytecode interpreter for the NFA */
static int re_match(value re,
unsigned char * starttxt,
register unsigned char * txt,
register unsigned char * endtxt,
int accept_partial_match)
{
register value * pc;
intnat instr;
struct backtrack_stack * stack;
union backtrack_point * sp;
value cpool;
value normtable;
unsigned char c;
union backtrack_point back;
{ int i;
struct re_group * p;
unsigned char ** q;
for (p = &re_group[1], i = Numgroups(re); i > 1; i--, p++)
p->start = p->end = NULL;
for (q = &re_register[0], i = Numregisters(re); i > 0; i--, q++)
*q = NULL;
}
pc = &Field(Prog(re), 0);
stack = &initial_stack;
sp = stack->point;
cpool = Cpool(re);
normtable = Normtable(re);
re_group[0].start = txt;
while (1) {
instr = Long_val(*pc++);
switch (Opcode(instr)) {
case CHAR:
if (txt == endtxt) goto prefix_match;
if (*txt != Arg(instr)) goto backtrack;
txt++;
break;
case CHARNORM:
if (txt == endtxt) goto prefix_match;
if (Byte_u(normtable, *txt) != Arg(instr)) goto backtrack;
txt++;
break;
case STRING: {
unsigned char * s =
(unsigned char *) String_val(Field(cpool, Arg(instr)));
while ((c = *s++) != 0) {
if (txt == endtxt) goto prefix_match;
if (c != *txt) goto backtrack;
txt++;
}
break;
}
case STRINGNORM: {
unsigned char * s =
(unsigned char *) String_val(Field(cpool, Arg(instr)));
while ((c = *s++) != 0) {
if (txt == endtxt) goto prefix_match;
if (c != Byte_u(normtable, *txt)) goto backtrack;
txt++;
}
break;
}
case CHARCLASS:
if (txt == endtxt) goto prefix_match;
if (! In_bitset(String_val(Field(cpool, Arg(instr))), *txt, c))
goto backtrack;
txt++;
break;
case BOL:
if (txt > starttxt && txt[-1] != '\n') goto backtrack;
break;
case EOL:
if (txt < endtxt && *txt != '\n') goto backtrack;
break;
case WORDBOUNDARY:
/* At beginning and end of text: no
At beginning of text: OK if current char is a letter
At end of text: OK if previous char is a letter
Otherwise:
OK if previous char is a letter and current char not a letter
or previous char is not a letter and current char is a letter */
if (txt == starttxt) {
if (txt == endtxt) goto prefix_match;
if (Is_word_letter(txt[0])) break;
goto backtrack;
} else if (txt == endtxt) {
if (Is_word_letter(txt[-1])) break;
goto backtrack;
} else {
if (Is_word_letter(txt[-1]) != Is_word_letter(txt[0])) break;
goto backtrack;
}
case BEGGROUP: {
int group_no = Arg(instr);
struct re_group * group = &(re_group[group_no]);
back.undo.loc = &(group->start);
back.undo.val = group->start;
group->start = txt;
goto push;
}
case ENDGROUP: {
int group_no = Arg(instr);
struct re_group * group = &(re_group[group_no]);
back.undo.loc = &(group->end);
back.undo.val = group->end;
group->end = txt;
goto push;
}
case REFGROUP: {
int group_no = Arg(instr);
struct re_group * group = &(re_group[group_no]);
unsigned char * s;
if (group->start == NULL || group->end == NULL) goto backtrack;
for (s = group->start; s < group->end; s++) {
if (txt == endtxt) goto prefix_match;
if (*s != *txt) goto backtrack;
txt++;
}
break;
}
case ACCEPT:
goto accept;
case SIMPLEOPT: {
char * set = String_val(Field(cpool, Arg(instr)));
if (txt < endtxt && In_bitset(set, *txt, c)) txt++;
break;
}
case SIMPLESTAR: {
char * set = String_val(Field(cpool, Arg(instr)));
while (txt < endtxt && In_bitset(set, *txt, c))
txt++;
break;
}
case SIMPLEPLUS: {
char * set = String_val(Field(cpool, Arg(instr)));
if (txt == endtxt) goto prefix_match;
if (! In_bitset(set, *txt, c)) goto backtrack;
txt++;
while (txt < endtxt && In_bitset(set, *txt, c))
txt++;
break;
}
case GOTO:
pc = pc + SignedArg(instr);
break;
case PUSHBACK:
back.pos.pc = Set_tag(pc + SignedArg(instr));
back.pos.txt = txt;
goto push;
case SETMARK: {
int reg_no = Arg(instr);
unsigned char ** reg = &(re_register[reg_no]);
back.undo.loc = reg;
back.undo.val = *reg;
*reg = txt;
goto push;
}
case CHECKPROGRESS: {
int reg_no = Arg(instr);
if (re_register[reg_no] == txt)
goto backtrack;
break;
}
default:
caml_fatal_error ("impossible case in re_match");
}
/* Continue with next instruction */
continue;
push:
/* Push an item on the backtrack stack and continue with next instr */
if (sp == stack->point + BACKTRACK_STACK_BLOCK_SIZE) {
struct backtrack_stack * newstack =
caml_stat_alloc(sizeof(struct backtrack_stack));
newstack->previous = stack;
stack = newstack;
sp = stack->point;
}
*sp = back;
sp++;
continue;
prefix_match:
/* We get here when matching failed because the end of text
was encountered. */
if (accept_partial_match) goto accept;
backtrack:
/* We get here when matching fails. Backtrack to most recent saved
program point, undoing variable assignments on the way. */
while (1) {
if (sp == stack->point) {
struct backtrack_stack * prevstack = stack->previous;
if (prevstack == NULL) return 0;
caml_stat_free(stack);
stack = prevstack;
sp = stack->point + BACKTRACK_STACK_BLOCK_SIZE;
}
sp--;
if (Tag_is_set(sp->pos.pc)) {
pc = Clear_tag(sp->pos.pc);
txt = sp->pos.txt;
break;
} else {
*(sp->undo.loc) = sp->undo.val;
}
}
continue;
}
accept:
/* We get here when the regexp was successfully matched */
free_backtrack_stack(stack);
re_group[0].end = txt;
return 1;
}
const QByteArray& operator[](int index) const { return Arg(index); }
/*-------------------------------------------------------------------------*
* SHOW_STRUCTURE *
* *
*-------------------------------------------------------------------------*/
static void
Show_Structure(int depth, int prec, int context, WamWord *stc_adr)
{
WamWord word, tag_mask;
WamWord *adr;
WamWord f_n = Functor_And_Arity(stc_adr);
int functor = Functor(stc_adr);
int arity = Arity(stc_adr);
OperInf *oper;
int nb_args_to_disp;
int i, j, n;
char str[32];
Bool bracket;
Bool surround_space;
char *p;
depth--;
if (name_vars && f_n == dollar_varname_1 && stc_adr >= name_number_above_H)
{
DEREF(Arg(stc_adr, 0), word, tag_mask);
if (tag_mask == TAG_ATM_MASK)
{
p = pl_atom_tbl[UnTag_ATM(word)].name;
if (Is_Valid_Var_Name(p))
{
Out_String(p);
pl_last_writing = W_IDENTIFIER;
return;
}
}
}
if (number_vars && f_n == dollar_var_1 && stc_adr >= name_number_above_H)
{
DEREF(Arg(stc_adr, 0), word, tag_mask);
if (tag_mask == TAG_INT_MASK && (n = UnTag_INT(word)) >= 0)
{
i = n % 26;
j = n / 26;
Out_Char('A' + i);
if (j)
{
sprintf(str, "%d", j);
Out_String(str);
}
pl_last_writing = W_IDENTIFIER;
return;
}
}
if (ignore_op || arity > 2)
goto functional;
if (f_n == curly_brackets_1)
{
Out_Char('{');
if (space_args)
Out_Space();
Show_Term(depth, MAX_PREC, GENERAL_TERM, Arg(stc_adr, 0));
if (space_args)
Out_Space();
Out_Char('}');
return;
}
bracket = FALSE;
if (arity == 1 && (oper = Pl_Lookup_Oper(functor, PREFIX)))
{
#if 1
/* Koen de Bosschere says "in case of ambiguity : */
/* select the associative operator over the nonassociative */
/* select prefix over postfix". */
OperInf *oper1;
if (oper->prec > oper->right
&& (oper1 = Pl_Lookup_Oper(functor, POSTFIX))
&& oper1->left == oper1->prec)
{
oper = oper1;
goto postfix;
}
#endif
if (oper->prec > prec || (context == INSIDE_LEFT_ASSOC_OP &&
(oper->prec == oper->right
&& oper->prec == prec)))
{ /* prevent also the case: fy T yf(x) */
Out_Char('(');
bracket = TRUE;
}
Show_Atom(GENERAL_TERM, functor);
last_prefix_op = W_PREFIX_OP_ANY;
if (space_args
#if SPACE_ARGS_RESTRICTED /* space_args -> space after fx operator */
&& oper->prec > oper->right
#endif
)
Out_Space();
else
if (strcmp(pl_atom_tbl[functor].name, "-") == 0)
{
last_prefix_op = W_PREFIX_OP_MINUS;
p_bracket_minus = &bracket;
}
Show_Term(depth, oper->right, INSIDE_ANY_OP, Arg(stc_adr, 0));
last_prefix_op = W_NO_PREFIX_OP;
/* Here we need a while(bracket--) instead of if(bracket) because
* in some cases with the minus op and additional bracket is needed.
* Example: with op(100, xfx, &) (recall the prec of - is 200).
* The term ((-(1)) & b must be displayed as: (- (1)) & b
* Concerning the sub-term - (1), the first ( is emitted 10 lines above
* because the precedence of - (200) is > precedence of & (100).
* The second ( is emitted by Need_Space() because the argument of - begins
* by a digit. At the return we have to close 2 ).
*/
while (bracket--)
Out_Char(')');
return;
}
if (arity == 1 && (oper = Pl_Lookup_Oper(functor, POSTFIX)))
{
postfix:
if (oper->prec > prec)
{
Out_Char('(');
bracket = TRUE;
}
context =
(oper->left == oper->prec) ? INSIDE_LEFT_ASSOC_OP : INSIDE_ANY_OP;
Show_Term(depth, oper->left, context, Arg(stc_adr, 0));
if (space_args
#if SPACE_ARGS_RESTRICTED /* space_args -> space before xf operator */
&& oper->prec > oper->left
#endif
)
Out_Space();
Show_Atom(GENERAL_TERM, functor);
if (bracket)
Out_Char(')');
return;
}
if (arity == 2 && (oper = Pl_Lookup_Oper(functor, INFIX)))
{
if (oper->prec > prec || (context == INSIDE_LEFT_ASSOC_OP &&
(oper->prec == oper->right
&& oper->prec == prec)))
{ /* prevent also the case: T xfy U yf(x) */
Out_Char('(');
bracket = TRUE;
}
context =
(oper->left == oper->prec) ? INSIDE_LEFT_ASSOC_OP : INSIDE_ANY_OP;
Show_Term(depth, oper->left, context, Arg(stc_adr, 0));
#if 1 /* to show | unquoted if it is an infix operator with prec > 1000 */
if (functor == ATOM_CHAR('|') && oper->prec > 1000)
{
if (space_args)
Out_Space();
Out_Char('|');
if (space_args)
Out_Space();
}
else
#endif
if (functor == ATOM_CHAR(','))
{
Out_Char(',');
if (space_args)
Out_Space();
}
else
{
surround_space = FALSE;
if (pl_atom_tbl[functor].prop.type == IDENTIFIER_ATOM ||
pl_atom_tbl[functor].prop.type == OTHER_ATOM ||
(space_args
#ifdef SPACE_ARGS_RESTRICTED /* space_args -> space around xfx operators */
&& oper->left != oper->prec && oper->right != oper->prec
#endif
))
{
surround_space = TRUE;
Out_Space();
}
Show_Atom(GENERAL_TERM, functor);
if (surround_space)
Out_Space();
}
Show_Term(depth, oper->right, INSIDE_ANY_OP, Arg(stc_adr, 1));
if (bracket)
Out_Char(')');
return;
}
functional: /* functional notation */
Show_Atom(GENERAL_TERM, functor);
Out_Char('(');
nb_args_to_disp = i = (arity < depth + 1 || depth < 0) ? arity : depth + 1;
adr = &Arg(stc_adr, 0);
goto start_display;
do
{
Out_Char(',');
if (space_args)
Out_Space();
start_display:
Show_Term(depth, MAX_ARG_OF_FUNCTOR_PREC, GENERAL_TERM, *adr++);
}
while (--i);
if (arity != nb_args_to_disp)
{
Out_Char(',');
if (space_args)
Out_Space();
Show_Atom(GENERAL_TERM, atom_dots);
}
Out_Char(')');
}
/*-------------------------------------------------------------------------*
* SIMPLIFY *
* *
* This function returns the result of the simplified boolean expression *
* given in e_word. NOT operators are only applied to variables. *
* *
* Input: *
* sign : current sign of the boolean term (-1 (inside a ~) or +1) *
* e_word: boolean term to simplify *
* *
* Output: *
* The returned result is a pointer to a node of the following form: *
* *
* for binary boolean not operator (~): *
* [1]: variable involved (tagged word) *
* [0]: operator NOT *
* *
* for unary boolean operators (<=> ~<=> ==> ~==> /\ ~/\ \/ ~\/): *
* [2]: right boolean exp (pointer to node) *
* [1]: left boolean exp (pointer to node) *
* [0]: operator (EQUIV, NEQUIV, IMPLY, NIMPLY, AND, NAND, OR, NOR) *
* *
* for boolean false value (0): *
* [0]: ZERO *
* *
* for boolean true value (1): *
* [0]: ONE *
* *
* for boolean variable: *
* [0]: tagged word *
* *
* for binary math operators (= \= < >= > <=) (partial / full AC): *
* [2]: right math exp (tagged word) *
* [1]: left math exp (tagged word) *
* [0]: operator (EQ, NEQ, LT, LTE, EQ_F, NEQ_F, LT_F, LTE_F) *
* (GT, GTE, GT_F, and GTE_F becomes LT, LTE, LT_F and LTE_F) *
* *
* These nodes are stored in a hybrid stack. NB: XOR same as NEQUIV *
*-------------------------------------------------------------------------*/
static WamWord *
Simplify(int sign, WamWord e_word)
{
WamWord word, tag_mask;
WamWord *adr;
WamWord f_n, le_word, re_word;
int op, n;
WamWord *exp, *sp1;
WamWord l, r;
#ifdef DEBUG
printf("ENTERING %5ld: %2d: ", sp - stack, sign);
Pl_Write(e_word);
printf("\n");
#endif
exp = sp;
if (sp - stack > BOOL_STACK_SIZE - 5)
Pl_Err_Resource(pl_resource_too_big_fd_constraint);
DEREF(e_word, word, tag_mask);
if (tag_mask == TAG_REF_MASK || tag_mask == TAG_FDV_MASK)
{
adr = UnTag_Address(word);
if (vars_sp - vars_tbl == VARS_STACK_SIZE)
Pl_Err_Resource(pl_resource_too_big_fd_constraint);
*vars_sp++ = word;
*vars_sp++ = 0; /* bool var */
if (sign != 1)
*sp++ = NOT;
*sp++ = Tag_REF(adr);
return exp;
}
if (tag_mask == TAG_INT_MASK)
{
n = UnTag_INT(word);
if ((unsigned) n > 1)
goto type_error;
*sp++ = ZERO + ((sign == 1) ? n : 1 - n);
return exp;
}
if (tag_mask == TAG_ATM_MASK)
{
word = Pl_Put_Structure(ATOM_CHAR('/'), 2);
Pl_Unify_Value(e_word);
Pl_Unify_Integer(0);
type_error:
Pl_Err_Type(pl_type_fd_bool_evaluable, word);
}
if (tag_mask != TAG_STC_MASK)
goto type_error;
adr = UnTag_STC(word);
f_n = Functor_And_Arity(adr);
if (bool_xor == f_n)
op = NEQUIV;
else
{
for (op = 0; op < NB_OF_OP; op++)
if (bool_tbl[op] == f_n)
break;
if (op == NB_OF_OP)
{
word = Pl_Put_Structure(ATOM_CHAR('/'), 2);
Pl_Unify_Atom(Functor(adr));
Pl_Unify_Integer(Arity(adr));
goto type_error;
}
}
le_word = Arg(adr, 0);
re_word = Arg(adr, 1);
if (op == NOT)
return Simplify(-sign, le_word);
if (sign != 1)
op = (op % 2 == EQ % 2) ? op + 1 : op - 1;
if (op >= EQ && op <= LTE_F)
{
Add_Fd_Variables(le_word);
Add_Fd_Variables(re_word);
n = (op == GT || op == GT_F) ? op - 2 :
(op == GTE || op == GTE_F) ? op + 2 : op;
*sp++ = n;
*sp++ = (n == op) ? le_word : re_word;
*sp++ = (n == op) ? re_word : le_word;
return exp;
}
sp += 3;
exp[0] = op;
exp[1] = (WamWord) Simplify(1, le_word);
sp1 = sp;
exp[2] = (WamWord) Simplify(1, re_word);
l = *(WamWord *) (exp[1]);
r = *(WamWord *) (exp[2]);
/* NB: beware when calling below Simplify() (while has been just called above)
* this can ran into stack overflow (N^2 space complexity).
* Try to recover the stack before calling Simplify().
* Other stack recovery are less important (e.g. when only using exp[1]).
*
* In the following exp[] += sizeof(WamWord) is used to "skip" the NOT
* in a simplification (points to the next cell).
*/
switch (op)
{
case EQUIV:
if (l == ZERO) /* 0 <=> R is ~R */
{
sp = exp;
return Simplify(-1, re_word);
}
if (l == ONE) /* 1 <=> R is R */
{
return (WamWord *) exp[2];
}
if (r == ZERO) /* L <=> 0 is ~L */
{
sp = exp;
return Simplify(-1, le_word);
}
if (r == ONE) /* L <=> 1 is L */
{
sp = sp1;
return (WamWord *) exp[1];
}
if (l == NOT) /* ~X <=> R is X <=> ~R */
{
exp[1] += sizeof(WamWord);
sp = sp1;
exp[2] = (WamWord) Simplify(-1, re_word);
break;
}
if (r == NOT) /* L <=> ~X is ~L <=> X */
{ /* NB: cannot recover the stack */
exp[1] = (WamWord) Simplify(-1, le_word);
exp[2] += sizeof(WamWord);
break;
}
break;
case NEQUIV:
if (l == ZERO) /* 0 ~<=> R is R */
{
return (WamWord *) exp[2];
}
if (l == ONE) /* 1 ~<=> R is ~R */
{
sp = exp;
return Simplify(-1, re_word);
}
if (r == ZERO) /* L ~<=> 0 is L */
{
sp = sp1;
return (WamWord *) exp[1];
}
if (r == ONE) /* L ~<=> 1 is ~L */
{
sp = exp;
return Simplify(-1, le_word);
}
if (l == NOT) /* ~X ~<=> R is X <=> R */
{
exp[0] = EQUIV;
exp[1] += sizeof(WamWord);
break;
}
if (r == NOT) /* L ~<=> ~X is L <=> X */
{
exp[0] = EQUIV;
exp[2] += sizeof(WamWord);
break;
}
if (IsVar(l) && !IsVar(r)) /* X ~<=> R is X <=> ~R */
{
exp[0] = EQUIV;
sp = sp1;
exp[2] = (WamWord) Simplify(-1, re_word);
break;
}
if (IsVar(r) && !IsVar(l)) /* L ~<=> X is L <=> ~X */
{
exp[0] = EQUIV; /* NB: cannot recover the stack */
exp[1] = (WamWord) Simplify(-1, le_word);
break;
}
break;
case IMPLY:
if (l == ZERO || r == ONE) /* 0 ==> R is 1 , L ==> 1 is 1 */
{
sp = exp;
*sp++ = ONE;
break;
}
if (l == ONE) /* 1 ==> R is R */
{
return (WamWord *) exp[2];
}
if (r == ZERO) /* L ==> 0 is ~L */
return sp = exp, Simplify(-1, le_word);
if (l == NOT) /* ~X ==> R is X \/ R */
{
exp[0] = OR;
exp[1] += sizeof(WamWord);
break;
}
if (r == NOT) /* L ==> ~X is X ==> ~L */
{
exp[1] = exp[2] + sizeof(WamWord);
exp[2] = (WamWord) Simplify(-1, le_word);
break;
}
break;
case NIMPLY:
if (l == ZERO || r == ONE) /* 0 ~==> R is 0 , L ~==> 1 is 0 */
{
sp = exp;
*sp++ = ZERO;
break;
}
if (l == ONE) /* 1 ~==> R is ~R */
{
sp = exp;
return Simplify(-1, re_word);
}
if (r == ZERO) /* L ~==> 0 is L */
{
sp = sp1;
return (WamWord *) exp[1];
}
if (l == NOT) /* ~X ~==> R is X ~\/ R */
{
exp[0] = NOR;
exp[1] += sizeof(WamWord);
break;
}
if (r == NOT) /* L ~==> ~X is L /\ X */
{
exp[0] = AND;
exp[2] += sizeof(WamWord);
break;
}
break;
case AND:
if (l == ZERO || r == ZERO) /* 0 /\ R is 0 , L /\ 0 is 0 */
{
sp = exp;
*sp++ = ZERO;
break;
}
if (l == ONE) /* 1 /\ R is R */
{
return (WamWord *) exp[2];
}
if (r == ONE) /* L /\ 1 is L */
{
sp = sp1;
return (WamWord *) exp[1];
}
if (l == NOT) /* ~X /\ R is R ~==> X */
{
exp[0] = NIMPLY;
word = exp[1];
exp[1] = exp[2];
exp[2] = word + sizeof(WamWord);
break;
}
if (r == NOT) /* L /\ ~X is L ~==> X */
{
exp[0] = NIMPLY;
exp[2] += sizeof(WamWord);
break;
}
break;
case NAND:
if (l == ZERO || r == ZERO) /* 0 ~/\ R is 1 , L ~/\ 0 is 1 */
{
sp = exp;
*sp++ = ONE;
break;
}
if (l == ONE) /* 1 ~/\ R is ~R */
{
sp = exp;
return Simplify(-1, re_word);
}
if (r == ONE) /* L ~/\ 1 is ~L */
{
sp = exp;
return Simplify(-1, le_word);
}
if (l == NOT) /* ~X ~/\ R is R ==> X */
{
exp[0] = IMPLY;
word = exp[1];
exp[1] = exp[2];
exp[2] = word + sizeof(WamWord);
break;
}
if (r == NOT) /* L ~/\ ~X is L ==> X */
{
exp[0] = IMPLY;
exp[2] += sizeof(WamWord);
break;
}
break;
case OR:
if (l == ONE || r == ONE) /* 1 \/ R is 1 , L \/ 1 is 1 */
{
sp = exp;
*sp++ = ONE;
break;
}
if (l == ZERO) /* 0 \/ R is R */
{
return (WamWord *) exp[2];
}
if (r == ZERO) /* L \/ 0 is L */
{
sp = sp1;
return (WamWord *) exp[1];
}
if (l == NOT) /* ~X \/ R is X ==> R */
{
exp[0] = IMPLY;
exp[1] += sizeof(WamWord);
break;
}
if (r == NOT) /* L \/ ~X is X ==> L */
{
exp[0] = IMPLY;
word = exp[1];
exp[1] = exp[2] + sizeof(WamWord);
exp[2] = word;
break;
}
break;
case NOR:
if (l == ONE || r == ONE) /* 1 ~\/ R is 0 , L ~\/ 1 is 0 */
{
sp = exp;
*sp++ = ZERO;
break;
}
if (l == ZERO) /* 0 ~\/ R is ~R */
{
sp = exp;
return Simplify(-1, re_word);
}
if (r == ZERO) /* L ~\/ 0 is ~L */
{
sp = exp;
return Simplify(-1, le_word);
}
if (l == NOT) /* ~X ~\/ R is X ~==> R */
{
exp[0] = NIMPLY;
exp[1] += sizeof(WamWord);
break;
}
if (r == NOT) /* L ~\/ ~X is X ~==> L */
{
exp[0] = NIMPLY;
word = exp[1];
exp[1] = exp[2] + sizeof(WamWord);
exp[2] = word;
break;
}
break;
}
return exp;
}
/*static */
void * Thread::EntryPoint(void * pthis)
{
Thread * pt = (Thread*)pthis;
pthis->Run( Arg() );
}
/**
* \brief Define a parameter (option that requires a value)
*/
void SimpleCli::defineParam(const QByteArray& name, const QString& valueHelp, const QString& help)
{
argdefs[name] = Arg(name, valueHelp, help, true);
aliases[name] = name;
}