Beispiel #1
0
/***************************************************************************
*  Função:  Menu Cadastrar Peça
*  ****/
static void MenuCadastrarPeca(PAR_tppPartida ppPartida)
{
   char *nome, *passos, *tipoMov;
   ISP_tpCondRet ispCondRet;
   MPEC_tpTipoMovimento tipoMovimento;
   LIS_tppLista pPassos;

   MEM_Alloc(sizeof(char)*20,(void**)&nome);
   MEM_Alloc(sizeof(char)*200,(void**)&passos);
   MEM_Alloc(sizeof(char)*4,(void**)&tipoMov);

   printf("Nome da peca (20 caracteres): ");
   scanf("%s",nome);
   printf("Movimentos ([n]coordenada_[n]coordenada): ");
   scanf("%s", passos);
   printf("Tipo de movimento(Anda | Voa): ");
   scanf("%s",tipoMov);

   ispCondRet = ISP_LerTipoMovimento(tipoMov,&tipoMovimento);

   if(ispCondRet != ISP_CondRetOK)
   {
      return Mensagem("Tipo de movimento invalido!");
   }

   ISP_LerPassos(passos,&pPassos);

   PAR_CriarPeca(ppPartida, nome, pPassos, tipoMovimento);

   return Mensagem("Peca cadastrada com sucesso!");
}
Beispiel #2
0
/***************************************************************************
*  Função:  Menu Inserir Peça
*  ****/
static void MenuInserirPeca(PAR_tppPartida ppPartida, const PEC_tpTimePeca time)
{
   char *nome, *nomeCasa;
   PAR_tpCondRet condRet;

   MEM_Alloc(sizeof(char)*20,(void**)&nome);
   MEM_Alloc(sizeof(char)*2,(void**)&nomeCasa);

   printf("Nome da peca (20 caracteres): ");
   scanf("%s", nome);

   printf("Nome da casa que deseja inserir a peca (2 caracteres - convenção do xadrez): ");
   scanf("%s", nomeCasa);

   nomeCasa[0] = toupper(nomeCasa[0]);

   condRet = PAR_IrCasa(ppPartida, nomeCasa);

   if(condRet !=  PAR_CondRetOK)
   {
      return Mensagem("Erro ao inserir - Casa nao existe!");
   }

   condRet = PAR_InserirPeca(ppPartida,nome,time);

   if(condRet == PAR_CondRetPecaNaoEncontrada)
   {
      return Mensagem("Erro ao inserir - Peca nao encontrada!");
   }

   return Mensagem("Peca inserida no time com sucesso!");
}
Beispiel #3
0
/***************************************************************************
*  Função:  Menu Remover Peça
*  ****/
static void MenuRemoverPeca(PAR_tppPartida ppPartida)
{
   char *nomeDaCasa;
   PAR_tpCondRet condRet;

   MEM_Alloc(sizeof(char)*2,(void**)&nomeDaCasa);

   printf("Nome da casa onde esta a peca a ser removida: ");
   scanf("%s",nomeDaCasa);

   nomeDaCasa[0] = toupper(nomeDaCasa[0]);

   condRet = PAR_IrCasa(ppPartida,nomeDaCasa);

   if(condRet !=  PAR_CondRetOK)
   {
      return Mensagem("Erro ao remover - Casa nao existe!");
   }

   condRet = PAR_RemoverPeca(ppPartida);

   if(condRet == PAR_CondRetPecaNaoEncontrada)
   {
      return Mensagem("Erro ao remover - casa esta vazia!");
   }

   return Mensagem("Peca removida com sucesso!");
}
Beispiel #4
0
/***************************************************************************
*  Função:  Menu Inserir Rei
*  ****/
static void MenuInserirRei(PAR_tppPartida ppPartida)
{
   char *nomeCasa;
   PAR_tpCondRet condRet;

   MEM_Alloc(sizeof(char)*2,(void**)&nomeCasa);

   printf("Nome da casa que deseja inserir o rei (2 caracteres - convenção do xadrez): ");
   scanf("%s", nomeCasa);

   nomeCasa[0] = toupper(nomeCasa[0]);

   condRet = PAR_IrCasa(ppPartida, nomeCasa);

   if(condRet !=  PAR_CondRetOK)
   {
      return Mensagem("Erro ao inserir - Casa nao existe!");
   }

   condRet = PAR_InserirRei(ppPartida);

   if(condRet != PAR_CondRetOK)
   {
      return Mensagem("Erro ao inserir o rei!");
   }

   return Mensagem("Rei inserido com sucesso!");
}
Beispiel #5
0
  /* create a new chunk node, setting its cache index and ref count */
  FT_EXPORT_DEF( FT_Error )  FTC_ChunkNode_Init( FTC_ChunkNode  node,
                                                 FTC_ChunkSet   cset,
                                                 FT_UInt        index,
                                                 FT_Bool        alloc )
  {
    FTC_Chunk_Cache      cache = cset->cache;
    FTC_CacheNode_Data*  data  = FTC_CACHENODE_TO_DATA_P( &node->root );
    FT_Error             error = 0;


    data->cache_index  = (FT_UShort)cache->root.cache_index;
    data->ref_count    = (FT_Short) 0;
    node->cset         = cset;
    node->cset_index   = (FT_UShort)index;
    node->num_elements = ( index + 1 < cset->num_chunks )
                         ? cset->element_count
                         : cset->element_max - cset->element_count*index;
    if ( alloc )
    {
      /* allocate elements array */
      FT_Memory   memory;


      memory = cache->root.memory;
      error  = MEM_Alloc( node->elements,
                          cset->element_size * cset->element_count );
    }

    return error;
  }
