###########################################################################
# cgkit - Python Computer Graphics Kit
# Copyright (C) 2004 Matthias Baas (baas@ira.uka.de)
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
# cgkit homepage: http://cgkit.sourceforge.net
###########################################################################
# $Id: glslangparams.py,v 1.2 2006/04/12 11:52:09 mbaas Exp $

"""Extract shader parameters from an OpenGL shader source file.
"""

import sys, copy
import StringIO
import cgkit.glslangtokenize as glslangtokenize
import cgkit.simplecpp as simplecpp
import cgkit.slparams as slparams
from cgkit.glslangtokenize import WHITESPACE, NAME, NUMBER, STRING, NEWLINE, OPERATOR, CHARACTER, TYPE, QUALIFIER

class GLSLangParseError(Exception):
    pass

# _GLSLangParser
class _GLSLangParser:
    """Extract variables from a glslang shader.
    """
    
    def __init__(self, file, structs=None):
        """Constructor.

        fils is a file-like object.
        structs is a dictionary containing the 'predefined' structs.
        This is used internally when the contents of a struct is
        recursively parsed.
        """

        # The following lists receive the result:

        # Contains 2-tuples (type, identifier)
        self.attribute = []
        # Contains 3-tuples (type, identifier, arraysize)
        self.varying = []
        # Contains 5-tuples (type, identifier, arraysize, structname, struct)
        self.uniform = []
        # Contains 5-tuples (type, identifier, arraysize, structname, struct)
        self.const = []
        # Contains 5-tuples (type, identifier, arraysize, structname, struct)
        self.other = []

        # file
        self.file = file
        # Current state
        self.state = self.initialState
        
        # Current qualifier
        self.qualifier = None
        # Current type
        self.type = None
        # Identifier
        self.identifier = None
        # String with the array size
        self.arraysize = None
        # Struct name
        self.structname = None
        self.struct = None

        self.named_structs = {}
        if structs!=None:
            self.named_structs = copy.deepcopy(structs)

        # Number of open parentheses
        self.openparen = 0

        # The contents of a struct as a string
        # (for calling the parser again on this)
        self.structcontents = ""
        

    def read(self):
        """Read the file.
        """
        glslangtokenize.tokenize(self.file.readline, self.tokeater)

    def tokeater(self, type, s, start, end, line, filename):
        """Token eater.

        This method skips whitespace and newlines and calls the
        current state method.
        """
        if type in [WHITESPACE, NEWLINE]:
            return

        self.state(type, s, start, end, line, filename)

    def switchState(self, state):
        """Switch to a different state.

        state is a callable.
        """
        self.state = state

    def variable(self):
        """Store a result variable.

        This method is called by the states whenever all information for
        a variable has been read.
        """
        if self.qualifier=="attribute":
            self.attribute.append((self.type, self.identifier))
        elif self.qualifier=="varying":
            self.varying.append((self.type, self.identifier, self.arraysize))
        elif self.qualifier=="uniform":
            self.uniform.append((self.type, self.identifier, self.arraysize, self.structname, self.struct))
        elif self.qualifier=="const":
            self.const.append((self.type, self.identifier, self.arraysize, self.structname, self.struct))
        else:
            self.other.append((self.type, self.identifier, self.arraysize, self.structname, self.struct))

    # States:
    # Each state takes the same arguments as a token reader

    def initialState(self, type, s, start, end, line, filename):
        """Initial state.
        """
        self.qualifier = None
        self.type = None
        self.identifier = None
        self.arraysize = None
        self.structname = None
        self.struct = None
        if type==QUALIFIER:
            self.qualifier = s
            self.switchState(self.qualifierState)
        elif type==TYPE and s!="struct":
            self.type = s
            self.switchState(self.typeState)
        elif s=="struct":
            self.type = s
            self.switchState(self.structState)
        else:
            # Is the type a previously defined struct?
            if s in self.named_structs:
                self.type = "struct"
                self.structname = s
                self.struct = self.named_structs[s]
                self.switchState(self.typeState)
            else:
                raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)

    def qualifierState(self, type, s, start, end, line, filename):
        """A qualifier has been read.
        """
        if type==TYPE and s!="struct":
            self.type = s
            if self.qualifier in ["attribute", "varying"] and s not in ["float", "vec2", "vec3", "vec4", "mat2", "mat3", "mat4"]:
                raise GLSLangParseError, "%s, line %d: Invalid type for an %s variable: %s"%(filename, start[0], self.qualifier, s)
            self.switchState(self.typeState)
        elif s=="struct":
            self.type = s
            self.switchState(self.structState)
        else:
            # Is the type a previously defined struct?
            if s in self.named_structs:
                self.type = "struct"
                self.structname = s
                self.struct = self.named_structs[s]
                if self.qualifier in ["attribute", "varying"]:
                    raise GLSLangParseError, "%s, line %d: %s variables cannot be declared as structs"%(filename, start[0], self.qualifier)
                self.switchState(self.typeState)
            else:
                raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)

    def typeState(self, type, s, start, end, line, filename):
        """The type of a varibale has been read.
        """
        if type==NAME:
            self.identifier = s
            self.switchState(self.nameState)
        elif s==";":
            self.switchState(self.initialState)
        else:
            raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)

    def nameState(self, type, s, start, end, line, filename):
        """The name of a variable/function has been read.
        """
        if s==",":
            self.variable()
            self.switchState(self.typeState)
        elif s==";":
            self.variable()
            self.switchState(self.initialState)
        elif s=="[":
            self.arraysize = ""
            if self.qualifier=="attribute":
                raise GLSLangParseError, "%s, line %d: attribute variables cannot be declared as arrays"%(filename, start[0])
            self.switchState(self.arrayState)
        elif s=="(":
            self.openparen = 1
            self.switchState(self.functionState)
        elif s=="=":
            self.switchState(self.initState)
        else:
            raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)

    def initState(self, type, s, start, end, line, filename):
        """A '=' has been encountered.

        Skip the initializer.
        """
        if s==";":
            self.variable()
            self.switchState(self.initialState)

    def arrayState(self, type, s, start, end, line, filename):
        """A '[' has been encountered.
        """
        if s=="]":
            self.switchState(self.arrayState2)
        else:
            self.arraysize += s

    def arrayState2(self, type, s, start, end, line, filename):
        if s==";":
            self.variable()
            self.switchState(self.initialState)
        elif s==",":
            self.variable()
            self.arraysize = None
            self.switchState(self.typeState)
        else:
            raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)

    def functionState(self, type, s, start, end, line, filename):
        """Skip function args.
        """
        if s=="(":
            self.openparen += 1
        elif s==")":
            self.openparen -= 1
            if self.openparen==0:
                self.switchState(self.functionState2)
            
    def functionState2(self, type, s, start, end, line, filename):
        """Skip function body.
        """

        # If this was only a function prototype there will be an immediate
        # semicolon instead of the function body
        if self.openparen==0 and s==";":
            self.switchState(self.initialState)
        elif s=="{":
            self.openparen += 1
        elif s=="}":
            if self.openparen==0:
                raise GLSLangParseError, "%s, line %d: '{' expected, got '}'"%(filename, start[0])
            self.openparen -= 1
            if self.openparen==0:
                self.switchState(self.initialState)
        elif self.openparen==0:
            raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)

    def structState(self, type, s, start, end, line, filename):
        """The keyword 'struct' has been read.
        """
        self.structcontents = ""
        if type==NAME:
            self.structname = s
            self.switchState(self.structState2)
        elif s=="{":
            self.switchState(self.structState3)
        else:
            raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)

    def structState2(self, type, s, start, end, line, filename):
        """The struct name has been read.
        """
        if s=="{":
            self.switchState(self.structState3)
        else:
            raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)

    def structState3(self, type, s, start, end, line, filename):
        """Collect the struct contents.
        """
        if s=="}":
            f = StringIO.StringIO(self.structcontents)
            p = _GLSLangParser(f, structs=self.named_structs)
            p.read()
            self.struct = p.other
            if self.structname!="":
                self.named_structs[self.structname] = self.struct
            self.switchState(self.typeState)
        else:
            self.structcontents += s+" "
        


