← Back to branch summary

~ubuntu-branches/debian/sid/kdevelop/sid

« back to all changes in this revision

Viewing changes to buildtools/projectmanager/builders/makebuilder/kdevmakebuilder.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jeremy Lainé
  • Date: 2006-05-23 18:39:42 UTC
  • Revision ID: james.westby@ubuntu.com-20060523183942-hucifbvh68k2bwz7
Tags: upstream-3.3.2
Import upstream version 3.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
buildtools/projectmanager/builders/makebuilder/kdevmakebuilder.cpp
 
1
 
 
2
#include <config.h>
 
3
#include "kdevmakebuilder.h"
 
4
 
 
5
#include <kdevproject.h>
 
6
#include <kdevcore.h>
 
7
#include <kdevmakefrontend.h>
 
8
#include <domutil.h>
 
9
#include <makeoptionswidget.h>
 
10
 
 
11
#include <kiconloader.h>
 
12
#include <kgenericfactory.h>
 
13
#include <kprocess.h>
 
14
#include <kdialogbase.h>
 
15
#include <kglobal.h>
 
16
#include <klocale.h>
 
17
#include <kdebug.h>
 
18
 
 
19
#include <qvbox.h>
 
20
 
 
21
K_EXPORT_COMPONENT_FACTORY(libkdevmakebuilder, KGenericFactory<KDevMakeBuilder>("kdevmakebuilder"))
 
22
 
 
23
 
 
24
const QString &KDevMakeBuilder::builder =
 
25
    KGlobal::staticQString("/kdevprojectmanager/builder");
 
26
    
 
27
const QString &KDevMakeBuilder::makeTool =
 
28
    KGlobal::staticQString("/kdevprojectmanager/builder/make/makebin");
 
29
    
 
30
const QString &KDevMakeBuilder::priority =
 
31
    KGlobal::staticQString("/kdevprojectmanager/builder/make/prio");
 
32
    
 
33
const QString &KDevMakeBuilder::abortOnError =
 
34
    KGlobal::staticQString("/kdevprojectmanager/builder/make/abortonerror");
 
35
    
 
36
const QString &KDevMakeBuilder::numberOfJobs =
 
37
    KGlobal::staticQString("/kdevprojectmanager/builder/make/numberofjobs");
 
38
    
 
39
const QString &KDevMakeBuilder::dontAct = 
 
40
    KGlobal::staticQString("/kdevprojectmanager/builder/make/dontact");
 
41
 
 
42
const QString &KDevMakeBuilder::environment = 
 
43
    KGlobal::staticQString("/kdevprojectmanager/builder/make/envvars");
 
44
    
 
45
KDevMakeBuilder::KDevMakeBuilder(QObject *parent, const char *name, const QStringList &)
 
46
    : KDevProjectBuilder(parent, name)
 
47
{
 
48
    m_project = ::qt_cast<KDevProject*>(parent);
 
49
    Q_ASSERT(m_project);
 
50
    
 
51
    connect(project()->core(), SIGNAL(projectConfigWidget(KDialogBase*)),
 
52
        this, SLOT(projectConfigWidget(KDialogBase*)));
 
53
        
 
54
    if (KDevMakeFrontend *make = project()->extension<KDevMakeFrontend>("KDevelop/MakeFrontend")) {
 
55
        connect(make, SIGNAL(commandFinished(const QString &)),
 
56
            this, SLOT(commandFinished(const QString &)));
 
57
            
 
58
        connect(make, SIGNAL(commandFailed(const QString &)),
 
59
            this, SLOT(commandFailed(const QString &)));
 
60
    }
 
61
}
 
62
 
 
63
KDevMakeBuilder::~KDevMakeBuilder()
 
64
{
 
65
}
 
66
 
 
67
KDevProject *KDevMakeBuilder::project() const
 
68
{
 
69
    return m_project;
 
70
}
 
71
 
 
72
bool KDevMakeBuilder::isExecutable(ProjectItemDom dom) const
 
73
{
 
74
    Q_UNUSED(dom);
 
75
    return false;
 
76
}
 
77
 
 
78
ProjectItemDom KDevMakeBuilder::defaultExecutable() const
 
79
{
 
80
    return m_defaultExecutable;
 
81
}
 
82
 
 
83
void KDevMakeBuilder::setDefaultExecutable(ProjectItemDom dom)
 
84
{
 
85
    m_defaultExecutable = dom;
 
86
}
 
87
 
 
88
bool KDevMakeBuilder::configure(ProjectItemDom dom)
 
89
{
 
90
    Q_UNUSED(dom);
 
91
    return false;
 
92
}
 
93
    
 
94
bool KDevMakeBuilder::build(ProjectItemDom dom)
 
