int main( int argc, char * argv[] )
{
if (argc != 2)
{
cerr << "usage:" << endl;
cerr << "makeclas classfile" << endl;
return(1);
}
ClassDef defClass( argv[1] );
defClass.WriteHpp();
defClass.WriteCpp();
return(0);
}
void Unit::merge() {
if (UNLIKELY(!m_initialMergeDone)) {
SimpleLock lock(m_preConstsLock);
if (LIKELY(!m_initialMergeDone)) {
if (!RuntimeOption::RepoAuthoritative) {
Transl::mergePreConsts(m_preConsts);
}
for (MutableFuncRange fr(nonMainFuncs()); !fr.empty();) {
loadFunc(fr.popFront());
}
m_initialMergeDone = true;
}
}
Func** it = funcHoistableBegin();
Func** fend = funcEnd();
if (it != fend) {
bool debugger = isDebuggerAttached();
do {
Func* func = *it;
ASSERT(func->top());
setCachedFunc(func, debugger);
} while (++it != fend);
}
bool redoHoistable = false;
int ix = m_firstHoistablePreClass;
int end = m_firstMergablePreClass;
// iterate over all the potentially hoistable classes
// with no fatals on failure
while (ix < end) {
PreClass* pre = (PreClass*)m_mergeables[ix++];
if (!defClass(pre, false)) redoHoistable = true;
}
if (UNLIKELY(redoHoistable)) {
// if this unit isnt mergeOnly, we're done
if (!isMergeOnly()) return;
// as a special case, if all the classes are potentially
// hoistable, we dont list them twice, but instead
// iterate over them again
// At first glance, it may seem like we could leave
// the maybe-hoistable classes out of the second list
// and then always reset ix to 0; but that gets this
// case wrong if there's an autoloader for C, and C
// extends B:
//
// class A {}
// class B implements I {}
// class D extends C {}
//
// because now A and D go on the maybe-hoistable list
// B goes on the never hoistable list, and we
// fatal trying to instantiate D before B
if (end == (int)m_mergeables.size()) ix = m_firstHoistablePreClass;
}
end = m_mergeables.size();
// iterate over all but the guaranteed hoistable classes
// fataling if we fail.
while (ix < end) {
PreClass* pre = (PreClass*)m_mergeables[ix++];
defClass(pre, true);
}
}
void
initClassDefs()
{ defineClasses(classdefs);
#define defClass(n, s, mf, cp, summ) \
(cp) = defineClass(n, s, CtoString(summ), mf);
defClass(CtoName("*"), NAME_binaryExpression, makeClassTimes,
ClassTimes, "Multiplication expression");
defClass(CtoName("-"), NAME_binaryExpression, makeClassMinus,
ClassMinus, "Subtraction expression");
defClass(CtoName("+"), NAME_binaryExpression, makeClassPlus,
ClassPlus, "Addition expression");
defClass(CtoName("/"), NAME_binaryExpression, makeClassDivide,
ClassDivide, "Division expression");
defClass(CtoName(":="), NAME_object, makeClassBinding,
ClassBinding, "Name-value pair for argument-list");
defClass(CtoName("<"), NAME_binaryCondition, makeClassLess,
ClassLess, "Compare expressions on less-then");
defClass(CtoName("="), NAME_binaryCondition, makeClassEquation,
ClassEquation, "Identity between two expressions");
defClass(CtoName("=<"), NAME_binaryCondition, makeClassLessEqual,
ClassLessEqual, "Compare expressions on less-or-equal");
defClass(CtoName("=="), NAME_code, makeClassEqual,
ClassEqual, "Test equivalence of arguments");
defClass(CtoName(">"), NAME_binaryCondition, makeClassGreater,
ClassGreater, "Test equivalence of arguments");
defClass(CtoName(">="), NAME_binaryCondition, makeClassGreaterEqual,
ClassGreaterEqual, "Compare expressions on greater-or-equal");
defClass(CtoName("?"), NAME_function, makeClassObtain,
ClassObtain, "Invoke a get method");
defClass(CtoName("\\=="), NAME_code, makeClassNonEqual,
ClassNonEqual, "Test non-equivalence of arguments");
defClass(CtoName("@="), NAME_code, makeClassAssoc,
ClassAssoc, "Assign named reference to object");
initBoxes();
numberTreeClass(ClassObject, 0);
}