Beispiel #6
0
/** ============================================================================
 *  @func   MEM_Calloc
 *
 *  @desc   Allocates the specified number of bytes and memory is set to zero.
 *
 *  @modif  None
 *  ============================================================================
 */
EXPORT_API
DSP_STATUS
MEM_Calloc (OUT Void ** ptr, IN Uint32 cBytes, IN OUT Pvoid arg)
{
    DSP_STATUS status = DSP_SOK ;
    Uint32       i                ;

    TRC_3ENTER ("MEM_Calloc", ptr, cBytes, arg) ;

    DBC_Require (ptr != NULL) ;
    DBC_Require (MEM_IsInitialized == TRUE) ;
    DBC_Require (cBytes != 0) ;

    status = MEM_Alloc (ptr, cBytes, arg) ;

    if (DSP_SUCCEEDED (status)) {
        for (i = 0 ; i < cBytes ; i++) {
            (*(Uint8 **) ptr)[i] = 0 ;
        }
    }

    DBC_Ensure (   ((ptr == NULL) && DSP_FAILED (status))
                || ((ptr != NULL) && (*ptr != NULL) && DSP_SUCCEEDED (status))
                || ((ptr != NULL) && (*ptr == NULL) && DSP_FAILED (status))) ;

    TRC_1LEAVE ("MEM_Calloc", status) ;

    return  status ;
}
Beispiel #7
0
/**
 * Free unused memory.
 */
void BITSET_Trim(BitSet * bs)
{
    if (bs->alloc > bs->inuse) {
        if (bs->inuse == 0) {
            ASSERT(bs->storage.units);
            MEM_Free(bs->storage.units);
            bs->storage.units  = NULL;
            bs->alloc = 0;
        } else {
            BitUnit * savebuf = bs->storage.units;
            size_t size = sizeof(BitUnit) * bs->inuse;

#ifdef NO_REALLOC
            bs->storage.units = (BitUnit*)MEM_Alloc(size);
            if (bs->storage.units) {
                memcpy(bs->storage.units, savebuf, size);
                MEM_Free(bs->storage.units);
            }
#else
            bs->storage.units = (BitUnit*)MEM_Realloc(savebuf, size);
#endif /* NO_REALLOC */

            if (bs->storage.units) {
                bs->alloc = bs->inuse;
            } else {
                bs->storage.units = savebuf;
            }
        }
    }
}
Beispiel #8
0
/**
 * Creates and starts n worker thread
 */
WorkQueue * WKQ_CreatePool(int n)
{
    size_t size = sizeof(WorkQueue) + sizeof(ThrID)*(MAX(n,1)-1);
    WorkQueue * q = MEM_Alloc(size);
    if (q) {
        ASSERT(WKQ.initcount > 0);
        if (WKQ.initcount == 0) WKQ_InitModule();
        memset(q, 0, size);
        q->nthreads = n;
        if (MUTEX_Init(&q->mutex)) {
            if (EVENT_Init(&q->event)) {
                if (EVENT_Init(&q->stopEvent)) {
                    if (EVENT_Reset(&q->stopEvent)) {
                        int i;
                        q->flags = WKQ_ACTIVE;
                        QUEUE_Init(&q->items);
                        QUEUE_Init(&q->submit);
                        for (i=0; i<n; i++) {
                            if (!THREAD_Create(q->threads+i, WKQ_Thread, q)) {
                                WKQ_Delete(q);
                                return NULL;
                            }
                        }
                        return q;
                    }
                    EVENT_Destroy(&q->stopEvent);
                }
                EVENT_Destroy(&q->event);
            }
            MUTEX_Destroy(&q->mutex);
        }
        MEM_Free(q);
    }
    return NULL;
}
Beispiel #9
0
/**
 * Initializes the input zlib context 
 */
