static Value classNew(Context *ctx, const List<Value>& args)
{
if (args.getCount() < 1)
{
ctx->throwException(createException(ExcType::ValueError, "__new__/__call__ takes at least 1 argument."));
}
Value class_ = args[0];
Value __base__ = createString("__base__");
Value base = getMember(ctx, class_, __base__);
destroy(ctx, __base__);
Value __typeID__ = createString("__typeID__");
Value typeID = getMember(ctx, class_, __typeID__);
destroy(ctx, __typeID__);
if (base.type != ValueType::Object)
{
ctx->throwException(createException(ExcType::TypeError, "Class base must be an object."));
}
if (typeID.type != ValueType::Int)
{
ctx->throwException(createException(ExcType::TypeError, "Class type ID must be an integer."));
}
Value resultHead = createObject();
HashMap<Str, Value>& resultMembers = ((ObjectData *)resultHead.p)->members;
HashMap<Str, Value>& baseMembers = ((ObjectData *)base.p)->members;
for (auto kv : baseMembers)
{
resultMembers.set(kv.first, createCopy(kv.second));
}
resultMembers.set("__classTypeID__", createInt(typeID.i));
resultMembers.set("__class__", createCopy(args[0]));
auto pos = resultMembers.find("__init__");
if (pos != resultMembers.end())
{
destroy(ctx, callMethod(ctx, resultHead, "__init__", List<Value>(args.getCount()-1, args.getData()+1)));
} else
{
if (args.getCount() != 1)
{
ctx->throwException(createException(ExcType::ValueError, "__new__/__call__ takes 1 argument."));
}
}
destroy(ctx, typeID);
destroy(ctx, base);
return resultHead;
}
int Scene_Test::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: initTestCase(); break;
case 1: init(); break;
case 2: cleanup(); break;
case 3: initial(); break;
case 4: values(); break;
case 5: fixtureRemoval(); break;
case 6: loadSuccess(); break;
case 7: loadWrongType(); break;
case 8: loadWrongRoot(); break;
case 9: save(); break;
case 10: copyFrom(); break;
case 11: createCopy(); break;
case 12: arm(); break;
case 13: armMissingFixture(); break;
case 14: armTooManyChannels(); break;
case 15: flashUnflash(); break;
case 16: writeHTPBusZero(); break;
case 17: writeHTPBusOne(); break;
case 18: writeLTPHTPBusZero(); break;
case 19: writeLTPBusOne(); break;
case 20: writeLTPReady(); break;
case 21: writeValues(); break;
default: ;
}
_id -= 22;
}
return _id;
}
static Value createMethod(Context *ctx, const List<Value>& args)
{
if (args.getCount() != 2)
{
ctx->throwException(createException(ExcType::ValueError, "__methodify takes 2 argument."));
}
Value result = createObject();
HashMap<Str, Value>& resultMembers = ((ObjectData *)result.p)->members;
resultMembers.set("__func__", createCopy(args[0]));
resultMembers.set("__obj__", createCopy(args[1]));
resultMembers.set("__call__", createNativeFunction(methodCall));
return result;
}
int main()
{
anonymousStruct* myCopy;
globalStruct.a = 5;
globalStruct.b = 'b';
globalStruct.c = 3.14159;
myCopy = createCopy(globalStruct, 102);
return 0;
}
static Value createClass(Context *ctx, const List<Value>& args)
{
if (args.getCount() != 1)
{
ctx->throwException(createException(ExcType::ValueError, "__classify takes 1 argument."));
}
Value base = args[0];
if (base.type != ValueType::Object)
{
ctx->throwException(createException(ExcType::ValueError, "base must be an object."));
}
Value result = createObject();
HashMap<Str, Value>& resultMembers = ((ObjectData *)result.p)->members;
resultMembers.set("__base__", createCopy(args[0]));
resultMembers.set("__typeID__", createInt(ctx->getEngine()->createNewTypeID()));
resultMembers.set("__call__", createNativeFunction(classNew));
return result;
}
void ProjectSaver::writeProjects (const OwnedArray<LibraryModule>& modules, const String& specifiedExporterToSave, bool isCommandLineApp)
{
ThreadPool threadPool;
// keep a copy of the basic generated files group, as each exporter may modify it.
auto originalGeneratedGroup = generatedFilesGroup.state.createCopy();
CLionProjectExporter* clionExporter = nullptr;
OwnedArray<ProjectExporter> exporters;
try
{
for (Project::ExporterIterator exp (project); exp.next();)
{
if (specifiedExporterToSave.isNotEmpty() && exp->getName() != specifiedExporterToSave)
continue;
auto* exporter = exporters.add (exp.exporter.release());
exporter->initialiseDependencyPathValues();
if (exporter->getTargetFolder().createDirectory())
{
if (exporter->isCLion())
{
clionExporter = dynamic_cast<CLionProjectExporter*> (exporter);
}
else
{
exporter->copyMainGroupFromProject();
exporter->settings = exporter->settings.createCopy();
exporter->addToExtraSearchPaths (RelativePath ("JuceLibraryCode", RelativePath::projectFolder));
generatedFilesGroup.state = originalGeneratedGroup.createCopy();
exporter->addSettingsForProjectType (project.getProjectType());
for (auto& module: modules)
module->addSettingsForModuleToExporter (*exporter, *this);
generatedFilesGroup.sortAlphabetically (true, true);
exporter->getAllGroups().add (generatedFilesGroup);
}
if (isCommandLineApp)
saveExporter (exporter, modules);
else
threadPool.addJob (new ExporterJob (*this, exporter, modules), true);
}
else
{
addError ("Can't create folder: " + exporter->getTargetFolder().getFullPathName());
}
}
}
catch (ProjectExporter::SaveError& saveError)
{
addError (saveError.message);
}
if (! isCommandLineApp)
while (threadPool.getNumJobs() > 0)
Thread::sleep (10);
if (clionExporter != nullptr)
{
for (auto* exporter : exporters)
clionExporter->writeCMakeListsExporterSection (exporter);
std::cout << "Finished saving: " << clionExporter->getName() << std::endl;
}
}
