Contents

SAP ABAP

The reference for what gitta Enterprise reads in ABAP, and what counts as a change of meaning. gitta reads reports, includes, forms, function modules and ABAP Objects. When one agent changes a field, a method or an interface that another agent’s new code uses, that agent hears about it while it works. You merge as usual, and gitta runs ABAP Unit on the combined work before it reaches the main branch.

What gitta reads in ABAP

Many programs share the same Data Dictionary object, and one method can have callers all over the code base. One change can reach far. gitta reads the ABAP and keeps track of what each agent changes and what each agent’s new code uses.

Reports and programs (REPORT, PROGRAM) and the includes they pull in with INCLUDE.
Forms and their typed parameters (FORM, PERFORM, USING, CHANGING, TABLES), also PERFORM f IN PROGRAM p across programs.
Function modules (FUNCTION, CALL FUNCTION 'Z_X'). A call anywhere in the code resolves to the function it names.
ABAP Objects. Classes, methods and interfaces, with INHERITING FROM and INTERFACES. A call through cl=>m, obj->m, me->m, super->m or if~m resolves to the method it reaches, and a CREATE OBJECT or NEW resolves to the constructor.
The Data Dictionary used in code. A customer-namespace table or structure a program reads through SELECT ... FROM ztab, TABLES ztab, TYPE ztab, a work area over that type, or ztab-field directly.
Open SQL. gitta follows each SELECT, INSERT, UPDATE, MODIFY and DELETE and reads the tables in FROM and JOIN, so it knows the tables and fields each query touches.
Data of every kind (DATA, TYPES, CONSTANTS, STATICS, CLASS-DATA, FIELD-SYMBOLS, PARAMETERS, SELECT-OPTIONS), structures, internal tables and class attributes used by a method.

When one agent changes something that another agent’s new code uses, the other agent gets a warning at its next step, and gitta status shows it too. The agent adapts its code, and ABAP Unit on the combined code decides the merge.

The where-used fan-out

A Data Dictionary field is shared by every program that reads it. When an agent widens that field, each of those programs now reads a different layout. The dictionary change shows one line. It shows nothing about the programs that depend on the field. gitta lists every one of them.

ZPARTYthe customer address structure, field POSTCODE

ZCL_PARTY_READER
ZCL_PARTY_UPDATE
ZCL_PARTY_SEARCH
ZCL_ADDRESS_VALID
ZCL_PARTY_MAP
Z_PARTY_SELECT
Z_PARTY_LOAD
ZCL_LETTER_PRINT
ZPARTY_REPORT
ZCL_PARTY_FACTORY
ZCL_PARTY_EXPORT
ZCL_DUPLICATE_CHECK
ZCL_PARTY_DISPLAY
ZCL_PARTY_LOG
ZCL_PARTY_GUID
ZIF_PARTY_SOURCE

Reads a field through a work area typed on the structure
Reads a field with ztab-field directly
Reads it with Open SQL SELECT
Does not touch the changed field

gitta names every program and class whose new code reads ZPARTY-POSTCODE. When an agent widens the field, each of these hears about it, and the three that write a work area into a shorter field hear it first.

The same fan-out works for a method and an interface. When an agent changes a method’s signature, gitta names every call site that reaches it, whether the call goes through the class, an object reference, me->, super-> or an interface alias. When an agent changes a function module body, gitta names its callers.

What gitta supports

Part	What counts as a change of meaning	Symbol in warnings
Dictionary fields a program reads	A widened or retyped field that another agent’s new code reads, through `ztab-field`, a work area over `TYPE ztab`, or Open SQL. gitta follows the use side, the program that reads the field.	`DDIC.ZPARTY-POSTCODE`
Tables in Open SQL	A query that reads a table in `FROM` or `JOIN`, or writes it with `INSERT`, `UPDATE`, `MODIFY` or `DELETE`. The table and its fields count as uses.	`DDIC.ZPARTY`
Methods	A method’s interface, its `IMPORTING`, `EXPORTING`, `CHANGING` and `RETURNING` parameters. A call through `cl=>m`, `obj->m`, `me->`, `super->` or `if~m` uses it. A method that reads changed class data also counts.	`ZCL_PARTY_READER.READ_ADDRESS`
Interfaces	An interface method and its `ALIASES`. New code that calls the alias or implements the interface relies on the signature.	`ZIF_PARTY.GET_ADDRESS`
Classes and inheritance	A class attribute a method uses, and the parent a `super->` call reaches through `INHERITING FROM`.	`ZCL_PARTY_READER.GV_CLIENT`
Function modules	A changed body of a function, for every `CALL FUNCTION 'Z_X'` that reaches it. The interface of a function lives outside its ABAP source, so a body change is a low-severity warning to its callers for now.	`FUNCTION.Z_PARTY_SELECT`
Forms	A form’s typed `USING`, `CHANGING` and `TABLES` parameters, for `PERFORM` in the same program and `PERFORM f IN PROGRAM p`.	`ZPARTY_REPORT.PRINT_ROW`

gitta also reads colon chains (DATA: a, b.), pragmas such as ##NO_TEXT, inline and line comments, host variables (@lv), and string and template literals. It records a macro (DEFINE) and reads its call sites. Names in ABAP are not case sensitive, and gitta shows them in upper case.

gitta reads ABAP with its own reader, the way it reads COBOL, not with a full ABAP grammar. A change that only adds comments or changes case is not a change of meaning. ABAP files merge line by line, as with Git. When the lines clash, the merge stops with a conflict. For the COBOL reference, see COBOL, copybooks and JCL.

How gitta reads ABAP without abapGit

gitta works on a Git repository. Teams that keep ABAP in Git with abapGit get the fan-out above with no extra setup. Many SAP shops use the transport system, not Git. gitta reads ABAP there too, through three parts.

Source. gitta reads an object through SAP’s ADT source interface, the same service that Eclipse ADT uses. An ADT developer user reads the source of a class, a program or an include over the ADT node. This path works on AS ABAP, on S/4HANA and on the BTP ABAP environment, so one developer can test it on a trial system.
The change trigger. A transport request groups changes, and the release of that request exports it. gitta takes the transport release as the change event. It reads the object list of the request and checks the objects it names.
The gate. gitta runs ABAP Unit on the combined work during the merge, the same way it runs a gate command on other code. A failing test stops the merge, and gitta shows the change that broke it.

The ADT source read and the transport release are both tested by one developer on a free trial, with no need to reach SAP. For where gitta runs next to a build, see the Mainframe guide, which describes the same pattern for z/OS.