STATIC Bool ZipInitIn(Zip * zf)
{

    /* allocate buffer */
    zf->inbuf = (I8u*)MEM_Alloc(zf->bufsize);
    if (zf->inbuf) {

        /* allocate zlib context */
        zf->in = MEM_New(z_stream);
        if (zf->in) {
            int bits = ((zf->zflags & ZIP_ZHDR) ? (-MAX_WBITS) : MAX_WBITS);

            /* tell zlib to use our memory allocation functions */
            memset(zf->in, 0, sizeof(*zf->in));
            zf->in->zalloc = ZipMemAlloc;
            zf->in->zfree = ZipMemFree;
            zf->in->next_in = zf->inbuf;
            if (inflateInit2(zf->in, bits) == Z_OK) {

                /* skip .gz header */
                if (!(zf->zflags & ZIP_GZIP) || ZipSkipHeader(zf)) {
                    return True;
                }
                inflateEnd(zf->in);
            }
            MEM_Free(zf->in);
            zf->in = NULL;
        }
        MEM_Free(zf->inbuf);
        zf->inbuf = NULL;
    }
    zf->zflags |= ZIP_IN_ERR;
    return False;
}
Beispiel #10
0
static ELEMENT* psc_read_element (MEM *elemem, MEM *facmem, FILE *f)
{
  FACE *fac, *tail;
  ELEMENT *ele;
  short j;
  int i;

  ERRMEM (ele = MEM_Alloc (elemem));

  fread (&ele->type, sizeof (short), 1, f);
  fread (&ele->neighs, sizeof (short), 1, f);
  fread (&ele->volume, sizeof (int), 1, f);
  fread (ele->nodes, sizeof (int), ele->type, f);

  for (i = 0; i < ele->neighs; i ++)
  {
    fread (&j, sizeof (short), 1, f);
    ele->adj [i] = (void*) (long) j;
  }

  fread (&j, sizeof (short), 1, f);

  for (i = 0, tail = NULL; i < j; i ++)
  {
    fac = psc_read_face (facmem, f);
    fac->ele = ele;

    if (tail) tail->next = fac;
    else ele->faces = fac;
    tail = fac;
  }

  return ele;
}
Beispiel #11
0
/*
 * ======== MGRWRAP_EnumProc_Info ========
 */
u32 MGRWRAP_EnumProc_Info(union Trapped_Args *args, void *pr_ctxt)
{
	u8 *pProcessorInfo;
	u32 uNumProcs;
	DSP_STATUS status = DSP_SOK;
	u32 size = args->ARGS_MGR_ENUMPROC_INFO.uProcessorInfoSize;

	GT_4trace(WCD_debugMask, GT_ENTER,
		 "MGRWRAP_EnumProc_Info: entered args:\n"
		 "0x%x uProcessor: 0x%x\tpProcessorInfo: 0x%x\t"
		 "uProcessorInfoSize: 0x%x\tpuNumProcs \n",
		 args->ARGS_MGR_ENUMPROC_INFO.uProcessor,
		 args->ARGS_MGR_ENUMPROC_INFO.pProcessorInfo,
		 args->ARGS_MGR_ENUMPROC_INFO.uProcessorInfoSize,
		 args->ARGS_MGR_ENUMPROC_INFO.puNumProcs);
	pProcessorInfo = MEM_Alloc(size, MEM_NONPAGED);
	if (pProcessorInfo == NULL)
		status = DSP_EMEMORY;

	if (DSP_SUCCEEDED(status)) {
		status = MGR_EnumProcessorInfo(args->
				ARGS_MGR_ENUMPROC_INFO.uProcessor,
				(struct DSP_PROCESSORINFO *)pProcessorInfo,
				size, &uNumProcs);
	}
	cp_to_usr(args->ARGS_MGR_ENUMPROC_INFO.pProcessorInfo, pProcessorInfo,
		 status, size);
	cp_to_usr(args->ARGS_MGR_ENUMPROC_INFO.puNumProcs, &uNumProcs,
		 status, 1);
	if (pProcessorInfo)
		MEM_Free(pProcessorInfo);

	return status;
}
Beispiel #12
0
/***************************************************************************
*  Função: GRA Inserir vertice
******/
GRA_tpCondRet GRA_InserirVertice(GRA_tppGrafo pGrafoParm, char *nomeVertice, void *pValor)
{
	tpGrafo *pGrafo = (tpGrafo*) pGrafoParm;
	tpVertice *pVertice;

	if (pGrafo == NULL)
	{
		return GRA_CondRetGrafoNaoFoiCriado;
	}

   if (ExisteVertice(pGrafo, nomeVertice))
   {
      return GRA_CondRetJaExiste;
   }

	MEM_Alloc(sizeof(tpVertice), (void **) &pVertice);
	if (pVertice == NULL)
	{
		return GRA_CondRetFaltouMemoria;
	}

	pVertice->nome = nomeVertice;
	pVertice->pValor = pValor;
	pVertice->destruirValor = pGrafo->destruirValor;

	LIS_CriarLista(&pVertice->pAntecessores, NULL, CompararVerticeENome);
	LIS_CriarLista(&pVertice->pSucessores, DestruirAresta, CompararArestaENome);

	pGrafo->pCorrente = pVertice;
	LIS_InserirElementoApos(pGrafo->pVertices, pVertice);

	return GRA_CondRetOK;
}
Beispiel #13
0
/*
 * ======== MGRWRAP_EnumNode_Info ========
 */
