sntncepars.cpp

中科院开源的ictprop源码,使用方法： 1、修改源码中的InputComboBox.cpp文件 InvokeAction里面的txt文件路径换成你的本地路径； 2、入口在帮助里面

#include "stdafx.h"
#include "symbol.h"
#include "rrtbl.h"
#include "grmrgrph.h"
#include "sntncelex.h"
#include "sntncepars.h"
#include "math.h"
#define pfat(cate, from) catetbl[from*tntcount+cate]

//#define DELTA 1e-10
#define MAXSORTSTACK 50
char *mymark;

extern FILE *pfo;
FILE *pfedgs;

int interactive;
chartnode_t chart[MAXCNODE];

//unsigned int glbmaxsub=0;
typedef struct range_t{
		int l;
		int r;
	}range_t;

	range_t rangestack[MAXSORTSTACK];
rrset_struct *rrset=NULL;

typedef struct rrrqentry_t{
        edge_t ed;
        unsigned int cate;
		int nxt;
}rrqentry_t;

typedef struct rrq_t{
        rrqentry_t queue[MAXSQUE];
		int topptr;
		int botptr;
}rrq_t;

unsigned int *lstack;
int lsptr;

rrq_t rq;
pf_t *pfroot=NULL, *pfhead=NULL;

pf_t **catetbl;
edge_t *edgepool;
pf_t *trnodepool;

int curavle=0;
int loope=0;

int npfs;

pf_t *tokenpf;
int cirflag;

edge_t *pooledg;
rrqentry_t *nre;

int unacc[MAXCNODE];

pf_t *addpf(unsigned int cate, int from){
  int index;
  pf_t *ppf;

  index=from*tntcount+cate;

  if ((ppf=catetbl[index])==NULL){
     ppf=&trnodepool[npfs++];
     //ppf=(pf_t *)malloc(sizeof(pf_t));
     ppf->cate=cate;
	 ppf->litoramb.literal=NULL;
     ppf->subpfs=NULL;
  //   ppf->nxt=pfhead;
	 ppf->prb=0;
//	 ppf->refs=0;
     pfhead=ppf;
     catetbl[index]=ppf;
  }

  return ppf;
}

int sumsubpf(pf_t *pf, edge_t *compedge){
	double subprb=1.0;
	int solid=0;
	unsigned int cursub, pos, rlen;
	edge_t *pe;

	if (compedge->rule<=rulcount){

		rlen=rightlenof(compedge->rule);
		for (pe=compedge->prevedge; (pe!=NULL) ;pe=pe->prevedge)
			subprb*=pe->ppf->prb;
		subprb*=probof(compedge->rule);

		if (compedge->ppf->prb>0){
			subprb*=compedge->ppf->prb;
			solid=1;
		}

		if (-pf->prb<=subprb){
			if (pf->subpfs){
				if (!solid)
					if (((pf->litoramb.totalamb+1)%MAXAMB)==0){
						pf->subpfs=(subpf_t *)realloc(pf->subpfs, 
										(pf->litoramb.totalamb+1+MAXAMB)*sizeof(subpf_t));
					}
				}
			else{
				pf->subpfs=(subpf_t *)calloc(MAXAMB, sizeof(subpf_t));
				pf->subpfs[0].sublst=NULL;
			}

			if (solid){
				cursub=0;
				pf->subpfs[cursub].rulno=compedge->rule;

				if (!pf->subpfs[0].sublst){
					pf->subpfs[cursub].sublst=
						(pf_t **)calloc(MAXRLEN, sizeof(pf_t *));
				}
			}
			else{
				cursub=++pf->litoramb.totalamb;

				pf->subpfs[cursub].rulno=compedge->rule;
				pf->subpfs[cursub].sublst=
					(pf_t **)calloc(rlen, sizeof(pf_t *));
			}

			for (pos=rlen-1,pe=compedge;pe!=NULL;pos--,pe=pe->prevedge){
				pf->subpfs[cursub].sublst[pos]=pe->ppf;
			}

			if (!solid)
				subprb*=-compedge->ppf->prb;

			if (-pf->prb<subprb){
				pf->prb=-subprb;
			}
		}

	}
	else{
		pf->litoramb.literal=currwentry->word;
		pf->prb=1.0;
	}

	return 0;
}

