Is it possible for a JavaScript function to return its own function call as a string?

http://jsfiddle.net/WkJE9/4/

function DisplayMyName() 
{
   //Convert function arguments into a real array then let's convert those arguments to a string.
   var args = [].slice.call(arguments).join(',');

   // Get Function name
   var myName = arguments.callee.toString();
   myName = myName.substr('function '.length);
   myName = myName.substr(0, myName.indexOf('('));

   return(myName + " ("+ args + ")"); 
}

var functionText = DisplayMyName(5, "3", /(a|b|c)/) //returns DisplayMyName(5, "3", /(a|b|c)/)
alert(functionText);

Using the implicit arguments variable, you can extract both the function arguments and the function name:

function getOwnFunctionCall() {
    var args = arguments; // Contains the arguments as an array
    var callee = arguments.callee; // The caller function
    // Use this to construct your string
}

Edit

Several comments note that callee is not something to be relied on. But if this is something you are going to do inside each of your methods, then just use the function name as you have defined it:

var functionName = "getOwnFunctionCall"; // But you can really just use it inline...

if you NEED to do it, and need to do it in global strict, and you don't want to hard-code the names:

function args(arg){
 var me;
  try{ badCAll654(); }catch(y){  me=String(y.stack).split("args")[1].split("\n")[1].trim().split("@")[0].replace(/^at /,"").split(" ")[0].trim() }
  return  me +"("+[].slice.call(arg).join(", ")+")";
}



function getOwnFunctionCall() {
  "use strict";
  return args(arguments);
}


getOwnFunctionCall(1,true, /dd/);

this can be a good debugging tool, but i would not recommend using it on production sites/apps; it's going to impact performance quite a bit. This pattern only works in chrome and firefox, but works under a global "use strict".

IE9 is less strict, so you can do the following:

function args(arg){
 var me=arg.callee+'';
  return  me.split("(")[0].split("function")[1].trim() +"("+[].slice.call(arg).join(", ")+")";
}   

function getOwnFunctionCall() {
  "use strict";
  return args(arguments);
}


getOwnFunctionCall(1,true, /dd/);

if you poly-fill the trim()s, it should also work in IE8. if you don't use strict, you can do even more cool stuff like log the function that called the function that's being logged. you CAN even rip that function's source to find calls to the logged function if you want the names of the arguments and not just the values. Complex and worthless, but possible.

again, you should really use this only for debugging!

Based on your comment

I've been trying to find ways to prevent specific functions in eval statements from being evaluated, and this is one potential solution for that problem.

What you are asking for might not be what you really need. Why not just override the functions you want to prevent before evaling and restore them aferwards:

var blacklist = [ 'alert', 'setTimeout' ];

var old = {};

// Save the blacklisted functions and overwrite
blacklist.forEach(function(name) {
    old[name] = window[name];
    window[name] = function() {
        console.log(name + ' has been disabled for security reasons');
    }
});

eval('alert("Hello world")');

// restore the original functions
blacklist.forEach(function(name) {
    window[name] = old[name];
});

is it possible for a function to return its own function call as a string?

No. You cannot extract by what expression you got your arguments into the function - you can only access their values. Of course you could simulate a call string with primitive values, but you never know whether they were passed to the function as a variable, a literal, or a whole expression.

Maybe, Mozilla's toSource method can help you with that.