libgeneralist

So, /prog/, I'm writing a general library in C, with the aim of being somewhat inspired by libraries such as glib, but far lighter and cleaner. So far, I have a linked list implementation and a Unicode string implementation (this is incomplete), totalling 670 SLOC. The build system is cmake, the code is fully documented with doxygen. Of course, the library is in its infancy and far from finished; what other things should I implement? Any data structures? OS abstractions?

...Just for you >>n64
//-------------

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//-----------------------------

const char cBlock[30] ={"!abcdefghijklmnopqrstuvwxyz?"};

struct s_chNode{int ID, Index, PreVal, Value, Branch, Leaf;};

struct s_chNode *Blinks, *blink;

int iBlinkmax=0, iBlinks=0;

//-----------------------------

void initBlink(){
Blinks = (struct s_chNode *)malloc(sizeof(struct s_chNode));
}

//------------------------------

void incBlink(){
blink = realloc(Blinks,((iBlinkmax+=10)+2)* sizeof(struct s_chNode));
if (blink!=NULL) Blinks = blink;
}

//------------------

int BlinkScan(int BPreV, int BVal){
int iB, iHalt=-1;
for(iB=0;iB<iBlinks;iB++){
    if(Blinks[iB].Value == BVal)
        if(Blinks[iB].PreVal == BPreV) return iB;
    }
return -1;
}

//-----------------------
   
int BlinkEntry(int iD, int PreVal, int Val){
int iB=0;
iB = BlinkScan(PreVal, Val);
  if (iB!=-1) return iB;
if(iBlinkmax<=iD) incBlink();
Blinks[iD].ID = iD;
Blinks[iD].Index = 0;
Blinks[iD].PreVal = PreVal;
Blinks[iD].Value = Val;
Blinks[iD].Branch = 0;
Blinks[iD].Leaf = 0;
iBlinks++;
//printf("added %i", iBoards-1);
return iD;
}

//------------------

int AutoBlinkScan(int BPreV, int BVal){
int iB, iHalt=-1, BVMin = BVal;
for(iB=0;iB<iBlinks;iB++){
    if(Blinks[iB].PreVal == BPreV)
        if(Blinks[iB].Value <= BVMin){
            iHalt = iB;
            BVMin = Blinks[iB].Value;
            }
    }
return iHalt;
}

//----------------------------------

void BlinkSort(int Zion){
int i, ii, iZ, Zi, bspv, bsnv;
Zi=Zion;
bspv = Blinks[Zi].PreVal;
bsnv = Blinks[Zi].Value;
for(i=1;i<27;i++){
    iZ = BlinkScan(bspv, i);
    ii = AutoBlinkScan(i, 0);
    if(iZ!=-1){
        Blinks[Zi].Branch = iZ;
        Blinks[iZ].Leaf = ii;
        printf("%i - %i / %i\n", Zi, iZ, ii);
        Zi = iZ;
        }   
    }
}

//-----------------------------------

int GetLeaf(int ZionII){
int Zi;
Zi=ZionII;
while((Blinks[Zi].Leaf==0)+(Blinks[Zi].Branch!=0)==2){
    Zi = Blinks[Zi].Branch;
    }
return Zi;
}

//---------------------------

int scanChar(int cX){
  int Geti=0;
  while(Geti<=27){
    if((int) cBlock[Geti]==cX) return Geti;
    Geti++;
    }
  return 0;
}

//------------------------------

int main(int argc, char *argv[]){
  char  myStr[1000];
  int i=0, j=1, k=0, l=0, m=0, loopi=0, li=0;

  initBlink();
  BlinkEntry(iBlinks, 0, 0);

  if(argc>=1){
    loopi = strlen(argv[1]);
    for(li=0;li<loopi;li++){
        myStr[li] = argv[1][li];
        }
    } else {
    loopi=10;
    scanf("%10s", myStr);
    }
  while(((int) j!=0)+(i<loopi)==2){
    j= (int) myStr[i];
    printf("-%c -", j);
    k=scanChar(j);
    m=BlinkEntry(iBlinks, l, k);
    printf("%c-%c-%i-%i\n", cBlock[l], cBlock[k], m, i);
    l=k;
    i++;
    }
  BlinkSort(0);
  printf("\n");
  li=GetLeaf(0);
  while(Blinks[li].Branch>0){
    if(Blinks[li].Leaf>0){
        printf("\nli %i, leaf %i\n", li, Blinks[li].Leaf);
        BlinkSort(Blinks[li].Leaf);
        }
    if(Blinks[li].Branch>0) {
        li=GetLeaf(Blinks[li].Branch);
        }
    }
  printf("leaf %i\n", li);

  if(Blinks[li].Leaf>0){
    printf("\nli %i, leaf %i\n", li, Blinks[li].Leaf);
    BlinkSort(Blinks[li].Leaf);
    }

  /*BlinkSort(6);
  printf("\n");
  BlinkSort(17);
  printf("\n");
  BlinkSort(44);
  printf("\n");
  BlinkSort(33);
  printf("\n");
*/
  return 0;
}

//--------------