releasepf(pf_t *ppf){
  unsigned int c;

  if (ppf->subpfs){
	for (c=0;c<=ppf->litoramb.totalamb;c++)
		if (ppf->subpfs[c].sublst)
			free(ppf->subpfs[c].sublst);
	free(ppf->subpfs);
  }
  //free(ppf);
  return 0;
}

releasewholepf(){
	int i;

	for (i=0; i<npfs; i++){
		releasepf(&trnodepool[i]);
	}
	/*
	int nonz=0;

  pf_t *ppf, *qpf; 

  
    for (qpf=ppf=pfhead;ppf!=NULL;){
           if (ppf==pfhead){
              pfhead=qpf=ppf->nxt;
			  if (ppf->refs==0)
				  nonz++;
              releasepf(ppf);
              ppf=pfhead;
           }
           else{
              qpf->nxt=ppf->nxt;
			  if (ppf->refs==0)
				  nonz++;
              releasepf(ppf);
              ppf=qpf->nxt;
           }
         //  npfs--;
    }

	pfhead=NULL;

	printf("\n%f\n", (double)nonz/(double)npfs);
	*/
	npfs=0;
	return 0;
}

addchartnode(){
   int i;
	unsigned int j;
   
   for (i=0; i<MAXCNODE; i++){
	   chart[i].numb=0;
	   chart[i].pled=-1;
	   chart[i].plst=-1;
	   chart[i].chd=-1;
	   chart[i].ctl=-1;
	   chart[i].expeclist=(char *)malloc(sizeof(char)*tntcount);
	   for (j=0; j<tntcount; j++){
		   chart[i].expeclist[j]=0;
	   }
   }
   return 0;
}

quicksrt(int l, int r){
	int i,j;
	edge_t ed;
	int rstptr;

	rangestack[rstptr=0].l=l;
	rangestack[rstptr].r=r;

	while (rstptr>=0){
		l=rangestack[rstptr].l;
		r=rangestack[rstptr].r;
		rstptr--;

st:
		if (l>=r)
			continue;

		i=l;j=r;
		ed=edgepool[i];

		while (!(i==j)){
			while ((j>i) && ( EXP(edgepool[j].rule, edgepool[j].role)>EXP(ed.rule, ed.role)))
				j--;
			if (i<j)
				edgepool[i++]=edgepool[j];

			while ((j>i) && ( EXP(edgepool[i].rule, edgepool[i].role)<EXP(ed.rule, ed.role)))
				i++;
			if (i<j)
				edgepool[j--]=edgepool[i];
		}
	
		edgepool[i]=ed;
		i++;j--;

		if ((r-i)>(j-l)){
			rstptr++;
			rangestack[rstptr].l=i; 
			rangestack[rstptr].r=r;
			r=j;
			goto st;
		}
		else{
			rstptr++;
			rangestack[rstptr].l=l;
			rangestack[rstptr].r=j;
			l=i;
			goto st;
		}
	}

	return 0;
}

