code: func (l *State) ProtectedCall(argCount, resultCount, errorFunction int) error {
  	return l.ProtectedCallWithContinuation(argCount, resultCount, errorFunction, 0, nil)
  }
docs: // ProtectedCall calls a function in protected mode. Both argCount and
  // resultCount have the same meaning as in Call. If there are no errors
  // during the call, ProtectedCall behaves exactly like Call.
  //
  // However, if there is any error, ProtectedCall catches it, pushes a single
  // value on the stack (the error message), and returns an error. Like Call,
  // ProtectedCall always removes the function and its arguments from the stack.
  //
  // If errorFunction is 0, then the error message returned on the stack is
  // exactly the original error message. Otherwise, errorFunction is the stack
  // index of an error handler (in the Lua C, message handler). This cannot be
  // a pseudo-index in the current implementation. In case of runtime errors,
  // this function will be called with the error message and its return value
  // will be the message returned on the stack by ProtectedCall.
  //
  // Typically, the error handler is used to add more debug information to the
  // error message, such as a stack traceback. Such information cannot be
  // gathered after the return of ProtectedCall, since by then, the stack has
  // unwound.
  //
  // The possible errors are the following:
  //
  //    RuntimeError  a runtime error
  //    MemoryError   allocating memory, the error handler is not called
  //    ErrorError    running the error handler
  //
  // http://www.lua.org/manual/5.2/manual.html#lua_pcall