implementation approach - part II

I'm at my wits end with in terms of a solution for an implementation approach.  So I garnered assistance here on the creation of a static member function that'll call non-static members
Now I opt to port my example using the VxWorks facility taskSpawn (for more information on taskSpawn see below).  

#include <iostream>

class TEST
{
private:
      int spawned;
                int t_ida;
                int t_idb;
                int t_idc;

      static int bogus;

public:
      typedef void (TEST::*PTRFUNC )();

      TEST() : spawned(0)
      {  
            std::cout <<  " Constructor called " << std::endl;
                                // call function A
                                int t_ida = taskSpawn( "TaskMain", 100, 0, 10000,
                                                                   (FUNCPTR)TEST::TaskMain,(int)this,
                                                                   (int)&TEST::StartA,0,0,0,0,0,0,0,0);

                                // call function B
                                int t_idb = taskSpawn( "TaskMain", 90, 0, 10000,
                                                                    (FUNCPTR)TEST::TaskMain,(int)this,
                                                                   (int)&TEST::StartB,0,0,0,0,0,0,0,0);

                                // call function C
                                int t_idc = taskSpawn( "TaskMain", 80, 0, 10000,
                                                                     (FUNCPTR)TEST::TaskMain,(int)this,
                                                                   (int)&TEST::StartC,0,0,0,0,0,0,0,0);

            //TEST::TaskMain(this, &TEST::StartA);
            //TEST::TaskMain(this, &TEST::StartB);
            //TEST::TaskMain(this, &TEST::StartC);

      }
      ~TEST() { std::cout <<  " Destructor called " << std::endl; }

      static int TaskMain(TEST* obj, PTRFUNC p)
      {
            (obj->*p)();             
            return 0;
      }
      void StartA() { std::cout <<  " A Started " << std::endl; }
      void StartB() { std::cout <<  " B Started " << std::endl; }
      void StartC() { std::cout <<  " C Started " << std::endl; }
};


int main ()
{
      TEST *ptr = new TEST;
      delete ptr;
}

A quick synopsis on taskSpawn. ' (FUNCPTR)TEST::TaskMain'  referenced as a pass parameter to taskSpawn defines the entry point to your function.  In other words, the static function TaskMain inside the class gets called with the passed parameters being the this ((int) this)pointer and the functoin name ((int )&TEST::StartA(B)(C))).

Gcc complains that about the parameter (int) &TEST::StartA and it's ilks StartB and StartC claiming.  "aggregate value used where in integer was expected".   Now I'm unsure what approach to use.  Of course I'm not sure what the ramifications are of using a member function as a passed parameter since taskSpawn expects a 32 bit integer.  I also believe to pass the address of a member function the member function has to be static.

Info on taskSpawn

int taskSpawn
    (
    char *  name,      /* name of new task (stored at pStackBase) */
    int     priority,  /* priority of new task */
    int     options,   /* task option word */
    int     stackSize, /* size (bytes) of stack needed plus name */
    FUNCPTR entryPt,   /* entry point of new task */
    int     arg1,      /* 1st of 10 req'd task args to pass to func */
    int     arg2,
    int     arg3,
    int     arg4,
    int     arg5,
    int     arg6,
    int     arg7,
    int     arg8,
    int     arg9,
    int     arg10
    )

One thought was to change TaskMain to take int arguments then reintrepret cast

      static int TaskMain(TEST* obj, int p)   //perhaps int* p
      {
                               // now reintrepret_cast p back to the PTRFUNC . how?

            //(obj->*p)();             
            return 0;
      }

Could really use some guidance.  Thanks in advance