---
name: "ccconfig"
section: "1p"
platform: "linux"
package: "libconvert-binary-c-perl"
version: "0.85-1+b1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/ccconfig"
---

# ccconfig(1p)

Get Convert::Binary::C configuration for a compiler

## NAME

ccconfig - Get Convert::Binary::C configuration for a compiler

## SYNOPSIS

ccconfig *options* \[-- compiler-options\]

*options*:

```
  -c
  --cc             compiler   compiler executable to test
                              default: auto-determined

  -o
  --output-file    file       output filename
                              default: output to stdout
  -f
  --output-format  format     output format
                              default: dumper
  --basename       name       basename of the temporary test files
                              default: _t_e_s_t
  -I
  --inc-path       path       manually set compiler include path
  --preprocess     rule       compiler rule for preprocessing
  --compile-obj    rule       compiler rule for compiling objects
  --compile-exe    rule       compiler rule for compiling executables
  --c-ext          ext        extension of C source files
  --pp-ext         ext        extension of preprocessor output files
  --obj-ext        ext        extension of object files
  --exe-ext        ext        extension of executable files
  --nodelete                  don't delete temporary files
  --norun                     don't try to run executables
  --quiet                     don't display anything
  --nostatus                  don't display status indicator

  --version                   print version number

  --debug                     debug mode
```

Placeholders allowed in compiler rules:

```
  %c    C source file
  %o    object file
  %e    executable file
  %i    preprocessor output file
  |     result is written to stdout (only at end of rule)
```

## DESCRIPTION

`"ccconfig"` will try to determine a usable configuration for Convert::Binary::C from testing a compiler executable. It is not necessary that the binaries generated by the compiler can be executed, so `"ccconfig"` can also be used for cross-compilers.

This tool is still experimental, and you should neither rely on its output without checking, nor expect it to work in your environment.

## OPTIONS

### "--cc" compiler

This option allows you to explicitly specify a compiler executable. This is especially useful if you don't want to use your system compiler. If this options is not given, `"ccconfig"` tries to guess a compiler.

### "--output-file" file

Write Convert::Binary::C configuration to the specified file. The default is to write the configuration to `"stdout"`.

### "--output-format" format

Specify the output format of the Convert::Binary::C configuration. The following formats are currently supported:

```
  dumper      Output a %config hash using Data::Dumper
  require     Output in a format suitable for require
```

The default is `"dumper"`.

### "--basename" name

Allows you to change the base name of the temporary test files. This is used along with the various `"-ext"` options to build the filenames of C source files, preprocessor output files, object files and executables.

### "--inc-path" path

This option allows you to manually set the include path of the compiler. This is useful if `"ccconfig"` cannot determine the include path automatically, most probably because it cannot parse the preprocessor output. This option can be specified more than once.

### "--preprocess" rule

Using this option, you can specify a *rule* that `"ccconfig"` uses to run the compiler to get preprocessor output. Most compilers write the preprocessor output to standard output when given the `"-E"` option, i.e.

```
  cc -E foo.c
```

will preprocess *foo.c* to standard output. The corresponding rule for `"ccconfig"` would be:

```
  ccconfig --preprocess='-E %c |'
```

The \<%c\> will be replaced with the C source filename, and the pipe symbol signals that the result will be written to standard output.

The following placeholders can be used in `"ccconfig"` rules:

```
  %c    C source file
  %o    object file
  %e    executable file
  %i    preprocessor output file
```

Usually, `"ccconfig"` tries to figure out the correct rules on its own.

### "--compile-obj" rule

Like `"--preprocess"`, this option allows you to define a rule for how to compile an object file. For most compilers, this rule will be something like

```
  ccconfig --compile-obj='-c -o %o %c'
```

### "--compile-exe" rule

Like `"--preprocess"`, this option allows you to define a rule for how to compile an executable file. For most compilers, this rule will be something like

```
  ccconfig --compile-exe='-o %e %c'
```

Note that it is sufficient to specify either `"--compile-obj"` or `"--compile-exe"`. So if your compiler can only create object files, that's just fine.

### "--c-ext"

This option is used along with `"--basename"` to build the name of a C source file. This is usually set to `".c"`.

### "--pp-ext"

This option is used along with `"--basename"` to build the name of a preprocessor output file.

### "--obj-ext"

This option is used along with `"--basename"` to build the name of an object file.

### "--exe-ext"

This option is used along with `"--basename"` to build the name of an executable file.

### "--nodelete"

Don't attempt to delete temporary files that have been created by the compiler. Normally, `"ccconfig"` will look for all files with the same basename as the temporary test file and delete them.

### "--norun"

You can specify this option if the executables generated by your compiler cannot be run on your machine, i.e. if you have a cross-compiler. However, `"ccconfig"` will automatically find out that it cannot run the executables.

When this option is set, a different set of algorithms is used to determine a couple of configuration settings. These algorithms are all based upon placing a special signature in the object file. They are less reliable that the standard algorithms, so you shouldn't use them unless you have to.

### "--quiet"

Don't display anything except for the final configuration.

### "--nostatus"

Hide the status indicator. Recommended if you want to redirect the script output to a file:

```
  ccconfig --nostatus >config.pl 2>ccconfig.log
```

### "--version"

Writes the program name, version and path to standard output.

### "--debug"

Generate tons of debug output. Don't use unless you know what you're doing.

## EXAMPLES

Normally, a simple

```
  ccconfig
```

without arguments is enough if you want the configuration for your system compiler. While `"ccconfig"` is running, it will write lots of status information to `"stderr"`. When it's done, it will usually dump a Perl hash table to `"stdout"` which can be directly used as a configuration for Convert::Binary::C.

If you want the configuration for a different compiler, or `"ccconfig"` cannot determine your system compiler automatically, use

```
  ccconfig -c gcc32
```

if your compiler's name is `"gcc32"`.

If you want to pass additional options to the compiler, you can do so after a double-dash on the command line:

```
  ccconfig -- -g -DDEBUGGING
```

or

```
  ccconfig -c gcc32 -- -ansi -fshort-enums
```

If you'd like to interface with the Perl core, you may find a suitable configuration using something like:

```
  ccconfig --cc=`perl -MConfig -e 'print $Config{cc}'` \
           -- `perl -MConfig -e 'print $Config{ccflags}'`
```

## COPYRIGHT

Copyright (c) 2002-2024 Marcus Holland-Moritz. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

## SEE ALSO

See Convert::Binary::C.