= Upgrade module interface =

This transformation upgrades the calls of the old regular expression module regexp to the new re module. The transformation is based on a generic interface upgrade module, which is invoked with the right structural and semantic change descriptors.

An example of upgrading regexp interface:

{{{
case regexp:match(String, RE) of
   {error, Reason} -> throw("Error: " ++ lists:flatten(
                        regexp:format_error(Reason)));
   {match, 1, Len} -> Len;
   {match, St, Len} -> use(St, Len);
   nomatch -> ok
end
}}}

Result:

{{{
try re:run(String, RE, [{capture, first}]) of
   {match, [{0, Len}]} -> Len;      % [{1-1, Len}] works too
   {match, [{St, Len}]} -> use(St+1, Len);
   nomatch -> ok
catch
   error:badarg -> throw("Error: " ++ lists:flatten(
                     "Bad regular expression"))
end
}}}


== Side conditions ==

 * Patterns belong to applications to be updated should match at least one of the patterns written in the change descriptors.


== Transformation steps and compensations ==

 1. Updating the function application:
  * Modifying the called function’s identifier {{{regexp:match ->re:run}}}
  * Matching the old function arguments and creating the new argument list {{{(String, RE) -> (String, RE, [capture, first])}}}

 2. Finding the patterns to be updated and performing on them the matching and the replacing. Furthermore, applying the correction functions on the variable bindings or/and usages.
  * Pattern: {{{match, 1, Len -> match, [0, Len]}}}
  * Expression: {{{use(St, Len) -> use(St+1, Len)}}}

 3.  Turning the case expression to a try expression and moving error pattern to the catch block (error:badarg is moved to a catch block after we changed case expression to try expression).