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); }