FDL 함수

#include <fbuf.h>
#include <atmi.h>
FBUF *fballoc(int count, FLDLEN datalen)

#include <fbuf.h>
#include <atmi.h>
...
FBUF *fbuf;
if ((fbuf = fballoc(100, 1000)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
/* result allocated size : 1408 bytes */

...
FBUF *fbuf;
if ((fbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
/* result allocated size : 1024 bytes */

#include <fbuf.h>
#include <atmi.h>
int fbbufop(FBUF *dest, FBUF *src, int mode)

#include "demo_fdl.h"
...
main()
{
    FBUF *destbuf, *srcbuf;
    ...
    destbuf=fballoc(5,5);
    ...
    fbput(destbuf, INPUT, "5555", 0);
    fbput(destbuf, INPUT, "7777", 0);
    fbput(destbuf, OUTPUT, "3333", 0);
    fbput(destbuf, SEQNO, "8888", 0);

    srcbuf=fballoc(5,5);
    ...
    fbput(srcbuf, INPUT, "1111", 0);
    fbput(srcbuf, OUTPUT, "2222", 0);
    fbput(srcbuf, CORPNO, "3333", 0);

    /* Mode를 select할 수 있게 한다. */
    ...
    printf("input : ");
    scanf("%d", &a);

    switch(a)
    {
        /*FBMOVE mode */
        case 1:
            iRet=fbbufop(destbuf, srcbuf, FBMOVE);
            ...

            fbprint(destbuf);
            break;
        /* destbuf : “1111”, “2222”, “3333”*/

        /*FBCOMP mode */
        case 2:
            iRet=fbbufop(destbuf, srcbuf, FBCOMP);
            printf("ret = %d\n", iRet);
            if(iRet < 0) {
               printf("Do not match!!!\n");
               fbfree(destbuf);
               fbfree(srcbuf);
               exit(0);
            }
            printf("Match!!!\n");
            break;
        /* “Do not match!!! */

        /*FBCOPY mode */
        case 3:
            iRet=fbbufop(destbuf, srcbuf, FBCOPY);
            ...
            fbprint(destbuf);
            break;
        /* destbuf : “1111”, “2222”, “3333”*/

        /*FBCONCAT mode */
        case 4:
            iRet=fbbufop(destbuf, srcbuf, FBCONCAT);
            ...
            fbprint(destbuf);
            break;
        /* destbuf : “5555”, “7777”, “3333”, “8888”, “1111”, “2222”, “3333”*/

        /*FBJOIN mode */
        case 5:
           iRet=fbbufop(destbuf, srcbuf, FBJOIN);
           ...
           fbprint(destbuf);
           break;
        /* destbuf : “1111”, “2222”*/

        /*FBOJOIN mode */
        case 6:
           iRet=fbbufop(destbuf, srcbuf, FBOJOIN);
           ...
           fbprint(destbuf);
           break;
        /*  destbuf : “1111”, “7777”, “2222”, “8888”*/

        /*FBUPDATE mode */
        case 7:
           iRet=fbbufop(destbuf, srcbuf, FBUPDATE);
            ...
           fbprint(destbuf);
           break;
        /* destbuf : “1111”, “7777”, “2222”, “8888”, “3333”*/

    }
    fbfree(destbuf);
    fbfree(srcbuf);
}

#include <fbuf.h>
#include <atmi.h>
int fbbufop_proj(FBUF *dest, FBUF *src, FLDKEY *fldkey)

#include “demo_fdl.h”
...

int iRet, i;
FBUF *destbuf, *srcbuf;
FLDKEY fkey[4];

...
fbput(destbuf, INPUT, "aaa", 0);
fbput(destbuf, OUTPUT, "bbb", 0);
fbput(destbuf, SEQNO, "ccc", 0);
...
fbput(srcbuf, TEST1, "AAA", 0);
fbput(srcbuf, TEST2, "BBB", 0);
fbput(srcbuf, TEST3, "CCC", 0);

fkey[0]=fbget_fldkey("INPUT");
fkey[1]=fbget_fldkey("SEQNO");
fkey[2]=0; /* The last entry in the array must be 0 */

ret=fbbufop_proj(destbuf, NULL, fkey);
...
/* destbuf : aaa, ccc */
...
fkey[0]=fbget_fldkey("TEST3");
fkey[1]=fbget_fldkey("TEST1");
fkey[2]=fbget_fldkey("TEST2");

fkey[3]=0; /* The last entry in the array must be 0 */

ret=fbbufop_proj(destbuf, srcbuf, fkey);
...
/* destbuf : AAA, BBB, CCC */
/* fkey array is sorted if the entries are not in numeric order */
...

#include <fbuf.h>
#include <atmi.h>
long fbcalcsize(int count, FLDLEN datalen)

#include “demo_fdl.h”
...

FBUF *fbuf;
long size;

size = fbcalcsize(100, 1000);
printf(“size : [%ld]\n”, size); /* output : size : [1408] */
if ((fbuf = (FBUF *)tpalloc(“FIELD”, NULL, size)) == NULL) {
    printf(“tpalloc failed, errno = %d\n”, tperrno);
    ...
}

/* fbuf is set in 1024 bytes by default if size is less than 1024*/
...

#include <fbuf.h>
#include <atmi.h>
int fbchg_tu(FBUF *fbuf, FLDKEY fldkey, int nth, char *value, FLDLEN fldlen)

#include “demo_fdl.h”
...
long rcvlen, ret;
char buffer[100];
FLDLEN fldlen;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, tperrno);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);  /* 영 번째 순번에는 aaaa가 있음. */
ret = fbchg_tu(fbuf, INPUT, 1, “bbbb ”, 4);   /* 첫 번째 순번에 bbbb를 추가함. */
if (ret < 0) {
    error processing...
}
ret = fbget_tu(fbuf, INPUT, 1, buffer, &fldlen);
/* 첫 번째 순번에 있는 데이터를 buffer에 넣음. */
if (ret < 0) {
    error processing...
}
printf(“Field Data: [%s]\n”, buffer);
/* output : Field Data: [bbbb] */

fbprint(fbuf);
/* output : aaaa, bbbb   */
...

#include <fbuf.h>
#include <atmi.h>
int fbchg_tut(FBUF *fbuf, FLDKEY fldkey, int nth, char *value, FLDLEN fldlen,
              int type)

#include “demo_fdl.h”
...
long ret, lVal=100000;
FBUF *fbuf;
...
fbputt(fbuf, INPUT, "aaaa", 0, FB_STRING);
fbchg_tut(fbuf, INPUT, 0, (char *)&lVal, 0, FB_LONG);
printf("1st occurrence of INPUT field is changed as follows : \n");
fbprint(fbuf);
...
/* fkey = 469762149, fname = INPUT, type = string, value = 100000 */

#include <fbuf.h>
#include <atmi.h>
int fbdelall(FBUF *fbuf, FLDKEY fldkey)

#include “demo_fdl.h”
...
int ret;
FBUF *fbuf;
if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, “cccc”, 0);

ret = fbdelall(fbuf, INPUT);
printf(“Delete Field Number: [%d]\n”, ret);
/* output: Delete Field Number: [3] */
...

#include <fbuf.h>
#include <atmi.h>
int fbdelall_tu(FBUF *fbuf, FLDKEY *fldkey)

#include “demo_fdl.h”
...
FLDKEY fkey[3];

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, OUTPUT, “cccc”, 0);

