Stop overcomplicating things. Instead of dealing with different scopes, simplify your code by packaging replacement values in an object rather than using individual variables. Utilize the g flag and a replacement function within c() to streamline the process. Try this instead:

function a(){
    var values = {
        v: 9,
        w: 2,
        x: 7
    };

    func(c('{w} + {x} = {v}', values));
}

function b(){
    var values = {
        v: 1,
        y: 'hello',
        z: 'world'
    };

    func(c('{v}. {y} {z}', values));
}

function c(template, values) {
    return template.replace(/{(.*?)}/g, function(match) {
        return values[match[1]];
    });
}

After spending some time experimenting with it, I've managed to get quite close to passing the local scope into another function. The process is a bit unconventional and involves duplicating code, but it could be what you're seeking.

The approach includes defining all local variables as parameters in functions (instead of using var statements), enabling their names to be extracted by converting the function back to source using .toString(). These parameters are not provided when calling a() and b()!

(Please note that the c() function mentioned here is similar to the one in my previous answer.)

rxArgs = /^[^(]+\(([^)]+)\)/;

function a(v, w, x){
    v = 9;
    w = 2;
    x = 7;

    var args = rxArgs.exec(arguments.callee.toString())[1].split(", ");
    var i = args.length, values = {};

    while (i--) values[args[i]] = eval(args[i]);

    func(c('{w} + {x} = {v}', values));
}

function b(v, y, z){
    v = 1;
    y = 'hello';
    z = 'world';

    var args = rxArgs.exec(arguments.callee.toString())[1].split(", ");
    var i = args.length, values = {};

    while (i--) values[args[i]] = eval(args[i]);

    func(c('{v}. {y} {z}', values));
}

function c(template, values) {
    return template.replace(/{(.*?)}/g, function(match) {
        return values[match[1]];
    });
}

However, at this stage, so much boilerplate is being introduced into each function that it might be more efficient to simply inline c() instead.

function a(){
    var v = 9;
    var w = 2;
    var x = 7;

    func('{w} + {x} = {v}'.replace(/{(.*?)}/g, function(match) {
        return eval(match[1]);
    }));
}

function b(){
    var v = 1;
    var y = 'hello';
    var z = 'world';

    func('{v}. {y} {z}'.replace(/{(.*?)}/g, function(match) {
        return eval(match[1]);
    }));
}

My recommendation is to enhance your code by parsing the templates and explicitly interpreting the "{foo}" references within your own code, rather than relying on eval() for everything.

It's unclear why functions like "a()" and "b()" in your examples even require a template mechanism. In languages with first-class function objects such as Javascript, accomplishing what your code aims to do can be achieved more effectively through functional programming.

UPDATE:

It appears from your query that the values will be provided by the caller. In case all values are coming from the same source, you can simply pass the arguments object to function c.

Within the function c, you can then extract the next item from the arguments object passed for each match in the template.

Demonstration: http://jsfiddle.net/u99Bj/1/

function a(){
    var template = '{w} + {x} = {v}';
    c(template, arguments);
}

function b(){
    var template = '{v}. {y} {z}';
    c(template, arguments);
}

function c(template, args){
    var re = /{(.+?)}/;
    var i = 0;
    var match = template.match(re);
    while (match != null){
        template = template.replace(re, args[i++]);
        match = template.match(re);
    }
    alert(template);
}

If some functions require static values, you would have to convert the arguments into an Array and add necessary elements to the Array.

Is it possible to achieve the desired functionality in this way :

function customFunction(template,caller)
{ ... 
}

and then invoke it like this

customFunction(template,this)

this would enable you to access the variables as properties of 'this' (passing the function as an object rather than passing its scope)

UPDATE

Consider this alternative approach:

function example(){
    this.v = 9;
    this.w = 2;
    this.x = 7;
    this.template = '{w} + {x} = {v}';
}

function customFunction(obj){
    var template = obj.template;
    var re = /{(.+?)}/;
    var match = template.match(re);
    while (match != null){
        template = template.replace(re, obj[match[1]]);
        match = template.match(re);
    }
    alert(template);
}

<input type="button" value="example" onclick="customFunction(new example())"/><br/>

How about utilizing only this particular keyword

<script type="text/javascript">
function a(){
    this.v = 9;
    this.w = 2;
    this.x = 7;
    var template = '{w} + {x} = {v}';
    c(template);
}

function b(){
    this.v = 1;
    this.y = 'hello';
    this.z = 'world';
    var template = '{v}. {y} {z}';
    c(template);
}

function c(template){
    var re = /{(.+?)}/;
    var match = template.match(re);
    while (match != null){
        template = template.replace(re, eval(match[1]));
        match = template.match(re);
    }
    alert(template);
}
</script>

All variables will be initialized in document by default. They can be encapsulated in other objects if needed. Exercise caution with optional variables to prevent interference with parsing.