u32 MGRWRAP_EnumNode_Info(union Trapped_Args *args, void *pr_ctxt)
{
	u8 *pNDBProps;
	u32 uNumNodes;
	DSP_STATUS status = DSP_SOK;
	u32 size = args->ARGS_MGR_ENUMNODE_INFO.uNDBPropsSize;

	GT_4trace(WCD_debugMask, GT_ENTER,
		 "MGR_EnumNodeInfo: entered args:\n0x%x"
		 " uNode: 0x%x\tpNDBProps: 0x%x\tuNDBPropsSize: "
		 "0x%x\tpuNumNodes\n", args->ARGS_MGR_ENUMNODE_INFO.uNode,
		 args->ARGS_MGR_ENUMNODE_INFO.pNDBProps,
		 args->ARGS_MGR_ENUMNODE_INFO.uNDBPropsSize,
		 args->ARGS_MGR_ENUMNODE_INFO.puNumNodes);
	pNDBProps = MEM_Alloc(size, MEM_NONPAGED);
	if (pNDBProps == NULL)
		status = DSP_EMEMORY;

	if (DSP_SUCCEEDED(status)) {
		status = MGR_EnumNodeInfo(args->ARGS_MGR_ENUMNODE_INFO.uNode,
					 (struct DSP_NDBPROPS *)pNDBProps,
					 size, &uNumNodes);
	}
	cp_to_usr(args->ARGS_MGR_ENUMNODE_INFO.pNDBProps, pNDBProps, status,
		 size);
	cp_to_usr(args->ARGS_MGR_ENUMNODE_INFO.puNumNodes, &uNumNodes, status,
		 1);
	if (pNDBProps)
		MEM_Free(pNDBProps);

	return status;
}
Beispiel #14
0
/*
 * ======== STRMWRAP_FreeBuffer ========
 */
u32 STRMWRAP_FreeBuffer(union Trapped_Args *args, void *pr_ctxt)
{
	DSP_STATUS status = DSP_SOK;
	u8 **apBuffer = NULL;
	u32 uNumBufs = args->ARGS_STRM_FREEBUFFER.uNumBufs;

	DBC_Require(uNumBufs <= MAX_BUFS);

	apBuffer = MEM_Alloc((uNumBufs * sizeof(u8 *)), MEM_NONPAGED);

	cp_fm_usr(apBuffer, args->ARGS_STRM_FREEBUFFER.apBuffer, status,
		 uNumBufs);

	if (DSP_SUCCEEDED(status)) {
		mutex_lock(&((struct PROCESS_CONTEXT *)pr_ctxt)->strm_lock);
		status = STRM_FreeBuffer(args->ARGS_STRM_FREEBUFFER.hStream,
					 apBuffer, uNumBufs, pr_ctxt);
		mutex_unlock(&((struct PROCESS_CONTEXT *)pr_ctxt)->strm_lock);
	}
	cp_to_usr(args->ARGS_STRM_FREEBUFFER.apBuffer, apBuffer, status,
		 uNumBufs);
	if (apBuffer)
		MEM_Free(apBuffer);

	return status;
}
Beispiel #15
0
/*
 * ======== NODEWRAP_GetUUIDProps ========
 */
