# Control Flow Abstraction Generator

> Generate abstract Control Flow Graph (CFG) representations of programs showing loops, branches, and function calls for static analysis or verification. Use when users need to: (1) Visualize program control flow structure, (2) Generate CFGs for static analysis tools, (3) Create control flow abstractions for formal verification, (4) Analyze program paths and reachability, (5) Document program struc…

- **Type:** Skill
- **Install:** `agentstack add skill-arabelatso-skills-4-se-control-flow-abstraction-generator`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [ArabelaTso](https://agentstack.voostack.com/s/arabelatso)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [ArabelaTso](https://github.com/ArabelaTso)
- **Source:** https://github.com/ArabelaTso/Skills-4-SE/tree/main/skills/control-flow-abstraction-generator
- **Website:** https://ArabelaTso.github.io/Skills-4-SE/

## Install

```sh
agentstack add skill-arabelatso-skills-4-se-control-flow-abstraction-generator
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Control Flow Abstraction Generator

Generate abstract Control Flow Graph representations of programs.

## Overview

This skill analyzes program code and generates Control Flow Graphs (CFGs) that abstract the program's control flow structure. CFGs show how execution flows through the program via nodes (statements, conditions) and edges (control transfers), making them suitable for static analysis, formal verification, and program understanding.

## How to Use

Provide:
1. **Program code**: Function or program to analyze
2. **Analysis scope**: Function-level or program-level
3. **Output format** (optional): Textual, DOT, JSON, or multiple

The skill will generate:
- CFG with nodes and edges
- Node types (entry, exit, statement, condition, merge)
- Edge types (sequential, true/false branches, back edges, calls)
- Optional: DOT format for visualization, JSON for tool integration

## CFG Generation Workflow

### Step 1: Parse Program Structure

Identify program constructs:
- **Sequential statements**: Assignments, expressions, declarations
- **Conditional statements**: if-then-else, switch-case
- **Loop statements**: while, for, do-while
- **Function calls**: Direct calls, recursive calls
- **Control transfers**: break, continue, return, goto
- **Exception handling**: try-catch-finally

### Step 2: Create CFG Nodes

Generate nodes for each construct:

**Entry Node**: Function/program start
- Label: `ENTRY` or function name
- Type: `entry`
- Successors: First statement

**Exit Node**: Function/program end
- Label: `EXIT` or `return`
- Type: `exit`
- Predecessors: All return points

**Statement Node**: Regular statement
- Label: Statement text or line number
- Type: `statement`
- Represents: Assignment, call, expression

**Condition Node**: Branch decision
- Label: Boolean expression
- Type: `condition`
- Successors: True branch, false branch

**Merge Node**: Branch join point
- Label: `MERGE` or empty
- Type: `merge`
- Predecessors: Multiple branches

### Step 3: Create CFG Edges

Connect nodes with appropriate edges:

**Sequential Edge**: Normal flow
- From: Statement/node
- To: Next statement/node
- Label: None or `→`

**True Edge**: Condition true branch
- From: Condition node
- To: True branch first statement
- Label: `T` or `true`

**False Edge**: Condition false branch
- From: Condition node
- To: False branch first statement
- Label: `F` or `false`

**Back Edge**: Loop iteration
- From: Loop body end
- To: Loop header
- Label: `↶` or `back`

**Call Edge**: Function invocation (interprocedural)
- From: Call site
- To: Called function entry
- Label: `⇒` or `call`

**Return Edge**: Function return (interprocedural)
- From: Called function exit
- To: Call site return point
- Label: `⇐` or `return`

### Step 4: Handle Special Constructs

**Loops**: Create back edges from body to header

**Break**: Create edge from break statement to loop exit

**Continue**: Create back edge from continue to loop header

**Return**: Create edge from return to EXIT node

**Exceptions**: Create exception edges from try block to catch handlers

### Step 5: Generate Output

Produce CFG in requested format(s):
- Textual representation
- DOT format for Graphviz
- JSON for tool integration

## Example: Simple Conditional

**Code**:
```python
def max_value(x, y):
    if x > y:
        result = x
    else:
        result = y
    return result
```

**CFG (Textual)**:
```
Node 1 (ENTRY):
  Label: max_value
  Successors: [2]

Node 2 (x > y):
  Type: condition
  Predecessors: [1]
  Successors: [3 (true), 4 (false)]

Node 3 (result = x):
  Type: statement
  Predecessors: [2]
  Successors: [5]

Node 4 (result = y):
  Type: statement
  Predecessors: [2]
  Successors: [5]

Node 5 (MERGE):
  Type: merge
  Predecessors: [3, 4]
  Successors: [6]

Node 6 (return result):
  Type: statement
  Predecessors: [5]
  Successors: [7]

Node 7 (EXIT):
  Predecessors: [6]
```

**CFG (Visual)**:
```
    ENTRY
      ↓
   [x > y]
    ↓   ↓
   T↓   ↓F
    ↓   ↓
[result=x] [result=y]
    ↓       ↓
    └→MERGE←┘
        ↓
  [return result]
        ↓
      EXIT
```

**CFG (DOT)**:
```dot
digraph CFG {
  node [shape=box];

  n1 [label="ENTRY", shape=ellipse];
  n2 [label="x > y", shape=diamond];
  n3 [label="result = x"];
  n4 [label="result = y"];
  n5 [label="MERGE", shape=circle];
  n6 [label="return result"];
  n7 [label="EXIT", shape=ellipse];

  n1 -> n2;
  n2 -> n3 [label="T", color=green];
  n2 -> n4 [label="F", color=red];
  n3 -> n5;
  n4 -> n5;
  n5 -> n6;
  n6 -> n7;
}
```

## Example: While Loop

**Code**:
```python
def sum_to_n(n):
    sum = 0
    i = 0
    while i  threshold:
            result.append(item * 2)
        else:
            if item  threshold]       ↑
  ↓T            ↓F       ↑