fkey[0] = INPUT;
fkey[1] = OUTPUT;
fkey[2] = 0; /* The last entry in the array must be 0 */

ret = fbdelall_tu(fbuf, fkey);
printf(“The Number of deleted fields: [%d]\n”, ret);

/* output: Number of deleted fields: [3] */
...

#include <fbuf.h>
#include <atmi.h>
int fbdelete(FBUF *fbuf, FLDKEY fldkey, int nth)

#include “demo_fdl.h”
...
char buffer[100];
int ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);  /* fbuf의 0번째 데이터는 “aaaa”이다. */
fbput(fbuf, INPUT, “bbbb”, 0);  /* fbuf의 1번째 데이터는 “bbbb”이다. */
fbput(fbuf, INPUT, “cccc”, 0);  /* fbuf의 2번째 데이터는 “cccc”이다. */
fbdelete(fbuf, INPUT, 1);         /* fbuf의 1번째 데이터인 “bbbb”를 삭제한다. */

ret=fbdelete(fbuf, INPUT, 3);
if(ret<0){
     printf("fbdelete error : %s\n", fbstrerror(fberror));
}                                 /* fbuf의 3번째 순번에는 데이터가 없기 때문에
fbdelete error : FBENOENT (not found) 가 출력된다. */

fbget(fbuf, INPUT, buffer, 0);
printf(“INPUT: [%s]\n”, buffer);   /* output:  INPUT: [aaaa] */
fbget(fbuf, INPUT, buffer, 0);
printf(“INPUT: [%s]\n”, buffer);   /* output:  INPUT: [cccc] */
...

#include <fbuf.h>
#include <atmi.h>
int fbfldcount(FBUF *fbuf)

#include “demo_fdl.h”
...

