sntncepars.cpp

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

#define lspush(catee) lstack[++lsptr]=catee;

#define lspop(pcate) pcate=lstack[lsptr--];

double prbbranch(pf_t *ppf){
  subpf_t subpf;
  int sublen, curpos;
  unsigned int amb, vp=0;
  double subprb, maxprb;
  

  if (ppf->subpfs==NULL){
	  ppf->prb=1.0;
      return 1.0;
  }

  maxprb=-1.0;
  ppf->prb=0;
  for (amb=0; amb<=ppf->litoramb.totalamb; amb++){
      subprb=1.0;

      subpf=ppf->subpfs[amb];

	  if (subpf.sublst==NULL)
		  continue;
      sublen=rightlenof(subpf.rulno);
      for (curpos=0;curpos<sublen;curpos++){
		  double x=subpf.sublst[curpos]->prb;

		  if ((x==0)&&(tokenpf)){
			  cirflag=1;
			  subprb=0;
			  continue;
		  }

	  	  if ((sublen==1)&&(x<0)&&(!tokenpf))
			tokenpf=ppf;

          subprb*=(x>=0)?x:prbbranch(subpf.sublst[curpos]);

		  if (ppf==tokenpf){
		    	tokenpf=NULL;
				cirflag=0;
		  }


      }
	  subprb*=probof(subpf.rulno);
      if (subprb>=maxprb){
		  maxprb=subprb;
		  vp=amb;
	  }
  }

  if (!cirflag){
	ppf->prb=maxprb;

	for (amb=0; amb<=ppf->litoramb.totalamb; amb++){
		  if (amb==vp)
			  continue;
		if (ppf->subpfs[amb].sublst){	
			free(ppf->subpfs[amb].sublst);
			ppf->subpfs[amb].sublst=NULL;
		}
	}
	subpf=ppf->subpfs[vp];
	free(ppf->subpfs);
	ppf->subpfs=(subpf_t *)malloc(sizeof(subpf_t));
	ppf->subpfs[0]=subpf;
	ppf->litoramb.totalamb=0;

	return ppf->prb;
  }
  else{
	  ppf->prb=-1.0;
	  return maxprb;
  }

}

prbmaxprefix(){
	int bottom, top, curbot, curtop, curedp;
	double curmaxprb, curprb;
	edge_t *pe, *ptop, *pcur;
	double x;




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


	for (curtop=curbot=bottom; curtop<=top;){

		curmaxprb=-1;
		curedp=curtop;
		do{
			for (x=1.0, pe=&edgepool[curtop]; pe!=NULL; pe=pe->prevedge)
				x*=pe->ppf->prb;

			curprb=x*=probof(edgepool[curtop].rule);

			if (curprb>curmaxprb){
				/*
				if (curedp!=curtop)
					if (edgepool[curedp].ppf)
						edgepool[curedp].ppf->refs--;
						*/
				curedp=curtop;
				curmaxprb=curprb;
			}
			/*
			else
				if (edgepool[curedp].ppf)
					edgepool[curtop].ppf->refs--;
					*/
			curtop++;
		}while ((curtop<=top)&&
				((ptop=&edgepool[curtop])->origin==(pcur=&edgepool[curedp])->origin)&&
				(leftof(ptop->rule)==leftof(pcur->rule))&&
				(PST(ptop->rule, ptop->role)==PST(pcur->rule, pcur->role))
				//REQ(ptop->rule, ptop->role, pcur->rule, pcur->role)
				);

		edgepool[curbot++]=edgepool[curedp];
	}

	chart[curchartnode].pled=curbot-1;
	curavle=curbot;

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


	return 0;
}

