← Back to branch summary

~bzoltan/kubuntu-packaging/decouple_cmake_plugin

« back to all changes in this revision

Viewing changes to src/shared/qbs/src/lib/language/language.cpp

  • Committer: Timo Jyrinki
  • Date: 2013-11-15 12:25:23 UTC
  • mfrom: (1.1.28)
  • Revision ID: timo.jyrinki@canonical.com-20131115122523-i2kyamsu4gs2mu1m
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/shared/qbs/src/lib/language/language.cpp
45
45
 
46
46
#include <QDir>
47
47
#include <QDirIterator>
 
48
#include <QMap>
48
49
#include <QMutexLocker>
49
50
#include <QScriptValue>
50
51
 
97
98
{
98
99
    pool.stream() >> absoluteFilePath;
99
100
    pool.stream() >> fileTags;
 
101
    pool.stream() >> overrideFileTags;
100
102
    properties = pool.idLoadS<PropertyMapInternal>();
101
103
}
102
104
 
104
106
{
105
107
    pool.stream() << absoluteFilePath;
106
108
    pool.stream() << fileTags;
 
109
    pool.stream() << overrideFileTags;
107
110
    pool.store(properties);
108
111
}
109
112
 
214
217
    }
215
218
}
216
219
 
 
220
void ResolvedFileContext::load(PersistentPool &pool)
 
221
{
 
222
    filePath = pool.idLoadString();
 
223
    jsExtensions = pool.idLoadStringList();
 
224
    pool.stream() >> jsImports;
 
225
}
 
226
 
 
227
void ResolvedFileContext::store(PersistentPool &pool) const
 
228
{
 
229
    pool.storeString(filePath);
 
230
    pool.storeStringList(jsExtensions);
 
231
    pool.stream() << jsImports;
 
232
}
 
233
 
 
234
bool operator==(const ResolvedFileContext &a, const ResolvedFileContext &b)
 
235
{
 
236
    if (&a == &b)
 
237
        return true;
 
238
    if (!!&a != !!&b)
 
239
        return false;
 
240
    return a.filePath == b.filePath
 
241
            && a.jsExtensions == b.jsExtensions
 
242
            && a.jsImports == b.jsImports;
 
243
}
 
244
 
 
245
 
217
246
/*!
218
 
 * \class PrepareScript
219
 
 * \brief The \c PrepareScript class represents the JavaScript code found in the "prepare" binding
 
247
 * \class ScriptFunction
 
248
 * \brief The \c ScriptFunction class represents the JavaScript code found in the "prepare" binding
220
249
 *        of a \c Rule or \c Transformer item in a qbs file.
221
250
 * \sa Rule
222
251
 * \sa ResolvedTransformer
223
252
 */
224
253
 
225
254
 /*!
226
 
  * \variable PrepareScript::script
 
255
  * \variable ScriptFunction::script
227
256
  * \brief The actual Javascript code, taken verbatim from the qbs source file.
228
257
  */
229
258
 
230
259
  /*!
231
 
   * \variable PrepareScript::location
 
260
   * \variable ScriptFunction::location
232
261
   * \brief The exact location of the script in the qbs source file.
233
262
   * This is mostly needed for diagnostics.
234
263
   */
235
264
 
236
 
void PrepareScript::load(PersistentPool &pool)
237
 
{
238
 
    pool.stream() >> script;
239
 
    pool.stream() >> location;
240
 
}
241
 
 
242
 
void PrepareScript::store(PersistentPool &pool) const
243
 