qsrt(int l, int r){
	int qi,qj;
	edge_t ed;
	edge_t *edg;
	int flagO, flagL;
	int rstptr;

	rangestack[rstptr=0].l=l;
	rangestack[rstptr].r=r;

	while (rstptr>=0){
		l=rangestack[rstptr].l;
		r=rangestack[rstptr].r;
		rstptr--;

start:
		if (l>=r)
			continue;
		qi=l;qj=r;

		ed=edgepool[qi];
		while (!(qi==qj)){
			edg=&edgepool[qj];
			while ( (qj>qi) &&
					( ((flagO=edg->origin-ed.origin)>0) ||
						( !flagO && 
							( ((flagL=leftof(edg->rule)-leftof(ed.rule))>0) ||
								( !flagL && 
									(PST(edg->rule, edg->role)>PST(ed.rule, ed.role))
								//	RGT(edg->rule, edg->role, ed.rule, ed.role)
								)
							)
						)
					)
				)
				edg=&edgepool[--qj];

			if (qi<qj)
				edgepool[qi++]=edgepool[qj];

			edg=&edgepool[qi];
			while ( (qj>qi) &&
					( ((flagO=ed.origin-edg->origin)>0) ||
						( !flagO && 
							( ((flagL=leftof(ed.rule)-leftof(edg->rule))>0) ||
								( !flagL && 
									(PST(ed.rule, ed.role)>PST(edg->rule, edg->role))
								//	RGT(ed.rule, ed.role, edg->rule, edg->role)
								)
							)
						)
					)
				)
				edg=&edgepool[++qi];

			if (qi<qj)
				edgepool[qj--]=edgepool[qi];
		}

		edgepool[qi]=ed;

		qi++;qj--;
		if ((r-qi)>(qj-l)){
			rstptr++;
			rangestack[rstptr].l=qi; 
			rangestack[rstptr].r=r;
			r=qj;
			goto start;
		}
		else{
			rstptr++;
			rangestack[rstptr].l=l;
			rangestack[rstptr].r=qj;
			l=qi;
			goto start;
		}
	}
 
  return 0;
}


releasechart(){
  int p;

  for (p=0;p<MAXCNODE;p++){
	  chart[p].pled=chart[p].plst=-1;
	  chart[p].chd=chart[p].ctl=-1;
	  free(chart[p].expeclist);
	  chart[p].expeclist=NULL;
  }
  return 0;
}

releaseedges(){
  int p;
  unsigned int q;

  for (p=0;(chart[p].numb!=0); p++){
	  chart[p].numb=0;
	  for (q=0; q<tntcount; q++){
		  chart[p].expeclist[q]=0;
	  }
  }

}

searchcompe(unsigned int cate, int *pos){
  int bottom, middle, top;

  bottom=chart[accchartnode].plst+1;
  top=chart[accchartnode].pled;

  if (top<bottom){
	  *pos=top;
	  return 0;
  }
  while (top>bottom){
    middle=(top+bottom)/2;
    if (cate>EXP(edgepool[middle].rule, edgepool[middle].role))
       bottom=middle+1;
    else
       top=middle;
  }

 /*
  if (top==bottom){
     if (cate>EXP(edgepool[top].rule, edgepool[top].role))
        bottom++;
  } 

  *pos=bottom;
  */
  *pos=top;
  if ( 
     !(cate==EXP(edgepool[*pos].rule, edgepool[*pos].role)))
     return 0;
  else
     return 1;

}

#define addexpec(expec){\
	chart[curchartnode].expeclist[expec]=1;\
}

#define addedge(dumrule, dumrole, dumorigin, dumprevedge, dumppf){\
	pooledg=&edgepool[curavle++];\
	pooledg->rule=dumrule;\
	pooledg->role=dumrole;\
	pooledg->origin=dumorigin;\
	pooledg->prevedge=dumprevedge;\
	pooledg->ppf=dumppf;\
\
	if (dumrole==0)\
		loope++;\
	chart[curchartnode].numb++;\
	chart[curchartnode].pled++;\
}

#define enqedge(dumrule, dumrole, dumorigin, dumprevedge, dumppf, dumcate){\
	nre=&rq.queue[++rq.topptr];\
	nre->nxt=-1;\
	nre->cate=dumcate;\
	nre->ed.rule=dumrule;\
	nre->ed.role=dumrole;\
	nre->ed.origin=dumorigin;\
	nre->ed.prevedge=dumprevedge;\
	nre->ed.ppf=dumppf;\
\
	(chart[dumorigin].chd==-1)?(chart[dumorigin].chd=rq.topptr):\
		(rq.queue[chart[dumorigin].ctl].nxt=rq.topptr);\
	chart[dumorigin].ctl=rq.topptr;\
}


#define rqinit {rq.topptr=rq.botptr=-1;}

#define lsempty (lsptr==-1)

#define lsinit lsptr=-1;