NeoMutt  2019-12-07-60-g0cfa53
Teaching an old dog new tricks
DOXYGEN
version.c File Reference

Display version and copyright about NeoMutt. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/utsname.h>
#include <unistd.h>
#include "mutt/mutt.h"
#include "gui/lib.h"
#include "version.h"
+ Include dependency graph for version.c:

Go to the source code of this file.

Data Structures

struct  CompileOptions
 List of built-in capabilities. More...
 

Functions

const char * mutt_make_version (void)
 Generate the NeoMutt version string. More...
 
const char * mutt_hcache_backend_list (void)
 Get a list of backend names. More...
 
static void print_compile_options (struct CompileOptions *co, FILE *fp)
 Print a list of enabled/disabled features. More...
 
static char * rstrip_in_place (char *s)
 Strip a trailing carriage return. More...
 
void print_version (FILE *fp)
 Print system and compile info to a file. More...
 
void print_copyright (void)
 Print copyright message. More...
 
bool feature_enabled (const char *name)
 Test if a compile-time feature is enabled. More...
 

Variables

const int SCREEN_WIDTH = 80
 
unsigned char cc_cflags []
 
unsigned char configure_options []
 
static const char * Copyright
 
static const char * Thanks
 
static const char * License
 
static const char * ReachingUs
 
static const char * Notice
 
static struct CompileOptions comp_opts_default []
 
static struct CompileOptions comp_opts []
 

Detailed Description

Display version and copyright about NeoMutt.

Authors
  • Michael R. Elkins
  • Thomas Roessler
  • Richard Russon

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file version.c.

Function Documentation

◆ mutt_make_version()

const char* mutt_make_version ( void  )

Generate the NeoMutt version string.

Return values
ptrVersion string
Note
This returns a pointer to a static buffer

Definition at line 1559 of file muttlib.c.

1560 {
1561  static char vstring[256];
1562  snprintf(vstring, sizeof(vstring), "NeoMutt %s%s", PACKAGE_VERSION, GitVer);
1563  return vstring;
1564 }
const char * GitVer
+ Here is the caller graph for this function:

◆ mutt_hcache_backend_list()

const char* mutt_hcache_backend_list ( void  )

Get a list of backend names.

get a list of backend identification strings

Return values
ptrComma-space-separated list of names

The caller should free the string.

Definition at line 472 of file hcache.c.

473 {
474  char tmp[256] = { 0 };
475  const struct HcacheOps **ops = hcache_ops;
476  size_t len = 0;
477 
478  for (; *ops; ops++)
479  {
480  if (len != 0)
481  {
482  len += snprintf(tmp + len, sizeof(tmp) - len, ", ");
483  }
484  len += snprintf(tmp + len, sizeof(tmp) - len, "%s", (*ops)->name);
485  }
486 
487  return mutt_str_strdup(tmp);
488 }
const struct HcacheOps * hcache_ops[]
Backend implementations.
Definition: hcache.c:79
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
Header Cache API.
Definition: backend.h:34
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ print_compile_options()

static void print_compile_options ( struct CompileOptions co,
FILE *  fp 
)
static

Print a list of enabled/disabled features.

Parameters
coArray of compile options
fpfile to write to

Two lists are generated and passed to this function:

One list which just uses the configure state of each feature. One list which just uses feature which are set to on directly in NeoMutt.

The output is of the form: "+enabled_feature -disabled_feature" and is wrapped to SCREEN_WIDTH characters.

Definition at line 318 of file version.c.

