O_oThe short answer is that it limits scalability and maintainability of your function - and of programs that call it - in the long run. As an example, the approach will not work in multi-threaded programs, if two threads attempt to use your function at once.
Indeed. This is an issue known as "reentrancy".
As another example, which doesn't revolve around multiple threads, consider a function which simply used a function that is itself not reentrant.
Consider a mutually recursive set of alternating functions (a trivial parser) which each internally calls `strtok' without manually adjusting the pointer passed to `strtok': the adjust offset of the first value stored by `strtok', the `str' pointer, will be used incorrectly by the nested calls thanks to those calls passing null to `strtok' instead of the a pointer to the string the alternate sides of the parser is responsible for processing. Such a problem happens even if `strtok' is thread-safe because the parser is being called from a single thread.
I realize this is a complicated example, but the point here is to say that functions with reentrancy problems have a tendency to push problems uphill.
If you write a utility function with a reentrancy problem, such as using a `static' because it is easier, you can't easily use a problematic function as part of the implementation of higher level functions without causing reentrancy problems in those higher level functions.