u32 NODEWRAP_GetUUIDProps(union Trapped_Args *args, void *pr_ctxt)
{
	DSP_STATUS status = DSP_SOK;
	struct DSP_UUID nodeId;
	struct DSP_NDBPROPS    *pnodeProps = NULL;

	GT_0trace(WCD_debugMask, GT_ENTER,
		 "NODEWRAP_GetUUIDPropste: entered\n");


	cp_fm_usr(&nodeId, args->ARGS_NODE_GETUUIDPROPS.pNodeID, status, 1);
	if (DSP_FAILED(status))
		goto func_cont;
	pnodeProps = MEM_Alloc(sizeof(struct DSP_NDBPROPS), MEM_NONPAGED);
	if (pnodeProps != NULL) {
		status = NODE_GetUUIDProps(args->
					  ARGS_NODE_GETUUIDPROPS.hProcessor,
					  &nodeId, pnodeProps);
		cp_to_usr(args->ARGS_NODE_GETUUIDPROPS.pNodeProps, pnodeProps,
			 status, 1);
	} else
		status = DSP_EMEMORY;
func_cont:
	if (pnodeProps)
		MEM_Free(pnodeProps);
	return status;
}
Beispiel #16
0
  static
  PList_Element  Element_New( PEngine_Instance  engine )
  {
    PList_Element  element;


    LOCK();
    if ( FREE_Elements )
    {
      element       = (PList_Element)FREE_Elements;
      FREE_Elements = element->next;
    }
    else
    {
      if ( !MEM_Alloc( element, sizeof ( TList_Element ) ) )
      {
        element->next = NULL;
        element->data = NULL;
      }
    }

    /* Note: in case of failure, Alloc sets the pointer to NULL */
    UNLOCK();

    return element;
  }
Beispiel #17
0
/****************************************************************************\
 *
 * NT_QueryObjectName()
 *
 * DESCRIPTION:
 *
 *  Queries the name of the object (such as a device or file object).
 *  The caller must deallocate the return value with MEM_Free. The
 *  returned string (if not NULL) is guaranteed to be NULL terminated.
 *
 * ARGUMENTS:
 *
 *  obj - the object whose name to query
 *
\****************************************************************************/
OBJECT_NAME_INFORMATION * NT_QueryObjectName(PVOID obj)
{
    ULONG len = 0;
    NTSTATUS status = ObQueryNameString(obj, NULL, 0, &len);
    ASSERT(status != STATUS_SUCCESS);

    /*  Unlike the rest of the system, ObQueryNameString returns
     *  STATUS_INFO_LENGTH_MISMATCH instead of STATUS_BUFFER_TOO_SMALL 
     *  when passed too small a buffer. We expect to get this error here.
     *  Anything else we can't handle.
     */
    if (status == STATUS_INFO_LENGTH_MISMATCH && len > 0) {
        OBJECT_NAME_INFORMATION * name = MEM_Alloc(len + sizeof(WCHAR));
        if (name) {
            /* NOTE: ObQueryNameString may return STATUS_SUCCESS and empty
             * string for unnamed objects */
            status = ObQueryNameString(obj, name, len, &len);
            if (NT_SUCCESS(status) && name->Name.MaximumLength > 0) {
                /* make sure it's NULL terminated */
                ULONG Last = name->Name.Length/sizeof(name->Name.Buffer[0]);
                name->Name.Buffer[Last] = 0; 
                return name;
            }
            MEM_Free(name);
        }
    }
    return NULL;
}
Beispiel #18
0
/***************************************************************************
*  Função: GRA Inserir aresta
******/
GRA_tpCondRet GRA_InserirAresta(GRA_tppGrafo pGrafoParm,
	char *nomeAresta, char *nomeVerticeOrigem, char *nomeVerticeDestino)
{
	tpGrafo *pGrafo = (tpGrafo*) pGrafoParm;
	tpAresta *pAresta;
	LIS_tpCondRet lisCondRet;
   GRA_tpCondRet graCondRet;
   tpVertice *pVerticeOrigem, *pVerticeDestino;

	if (pGrafo == NULL)
	{
		return GRA_CondRetGrafoNaoFoiCriado;
	}

   // Procura vértice origem
   graCondRet = ProcurarVertice(pGrafo, nomeVerticeOrigem, &pVerticeOrigem);
   if (graCondRet != GRA_CondRetOK)
   {
      return graCondRet;
   }

   // Procura vértice destino
   graCondRet = ProcurarVertice(pGrafo, nomeVerticeDestino, &pVerticeDestino);
   if (graCondRet != GRA_CondRetOK)
   {
      return graCondRet;
   }

   // Verifica se já existe uma aresta com este nome
   if (ExisteAresta(pVerticeOrigem, nomeAresta))
   {
      return GRA_CondRetJaExiste;
   }

	MEM_Alloc(sizeof(tpAresta), (void **) &pAresta);
	if (pAresta == NULL)
	{
		return GRA_CondRetFaltouMemoria;
	}

   // Atualiza os antecessores do vértice destino
	lisCondRet = LIS_InserirElementoApos(pVerticeDestino->pAntecessores, pVerticeOrigem);
	if (lisCondRet == LIS_CondRetFaltouMemoria)
	{
		return GRA_CondRetFaltouMemoria;
	}

   // Atualiza os sucessores do vértice origem
	lisCondRet = LIS_InserirElementoApos(pVerticeOrigem->pSucessores, pAresta);
	if (lisCondRet == LIS_CondRetFaltouMemoria)
	{
		return GRA_CondRetFaltouMemoria;
	}

	pAresta->nome = nomeAresta;
    pAresta->pVertice = pVerticeDestino;

	return GRA_CondRetOK;
}
Beispiel #19
0
/**
 * Initializes the output zlib context 
 */
