bool CMetaDataFunction::CallFuction(int param_count, void **pParam, void *pReturn)
{
	if (!m_pFunction) return false;
	SMetaDataCalledFunctionDataPacket Packet = { param_count, pParam, pReturn };
	TpMDCalledFunction pFunc(reinterpret_cast<TpMDCalledFunction>(m_pFunction));
	return pFunc(Packet);
}
Exemple #2
0
void ReorderOddEven(int *pData,unsigned int length,bool (* pFunc)(int))
{
	if(length<=0 || pData==NULL)
		return;

	int *head = pData;
	int *tail = pData+length-1;
	while (head<tail)
	{
		while (head<tail && !pFunc(*head))
		{
			head++;
		}
		while (head<tail && pFunc(*tail))
		{
			tail--;
		}

		if(head<tail)
		{
			int temp = *head;
			*head = *tail;
			*tail = temp;
		}
	}
}
void WiiRemote::task(void (*pFunc)(void)) {
    Max.Task();
    Usb.Task();
    delay(1);

    // re-initialize
    if (Usb.getUsbTaskState() == USB_DETACHED_SUBSTATE_INITIALIZE) {
        /* TODO */
        wiiremote_status_ = 0;
    }

    // wait for addressing state
    if (Usb.getUsbTaskState() == USB_STATE_CONFIGURING) {
        initBTController();

        if (wiiremote_status_ & WIIREMOTE_STATE_USB_CONFIGURED) {
            hci_state_ = HCI_INIT_STATE;
            hci_counter_ = 10;
            l2cap_state_ = L2CAP_DOWN_STATE;

            Usb.setUsbTaskState(USB_STATE_RUNNING);
        }
    }

    if (Usb.getUsbTaskState() == USB_STATE_RUNNING) {
        HCI_task();     // poll the HCI event pipe
        L2CAP_task();   // start polling the ACL input pipe too, though discard
                        // data until connected
    }
    //if (l2cap_state_ == L2CAP_READY_STATE) {
    if (wiiremote_status_ & WIIREMOTE_STATE_RUNNING) {
        if (pFunc) { pFunc(); }
    }
} // task
static long ged_dispatch(GED_BRIDGE_PACKAGE *psBridgePackageKM)
{
    int ret = -EFAULT;
    void *pvInt, *pvOut;
    typedef int (ged_bridge_func_type)(void*, void*);
    ged_bridge_func_type* pFunc = NULL;
    
    if ((psBridgePackageKM->i32InBufferSize >=0) && (psBridgePackageKM->i32OutBufferSize >=0) &&
        (psBridgePackageKM->i32InBufferSize + psBridgePackageKM->i32OutBufferSize < GED_IOCTL_PARAM_BUF_SIZE))
    {
        pvInt = gvIOCTLParamBuf;
        pvOut = (void*)((char*)pvInt + (uintptr_t)psBridgePackageKM->i32InBufferSize);
        if (psBridgePackageKM->i32InBufferSize > 0)
        {
            if (0 != ged_copy_from_user(pvInt, psBridgePackageKM->pvParamIn, psBridgePackageKM->i32InBufferSize))
            {
                GED_LOGE("ged_copy_from_user fail\n");
                return ret;
            }
        }

        // we will change the below switch into a function pointer mapping table in the future
        switch(GED_GET_BRIDGE_ID(psBridgePackageKM->ui32FunctionID))
        {
        case GED_BRIDGE_COMMAND_LOG_BUF_GET:
            pFunc = (ged_bridge_func_type*)ged_bridge_log_buf_get;
            break;
        case GED_BRIDGE_COMMAND_LOG_BUF_WRITE:
            pFunc = (ged_bridge_func_type*)ged_bridge_log_buf_write;
            break;
        case GED_BRIDGE_COMMAND_LOG_BUF_RESET:
            pFunc = (ged_bridge_func_type*)ged_bridge_log_buf_reset;
            break;            
        case GED_BRIDGE_COMMAND_BOOST_GPU_FREQ:
            pFunc = (ged_bridge_func_type*)ged_bridge_boost_gpu_freq;
            break;
        case GED_BRIDGE_COMMAND_MONITOR_3D_FENCE:
            pFunc = (ged_bridge_func_type*)ged_bridge_monitor_3D_fence;
            break;
        default:
            GED_LOGE("Unknown Bridge ID: %u\n", GED_GET_BRIDGE_ID(psBridgePackageKM->ui32FunctionID));
            break;
        }

        if (pFunc)
        {
            ret = pFunc(pvInt, pvOut);
        }

        if (psBridgePackageKM->i32OutBufferSize > 0)
        {
            if (0 != ged_copy_to_user(psBridgePackageKM->pvParamOut, pvOut, psBridgePackageKM->i32OutBufferSize))
            {
                return ret;
            }
        }
    }

    return ret;
}
/** \brief Sorts objects of list, use compare pFunc
 * \param pList ArrayList* Pointer to arrayList
 * \param pFunc (*pFunc) Pointer to fuction to compare elements of arrayList
 * \param order int  [1] indicate UP - [0] indicate DOWN
 * \return int Return (-1) if Error [pList or pFunc are NULL pointer]
 *                  - (0) if ok
 */
