The handlerNames function takes two parameters

pScript - the text of the script

pHandlerType - the type of handler to be listed (optional)

This custom function is called with a statement such as one of the following:

get handlerNames(the script of button "OK","message")

put handlerNames(myScript) into allHandlerNames

if handlerNames(the script of me,it) is "(None)" then go next

The handlerNames function works by looking for text that is common to all handlers (or to all handlers of a certain type). There are four kinds of handlers in LiveCode:

• message handlers, which all begin with the word "on", the words "private on", the word "before" or the word "after"
• function handlers, which all begin with the word "function" or the words "private function"
• getProp handlers, which all begin with the word "getProp"
• setProp handlers, which all begin with the word "setProp"

The handlerNames function takes advantage of this to locate handlers in a script by finding all the lines that begin with one of the words that mark the start of a handler. For each possible handler type, the function uses the filter command to find only the lines that start with that handler type's characteristic word. For example, to find message handlers, the function gets only the lines in the script that begin with "on", "before" or "after". After using the filter command, the pScript parameter variable contains only the lines that matched the filter we used: in this case, only the starting lines of each handler of the type requested.

function handlerNames pScript,pHandlerType
   switch pHandlerType
      case "message" 
         ## list the message handlers
         filter pScript matching regex pattern "^(private )?on|^after|^before"
         break
      case "function" 
         ## list the function handlers
         filter pScript with regex pattern "^(private )?function"
         break
      case "setProp" 
         ## list the setProp handlers
         filter pScript with "setProp*"
         break
      case "getProp" 
         ## list the getProp handlers
         filter pScript with "getProp*"
         break
      default 
         ## list all the handlers, if no type specified
         filter pScript with "end*"
   end switch

You'll notice that you can call the function with just one parameter (pScript). It's possible to do this because the default clause of the switch control structure is executed if pHandlerType is empty (or anything other than "message", "function", "setProp", or "getProp").

The handler's name is always part of the script line that starts a handler. In fact, it is the word immediately after the handler type (on, before, after, function, getProp, or setProp). So by taking the second word of each line we've found (or third, if the first word is "private"), we can get just the name of each handler. The repeat loop that does this simply substitutes the appropriate word of each line for the entire line. In this way, we obtain a list of handler names, which is returned to the handler that called the function.

If no handler names were found, that is, if the list is empty, the message "(None found)" is returned. Depending on what this function is intended to do, we might want to return something else. For example, if the return value is going to be used to perform some operation on each handler in turn, we might want to return empty instead.

   repeat with x = 1 to the number of lines of pScript
      if word 1 of line x of pScript is "private" then
         ## word 3 of the first line of a private handler is the handler name:
         put word 3 of line x of pScript into line x of pScript
      else
         ## word 2 of the first line of any other handler or the last line of any handler is the handler name:
         put word 2 of line x of pScript into line x of pScript
      end if
   end repeat
   if pScript is empty then 
      return "(None found)"
   else
      return pScript
   end if

function handlerNames pScript,pHandlerType
   switch pHandlerType
      case "message" 
         ## list the message handlers
         filter pScript matching regex pattern "^(private )?on.+|^after.+|^before.+"
         break
      case "function" 
         ## list the function handlers
         filter pScript with regex pattern "^(private )?function.+"
         break
      case "setProp" 
         ## list the setProp handlers
         filter pScript with "setProp*"
         break
      case "getProp" 
         ## list the getProp handlers
         filter pScript with "getProp*"
         break
      default 
         ## list all the handlers, if no type specified
         filter pScript with "end*"
   end switch
   
   repeat with x = 1 to the number of lines of pScript
      if word 1 of line x of pScript is "private" then
         ## word 3 of the first line of a private handler is the handler name:
         put word 3 of line x of pScript into line x of pScript
      else
         ## word 2 of the first line of any other handler or the last line of any handler is the handler name:
         put word 2 of line x of pScript into line x of pScript
      end if
   end repeat
     
   if pScript is empty then 
      return "(None found)"
   else
      return pScript
   end if
end handlerNames

The script above is unable to exclude handlers that happen to be enclosed between /* and */. The reason why code that could account for this is not included is that the complexity of the task would severely overcomplicate the lesson. Nonetheless, a small command that can remove all characters between a /* and the next occurring */ (and something to demonstrate its shortcomings) is included in the sample stack; uncomment the additional line that calls it in the function.