int cnt;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, OUTPUT, “cccc”, 0);
cnt = fbfldcount(fbuf);
printf(“Field Count: [%d]\n”, cnt);

/* output: Field Count: [3] */
...
}

#include <fbuf.h>
#include <atmi.h>
int fbfprint(FBUF *fbuf, FILE *iop)

#include “demo_fdl.h”
...
FILE *iop;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

iop = fopen(“sample.text”, “w”);
fbput(fbuf, INPUT, “5555”, 0);
fbput(fbuf, INPUT, “7777”, 0);
fbfprint(fbuf, iop);
fclose(iop);

#include <fbuf.h>
#include <atmi.h>
int fbfree(FBUF *fbuf)

#include “demo_fdl.h”
...
int ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “aaaa”, 0);
ret = fbfree(fbuf);
printf(“fbfree, ret = %d\n”, ret);
/* output : fbfree, ret = 1 */
fbput(fbuf, INPUT, “bbbb”, 0);
fbprint(fbuf);
/* an error occurs since memory was not allocated. */

#include <fbuf.h>
#include <atmi.h>
int fbftos(FBUF *fbuf, char *cstruct, char *stname)

#include “demo_fdl.h”
#include “demo_sdl.h”
...
int ret, fdllen, val = 1000;
struct demo temp;
FBUF *fbuf;
Char *cstruct;

if(tpstart((TPSTART_T *)NULL) == -1) {
    printf(“tpstart failed\n”);
    ...
}

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

cstruct = (char *)&temp;
if(fbstinit((char *)&temp, “demo”) < 1)  {
    printf(“fbstinit failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INTDATA, (char *)&val, 0);

if(fbftos(fbuf, cstruct, “demo”) < 0) {
    ...
}
...

VIEW demo
#type      cname      Fldkey      count      flag      size      null
string   demodata     INPUT          5        -         20       “”
carray  carraydata    CARRAYDATA     1        -         20     “star”
char    chardata      CHARDATA       1        -         -       “c”
int       inum        INTDATA        5        -         -         0
short     snum        SHORTDATA      1        -         -         0
long      lnum        LONGDATA       1        -         -         1
float     fnum        FLOATDATA      1        -         -        1.0
double    dnum        DOUBLEDATA     1        -         -        1.0
END

$TMAXDIR$/sample/sdl> sdlc –c –v demo.s –o tmax.sdl
$TMAXDIR$/sample/sdl> sdlc –c –v demo.v –o tmax.sdl

$TMAXDIR$/sample/sdl> sdlc –v demo.s

#include <fbuf.h>
#include <atmi.h>
int fbget(FBUF *fbuf, FLDKEY fldkey, char *loc, FLDLEN *fldlen)

#include “demo_fdl.h”
...
long rcvlen, ret;
FLDLEN fldlen;
char buffer[100];
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, “cccc”, 0);

fbget(fbuf, INPUT, buffer, &fldlen);
printf(“Field Data: [%s]\n”, buffer);
/* output: Field Data: [aaaa] */
...

#include <fbuf.h>
#include <atmi.h>
char *fbgetalloc_tu(FBUF *fbuf, FLDKEY fldkey, int nth, int *extralen)

#include “demo_fdl.h”
...
long ret;
int extralen;
char *buffer;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, “cccc”, 0);

extralen = 4;
buffer = fbgetalloc_tu(fbuf, INPUT, 0, &extralen);
printf(“Field Data: [%s]\n”, buffer);
/* output: Field Data: [aaaa], returned after adding 4 bytes to
the length of the field value. */
fbfree(fbuf);
...

#include <fbuf.h>
#include <atmi.h>
char *fbgetalloc_tut(FBUF *fbuf, FLDKEY fldkey, int nth, int type, int *extralen)

#include “demo_fdl.h”
...
long ret;
int extralen;
char *buffer;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, “cccc”, 0);

extralen = 4;
buffer = fbgetalloc_tut(fbuf, INPUT, 0, FB_STRING, &extralen);
printf(“Field Data: [%s]\n”, buffer);
/* output: Field Data: [aaaa], returned after adding 4 bytes to the length of the
field value. */

fbfree(fbuf);
...

#include <fbuf.h>
#include <atmi.h>
long fbget_fbsize(FBUF *fbuf)

#include “demo_fdl.h”
...
long ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “1111”, 0);
ret = fbget_fbsize(fbuf ) ;
printf(“Field Buffer Size: [%ld]\n”, ret);
/* output: Field Buffer Size: [1024] */
...

#include <fbuf.h>
#include <atmi.h>
FLDKEY fbget_fldkey(char *name)

#include “demo_fdl.h”
...
FLDKEY fkey;
FBUF *sndbuf;