STATIC Bool ZipInitOut(Zip * zf)
{

    /* allocate buffer */
    zf->outbuf = (I8u*)MEM_Alloc(zf->bufsize);
    if (zf->outbuf) {

        /* allocate zlib context */
        zf->out = MEM_New(z_stream);
        if (zf->out) {
            int zerr;
            int bits = ((zf->zflags & ZIP_ZHDR) ? (-MAX_WBITS) : MAX_WBITS);

            /* tell zlib to use our memory allocation functions */
            memset(zf->out, 0, sizeof(*zf->out));
            zf->out->zalloc = ZipMemAlloc;
            zf->out->zfree = ZipMemFree;

            /* windowBits is passed < 0 to suppress zlib header */
            zerr = deflateInit2(zf->out, Z_BEST_COMPRESSION,
                                         Z_DEFLATED, bits, 8,
                                         Z_DEFAULT_STRATEGY);

            if (zerr == Z_OK) {
                if (zf->zflags & ZIP_GZIP) {
                    /* write a very simple .gz header */
                    I8u hdr[10];
                    memset(hdr, 0, sizeof(hdr));
                    hdr[0] = (I8u)GzMagic[0];
                    hdr[1] = (I8u)GzMagic[1];
                    hdr[2] = Z_DEFLATED;
                    hdr[9] = OS_CODE;
                    if (FILE_Write(zf->f,hdr,sizeof(hdr)) == sizeof(hdr)) {
                        FILE_Flush(zf->f);
                        zf->out->next_out = zf->outbuf;
                        zf->out->avail_out = zf->bufsize;
                        return True;
                    }
                } else {
                    /* not writing the header */
                    zf->out->next_out = zf->outbuf;
                    zf->out->avail_out = zf->bufsize;
                    return True;
                }
                deflateEnd(zf->out);
            }
            MEM_Free(zf->out);
            zf->out = NULL;
        }
        MEM_Free(zf->outbuf);
        zf->outbuf = NULL;
    }
    zf->zflags |= ZIP_OUT_ERR;
    return False;
}
Beispiel #20
0
int main(void) {
	void *p1, *p2, *p3;
			
	uSMARTX_Init(tsk_tbl);
	
	p1 = MEM_Alloc(&sys_mem, 15);
	p2 = MEM_Alloc(&sys_mem, 64);
	p3 = MEM_Alloc(&sys_mem, 100);
	MEM_Free(&sys_mem, p1);
	p3 = MEM_Alloc(&sys_mem, 100);
	MEM_Free(&sys_mem, p2);
	p3 = MEM_Alloc(&sys_mem, 100);
	while(1) {
		uSMARTX_Tick();
		if(uSMARTX_Scheduler() == SYS_ERROR)
			break;
	}
	
	while(1);
}
Beispiel #21
0
/**
 * Create a card deck.
 *
 * \b History:
 * \arg 02.04.94  ESF Created.
 * \arg 03.16.94  ESF Added code for returned card handling.
 */
Deck *DECK_Create(Int32 iNumCards)
{
  Deck   *pDeck = (Deck *)MEM_Alloc(sizeof(Deck));
  Int32   i;

  /* Seed the random number generator */
  srand(time(NULL));

  /* Init the structure */
  pDeck->iCardsLeft = pDeck->iTotalCards = iNumCards;
  pDeck->iCardsReturned = 0;
  pDeck->piCards         = (Int32 *)MEM_Alloc(sizeof(Int32)*iNumCards);
  pDeck->piCardsReturned = (Int32 *)MEM_Alloc(sizeof(Int32)*iNumCards);

  /* Init all of the cards */
  for(i=0; i!=iNumCards; i++)
    pDeck->piCards[i] = i;

  return(pDeck);
}
Beispiel #22
0
/*
 * ======== NODEWRAP_Allocate ========
 */