int al_sort(ArrayList* pList, int (*pFunc)(void* ,void*), int order)
{
    int returnAux = -1, i,j,r;
    void* dato1, *dato2, *auxP;

    if(pList != NULL && pFunc != NULL && (order ==0 ||order ==1) )
    {
        for(i=0; i<pList->size-1; i++)
        {
            for(j=i+1; j<pList->size; j++)
            {
                dato1 = *((pList->pElements)+i);
                dato2 = *((pList->pElements)+j);
                r=pFunc(dato1, dato2);

                if(r==1 && order == 1)
                {
                    auxP=*((pList->pElements)+i);
                    *((pList->pElements)+i)=*((pList->pElements)+j);
                    *((pList->pElements)+j)=auxP;
                }
                if(r==-1 && order == 0)
                {
                    auxP=*((pList->pElements)+i);
                    *((pList->pElements)+i)=*((pList->pElements)+j);
                    *((pList->pElements)+j)=auxP;
                }
            }
        }
        returnAux = 0;
    }
    return returnAux;
}
Exemple #6
0
static void bfs(TMGraph* graph, int v, int visited[], MGraph_Printf* pFunc)
{
    LinkQueue* queue = LinkQueue_Create();
    
    if( queue != NULL )
    {
        LinkQueue_Append(queue, graph->v + v);
        
        visited[v] = 1;
        
        while( LinkQueue_Length(queue) > 0 )
        {
            int i = 0;
            
            v = (MVertex**)LinkQueue_Retrieve(queue) - graph->v;
            
            pFunc(graph->v[v]);
            
            printf(", ");
            
            for(i=0; i<graph->count; i++)
            {
                if( (graph->matrix[v][i] != 0) && !visited[i] )
                {
                    LinkQueue_Append(queue, graph->v + i);
                    
                    visited[i] = 1;
                }
            }
        }
    }
    
    LinkQueue_Destroy(queue);
}
Exemple #7
0
static void recursive_display(BSTreeNode* node, BSTree_Printf* pFunc, int format, int gap, char div) // O(n)
{
    int i = 0;
    
    if( (node != NULL) && (pFunc != NULL) )
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        
        pFunc(node);
        
        printf("\n");
        
        if( (node->left != NULL) || (node->right != NULL) )
        {
            recursive_display(node->left, pFunc, format + gap, gap, div);
            recursive_display(node->right, pFunc, format + gap, gap, div);
        }
    }
    else
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        printf("\n");
    }
}
Exemple #8
0
/* execute a function on all list members. The functions receives a
 * user-supplied parameter, which may be either a simple value
 * or a pointer to a structure with more data. If the user-supplied
 * function does not return RS_RET_OK, this function here terminates.
 * rgerhards, 2007-08-02
 * rgerhards, 2007-11-21: added functionality to delete a list element.
 * If the called user function returns RS_RET_OK_DELETE_LISTENTRY the current element
 * is deleted.
 */
rsRetVal llExecFunc(linkedList_t *pThis, rsRetVal (*pFunc)(void*, void*), void* pParam)
{
	DEFiRet;
	rsRetVal iRetLL;
	void *pData;
	linkedListCookie_t llCookie = NULL;
	linkedListCookie_t llCookiePrev = NULL; /* previous list element (needed for deletion, NULL = at root) */

	assert(pThis != NULL);
	assert(pFunc != NULL);

	while((iRetLL = llGetNextElt(pThis, &llCookie, (void**)&pData)) == RS_RET_OK) {
		iRet = pFunc(pData, pParam);
		if(iRet == RS_RET_OK_DELETE_LISTENTRY) {
			/* delete element */
			CHKiRet(llUnlinkAndDelteElt(pThis, llCookie, llCookiePrev));
			/* we need to revert back, as we have just deleted the current element.
			 * So the actual current element is the one before it, which happens to be
			 * stored in llCookiePrev. -- rgerhards, 2007-11-21
			 */
			llCookie = llCookiePrev;
		} else if (iRet != RS_RET_OK) {
			FINALIZE;
		}
		llCookiePrev = llCookie;
	}

	if(iRetLL != RS_RET_END_OF_LINKEDLIST)
		iRet = iRetLL;

finalize_it:
	RETiRet;
}
void test()
{
    char dllname[] = {'c', ':', '\\', 't', 'e', 's', 't', '.', 'd', 'l', 'l', '\0'};
    //必须用2088770939这个 LoadLibrary 函数的绝对地址(在我的xp下是这个地址,使用时应该在自己的windows下获取)
    pLoadLibrary pFunc = pLoadLibrary(2088770939);
    //调用LoadLibrary,因为LoadLibrary函数在windows下每个进程中绝对地址都是一样的。
    pFunc(dllname);
}
Exemple #10
0
HRESULT _ATL_OBJMAP_ENTRY::RegisterClassObject(DWORD dwClsContext, DWORD dwFlags)
{
	CComPtr<IUnknown> p;
	HRESULT hRes = pFunc(NULL, IID_IUnknown, (LPVOID*) &p);
	if (SUCCEEDED(hRes))
		hRes = CoRegisterClassObject(*pclsid, p, dwClsContext, dwFlags, &dwRegister);
	return hRes;
}
/** \brief Sorts objects of list, use compare pFunc
 * \param pList ArrayList* Pointer to arrayList
 * \param pFunc (*pFunc) Pointer to fuction to compare elements of arrayList
 * \param order int  [1] indicate UP - [0] indicate DOWN
 * \return int Return (-1) if Error [pList or pFunc are NULL pointer]
 *                  - (0) if ok
 */