pred(){
	int match=0;
	unsigned int cate, expecate;
	rulrol_struct  *qrr;
	int loc, prerr;
	int ptr,lastptr;
	unsigned int rul;
	unsigned int rol;
	int i;

	if ((*nextdefs)[0]==0)
		return 0;

	while (!lsempty){
		lspop(cate);
		if ((cate<tcount)){
			if (!match)
       			for (i=0; (*nextdefs)[i]<tcount; i++){
					if (cate==(*nextdefs)[i]){
						match=1;
						break;
					}
				}
		}
		else{
			prerr=0;
			//merge rrlist
			for (i=0; (*nextdefs)[i]<tcount; i++){
				for (qrr=lrr(cate, (*nextdefs)[i]); qrr!=NULL; qrr=qrr->nxt){
					loc=ROLPOS(qrr->rule, qrr->role);
					if (!rrset[loc].prr){
						rrset[loc].prr=qrr;
						rrset[prerr].next=loc;
						prerr=loc;
					}
				}
			}

			lastptr=0;

			if ((ptr=rrset[0].next)!=-1)
				match=1;

			for (;ptr!=-1;ptr=rrset[ptr].next){
				rul=rrset[ptr].prr->rule;
				rol=rrset[ptr].prr->role;

			//	addedge(rul, rol, curchartnode, NULL, NULL);
				expecate=EXP(rul, rol);
				addexpec(expecate);
				addexpec(leftof(rul));
				if (expecate>=tcount && !mymark[expecate]){
					lspush(expecate);
					mymark[expecate]=1;
				}
				rrset[ptr].prr=NULL;
				rrset[lastptr].next=-1;
				lastptr=ptr;
			}
		}
	}

	lsinit;
	return match;
}

init(){
	extern int bufptr;
	unsigned int nidx;

	for (nidx=0;nidx<tntcount;nidx++)
		mymark[nidx]=0;


	bufptr=0;
	lsinit;
	rqinit;
	curavle=0;
	loope=0;
	curchartnode=prechartnode=0;
	filllattice();
	lookahead();
	chart[curchartnode].plst=chart[curchartnode].pled=-1;
	chart[curchartnode].chd=chart[curchartnode].ctl=-1;
//	addedge(0, 0, 0, NULL, NULL);
	lspush(ssym->sid);
	chart[0].expeclist[ssym->sid]=1;
	catetbl[ssym->sid]=NULL;
}

scan(){
	int catedim, i;

	/*choose the most probable prefix parse*/
	if (curchartnode>=1){
		qsrt(chart[prechartnode].plst+1, chart[prechartnode].pled);
		prbmaxprefix();
	}
	quicksrt(chart[prechartnode].plst+1, chart[prechartnode].pled);

	/*step forward*/
	currwentry=nextwentry;
	currdefs=nextdefs;
	accchartnode=prechartnode=curchartnode++;
	lookahead();

	chart[curchartnode].plst=chart[curchartnode].pled=curavle-1;

	for (i=0; (*currdefs)[i]<tcount; i++)
		enqedge(rulupbound, 0, prechartnode, NULL, NULL, (*currdefs)[i]);

	catedim=curchartnode*tntcount;
	for (i=0;i<catedim;i++)
		catetbl[i]=NULL;

	return 0;
}