u32 NODEWRAP_Allocate(union Trapped_Args *args, void *pr_ctxt)
{
	DSP_STATUS status = DSP_SOK;
	struct DSP_UUID nodeId;
	u32 cbDataSize = 0;
	u32 __user *pSize = (u32 __user *)args->ARGS_NODE_ALLOCATE.pArgs;
	u8 *pArgs = NULL;
	struct DSP_NODEATTRIN attrIn, *pAttrIn = NULL;
	struct NODE_OBJECT *hNode;

	GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Allocate: entered\n");

	/* Optional argument */
	if (pSize) {
		if (get_user(cbDataSize, pSize))
			status = DSP_EFAIL;

		cbDataSize += sizeof(u32);
		if (DSP_SUCCEEDED(status)) {
			pArgs = MEM_Alloc(cbDataSize, MEM_NONPAGED);
			if (pArgs == NULL)
				status = DSP_EMEMORY;

		}
		cp_fm_usr(pArgs, args->ARGS_NODE_ALLOCATE.pArgs, status,
			 cbDataSize);
	}
	cp_fm_usr(&nodeId, args->ARGS_NODE_ALLOCATE.pNodeID, status, 1);
	if (DSP_FAILED(status))
		goto func_cont;
	/* Optional argument */
	if (args->ARGS_NODE_ALLOCATE.pAttrIn) {
		cp_fm_usr(&attrIn, args->ARGS_NODE_ALLOCATE.pAttrIn, status, 1);
		if (DSP_SUCCEEDED(status))
			pAttrIn = &attrIn;
		else
			status = DSP_EMEMORY;

	}
	if (DSP_SUCCEEDED(status)) {
		mutex_lock(&((struct PROCESS_CONTEXT *)pr_ctxt)->node_lock);
		status = NODE_Allocate(args->ARGS_NODE_ALLOCATE.hProcessor,
				      &nodeId, (struct DSP_CBDATA *)pArgs,
				      pAttrIn, &hNode, pr_ctxt);
		mutex_unlock(&((struct PROCESS_CONTEXT *)pr_ctxt)->node_lock);
	}
	cp_to_usr(args->ARGS_NODE_ALLOCATE.phNode, &hNode, status, 1);
func_cont:
	if (pArgs)
		MEM_Free(pArgs);

	return status;
}
Beispiel #23
0
  static 
  TFileMap*  Allocate_Map( void )
  {
    TFileMap*  result;


    if ( MEM_Alloc( result, sizeof ( TFileMap ) ) )
      return NULL;

    result->refcount = 1;
    return result;
  }
Beispiel #24
0
/***************************************************************************
*  Função:  Menu Alterar Peça
*  ****/
static void MenuAlterarPeca(PAR_tppPartida ppPartida)
{
   char *nomeAtual, *novoNome, *novosPassos, *movimento;
   ISP_tpCondRet ispCondRet;
   PAR_tpCondRet parCondRet;
   MPEC_tpTipoMovimento novoTipoMovimento;
   LIS_tppLista pPassos;

   MEM_Alloc(sizeof(char)*20,(void**)&nomeAtual);
   MEM_Alloc(sizeof(char)*20,(void**)&novoNome);
   MEM_Alloc(sizeof(char)*200,(void**)&novosPassos);
   MEM_Alloc(sizeof(char)*4,(void**)&movimento);

   printf("\nNome da peca que quer alterar (20 caracteres): ");
   scanf("%s", nomeAtual);
   printf("Novo nome (20 caracteres): ");
   scanf("%s", novoNome);
   printf("Novo movimento ([n]coordenada): ");
   scanf("%s", novosPassos);
   printf("Novo tipo de movimento (Anda | Voa): ");
   scanf("%s", movimento);

   ispCondRet = ISP_LerTipoMovimento(movimento,&novoTipoMovimento);

   if(ispCondRet != ISP_CondRetOK)
   {
      return Mensagem("Tipo de movimento invalido!");
   }

   ISP_LerPassos(novosPassos,&pPassos);

   parCondRet = PAR_AlterarPeca(ppPartida,nomeAtual,novoNome,pPassos,novoTipoMovimento);

   if(parCondRet != PAR_CondRetOK)
   {
      return Mensagem("Erro ao alterar peca!");
   }

   return Mensagem("Peca alterada com sucesso!");
}
Beispiel #25
0
static ELEMENT* create_element (MEM *elemem, int *element)
{
  ELEMENT *ele;
  int n;

  ele = static_cast<ELEMENT*>(MEM_Alloc (elemem));
  ele->type = element [0];
  for (n = 1; n <= element [0]; n ++)
    ele->nodes [n-1] = element [n];
  ele->material = element [n]; /* material number */

  return ele;
}
Beispiel #26
0
/* create new list item */
static ITEM* skip_item (LIST *list, void *key, void *data)
{
  ITEM *item;

  if (!(item = MEM_Alloc (&list->mem))) return NULL;

  item->key = key;
  item->data = data;
  item->forward = (ITEM**) (item + 1); /* XXX: rather than this, length of 'forward' should vary depending on the number of stored items;
                                          XXX: 'forward' could be 'malloc'ed here and 'realloc'ated later, when the number of items exceeds
                                          XXX: consecutive powers of two; the drawback would be in greater memory fragmentation */

  return item;
}
Beispiel #27
0
static FACE* psc_read_face (MEM *facmem, FILE *f)
{
  FACE *fac;

  ERRMEM (fac = MEM_Alloc (facmem));

  fread (fac->normal, sizeof (double), 3, f);
  fread (&fac->type, sizeof (int), 1, f);
  fread (fac->nodes, sizeof (int), fac->type, f);
  fread (&fac->index, sizeof (int), 1, f);
  fread (&fac->surface, sizeof (int), 1, f);

  return fac;
}
Beispiel #28
0
/*
 * ======== NODEWRAP_Connect ========
 */