# glslangparams
def glslangparams(shader=None, cpp=None, cpperrstream=sys.stderr):
    """Extracts the shader parameters from an OpenGL 2 shader source file.

    The argument shader is either the name of the shader source file
    or a file-like object that provides the shader sources.
    cpp determines how the shader source is preprocessed. It
    can either be a string containing the name of an external
    preprocessor tool (such as 'cpp') that must take the file name as
    parameter and dump the preprocessed output to stdout or it can be
    a callable that takes shader and cpperrstream as input and returns
    the preprocessed sources as a string. If the external
    preprocessor does not produce any data a PreprocessorNotFound
    exception is thrown.
    The error stream of the preprocessor is written to the object
    that is specified by cpperrstream which must have a write()
    method. If cpperrstream is None, the error stream is ignored.

    If cpp is None a simple internal preprocessor based on the
    simplecpp module is used.

    The function returns three lists (uniform, attribute, varying)
    that contain the variables with the corresponding qualifier.

    A uniform variable is a 5-tuple (type, identifier, arraysize,
    structname, struct). arraysize is a string containing the
    expression for the length of the array (i.e. the value between
    the square brackets). If the variable is no array, arraysize is None.
    When the variable is a struct, type has the value 'struct'. In this
    case, the struct is given in struct (which is itself a list of
    variables as 5-tuples). If the struct has a name, this name is
    given in structname, otherwise structname is None.

    An attribute variable is a 2-tuple (type, identifier) and a
    varying variable is a 3-tuple (type, identifier, arraysize) where
    arraysize is defined as in the uniform case.
    """

    # Run the preprocessor on the input file...
    
    if cpp==None:
        cpp = simplecpp.PreProcessor()
        
    glslangsrc = slparams.preprocess(cpp, shader, cpperrstream)
    f = StringIO.StringIO(glslangsrc)

    # Extract the variables...
    parser = _GLSLangParser(f)
    parser.read()
    return parser.uniform, parser.attribute, parser.varying