319 {
320  size_t used = 2;
321  bool tty = fp ? isatty(fileno(fp)) : false;
322 
323  fprintf(fp, " ");
324  for (int i = 0; co[i].name; i++)
325  {
326  const size_t len = strlen(co[i].name) + 2; /* +/- and a space */
327  if ((used + len) > SCREEN_WIDTH)
328  {
329  used = 2;
330  fprintf(fp, "\n ");
331  }
332  used += len;
333  const char *fmt = "?%s ";
334  switch (co[i].enabled)
335  {
336  case 0: // Disabled
337  if (tty)
338  fmt = "\033[1;31m-%s\033[0m "; // Escape, red
339  else
340  fmt = "-%s ";
341  break;
342  case 1: // Enabled
343  if (tty)
344  fmt = "\033[1;32m+%s\033[0m "; // Escape, green
345  else
346  fmt = "+%s ";
347  break;
348  case 2: // Devel only
349  if (tty)
350  fmt = "\033[1;36m!%s\033[0m "; // Escape, cyan
351  else
352  fmt = "!%s ";
353  break;
354  }
355  fprintf(fp, fmt, co[i].name);
356  }
357  fprintf(fp, "\n");
358 }
const char * name
Definition: version.c:111
const char * name
Definition: pgpmicalg.c:46
const int SCREEN_WIDTH
Definition: version.c:55
+ Here is the caller graph for this function:

◆ rstrip_in_place()

static char* rstrip_in_place ( char *  s)
static

Strip a trailing carriage return.

Parameters
sString to be modified
Return values
ptrThe modified string

The string has its last carriage return set to NUL.

Definition at line 367 of file version.c.

368 {
369  if (!s)
370  return NULL;
371 
372  char *p = &s[strlen(s)];
373  if (p == s)
374  return s;
375  p--;
376  while ((p >= s) && ((*p == '\n') || (*p == '\r')))
377  *p-- = '\0';
378  return s;
379 }
+ Here is the caller graph for this function:

◆ print_version()

void print_version ( FILE *  fp)

Print system and compile info to a file.

Parameters
fp- file to print to

Print information about the current system NeoMutt is running on. Also print a list of all the compile-time information.

Definition at line 388 of file version.c.