fkey = fbget_fldkey(“INPUT”);
printf(“Field Key : [%d]\n”, fkey);

/* output : Field Key : [469762149] */
...
fbput(sndbuf, fkey, “1111", 0);
...

#include <fbuf.h>
#include <atmi.h>
char *fbget_fldname(FLDKEY fldkey)

#include “demo_fdl.h”
...
FLDKEY fkey;
char *name;

fkey = fbget_fldkey(“INPUT”);
printf(“Field Key : [%d]\n”, fkey);
/* output : Field Key : [469762149] */

name = fbget_fldname(fkey);
printf(“Field Name : [%s]\n”, name);
/* output : Field Name : [INPUT] */
...

#include <fbuf.h>
#include <atmi.h>
int fbget_fldno(FLDKEY fldkey)

#include “demo_fdl.h”
...
long ret;
FLDKEY len;
int nth;
char buffer[100];
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, “cccc”, 0);

fbgetlast_tu(fbuf, INPUT, &nth, buffer, &len);
printf(“Field Data: [%s], occurrence = %d, len = %d\n”, buffer, nth, len);
/* output: Field Data: [cccc], occurrence = 2, len = 4 */
...

#include <fbuf.h>
#include <atmi.h>
int fbget_fldtype(FLDKEY fldkey)

#include “demo_fdl.h”
...
FLDKEY fkey;
int type;

fkey = fbget_fldkey(“INPUT”);
printf(“Field Key : [%d]\n”, fkey);/* output: Field Key : [469762149] */
type = fbget_fldtype(fkey);
printf(“Field Type : [%d]\n”, type);/* output : Field Type : [7] */
...

#include <fbuf.h>
#include <atmi.h>
int fbgetlast_tu(FBUF *fbuf, FLDKEY fldkey, int *nth, char *loc, int *len)

#include “demo_fdl.h”
...
long ret;
FLDKEY len;
int nth;
char buffer[100];
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, “cccc”, 0);

fbgetlast_tu(fbuf, INPUT, &nth, buffer, &len);
printf(“Field Data: [%s], occurrence = %d, len = %d\n”, buffer, nth, len);
/* output: Field Data: [cccc], occurrence = 2, len = 4 */
...

#include <fbuf.h>
#include <atmi.h>
char *fbget_strfldtype(FLDKEY fldkey)

#include “demo_fdl.h”
...
FLDKEY fkey;
char *stype;
...
fkey = fbget_fldkey(“INPUT”);
printf(“Field Key : [%d]\n”, fkey);
/* output : Field Key : [469762149] */

stype = fbget_strfldtype(fkey);
printf(“Field Type : [%s]\n”, stype);
/* output : Field type : [string] */

#include <fbuf.h>
#include <atmi.h>
int fbget_tu(FBUF *fbuf, FLDKEY fldkey, int nth, char *value, FLDLEN *len)

#include “demo_fdl.h”
...
char buffer[100];
long rcvlen;
FLDLEN fldlen;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, OUTPUT, “cccc”, 0);

fbget_tu(fbuf, INPUT, 1, buffer, &fldlen);
printf(“Data: [%s]\n”, buffer) /* output: Data: [bbbb] */
...

#include <fbuf.h>
#include <atmi.h>
int fbget_tut(FBUF *fbuf, FLDKEY fldkey, int nth, char *value, FLDLEN *len,
              int type)

#include “demo_fdl.h”
...
FBUF *fbuf;
int ret, val=65;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbputt(fbuf, INPUT,  (char *)&val, 0, FB_INT);
fbputt(fbuf, INTDATA, "1111", 0, FB_STRING);
fbprint(fbuf);

fbget_tut(fbuf, INTDATA, 0, (char *)&ret, &fldlen, FB_INT);
printf("Field Data: [%d]\n", ret);
/* output: Field Data: [1111] */
...

#include <fbuf.h>
#include <atmi.h>
long fbget_unused(FBUF *fbuf)

#include “demo_fdl.h”
...
long ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “1111”, 0);
ret = fbget_unused (fbuf);
printf(“Unused Buffer Size: [%d]\n”, ret);

/* output: Unused Buffer Size: [1000] */
...

#include <fbuf.h>
#include <atmi.h>
long fbget_used(FBUF *fbuf)

#include “demo_fdl.h”
...
long ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “1111”, 0);
ret = fbget_used(fbuf);
printf(“Used Buffer Size: [%d]\n”, ret);

/* output: Used Buffer Size: [24] */
...

#include <fbuf.h>
#include <atmi.h>
int fbgetf(FBUF *fbuf, FLDKEY fldkey, char *loc, int *fldlen, int *pos)

