---
name: "C::Scan"
section: "3pm"
platform: "linux"
package: "libc-scan-perl"
version: "0.74-7"
release: "Debian 4.0 (Etch)"
platforms: ["linux"]
url: "https://new.carta.tech/C::Scan"
---

# C::Scan(3pm)

C::Scan - scan C language files for easily recognized constructs.

```
  $c = new C::Scan 'filename' => $filename, 'filename_filter' => $filter,
                   'add_cppflags' => $addflags;
  $c->set('includeDirs' => [$Config::Config{shrpdir}]);
```

```
  my $fdec = $c->get('parsed_fdecls');
```

**This description is** ***VERY*** **incomplete.** This module uses `"Data::Flow"` interface, thus one uses it in the following fashion:

```
  $c = new C::Scan(attr1 => $value1, attr2 => $value2);
  $c->set( attr3 => $value3 );
```

```
  $value4 = $c->get('attr4');
```

Attributes are depending on some other attributes. The only *required* attribute, i.e., the attribute which *should* be set, is `"filename"`, which denotes which file to parse. All other attributes are either optional, or would be calculated basing on values of required and optional attributes.\
 **Output attributes** Value: reference to a list of included files. Value: reference to hash of macros with arguments. The values are references to an array of length 2, the first element is a reference to the list of arguments, the second one being the expansion. Newlines are not unescaped, thus

```
  #define C(x,y) E\
                 F
```

will finish with `"("C" => [ ["x", "y"], "E\nF"])"`. Value: reference to hash of macros without arguments.  Newlines are not escaped, thus

```
  #define A B
```

will finish with `"("A" => "B")"`. Value: reference to list of declarations of functions. Value: reference to list of definitions of functions. Value: reference to list of parsed declarations of functions.

A parsed declaration is a reference to a list of `"(rt, nm, args, ft,` `mod)"`. Here `"rt"` is return type of a function, `"nm"` is the name, `"args"` is the list of arguments, `"ft"` is the full text of the declaration, and `"mod"` is the modifier (which is always `"undef"`).

Each entry in the list `"args"` is of the same form `"(ty, nm, args,` `ft, mod)"`, here `"ty"` is the type of an argument, `"nm"` is the name (a generated one if missing in the declaration), `"args"` is `"undef"`, and `"mod"` is the string of array modifiers. Value: a reference to a hash which contains known `"typedef"`s as keys. Values of the hash are array references of length 2, with what should be put before/after the type for a standalone typedef declaration (but without the `"typedef"` substring).

Parse uses naive heuristics. Value: a reference to a list which contains known expansions of `"typedef"`s. Value: a reference to a list of `"typedef"`ed names.  Heuristics are used. Value: a reference to a list of `"extern"` variable declarations. Value: a reference to a hash of parsed `"extern"` variable declarations, containing the variable names as keys. Values of the hash are array references of length 2, with what should be put before/after the name for a standalone extern variable declaration (but without the `"extern"` substring). Value: a reference to a hash of parsed struct declarations from typedefs. Keys are typedefed names, values are `"undef"` if not a struct or union, else an array reference of definitions of the elements of the structure; each definition is itself an array reference of length 3, consisting of what should be put before/after the name for a standalone variable declaration, followed by the name of the element. Anonymous structs and unions used within the definitions are given an arbitrary name including the string `"ANON"`, and referred to using that name.