ut_umem.c File Reference


Detailed Description

Store variable-length-records in memory: reserve/connect/release .. UME_.

=====================================================
Liste_Funktionen_Beginn:

UME_init              init Memspc.
UME_EMPTY             preload empty Memspc.

UME_reserve           get memSpacePos & reserve space
UME_connect           get actual memSpacePosition = get memSpace  INLINE
UME_release           release memSpace  INLINE
UME_add               den next-Pointer korrigieren (Obj. manuell gespeichert)
UME_reset             verkleinern Memspc
UME_save              save Obj -> Memspc

UME_ck_add            den next-Pointer korrigieren; no message
UME_reall_save        save and reallocate if necessary
UME_reall_add         add and reallocate if necessary
UME_del               Datenbereich (u Pointer) loeschen

UME_ck_free           return free space
UME_set_free          correct free space
UME_ck_tot            report total space
UME_dump              display free space

UME_malloc
UME_malloc_CB         malloc and set callback
UME_realloc
UME_free

UME_alloc_tmp         allocate mem for active function (temp.space)

Liste_Funktionen_Ende:
=====================================================

- see also:
../doc/gCAD3D_prog_de.txt section Memoryfunktionen

- usage examples:

  char     memspc51[50000];
  Memspc   memSeg1;
  int      *iTab;

  UME_init (&memSeg1, memspc51, sizeof(memspc51));
  UME_connect (iTab, memSeg1);            // give space to iTab
  iSiz = UME_ck_free (&memSeg1);          // query free size in bytes
  UME_add (&memSeg1, iNr * sizeof(int));  // reserve spc for iNr long's
  ...                                     // (increments memSeg1.next !)
  UME_release (iTab, memSeg1);            // reset memSeg1

--------------------------
  oder:
  iTab = UME_reserve (&memSeg1, 100 * sizeof(int));   // get spc for 100 int's

#include "../xa/MS_Def0.h"
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "../ut/ut_geo.h"
#include "../ut/ut_TX.h"
#include "../ut/ut_umem.h"

Functions

int UME_realloc (long *spcOff, Memspc *memSpc, long newSiz)
int UME_malloc (Memspc *memSpc, long spcSiz, long memInc)
int UME_free (Memspc *memSpc)
int UME_init (Memspc *memSpc, void *objDat, int osiz)
int UME_reset (Memspc *memSpc, void *newStart)
void * UME_reserve (Memspc *memSpc, int osiz)
int UME_add (Memspc *memSpc, int osiz)
int UME_ck_add (Memspc *memSpc, long addSiz)
int UME_reall_add (long *spcOff, Memspc *memSpc, long addSiz)
int UME_reall_save (long *spcOff, Memspc *memSpc, void *objDat, int osiz)
void * UME_save (Memspc *memSpc, void *objDat, int osiz)
int UME_ck_free (Memspc *memSpc)
int UME_ck_tot (Memspc *memSpc)
int UME_set_free (int sizFree, Memspc *memSpc)
int UME_dump (Memspc *memSpc, char *txt)
int UME_del (Memspc *memSpc, void *nach, void *von,...)


Function Documentation

int UME_realloc ( long *  spcOff,
Memspc memSpc,
long  newSiz 
)

    memspc vergroessern; die Pointer start, next und end korrigieren.
    Input:
      newSiz   is new total size of memSpc
    Output:
      spcOff   distance from active memSpc->start to new memSpc->start

int UME_malloc ( Memspc memSpc,
long  spcSiz,
long  memInc 
)

    malloc <spcSiz> bytes and provide it in memSpc.
    Call UME_malloc only once!
    Memspace must be freed with UME_free
    Input:
      spcSiz  malloc this size
      memInc  if reallocate: increase <memInc> bytes
    Output:
      RetCode 0=OK; -1=outOfMemory-Error.
    
    Example:
    Memspc tmpSpc=UME_EMPTY;
    UME_malloc (&tmpSpc, 100 *sizeof(int), 50 *sizeof(int));
    ...
    UME_free (&tmpSpc);

int UME_free ( Memspc memSpc  ) 

    das komplette memseg mit free im OS freigeben !
    auch:
      free (memSpc->start);