#include “demo_fdl.h”
...
int ret, int0_pos, str0_pos, fldlen;
char str0[30];
FBUF *fbuf;

if ((fbuf = fballoc(20000, 1000000)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

int0_pos = str0_pos = 0;
while(1)
{
    ret = fbgetf(fbuf, STR0, (char *)str0, (int *)&fldlen, &str0_pos);
    if(ret < 0)
    {
        printf(“FBERROR at STR0:%d\n”, fberror);
        break;
     }
     ret = fbgetf(fbuf, INT0, (char *)&int0, (int *)&fldlen, &int0_pos);
     if(ret < 0)
     {
        ...
     }
     ...
}
...

#include <fbuf.h>
#include <atmi.h>
int fbgetlen(FBUF *fbuf, FLDKEY fldkey, int nth)

#include “demo_fdl.h”
...
int ret;
if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
if(fbgetlen(fbuf, INPUT, 1)  <  0)
{
      ...
}
...

#include <fbuf.h>
#include <atmi.h>
int fbgetnth(FBUF *fbuf, FLDKEY fldkey, char *value, FLDLEN fldlen)

#include “demo_fdl.h”
...
int occ;
FBUF *fbuf;
...
if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, “ddddd”, 0);
fbput(fbuf, INPUT, “eeeee”, 0);
fbput(fbuf, OUTPUT, “cccc”, 0);
occ = fbgetnth(fbuf, INPUT, “eeee”, 0);
printf(“Occurrence: [%d]\n”, occ); /* output: Occurrence: [3] */
...

#include <fbuf.h>
#include <atmi.h>
int fbgetntht(FBUF *fbuf, FLDKEY fldkey, char *value, FLDLEN fldlen, int fromtype)

#include “demo_fdl.h”
...
int occ, val;
FBUF *fbuf;
...
if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

val = 1111;
fbput(fbuf, INPUT,  "aaaa", 0);
fbput(fbuf, INPUT,  "dddd", 0);
fbput(fbuf, INPUT,  “1111”, 0);
fbput(fbuf, OUTPUT, "cccc", 0);

occ=fbgetntht(fbuf, INPUT, (char *)&val, 0, FB_INT);
printf("Occurrence: [%d]\n", occ); /* Occurrence: [2] */
...

#include <fbuf.h>
#include <atmi.h>
char *fbgetval(FBUF *fbuf, FLDKEY fldkey, int nth, FLDLEN *fldlen)

#include “demo_fdl.h”
...

char *ptr;
long rcvlen;
FLDLEN fldlen;
FBUF *fbuf;

fbuf = fballoc(10, 100);
...

fbput(fbuf, INPUT, "aaaa", 0);
fbput(fbuf, INPUT, "bbbb", 0);

ptr=fbgetval(fbuf, INPUT, 0, &fldlen);
printf("Data: [%s]\n", ptr);    /* output: Data: [aaaa] */
printf("len = %d\n", fldlen);   /* len = 4 */
...

#include <fbuf.h>
#include <atmi.h>
int fbgetvali (FBUF *fbuf, FLDKEY fldkey, int nth)

#include “demo_fdl.h ”
...

int cnt;
int vali;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

cnt=111;
fbput(fbuf, TOTMON, (char *)&cnt, 0);
fbput(fbuf, INPUT, "aaaa", 0);
vali=fbgetvali(fbuf, TOTMON, 0);
printf("Field Data: [%d]\n", vali);  /* output: Field Data: [111] */

vali = fbgetvali(fbuf, INPUT, 0);
printf("Field Data : [%d]\n", vali);  /* output: Field Data: [0] */

fbfree(fbuf);
...

#include <fbuf.h>
#include <atmi.h>
char *fbgetval_last_tu(FBUF *fbuf, FLDKEY fldkey, int *nth, FLDLEN *fldlen)

#include “demo_fdl.h”
...

char     *ptr;
long     rcvlen;
int      i,occ ;
FLDLEN   fldlen;
FBUF     *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, “ddddd”, 0);
fbput(fbuf, INPUT, “eeeee”, 0);
fbput(fbuf, OUTPUT, “cccc”, 0);

ptr = fbgetval_last_tu(fbuf, INPUT, &occ, &fldlen);
printf(“Data: [%s], Occurrence: [%d]\n”, ptr, occ);
/* output: Data: [eeeee], Occurrence: [3] */
for (i = 0; i < occ; i++) {
    ptr = fbgetval(fbuf, INPUT, i, &fldlen);
    printf(“Data: [%s]\n”, ptr);
}
...

#include <fbuf.h>
#include <atmi.h>
long fbgetvall_tu(FBUF *fbuf, FLDKEY fldkey, int nth)

