009B29AF   lea         ecx,[ebp-1030h]  ; uncompressed buffer to be filled

009B29B5   push        1  ; number of bytes to uncompress

009B29B7   push        ecx

009B29B8   mov         ecx,dword ptr [ebp-1Ch]

009B29BB   push        ecx  ; compression structure 64h bytes

009B29BC   mov         ecx,eax  ; ZLIB object (Baby source is in C++)

009B29BE   call        dword ptr [edx+18h]  ; inflate

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



void

main(int argc, char **argv)

{

	char resname[256];

	unsigned char hdr, high_nibble, lenbyte;

	unsigned char specifier[2];

	int i, record_length;

	FILE *fpin;

	long curpos, datapos;



	if (argc != 2) {

		printf("usage: %s uncompressed_filename\n", argv[0]);

		return;

		}



	fpin = fopen(argv[1], "rb";

	if (!fpin) goto ko;



		// a record per loop

	while (1) {

		curpos = ftell(fpin);

		fread(&hdr, 1, sizeof(hdr), fpin);

		if (feof(fpin)) return;



			// get the record size

		high_nibble = hdr >> 4;

		if (high_nibble >= 4) record_length = high_nibble - 4;

		else for (i=record_length=0; i<high_nibble+1; i++) {

			record_length *= 256;

			fread(&lenbyte, 1, sizeof(lenbyte), fpin);

			record_length += lenbyte;

			}

		datapos = ftell(fpin);



		switch (hdr & 0xF) {  // low nibble



		case 0:  // one-byte specifier follows

			fread(specifier, 1, 1, fpin);

			printf("@%x: <id %x> %x bytes\n",

				curpos, specifier[0], record_length);

			break;

		case 3:  // two-bytes specifier follows

			fread(specifier, 1, 2, fpin);

			printf("@%x: <id %x> %x bytes\n",

				curpos, specifier[0]*256+specifier[1], record_length);

			break;

		case 4:  // no specifier

		case 6:  // no specifier

			printf("@%x: <no id(%d)> %x bytes\n",

				curpos, hdr&0xF, record_length);

			break;



		case 2:  // named resource

			fread(&lenbyte, 1, sizeof(lenbyte), fpin);

			fread(resname, 1, lenbyte, fpin);

			printf("@%x: <res %.*s> %x bytes\n",

				curpos, lenbyte, resname, record_length);

			break;



		case 1:  // entry

			fread(&lenbyte, 1, sizeof(lenbyte), fpin);

			fread(resname, 1, lenbyte, fpin);

			printf("@%x: <entry> \"%.*s\"> %x bytes\n",

				curpos, lenbyte, resname, record_length);

			break;



		default:

			printf("unexpected low_nibble %x\n", hdr & 0xF);

			return;

		}

		fseek(fpin, datapos+record_length, SEEK_SET);

		}



	return;

ko:

	printf("exit due to error %d: %s\n", errno, strerror(errno));

}

#include <stdio.h>

#include <windows.h>

#include <conio.h>



int isvalidchar(char ch);

void stripjunk(char *buffer);



struct bdc {

	char szTerm[256];

	char szDefinition[256];

} **babyterm[27]; 

int ptrcnt[27]; //sorted



void main(int argc,char **argv) {

FILE *fdic;

int ix,iy,rec_length;

unsigned char hdr,high_nibble,lenbyte,tmpch;

unsigned long datapos;

char tmpbuff[256];

char uterm[256];

int bg,eg;



if(argc!=2) { printf("usage: %s uncompressed_filename\n", argv[0]); return; }

//initial allocation of pointers

for(ix=0;ix<27;ix++)  {

	babyterm[ix]=(struct bdc**)malloc(sizeof(struct bdc*));

	ptrcnt[ix]=0;

}

//>>parsing

fdic=fopen(argv[1],"rb";

if(!fdic) { printf("error opening file [%s].\n",argv[1]); return; }

bg=GetTickCount();

while(1) {

	fread(&hdr,sizeof(char),1,fdic);

	if(feof(fdic)) break;



	//get record size

	high_nibble=hdr >> 4;

	if(high_nibble>=4) rec_length=high_nibble-4;

	else {

		for(ix=rec_length=0;ix<high_nibble+1;ix++) {

			rec_length*=256;

			fread(&lenbyte,sizeof(char),1,fdic);

			rec_length+=lenbyte;

		}

	}

	datapos=ftell(fdic);



	switch(hdr & 0xF) {

			case 1: {

			fread(&lenbyte,sizeof(char),1,fdic);

			memset(tmpbuff,0,lenbyte+1);

			fread(tmpbuff,sizeof(char),lenbyte,fdic);

			if(!isalpha(tmpbuff[0])) break;

			stripjunk(tmpbuff);

			//printf("TERM [%s] -> \n",tmpbuff);

			//>>allocating space for term struct

			tmpch=tolower(tmpbuff[0])-'a';

			babyterm[tmpch][ptrcnt[tmpch]]=(struct bdc*)malloc(sizeof(struct bdc));

			if(babyterm[tmpch][ptrcnt[tmpch]]==NULL) {

				printf(":O ran out of space.\n";

				return;

			}

			strcpy(babyterm[tmpch][ptrcnt[tmpch]]->szTerm,tmpbuff);

			//>>

			fseek(fdic,1,SEEK_CUR); //definiton lenbyte is next

			fread(&lenbyte,sizeof(char),1,fdic);

			memset(tmpbuff,0,lenbyte+1);

			fread(tmpbuff,sizeof(char),lenbyte,fdic);

			stripjunk(tmpbuff);

			strcpy(babyterm[tmpch][ptrcnt[tmpch]]->szDefinition,tmpbuff);

			//printf("DEF [%s]\n",tmpbuff);

			ptrcnt[tmpch]++;

			} break;

			default: break;

	}

	fseek(fdic,datapos+rec_length,SEEK_SET);

}

eg=GetTickCount();

fclose(fdic);	



printf("total parsing time: %dms\n",eg-bg);



printf("--------------------------\n";

for(ix=0;ix<27;ix++) {

	if(ptrcnt[ix]>0) {

		for(iy=0;iy<ptrcnt[ix];iy++) {

		printf("--\n[%s][%s]\n",babyterm[ix][iy]->szTerm,babyterm[ix][iy]->szDefinition);

		if(getch()==27) goto takeinp;

		}

	}

}

printf("--------------------------\n\n";

takeinp:

for(; { //input loop

	memset(uterm,0,256);

	printf("Term:";

	scanf("%256s",uterm);

	if(uterm[0]) {

		tmpch=tolower(uterm[0])-'a';

		for(ix=0;ix<ptrcnt[tmpch];ix++) 

			if(!strcmpi(babyterm[tmpch][ix]->szTerm,uterm))

			printf("%s = \n%s\n",uterm,babyterm[tmpch][ix]->szDefinition);

	}

}

}



void stripjunk(char *buffer) {

int ix,slen;

slen=strlen(buffer);



for(ix=1;ix<slen;ix++)

	if(buffer[ix]=='$') { buffer[ix]=0; break; }

slen=ix;

for(ix=0;ix<slen;ix++) 

	if(!isvalidchar(buffer[ix])) { buffer[ix]=0; break; }

	

}



int isvalidchar(char ch) {

	int ix;

	char valtab[]="abcdefghijklmnopqrstuvwxyz 0123456789!@#$%&8()_-+=|{}[]<>\"',.%%/\\:;!?";

	ch=tolower(ch);



	for(ix=0;(unsigned)ix<strlen(valtab);ix++)

		if(ch==valtab[ix]) return 1;

return 0;

}

babyterm[tmpch] = (struct bdc**)realloc(babyterm[tmpch],

                           (ptrcnt[tmpch]+1)*sizeof(struct bdc*));

babyterm[tmpch][ptrcnt[tmpch]] = (struct bdc*)malloc(sizeof(struct bdc));

babyterm[tmpch][ptrcnt[tmpch]] = (struct bdc*)malloc(sizeof(struct bdc));

#include <stdio.h>

#include <windows.h>

#include "zlib.h"



#pragma comment(lib,"zlib.lib"



int isvalidchar(char ch);

void stripjunk(char *buffer,char type);

int focc(char *cstr,char ch);

int uncomp_bgl(char *bglname,char *datname);

int writegls(char *datname);



char glsheader[1024];

char glsheadertemplate[]=

"### Glossary title:%s\r\n"

"### Author:%s\r\n"

"### Description:%s\r\n"

"### Source language:English\r\n"

"### Source alphabetefault\r\n"

"### Target language:English\r\n"

"### Target alphabetefault\r\n"

"### Browsing enabled?No\r\n"

"### Type of glossary:00000000\r\n"

"### Case sensitive words?0\r\n"

";gls generated by bglgls\r\n\r\n"

"### Glossary section:\r\n\r\n";



int main(int argc,char **argv) {

int ix;

char szAuth[32];

char szTitle[32];

char szDescription[128];

char datfname[128];



if(argc!=2) { 

	printf("usage: bglgls.exe filename.bgl\n"; 

	return 0; 

}

//>get input

printf("gls Author:";

fgets(szAuth,32,stdin);

printf("gls Title:";

fgets(szTitle,32,stdin);

printf("gls Description:";

fgets(szDescription,128,stdin);



szAuth[strlen(szAuth)-1]=0;

szTitle[strlen(szTitle)-1]=0;

szDescription[strlen(szDescription)-1]=0;

sprintf(glsheader,glsheadertemplate,szAuth,szTitle,szDescription);

//>set output filename

strncpy(datfname,argv[1],128);

ix=focc(datfname,'.');

if(ix<0) { printf("invalid filename\n"; return 0; }

datfname[ix]=0;

strcat(datfname,".dat";

//>>

if(!uncomp_bgl(argv[1],datfname)) { printf("error uncompressing BGL.\n"; return 0; }

if(!writegls(datfname)) { printf("error writing GLS.\n"; return 0; }

return 0;

}

//>>uncompression routine

int uncomp_bgl(char *bglname,char *datname) {

FILE *ztmp;

FILE *zfile;

char iobuff[128];

char tmppath[256];

char tmpfname[256];

unsigned char zptrbyte;

int tread;



//get temp filename

GetTempPath(256,tmppath);

GetTempFileName(tmppath,"bgl",0,tmpfname);

ztmp=fopen(tmpfname,"wb";

if(!ztmp) return 0;

//>

zfile=fopen(bglname,"rb";

if(!zfile) return 0;

fseek(zfile,0x5,SEEK_SET);

fread(&zptrbyte,sizeof(char),1,zfile);

printf("zlib header@0x%X\n",zptrbyte);

fseek(zfile,zptrbyte,SEEK_SET);

while(!feof(zfile)) {

	tread=fread(iobuff,sizeof(char),128,zfile);

	fwrite(iobuff,sizeof(char),tread,ztmp);

}

fclose(zfile);

fclose(ztmp);

//>>uncompressing >

zfile=fopen(datname,"wb";

ztmp=gzopen(tmpfname,"rb";

if(!zfile||!ztmp) return 0;

while(!gzeof(ztmp)) {

	tread=gzread(ztmp,iobuff,128);

	fwrite(iobuff,sizeof(char),tread,zfile);

}

gzclose(ztmp);

fclose(zfile);

DeleteFile(tmpfname); //get rid of temporary file

return 1;

}

//write gls

int writegls(char *datname) {

FILE *fdic,*fgls;

int ix,rec_length;

short int lenword;

unsigned char hdr,high_nibble,lenbyte;

unsigned char lenmul,lenadd;

unsigned long datapos;

char tmpbuff[1024];

char glsf[256];

int tt=0,lt=0;



//gls filename

strcpy(glsf,datname);

ix=focc(glsf,'.');

glsf[ix]=0;

strcat(glsf,".gls";

printf("gls filename:%s\n",glsf);

fgls=fopen(glsf,"wb";

if(!fgls) return 0;

//>write header

printf("writing GLS";

fwrite(glsheader,sizeof(char),strlen(glsheader),fgls);

//>>parsing

fdic=fopen(datname,"rb";

if(!fdic) return 0;

while(1) {

	fread(&hdr,sizeof(char),1,fdic);

	if(feof(fdic)) break;



	//get record size

	high_nibble=hdr >> 4;

	if(high_nibble>=4) rec_length=high_nibble-4;

	else {

		for(ix=rec_length=0;ix<high_nibble+1;ix++) {

			rec_length*=256;

			fread(&lenbyte,sizeof(char),1,fdic);

			rec_length+=lenbyte;

		}

	}

	datapos=ftell(fdic);



	switch(hdr & 0xF) {

			case 1: {

			fread(&lenbyte,sizeof(char),1,fdic);

			memset(tmpbuff,0,1024);

			fread(tmpbuff,sizeof(char),lenbyte,fdic);

			if(!isalpha(tmpbuff[0])) break;

			stripjunk(tmpbuff,0);

			strcat(tmpbuff,"\r\n";

			fwrite(tmpbuff,sizeof(char),strlen(tmpbuff),fgls);

			fread(&lenmul,sizeof(char),1,fdic);

				fread(&lenadd,sizeof(char),1,fdic);

			memset(tmpbuff,0,1024);

			lenword=lenmul*256+lenadd;

			if(lenword>1019) lenword=1019;

			fread(tmpbuff,sizeof(char),lenword,fdic);

			stripjunk(tmpbuff,1);

			strcat(tmpbuff,"\r\n\r\n";

			fwrite(tmpbuff,sizeof(char),strlen(tmpbuff),fgls);

			if(tt-100==lt) { lt=tt; printf("."; }

			tt++;

			} break;

			default: break;

	}

	fseek(fdic,datapos+rec_length,SEEK_SET);

}

fclose(fdic);

fclose(fgls);	

DeleteFile(datname); //we dont need the *.dat anymore..

printf("%d terms written to file!\n",tt);

return 1;

}

//find occurrence

int focc(char *cstr,char ch) { 

int ix;

for(ix=0;(unsigned)ix<strlen(cstr);ix++)

	if(cstr[ix]==ch) return ix;

return -1;

}

//>

void stripjunk(char *buffer,char type) {

int ix,slen;

slen=strlen(buffer);



if(!type) {

	for(ix=1;ix<slen;ix++)

		if(buffer[ix]=='$') { buffer[ix]=0; break; }

	slen=ix;

}	

for(ix=0;ix<slen;ix++) 

	if(!isvalidchar(buffer[ix])) { buffer[ix]=0; break; }

}

//valid term/definition char

int isvalidchar(char ch) {

	int ix;

	char valtab[]="abcdefghijklmnopqrstuvwxyz 0123456789!@#$%&8()_-+=|{}[]<>\"',.%%/\\:;!?";

	ch=tolower(ch);

	for(ix=0;(unsigned)ix<strlen(valtab);ix++)

		if(ch==valtab[ix]) return 1;

return 0;

}

00000ED5 1241 6273 6F72 7074 696F 6E20 636F 7374 .Absorption cost

00000EE5 696E 6700 0FE5 D2ED E4E5 20ED C7C8 ED20 ing....... ....

00000EF5 CCD0 C8ED                               ....

The strangeness is that they are not even (2 bytes per character)

for(ix=0;ix<slen;ix++) 

	if(!isvalidchar(buffer[ix])) { buffer[ix]=0; break; }

### Source language:English

### Source alphabetefault

### Target language:English

### Target alphabetefault

import traceback

styles = {48: "n", 49: "adj", 50: "v", 51: "adv", 52: "interj", 53: "pron",

          54: "prep", 55: "conj", 56: "suff", 57: "pref", 58: "art", 59: "aux"}



ps = open("u.gls","w"



# Header

ps.write("### Glossary title:Uru\n"

ps.write("### Author:Urudict\n"

ps.write("### Description:Urudict\n"

ps.write("### Source language:Japanese\n"

ps.write("### Source alphabetefault\n"

ps.write("### Target language:English\n"

ps.write("### Target alphabetefault\n"

ps.write("### Browsing enabled?No\n"

ps.write("### Type of glossary:00000000\n"

ps.write("### Case sensitive words?0\n\n"

# Glossary section

ps.write("### Glossary section:\n\n"



r = open("Babylon_Japanese_English_dicti.txt" # un-gz'd dictionary (see earlier posts)

e = open("entries.txt" # output of Bilbo's original code

for line in e.readlines():

    line = line.decode('utf-8')

    if '<entry>' not in line: continue

    line = line.split()

    offset = int(line[0][1:-1],16)

    entry = " ".join(line[2:-2])[1:-2]

    record = int(line[-2],16)

    spelling, type, defn, alts = "", "", "", ""

    

    try:

        r.seek(offset)

        bin = r.read(record)

        nib = int(hex(ord(bin[0]))[2])+1 # length of the 'length' header

        if len(hex(ord(bin[0]))) == 3: nib = 1 # 0x1 case

        bin += r.read(nib+1) # first byte and length headers aren't part of record length

        term = bin[nib+2:nib+2+ord(bin[nib+1])] # Get term from 2 bytes after nib + 'length'

        bin = bin[nib+4+ord(bin[nib+1]):] # discard up to and including term

        if bin.find("<I>" != -1: # check for spelling

            spelling = bin[bin.find("(":bin.find(""+1] # extract spelling

            bin = bin[bin.find(""+2:] # discard spelling if exists

        # at this point, bin should start with definition

        defn = bin[:bin.find('\x14')] # extract defintion

        bin = bin[bin.find('\x14')+1:] # discard definition

        if bin and bin[0] == '\x02': # check for type

            type = styles[ord(bin[1])] # extract type

            bin = bin[2:] # discard type

        if bin: # if bin isn't empty, rest of record is alts

            alts = bin

            for c in [chr(k) for k in range(1,30)]:

                alts = alts.replace(c, '\x00')



        ps.write(term.decode("shift-jis".encode('utf-8')) # write term

        for k in alts.split('\x00'):

            if k: ps.write("|"+k.decode("shift-jis".encode('utf-8')) # write alts

        #ps.write("\n<font color='blue'>"+type+"</font> " #type

        ps.write("\n"+type.encode('utf-8')) # write type

        if type: ps.write(". "

        ps.write(spelling.decode("shift-jis".encode('utf-8'))

        if spelling: ps.write(" "

        ps.write (defn.decode("shift-jis".encode('utf-8')+"\n\n" # definition

    except Exception:

        print hex(offset), hex(record)

        dmp = open("dmp.txt","w"

        r.seek(offset)

        dmp.write(r.read(record+nib+1))

        dmp.close()

        print traceback.format_exc()

        break



e.close()

r.close()

ps.close()

    

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

#include <ctype.h>

#include <zlib.h>

#pragma comment(lib,"zlib.lib"

#include "zlib.h"

#include "zconf.h"



//include namespace std

int isvalidchar(char ch);

void stripjunk(char *buffer,char type);

int focc(char *cstr,char ch);

int uncomp_bgl(char *bglname,char *datname);

int writegls(char *datname);



char glsheader[32768];

char glsheadertemplate[]=

"### Glossary title:%s\r\n"

"### Author:%s\r\n"

"### Description:%s\r\n"

"### Source language:English\r\n"

"### Source alphabetefault\r\n"

"### Target language:Arabic\r\n"

"### Target alphabet:Arabic\r\n"

"### Browsing enabled?No\r\n"

"### Type of glossary:00000000\r\n"

"### Case sensitive words?0\r\n"

";gls generated by bglgls\r\n\r\n"

"### Glossary section:\r\n\r\n";



int main(int argc,char **argv) {

int ix;

char szAuth[32];

char szTitle[32];

char szDescription[128];

char datfname[128];



if(argc!=2) { 

	printf("usage: bglgls.exe filename.bgl\n"; 

	return 0; 

}

//>get input

printf("gls Author:";

fgets(szAuth,32,stdin);

printf("gls Title:";

fgets(szTitle,32,stdin);

printf("gls Description:";

fgets(szDescription,128,stdin);



szAuth[strlen(szAuth)-1]=0;

szTitle[strlen(szTitle)-1]=0;

szDescription[strlen(szDescription)-1]=0;

sprintf(glsheader,glsheadertemplate,szAuth,szTitle,szDescription);

//>set output filename

strncpy(datfname,argv[1],128);

ix=focc(datfname,'.');

if(ix<0) { printf("invalid filename\n"; return 0; }

datfname[ix]=0;

strcat(datfname,".dat";

//>>

if(!uncomp_bgl(argv[1],datfname)) { printf("error uncompressing BGL.\n"; return 0; }

if(!writegls(datfname)) { printf("error writing GLS.\n"; return 0; }

return 0;

}

//>>uncompression routine

int uncomp_bgl(char *bglname,char *datname) {

FILE *ztmp;

FILE *zfile;

char iobuff[128];

char tmppath[256];

char tmpfname[256];

unsigned char zptrbyte;

int tread;



//get temp filename

GetTempPath(256,tmppath);

GetTempFileName(tmppath,"bgl",0,tmpfname);

ztmp=fopen(tmpfname,"wb";

if(!ztmp) return 0;

//>

zfile=fopen(bglname,"rb";

if(!zfile) return 0;

fseek(zfile,0x5,SEEK_SET);

fread(&zptrbyte,sizeof(char),1,zfile);

printf("zlib header@0x%X\n",zptrbyte);

fseek(zfile,zptrbyte,SEEK_SET);

while(!feof(zfile)) {

	tread=fread(iobuff,sizeof(char),128,zfile);

	fwrite(iobuff,sizeof(char),tread,ztmp);

}

fclose(zfile);

fclose(ztmp);

//>>uncompressing >

zfile=fopen(datname,"wb";

ztmp=(FILE*)gzopen(tmpfname,"rb";

if(!zfile||!ztmp) return 0;

while(!gzeof(ztmp)) {

	tread=gzread(ztmp,iobuff,128);

	fwrite(iobuff,sizeof(char),tread,zfile);

}

gzclose(ztmp);

fclose(zfile);

DeleteFile(tmpfname); //get rid of temporary file

return 1;

}

//write gls

int writegls(char *datname) {

FILE *fdic,*fgls;

int ix,rec_length;

short int lenword;

unsigned char hdr,high_nibble,lenbyte;

unsigned char lenmul,lenadd;

unsigned long datapos;

char tmpbuff[32768];

char glsf[256];

int tt=0,lt=0;



//gls filename

strcpy(glsf,datname);

ix=focc(glsf,'.');

glsf[ix]=0;

strcat(glsf,".gls";

printf("gls filename:%s\n",glsf);

fgls=fopen(glsf,"wb";

if(!fgls) return 0;

//>write header

printf("writing GLS";

fwrite(glsheader,sizeof(char),strlen(glsheader),fgls);

//>>parsing

fdic=fopen(datname,"rb";

if(!fdic) return 0;

while(1) {

	fread(&hdr,sizeof(char),1,fdic);

	if(feof(fdic)) break;



	//get record size

	high_nibble=hdr >> 4;

	if(high_nibble>=4) rec_length=high_nibble-4;

	else {

		for(ix=rec_length=0;ix<high_nibble+1;ix++) {

			rec_length*=256;

			fread(&lenbyte,sizeof(char),1,fdic);

			rec_length+=lenbyte;

		}

	}

	datapos=ftell(fdic);



	switch(hdr & 0xF) {

			case 1: {

			fread(&lenbyte,sizeof(char),1,fdic);

			memset(tmpbuff,0,32768);

			fread(tmpbuff,sizeof(char),lenbyte,fdic);

			if(!isalpha(tmpbuff[0])) break;

			stripjunk(tmpbuff,0);

			strcat(tmpbuff,"\r\n";

			fwrite(tmpbuff,sizeof(char),strlen(tmpbuff),fgls);

			fread(&lenmul,sizeof(char),1,fdic);

				fread(&lenadd,sizeof(char),1,fdic);

			memset(tmpbuff,0,32768);

			lenword=lenmul*256+lenadd;

			if(lenword>32608) lenword=32608;

			fread(tmpbuff,sizeof(char),lenword,fdic);

			stripjunk(tmpbuff,1);

			strcat(tmpbuff,"\r\n\r\n";

			fwrite(tmpbuff,sizeof(char),strlen(tmpbuff),fgls);

			if(tt-100==lt) { lt=tt; printf("."; }

			tt++;

			} break;

			default: break;

	}

	fseek(fdic,datapos+rec_length,SEEK_SET);

}

fclose(fdic);

fclose(fgls);	

DeleteFile(datname); //we dont need the *.dat anymore..

printf("%d terms written to file!\n",tt);

return 1;

}

//find occurrence

int focc(char *cstr,char ch) { 

int ix;

for(ix=0;(unsigned)ix<strlen(cstr);ix++)

	if(cstr[ix]==ch) return ix;

return -1;

}

//>

void stripjunk(char *buffer,char type) {

int ix,slen;

slen=strlen(buffer);



if(!type) {

	for(ix=1;ix<slen;ix++)

		if(buffer[ix]=='$') { buffer[ix]=0; break; }

	slen=ix;

}	

for(ix=0;ix<slen;ix++) 

	if(!isvalidchar(buffer[ix])) { buffer[ix]=0; break; }

}

//valid term/definition char

int isvalidchar(char ch) {

    if (ch==30 ||ch==31) return 0;

    return 1;//I didn't delete the old code here, but u can.

	int ix;

	char valtab[]="abcdefghijklmnopqrstuvwxyz 0123456789!@#$%&8()_-+=|{}[]<>\"',.%%/\\:;!?";

	ch=tolower(ch);

	for(ix=0;(unsigned)ix<strlen(valtab);ix++)

		if(ch==valtab[ix]) return 1;

return 0;

}

http://www.4shared.com/file/ikJChutb/Business_EV_2008_release_01.html

cambridge_advanced_learners_dictionary_2nd_ed.rar 

(6.75 MB, BDC inside)

http://www.mediafire.com/?2iyls1hjlmo

http://www.megaupload.com/?d=CFDK4ZKD