u32 NODEWRAP_Connect(union Trapped_Args *args, void *pr_ctxt)
{
	DSP_STATUS status = DSP_SOK;
	struct DSP_STRMATTR attrs;
	struct DSP_STRMATTR *pAttrs = NULL;
	u32 cbDataSize;
	u32 __user *pSize = (u32 __user *)args->ARGS_NODE_CONNECT.pConnParam;
	u8 *pArgs = NULL;

	GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Connect: entered\n");

	/* Optional argument */
	if (pSize) {
		if (get_user(cbDataSize, pSize))
			status = DSP_EFAIL;

		cbDataSize += sizeof(u32);
		if (DSP_SUCCEEDED(status)) {
			pArgs = MEM_Alloc(cbDataSize, MEM_NONPAGED);
			if (pArgs == NULL) {
				status = DSP_EMEMORY;
				goto func_cont;
			}

		}
		cp_fm_usr(pArgs, args->ARGS_NODE_CONNECT.pConnParam, status,
			 cbDataSize);
		if (DSP_FAILED(status))
			goto func_cont;
	}
	if (args->ARGS_NODE_CONNECT.pAttrs) {	/* Optional argument */
		cp_fm_usr(&attrs, args->ARGS_NODE_CONNECT.pAttrs, status, 1);
		if (DSP_SUCCEEDED(status))
			pAttrs = &attrs;

	}
	if (DSP_SUCCEEDED(status)) {
		status = NODE_Connect(args->ARGS_NODE_CONNECT.hNode,
				     args->ARGS_NODE_CONNECT.uStream,
				     args->ARGS_NODE_CONNECT.hOtherNode,
				     args->ARGS_NODE_CONNECT.uOtherStream,
				     pAttrs, (struct DSP_CBDATA *)pArgs);
	}
func_cont:
	if (pArgs)
		MEM_Free(pArgs);

	return status;
}
Beispiel #29
0
/***************************************************************************
*  Função: GRA Criar grafo
******/
GRA_tpCondRet GRA_CriarGrafo(GRA_tppGrafo *ppGrafo,
	void (*destruirValor)(void *pValor))
{
	tpGrafo *pGrafo;
   MEM_Alloc(sizeof(tpGrafo), (void **) &pGrafo);

	pGrafo->pCorrente = NULL;
	pGrafo->destruirValor = destruirValor;

	LIS_CriarLista(&pGrafo->pOrigens, NULL, CompararVerticeENome);
	LIS_CriarLista(&pGrafo->pVertices, DestruirVertice, CompararVerticeENome);

	*ppGrafo = (GRA_tppGrafo) pGrafo;

	return GRA_CondRetOK;
}
Beispiel #30
0
int THR_Create(Thread **thr, void (*fp)(void *), void *arg)
{
	(*thr) = (Thread*)MEM_Alloc(sizeof(Thread));
	if(!(*thr))
		return -1;

	(*thr)->fp = fp;
	(*thr)->arg = arg;
	(*thr)->handle = (HANDLE)_beginthreadex(NULL, 0, ThreadWrapper, (*thr), 0, NULL);
	if((*thr)->handle == NULL){
		LOG_ERROR("THR_Create: Failed to create thread! (%d)", errno);
		return -1;
	}

	return 0;
}