ACE — ABAP Code Explorer
Read any ABAP program like a map — without starting a single debugger session.
ACE is a SAP GUI tool that parses ABAP source statically and answers the questions you normally
burn hours on in the debugger: what calls what, where a value really comes from, which branch is
actually reachable, and how risky a piece of code is. It never executes the analysed code and
never changes it — it only reads the source.
Also outside SAP GUI. The code metrics are available in Eclipse ADT and in VS Code through
VERTEX · Marketplace.
It reads ACE over an ADT resource that lives in
Simple-Data-Explorer, so both repositories
have to be on the system.
In the construction phase. Metrics only so far — the call map, the slicing and the skeletons
are still SAP GUI.
What ACE gives you
| The situation you are in | What you normally do | What ACE does |
|---|
| You inherited a 6000-line report and have to change it by Friday | Set breakpoints, find a transaction that reaches the code, hope you have the right data | Open it, read the call tree and the flow diagram — no data, no transaction, no authorizations needed |
| "Where does this field get its value from?" | Watchpoints, step-through, restart, repeat | Double-click the variable → ACE shows every statement that contributes to it, across method and FORM boundaries |
| "What will my change break?" | Where-used list, then guessing | Static call map of the whole program or package, with depth control |
| "Which parts of this legacy object are dangerous?" | Gut feeling | McCabe complexity, Halstead, Maintainability Index per method/FORM/module, hotspots sorted |
| "I need to explain this object to a colleague or an LLM" | Copy 3000 lines of source | Skeleton view — structure, calls and DB access with line numbers, on one screen |
Concretely, ACE lets you:
- Analyse code you cannot run. Debugging needs the right transaction, the right data, the right
authorizations, and often a system you do not have. ACE needs only the object name and read access
to the source.
- Do backward program slicing ("watchpoints without the debugger"). Mark one or more variables and
ACE builds the data dependency chain that produces them — resolving parameter renaming
(
IV_ → EV_ and back) at any call depth.
- See the whole picture instead of one call stack. Call flow, static class/call map and control
structure schemes as Mermaid diagrams, clickable back into the source.
- Ignore the noise. Only Z mode follows customer code only (
Z*, Y* and /NAMESPACE/*),
so SAP standard does not flood the picture.
- Work on several objects at once. Every object opens in its own window — as many as your screen fits.
- Move on to the real tools when needed. One click opens the current unit in Eclipse (ADT); breakpoints
can be set straight from the ACE source view.
Typical users: consultants dropped into an unfamiliar system, developers taking over foreign code,
reviewers doing impact analysis before an upgrade, and anyone who has to document a system nobody
remembers writing.
Table of contents
Demo
Short video demo (Loom)
Selection screen — type an object name and press Enter:
The analysis window — tree, source and units:
Multi-window: open as many objects as your display fits:
Requirements
| |
|---|
| Backend | SAP NetWeaver AS ABAP 7.50+ (modern ABAP syntax: NEW, VALUE, COND, string templates) |
| Frontend | SAP GUI for Windows — the UI is built on GUI controls (ALV, ABAP editor control, HTML viewer, splitters) |
| Authorizations | Read access to the source of the objects you analyse (S_DEVELOP display) |
| Optional | abapMermaid for the diagram windows |
ACE is read-only: it parses source from the repository and never executes the analysed object.
The only write operations it can perform are the breakpoints you set yourself from the source view.
Installation
Option A: abapGit (recommended)
- Install abapGit if it is not there yet.
- Create a package, e.g.
$ACE (local) or a transportable ZACE.
- In abapGit: New Online → repository
https://github.com/ysichov/ACE → your package.
- Pull and activate all objects.
- Run report
Z_ACE.
Option B: single file
If you cannot use abapGit, src/z_ace_standalone.prog.abap is the whole tool merged into one report
(generated with abapmerge, post-processed to compile on 7.50).
SE38 → create report Z_ACE_STANDALONE (executable program).- Paste the content of
src/z_ace_standalone.prog.abap.
- Activate and run.
The standalone file is generated. Never edit it by hand — change the individual classes and
regenerate (see Development).
Optional: Mermaid diagrams
The diagram windows need abapMermaid installed in the same
system. At startup ACE checks for class ZCL_WD_GUI_MERMAID_JS_DIAGRAM; if it is missing, the
Flow and Map buttons are simply not shown and everything else keeps working.
Quick start
- Run report
Z_ACE (SE38 / SA38, or create a transaction for it).
- Type a program name into Program and press Enter.
F8 is deliberately disabled — Enter is what launches the analysis.
- A new analysis window opens. On the left you get the object tree, on the right the source.
- Double-click any node in the tree (event, FORM, method, function) to jump to it.
- Press Code Flow to build the linear execution sequence, or Map for the static call map.
- Open another object from the selection screen — it appears in its own window, side by side.
Entry points
The selection screen accepts several object types; all of them are resolved to the underlying
program/include that ACE parses.
| Field | You enter | ACE opens |
|---|
| Program | Report, module pool, include | the program itself |
| Package | Development package | every PROG / CLAS / INTF / FUGR in it, parsed lazily on demand — see Package mode |
| Class | Global class or interface | the class pool (ZCL_X====CP) or interface pool (====IP) |
| Function module | FM name | the generated include of the function group (via TFDIR) |
| OData service | Gateway project | the backend service class (via /IWBEP/I_MGW_SRH) |
| WDC component | Web Dynpro component | the generated component class (via CL_WDY_WB_NAMING_SERVICE) |
The ACE window
Layout
┌──────────────────────────────────────────────────────────────┐
│ main toolbar: Flow · Map · Code Flow · Handlers · Only Z ... │
├───────────────────────┬──────────────────────────────────────┤
│ │ view toolbar: view mode · fold · ... │
│ Objects & Code Flow ├──────────────────────────────────────┤
│ tree (35%) │ │
│ │ Source viewer (classic or HTML) │
│ │ │
├───────────────────────┴──────────────────────────────────────┤
│ Units / steps (ALV) │
└──────────────────────────────────────────────────────────────┘
Every analysed object gets its own dialog window, so several programs can be compared side by side.
Object tree
The left panel ("Objects & Code Flow") is built lazily — subnodes are parsed when you expand them,
so opening a huge program stays fast. It contains:
- includes and their structure
- events (
START-OF-SELECTION, AT SELECTION-SCREEN, …)
- FORMs and dialog modules
- function modules of the group
- global and local classes, with the class hierarchy
- methods, their parameters and local variables
- global variables
- enhancements
Double-click behaviour:
- on a code node (event / FORM / method / module): navigate to that unit in the source viewer;
- on a variable: toggle it as a selection (bold = selected). Selected variables drive the
data dependency analysis — this is the "watchpoint without debugging".
Source viewer
Two rendering modes, switched with the first button of the view toolbar:
- Classic — the SAP ABAP editor control. Double-click a call to navigate into it, click the left
border to toggle a breakpoint.
- HTML — a rendered view with clickable calls, collapsible control structures (
IF/LOOP/CASE…),
a breakpoint gutter (click = session breakpoint, Ctrl+click = external breakpoint) and colouring
that separates calls and DB access from ordinary statements.
Navigation keeps a history, so you can walk into a chain of calls and come back.
Main toolbar
| Button | What it does |
|---|
| Run | Copies the Smart Debugger script to the clipboard and submits the analysed report — see Smart Debugger handoff |
| Flow | Mermaid diagram of the traced execution flow (needs abapMermaid) |
| Map | Static call map — the whole picture of classes/programs and their calls (needs abapMermaid) |
| Code Flow | Builds the linear code flow sequence of the current unit — see Code Flow |
| Show All Steps / Only Calculated | Toggles between the full flow and only the statements that contribute to the selected variables |
| Handlers | Builds the flow of all registered event handlers of the object |
| Only Z / Z & Standard | Whether the parser follows calls into SAP standard code — see Only Z and Depth |
| Depth ◀ n ▶ | Call nesting depth the parser follows (0–99, default 19). Click the number to type a value |
| Metrics | McCabe / Halstead / Maintainability Index report — see Code metrics |
| Steps | Opens the internal steps table in an ALV popup with filters |
| Get whole Class | Merges the local includes of a global class (CCDEF, CCIMP, CCMAC, CCAU) into one source view |
| ADT | Opens the current unit in Eclipse via an adt:// link, positioned on the current line |
| Info | Opens this documentation |
Source view toolbar
| Button | What it does |
|---|
| Classic view / HTML view | Switches source rendering |
| Collapse all / Expand all | Folds every control structure (HTML view only) |
| Scheme | Opens the branch scheme of the current unit. Each click opens a new popup, so branches can be compared side by side |
| Skeleton | Text skeleton of the unit: structure, calls and DB access with line numbers |
Features
Code Flow
Code Flow ("code mix") builds the sequence of statements that would be executed, starting from the
selected unit and walking into every call it can resolve statically — up to the configured
depth. The result is a single synthetic source view (Code_Flow_Mix) where code
from several includes, FORMs and methods is stitched together in execution order, with the call
hierarchy marked by indentation and arrows.
Empty block pairs (IF/ENDIF, LOOP/ENDLOOP with nothing left inside after filtering) are removed,
and branches whose body contributes nothing are dimmed, so what remains is the code that actually matters.
Data dependency analysis
This is the feature the tool was built for. In programming theory it is called backward program
slicing / data dependency analysis; some languages have tooling for it, and now ABAP does too.
To keep this page readable, only the first part of the README is shown. Open the original README for the full document.