int al_sort(ArrayList* pList, int (*pFunc)(void* ,void*), int order)
{
    int returnAux = -1;
    int i;
    int j;
    void *punt_temp;

    if((pList != NULL) && (pFunc != NULL) && (order == 1 || order == 0))
    {
        if(order == 1)
        {
            for(i=0;i<pList->size-1;i++)
            {
                for(j=i+1;j<pList->size;j++)
                {
                    if(pFunc(*(pList->pElements + i),*(pList->pElements + j))==1)
                    {
                        punt_temp=*(pList->pElements+i);
                        *(pList->pElements + i)=*(pList->pElements+j);
                        *(pList->pElements + j)=punt_temp;
                    }
                }
            }
        }
        else
        {
            for(i=0;i<pList->size-1;i++)
            {
                for(j=i+1;j<pList->size;j++)
                {
                    if(pFunc(*(pList->pElements+i),*(pList->pElements+j))==-1)
                    {
                        punt_temp =*(pList->pElements+i);
                        *(pList->pElements + i)=*(pList->pElements+j);
                        *(pList->pElements + j)=punt_temp;
                    }
                }
            }
        }

        returnAux=0;
    }

    return returnAux;
}
static void __cdecl CrtDoForAllClientObjects_thunk(void *pData, void *pContext)
{
    _PHEAP_m pFunc = (_PHEAP_m) DecodePointer(__pfnHeapfunc);

    if (pFunc)
    {
        pFunc(pData, pContext);
    }
}
/** \brief Sorts objects of list, use compare pFunc
 * \param pList ArrayList* Pointer to arrayList
 * \param pFunc (*pFunc) Pointer to fuction to compare elements of arrayList
 * \param order int  [1] indicate UP - [0] indicate DOWN
 * \return int Return (-1) if Error [pList or pFunc are NULL pointer]
 *                  - (0) if ok
 */
int al_sort(ArrayList* pList, int (*pFunc)(void* ,void*), int order)
{
    int returnAux = -1;
    int i,j;
    void* aux;
    if(pList!=NULL&&pFunc!=NULL)
    {

        if(order==1)
        {
            returnAux=0;
            for(i=0;i<pList->size-1;i++)
            {
                for(j=i+1;j<pList->size;j++)
                {
                    if(pFunc(pList->pElements[i],pList->pElements[j]))//si elemento i es mayor que elemento j...
                    {
                        aux=pList->pElements[i];
                        pList->pElements[i]=pList->pElements[j];
                        pList->pElements[j]=aux;
                    }
                }
            }
        }
        if(order==0)
        {
            returnAux=0;
            for(i=0;i<pList->size-1;i++)
            {
                for(j=i+1;j<pList->size;j++)
                {
                    if(pFunc(pList->pElements[i],pList->pElements[j])==-1)//si elemento i es mayor que elemento j...
                    {
                        aux=pList->pElements[i];
                        pList->pElements[i]=pList->pElements[j];
                        pList->pElements[j]=aux;
                    }
                }
            }
        }
    }
    return returnAux;
}
/** \brief find Employee by id
 * \param pList ArrayList* Pointer to arrayList
 * \param pFunc (*pFunc) Pointer to fuction to compare elements of arrayList
 * \return int  -(-1)if not found
                -(index of array)if found
 */
