The OpenEdge Hive

Proparse builds tables of symbols and scopes, which you can use. Some groovy borrowed from AutoDox2:

import com.joanju.proparse.ProToken;
import org.prorefactor.core.JPNode;
import org.prorefactor.core.TokenTypes;
import org.prorefactor.nodetypes.BlockNode;
import org.prorefactor.treeparser.Block;
import org.prorefactor.treeparser.ParseUnit
import org.prorefactor.treeparser.Routine
import org.prorefactor.treeparser.SymbolScope;

ParseUnit unit

void buildRoutines() {
	def functionRoutineDoxs = new HashMap()
	def funcAndProcDoxs = new HashMap()
	def functionForwardRoutines = new HashMap()
	def inSuperRoutines = new HashMap()
	scopes_loop:
	for (SymbolScope scope : unit.getRootScope().getChildScopes()) {
		Block block = scope.getRootBlock();
		JPNode blockNode = block.getNode();
		int blockNodeType = blockNode.getType();
		// We only want methods, not triggers or CAN-FIND scopes.
		switch (blockNodeType) {
			case TokenTypes.PROCEDURE :
			case TokenTypes.FUNCTION :
			case TokenTypes.METHOD :
			case TokenTypes.CONSTRUCTOR	:
				break
			default :
				continue scopes_loop
		}
		def routine = (Routine) blockNode.getSymbol()
		
		boolean isFunc = blockNodeType==TokenTypes.FUNCTION
		boolean isProc = blockNodeType==TokenTypes.PROCEDURE
		
		def name = routine.getName().toLowerCase()
		// IN SUPER functions and procedures need to be documented, but they
		// might be overridden by local func/proc of the same name. Keep these
		// in a separate list for now, and only add them if there's no local equivalent.
		if ((isFunc || isProc) 
			&& blockNode.findDirectChild(TokenTypes.IN_KW) 
			&& blockNode.findDirectChild(TokenTypes.SUPER)
			) {
			inSuperRoutines.put(name, routine)
			continue scopes_loop
		}

		// We need FUNCTION FORWARDs because the formal args are
		// optional in the function definition block if there is a 
		// function forward declaration.
		if (isFunc && blockNode.findDirectChild(TokenTypes.FORWARDS)) {
			functionForwardRoutines.put(name, routine)
			continue scopes_loop
		}
	}
}