{
244
 
    pool.stream() << script;
245
 
    pool.stream() << location;
 
265
void ScriptFunction::load(PersistentPool &pool)
 
266
{
 
267
    pool.stream()
 
268
            >> sourceCode
 
269
            >> argumentNames
 
270
            >> location;
 
271
    fileContext = pool.idLoadS<ResolvedFileContext>();
 
272
}
 
273
 
 
274
void ScriptFunction::store(PersistentPool &pool) const
 
275
{
 
276
    pool.stream()
 
277
            << sourceCode
 
278
            << argumentNames
 
279
            << location;
 
280
    pool.store(fileContext);
 
281
}
 
282
 
 
283
bool operator==(const ScriptFunction &a, const ScriptFunction &b)
 
284
{
 
285
    if (&a == &b)
 
286
        return true;
 
287
    if (!!&a != !!&b)
 
288
        return false;
 
289
    return a.sourceCode == b.sourceCode
 
290
            && a.location == b.location
 
291
            && *a.fileContext == *b.fileContext;
246
292
}
247
293
 
248
294
void ResolvedModule::load(PersistentPool &pool)
249
295
{
250
296
    name = pool.idLoadString();
251
297
    moduleDependencies = pool.idLoadStringList();
252
 
    setupBuildEnvironmentScript = pool.idLoadString();
253
 
    setupRunEnvironmentScript = pool.idLoadString();
254
 
    pool.stream() >> jsImports
255
 
      >> jsExtensions
256
 
      >> setupBuildEnvironmentScript
257
 
      >> setupRunEnvironmentScript;
 
298
    setupBuildEnvironmentScript = pool.idLoadS<ScriptFunction>();
 
299
    setupRunEnvironmentScript = pool.idLoadS<ScriptFunction>();
258
300
}
259
301
 
260
302
void ResolvedModule::store(PersistentPool &pool) const
261
303
{
262
304
    pool.storeString(name);
263
305
    pool.storeStringList(moduleDependencies);
264
 
    pool.storeString(setupBuildEnvironmentScript);
265
 
    pool.storeString(setupRunEnvironmentScript);
266
 
    pool.stream() << jsImports
267
 
      << jsExtensions
268
 
      << setupBuildEnvironmentScript
269
 
      << setupRunEnvironmentScript;
 
306
    pool.store(setupBuildEnvironmentScript);
 
307
    pool.store(setupRunEnvironmentScript);
 
308
}
 
309
 
 
310
bool operator==(const ResolvedModule &m1, const ResolvedModule &m2)
 
311
{
 
312
    if (&m1 == &m2)
 
313
        return true;
 
314
    if (!!&m1 != !!&m2)
 
315
        return false;
 
316
    return m1.name == m2.name
 
317
            && m1.moduleDependencies.toSet() == m2.moduleDependencies.toSet()
 
318
            && *m1.setupBuildEnvironmentScript == *m2.setupBuildEnvironmentScript
 
319
            && *m1.setupRunEnvironmentScript == *m2.setupRunEnvironmentScript;
 
320
}
 
321
 
 
322
static bool modulesAreEqual(const ResolvedModuleConstPtr &m1, const ResolvedModuleConstPtr &m2)
 
323
{
 
324
    return *m1 == *m2;
270
325
}
271
326
 
272
327
QString Rule::toString() const
285
340
 
286
341
void Rule::load(PersistentPool &pool)
287
342
{
288
 
    script = pool.idLoadS<PrepareScript>();
 
343
    script = pool.idLoadS<ScriptFunction>();
289
344
    module = pool.idLoadS<ResolvedModule>();
290
 
    pool.stream() >> jsImports
291
 
        >> jsExtensions
 
345
    pool.stream()
292
346
        >> inputs
293
347
        >> auxiliaryInputs
294
348
        >> usings
302
356
{
303
357
    pool.store(script);
304
358
    pool.store(module);
305
 
    pool.stream() << jsImports
306
 
        << jsExtensions
 
359
    pool.stream()
307
360
        << inputs
308
361
        << auxiliaryInputs
309
362
        << usings
375
428
    pool.loadContainerS(dependencies);
376
429
    pool.loadContainerS(fileTaggers);
377
430
    pool.loadContainerS(modules);
 
431
    pool.loadContainerS(transformers);
378
432
    pool.loadContainerS(groups);
379
433
    pool.loadContainerS(artifactProperties);
380
434
    buildData.reset(pool.idLoad<ProductBuildData>());
397
451
    pool.storeContainer(dependencies);
398
452
    pool.storeContainer(fileTaggers);
399
453
    pool.storeContainer(modules);
 
454
    pool.storeContainer(transformers);
400
455
    pool.storeContainer(groups);
401
456
    pool.storeContainer(artifactProperties);
402
457
    pool.store(buildData.data());
495
550
    QSet<QString> seenModuleNames;
496
551
    QList<const ResolvedModule *> topSortedModules = topSortModules(moduleChildren, rootModules, seenModuleNames);
497
552
    foreach (const ResolvedModule *module, topSortedModules) {
498
 
        if ((envType == BuildEnv && module->setupBuildEnvironmentScript.isEmpty()) ||
499
 
            (envType == RunEnv && module->setupBuildEnvironmentScript.isEmpty() && module->setupRunEnvironmentScript.isEmpty()))
 
553
        if ((envType == BuildEnv && module->setupBuildEnvironmentScript->sourceCode.isEmpty()) ||
 
554
            (envType == RunEnv && module->setupBuildEnvironmentScript->sourceCode.isEmpty()
 
555
             && module->setupRunEnvironmentScript->sourceCode.isEmpty()))
500
556
            continue;
501
557
 
 
558
        ScriptFunctionConstPtr setupScript;
 
559
        if (envType == BuildEnv) {
 
560
            setupScript = module->setupBuildEnvironmentScript;
 
561
        } else {
 
562
            if (!module->setupRunEnvironmentScript)
 
563
                setupScript = module->setupBuildEnvironmentScript;
 
564
            else
 
565
                setupScript = module->setupRunEnvironmentScript;
 
566
        }
 
567
 
502
568
        // handle imports
503
 
        engine->import(module->jsImports, scope, scope);
504
 
        JsExtensions::setupExtensions(module->jsExtensions, scope);
 
569
        engine->import(setupScript->fileContext->jsImports, scope, scope);
 
570
        JsExtensions::setupExtensions(setupScript->fileContext->jsExtensions, scope);
505
571
 
506
572
        // expose properties of direct module dependencies
507
573
        QScriptValue scriptValue;
519
585
        for (QVariantMap::const_iterator it = moduleCfg.constBegin(); it != moduleCfg.constEnd(); ++it)
520
586
            scope.setProperty(it.key(), engine->toScriptValue(it.value()));
521
587
 
522
 
        QString setupScript;
523
 
        if (envType == BuildEnv) {
524
 
            setupScript = module->setupBuildEnvironmentScript;
525
 
        } else {
526
 
            if (module->setupRunEnvironmentScript.isEmpty()) {
527
 
                setupScript = module->setupBuildEnvironmentScript;
528
 
            } else {
529
 
                setupScript = module->setupRunEnvironmentScript;
530
 
            }
531
 
        }
532
 
 
533
588
        QScriptContext *ctx = engine->currentContext();
534
589
        ctx->pushScope(scope);
535
 
        scriptValue = engine->evaluate(setupScript);
 
590
        scriptValue = engine->evaluate(setupScript->sourceCode + QLatin1String("()"));
536
591
        ctx->popScope();
537
592
        if (Q_UNLIKELY(scriptValue.isError() || engine->hasUncaughtException())) {
538
593
            QString envTypeStr = (envType == BuildEnv ? "build" : "run");
564
619
 
565
620
const QList<RuleConstPtr> &ResolvedProduct::topSortedRules() const
566
621
{
 
622
    QBS_CHECK(buildData);
567
623
    if (buildData->topSortedRules.isEmpty()) {
568
624
        FileTags productFileTags = fileTags;
569
625
        productFileTags += additionalFileTags;
888
944
    }
889
945
}
890
946
 
 
947
void ResolvedTransformer::load(PersistentPool &pool)
 
948
{
 
949
    module = pool.idLoadS<ResolvedModule>();
 
950
    pool.stream() >> inputs;
 
951
    pool.loadContainerS(outputs);
 
952
    transform = pool.idLoadS<ScriptFunction>();
 
953
}
 
954
 
 
955
void ResolvedTransformer::store(PersistentPool &pool) const
 
956
{
 
957
    pool.store(module);
 
958
    pool.stream() << inputs;
 
959
    pool.storeContainer(outputs);
 
960
    pool.store(transform);
 
961
}
 
962
 
 
963
 
 
964
template<typename T> QMap<QString, T> listToMap(const QList<T> &list)
 
965
{
 
966
    QMap<QString, T> map;
 
967
    foreach (const T &elem, list)
 
968
        map.insert(keyFromElem(elem), elem);
 
969
    return map;
 
970
}
 
971
 
 
972
template<typename T> bool listsAreEqual(const QList<T> &l1, const QList<T> &l2)
 
973
{
 
974
    if (l1.count() != l2.count())
 
975
        return false;
 
976
    const QMap<QString, T> map1 = listToMap(l1);
 
977
    const QMap<QString, T> map2 = listToMap(l2);
 
978
    foreach (const QString &key, map1.keys()) {
 
979
        const T value2 = map2.value(key);
 
980
        if (!value2)
 
981
            return false;
 
982
        if (*map1.value(key) != *value2)
 
983
            return false;
 
984
    }
 
985
    return true;
 
986
}
 
987
 
 
988
QString keyFromElem(const SourceArtifactPtr &sa) { return sa->absoluteFilePath; }
 
989
QString keyFromElem(const ResolvedTransformerConstPtr &t) { return t->transform->sourceCode; }
 
990
 
 
991
bool operator==(const SourceArtifact &sa1, const SourceArtifact &sa2)
 
992
{
 
993
    if (&sa1 == &sa2)
 
994
        return true;
 
995
    if (!!&sa1 != !!&sa2)
 
996
        return false;
 
997
    return sa1.absoluteFilePath == sa2.absoluteFilePath
 
998
            && sa1.fileTags == sa2.fileTags
 
999
            && sa1.overrideFileTags == sa2.overrideFileTags
 
1000
            && sa1.properties->value() == sa2.properties->value();
 
1001
}
 
1002
 
 
1003
bool sourceArtifactListsAreEqual(const QList<SourceArtifactPtr> &l1,
 
1004
                                 const QList<SourceArtifactPtr> &l2)
 
1005
{
 
1006
    return listsAreEqual(l1, l2);
 
1007
}
 
1008
 
 
1009
bool operator==(const ResolvedTransformer &t1, const ResolvedTransformer &t2)
 
1010
{
 
1011
    return modulesAreEqual(t1.module, t2.module)
 
1012
            && t1.inputs.toSet() == t2.inputs.toSet()
 
1013
            && sourceArtifactListsAreEqual(t1.outputs, t2.outputs)
 
1014
            && *t1.transform == *t2.transform;
 
1015
}
 
1016
 
 
1017
bool transformerListsAreEqual(const QList<ResolvedTransformerConstPtr> &l1,
 
1018
                              const QList<ResolvedTransformerConstPtr> &l2)
 
1019
{
 
1020
    return listsAreEqual(l1, l2);
 
1021
}
 
1022
 
891
1023
} // namespace Internal
892
1024
} // namespace qbs