int al_find(ArrayList* pList,int (*pFunc)(void* ,void*),int id)
{
    int returnAux=-1;
    int i;
    for(i=0;i<pList->size;i++)
    {
        if(pFunc(*(pList->pElements+i),((int*)id))==0)//tal vez ahi que probar de otra manera sin castear
            return i;
    }
    return returnAux;
}
Exemple #15
0
FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj) {
  CPDF_Dictionary* pDict = pObj->GetDict();
  if (!pDict) {
    return FALSE;
  }
  if (m_nInputs != kRequiredNumInputs) {
    return FALSE;
  }
  CPDF_Array* pArray = pDict->GetArrayBy("Functions");
  if (!pArray) {
    return FALSE;
  }
  uint32_t nSubs = pArray->GetCount();
  if (nSubs == 0)
    return FALSE;
  m_nOutputs = 0;
  for (uint32_t i = 0; i < nSubs; i++) {
    CPDF_Object* pSub = pArray->GetDirectObjectAt(i);
    if (pSub == pObj)
      return FALSE;
    std::unique_ptr<CPDF_Function> pFunc(CPDF_Function::Load(pSub));
    if (!pFunc)
      return FALSE;
    // Check that the input dimensionality is 1, and that all output
    // dimensionalities are the same.
    if (pFunc->CountInputs() != kRequiredNumInputs)
      return FALSE;
    if (pFunc->CountOutputs() != m_nOutputs) {
      if (m_nOutputs)
        return FALSE;

      m_nOutputs = pFunc->CountOutputs();
    }

    m_pSubFunctions.push_back(std::move(pFunc));
  }
  m_pBounds = FX_Alloc(FX_FLOAT, nSubs + 1);
  m_pBounds[0] = m_pDomains[0];
  pArray = pDict->GetArrayBy("Bounds");
  if (!pArray)
    return FALSE;
  for (uint32_t i = 0; i < nSubs - 1; i++)
    m_pBounds[i + 1] = pArray->GetFloatAt(i);
  m_pBounds[nSubs] = m_pDomains[1];
  m_pEncode = FX_Alloc2D(FX_FLOAT, nSubs, 2);
  pArray = pDict->GetArrayBy("Encode");
  if (!pArray)
    return FALSE;

  for (uint32_t i = 0; i < nSubs * 2; i++)
    m_pEncode[i] = pArray->GetFloatAt(i);
  return TRUE;
}
Exemple #16
0
/********************************************************************
	Method:    TraverseList
	Parameter: 单链表,函数指针
	Returns:

	Purpose:   输出单链表

*********************************************************************/
bool TraverseList(LinkList L, bool (*pFunc)(Node * ))
{
    Node *s = L->next;
    while (s)
    {
        pFunc(s);
        s = s->next;
    }
    printf("\n");

    return true;
}
static void recursive_dfs(TMGraph* graph, int v, int visited[], MGraph_Printf* pFunc)
{
    int i = 0;    
    pFunc(graph->v[v]);    
    visited[v] = 1;    
    printf(", ");
    
    for(i=0; i<graph->count; i++){    
        if( (graph->matrix[v][i] != 0) && !visited[i] ){ // 深度优先遍历 直接遍历某个节点边对应的另外一个端点        
            recursive_dfs(graph, i, visited, pFunc);
        }
    }
}
int main()
{
    TrampolineMgr* mgr = new TrampolineMgr;
    TrampolineMgr::loadFunctionInfo("/tmp/fi");

    float (*pFunc)(int,int,double) = (float (*)(int,int,double)) mgr->generate((void*) &mytestfunc, "mytestfunc");
    int (*pPrintf)(FILE* f, const char*,...) = (int (*)(FILE* f, const char*,...)) mgr->generate((void*) &fprintf, "printf");
    std::cout << pFunc(2,3,0.5) << std::endl;
    //pPrintf(stdout, "Hello world: %s\n", "Test");

    delete mgr;
    return 0;
}
Exemple #19
0
void MGraph_Display(MGraph* graph, MGraph_Printf* pFunc) // O(n*n)
{
    TMGraph* tGraph = (TMGraph*)graph;
    
    if( (tGraph != NULL) && (pFunc != NULL) )
    {
        int i = 0;
        int j = 0;
        
        for(i=0; i<tGraph->count; i++)
        {
            printf("%d:", i);
            pFunc(tGraph->v[i]);
            printf(" ");
        }
        
        printf("\n");
        
        for(i=0; i<tGraph->count; i++)
        {
            for(j=0; j<tGraph->count; j++)
            {
                if( tGraph->matrix[i][j] != 0 )
                {
                    printf("<");
                    pFunc(tGraph->v[i]);
                    printf(", ");
                    pFunc(tGraph->v[j]);
                    printf(", %d", tGraph->matrix[i][j]);
                    printf(">");
                    printf(" ");
                }
            }
        }
        
        printf("\n");
    }
}
/** \brief Sorts objects of list, use compare pFunc
 * \param pList ArrayList* Pointer to arrayList
 * \param pFunc (*pFunc) Pointer to fuction to compare elements of arrayList
 * \param order int  [1] indicate UP - [0] indicate DOWN
 * \return int Return (-1) if Error [pList or pFunc are NULL pointer]
 *                  - (0) if ok
 */