389 {
390  struct utsname uts;
391  bool tty = fp ? isatty(fileno(fp)) : false;
392  const char *fmt = "%s\n";
393 
394  if (tty)
395  fmt = "\033[1;36m%s\033[0m\n"; // Escape, cyan
396 
397  fprintf(fp, fmt, mutt_make_version());
398  fprintf(fp, "%s\n", _(Notice));
399 
400  uname(&uts);
401 
402 #ifdef SCO
403  fprintf(fp, "System: SCO %s", uts.release);
404 #else
405  fprintf(fp, "System: %s %s", uts.sysname, uts.release);
406 #endif
407 
408  fprintf(fp, " (%s)", uts.machine);
409 
410 #ifdef NCURSES_VERSION
411  fprintf(fp, "\nncurses: %s (compiled with %s.%d)", curses_version(),
412  NCURSES_VERSION, NCURSES_VERSION_PATCH);
413 #elif defined(USE_SLANG_CURSES)
414  fprintf(fp, "\nslang: %s", SLANG_VERSION_STRING);
415 #endif
416 
417 #ifdef _LIBICONV_VERSION
418  fprintf(fp, "\nlibiconv: %d.%d", _LIBICONV_VERSION >> 8, _LIBICONV_VERSION & 0xff);
419 #endif
420 
421 #ifdef HAVE_LIBIDN
422  fprintf(fp, "\n%s", mutt_idna_print_version());
423 #endif
424 
425 #ifdef CRYPT_BACKEND_GPGME
426  fprintf(fp, "\nGPGme: %s", mutt_gpgme_print_version());
427 #endif
428 
429 #ifdef HAVE_NOTMUCH
430  fprintf(fp, "\nlibnotmuch: %d.%d.%d", LIBNOTMUCH_MAJOR_VERSION,
431  LIBNOTMUCH_MINOR_VERSION, LIBNOTMUCH_MICRO_VERSION);
432 #endif
433 
434 #ifdef USE_HCACHE
435  const char *backends = mutt_hcache_backend_list();
436  fprintf(fp, "\nhcache backends: %s", backends);
437  FREE(&backends);
438 #endif
439 
441  fprintf(fp, "\n\nConfigure options: %s\n", (char *) configure_options);
442 
443  rstrip_in_place((char *) cc_cflags);
444  fprintf(fp, "\nCompilation CFLAGS: %s\n", (char *) cc_cflags);
445 
446  fprintf(fp, "\n%s\n", _("Default options:"));
448 
449  fprintf(fp, "\n%s\n", _("Compile options:"));
451 
452 #ifdef DOMAIN
453  fprintf(fp, "DOMAIN=\"%s\"\n", DOMAIN);
454 #endif
455 #ifdef ISPELL
456  fprintf(fp, "ISPELL=\"%s\"\n", ISPELL);
457 #endif
458  fprintf(fp, "MAILPATH=\"%s\"\n", MAILPATH);
459 #ifdef MIXMASTER
460  fprintf(fp, "MIXMASTER=\"%s\"\n", MIXMASTER);
461 #endif
462  fprintf(fp, "PKGDATADIR=\"%s\"\n", PKGDATADIR);
463  fprintf(fp, "SENDMAIL=\"%s\"\n", SENDMAIL);
464  fprintf(fp, "SYSCONFDIR=\"%s\"\n", SYSCONFDIR);
465 
466  fprintf(fp, "\n");
467  fputs(_(ReachingUs), fp);
468 }
unsigned char configure_options[]
static struct CompileOptions comp_opts[]
Definition: version.c:151
const char * mutt_hcache_backend_list(void)
Get a list of backend names.
Definition: hcache.c:472
#define _(a)
Definition: message.h:28
#define ISPELL
Definition: init.h:119
static struct CompileOptions comp_opts_default[]
Definition: version.c:117
static char * rstrip_in_place(char *s)
Strip a trailing carriage return.
Definition: version.c:367
static const char * ReachingUs
Definition: version.c:92
unsigned char cc_cflags[]
const char * mutt_gpgme_print_version(void)
Get version of GPGME.
Definition: crypt_gpgme.c:5863
const char * mutt_idna_print_version(void)
Create an IDN version string.
Definition: idna.c:313
#define FREE(x)
Definition: memory.h:40
static void print_compile_options(struct CompileOptions *co, FILE *fp)
Print a list of enabled/disabled features.
Definition: version.c:318
const char * mutt_make_version(void)
Generate the NeoMutt version string.
Definition: muttlib.c:1559
static const char * Notice
Definition: version.c:99
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ print_copyright()

void print_copyright ( void  )

Print copyright message.

Print the authors' copyright messages, the GPL license and some contact information for the NeoMutt project.

Definition at line 476 of file version.c.

477 {
478  puts(mutt_make_version());
479  puts(Copyright);
480  puts(_(Thanks));
481  puts(_(License));
482  puts(_(ReachingUs));
483 }
#define _(a)
Definition: message.h:28
static const char * Copyright
Definition: version.c:60
static const char * ReachingUs
Definition: version.c:92
static const char * Thanks
Definition: version.c:72
const char * mutt_make_version(void)
Generate the NeoMutt version string.
Definition: muttlib.c:1559
static const char * License
Definition: version.c:76
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ feature_enabled()

bool feature_enabled ( const char *  name)

Test if a compile-time feature is enabled.

Parameters
nameCompile-time symbol of the feature
Return values
trueFeature enabled
falseFeature not enabled, or not compiled in

Many of the larger features of neomutt can be disabled at compile time. They define a symbol and use ifdef's around their code. The symbols are mirrored in "CompileOptions comp_opts[]" in this file.

This function checks if one of these symbols is present in the code.

These symbols are also seen in the output of "neomutt -v".

Definition at line 500 of file version.c.