#include “demo_fdl.h”
...
long lval;
short sval;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

sval = 111;
fbput(fbuf, INPUT, (char *)&sval, 0);
lval = fbgetvall_tu(fbuf, INPUT, 0);

printf(“Field Data: [%ld]\n”, lval); /* output: Field Data: [111] */
...

#include <fbuf.h>
#include <atmi.h>
char *fbgetvals (FBUF *fbuf, FLDKEY fldkey, int nth)

#include “demo_fdl.h”
...
char *ptr;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “aaaa”, 0);
ptr = fbgetvals(fbuf, INPUT, 0);
printf(“Field Data: [%s]\n”, ptr);
/* output: Field Data: [aaaa] */
...

#include <fbuf.h>
#include <atmi.h>
char *fbgetvals_tu(FBUF *fbuf, FLDKEY fldkey, int nth)

#include “demo_fdl.h”
...
char *ptr;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
ptr = fbgetvals_tu(fbuf, INPUT, 1);
printf(“Field Data: [%s]\n”, ptr); /* output: Field Data: [bbbb] */
...

#include <fbuf.h>
#include <atmi.h>
char *fbgetvalt(FBUF *fbuf, FLDKEY fldkey, int nth, FLDLEN *len, int totype)

#include “demo_fdl.h”
...

int *ptr;
long rcvlen;
FLDLEN fldlen;
FBUF *fbuf;
Int totype;
Int val = 111;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, (char *)&val, 0, FB_INT);

ptr = fbgetvalt(fbuf, INPUT, 2, &fldlen, FB_INT);
printf(“Data: [%d]\n”, ptr); /* output: Data: [111] */
...

#include <fbuf.h>
#include <atmi.h>
int fbinit(FBUF *fbuf, FLDLEN buflen)

#include “demo_fdl.h”
...
FBUF *fbuf;
int ret;
long size;
size = fbcalcsize(10, 100);

if ((fbuf = (FBUF *)tpalloc(“FIELD”, NULL, size)) == NULL) {
    printf(“tpalloc failed, errno = %d\n”, tperrno);
    ...
}
ret = fbinit(fbuf, size);
printf(“fbinit, ret : [%d]\n”, ret); /* fbinit, ret: [1] */
...

#include <fbuf.h>
#include <atmi.h>
int fbinsert(FBUF *fbuf, FLDKEY fldkey, int nth, char *value, int fldlen)

#include “demo_fdl.h”
...
long rcvlen, ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbinsert(fbuf, INPUT, 0, “aaaa”, 0);
fbinsert (fbuf, INPUT, 1, “bbbb”, 0);
fbinsert (fbuf, INPUT, 2, “cccc”, 0);
...

#include <fbuf.h>
#include <atmi.h>
int fbisfbuf(FBUF *fbuf)

#include “demo_fdl.h”
...
FBUF *fbuf;
int ret;

if ((fbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0)) == NULL) {
    printf(“tpalloc failed, errno = %d\n”, tperrno);
    ...
}
ret = fbisfbuf(fbuf);
printf(“ret : [%d]\n”, ret); /* output : ret : [1] */
...

#include <fbuf.h>
#include <atmi.h>
int fbispres(FBUF *fbuf, FLDKEY fldkey, int nth)

#include “demo_fdl.h”
...
int ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
ret = fbispres(fbuf, INPUT, 1);
printf(“Field Occ: [%d]\n”, ret); /* output: Field Occ: [1] */
...

#include <fbuf.h>
#include <atmi.h>
int fbkeyoccur(FBUF *fbuf, FLDKEY fldkey)

#include “demo_fdl.h”
...
int cnt;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, OUTPUT, “cccc”, 0);
cnt = fbkeyoccur(fbuf, INPUT);
printf(“Field Count: [%d]\n”, cnt);
/* output: Field Count: [2] */
...

#include <fbuf.h>
#include <atmi.h>
FLDKEY fbmake_fldkey(int type, int no)

#include “demo_fdl.h”
...
FLDKEY fkey;

fkey = fbmake_fldkey(FB_STRING, 101);
printf(“Field Key : [%d]\n”, fkey);
/* output : Field Key : [469762149] */
...

#include <fbuf.h>
#include <atmi.h>
int fbnext_tu(FBUF *fbuf, FLDKEY *fldkey, int *nth, char *value, int *len)

#include “demo_fdl.h”
...

char data[100];
long rcvlen;
int i, occ, nth, fc, len;

FLDKEY fkey;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbput(fbuf, INPUT, “dddd”, 0);
fbput(fbuf, INPUT, “eeee”, 0);
fbput(fbuf, INPUT, “cccc”, 0);