int al_sort(ArrayList* pList, int (*pFunc)(void*,void*), int order)
{
    int i,j;
    int retornFuncion;
    int retorno=-1;
    int tam =  al_len(pList);
    int flag=0;

    void* aux;


    if (pList != NULL && pFunc != NULL && (order==1 || order==0))
    {
        for (i=0; i< tam-1; i++ )
        {
            for(j=i+1; j< tam; j++ )
            {
                retornFuncion = pFunc(al_get(pList, i), al_get(pList, j));

                if(retornFuncion ==1 && order == 1)
                {
                    aux=al_get(pList,i);
                    al_set(pList,i,al_get(pList,j));
                    al_set(pList,j,aux);
                }
                else if(retornFuncion == -1 && order == 0)
                {
                    aux=al_get(pList,i);
                    al_set(pList,i,al_get(pList,j));
                    al_set(pList,j,aux);
                }
            }
        }

        flag=1;

    }

    if (flag)
    {
        retorno=0;
    }

    return retorno;

}
Exemple #21
0
		void ReplaceVariable(ELEMENT* pEle)
		{
			/*递归函数,用来访问pEle下所有元素*/
			function<void(ELEMENT*, function<void(ELEMENT*)>)>
				recursiveFunc = [&recursiveFunc](ELEMENT* pEle, function<void(ELEMENT*)> pFunc)->void
			{
				if (pFunc != nullptr)
				{
					pFunc(pEle);
				}

				for (ELEMENT* p = pEle->FirstChildElement();
					p != 0;
					p = p->NextSiblingElement())
				{
					recursiveFunc(p, pFunc);
				}
			};
			
			/*以下用来将内容替换成变量中内容*/
			for (ELEMENT* p = pEle->FirstChildElement("Variable")->FirstChildElement();
				p != 0;
				p=p->NextSiblingElement())
			{
				std::string vName, vValue;
				
				vName = string("$(") + string(p->Name()) + string(")");
				vValue = std::string(p->GetText());
				
				recursiveFunc(pEle, [vName,vValue](ELEMENT* p)->void
				{
					const char* text;
					if ((text=p->GetText()) != nullptr)
					{
						string str(text);
						std::size_t pos;
						while ((pos = str.find(vName)) != str.npos)
						{
							str.replace(pos, vName.length(), vValue);
						}
						p->SetText(str.c_str());
					}
				});
				
			}
		}