501 {
502  if (!name)
503  return false;
504  for (int i = 0; comp_opts_default[i].name; i++)
505  {
507  {
508  return true;
509  }
510  }
511  for (int i = 0; comp_opts[i].name; i++)
512  {
513  if (mutt_str_strcmp(name, comp_opts[i].name) == 0)
514  {
515  return comp_opts[i].enabled;
516  }
517  }
518  return false;
519 }
static struct CompileOptions comp_opts[]
Definition: version.c:151
const char * name
Definition: version.c:111
static struct CompileOptions comp_opts_default[]
Definition: version.c:117
const char * name
Definition: pgpmicalg.c:46
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:615
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ SCREEN_WIDTH

const int SCREEN_WIDTH = 80

Definition at line 55 of file version.c.

◆ cc_cflags

unsigned char cc_cflags[]

◆ configure_options

unsigned char configure_options[]

◆ Copyright

const char* Copyright
static
Initial value:
=
"Copyright (C) 1996-2016 Michael R. Elkins <me@mutt.org>\n"
"Copyright (C) 1996-2002 Brandon Long <blong@fiction.net>\n"
"Copyright (C) 1997-2009 Thomas Roessler <roessler@does-not-exist.org>\n"
"Copyright (C) 1998-2005 Werner Koch <wk@isil.d.shuttle.de>\n"
"Copyright (C) 1999-2017 Brendan Cully <brendan@kublai.com>\n"
"Copyright (C) 1999-2002 Tommi Komulainen <Tommi.Komulainen@iki.fi>\n"
"Copyright (C) 2000-2004 Edmund Grimley Evans <edmundo@rano.org>\n"
"Copyright (C) 2006-2009 Rocco Rutte <pdmef@gmx.net>\n"
"Copyright (C) 2014-2019 Kevin J. McCarthy <kevin@8t8.us>\n"
"Copyright (C) 2015-2019 Richard Russon <rich@flatcap.org>\n"

Definition at line 60 of file version.c.

◆ Thanks

const char* Thanks
static
Initial value:
=
N_("Many others not mentioned here contributed code, fixes,\n"
"and suggestions.\n")
#define N_(a)
Definition: message.h:32

Definition at line 72 of file version.c.

◆ License

const char* License
static
Initial value:
= N_(
" This program is free software; you can redistribute it and/or modify\n"
" it under the terms of the GNU General Public License as published by\n"
" the Free Software Foundation; either version 2 of the License, or\n"
" (at your option) any later version.\n"
"\n"
" This program is distributed in the hope that it will be useful,\n"
" but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
" GNU General Public License for more details.\n"
"\n"
" You should have received a copy of the GNU General Public License\n"
" along with this program; if not, write to the Free Software\n"
" Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA "
"02110-1301, USA.\n")
#define N_(a)
Definition: message.h:32

Definition at line 76 of file version.c.

◆ ReachingUs

const char* ReachingUs
static
Initial value:
=
N_("To learn more about NeoMutt, visit: https://neomutt.org\n"
"If you find a bug in NeoMutt, please raise an issue at:\n"
" https://github.com/neomutt/neomutt/issues\n"
"or send an email to: <neomutt-devel@neomutt.org>\n")
#define N_(a)
Definition: message.h:32

Definition at line 92 of file version.c.

◆ Notice

const char* Notice
static
Initial value:
=
N_("Copyright (C) 1996-2016 Michael R. Elkins and others.\n"
"NeoMutt comes with ABSOLUTELY NO WARRANTY; for details type 'neomutt -vv'.\n"
"NeoMutt is free software, and you are welcome to redistribute it\n"
"under certain conditions; type 'neomutt -vv' for details.\n")
#define N_(a)
Definition: message.h:32

Definition at line 99 of file version.c.

◆ comp_opts_default

struct CompileOptions comp_opts_default[]
static

Definition at line 117 of file version.c.

◆ comp_opts

struct CompileOptions comp_opts[]
static

Definition at line 151 of file version.c.