comp(){
	edge_t *compedge, *prevedge;
	rulrol_struct  *qrr;
	pf_t *newpf;
	unsigned int cate, expecate;
	int epos=0;
	unsigned int rul;
	unsigned int rol;
	int ptr, lastptr, lastiniptr;
	int loc, prerr;
	int i;
	unsigned int nidx;
	int hd;
	int curcatedim;
	int eend;

	/*initialize the marks for prediction*/
	for (nidx=0;nidx<tntcount;nidx++)
		mymark[nidx]=0;

	while ((accchartnode>0) || (chart[0].chd>=0)){
		hd=chart[accchartnode].chd;
		
		/*dequeue at accchartnode*/
		cate=rq.queue[hd].cate;
		compedge=&(rq.queue[hd].ed);
		hd=chart[accchartnode].chd=rq.queue[hd].nxt;
		if (hd==-1)
			chart[accchartnode].ctl=-1;
		eend=chart[accchartnode].pled;

		if ((newpf=pfat(cate, accchartnode))!=NULL){
			/*add ambiguity*/
			sumsubpf(newpf, compedge);
		}
		else{
			/*fill in the qualified-roles-list*/
			
			loc=prerr=0;
			for (i=0; (*nextdefs)[i]<tcount; i++){
				for (qrr=rrr(cate, (*nextdefs)[i]);qrr!=NULL;qrr=qrr->nxt){
					loc=ROLPOS(qrr->rule, qrr->role);
					if (rrset[loc].prr==NULL){
						rrset[loc].prr=qrr;
						rrset[prerr].next=loc;
						prerr=loc;
					}
				}
			}
			

			/*examine the expected roles*/
			//epos=chart[accchartnode].plst+1;
			if (searchcompe(cate, &epos))
			do{
				prevedge=&edgepool[epos];
				rul=prevedge->rule;
				rol=(unsigned int)(prevedge->role+1);
				loc=ROLPOS(rul, rol);
				if (rrset[loc].prr){
					/*if this role is expected and qualified, add it*/
					/*new node can be added in the forest. only executed at the first time*/
					if (!newpf)
						sumsubpf(newpf=addpf(cate, accchartnode), compedge);

			//		newpf->refs++;
					if (rul>0){
						expecate=EXP(rul, rol);
						if (TOSHIFT(rul, rol)){

							/*rightmost not met yet, put into edgepool*/
							addedge(rul, rol, prevedge->origin, prevedge, newpf);
							if (!mymark[expecate]){
								/*mark the expected cates, for prediction*/
								lspush(expecate);
								mymark[expecate]=1;
							}
						}
						else
							/*rightmost of rhs met, enque for completion*/

							enqedge(rul, rol, prevedge->origin, prevedge, newpf, expecate);
					}
				}

			//	epos++;
			}while ((++epos<=eend) 
					&& (EXP(edgepool[epos].rule, edgepool[epos].role)==cate));

			/*clear the qulified-roles-list*/
		
			
			lastptr=lastiniptr=0;
			for (ptr=rrset[0].next;ptr!=-1;ptr=rrset[ptr].next){				
				rrset[lastptr].next=-1;
				lastptr=ptr;

				if (rrset[ptr].prr->role>1){
					rrset[ptr].prr=NULL;
				}
				else{
					rrset[lastiniptr].next=ptr;
					lastiniptr=ptr;
				}
			}

			//examine x.1 roles
			if (chart[accchartnode].expeclist[cate]){
				lastptr=0;
				for (ptr=rrset[0].next; ptr!=-1; ptr=rrset[ptr].next){
					rul=rrset[ptr].prr->rule;
					rol=rrset[ptr].prr->role;

					if ((rul==0)||(chart[accchartnode].expeclist[leftof(rul)])){

						if (!newpf)
							sumsubpf(newpf=addpf(cate, accchartnode), compedge);

						if (rul>0){
							expecate=EXP(rul, rol);
							if (TOSHIFT(rul, rol)){

								//rightmost not met yet, put into edgepool
								addedge(rul, rol, accchartnode, NULL, newpf);
								if (!mymark[expecate]){
									//mark the expected cates, for prediction
									lspush(expecate);
									mymark[expecate]=1;
								}
							}
							else
								//rightmost of rhs met, enque for completion

								enqedge(rul, rol, accchartnode, NULL, newpf, expecate);
						}
					}

				}
			}
							

			/*clear the qulified-roles-list*/
			
			lastptr=0;
			for (ptr=rrset[0].next;ptr!=-1;ptr=rrset[ptr].next){				

					rrset[ptr].prr=NULL;
					rrset[lastptr].next=-1;
				lastptr=ptr;
			}

			
		}

		/*spread from right to left*/
		if (chart[accchartnode].chd<0){
			curcatedim=(accchartnode+1)*tntcount;
			for (i=accchartnode*tntcount; i<curcatedim; i++){
				if (catetbl[i])
					if (catetbl[i]->prb<0)
						prbbranch(catetbl[i]);
			}

			while ((accchartnode>0)&&(chart[accchartnode].chd<0))
				accchartnode--;
		}
	}

	rqinit;
}

parses(){
  init();

  for (;!endofsntnce;prechartnode=curchartnode){
//	  printf("parsing at %d\n", curchartnode);
      if (!pred()){
         endofsntnce=0;
         releaseedges();
		 curavle=0;
		 pfroot=NULL;
		 nextwentry=NULL;
         return -1;
      }
      scan();
//	  if (nextwentry==NULL)
//		  break;
      comp();
  }

  pfroot=catetbl[ssym->sid];
  endofsntnce=0;
  releaseedges();


  fprintf(pfedgs, "%d\t%d\t%d\t%d\n", curavle, loope, npfs, endposofsntnce);
  curavle=0;
  loope=0;

  return 0;
}