[result.append  [item ():
  Type: 
  Predecessors: []
  Successors: []
```

### DOT Format (Graphviz)

Graph visualization format:
```dot
digraph CFG {
  node [shape=box];
  n1 [label="...", shape=...];
  n1 -> n2 [label="...", color=...];
}
```

Generate PNG/SVG with: `dot -Tpng cfg.dot -o cfg.png`

### JSON Format

Machine-readable for tool integration:
```json
{
  "nodes": [
    {"id": 1, "label": "...", "type": "..."}
  ],
  "edges": [
    {"from": 1, "to": 2, "type": "..."}
  ]
}
```

## Analysis Levels

### Function-Level (Intraprocedural)

**Scope**: Single function
**Nodes**: Statements within function
**Edges**: Control flow within function
**Calls**: Treated as single statement nodes

**Use cases**:
- Function-level analysis
- Loop detection
- Path analysis within function

### Program-Level (Interprocedural)

**Scope**: Multiple functions
**Nodes**: Statements across all functions
**Edges**: Control flow + call/return edges
**Calls**: Explicit call and return edges

**Use cases**:
- Whole-program analysis
- Call graph construction
- Interprocedural dataflow

## CFG Properties

### Dominance

Node A dominates node B if every path from ENTRY to B passes through A.

**Uses**: Loop header identification, optimization

### Post-Dominance

Node A post-dominates node B if every path from B to EXIT passes through A.

**Uses**: Control dependence, merge point identification

### Reachability

Node B is reachable from node A if there exists a path from A to B.

**Uses**: Dead code detection, path analysis

### Strongly Connected Components

Maximal set of nodes where every node is reachable from every other.

**Uses**: Loop detection, cycle analysis

## Common Patterns

### Sequential Statements
**Pattern**: Linear flow
**See**: [cfg_patterns.md](references/cfg_patterns.md#sequential-statements)

### If-Then-Else
**Pattern**: Diamond shape with merge
**See**: [cfg_patterns.md](references/cfg_patterns.md#conditional-statements)

### While Loop
**Pattern**: Back edge from body to header
**See**: [cfg_patterns.md](references/cfg_patterns.md#loop-statements)

### Break/Continue
**Pattern**: Direct edges to exit/header
**See**: [cfg_patterns.md](references/cfg_patterns.md#loop-statements)

### Try-Catch
**Pattern**: Exception edges to handlers
**See**: [cfg_patterns.md](references/cfg_patterns.md#exception-handling)

## References

Detailed CFG construction patterns:

- **[cfg_patterns.md](references/cfg_patterns.md)**: Comprehensive patterns for all control flow constructs with examples

Load this reference when:
- Need detailed patterns for specific constructs
- Working with complex nested structures
- Want to see all output format examples
- Need CFG property definitions

## Tips

1. **Start with entry/exit**: Always create ENTRY and EXIT nodes first
2. **Handle loops carefully**: Identify loop headers and create back edges
3. **Merge branches**: Create explicit merge nodes after conditionals
4. **Label edges clearly**: Use T/F for branches, mark back edges
5. **Consider scope**: Choose function-level or program-level based on use case
6. **Visualize complex CFGs**: Use DOT format for large graphs
7. **Validate structure**: Check that all nodes are reachable from ENTRY
8. **Document assumptions**: Note how you handle language-specific constructs

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [ArabelaTso](https://github.com/ArabelaTso)
- **Source:** [ArabelaTso/Skills-4-SE](https://github.com/ArabelaTso/Skills-4-SE)
- **License:** Apache-2.0
- **Homepage:** https://ArabelaTso.github.io/Skills-4-SE/

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-arabelatso-skills-4-se-control-flow-abstraction-generator
- Seller: https://agentstack.voostack.com/s/arabelatso
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.