int UME_init ( Memspc memSpc,
void *  objDat,
int  osiz 
)

    UME_init              init Memspc
    
    puts memSpc as first Record into objDat; gives back its Adress.
    
      Examples:
    char     memspc51[50000];
    Memspc   memSeg1;
    int      *iTab, sizTab;
    // attach memspc51
    UME_init (&memSeg1, memspc51, sizeof(memspc51));
    
    // give whole space to iTab; do not fix memspc.next
    UME_connect (iTab, &memSeg1);
    // set max size for iTab
    sizTab = UME_ck_free (&memSeg1) / sizeof(int);
    
    // reserve 100 int's in memSeg1; update memspc.next.
    iTab = UME_reserve (&memSeg1, 100 * sizeof(int));
    // give the remaining space to (char*)cbuf
    UME_connect (cbuf, memSeg1);
    // query size of cbuf
    cbufSiz = UME_ck_free (memSeg1);
    
    see also ../doc/gCAD3D_prog_de.txt section Memoryfunktionen

int UME_reset ( Memspc memSpc,
void *  newStart 
)

UME_reset verkleinern Memspc

void* UME_reserve ( Memspc memSpc,
int  osiz 
)

    UME_reserve           get memSpacePos & reserve space
      does UME_connect (returns memspace) & UME_add (modify memspc.next)
    RetCode: the address (starting-Position) of the memSpace;
      NULL if EOM (not enough memspace)

int UME_add ( Memspc memSpc,
int  osiz 
)

    UME_add               den next-Pointer korrigieren (Obj. manuell speichern)
    
    RetCod 0=OK, -1=OutOfSpace
    
    Platz reservieren; wird nachfolgend NICHT mit UME_save belegt.
    
    Achtung Reihenfolge:
    
    1) den Pointer merken
      Point  *pTab;
      pTab = (Point*)memSeg1->next;
    
    2) den Platz reservieren (aendert den Pointer memSeg1->next)
      i1 = UME_add (memSeg1, sizeof(Point) * ptNr);
      if(i1 < 0) goto L_eom;  // Test ob genug Platz im memSeg
    
    3) den Platz belegen
      memcpy (pTab, pta, sizeof(Point) * ptNr);

int UME_ck_add ( Memspc memSpc,
long  addSiz 
)

    UME_ck_add            den next-Pointer korrigieren; no message
    retCod -1:   zu wenig mem

int UME_reall_add ( long *  spcOff,
Memspc memSpc,
long  addSiz 
)

    add = allocate Space for <addSiz> bytes; reallocate if necessary.
    next-Pointer is incremented <addSiz> bytes
    Input:
      addSiz   occupy <addSiz> bytes in memSpc
                0: must increase memSpc
    Output:
      spcOff   displacement-offset; 0: no reallocate.
      RetCode  0=OK; -1=outOfMemory-Error.

int UME_reall_save ( long *  spcOff,
Memspc memSpc,
void *  objDat,
int  osiz 
)

    UME_reall_save              save Obj -> Memspc
    next-Pointer is incremented <addSiz> bytes and
    <osiz> bytes from position <objDat> are saved into memSpc.
    Input:
      oSiz     nr of bytes to save
      objDat   date to be saved in memSpc
    Output:
      spcOff   displacement-offset; 0: no reallocate.
      RetCode  0=OK; -1=outOfMemory-Error.

void* UME_save ( Memspc memSpc,
void *  objDat,
int  osiz 
)

    UME_save              save Obj -> Memspc
    RetCode: the address (starting-Position) of the memSpace;
      NULL if EOM

int UME_ck_free ( Memspc memSpc  ) 

UME_ck_free return free space

int UME_ck_tot ( Memspc memSpc  ) 

UME_ck_tot report total space

int UME_set_free ( int  sizFree,
Memspc memSpc 
)

    UME_set_free          correct free space
    
    usage:
    sSiz = UME_ck_free (wrkSpc);
    .. remove some free space - reduce sSiz
    UME_set_free (sSiz, wrkSpc);    // correct free space

int UME_dump ( Memspc memSpc,
char *  txt 
)

UME_dump display free space

int UME_del ( Memspc memSpc,
void *  nach,
void *  von,
  ... 
)

    Datenbereich (u Pointer) loeschen (nach links verschieben);
      "nach" muss also kleiner als "von" sein !!


Generated on Sat May 30 09:31:56 2009 for gCAD3D by  doxygen 1.5.6