/* OGDL, Ordered Graph Data Language 

 * (c) R.Veen, 2002-2006.

 * License: see http://ogdl.org/ (similar to zlib)

 */

package ogdl;

import java.io.IOException;

import java.io.Reader;

import ogdl.parser.IParserHandler;

/** Parser for the OGDL text format

    Non recursive parser. Doesn't need a special Reader.

        <ul>

        <li>All functions return boolean if the item exists, false if not. If false, they don't modify anything.

        <li>Relevant functions send an event thru the ParserEvent object.

        <li>Uses a special ParserReader, not a java.io.PushBackReader.

        <li>Stores locally one leaf/string to process escape sequences. The minimum content element returned

             is one leaf (block or not).

        <li>Leaf type is not preserved: simple, quoted or blocks are all returned as 

        </ul>

    date: Nov 2002.

    $Id: OgdlParser.java,v 1.8 2005/06/06 16:10:53 tbryan Exp $

*/

public final class OgdlParser

{

    public final static int CONTENT = 1;        /* primary events, content related */

    public final static int FORMAT = 2;         /* secondary events, format related */

    protected Reader r;

    int line=1, level=-1, groups[], lineInd[], lineLevel, groupLevel, groupIndex=0;

    int savedSpaces = 0;

    boolean savedNewline = false;

    private IParserHandler event;

    /* leaf buffer, for first level string processing: escape sequences */

    StringBuffer sb;

    public OgdlParser (Reader r, IParserHandler event) throws Exception

    {

        this.r = r;

        this.event = event;

        sb = new StringBuffer();

        groups = new int[64];

        lineInd = new int[64];

    }

    /* XXX: here an efficient string reader ... */

    /** space = char_space+ 

        Returns the number of spaces. Mixing of tabs and spaces is not

        allowed as indentation, but not checked yet.

    */

    public int space() throws IOException

    {

        int i;

        if ( savedSpaces != 0 ) {

            i = savedSpaces;

            savedSpaces = 0;

            return i;

        }

        i = 0;

        while ( Characters.is( read(), Characters.SPACE ) )

            i++;

        unread();        

        return i;        

    }

    /** newline ::= ( CR LF) | CR | LF */

    public boolean newline() throws IOException

    {

        line++;

        if ( savedNewline ) {

            savedNewline = false;

            return true;

        }

        int c = read();

        if ( c == '\r' ) {

            c = read();

            if ( c != '\n' )

                unread();

            return true;

        }

        else if ( c == '\n' )

            return true;

        line--;

        unread();

        return false;

    }

    /** eos ::= end of stream (no more chars)  */

    public boolean eos() throws IOException

    {

        int c = read();

        unread();

        return c == -1 || c == '\f' ? true: false;

    }    

    /** word

     */

    public boolean word() throws IOException

    {

        int i = 0, c;

        sb.setLength(0);

        while ( Characters.is( c=read(), Characters.WORD ) ) {

            sb.append((char) c);

            i++;         

        }

        unread();

        return i>0 ? true:false;

    }

    public boolean comment() throws IOException

    {

        int i = 0, c;

        sb.setLength(0);

        if ( (c=read()) == '#' ) {

            sb.append((char) c);

            i++;         

            while ( ! Characters.is( c=read(), Characters.BREAK ) ) {

                sb.append((char) c);

                i++;         

            }

        }

        unread();

        return i>0 ? true:false;

    }

    /** separator

     */

    public boolean separator() throws IOException

    {

        int i = 0, c;

        sb.setLength(0);

        if ( Characters.isSeparator( (char) (c=read()) ) ) {

            sb.append((char) c);

            i++;         

        }

        else

            unread();

        return i>0 ? true:false;

    }

    public boolean quoted() throws IOException

    {

        int q = read();

        int c, cc=0;

        int skip=0;

        if ( q != '"' && q != '\'' ) {

            unread();

            return false; 

        }

        sb.setLength(0);

        while ( true ) {

            c = read();

            if ( c == -1 || ( c == q && cc != '\\' ) )

                break;

            if (skip > 0) {

                if ( Characters.isSpace((char) c) ) {

                    skip--;

                    cc = c;

                    continue;

                }

                else 

                    skip = 0;

            }

            sb.append((char) c);

            cc = c;

            if ( c == '\n' )

                skip = lineInd[level] + 1;

        }

        return true;

    }

    public boolean block() throws IOException

    {

        int c = read();

        int m,i;

        int ind=-1;

        if ( c != '\\' ) {

            unread();

            return false;

        }

        if ( !newline() ) 

            return false;           // loosing one char !

        sb.setLength(0);

        while (true) {

            m = space();

            if (m <= lineInd[lineLevel]) {

                if (newline())

                    sb.append('\n');

                else {

                    savedSpaces = m;

                    break;

                }

            }

            else {

                if (ind<0) ind = m;

                for (i=ind; i<m; i++)

                    sb.append(' ');

                while (true) {

                    c = read();

                    if ( c == -1 || c == '\n' ) {

                        sb.append('\n');

                        break;

                    }

                    sb.append((char)c);

                } 

                if (c == -1) 

                    break;

            }

        }

        return true;

    }

    public int node() throws IOException

    { 

        if (block()) {

            return -1;

        }

        if (!quoted() && !comment() && !word() && !separator())

            return 0;

        int len = sb.length();

        char c = len>0? sb.charAt(0): 0;

        if ( c == '(' ) {

            groups[groupIndex++] = level;

            event.event(FORMAT,level, "(");

            return 1;

        }

        else if ( c == ')' ) {

            groups[--groupIndex] = level;

            event.event(FORMAT,level, ")");

            return 1;

        }

        else if (c == ',') {

            // reset level to the first node of this line

            if (groupIndex==0)

                level=lineLevel;

            else

                level = groups[groupIndex-1];

            return 1;

        }

        else if (c == '#')

            return 1;

        if (len != 0) 

        level++;   

        return 1;

    }

    /** line() : space? ( node ( space node )* )? space? newline

       returns:

          0 : EOS

          1 : more

    */

    public boolean line() throws Exception

    {   

        int i = space();

        if ( newline() ) return true;

        if ( eos () )    return false;

        if ( level < 0 ) {

            lineInd[0]=i;

            lineLevel=0;

        }

        else if ( i > lineInd[lineLevel] ) {

            lineInd[++lineLevel] = i;

        }

        else if ( i < lineInd[lineLevel] ) {

            while (lineLevel != 0) {

                if ( i >= lineInd[lineLevel] )

                    break;

                lineLevel--;  

            }

        }

        level = lineLevel;

        while ( (i=node()) > 0) 

            space();

        if (i > 0) {        /* after a block don't eat spaces */

            space();

            newline();

        }

        if (eos()) 

            return false;

        return true;

    }

    /** parse ::= line* */

    public void parse() throws Exception

    {

        try {

            while ( line() ) ;

        }

        catch (SyntaxException e)

        {

            event.error(e,e.line);

        }

    }

    /* ----------------------------------------------------- 

       Small isolation layer.

    */

    boolean unGetFlag = false;

    int unChar;

    public void unread(int c)

    {

    	unGetFlag = true;

    	unChar = c;

    }    

    private int read() throws IOException

    {

        if (unGetFlag) {

            unGetFlag = false;

            return unChar;

        }

        return unChar = r.read();

    }

    private void unread()

    {

        unGetFlag = true;

    }

}