len = 4;
for(fkey = FIRSTFLDKEY;fc = fbnext_tu(fbuf, &fkey , &occ, data, &len) > 0;

len = sizeof(data))
printf(“fkey = %ld Data: [%s], Occurrence: [%d] len [%d]\n”, fkey, data, occ,
len);

/* output: fkey = 469762149 Data: [aaaa], Occurrence: [0] len [4]
  output: fkey = 469762149 Data: [bbbb], Occurrence: [0] len [4]
  output: fkey = 469762149 Data: [dddd], Occurrence: [0] len [4]
  output: fkey = 469762149 Data: [eeee], Occurrence: [0] len [4]
  output: fkey = 469762149 Data: [cccc], Occurrence: [0] len [4] */
...

#include <fbuf.h>
#include <atmi.h>
int fbprint(FBUF *fbuf)

#include “demo_fdl.h”
...

FBUF *fbuf;
if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “5555”, 0);
fbput(fbuf, INPUT, “7777”, 0);
fbput(fbuf, INPUT, “3333”, 0);
fbput(fbuf, INPUT, “8888”, 0);

fbprint(fbuf);
...

#include <fbuf.h>
#include <atmi.h>
int fbput(FBUF *fbuf, FLDKEY fldkey, char *value, FLDLEN len)

#include “demo_fdl.h”
...

long rcvlen, ret;
FBUF *fbuf;
int ival = 1000;
if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INTDATA, (char *)&ival, 0);

#include <fbuf.h>
#include <atmi.h>
int fbputt(FBUF *fbuf, FLDKEY fldkey, char *value, FLDLEN len, int type)

#include “demo_fdl.h”
...
long rcvlen, ret;
FBUF *fbuf;
int ival;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
ival = 1111;
fbputt(fbuf, INPUT, “aaaa”, 0, FB_STRING);
/* string형인 INPUT 필드 키에 int형인 ival(1111)을 넣기 위해 FB_INT형을 지정. */
fbputt(fbuf, INPUT, (char *)&ival, 0, FB_INT);
...
fbprint(fbuf);
fbfree(fbuf);
...
/* output :    fkey = 469762149, fname = NAME, type = string, value = aaaa
               fkey = 469762149, fname = NAME, type = string, value = 1111  */
...

#include <fbuf.h>
#include <atmi.h>
FBUF *fbrealloc(FBUF *fbuf, int ncount, int nlen)

#include “demo_fdl.h“
...
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n“, fberror);
    ...
}
printf(“Buffer Size: [%ld]\n“, fbget_fbsize(fbuf));
/* output: Buffer Size: [1024] */
if ((fbuf = (FBUF *)fbrealloc(fbuf, 1000, 150)) == NULL) {
    printf(“fbrealloc failed, errno = %d\n“, fberror);
    ...
}

printf(“Buffer Size: [%ld]\n”fbget_fbsize(fbuf));
/* output: Buffer Size: [4158] */

#include <fbuf.h>
#include <atmi.h>
int fbread(FBUF *fbuf, FILE *iop)

#include “demo_fdl.h”
...
int ret;
FILE *iop;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
iop = fopen(“sample.dat”, “r”);
ret = fbread(fbuf, iop);

if (ret == 1)
   fbprint(fbuf);
fclose(iop)
...

#include <fbuf.h>
#include <atmi.h>
int fbsnull(char *cstruct, char *cname, int nth, char *stname)

#include “demo_fdl.h”
#include “demo_sdl.h”
...
int val = 1000, ret;
struct demo temp;
char *cstruct;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

if(tpstart((TPSTART_T *)NULL) == NULL){
    printf(tpstart error\n”);
    ...
}

cstruct = (char *)&temp;
if(fbstinit(cstruct, “demo”) < 0){
     ...
}

fbput(fbuf, INPUT, “aaaa”, 0);
if(fbftos(fbuf, cstruct, “demo”) < 0){
     ...
}
ret = fbsnull(cstruct, “demodata”, 0, “demo”);
if(ret < 0) {
     printf(“fbsnull failed\n”);
     ...
}
else if(ret == 0)
     printf(“This occurrence is not null\n”);
else
     printf(“This occurrence is null\n”);
...

#include <fbuf.h>
#include <atmi.h>
int fbstelinit(char *cstruct, char *cname, char *stname)

#include “demo_fdl.h”
#include “demo_sdl.h”
...
cstruct demo temp;
char *cstruct;
if(tpstart((TPSTART_T *)NULL) == NULL) {
     printf(“tpstart failed\n”);
     ...
}
cstruct = (char *)&temp;
if(fbstelinit(cstruct, “demodata”, “demo”) < 0) {
     ...
}
...

