1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
/* ######################################################################
APT Config - Program to manipulate APT configuration files
This program will parse a config file and then do something with it.
Commands:
shell - Shell mode. After this a series of word pairs should occur.
The first is the environment var to set and the second is
the key to set it from. Use like:
eval `apt-config shell QMode apt::QMode`
##################################################################### */
/*}}}*/
// Include Files /*{{{*/
#include <config.h>
#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/cmndline.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/error.h>
#include <apt-pkg/init.h>
#include <apt-pkg/pkgsystem.h>
#include <apt-pkg/strutl.h>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <string.h>
#include <apt-private/private-cmndline.h>
#include <apt-private/private-main.h>
#include <apti18n.h>
/*}}}*/
using namespace std;
// DoShell - Handle the shell command /*{{{*/
// ---------------------------------------------------------------------
/* */
static bool DoShell(CommandLine &CmdL)
{
for (const char **I = CmdL.FileList + 1; *I != 0; I += 2)
{
if (I[1] == 0 || strlen(I[1]) == 0)
return _error->Error(_("Arguments not in pairs"));
string key = I[1];
if (key.end()[-1] == '/') // old directory format
key.append("d");
if (_config->ExistsAny(key.c_str()))
cout << *I << "='" <<
SubstVar(_config->FindAny(key.c_str()),"'","'\\''") << '\'' << endl;
}
return true;
}
/*}}}*/
// DoDump - Dump the configuration space /*{{{*/
// ---------------------------------------------------------------------
/* */
static bool DoDump(CommandLine &CmdL)
{
bool const empty = _config->FindB("APT::Config::Dump::EmptyValue", true);
std::string const format = _config->Find("APT::Config::Dump::Format", "%F \"%v\";\n");
if (CmdL.FileSize() == 1)
_config->Dump(cout, NULL, format.c_str(), empty);
else
for (const char **I = CmdL.FileList + 1; *I != 0; ++I)
_config->Dump(cout, *I, format.c_str(), empty);
return true;
}
/*}}}*/
static bool ShowHelp(CommandLine &) /*{{{*/
{
std::cout <<
_("Usage: apt-config [options] command\n"
"\n"
"apt-config is an interface to the configuration settings used by\n"
"all APT tools, mainly intended for debugging and shell scripting.\n");
return true;
}
/*}}}*/
static std::vector<aptDispatchWithHelp> GetCommands() /*{{{*/
{
return {
{"shell", &DoShell, _("get configuration values via shell evaluation")},
{"dump", &DoDump, _("show the active configuration setting")},
{nullptr, nullptr, nullptr}
};
}
/*}}}*/
int main(int argc,const char *argv[]) /*{{{*/
{
// Parse the command line and initialize the package library
CommandLine CmdL;
auto const Cmds = ParseCommandLine(CmdL, APT_CMD::APT_CONFIG, &_config, &_system, argc, argv, &ShowHelp, &GetCommands);
std::vector<std::string> const langs = APT::Configuration::getLanguages(true);
_config->Clear("Acquire::Languages");
for (std::vector<std::string>::const_iterator l = langs.begin(); l != langs.end(); ++l)
_config->Set("Acquire::Languages::", *l);
std::vector<std::string> const archs = APT::Configuration::getArchitectures();
_config->Clear("APT::Architectures");
for (std::vector<std::string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
_config->Set("APT::Architectures::", *a);
string const conf = "APT::Compressor::";
std::map<std::string,std::string> CompressorNames;
for (auto && key : _config->FindVector("APT::Compressor", "", true))
{
auto const comp = conf + key + "::Name";
CompressorNames.emplace(_config->Find(comp, key), key);
}
std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
_config->Clear("APT::Compressor");
for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressors.begin(); c != compressors.end(); ++c)
{
auto const n = CompressorNames.find(c->Name);
string comp = conf + (n == CompressorNames.end() ? c->Name : n->second) + "::";
_config->Set(comp + "Name", c->Name);
_config->Set(comp + "Extension", c->Extension);
_config->Set(comp + "Binary", c->Binary);
_config->Set((comp + "Cost").c_str(), c->Cost);
for (std::vector<std::string>::const_iterator a = c->CompressArgs.begin(); a != c->CompressArgs.end(); ++a)
_config->Set(comp + "CompressArg::", *a);
for (std::vector<std::string>::const_iterator a = c->UncompressArgs.begin(); a != c->UncompressArgs.end(); ++a)
_config->Set(comp + "UncompressArg::", *a);
}
std::vector<std::string> const profiles = APT::Configuration::getBuildProfiles();
_config->Clear("APT::Build-Profiles");
for (std::vector<std::string>::const_iterator p = profiles.begin(); p != profiles.end(); ++p)
_config->Set("APT::Build-Profiles::", *p);
return DispatchCommandLine(CmdL, Cmds);
}
/*}}}*/
|
