开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 组合框控件 > 查看源码
sntncepars.cpp
资源名称：ictprop.rar　[点击查看]
上传用户：tenhai
上传日期：2021-02-19
资源大小：492k
文件大小：18k
源码类别：

组合框控件

开发平台：

Visual C++

sntncepars.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "symbol.h"
  3. #include "rrtbl.h"
  4. #include "grmrgrph.h"
  5. #include "sntncelex.h"
  6. #include "sntncepars.h"
  7. #include "math.h"
  8. #define pfat(cate, from) catetbl[from*tntcount+cate]
  10. //#define DELTA 1e-10
  11. #define MAXSORTSTACK 50
  12. char *mymark;
  14. extern FILE *pfo;
  15. FILE *pfedgs;
  17. int interactive;
  18. chartnode_t chart[MAXCNODE];
  20. //unsigned int glbmaxsub=0;
  21. typedef struct range_t{
  22. int l;
  23. int r;
  24. }range_t;
  26. range_t rangestack[MAXSORTSTACK];
  27. rrset_struct *rrset=NULL;
  29. typedef struct rrrqentry_t{
  30.         edge_t ed;
  31.         unsigned int cate;
  32. int nxt;
  33. }rrqentry_t;
  35. typedef struct rrq_t{
  36.         rrqentry_t queue[MAXSQUE];
  37. int topptr;
  38. int botptr;
  39. }rrq_t;
  41. unsigned int *lstack;
  42. int lsptr;
  44. rrq_t rq;
  45. pf_t *pfroot=NULL, *pfhead=NULL;
  47. pf_t **catetbl;
  48. edge_t *edgepool;
  49. pf_t *trnodepool;
  51. int curavle=0;
  52. int loope=0;
  54. int npfs;
  56. pf_t *tokenpf;
  57. int cirflag;
  59. edge_t *pooledg;
  60. rrqentry_t *nre;
  62. int unacc[MAXCNODE];
  64. pf_t *addpf(unsigned int cate, int from){
  65.   int index;
  66.   pf_t *ppf;
  68.   index=from*tntcount+cate;
  70.   if ((ppf=catetbl[index])==NULL){
  71.      ppf=&trnodepool[npfs++];
  72.      //ppf=(pf_t *)malloc(sizeof(pf_t));
  73.      ppf->cate=cate;
  74.  ppf->litoramb.literal=NULL;
  75.      ppf->subpfs=NULL;
  76.   //   ppf->nxt=pfhead;
  77.  ppf->prb=0;
  78. //  ppf->refs=0;
  79.      pfhead=ppf;
  80.      catetbl[index]=ppf;
  81.   }
  83.   return ppf;
  84. }
  86. int sumsubpf(pf_t *pf, edge_t *compedge){
  87. double subprb=1.0;
  88. int solid=0;
  89. unsigned int cursub, pos, rlen;
  90. edge_t *pe;
  92. if (compedge->rule<=rulcount){
  94. rlen=rightlenof(compedge->rule);
  95. for (pe=compedge->prevedge; (pe!=NULL) ;pe=pe->prevedge)
  96. subprb*=pe->ppf->prb;
  97. subprb*=probof(compedge->rule);
  99. if (compedge->ppf->prb>0){
  100. subprb*=compedge->ppf->prb;
  101. solid=1;
  102. }
  104. if (-pf->prb<=subprb){
  105. if (pf->subpfs){
  106. if (!solid)
  107. if (((pf->litoramb.totalamb+1)%MAXAMB)==0){
  108. pf->subpfs=(subpf_t *)realloc(pf->subpfs, 
  109. (pf->litoramb.totalamb+1+MAXAMB)*sizeof(subpf_t));
  110. }
  111. }
  112. else{
  113. pf->subpfs=(subpf_t *)calloc(MAXAMB, sizeof(subpf_t));
  114. pf->subpfs[0].sublst=NULL;
  115. }
  117. if (solid){
  118. cursub=0;
  119. pf->subpfs[cursub].rulno=compedge->rule;
  121. if (!pf->subpfs[0].sublst){
  122. pf->subpfs[cursub].sublst=
  123. (pf_t **)calloc(MAXRLEN, sizeof(pf_t *));
  124. }
  125. }
  126. else{
  127. cursub=++pf->litoramb.totalamb;
  129. pf->subpfs[cursub].rulno=compedge->rule;
  130. pf->subpfs[cursub].sublst=
  131. (pf_t **)calloc(rlen, sizeof(pf_t *));
  132. }
  134. for (pos=rlen-1,pe=compedge;pe!=NULL;pos--,pe=pe->prevedge){
  135. pf->subpfs[cursub].sublst[pos]=pe->ppf;
  136. }
  138. if (!solid)
  139. subprb*=-compedge->ppf->prb;
  141. if (-pf->prb<subprb){
  142. pf->prb=-subprb;
  143. }
  144. }
  146. }
  147. else{
  148. pf->litoramb.literal=currwentry->word;
  149. pf->prb=1.0;
  150. }
  152. return 0;
  153. }
  155. releasepf(pf_t *ppf){
  156.   unsigned int c;
  158.   if (ppf->subpfs){
  159. for (c=0;c<=ppf->litoramb.totalamb;c++)
  160. if (ppf->subpfs[c].sublst)
  161. free(ppf->subpfs[c].sublst);
  162. free(ppf->subpfs);
  163.   }
  164.   //free(ppf);
  165.   return 0;
  166. }
  168. releasewholepf(){
  169. int i;
  171. for (i=0; i<npfs; i++){
  172. releasepf(&trnodepool[i]);
  173. }
  174. /*
  175. int nonz=0;
  177.   pf_t *ppf, *qpf; 
  179.   
  180.     for (qpf=ppf=pfhead;ppf!=NULL;){
  181.            if (ppf==pfhead){
  182.               pfhead=qpf=ppf->nxt;
  183.   if (ppf->refs==0)
  184.   nonz++;
  185.               releasepf(ppf);
  186.               ppf=pfhead;
  187.            }
  188.            else{
  189.               qpf->nxt=ppf->nxt;
  190.   if (ppf->refs==0)
  191.   nonz++;
  192.               releasepf(ppf);
  193.               ppf=qpf->nxt;
  194.            }
  195.          //  npfs--;
  196.     }
  198. pfhead=NULL;
  200. printf("n%fn", (double)nonz/(double)npfs);
  201. */
  202. npfs=0;
  203. return 0;
  204. }
  206. addchartnode(){
  207.    int i;
  208. unsigned int j;
  209.    
  210.    for (i=0; i<MAXCNODE; i++){
  211.    chart[i].numb=0;
  212.    chart[i].pled=-1;
  213.    chart[i].plst=-1;
  214.    chart[i].chd=-1;
  215.    chart[i].ctl=-1;
  216.    chart[i].expeclist=(char *)malloc(sizeof(char)*tntcount);
  217.    for (j=0; j<tntcount; j++){
  218.    chart[i].expeclist[j]=0;
  219.    }
  220.    }
  221.    return 0;
  222. }
  224. quicksrt(int l, int r){
  225. int i,j;
  226. edge_t ed;
  227. int rstptr;
  229. rangestack[rstptr=0].l=l;
  230. rangestack[rstptr].r=r;
  232. while (rstptr>=0){
  233. l=rangestack[rstptr].l;
  234. r=rangestack[rstptr].r;
  235. rstptr--;
  237. st:
  238. if (l>=r)
  239. continue;
  241. i=l;j=r;
  242. ed=edgepool[i];
  244. while (!(i==j)){
  245. while ((j>i) && ( EXP(edgepool[j].rule, edgepool[j].role)>EXP(ed.rule, ed.role)))
  246. j--;
  247. if (i<j)
  248. edgepool[i++]=edgepool[j];
  250. while ((j>i) && ( EXP(edgepool[i].rule, edgepool[i].role)<EXP(ed.rule, ed.role)))
  251. i++;
  252. if (i<j)
  253. edgepool[j--]=edgepool[i];
  254. }
  256. edgepool[i]=ed;
  257. i++;j--;
  259. if ((r-i)>(j-l)){
  260. rstptr++;
  261. rangestack[rstptr].l=i; 
  262. rangestack[rstptr].r=r;
  263. r=j;
  264. goto st;
  265. }
  266. else{
  267. rstptr++;
  268. rangestack[rstptr].l=l;
  269. rangestack[rstptr].r=j;
  270. l=i;
  271. goto st;
  272. }
  273. }
  275. return 0;
  276. }
  278. qsrt(int l, int r){
  279. int qi,qj;
  280. edge_t ed;
  281. edge_t *edg;
  282. int flagO, flagL;
  283. int rstptr;
  285. rangestack[rstptr=0].l=l;
  286. rangestack[rstptr].r=r;
  288. while (rstptr>=0){
  289. l=rangestack[rstptr].l;
  290. r=rangestack[rstptr].r;
  291. rstptr--;
  293. start:
  294. if (l>=r)
  295. continue;
  296. qi=l;qj=r;
  298. ed=edgepool[qi];
  299. while (!(qi==qj)){
  300. edg=&edgepool[qj];
  301. while ( (qj>qi) &&
  302. ( ((flagO=edg->origin-ed.origin)>0) ||
  303. ( !flagO && 
  304. ( ((flagL=leftof(edg->rule)-leftof(ed.rule))>0) ||
  305. ( !flagL && 
  306. (PST(edg->rule, edg->role)>PST(ed.rule, ed.role))
  307. // RGT(edg->rule, edg->role, ed.rule, ed.role)
  308. )
  309. )
  310. )
  311. )
  312. )
  313. edg=&edgepool[--qj];
  315. if (qi<qj)
  316. edgepool[qi++]=edgepool[qj];
  318. edg=&edgepool[qi];
  319. while ( (qj>qi) &&
  320. ( ((flagO=ed.origin-edg->origin)>0) ||
  321. ( !flagO && 
  322. ( ((flagL=leftof(ed.rule)-leftof(edg->rule))>0) ||
  323. ( !flagL && 
  324. (PST(ed.rule, ed.role)>PST(edg->rule, edg->role))
  325. // RGT(ed.rule, ed.role, edg->rule, edg->role)
  326. )
  327. )
  328. )
  329. )
  330. )
  331. edg=&edgepool[++qi];
  333. if (qi<qj)
  334. edgepool[qj--]=edgepool[qi];
  335. }
  337. edgepool[qi]=ed;
  339. qi++;qj--;
  340. if ((r-qi)>(qj-l)){
  341. rstptr++;
  342. rangestack[rstptr].l=qi; 
  343. rangestack[rstptr].r=r;
  344. r=qj;
  345. goto start;
  346. }
  347. else{
  348. rstptr++;
  349. rangestack[rstptr].l=l;
  350. rangestack[rstptr].r=qj;
  351. l=qi;
  352. goto start;
  353. }
  354. }
  355.  
  356.   return 0;
  357. }
  360. releasechart(){
  361.   int p;
  363.   for (p=0;p<MAXCNODE;p++){
  364.   chart[p].pled=chart[p].plst=-1;
  365.   chart[p].chd=chart[p].ctl=-1;
  366.   free(chart[p].expeclist);
  367.   chart[p].expeclist=NULL;
  368.   }
  369.   return 0;
  370. }
  372. releaseedges(){
  373.   int p;
  374.   unsigned int q;
  376.   for (p=0;(chart[p].numb!=0); p++){
  377.   chart[p].numb=0;
  378.   for (q=0; q<tntcount; q++){
  379.   chart[p].expeclist[q]=0;
  380.   }
  381.   }
  383. }
  385. searchcompe(unsigned int cate, int *pos){
  386.   int bottom, middle, top;
  388.   bottom=chart[accchartnode].plst+1;
  389.   top=chart[accchartnode].pled;
  391.   if (top<bottom){
  392.   *pos=top;
  393.   return 0;
  394.   }
  395.   while (top>bottom){
  396.     middle=(top+bottom)/2;
  397.     if (cate>EXP(edgepool[middle].rule, edgepool[middle].role))
  398.        bottom=middle+1;
  399.     else
  400.        top=middle;
  401.   }
  403.  /*
  404.   if (top==bottom){
  405.      if (cate>EXP(edgepool[top].rule, edgepool[top].role))
  406.         bottom++;
  407.   } 
  409.   *pos=bottom;
  410.   */
  411.   *pos=top;
  412.   if ( 
  413.      !(cate==EXP(edgepool[*pos].rule, edgepool[*pos].role)))
  414.      return 0;
  415.   else
  416.      return 1;
  418. }
  420. #define addexpec(expec){
  421. chart[curchartnode].expeclist[expec]=1;
  422. }
  424. #define addedge(dumrule, dumrole, dumorigin, dumprevedge, dumppf){
  425. pooledg=&edgepool[curavle++];
  426. pooledg->rule=dumrule;
  427. pooledg->role=dumrole;
  428. pooledg->origin=dumorigin;
  429. pooledg->prevedge=dumprevedge;
  430. pooledg->ppf=dumppf;
  432. if (dumrole==0)
  433. loope++;
  434. chart[curchartnode].numb++;
  435. chart[curchartnode].pled++;
  436. }
  438. #define enqedge(dumrule, dumrole, dumorigin, dumprevedge, dumppf, dumcate){
  439. nre=&rq.queue[++rq.topptr];
  440. nre->nxt=-1;
  441. nre->cate=dumcate;
  442. nre->ed.rule=dumrule;
  443. nre->ed.role=dumrole;
  444. nre->ed.origin=dumorigin;
  445. nre->ed.prevedge=dumprevedge;
  446. nre->ed.ppf=dumppf;
  448. (chart[dumorigin].chd==-1)?(chart[dumorigin].chd=rq.topptr):
  449. (rq.queue[chart[dumorigin].ctl].nxt=rq.topptr);
  450. chart[dumorigin].ctl=rq.topptr;
  451. }
  454. #define rqinit {rq.topptr=rq.botptr=-1;}
  456. #define lsempty (lsptr==-1)
  458. #define lsinit lsptr=-1;
  460. #define lspush(catee) lstack[++lsptr]=catee;
  462. #define lspop(pcate) pcate=lstack[lsptr--];
  464. double prbbranch(pf_t *ppf){
  465.   subpf_t subpf;
  466.   int sublen, curpos;
  467.   unsigned int amb, vp=0;
  468.   double subprb, maxprb;
  469.   
  471.   if (ppf->subpfs==NULL){
  472.   ppf->prb=1.0;
  473.       return 1.0;
  474.   }
  476.   maxprb=-1.0;
  477.   ppf->prb=0;
  478.   for (amb=0; amb<=ppf->litoramb.totalamb; amb++){
  479.       subprb=1.0;
  481.       subpf=ppf->subpfs[amb];
  483.   if (subpf.sublst==NULL)
  484.   continue;
  485.       sublen=rightlenof(subpf.rulno);
  486.       for (curpos=0;curpos<sublen;curpos++){
  487.   double x=subpf.sublst[curpos]->prb;
  489.   if ((x==0)&&(tokenpf)){
  490.   cirflag=1;
  491.   subprb=0;
  492.   continue;
  493.   }
  495.      if ((sublen==1)&&(x<0)&&(!tokenpf))
  496. tokenpf=ppf;
  498.           subprb*=(x>=0)?x:prbbranch(subpf.sublst[curpos]);
  500.   if (ppf==tokenpf){
  501.      tokenpf=NULL;
  502. cirflag=0;
  503.   }
  506.       }
  507.   subprb*=probof(subpf.rulno);
  508.       if (subprb>=maxprb){
  509.   maxprb=subprb;
  510.   vp=amb;
  511.   }
  512.   }
  514.   if (!cirflag){
  515. ppf->prb=maxprb;
  517. for (amb=0; amb<=ppf->litoramb.totalamb; amb++){
  518.   if (amb==vp)
  519.   continue;
  520. if (ppf->subpfs[amb].sublst){
  521. free(ppf->subpfs[amb].sublst);
  522. ppf->subpfs[amb].sublst=NULL;
  523. }
  524. }
  525. subpf=ppf->subpfs[vp];
  526. free(ppf->subpfs);
  527. ppf->subpfs=(subpf_t *)malloc(sizeof(subpf_t));
  528. ppf->subpfs[0]=subpf;
  529. ppf->litoramb.totalamb=0;
  531. return ppf->prb;
  532.   }
  533.   else{
  534.   ppf->prb=-1.0;
  535.   return maxprb;
  536.   }
  538. }
  540. prbmaxprefix(){
  541. int bottom, top, curbot, curtop, curedp;
  542. double curmaxprb, curprb;
  543. edge_t *pe, *ptop, *pcur;
  544. double x;
  549. bottom=chart[curchartnode].plst+1;
  550. top=chart[curchartnode].pled;
  553. for (curtop=curbot=bottom; curtop<=top;){
  555. curmaxprb=-1;
  556. curedp=curtop;
  557. do{
  558. for (x=1.0, pe=&edgepool[curtop]; pe!=NULL; pe=pe->prevedge)
  559. x*=pe->ppf->prb;
  561. curprb=x*=probof(edgepool[curtop].rule);
  563. if (curprb>curmaxprb){
  564. /*
  565. if (curedp!=curtop)
  566. if (edgepool[curedp].ppf)
  567. edgepool[curedp].ppf->refs--;
  568. */
  569. curedp=curtop;
  570. curmaxprb=curprb;
  571. }
  572. /*
  573. else
  574. if (edgepool[curedp].ppf)
  575. edgepool[curtop].ppf->refs--;
  576. */
  577. curtop++;
  578. }while ((curtop<=top)&&
  579. ((ptop=&edgepool[curtop])->origin==(pcur=&edgepool[curedp])->origin)&&
  580. (leftof(ptop->rule)==leftof(pcur->rule))&&
  581. (PST(ptop->rule, ptop->role)==PST(pcur->rule, pcur->role))
  582. //REQ(ptop->rule, ptop->role, pcur->rule, pcur->role)
  583. );
  585. edgepool[curbot++]=edgepool[curedp];
  586. }
  588. chart[curchartnode].pled=curbot-1;
  589. curavle=curbot;
  591. bottom=chart[curchartnode].plst+1;
  592. top=chart[curchartnode].pled;
  595. return 0;
  596. }
  598. pred(){
  599. int match=0;
  600. unsigned int cate, expecate;
  601. rulrol_struct  *qrr;
  602. int loc, prerr;
  603. int ptr,lastptr;
  604. unsigned int rul;
  605. unsigned int rol;
  606. int i;
  608. if ((*nextdefs)[0]==0)
  609. return 0;
  611. while (!lsempty){
  612. lspop(cate);
  613. if ((cate<tcount)){
  614. if (!match)
  615.         for (i=0; (*nextdefs)[i]<tcount; i++){
  616. if (cate==(*nextdefs)[i]){
  617. match=1;
  618. break;
  619. }
  620. }
  621. }
  622. else{
  623. prerr=0;
  624. //merge rrlist
  625. for (i=0; (*nextdefs)[i]<tcount; i++){
  626. for (qrr=lrr(cate, (*nextdefs)[i]); qrr!=NULL; qrr=qrr->nxt){
  627. loc=ROLPOS(qrr->rule, qrr->role);
  628. if (!rrset[loc].prr){
  629. rrset[loc].prr=qrr;
  630. rrset[prerr].next=loc;
  631. prerr=loc;
  632. }
  633. }
  634. }
  636. lastptr=0;
  638. if ((ptr=rrset[0].next)!=-1)
  639. match=1;
  641. for (;ptr!=-1;ptr=rrset[ptr].next){
  642. rul=rrset[ptr].prr->rule;
  643. rol=rrset[ptr].prr->role;
  645. // addedge(rul, rol, curchartnode, NULL, NULL);
  646. expecate=EXP(rul, rol);
  647. addexpec(expecate);
  648. addexpec(leftof(rul));
  649. if (expecate>=tcount && !mymark[expecate]){
  650. lspush(expecate);
  651. mymark[expecate]=1;
  652. }
  653. rrset[ptr].prr=NULL;
  654. rrset[lastptr].next=-1;
  655. lastptr=ptr;
  656. }
  657. }
  658. }
  660. lsinit;
  661. return match;
  662. }
  664. init(){
  665. extern int bufptr;
  666. unsigned int nidx;
  668. for (nidx=0;nidx<tntcount;nidx++)
  669. mymark[nidx]=0;
  672. bufptr=0;
  673. lsinit;
  674. rqinit;
  675. curavle=0;
  676. loope=0;
  677. curchartnode=prechartnode=0;
  678. filllattice();
  679. lookahead();
  680. chart[curchartnode].plst=chart[curchartnode].pled=-1;
  681. chart[curchartnode].chd=chart[curchartnode].ctl=-1;
  682. // addedge(0, 0, 0, NULL, NULL);
  683. lspush(ssym->sid);
  684. chart[0].expeclist[ssym->sid]=1;
  685. catetbl[ssym->sid]=NULL;
  686. }
  688. scan(){
  689. int catedim, i;
  691. /*choose the most probable prefix parse*/
  692. if (curchartnode>=1){
  693. qsrt(chart[prechartnode].plst+1, chart[prechartnode].pled);
  694. prbmaxprefix();
  695. }
  696. quicksrt(chart[prechartnode].plst+1, chart[prechartnode].pled);
  698. /*step forward*/
  699. currwentry=nextwentry;
  700. currdefs=nextdefs;
  701. accchartnode=prechartnode=curchartnode++;
  702. lookahead();
  704. chart[curchartnode].plst=chart[curchartnode].pled=curavle-1;
  706. for (i=0; (*currdefs)[i]<tcount; i++)
  707. enqedge(rulupbound, 0, prechartnode, NULL, NULL, (*currdefs)[i]);
  709. catedim=curchartnode*tntcount;
  710. for (i=0;i<catedim;i++)
  711. catetbl[i]=NULL;
  713. return 0;
  714. }
  716. comp(){
  717. edge_t *compedge, *prevedge;
  718. rulrol_struct  *qrr;
  719. pf_t *newpf;
  720. unsigned int cate, expecate;
  721. int epos=0;
  722. unsigned int rul;
  723. unsigned int rol;
  724. int ptr, lastptr, lastiniptr;
  725. int loc, prerr;
  726. int i;
  727. unsigned int nidx;
  728. int hd;
  729. int curcatedim;
  730. int eend;
  732. /*initialize the marks for prediction*/
  733. for (nidx=0;nidx<tntcount;nidx++)
  734. mymark[nidx]=0;
  736. while ((accchartnode>0) || (chart[0].chd>=0)){
  737. hd=chart[accchartnode].chd;
  739. /*dequeue at accchartnode*/
  740. cate=rq.queue[hd].cate;
  741. compedge=&(rq.queue[hd].ed);
  742. hd=chart[accchartnode].chd=rq.queue[hd].nxt;
  743. if (hd==-1)
  744. chart[accchartnode].ctl=-1;
  745. eend=chart[accchartnode].pled;
  747. if ((newpf=pfat(cate, accchartnode))!=NULL){
  748. /*add ambiguity*/
  749. sumsubpf(newpf, compedge);
  750. }
  751. else{
  752. /*fill in the qualified-roles-list*/
  754. loc=prerr=0;
  755. for (i=0; (*nextdefs)[i]<tcount; i++){
  756. for (qrr=rrr(cate, (*nextdefs)[i]);qrr!=NULL;qrr=qrr->nxt){
  757. loc=ROLPOS(qrr->rule, qrr->role);
  758. if (rrset[loc].prr==NULL){
  759. rrset[loc].prr=qrr;
  760. rrset[prerr].next=loc;
  761. prerr=loc;
  762. }
  763. }
  764. }
  767. /*examine the expected roles*/
  768. //epos=chart[accchartnode].plst+1;
  769. if (searchcompe(cate, &epos))
  770. do{
  771. prevedge=&edgepool[epos];
  772. rul=prevedge->rule;
  773. rol=(unsigned int)(prevedge->role+1);
  774. loc=ROLPOS(rul, rol);
  775. if (rrset[loc].prr){
  776. /*if this role is expected and qualified, add it*/
  777. /*new node can be added in the forest. only executed at the first time*/
  778. if (!newpf)
  779. sumsubpf(newpf=addpf(cate, accchartnode), compedge);
  781. // newpf->refs++;
  782. if (rul>0){
  783. expecate=EXP(rul, rol);
  784. if (TOSHIFT(rul, rol)){
  786. /*rightmost not met yet, put into edgepool*/
  787. addedge(rul, rol, prevedge->origin, prevedge, newpf);
  788. if (!mymark[expecate]){
  789. /*mark the expected cates, for prediction*/
  790. lspush(expecate);
  791. mymark[expecate]=1;
  792. }
  793. }
  794. else
  795. /*rightmost of rhs met, enque for completion*/
  797. enqedge(rul, rol, prevedge->origin, prevedge, newpf, expecate);
  798. }
  799. }
  801. // epos++;
  802. }while ((++epos<=eend) 
  803. && (EXP(edgepool[epos].rule, edgepool[epos].role)==cate));
  805. /*clear the qulified-roles-list*/
  808. lastptr=lastiniptr=0;
  809. for (ptr=rrset[0].next;ptr!=-1;ptr=rrset[ptr].next){
  810. rrset[lastptr].next=-1;
  811. lastptr=ptr;
  813. if (rrset[ptr].prr->role>1){
  814. rrset[ptr].prr=NULL;
  815. }
  816. else{
  817. rrset[lastiniptr].next=ptr;
  818. lastiniptr=ptr;
  819. }
  820. }
  822. //examine x.1 roles
  823. if (chart[accchartnode].expeclist[cate]){
  824. lastptr=0;
  825. for (ptr=rrset[0].next; ptr!=-1; ptr=rrset[ptr].next){
  826. rul=rrset[ptr].prr->rule;
  827. rol=rrset[ptr].prr->role;
  829. if ((rul==0)||(chart[accchartnode].expeclist[leftof(rul)])){
  831. if (!newpf)
  832. sumsubpf(newpf=addpf(cate, accchartnode), compedge);
  834. if (rul>0){
  835. expecate=EXP(rul, rol);
  836. if (TOSHIFT(rul, rol)){
  838. //rightmost not met yet, put into edgepool
  839. addedge(rul, rol, accchartnode, NULL, newpf);
  840. if (!mymark[expecate]){
  841. //mark the expected cates, for prediction
  842. lspush(expecate);
  843. mymark[expecate]=1;
  844. }
  845. }
  846. else
  847. //rightmost of rhs met, enque for completion
  849. enqedge(rul, rol, accchartnode, NULL, newpf, expecate);
  850. }
  851. }
  853. }
  854. }
  857. /*clear the qulified-roles-list*/
  859. lastptr=0;
  860. for (ptr=rrset[0].next;ptr!=-1;ptr=rrset[ptr].next){
  862. rrset[ptr].prr=NULL;
  863. rrset[lastptr].next=-1;
  864. lastptr=ptr;
  865. }
  868. }
  870. /*spread from right to left*/
  871. if (chart[accchartnode].chd<0){
  872. curcatedim=(accchartnode+1)*tntcount;
  873. for (i=accchartnode*tntcount; i<curcatedim; i++){
  874. if (catetbl[i])
  875. if (catetbl[i]->prb<0)
  876. prbbranch(catetbl[i]);
  877. }
  879. while ((accchartnode>0)&&(chart[accchartnode].chd<0))
  880. accchartnode--;
  881. }
  882. }
  884. rqinit;
  885. }
  887. parses(){
  888.   init();
  890.   for (;!endofsntnce;prechartnode=curchartnode){
  891. //   printf("parsing at %dn", curchartnode);
  892.       if (!pred()){
  893.          endofsntnce=0;
  894.          releaseedges();
  895.  curavle=0;
  896.  pfroot=NULL;
  897.  nextwentry=NULL;
  898.          return -1;
  899.       }
  900.       scan();
  901. //   if (nextwentry==NULL)
  902. //   break;
  903.       comp();
  904.   }
  906.   pfroot=catetbl[ssym->sid];
  907.   endofsntnce=0;
  908.   releaseedges();
  911.   fprintf(pfedgs, "%dt%dt%dt%dn", curavle, loope, npfs, endposofsntnce);
  912.   curavle=0;
  913.   loope=0;
  915.   return 0;
  916. }