ut_mem.c File Reference


Detailed Description

memory: swap/insert/invert records MEM_

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

MEM_swap_int              2 int vertauschen
MEM_swap_2db              2 doubles vertauschen  INLINE
MEM_swap_2vp              swap 2 pointers        INLINE
MEM_swap_2bit             swap 2 bits
MEM_swap__                2 structs vertauschen

MEM_ins_rec               insert data into mem
MEM_ins_IndRec            insert one integer into intArray
MEM_ins_nrec              insert dataRecord(s) into table
MEM_chg_rec               change a record in mem (change line; delete+insert)
MEM_del_IndRec            delete 1 integer from intArray
MEM_del_DbRec             delete 1 double in double-Array
MEM_del_nrec              delete <delRecNr> records from table
MEM_inv_itab              invert table of intData; 1/2/3 --> 3/2/1
MEM_inv_dtab              invert table of dbData; 1/2/3 --> 3/2/1
MEM_inv_rtab              invert table of dataRecords; 1/2/3 --> 3/2/1

MEM_copy_tab              copy <recNr> records of size <sizRec>

MEM_wri_spc               write n chars from mem -> file

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

- see also:
UTX_memstr
UTX_memFind
UTX_memFind1
memchr
memcmp
memccpy
memcpy
memmove
memset
UTA_reallTab

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

Functions

int MEM_wri_spc (char *fnam, char *data, long cNr)
int MEM_swap__ (void *stru1, void *stru2, long strSiz)
int MEM_swap_2bit (int *ii, int ib1, int ib2)
int MEM_ins_IndRec (int *iTab, int *recNr, int recPos, int reVal)
int MEM_ins_rec (void *insPos, long movSiz, void *insDat, long insSiz)
int MEM_ins_nrec (int *recNr, void *recTab, int ipos, void *insDat, int insRecNr, int sizRec)
int MEM_chg_rec (void *datStart, long *datSiz, void *insDat, long insSiz, void *delPos, long delSiz)
int MEM_del_IndRec (int *recNr, void *recTab, int ipos)
int MEM_del_DbRec (int *recNr, void *recTab, int ipos)
int MEM_del_nrec (int *recNr, void *recTab, int ipos, int delRecNr, int sizRec)
int MEM_inv_itab (int recNr, int *recTab)
int MEM_inv_dtab (int recNr, double *recTab)
int MEM_inv_rtab (int recNr, void *recTab, int sizRec)
int MEM_copy_tab (void *tabo, void *tabi, int recNr, int sizRec)


Function Documentation

int MEM_wri_spc ( char *  fnam,
char *  data,
long  cNr 
)

MEM_wri_spc write n chars from mem -> file

int MEM_swap__ ( void *  stru1,
void *  stru2,
long  strSiz 
)

    MEM_swap__              2 structs vertauschen
    
    MEM_swap__(&p1, &p2, sizeof(Point));

int MEM_swap_2bit ( int *  ii,
int  ib1,
int  ib2 
)

ib muessen Values sein (1, 2, 4, 8 usw.)

int MEM_ins_IndRec ( int *  iTab,
int *  recNr,
int  recPos,
int  reVal 
)

    insert one new record into indexTable at position recPos.
    Beispiel:
      In:   recNr=3; iTab=0,1,2; recPos=0; reVal=3;
      Out:  recNr=4; Tab=3,0,1,2;

int MEM_ins_rec ( void *  insPos,
long  movSiz,
void *  insDat,
long  insSiz 
)

    MEM_ins_rec          insert data into mem
    
    insDat data to insert
    insSiz size of insDat
    insPos where to insert
    movSiz hom much bytes to move from insPos to insPos+insSiz

int MEM_ins_nrec ( int *  recNr,
void *  recTab,
int  ipos,
void *  insDat,
int  insRecNr,
int  sizRec 
)

    insert records into table.
    insert data BEFORE Record with index ipos.
    insert dataBlock insDat BEFORE dataRecord Nr ipos into Table recTab
    recTab consists of *recNr records of size sizRec
    
    Input/Output:
    *recNr   nr of records of table recTab;
             after exit recNr += insRecNr
    recTab   table with *recNr records; each with a size of sizRec bytes.
             after exit record nr ipos is the firsdt record of insDat ..
    
    Input:
    ipos     index in recTab of the first inserted record of insDat
    insDat   data to insert; size = sizRec * insRecNr
    insRecNr nr of records to insert
    sizRec   size of records (of recTab and insDat)
    
    Example insert 1 point p31 into 3. position (index nr 2) of pTab:
    MEM_ins_nrec (&recNr, pTab, 2, &p31, 1, sizeof(Point));

int MEM_chg_rec ( void *  datStart,
long *  datSiz,
void *  insDat,
long  insSiz,
void *  delPos,
long  delSiz 
)

    MEM_chg_rec          change a record in mem (change line)
    
    Input:
      datStart     Startposition des Datenblock
      datSiz       Size Datenblock (zB ex strlen)
      insDat       data to insert (len = insSiz)
      insSiz       size of insDat
      delPos       Position of old record (delete) and new record (insert)
      delSiz       how much bytes to delete at Pos delPos
    Output:
      datSiz  wird korrigiert
    
    
     strcpy(cbuf, "1234567890");   l1 = strlen(cbuf);
     MEM_chg_rec (cbuf, &l1, "AAA", 3, &cbuf[4], 1); // 5 -> AAA
    
    strcpy(cbuf, "1234567890");   l1 = strlen(cbuf);
    MEM_chg_rec (cbuf, &l1, "A", 1, &cbuf[4], 3);   // 567 -> A

int MEM_del_IndRec ( int *  recNr,
void *  recTab,
int  ipos 
)

    MEM_del_IndRec          delete 1 integer in intArray
    recNr  is decremented

int MEM_del_DbRec ( int *  recNr,
void *  recTab,
int  ipos 
)

    MEM_del_DbRec          delete 1 double in double-Array
    recNr  is decremented

int MEM_del_nrec ( int *  recNr,
void *  recTab,
int  ipos,
int  delRecNr,
int  sizRec 
)

    delete <delRecNr> records from table.
    first Record to delete has index ipos.
    recTab consists of *recNr records of size sizRec
    
    Input/Output:
    *recNr   nr of records of table recTab;
             after exit recNr -= delRecNr
    recTab   table with *recNr records; each with a size of sizRec bytes.
    
    Input:
    ipos     index in recTab of the first record to delete ..
    delRecNr nr of records to delete
    sizRec   size of records of recTab
    
    Example delete the 3. point (index nr 2) out of pTab:
    MEM_del_nrec (&pNr, pTab, 2, 1, sizeof(Point));

int MEM_inv_itab ( int  recNr,
int *  recTab 
)

MEM_inv_itab invert table of intData; 1/2/3 --> 3/2/1

int MEM_inv_dtab ( int  recNr,
double *  recTab 
)

MEM_inv_dtab invert table of dbData; 1/2/3 --> 3/2/1

int MEM_inv_rtab ( int  recNr,
void *  recTab,
int  sizRec 
)

MEM_inv_rtab invert table of dataRecords; 1/2/3 --> 3/2/1

int MEM_copy_tab ( void *  tabo,
void *  tabi,
int  recNr,
int  sizRec 
)

MEM_copy_tab copy <recNr> records of size <sizRec>


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