ruleparser.java

It is the Speech recognition software. It is platform independent. To execute the source code,

                }
                for (int j=0; j<p.size(); j++) {
                    alts.addElement(p.elementAt(j));
                }
            }
            return alts;
        }
    
        /*
         * RULESEQUENCE
         */
        if (r instanceof RuleSequence) {
            RuleSequence rs = (RuleSequence) r;
            Rule rarry[] = rs.getRules();
            if ((rarry == null) || (rarry.length == 0)) {
                return null;
            }
            Vector p = parse(G,rarry[0],input,iPos);
            if (p == null) {
                return null;
            }
            Vector res = new Vector();
            //System.out.println("seq sz" + p.size());
            for (int j=0; j<p.size(); j++) {
                //System.out.println("seq  " + p.elementAt(j));
                tokenPos tp = (tokenPos)p.elementAt(j);
                Rule rule0 = (Rule)p.elementAt(j);
                int nPos = tp.getPos();
                if (rarry.length == 1) {
                    if (rule0 instanceof emptyToken) { 
                        res.addElement(rule0); 
                        continue; 
                    }
                    jsgfRuleSequence rp = null;
                    Rule ra[] = new Rule[1];
                    ra[0] = rule0;
                    try {
                        rp = new jsgfRuleSequence(ra);
                        rp.setPos(tp.getPos());
                        res.addElement(rp);
                    }
                    catch(IllegalArgumentException e) {
                        System.out.println(e);
                    }
                    continue;
                }
                Rule nra[] = new Rule[rarry.length-1];
                System.arraycopy(rarry,1,nra,0,nra.length);
                RuleSequence nrs = new RuleSequence(nra);
                //System.out.println("2parse " + nPos + nrs);
                Vector q = parse(G,nrs,input,nPos);
                if (q == null) {
                    continue;
                }
                //System.out.println("2 seq sz " + p.size());
                for (int k=0; k<q.size(); k++) {
                    //System.out.println("2 seq  " + q.elementAt(k));
                    Rule r1 = (Rule) q.elementAt(k);
                    Rule ra[]=null;
                    tokenPos tp1 = (tokenPos) q.elementAt(k);
                    //System.out.println("rule0 " + rule0);
                    //System.out.println("r1 " + r1);
                    if (r1 instanceof emptyToken) { 
                        res.addElement(rule0); 
                        continue; 
                    }  
                    if (rule0 instanceof emptyToken) { 
                        res.addElement(r1); 
                        continue; 
                    }
                    if (r1 instanceof RuleSequence) {
                        RuleSequence r2 = (RuleSequence)r1;
                        Rule r2r[] = r2.getRules();
                        ra = new Rule[r2r.length+1];
                        ra[0]= rule0;
                        System.arraycopy(r2r,0,ra,1,r2r.length);
                    } else {
                        ra = new Rule[2];
                        ra[0]=rule0;
                        ra[1]=r1;
                    }
                    jsgfRuleSequence rp = null;
                    try {
                        rp = new jsgfRuleSequence(ra);
                        rp.setPos(tp1.getPos());
                        res.addElement(rp);
                    } catch(IllegalArgumentException e) {
                        System.out.println(e);
                    }
                }
            }
            return res;
        }
    
        /*
         * TAGS
         */
        if (r instanceof RuleTag) {
            RuleTag rtag = (RuleTag)r;
            String theTag = rtag.getTag();
            //System.out.println("tag="+theTag);
            Vector p = parse(G,rtag.getRule(),input,iPos);
            if (p == null) {
                return null;
            }
            Vector t = new Vector();
            for (int j=0; j<p.size(); j++) {
                tokenPos tp = (tokenPos) p.elementAt(j);
                if (tp instanceof emptyToken) { 
                    t.addElement(tp); 
                    continue; 
                }; 
                jsgfRuleTag tag = new jsgfRuleTag((Rule)tp,theTag);
                tag.setPos(tp.getPos());
                t.addElement(tag);
            }
            return t;
        }
    
        //
        // RULECOUNT (e.g. [], *, or + )
        //
        if (r instanceof RuleCount) {
            RuleCount rc = (RuleCount)r;
            int rcount = rc.getCount();
            emptyToken empty = new emptyToken();
            empty.setPos(iPos);
            Vector p = parse(G,rc.getRule(),input,iPos);
            if (p == null) {
                if (rcount == RuleCount.ONCE_OR_MORE) return null;
                Vector v = new Vector();
                v.addElement(empty);
                return v;
            }
            if (rcount != RuleCount.ONCE_OR_MORE) {
                p.addElement(empty);
            }
            if (rcount == RuleCount.OPTIONAL) {
                return p;
            }
            for (int m=2; m<=input.length-iPos; m++) {
                Rule ar[] = new Rule[m];
                for (int n=0; n<m; n++) {
                    ar[n]=rc.getRule();
                }
                RuleSequence rs1 = new RuleSequence(ar);
                Vector q = parse(G,rs1,input,iPos);
                if (q == null) {
                    return p;
                }
                for (int z=0; z<q.size(); z++) {
                    p.addElement(q.elementAt(z));
                }
            }
            return p;
        }
    
        System.out.println("ERROR UNKNOWN OBJECT " + r);
        return null;
    }

    /*
     * tokenize a string
     */
    static String []tokenize(String text) {
        StringTokenizer st = new StringTokenizer(text);
        int size = st.countTokens();
        String res[] = new String[size];
        int i=0;
        while (st.hasMoreTokens()) {
            res[i++] = st.nextToken().toLowerCase();
        }
        return res;
    }

    /* interface for keeping track of where a token occurs in the
     * tokenized input string
     */
    interface tokenPos {
        public int getPos();
        public void setPos(int i);
    }

    /* extension of RuleToken with tokenPos interface */
    class jsgfRuleToken extends RuleToken implements tokenPos {
        int iPos = 0;
        public jsgfRuleToken(String x) { super(x); }
        public int  getPos() { return iPos; }
        public void setPos(int i) { iPos = i; }
    }

    class emptyToken extends jsgfRuleToken {
        public emptyToken() { super("EMPTY"); }
    }

    /* extension of RuleTag with tokenPos interface */
    class jsgfRuleTag extends RuleTag implements tokenPos {
        int iPos = 0;
        public jsgfRuleTag(Rule r, String x) { super(r,x); }
        public int getPos() { return iPos; }
        public void setPos(int i) { iPos = i; }
    }

    /* extension of RuleSequence with tokenPos interface */
    class jsgfRuleSequence extends RuleSequence implements tokenPos {
        int iPos = 0;
        public jsgfRuleSequence(Rule rules[]) { super(rules); }
        public int getPos() { return iPos; }
        public void setPos(int i) { iPos = i; }
    }


    /* extension of RuleParse with tokenPos interface */
    class jsgfRuleParse extends RuleParse implements tokenPos {
        int iPos = 0;
        public jsgfRuleParse() { super(); }
        public jsgfRuleParse(RuleName rn,Rule r) throws IllegalArgumentException { 
            super(rn,r);
        }
        public int getPos() { return iPos; }
        public void setPos(int i) { iPos = i; }
    }
  


}