Exemple #22
0
// Basic test. Makes @size chunks of 64 elements and writes in them random values, reverse them and checks if they are ok. 
// IF @flagForPrintValues is set, prints the valus of the arrays(and the result for every chunk).
void testValueValidation(void(*pFunc)(char*, int), int size, char flagForPrintValues)
{
	// Allocate memory for the control values(@arr) and the same one in @arrReversed which will be reversed
	int sizeMul64 = size << 6;
	char * arr = new char[sizeMul64];
	char * arrReversed = new char[sizeMul64];

	printf("Starting value validation tests with %d chunks (%d elements)!\n", size, sizeMul64);

	// Fill with some random values.
	srand(0);
	for (size_t i = 0; i < sizeMul64; ++i)
		arr[i] = arrReversed[i] = rand() % 256 - 128; // -128 to 127

	// Prints the origin values.
	if (flagForPrintValues)
		printArr(arr, sizeMul64);

	// Reverse it in every chunk
	pFunc(arrReversed, size);

	if (flagForPrintValues)
	{
		printf("\n[REVERSED]\n\n");

		// Prints the reversed values values.
		printArr(arrReversed, sizeMul64);
		printf("\nLet us check the values:\n");
	}

	// Check if it`s reversed correctly.
	if (compareArrayWithReversedOneByChunks(arr, arrReversed, size, flagForPrintValues))
		printf(" ---> [Passed!]\n");
	else
		printf(" ---> [Failed!]\n");
	// Delete memory
	delete[] arr;
	delete[] arrReversed;
}
static void recursive_display(GTreeNode* node, GTree_Printf* pFunc, int format, int gap, char div)
{
    int i = 0;
    
    if( (node != NULL) && (pFunc != NULL) )
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
    
        pFunc(node->data);
    
        printf("\n");
    
        for(i=0; i<LinkList_Length(node->child); i++)
        {
            TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);
            
            recursive_display(trNode->node, pFunc, format + gap, gap, div);
        }
    }
}
Exemple #24
0
int main(int argc, char* argv[])
{
    HMODULE h = NULL;
    FILE* fp = NULL;
    jmp_buf env;
    int i;
    char* buf;
    ucontext_t context;

    h = LoadLibrary("windll.dll");
    if (h != NULL) {
        pFunc = (void*)GetProcAddress(h, "windll");
        if (pFunc != NULL) {
            printf("winmain: Call windll\n");
            pFunc();
        }
    }

    if (argc >= 3) {
        memcpy(env, argv[argc-2], sizeof(jmp_buf));
        sscanf(argv[argc-1], "%p", &__longjmp);

        fp = fopen("__funp.txt", "w");
        if (fp != NULL)
            fprintf(fp, "%p\n", pFunc);
        fclose(fp);

        fp = fopen("__env.bin", "rb");
        if (fp != NULL)
            fread(&context, sizeof(char), sizeof(ucontext_t), fp);
        fclose(fp);
        setcontext(&context);

        __longjmp(env, 2);
        printf("Never Executed!\n");
    }
}
static void bfs(TMGraph* graph, int v, int visited[], MGraph_Printf* pFunc)
{
    LinkQueue* queue = LinkQueue_Create();
    
    if( queue != NULL ){
        LinkQueue_Append(queue, graph->v + v); // 直接+v 跳到v对应的地方 实际上就是 v[v][0]       
        visited[v] = 1; 
        
        while( LinkQueue_Length(queue) > 0 ){
            int i = 0;            
            v = (MVertex**)LinkQueue_Retrieve(queue) - graph->v; // 出队列减去 graph->v 起始地址得到偏移量            
            pFunc(graph->v[v]);            
            printf(", ");
            
            for(i=0; i<graph->count; i++){
                if( (graph->matrix[v][i] != 0) && !visited[i] ){
                    LinkQueue_Append(queue, graph->v + i); // 压人的时候 实际上是压入了定点v  这里的遍历可以理解成一颗大树                
                    visited[i] = 1;
                }
            }
        }
    }    
    LinkQueue_Destroy(queue);
}
Exemple #26
0
void XMLParser::parseElement(istream & input, string sPrefix, vector<XMLSerializable*> & vObjects, int &index)
{
	string sElementName;
	getline(input, sElementName, '>');
	//cout << sPrefix << sElementName << " (start)" << endl;
    map<string,function<XMLSerializable*()>> mapConstructor;
    mapConstructor["Item"] = []() { return new Item; };
    mapConstructor["Enemy"] = []() { return new Enemy; };
    mapConstructor["Armor"] = []() { return new Armor; };
    mapConstructor["Weapon"] = []() { return new Weapon; };
    mapConstructor["Consumable"] = []() { return new Consumable; };
    function<XMLSerializable*()> pFunc;
    XMLSerializable* myObject = NULL;
    
    if (sPrefix == "-> ")
    {
        index++;
        pFunc = mapConstructor[sElementName];
        myObject = pFunc();
        vObjects.push_back(myObject);
    }
    
    
	bool bDone = false;
    
	string sContent;
    
	while( !bDone )
	{
        string sEndTag;
		char c = input.get();
		if( c == '<' )
		{
			if( input.peek() == '/' )
			{
				getline(input, sEndTag, '>');
                
				if( sEndTag == "/" + sElementName )
				{
                    
				//	cout << sPrefix << sElementName << ": " << sContent << " (end)" << endl;
                    
                    if (sPrefix == "-> -> ")
                    {
                        vObjects[index]->setElementData(sElementName, sContent);
                    }
                    bDone = true;
                    
				}
				else
				{
					cout << "Inavlid XML!" << endl;
				}
			}
			else
			{
				parseElement(input, sPrefix + "-> ", vObjects, index);
			}
		}
		else if( c != '\n' )
		{
			sContent.push_back(c);
		}
	}
    if (myObject != NULL)
    {
    }
	return;
}
Exemple #27
0
// Examples:
//
// 1. prog -c123   --> (c,123)
// 2. prog -c 123  --> (c,123)
// 3. prog -c=123  --> (c,123)
// 4. prog -cs 123 --> (c,123) (s)
// 5. prog -sc=123 --> (s) (c,123)
// 6. prog -cs123 --> (c,s123)
//
void CLI_Process
(
    int argc,
    char *argv[],
    CLI_OptionEntry *aOptionTable,
    int nOptionTable,
    CLI_CALLBACKFUNC *pFunc
)
{
    int minNonOption = 0;
    int bEndOfOptions = 0;
    for (int i = 1; i < argc; i++)
    {
        char *pArgv = argv[i];
        int iType = 0;
        if (!bEndOfOptions)
        {
            iType = iArgType(pArgv);
        }

        if (iType == 0)
        {
            // Non-option argument.
            //
            if (minNonOption <= i)
            {
                // We haven't associated it with an option, yet, so
                // pass it in by itself.
                //
                pFunc(0, pArgv);
            }
            continue;
        }

        if (minNonOption < i+1)
        {
            minNonOption = i+1;
        }

        if (iType == 3)
        {
            // A "--" causes the remaining unpaired arguments to be
            // treated as non-option arguments.
            //
            bEndOfOptions = 1;
            continue;
        }

        const char *p = pArgv+iType;

        if (iType == 2)
        {
            // We have a long option.
            //
            const char *pEqual = strchr(p, '=');
            size_t nLen;
            if (pEqual)
            {
                nLen = pEqual - p;
            }
            else
            {
                nLen = strlen(p);
            }
            for (int j = 0; j < nOptionTable; j++)
            {
                if (  !strncmp(aOptionTable[j].m_Flag, p, nLen)
                   && aOptionTable[j].m_Flag[nLen] == '\0')
                {
                    switch (aOptionTable[j].m_ArgControl)
                    {
                    case CLI_NONE:
                        pFunc(aOptionTable + j, 0);
                        break;

                    case CLI_OPTIONAL:
                    case CLI_REQUIRED:
                        if (pEqual)
                        {
                            pFunc(aOptionTable + j, pEqual+1);
                            break;
                        }
                        int bFound = 0;
                        for (; minNonOption < argc; minNonOption++)
                        {
                            int iType2 = iArgType(argv[minNonOption]);
                            if (iType2 == 0)
                            {
                                pFunc(aOptionTable + j, argv[minNonOption]);
                                minNonOption++;
                                bFound = 1;
                                break;
                            }
                            else if (iType2 == 3)
                            {
                                // End of options. Stop.
                                //
                                break;
                            }
                        }
                        if (  !bFound
                           && aOptionTable[j].m_ArgControl == CLI_OPTIONAL)
                        {
                            pFunc(aOptionTable + j, 0);
                        }
                        break;
                    }
                    break;
                }
            }
            continue;
        }

        // At this point, the only possibilities left are a short
        // option.
        //
        while (*p)
        {
            int ch = *p++;
            for (int j = 0; j < nOptionTable; j++)
            {
                if (  aOptionTable[j].m_Flag[0] == ch
                   && aOptionTable[j].m_Flag[1] == '\0')
                {
                    switch (aOptionTable[j].m_ArgControl)
                    {
                    case CLI_NONE:
                        pFunc(aOptionTable + j, 0);
                        break;

                    case CLI_OPTIONAL:
                    case CLI_REQUIRED:
                        if (*p)
                        {
                            // Value follows option letter
                            //
                            if (*p == '=')
                            {
                                p++;
                            }

                            pFunc(aOptionTable + j, p);
                            p = "";
                            break;
                        }
                        int bFound = 0;
                        for (; minNonOption < argc; minNonOption++)
                        {
                            int iType2 = iArgType(argv[minNonOption]);
                            if (iType2 == 0)
                            {
                                pFunc(aOptionTable + j, argv[minNonOption]);
                                minNonOption++;
                                bFound = 1;
                                break;
                            }
                            else if (iType2 == 3)
                            {
                                // End of options. Stop.
                                //
                                break;
                            }
                        }
                        if (  !bFound
                           && aOptionTable[j].m_ArgControl == CLI_OPTIONAL)
                        {
                            pFunc(aOptionTable + j, 0);
                        }
                        break;
                    }
                    break;
                }
            }
        }
    }
}
Exemple #28
0
template<> LogWrapper& LogWrapper::operator<<(LogWrapper::LoggerFunction pFunc)
{
  return pFunc(*this);
}
bool CMetaDataFunction::CallFuction(int param_count, ...)
{
	if (!m_pFunction || (!m_pParamTable && param_count != 0) || (m_pParamTable && param_count != m_pParamTable->size())) return false;
	
	bool ret;

	va_list pList;
	unsigned int param_addr;
	bool *pNeedRelease;

	CParamVector::iterator itr;
	int type_size;
	void **pParamPtrBuffer;
	int index;

	SMetaDataCalledFunctionDataPacket Packet;
	TpMDCalledFunction pFunc(reinterpret_cast<TpMDCalledFunction>(m_pFunction));

	pNeedRelease = new bool [param_count];
	try
	{
		va_start(pList, param_count);
		try
		{
			param_addr = reinterpret_cast<unsigned int>(pList);
			if (m_pParamTable)
			{
				pParamPtrBuffer = new void* [param_count];
				try
				{
					memset(pParamPtrBuffer, 0x00, sizeof(void*) * param_count);
					index = 0;
					for (itr = m_pParamTable->begin(); itr != m_pParamTable->end(); ++itr)
					{
						if ((*itr)->GetPtrLevel() <= 0)
							type_size = SizeInVarParamFunc((*itr)->GetMDType(), reinterpret_cast<void*>(param_addr), pParamPtrBuffer + index);
						else type_size = sizeof(void*);
						pNeedRelease[index] = pParamPtrBuffer[index] != NULL;
						if (!pNeedRelease[index])
						{
							pParamPtrBuffer[index] = reinterpret_cast<void*>(param_addr);
						}
						++index;
						param_addr += MD_FUNC_VA_INTSIZEOF(type_size);
					}

					Packet.ParamCount = param_count;
					Packet.pParam = pParamPtrBuffer;
					if (m_pReturnInfo)
					{
						Packet.pReturn = *reinterpret_cast<void**>(param_addr);
					}
					else Packet.pReturn = NULL;

					ret = pFunc(Packet);

					for (index = 0; index < param_count; ++index)
					{
						if (pNeedRelease[index])
							delete pParamPtrBuffer[index];
					}
				}
				catch(...)
				{
					delete pParamPtrBuffer;
					throw;
				}
				delete pParamPtrBuffer;
			}
			else
			{
				Packet.ParamCount = 0;
				Packet.pParam = NULL;
				if (m_pReturnInfo)
				{
					Packet.pReturn = *reinterpret_cast<void**>(param_addr);
				}
				else Packet.pReturn = NULL;

				ret = pFunc(Packet);
			}
		}
		catch(...)
		{
			va_end(pList);
			throw;
		}
		va_end(pList);
	}
	catch(...)
	{
		delete pNeedRelease;
		throw;
	}
	delete pNeedRelease;

	return ret;
}
bool CMetaDataFunction::CallFuction(CParamVector *pParamTypes, va_list pParamList, void *pReturn)
{
	if (!m_pFunction || (!m_pParamTable && (pParamTypes) && pParamTypes->size()!= 0)
		|| (m_pParamTable && pParamTypes && m_pParamTable->size() != pParamTypes->size())
		|| (m_pParamTable && !pParamTypes && m_pParamTable->size() != 0)) return false;

	bool ret;

	unsigned int param_addr;
	int arr_size;
	bool *pNeedRelease;
	void **pParamPtrBuffer;

	CParamVector::iterator itr_in;
	CParamVector::iterator itr_func;
	int type_size;
	int index;
	bool bParamsOK(true);

	SMetaDataCalledFunctionDataPacket Packet;
	TpMDCalledFunction pFunc(reinterpret_cast<TpMDCalledFunction>(m_pFunction));

	if (m_pParamTable)
		arr_size = m_pParamTable->size();
	else arr_size = 0;

	pNeedRelease = new bool [arr_size];
	try
	{
		memset(pNeedRelease, 0x00, sizeof(bool) * arr_size);
		param_addr = reinterpret_cast<unsigned int>(pParamList);
		if (arr_size > 0)
		{
			if (param_addr == 0)
			{
				throw new ExceptionMetaData(D_E_ID_ERR_MD_CALL_META_DATA_OF_FUNC, "错误:调用参数表缺失!");
			}
			pParamPtrBuffer = new void* [arr_size];
			try
			{
				memset(pParamPtrBuffer, 0x00, sizeof(void*) * arr_size);
				index = 0;
				for (itr_func = m_pParamTable->begin(), itr_in = pParamTypes->begin();
					itr_func != m_pParamTable->end() && itr_in != pParamTypes->end(); ++itr_func, ++itr_in)
				{
					if ((*itr_func)->GetMDType() == (*itr_in)->GetMDType() && (*itr_func)->GetPtrLevel() == (*itr_in)->GetPtrLevel())
					{
						if ((*itr_func)->GetPtrLevel() <= 0)
							type_size = SizeInVarParamFunc((*itr_func)->GetMDType(), reinterpret_cast<void*>(param_addr), pParamPtrBuffer + index);
						else type_size = sizeof(void*);
						pNeedRelease[index] = pParamPtrBuffer[index] != NULL;
						if (!pNeedRelease[index])
						{
							pParamPtrBuffer[index] = reinterpret_cast<void*>(param_addr);
						}
						++index;
						param_addr += MD_FUNC_VA_INTSIZEOF(type_size);
					}
					else
					{
						bParamsOK = false;
						break;
					}
				}
				if (bParamsOK) bParamsOK = itr_func == m_pParamTable->end() && itr_in == pParamTypes->end();

				if (bParamsOK)
				{
					Packet.ParamCount = arr_size;
					Packet.pParam = pParamPtrBuffer;
					if (m_pReturnInfo)
					{
						Packet.pReturn = pReturn;
					}
					else Packet.pReturn = NULL;

					ret = pFunc(Packet);
				}
				else ret = false;

				for (index = 0; index < arr_size; ++index)
				{
					if (pNeedRelease[index])
						delete pParamPtrBuffer[index];
				}
			}
			catch(...)
			{
				delete pParamPtrBuffer;
				throw;
			}
			delete pParamPtrBuffer;
		}
		else
		{
			Packet.ParamCount = 0;
			Packet.pParam = NULL;
			if (m_pReturnInfo)
			{
				Packet.pReturn = pReturn;
			}
			else Packet.pReturn = NULL;

			ret = pFunc(Packet);
		}
	}
	catch(...)
	{
		delete pNeedRelease;
		throw;
	}
	delete pNeedRelease;

	return ret;
}