95
{
 
96
    if (KDevMakeFrontend *make = project()->extension<KDevMakeFrontend>("KDevelop/MakeFrontend")) {
 
97
        if (ProjectFolderDom folder = dom->toFolder()) {
 
98
            // ### compile the folder
 
99
            QString command = buildCommand(dom);
 
100
            make->queueCommand(folder->name(), command);
 
101
            m_commands.append(qMakePair(command, dom));
 
102
            return true;
 
103
        } else if (ProjectTargetDom target = dom->toTarget()) {
 
104
            // ### compile the target
 
105
        } else if (ProjectFileDom file = dom->toFile()) {
 
106
            // ### compile the file
 
107
        }
 
108
    }
 
109
    
 
110
    return false;
 
111
}
 
112
 
 
113
bool KDevMakeBuilder::clean(ProjectItemDom dom)
 
114
{
 
115
    Q_UNUSED(dom);
 
116
    return false;
 
117
}
 
118
 
 
119
bool KDevMakeBuilder::execute(ProjectItemDom dom)
 
120
{
 
121
    Q_UNUSED(dom);
 
122
    return false;
 
123
}
 
124
 
 
125
void KDevMakeBuilder::projectConfigWidget(KDialogBase *dlg)
 
126
{
 
127
    Q_ASSERT(project());
 
128
    
 
129
    QVBox *vbox = dlg->addVBoxPage(i18n("Make Options"), i18n("Make Options"), BarIcon( "make", KIcon::SizeMedium ));
 
130
    MakeOptionsWidget *widget = new MakeOptionsWidget(*project()->projectDom(), builder, vbox);
 
131
    connect(dlg, SIGNAL(okClicked()), widget, SLOT(accept()));
 
132
}
 
133
 
 
134
void KDevMakeBuilder::commandFinished(const QString &command)
 
135
{
 
136
    if (!m_commands.isEmpty()) {
 
137
        QPair<QString, ProjectItemDom> item = m_commands.first();
 
138
        if (item.first == command) {
 
139
            m_commands.pop_front();
 
140
            emit builded(item.second);
 
141
        }
 
142
    }
 
143
}
 
144
 
 
145
void KDevMakeBuilder::commandFailed(const QString &command)
 
146
{
 
147
    Q_UNUSED(command);
 
148
    
 
149
    if (!m_commands.isEmpty()) {
 
150
        m_commands.clear();
 
151
        
 
152
        emit failed();
 
153
    }
 
154
}
 
155
 
 
156
QString KDevMakeBuilder::buildCommand(ProjectItemDom item, const QString &target)
 
157
{
 
158
    QDomDocument &dom = *project()->projectDom();
 
159
 
 
160
    QString cmdline = DomUtil::readEntry(dom, makeTool);
 
161
    int prio = DomUtil::readIntEntry(dom, priority);
 
162
    QString nice;
 
163
    if (prio != 0) {
 
164
        nice = QString("nice -n%1 ").arg(prio);
 
165
    }
 
166
 
 
167
    if (cmdline.isEmpty())
 
168
        cmdline = MAKE_COMMAND;
 
169
    if (!DomUtil::readBoolEntry(dom, abortOnError))
 
170
        cmdline += " -k";
 
171
    int jobs = DomUtil::readIntEntry(dom, numberOfJobs);
 
172
    if (jobs != 0) {
 
173
        cmdline += " -j";
 
174
        cmdline += QString::number(jobs);
 
175
    }
 
176
    if (DomUtil::readBoolEntry(dom, dontAct))
 
177
        cmdline += " -n";
 
178
 
 
179
    cmdline += " ";
 
180
    cmdline += target;
 
181
 
 
182
    cmdline.prepend(nice);
 
183
    cmdline.prepend(makeEnvironment());
 
184
 
 
185
    Q_ASSERT(item->toFolder());
 
186
 
 
187
    QString dircmd = "cd ";
 
188
    QString dir = item->toFolder()->name();
 
189
    dircmd += KProcess::quote(dir);
 
190
    dircmd += " && ";
 
191
 
 
192
    return dircmd + cmdline;
 
193
}
 
194
 
 
195
QString KDevMakeBuilder::makeEnvironment() const
 
196
{
 
197
    DomUtil::PairList envvars =
 
198
        DomUtil::readPairListEntry(*project()->projectDom(), environment, "envvar", "name", "value");
 
199
 
 
200
    QString env;
 
201
    DomUtil::PairList::ConstIterator it;
 
202
    for (it = envvars.begin(); it != envvars.end(); ++it) {
 
203
        env += (*it).first;
 
204
        env += "=";
 
205
        env += KProcess::quote((*it).second);
 
206
        env += " ";
 
207
    }
 
208
    return env;
 
209
}
 
210