#include <fbuf.h>
#include <atmi.h>
int fbstinit(char *cstruct, char *stname)

#include “demo_fdl.h”
#include “demo_sdl.h”
...
cstruct demo temp;
char *cstruct;
if(tpstart((TPSTART_T *)NULL) == NULL) {
     printf(“tpstart failed\n”);
     ...
}
cstruct = (char *)&temp;
if(fbstinit(cstruct, “demo”) < 0) {
     ...
}
...

#include <fbuf.h>
#include <atmi.h>
int fbstof(FBUF *fbuf, char *cstruct, int mode, char *stname)

#include “demo_fdl.h”
#include “demo_sdl.h”
...
int ret, fdllen, val = 1000;
struct demo temp;
FBUF *fbuf;
Char *cstruct;

if(tpstart((TPSTART_T *)NULL) == -1) {
    printf(“tpstart failed\n”);
    ...
}

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

cstruct = (char *)&temp;
if(fbstinit((char *)&temp, “demo”) < 1)  {
    printf(“fbstinit failed, errno = %d\n”, fberror);
    ...
}

strcpy(temp.demodata, “aaaa”);
temp.num = 1000;
if(fbstof(fbuf, cstruct, FBUPDATE, “demo”) < 0) {
...
}
...

#include <fbuf.h>
#include <atmi.h>
char *fbstrerror(int fberror)

#include “demo_fdl.h”
...
int ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

ret = fbget(fbuf, INPUT, “aaaa”, 0);
if( ret < 0 )
    printf(“ret = %d , fberror = %s[%d]\n”, ret, fbstrerror(fberror) , fberror);
/* output : ret = -1, fberror = not found[6] */
...

#include <fbuf.h>
#include <atmi.h>
char *fbtypecvt(FLDLEN *tolen, int totype, char *fromval, int fromtype,
                FLDLEN fromlen)

#include “demo_fdl.h”
...
int tolen, totype, fromtype, fromlen;
long vall;
FBUF *fbuf;
char *ptr;

if ((fbuf = fballoc(10, 100)) == NULL) {
      printf(“fballoc failed, errno = %d\n”, fberror);
      ...
}

vall = 1111;
fromlen = sizeof(long);

fbput(fbuf, TOTMON,(char *)&vall, 0);
ptr = fbtypecvt(&tolen, FB_STRING, (char *)&vall, FB_LONG, fromlen);

printf(“Converted string = %s\n”, ptr);
/* output Converted string = 1111 */
...

#include <fbuf.h>
#include <atmi.h>
int fbupdate(FBUF *fbuf, FLDKEY fldkey, int nth, char *value, int fldlen)

#include “demo_fdl.h”
...
long rcvlen, ret;
FBUF *fbuf;
char buf[20];
if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
fbinsert(fbuf, INPUT, 0, “aaaa”, 0);
ret = fbupdate(fbuf, INPUT, 0, “bbbbb”, 0);
fbget (fbuf, INPUT, buf, 0);
printf(“ret = [%d] INPUT = %s \n”, ret, buf);
/* output: “ret = 1 INPUT = bbbbbb” */
...

#include <fbuf.h>
#include <atmi.h>
int fbwrite(FBUF *fbuf, FILE *iop)

#include “demo_fdl.h”
...
int ret;
FILE *iop;
FBUF *fbuf;
if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
iop = fopen(“sample.dat”, “w”);
fbput(fbuf, INPUT, “aaaa”, 0);
fbput(fbuf, INPUT, “bbbb”, 0);
fbwrite(fbuf, iop);
fclose(iop)
...

#include <fbuf.h>
#include <atmi.h>
int getfberrno(void)

#include “demo_fdl.h”
...
int ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}

ret = fbget(fbuf, INPUT, “aaaa”, 0);
if( ret < 0 )
    printf(“ret = %d , error = %s[%d]\n”, ret, fbstrerror(getfberrno()) ,
             getfberrno());

/* output : ret = -1, error = not found[6] */
...

#include <fbuf.h>
#include <atmi.h>
int getfberror(void)

#include “demo_fdl.h”
...
int ret;
FBUF *fbuf;

if ((fbuf = fballoc(10, 100)) == NULL) {
    printf(“fballoc failed, errno = %d\n”, fberror);
    ...
}
ret = fbget(fbuf, INPUT, “aaaa”, 0);
if( ret < 0 )
    printf(“ret = %d , error = %s[%d]\n”, ret, fbstrerror(getfberror()) ,
            getfberror());
/* output : ret = -1, error = not found[6] */
...