new

21 files changed, 7136 insertions, 0 deletions

diff --git a/idlc/source/astarray.cxx b/idlc/source/astarray.cxx
new file mode 100644
index 000000000000..d133c380eee4
--- /dev/null
+++ b/idlc/source/astarray.cxx
@@ -0,0 +1,107 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astarray.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTARRAY_HXX_
+#include <idlc/astarray.hxx>
+#endif
+
+using namespace ::rtl;
+
+AstArray::AstArray(const OString& name, AstType* pType, const ExprList& rDimExpr, AstScope* pScope)
+    : AstType(NT_array, name, pScope)
+    , m_pType(pType)
+    , m_dimension(rDimExpr.size())
+    , m_dimExpressions(rDimExpr)
+{
+    if ( m_pType )
+        setName(makeName());
+}
+
+AstArray::AstArray(AstType* pType, const ExprList& rDimExpr, AstScope* pScope)
+    : AstType(NT_array, OString("arrary_"), pScope)
+    , m_pType(pType)
+    , m_dimension(rDimExpr.size())
+    , m_dimExpressions(rDimExpr)
+{
+    if ( m_pType )
+        setName(makeName());
+}
+
+OString AstArray::makeName()
+{
+    if ( m_pType )
+    {
+        OString name(m_pType->getScopedName());
+        OString openBracket("[");
+        OString closeBracket("]");
+        ExprList::iterator iter = m_dimExpressions.begin();
+        ExprList::iterator end = m_dimExpressions.end();
+
+        while ( iter != end )
+        {
+            name += openBracket;
+            name += (*iter)->toString();
+            name += closeBracket;
+            iter++;
+        }
+        return name;
+    }
+    return OString();
+}
diff --git a/idlc/source/astconstant.cxx b/idlc/source/astconstant.cxx
new file mode 100644
index 000000000000..bb377a0ed3e7
--- /dev/null
+++ b/idlc/source/astconstant.cxx
@@ -0,0 +1,184 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astconstant.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTCONSTANT_HXX_
+#include <idlc/astconstant.hxx>
+#endif
+#ifndef _IDLC_ASTSCOPE_HXX_
+#include <idlc/astscope.hxx>
+#endif
+
+using namespace ::rtl;
+
+AstConstant::AstConstant(const ExprType type,
+                         const NodeType nodeType,
+                         AstExpression* pExpr,
+                         const ::rtl::OString& name,
+                         AstScope* pScope)
+    : AstDeclaration(nodeType, name, pScope)
+    , m_pConstValue(pExpr)
+    , m_constValueType(type)
+{
+}
+
+AstConstant::AstConstant(const ExprType type,
+                         AstExpression* pExpr,
+                         const ::rtl::OString& name,
+                         AstScope* pScope)
+    : AstDeclaration(NT_const, name, pScope)
+    , m_pConstValue(pExpr)
+    , m_constValueType(type)
+{
+}
+
+AstConstant::~AstConstant()
+{
+
+}
+
+sal_Bool AstConstant::dumpBlob(RegistryTypeWriter& rBlob, sal_uInt16 index)
+{
+    RTConstValue    aConst;
+    sal_Unicode*    str = NULL;
+    sal_Bool        bRelativ = sal_False;
+    if ( getScope()->getScopeNodeType() == NT_constants )
+        bRelativ = sal_True;
+
+    AstExprValue *exprVal = getConstValue()->getExprValue();
+    switch (getConstValueType())
+    {
+        case ET_short:
+            aConst.m_type = RT_TYPE_INT16;
+            aConst.m_value.aShort = exprVal->u.sval;
+            break;
+        case ET_ushort:
+            aConst.m_type = RT_TYPE_UINT16;
+            aConst.m_value.aUShort = exprVal->u.usval;
+            break;
+        case ET_long:
+            aConst.m_type = RT_TYPE_INT32;
+            aConst.m_value.aLong = exprVal->u.lval;
+            break;
+        case ET_ulong:
+            aConst.m_type = RT_TYPE_UINT32;
+            aConst.m_value.aULong = exprVal->u.ulval;
+            break;
+        case ET_hyper:
+            aConst.m_type = RT_TYPE_INT64;
+            aConst.m_value.aHyper = exprVal->u.hval;
+            break;
+        case ET_uhyper:
+            aConst.m_type = RT_TYPE_UINT64;
+            aConst.m_value.aUHyper = exprVal->u.uhval;
+            break;
+        case ET_float:
+            aConst.m_type = RT_TYPE_FLOAT;
+            aConst.m_value.aFloat = exprVal->u.fval;
+            break;
+        case ET_double:
+            aConst.m_type = RT_TYPE_DOUBLE;
+            aConst.m_value.aDouble = exprVal->u.dval;
+            break;
+        case ET_char:
+            break;
+        case ET_byte:
+            aConst.m_type = RT_TYPE_BYTE;
+            aConst.m_value.aByte = exprVal->u.byval;
+            break;
+        case ET_boolean:
+            aConst.m_type = RT_TYPE_BOOL;
+            aConst.m_value.aBool = exprVal->u.bval;
+            break;
+        case ET_string:
+            {
+                aConst.m_type = RT_TYPE_STRING;
+                ::rtl::OUString aTempStr( OUString::createFromAscii(exprVal->u.strval->getStr()));
+                str = new sal_Unicode[aTempStr.getLength()+1];
+                rtl_copyMemory(str, aTempStr.getStr(), (aTempStr.getLength()+1) * sizeof(sal_Unicode));
+                aConst.m_value.aString = str;
+            }
+            break;
+        default:
+            {
+                fprintf(stderr, "%s: exprtype to const type: cannot convert ExprType\n",
+                        idlc()->getOptions()->getProgramName().getStr());
+                return sal_False;
+            }
+    }
+
+    OString name(getRelativName());
+    if ( getNodeType() == NT_enum_val || bRelativ )
+        name = getLocalName();
+
+    OUString type;
+    OUString fileName;
+    if ( getNodeType() != NT_enum_val )
+    {
+        type = OStringToOUString(exprTypeToString(getConstValueType()), RTL_TEXTENCODING_UTF8);
+        fileName = OStringToOUString(getFileName(), RTL_TEXTENCODING_UTF8);
+    }
+
+    rBlob.setFieldData(index, OStringToOUString(name, RTL_TEXTENCODING_UTF8), type,
+                       getDocumentation(), fileName, RT_ACCESS_CONST, aConst);
+    if (str)
+        delete[] str;
+
+    return sal_True;
+}
diff --git a/idlc/source/astdeclaration.cxx b/idlc/source/astdeclaration.cxx
new file mode 100644
index 000000000000..70baf1b1523f
--- /dev/null
+++ b/idlc/source/astdeclaration.cxx
@@ -0,0 +1,227 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astdeclaration.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTDECLARATION_HXX_
+#include <idlc/astdeclaration.hxx>
+#endif
+#ifndef _IDLC_ASTSCOPE_HXX_
+#include <idlc/astscope.hxx>
+#endif
+#ifndef _RTL_STRBUF_HXX_
+#include <rtl/strbuf.hxx>
+#endif
+
+using namespace ::rtl;
+
+static OString sGlobal("::");
+
+static OString convertName(const OString& name)
+{
+    OStringBuffer nameBuffer(name.getLength()+1);
+    sal_Int32 count = name.getTokenCount(':');
+    if ( count )
+    {
+        sal_Int32 offset = (name.indexOf("::") == 0 ? 2 : 0);
+        for (sal_Int32 i=offset; i < count; i+=2 )
+        {
+            nameBuffer.append('/');
+            nameBuffer.append(name.getToken(i, ':'));
+        }
+    } else
+    {
+        nameBuffer.append('/');
+        nameBuffer.append(name);
+    }
+    return nameBuffer.makeStringAndClear();
+}
+
+AstDeclaration::AstDeclaration(NodeType type, const OString& name, AstScope* pScope)
+    : m_nodeType(type)
+    , m_localName(name)
+    , m_pScope(pScope)
+    , m_bIsAdded(sal_False)
+    , m_bImported(sal_False)
+    , m_bInMainFile(sal_False)
+{
+    if ( m_pScope )
+    {
+        AstDeclaration* pDecl = scopeAsDecl(m_pScope);
+        if (pDecl)
+        {
+            m_scopedName = pDecl->getScopedName();
+            if (m_scopedName.getLength() > 0)
+                m_scopedName += sGlobal;
+            m_scopedName += m_localName;
+        }
+    } else
+    {
+        m_scopedName = m_localName;
+    }
+    m_fullName = convertName(m_scopedName);
+
+    if ( idlc()->getFileName() == idlc()->getRealFileName() )
+    {
+        m_fileName = idlc()->getMainFileName();
+        m_bInMainFile = sal_True;
+    } else
+    {
+        m_fileName = idlc()->getFileName();
+        m_bImported = sal_True;
+    }
+
+    if ( idlc()->isDocValid() )
+        m_documentation = OStringToOUString(idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8);
+}
+
+
+AstDeclaration::~AstDeclaration()
+{
+
+}
+
+void AstDeclaration::setName(const ::rtl::OString& name)
+{
+    sal_Int32 count = name.getTokenCount(':');
+    if ( count > 0 )
+    {
+        m_localName = name.getToken(count-1, ':');
+        m_scopedName = name;
+    } else if ( m_pScope )
+    {
+        m_localName = name;
+        AstDeclaration* pDecl = scopeAsDecl(m_pScope);
+        if (pDecl)
+        {
+            m_scopedName = pDecl->getScopedName();
+            if (m_scopedName.getLength() > 0)
+                m_scopedName += sGlobal;
+            m_scopedName += m_localName;
+        }
+    } else
+    {
+        m_localName = name;
+        m_scopedName = name;
+    }
+    m_fullName = convertName(m_scopedName);
+}
+
+sal_Bool AstDeclaration::isType()
+{
+    sal_Bool bIsType = sal_False;
+
+    switch (m_nodeType)
+    {
+        case NT_interface:
+        case NT_struct:
+        case NT_union:
+        case NT_enum:
+        case NT_sequence:
+        case NT_array:
+        case NT_typedef:
+        case NT_predefined:
+            bIsType = sal_True;
+    }
+
+    return bIsType;
+}
+
+sal_Bool AstDeclaration::hasAncestor(AstDeclaration* pDecl)
+{
+    if (this == pDecl)
+        return sal_True;
+    if ( !m_pScope )
+        return sal_False;
+    return scopeAsDecl(m_pScope)->hasAncestor(pDecl);
+}
+
+sal_Bool AstDeclaration::dump(RegistryKey& rKey, RegistryTypeWriterLoader* pLoader)
+{
+    AstScope* pScope = declAsScope(this);
+    sal_Bool bRet = sal_True;
+
+    if ( pScope )
+    {
+        DeclList::iterator iter = pScope->getIteratorBegin();
+        DeclList::iterator end = pScope->getIteratorEnd();
+        AstDeclaration* pDecl = NULL;
+        while ( iter != end && bRet)
+        {
+            pDecl = *iter;
+            if ( pDecl->isInMainfile() )
+            {
+                switch ( pDecl->getNodeType() )
+                {
+                    case NT_module:
+                    case NT_constants:
+                    case NT_interface:
+                    case NT_struct:
+                    case NT_exception:
+                    case NT_enum:
+                    case NT_union:
+                    case NT_typedef:
+                    case NT_service:
+                        bRet = pDecl->dump(rKey, pLoader);
+                }
+            }
+            iter++;
+        }
+    }
+    return bRet;
+}
diff --git a/idlc/source/astdump.cxx b/idlc/source/astdump.cxx
new file mode 100644
index 000000000000..cb5352b86427
--- /dev/null
+++ b/idlc/source/astdump.cxx
@@ -0,0 +1,414 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astdump.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTMODULE_HXX_
+#include <idlc/astmodule.hxx>
+#endif
+#ifndef _IDLC_ASTTYPEDEF_HXX_
+#include <idlc/asttypedef.hxx>
+#endif
+#ifndef _IDLC_ASTSERVICE_HXX_
+#include <idlc/astservice.hxx>
+#endif
+#ifndef _IDLC_ASTCONSTANT_HXX_
+#include <idlc/astconstant.hxx>
+#endif
+#ifndef _IDLC_ASTATTRIBUTE_HXX_
+#include <idlc/astattribute.hxx>
+#endif
+#ifndef _IDLC_ASTINTERFACEMEMBER_HXX_
+#include <idlc/astinterfacemember.hxx>
+#endif
+#ifndef _IDLC_ASTSERVICEEMEMBER_HXX_
+#include <idlc/astservicemember.hxx>
+#endif
+#ifndef _IDLC_ASTOBSERVES_HXX_
+#include <idlc/astobserves.hxx>
+#endif
+#ifndef _IDLC_ASTNEEDS_HXX_
+#include <idlc/astneeds.hxx>
+#endif
+#ifndef _IDLC_ASTSEQUENCE_HXX_
+#include <idlc/astsequence.hxx>
+#endif
+
+using namespace ::rtl;
+
+sal_Bool AstModule::dump(RegistryKey& rKey, RegistryTypeWriterLoader* pLoader)
+{
+    RegistryKey localKey;
+    if ( getNodeType() == NT_root )
+    {
+        localKey = rKey;
+    }else
+    {
+        if (rKey.createKey( OStringToOUString(getFullName(), RTL_TEXTENCODING_UTF8 ), localKey))
+        {
+            fprintf(stderr, "%s: warning, could not create key '%s' in '%s'\n",
+                    idlc()->getOptions()->getProgramName().getStr(),
+                    getFullName().getStr(), rKey.getRegistryName().getStr());
+            return sal_False;
+        }
+    }
+
+    const sal_uInt8*    pBlob = NULL;
+    sal_uInt32          aBlobSize = 0;
+    sal_uInt16          nConst = getNodeCount(NT_const);
+
+    if ( nConst > 0 )
+    {
+        RTTypeClass typeClass = RT_TYPE_MODULE;
+        if ( getNodeType() == NT_constants )
+            typeClass = RT_TYPE_CONSTANTS;
+
+        RegistryTypeWriter aBlob(pLoader->getApi(),
+                                 typeClass,
+                                 OStringToOUString(getRelativName(), RTL_TEXTENCODING_UTF8),
+                                 OUString(), nConst, 0, 0);
+
+        aBlob.setDoku( getDocumentation() );
+        aBlob.setFileName( OStringToOUString(getFileName(), RTL_TEXTENCODING_UTF8));
+
+        DeclList::iterator iter = getIteratorBegin();
+        DeclList::iterator end = getIteratorEnd();
+        AstDeclaration* pDecl = NULL;
+        sal_uInt16 index = 0;
+        while ( iter != end )
+        {
+            pDecl = *iter;
+            if ( pDecl->getNodeType() == NT_const &&
+                 pDecl->isInMainfile() )
+            {
+                ((AstConstant*)pDecl)->dumpBlob(aBlob, index++);
+            }
+            iter++;
+        }
+
+        pBlob = aBlob.getBlop();
+        aBlobSize = aBlob.getBlopSize();
+
+        if (localKey.setValue(OUString(), RG_VALUETYPE_BINARY,
+                                (RegValue)pBlob, aBlobSize))
+        {
+            fprintf(stderr, "%s: warning, could not set value of key \"%s\" in %s\n",
+                    idlc()->getOptions()->getProgramName().getStr(),
+                    getFullName(), localKey.getRegistryName());
+            return sal_False;
+        }
+    } else
+    {
+        RTTypeClass typeClass = RT_TYPE_MODULE;
+        if ( getNodeType() == NT_constants )
+            typeClass = RT_TYPE_CONSTANTS;
+
+        RegistryTypeWriter aBlob(pLoader->getApi(),
+                                 typeClass,
+                                 OStringToOUString(getRelativName(), RTL_TEXTENCODING_UTF8),
+                                 OUString(), 0, 0, 0);
+
+        aBlob.setDoku( getDocumentation() );
+        if ( getNodeType() == NT_constants )
+            aBlob.setFileName( OStringToOUString(getFileName(), RTL_TEXTENCODING_UTF8));
+
+        pBlob = aBlob.getBlop();
+        aBlobSize = aBlob.getBlopSize();
+
+        if ( getNodeType() != NT_root )
+        {
+            if (localKey.setValue(OUString(), RG_VALUETYPE_BINARY,
+                                    (RegValue)pBlob, aBlobSize))
+            {
+                fprintf(stderr, "%s: warning, could not set value of key \"%s\" in %s\n",
+                        idlc()->getOptions()->getProgramName().getStr(),
+                        getFullName(), localKey.getRegistryName());
+                return sal_False;
+            }
+        }
+    }
+    return AstDeclaration::dump(rKey, pLoader);
+}
+
+sal_Bool AstTypeDef::dump(RegistryKey& rKey, RegistryTypeWriterLoader* pLoader)
+{
+    RegistryKey localKey;
+    if (rKey.createKey( OStringToOUString(getFullName(), RTL_TEXTENCODING_UTF8 ), localKey))
+    {
+        fprintf(stderr, "%s: warning, could not create key '%s' in '%s'\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName().getStr(), rKey.getRegistryName().getStr());
+        return sal_False;
+    }
+
+    RegistryTypeWriter aBlob(pLoader->getApi(), RT_TYPE_TYPEDEF,
+                             OStringToOUString(getRelativName(), RTL_TEXTENCODING_UTF8),
+                             OStringToOUString(getBaseType()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                             0, 0, 0);
+
+    aBlob.setDoku( getDocumentation() );
+    aBlob.setFileName( OStringToOUString(getFileName(), RTL_TEXTENCODING_UTF8));
+
+    const sal_uInt8*    pBlob = aBlob.getBlop();
+    sal_uInt32          aBlobSize = aBlob.getBlopSize();
+
+    if (localKey.setValue(OUString(), RG_VALUETYPE_BINARY, (RegValue)pBlob, aBlobSize))
+    {
+        fprintf(stderr, "%s: warning, could not set value of key \"%s\" in %s\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName(), localKey.getRegistryName());
+        return sal_False;
+    }
+
+    return sal_True;
+}
+
+sal_Bool AstService::dump(RegistryKey& rKey, RegistryTypeWriterLoader* pLoader)
+{
+    if ( !idlc()->getOptions()->isValid("-C") )
+        return sal_True;
+
+    RegistryKey localKey;
+    if (rKey.createKey( OStringToOUString(getFullName(), RTL_TEXTENCODING_UTF8 ), localKey))
+    {
+        fprintf(stderr, "%s: warning, could not create key '%s' in '%s'\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName().getStr(), rKey.getRegistryName().getStr());
+        return sal_False;
+    }
+
+    sal_uInt16 nProperties = 0;
+    sal_uInt16 nIfaceMember = 0;
+    sal_uInt16 nServMember = 0;
+    sal_uInt16 nNeeds = 0;
+    sal_uInt16 nObserves = 0;
+    if ( nMembers() > 0 )
+    {
+        DeclList::iterator iter = getIteratorBegin();
+        DeclList::iterator end = getIteratorEnd();
+        while ( iter != end )
+        {
+            switch ( (*iter)->getNodeType() )
+            {
+                case NT_property:
+                    nProperties++;
+                    break;
+                case NT_interface_member:
+                    nIfaceMember++;
+                    break;
+                case NT_service_member:
+                    nServMember++;
+                    break;
+                case NT_observes:
+                    nObserves++;
+                    break;
+                case NT_needs:
+                    nNeeds++;
+                    break;
+            }
+            iter++;
+        }
+    }
+    sal_uInt16 nReferences = nIfaceMember + nServMember + nObserves + nNeeds;
+
+    RegistryTypeWriter aBlob(pLoader->getApi(), RT_TYPE_SERVICE,
+                             OStringToOUString(getRelativName(), RTL_TEXTENCODING_UTF8),
+                             OUString(), nProperties, 0, nReferences);
+
+    aBlob.setDoku( getDocumentation() );
+    aBlob.setFileName( OStringToOUString(getFileName(), RTL_TEXTENCODING_UTF8));
+
+    if ( nProperties || nReferences )
+    {
+        DeclList::iterator iter = getIteratorBegin();
+        DeclList::iterator end = getIteratorEnd();
+        AstDeclaration* pDecl = NULL;
+        sal_uInt16  propertyIndex = 0;
+        sal_uInt16  referenceIndex = 0;
+        while ( iter != end )
+        {
+            pDecl = *iter;
+            switch ( pDecl->getNodeType() )
+            {
+            case NT_property:
+                ((AstAttribute*)pDecl)->dumpBlob(aBlob, propertyIndex++);
+                break;
+            case NT_interface_member:
+            {
+                AstInterfaceMember* pIfaceMember = (AstInterfaceMember*)pDecl;
+                sal_uInt16 access = (pIfaceMember->isOptional() ? RT_ACCESS_OPTIONAL : RT_ACCESS_INVALID);
+                aBlob.setReferenceData(referenceIndex++,
+                           OStringToOUString( pIfaceMember->getRealInterface()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                           RT_REF_SUPPORTS, pIfaceMember->getDocumentation(), access);
+            }
+                break;
+            case NT_service_member:
+            {
+                AstServiceMember* pServMember = (AstServiceMember*)pDecl;
+                aBlob.setReferenceData(referenceIndex++,
+                           OStringToOUString( pServMember->getRealService()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                           RT_REF_EXPORTS, pServMember->getDocumentation());
+            }
+                break;
+            case NT_observes:
+            {
+                AstObserves* pObserves = (AstObserves*)pDecl;
+                aBlob.setReferenceData(referenceIndex++,
+                           OStringToOUString( pObserves->getRealInterface()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                           RT_REF_OBSERVES, pObserves->getDocumentation());
+            }
+                break;
+            case NT_needs:
+            {
+                AstNeeds* pNeeds = (AstNeeds*)pDecl;
+                aBlob.setReferenceData(referenceIndex++,
+                           OStringToOUString( pNeeds->getRealService()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                           RT_REF_NEEDS, pNeeds->getDocumentation());
+            }
+                break;
+            }
+            iter++;
+        }
+
+        const sal_uInt8* pBlob = aBlob.getBlop();
+        sal_uInt32       aBlobSize = aBlob.getBlopSize();
+
+        if (localKey.setValue(OUString(), RG_VALUETYPE_BINARY,
+                                (RegValue)pBlob, aBlobSize))
+        {
+            fprintf(stderr, "%s: warning, could not set value of key \"%s\" in %s\n",
+                    idlc()->getOptions()->getProgramName().getStr(),
+                    getFullName(), localKey.getRegistryName());
+            return sal_False;
+        }
+    }
+
+    return sal_True;
+}
+
+sal_Bool AstAttribute::dumpBlob(RegistryTypeWriter& rBlob, sal_uInt16 index)
+{
+    RTFieldAccess accessMode = RT_ACCESS_INVALID;
+
+    if (isReadonly())
+    {
+        accessMode |= RT_ACCESS_READONLY;
+    } else
+    {
+        accessMode |= RT_ACCESS_READWRITE;
+    }
+    if (isOptional())
+    {
+        accessMode |= RT_ACCESS_OPTIONAL;
+    }
+    if (isBound())
+    {
+        accessMode |= RT_ACCESS_BOUND;
+    }
+    if (isMayBeVoid())
+    {
+        accessMode |= RT_ACCESS_MAYBEVOID;
+    }
+    if (isConstrained())
+    {
+        accessMode |= RT_ACCESS_CONSTRAINED;
+    }
+    if (isTransient())
+    {
+        accessMode |= RT_ACCESS_TRANSIENT;
+    }
+    if (isMayBeAmbiguous())
+    {
+        accessMode |= RT_ACCESS_MAYBEAMBIGUOUS;
+    }
+    if (isMayBeDefault())
+    {
+        accessMode |= RT_ACCESS_MAYBEDEFAULT;
+    }
+    if (isRemoveable())
+    {
+        accessMode |= RT_ACCESS_REMOVEABLE;
+    }
+
+    rBlob.setFieldData(index, OStringToOUString(getLocalName(), RTL_TEXTENCODING_UTF8),
+                       OStringToOUString(getType()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                       getDocumentation(), OUString(), accessMode);
+
+    return sal_True;
+}
+
+AstType* SAL_CALL resolveTypeDef(AstType* pType)
+{
+    if ( pType->getNodeType() == NT_typedef )
+    {
+        return resolveTypeDef(((AstTypeDef*)pType)->getBaseType());
+    }
+    return pType;
+}
+
+const sal_Char* AstSequence::getRelativName()
+{
+    if ( !m_pRelativName )
+    {
+        m_pRelativName = new OString("[]");
+        AstType* pType = resolveTypeDef( m_pMemberType );
+        *m_pRelativName += pType->getRelativName();
+    }
+
+    return m_pRelativName->getStr();
+}
diff --git a/idlc/source/astenum.cxx b/idlc/source/astenum.cxx
new file mode 100644
index 000000000000..ea9365d5c4cd
--- /dev/null
+++ b/idlc/source/astenum.cxx
@@ -0,0 +1,161 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astenum.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTENUM_HXX_
+#include <idlc/astenum.hxx>
+#endif
+
+using namespace ::rtl;
+
+AstEnum::AstEnum(const ::rtl::OString& name, AstScope* pScope)
+    : AstType(NT_enum, name, pScope)
+    , AstScope(NT_enum)
+    , m_enumValueCount(0)
+{
+}
+
+AstEnum::~AstEnum()
+{
+}
+
+AstConstant* AstEnum::checkValue(AstExpression* pExpr)
+{
+    DeclList::iterator  iter = getIteratorBegin();
+    DeclList::iterator  end = getIteratorEnd();
+    AstConstant*        pConst = NULL;
+    AstDeclaration*     pDecl = NULL;
+
+    while ( iter != end)
+    {
+        pDecl = *iter;
+        pConst = (AstConstant*)pDecl;
+
+        if (pConst->getConstValue()->compare(pExpr))
+            return pConst;
+
+        iter++;
+    }
+
+    if ( pExpr->getExprValue()->u.lval > m_enumValueCount )
+        m_enumValueCount = pExpr->getExprValue()->u.lval + 1;
+
+    return NULL;
+}
+
+sal_Bool AstEnum::dump(RegistryKey& rKey, RegistryTypeWriterLoader* pLoader)
+{
+    RegistryKey localKey;
+    if (rKey.createKey( OStringToOUString(getFullName(), RTL_TEXTENCODING_UTF8 ), localKey))
+    {
+        fprintf(stderr, "%s: warning, could not create key '%s' in '%s'\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName().getStr(), rKey.getRegistryName().getStr());
+        return sal_False;
+    }
+
+    sal_uInt16 nConst = getNodeCount(NT_enum_val);
+    if ( nConst > 0 )
+    {
+        RegistryTypeWriter aBlob(pLoader->getApi(),
+                                 RT_TYPE_ENUM,
+                                 OStringToOUString(getRelativName(), RTL_TEXTENCODING_UTF8),
+                                 OUString(), nConst, 0, 0);
+
+        aBlob.setDoku( getDocumentation() );
+        aBlob.setFileName( OStringToOUString(getFileName(), RTL_TEXTENCODING_UTF8));
+
+        DeclList::iterator iter = getIteratorBegin();
+        DeclList::iterator end = getIteratorEnd();
+        AstDeclaration* pDecl = NULL;
+        sal_uInt16 index = 0;
+        while ( iter != end )
+        {
+            pDecl = *iter;
+            if ( pDecl->getNodeType() == NT_enum_val )
+                ((AstConstant*)pDecl)->dumpBlob(aBlob, index++);
+
+            iter++;
+        }
+
+        const sal_uInt8* pBlob = aBlob.getBlop();
+        sal_uInt32       aBlobSize = aBlob.getBlopSize();
+
+        if (localKey.setValue(OUString(), RG_VALUETYPE_BINARY,
+                                (RegValue)pBlob, aBlobSize))
+        {
+            fprintf(stderr, "%s: warning, could not set value of key \"%s\" in %s\n",
+                    idlc()->getOptions()->getProgramName().getStr(),
+                    getFullName(), localKey.getRegistryName());
+            return sal_False;
+        }
+    }
+
+    return sal_True;
+}
+
+AstDeclaration* AstEnum::addDeclaration(AstDeclaration* pDecl)
+{
+    AstScope* pScope = getScope();
+    // add enum value to enclosing scope of the enum
+//  pDecl->setName(scopeAsDecl(pScope)->getScopedName() + "::" + pDecl->getLocalName());
+//  pScope->addDeclaration(pDecl);
+
+    return AstScope::addDeclaration(pDecl);
+}
diff --git a/idlc/source/astexpression.cxx b/idlc/source/astexpression.cxx
new file mode 100644
index 000000000000..8bc9d06e87d0
--- /dev/null
+++ b/idlc/source/astexpression.cxx
@@ -0,0 +1,1638 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astexpression.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTEXPRESSION_HXX_
+#include <idlc/astexpression.hxx>
+#endif
+#ifndef _IDLC_ASTCONSTANT_HXX_
+#include <idlc/astconstant.hxx>
+#endif
+#ifndef _IDLC_ASTSCOPE_HXX_
+#include <idlc/astscope.hxx>
+#endif
+#ifndef _IDLC_ERRORHANDLER_HXX_
+#include <idlc/errorhandler.hxx>
+#endif
+
+#include <limits.h>
+#include <float.h>
+
+#undef  MAXCHAR
+#define MAXCHAR 127
+#undef  MINCHAR
+#define MINCHAR -128
+
+#define MAXINT64 9223372036854775807
+#define MININT64 -9223372036854775807-1
+#define MAXUINT64 18446744073709551615
+
+using namespace ::rtl;
+
+AstExpression::AstExpression(AstExpression *pExpr, ExprType et)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = pExpr->coerce(et);
+    if ( !m_exprValue)
+    {
+        idlc()->error()->coercionError(pExpr, et);
+    }
+}
+
+AstExpression::AstExpression(ExprComb c, AstExpression *pExpr1, AstExpression *pExpr2)
+    : m_combOperator(c)
+    , m_subExpr1(pExpr1)
+    , m_subExpr2(pExpr2)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+}
+
+AstExpression::AstExpression(sal_Int16 s)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = ET_short;
+    m_exprValue->u.sval = s;
+}
+
+AstExpression::AstExpression(sal_uInt16 us)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = ET_ushort;
+    m_exprValue->u.usval = us;
+}
+
+AstExpression::AstExpression(sal_Int32 l)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = ET_long;
+    m_exprValue->u.lval = l;
+}
+
+AstExpression::AstExpression(sal_Int32  l, ExprType et)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = et;
+    m_exprValue->u.lval = l;
+}
+
+AstExpression::AstExpression(sal_uInt32 ul)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = ET_ulong;
+    m_exprValue->u.ulval = ul;
+}
+
+AstExpression::AstExpression(sal_Int64  h)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = ET_hyper;
+    m_exprValue->u.hval = h;
+}
+
+AstExpression::AstExpression(sal_uInt64 uh)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = ET_uhyper;
+    m_exprValue->u.uhval = uh;
+}
+
+AstExpression::AstExpression(float f)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = ET_float;
+    m_exprValue->u.fval = f;
+}
+
+AstExpression::AstExpression(double d)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = ET_double;
+    m_exprValue->u.dval = d;
+}
+
+AstExpression::AstExpression(sal_Char c)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    m_exprValue = new AstExprValue();
+    m_exprValue->et = ET_char;
+    m_exprValue->u.cval = c;
+}
+
+AstExpression::AstExpression(::rtl::OString* s, sal_Bool bIsScopedName)
+    : m_combOperator(EC_none)
+    , m_subExpr1(NULL)
+    , m_subExpr2(NULL)
+    , m_exprValue(NULL)
+    , m_pSymbolicName(NULL)
+{
+    fillDefinitionDetails();
+
+    if ( bIsScopedName )
+    {
+        m_pSymbolicName = s;
+        m_combOperator = EC_symbol;
+    } else
+    {
+        m_exprValue = new AstExprValue();
+        m_exprValue->et = ET_string;
+        m_exprValue->u.strval = s;
+    }
+}
+
+AstExpression::~AstExpression()
+{
+    if ( m_exprValue )
+        delete m_exprValue;
+    if ( m_subExpr1 )
+        delete m_subExpr1;
+    if ( m_subExpr2 )
+        delete m_subExpr2;
+    if ( m_pSymbolicName )
+        delete m_pSymbolicName;
+}
+
+/*
+ * Perform the coercion from the given AstExprValue to the requested
+ * ExprType. Return an AstExprValue if successful, NULL if failed.
+ * must be done for hyper, uhyper
+ */
+static AstExprValue *
+coerce_value(AstExprValue *ev, ExprType t)
+{
+    if (ev == NULL)
+        return NULL;
+
+    switch (t)
+    {
+        case ET_short:
+            switch (ev->et)
+            {
+                case ET_short:
+                    return ev;
+                case ET_ushort:
+                    if ((sal_uInt16)ev->u.usval > SHRT_MAX)
+                        return NULL;
+                    ev->u.sval = (sal_Int16)ev->u.usval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_long:
+                    if ((sal_Int16)ev->u.lval > SHRT_MAX || (sal_Int16)ev->u.lval < SHRT_MIN)
+                        return NULL;
+                    ev->u.sval = (sal_Int16)ev->u.lval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_ulong:
+                    if ((sal_Int16)ev->u.ulval > SHRT_MAX)
+                        return NULL;
+                    ev->u.sval = (sal_Int16)ev->u.ulval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_hyper:
+                    if ((sal_Int16)ev->u.hval > SHRT_MAX || (sal_Int16)ev->u.hval < SHRT_MIN)
+                        return NULL;
+                    ev->u.sval = (sal_Int16)ev->u.hval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_uhyper:
+                    if ((sal_Int16)ev->u.uhval > SHRT_MAX)
+                        return NULL;
+                    ev->u.sval = (sal_Int16)ev->u.uhval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_boolean:
+                    ev->u.sval = (sal_Int16)ev->u.bval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_float:
+                    if ((sal_Int16)ev->u.fval > SHRT_MAX || (sal_Int16)ev->u.fval < SHRT_MIN)
+                        return NULL;
+                    ev->u.sval = (sal_Int16)ev->u.fval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_double:
+                    if ((sal_Int16)ev->u.dval > SHRT_MAX || (sal_Int16)ev->u.dval < SHRT_MIN)
+                        return NULL;
+                    ev->u.sval = (sal_Int16)ev->u.dval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_char:
+                    ev->u.sval = (sal_Int16)ev->u.cval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_byte:
+                    ev->u.sval = (sal_Int16)ev->u.byval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_ushort:
+            switch (ev->et)
+            {
+                case ET_short:
+                    if (ev->u.sval < 0 && ev->u.sval != USHRT_MAX)
+                        return NULL;
+                    ev->u.usval = (sal_uInt16)ev->u.sval;
+                    ev->et = ET_ushort;
+                    return ev;
+                case ET_ushort:
+                    return ev;
+                case ET_long:
+                    if ((sal_uInt16)ev->u.lval > USHRT_MAX || ev->u.lval < 0)
+                        return NULL;
+                    ev->u.usval = (sal_uInt16)ev->u.lval;
+                    ev->et = ET_ushort;
+                    return ev;
+                case ET_ulong:
+                    if ((sal_uInt16)ev->u.ulval > USHRT_MAX)
+                        return NULL;
+                    ev->u.usval = (sal_uInt16)ev->u.ulval;
+                    ev->et = ET_ushort;
+                    return ev;
+                case ET_hyper:
+                    if ((sal_uInt16)ev->u.hval > USHRT_MAX || ev->u.hval < 0)
+                        return NULL;
+                    ev->u.usval = (sal_uInt16)ev->u.hval;
+                    ev->et = ET_ushort;
+                    return ev;
+                case ET_uhyper:
+                    if ((sal_uInt16)ev->u.uhval > USHRT_MAX)
+                        return NULL;
+                    ev->u.usval = (sal_uInt16)ev->u.uhval;
+                    ev->et = ET_ushort;
+                    return ev;
+                case ET_boolean:
+                    ev->u.usval = (sal_uInt16)ev->u.bval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_float:
+                    if (ev->u.fval < 0.0 || (sal_uInt16)ev->u.fval > USHRT_MAX)
+                        return NULL;
+                    ev->u.usval = (sal_uInt16)ev->u.fval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_double:
+                    if (ev->u.dval < 0.0 || (sal_uInt16)ev->u.dval > USHRT_MAX)
+                        return NULL;
+                    ev->u.usval = (sal_uInt16)ev->u.dval;
+                    ev->et = ET_short;
+                    return ev;
+                case ET_char:
+                    if (ev->u.cval < 0)
+                        return NULL;
+                    ev->u.usval = (sal_uInt16)ev->u.cval;
+                    ev->et = ET_ushort;
+                    return ev;
+                case ET_byte:
+                    ev->u.usval = (sal_uInt16)ev->u.byval;
+                    ev->et = ET_ushort;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_long:
+            switch (ev->et)
+            {
+                case ET_short:
+                    ev->u.lval = (sal_Int32)ev->u.sval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_ushort:
+                    ev->u.lval = (sal_Int32)ev->u.usval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_long:
+                    return ev;
+                case ET_ulong:
+                    if ((sal_Int32)ev->u.ulval > LONG_MAX)
+                        return NULL;
+                    ev->u.lval = (sal_Int32)ev->u.ulval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_hyper:
+                    if ((sal_Int32)ev->u.hval > LONG_MAX || (sal_Int32)ev->u.hval < LONG_MIN)
+                        return NULL;
+                    ev->u.lval = (sal_Int32)ev->u.hval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_uhyper:
+                    if ((sal_Int32)ev->u.uhval > LONG_MAX)
+                        return NULL;
+                    ev->u.lval = (sal_Int32)ev->u.uhval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_boolean:
+                    ev->u.lval = (sal_Int32)ev->u.bval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_float:
+                    if ((sal_Int32)ev->u.fval > LONG_MAX || (sal_Int32)ev->u.fval < LONG_MIN)
+                        return NULL;
+                    ev->u.lval = (sal_Int32)ev->u.fval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_double:
+                    if ((sal_Int32)ev->u.dval > LONG_MAX || (sal_Int32)ev->u.dval < LONG_MIN)
+                        return NULL;
+                    ev->u.lval = (sal_Int32)ev->u.dval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_char:
+                    ev->u.lval = (sal_Int32) ev->u.cval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_byte:
+                    ev->u.lval = (sal_Int32) ev->u.byval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_ulong:
+            switch (ev->et)
+            {
+                case ET_short:
+                    if (ev->u.sval < 0)
+                        return NULL;
+                    ev->u.ulval = (sal_uInt32)ev->u.sval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_ushort:
+                    ev->u.ulval = (sal_uInt32)ev->u.usval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_long:
+                    if ((sal_uInt32)ev->u.lval < 0 && (sal_uInt32)ev->u.lval != ULONG_MAX)
+                        return NULL;
+                    ev->u.ulval = (sal_uInt32)ev->u.lval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_ulong:
+                    return ev;
+                case ET_hyper:
+                    if (ev->u.hval > (sal_Int64)ULONG_MAX || ev->u.hval < 0)
+                        return NULL;
+                    ev->u.lval = (sal_uInt32)ev->u.hval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_uhyper:
+                    if (ev->u.uhval > (sal_uInt64)ULONG_MAX)
+                        return NULL;
+                    ev->u.ulval = (sal_uInt32)ev->u.uhval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_boolean:
+                    ev->u.ulval = (sal_uInt32)ev->u.bval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_float:
+                    if (ev->u.fval < 0.0 || (sal_uInt32)ev->u.fval > ULONG_MAX)
+                        return NULL;
+                    ev->u.ulval = (sal_uInt32)ev->u.fval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_double:
+                    if (ev->u.dval < 0.0 || (sal_uInt32)ev->u.dval > ULONG_MAX)
+                        return NULL;
+                    ev->u.ulval = (sal_uInt32)ev->u.dval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_char:
+                    if (ev->u.cval < 0)
+                        return NULL;
+                    ev->u.ulval = (sal_uInt32)ev->u.cval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_byte:
+                    ev->u.ulval = (sal_uInt32)ev->u.byval;
+                    ev->et = ET_ulong;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_hyper:
+            switch (ev->et)
+            {
+                case ET_short:
+                    ev->u.hval = (sal_Int64)ev->u.sval;
+                    ev->et = ET_hyper;
+                    return ev;
+                case ET_ushort:
+                    ev->u.hval = (sal_Int64)ev->u.usval;
+                    ev->et = ET_hyper;
+                    return ev;
+                case ET_long:
+                    ev->u.hval = (sal_Int64)ev->u.lval;
+                    ev->et = ET_hyper;
+                    return ev;
+                case ET_ulong:
+                    ev->u.hval = (sal_Int64)ev->u.ulval;
+                    ev->et = ET_hyper;
+                    return ev;
+                case ET_hyper:
+                    return ev;
+                case ET_uhyper:
+                    if (ev->u.uhval > (sal_uInt64)MAXINT64)
+                        return NULL;
+                    ev->u.hval = (sal_Int64)ev->u.uhval;
+                    ev->et = ET_long;
+                    return ev;
+                case ET_boolean:
+                    ev->u.hval = (sal_Int64)ev->u.bval;
+                    ev->et = ET_hyper;
+                    return ev;
+                case ET_float:
+                    if ((sal_Int64)ev->u.fval > MAXINT64 || (sal_Int64)ev->u.fval < MININT64)
+                        return NULL;
+                    ev->u.hval = (sal_Int64)ev->u.fval;
+                    ev->et = ET_hyper;
+                    return ev;
+                case ET_double:
+                    if ((sal_Int64)ev->u.dval > MAXINT64 || (sal_Int64)ev->u.dval < MININT64)
+                        return NULL;
+                    ev->u.hval = (sal_Int64)ev->u.dval;
+                    ev->et = ET_hyper;
+                    return ev;
+                case ET_char:
+                    ev->u.hval = (sal_Int64)ev->u.cval;
+                    ev->et = ET_hyper;
+                    return ev;
+                case ET_byte:
+                    ev->u.hval = (sal_Int64)ev->u.byval;
+                    ev->et = ET_hyper;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_uhyper:
+            switch (ev->et)
+            {
+                case ET_short:
+                    if (ev->u.sval < 0)
+                        return NULL;
+                    ev->u.uhval = (sal_uInt64)ev->u.sval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_ushort:
+                    ev->u.uhval = (sal_uInt64)ev->u.usval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_long:
+                    if ((sal_uInt64)ev->u.lval < 0 && ev->u.lval != MAXUINT64)
+                        return NULL;
+                    ev->u.uhval = (sal_uInt64)ev->u.lval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_ulong:
+                    ev->u.uhval = (sal_uInt64)ev->u.ulval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_hyper:
+                    if ((sal_uInt64)ev->u.hval < 0 && ev->u.hval != MAXUINT64)
+                        return NULL;
+                    ev->u.uhval = (sal_uInt64)ev->u.hval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_uhyper:
+                    return ev;
+                case ET_boolean:
+                    ev->u.uhval = (sal_uInt64)ev->u.bval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_float:
+                    if (ev->u.fval < 0.0 || (sal_uInt64)ev->u.fval > MAXUINT64)
+                        return NULL;
+                    ev->u.uhval = (sal_uInt64)ev->u.fval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_double:
+                    if (ev->u.dval < 0.0 || (sal_uInt64)ev->u.dval > MAXUINT64)
+                        return NULL;
+                    ev->u.uhval = (sal_uInt64)ev->u.dval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_char:
+                    if (ev->u.cval < 0)
+                        return NULL;
+                    ev->u.uhval = (sal_uInt64)ev->u.cval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_byte:
+                    ev->u.uhval = (sal_uInt64)ev->u.byval;
+                    ev->et = ET_uhyper;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_boolean:
+            switch (ev->et)
+            {
+                case ET_short:
+                    ev->u.bval = (ev->u.sval == 0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_ushort:
+                    ev->u.bval = (ev->u.usval == 0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_long:
+                    ev->u.bval = (ev->u.lval == 0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_ulong:
+                    ev->u.bval = (ev->u.ulval == 0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_hyper:
+                    ev->u.bval = (ev->u.hval == 0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_uhyper:
+                    ev->u.bval = (ev->u.uhval == 0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_boolean:
+                    return ev;
+                case ET_float:
+                    ev->u.bval = (ev->u.fval == 0.0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_double:
+                    ev->u.bval = (ev->u.dval == 0.0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_char:
+                    ev->u.bval = (ev->u.cval == 0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_byte:
+                    ev->u.bval = (ev->u.byval == 0) ? sal_False : sal_True;
+                    ev->et = ET_boolean;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_float:
+            switch (ev->et)
+            {
+                case ET_short:
+                    ev->u.fval = (float)ev->u.sval;
+                    ev->et = ET_float;
+                    return ev;
+                case ET_ushort:
+                    ev->u.fval = (float)ev->u.usval;
+                    ev->et = ET_float;
+                    return ev;
+                case ET_long:
+                    ev->u.fval = (float)ev->u.lval;
+                    ev->et = ET_float;
+                    return ev;
+                case ET_ulong:
+                    ev->u.fval = (float)ev->u.ulval;
+                    ev->et = ET_float;
+                    return ev;
+                case ET_hyper:
+                    ev->u.fval = (float)ev->u.hval;
+                    ev->et = ET_float;
+                    return ev;
+                case ET_uhyper:
+                    if ((float)ev->u.ulval > FLT_MAX)
+                        return NULL;
+                    ev->u.fval = (float)ev->u.ulval;
+                    ev->et = ET_float;
+                    return ev;
+                    return NULL;
+                case ET_boolean:
+                    ev->u.fval = (ev->u.bval == sal_True) ? 1.0f : 0.0f;
+                    ev->et = ET_float;
+                    return ev;
+                case ET_float:
+                    return ev;
+                case ET_double:
+                    if ((float)ev->u.dval > FLT_MAX || (float)ev->u.dval < -FLT_MAX)
+                        return NULL;
+                    ev->u.fval = (float)ev->u.dval;
+                    ev->et = ET_float;
+                    return ev;
+                case ET_char:
+                    ev->u.fval = (float)ev->u.cval;
+                    ev->et = ET_float;
+                    return ev;
+                case ET_byte:
+                    ev->u.fval = (float)ev->u.byval;
+                    ev->et = ET_float;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_double:
+            switch (ev->et)
+            {
+                case ET_short:
+                    ev->u.dval = (double)ev->u.sval;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_ushort:
+                    ev->u.dval = (double)ev->u.usval;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_long:
+                    ev->u.dval = (double)ev->u.lval;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_ulong:
+                    ev->u.dval = (double)ev->u.ulval;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_hyper:
+                    ev->u.dval = (double)ev->u.hval;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_uhyper:
+                    if ((double)ev->u.dval > FLT_MAX || (double)ev->u.dval < -FLT_MAX)
+                        return NULL;
+                    ev->u.dval = (double)ev->u.ulval;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_boolean:
+                    ev->u.dval = (ev->u.bval == sal_True) ? 1.0 : 0.0;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_float:
+                    ev->u.dval = (double)ev->u.fval;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_double:
+                    return ev;
+                case ET_char:
+                    ev->u.dval = (double)ev->u.cval;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_byte:
+                    ev->u.dval = (double)ev->u.byval;
+                    ev->et = ET_double;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_char:
+            switch (ev->et)
+            {
+                case ET_short:
+                    if ((sal_Char)ev->u.sval > MAXCHAR || (sal_Char)ev->u.sval < MINCHAR)
+                        return NULL;
+                    ev->u.cval = (sal_Char)ev->u.sval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_ushort:
+                    if ((sal_Char)ev->u.usval > MAXCHAR)
+                        return NULL;
+                    ev->u.cval = (sal_Char)ev->u.usval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_long:
+                    if ((sal_Char)ev->u.lval > MAXCHAR || (sal_Char)ev->u.lval < MINCHAR)
+                        return NULL;
+                    ev->u.cval = (sal_Char)ev->u.lval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_ulong:
+                    if ((sal_Char)ev->u.ulval > MAXCHAR)
+                        return NULL;
+                    ev->u.cval = (sal_Char)ev->u.ulval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_hyper:
+                    if ((sal_Char)ev->u.hval > MAXCHAR || (sal_Char)ev->u.hval < MINCHAR)
+                        return NULL;
+                    ev->u.cval = (sal_Char)ev->u.hval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_uhyper:
+                    if ((sal_Char)ev->u.ulval > MAXCHAR)
+                        return NULL;
+                    ev->u.cval = (sal_Char)ev->u.uhval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_boolean:
+                    ev->u.cval = (sal_Char)ev->u.bval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_float:
+                    if ((sal_Char)ev->u.fval > MAXCHAR || (sal_Char)ev->u.fval < MINCHAR)
+                        return NULL;
+                    ev->u.cval = (sal_Char)ev->u.fval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_double:
+                    if ((sal_Char)ev->u.dval > MAXCHAR || (sal_Char)ev->u.dval < MINCHAR)
+                        return NULL;
+                    ev->u.cval = (sal_Char)ev->u.dval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_char:
+                    return ev;
+                case ET_byte:
+                    if ((sal_Char)ev->u.byval > MAXCHAR)
+                        return NULL;
+                    ev->u.cval = (sal_Char)ev->u.byval;
+                    ev->et = ET_char;
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_byte:
+            switch (ev->et)
+            {
+                case ET_short:
+                    if (ev->u.sval < 0 || (sal_uChar)ev->u.sval > (MAXCHAR << 1))
+                        return NULL;
+                    ev->u.byval = (sal_uChar)ev->u.sval;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_ushort:
+                    if ((sal_uChar)ev->u.usval > (MAXCHAR << 1))
+                        return NULL;
+                    ev->u.byval = (sal_uChar)ev->u.usval;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_long:
+                    if (ev->u.lval < 0 || (sal_uChar)ev->u.lval > (MAXCHAR << 1))
+                        return NULL;
+                    ev->u.byval = (sal_uChar) ev->u.lval;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_ulong:
+                    if ((sal_uChar)ev->u.ulval > (MAXCHAR << 1))
+                        return NULL;
+                    ev->u.byval = (sal_uChar) ev->u.ulval;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_hyper:
+                    if (ev->u.hval < 0 || (sal_uChar)ev->u.hval > (MAXCHAR << 1))
+                        return NULL;
+                    ev->u.byval = (sal_uChar) ev->u.hval;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_uhyper:
+                    if ((sal_uChar)ev->u.uhval > (MAXCHAR << 1))
+                        return NULL;
+                    ev->u.byval = (sal_uChar) ev->u.uhval;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_boolean:
+                    ev->u.byval = (ev->u.bval == sal_False) ? 1 : 0;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_float:
+                    if (ev->u.fval < 0.0 || (sal_uChar)ev->u.fval > (MAXCHAR << 1))
+                        return NULL;
+                    ev->u.byval = (sal_uChar) ev->u.fval;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_double:
+                    if (ev->u.dval < 0.0 || (sal_uChar)ev->u.dval > (MAXCHAR << 1))
+                        return NULL;
+                    ev->u.byval = (sal_uChar) ev->u.dval;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_char:
+                    if (ev->u.cval < 0)
+                        return NULL;
+                    ev->u.byval = (sal_uChar) ev->u.cval;
+                    ev->et = ET_byte;
+                    return ev;
+                case ET_byte:
+                    return ev;
+                case ET_string:
+                case ET_any:
+                case ET_void:
+                case ET_type:
+                case ET_none:
+                    return NULL;
+            }
+        case ET_any:
+            switch (ev->et)
+            {
+                case ET_any:
+                    return ev;
+                default:
+                    return NULL;
+            }
+        case ET_void:
+            switch (ev->et)
+            {
+                case ET_void:
+                    return ev;
+                default:
+                    return NULL;
+            }
+        case ET_type:
+            switch (ev->et)
+            {
+                case ET_type:
+                    return ev;
+                default:
+                    return NULL;
+            }
+        case ET_none:
+            return NULL;
+        case ET_string:
+            switch (ev->et)
+            {
+                case ET_string:
+                    return ev;
+                default:
+                    return NULL;
+            }
+      }
+
+    return NULL;
+}
+
+/*
+ * Evaluate the expression with the evaluation kind requested. Supported
+ * evaluation kinds are
+ * - EK_const:      The expression must evaluate to a constant
+ * - EK_positive_int:   The expression must further evaluate to a
+ *          positive integer
+ */
+static AstExprValue *
+eval_kind(AstExprValue *ev, EvalKind ek)
+{
+    if (ek == EK_const)
+        return ev;
+    if (ek == EK_positive_int)
+        return coerce_value(ev, ET_ulong);
+
+    return NULL;
+}
+
+
+
+AstExprValue* AstExpression::eval(EvalKind ek)
+{
+    AstExprValue *v = NULL;
+
+    /*
+     * Call internal evaluator which does not coerce value to
+     * EvalKind-expected format
+     */
+    v = eval_internal(ek);
+    /*
+     * Then coerce according to EvalKind-expected format
+     */
+    return eval_kind(v, ek);
+}
+
+AstExprValue* AstExpression::coerce(ExprType t, sal_Bool bAssign)
+{
+    AstExprValue *copy;
+
+    /*
+     * Is it already of the right type?
+     */
+    if (m_exprValue != NULL && m_exprValue->et == t)
+        return m_exprValue;
+    /*
+     * OK, must coerce
+     *
+     * First, evaluate it, then try to coerce result type
+     * If already evaluated, return the result
+     */
+    m_exprValue = eval_internal(EK_const);
+    if (m_exprValue == NULL)
+        return NULL;
+
+    /*
+     * Create a copy to contain coercion result
+     */
+    copy = new AstExprValue;
+
+    copy->et = m_exprValue->et;
+    switch (m_exprValue->et)
+    {
+        case ET_void:
+        case ET_none:
+        case ET_any:
+            return NULL;
+        case ET_short:
+            copy->u.sval = m_exprValue->u.sval;
+            break;
+        case ET_ushort:
+            copy->u.usval = m_exprValue->u.usval;
+            break;
+        case ET_long:
+            copy->u.lval = m_exprValue->u.lval;
+            break;
+        case ET_ulong:
+            copy->u.ulval = m_exprValue->u.ulval;
+            break;
+        case ET_hyper:
+            copy->u.hval = m_exprValue->u.hval;
+            break;
+        case ET_uhyper:
+            copy->u.uhval = m_exprValue->u.uhval;
+            break;
+        case ET_boolean:
+            copy->u.bval = m_exprValue->u.bval;
+            break;
+        case ET_float:
+            copy->u.fval = m_exprValue->u.fval;
+            break;
+        case ET_double:
+            copy->u.dval = m_exprValue->u.dval;
+            break;
+        case ET_char:
+            copy->u.cval = m_exprValue->u.cval;
+            break;
+          case ET_byte:
+            copy->u.byval = m_exprValue->u.byval;
+            break;
+          case ET_string:
+            copy->u.strval = m_exprValue->u.strval;
+            break;
+    }
+
+    if (bAssign)
+    {
+        m_exprValue = coerce_value(copy, t);
+        return m_exprValue;
+    }
+
+    return coerce_value(copy, t);
+}
+
+void AstExpression::evaluate(EvalKind ek)
+{
+    m_exprValue = eval_internal(ek);
+    m_exprValue = eval_kind(m_exprValue, ek);
+}
+
+sal_Bool AstExpression::operator==(AstExpression *pExpr)
+{
+    if (m_combOperator != pExpr->getCombOperator())
+        return sal_False;
+    evaluate(EK_const);
+    pExpr->evaluate(EK_const);
+    if (m_exprValue == NULL || pExpr->getExprValue() == NULL)
+        return sal_False;
+    if (m_exprValue->et != pExpr->getExprValue()->et)
+        return sal_False;
+    switch (m_exprValue->et)
+    {
+        case ET_short:
+            return (m_exprValue->u.sval == pExpr->getExprValue()->u.sval) ? sal_True : sal_False;
+        case ET_ushort:
+            return (m_exprValue->u.usval == pExpr->getExprValue()->u.usval) ? sal_True : sal_False;
+        case ET_long:
+            return (m_exprValue->u.lval == pExpr->getExprValue()->u.lval) ? sal_True : sal_False;
+        case ET_ulong:
+            return (m_exprValue->u.ulval == pExpr->getExprValue()->u.ulval) ? sal_True : sal_False;
+        case ET_hyper:
+            return (m_exprValue->u.hval == pExpr->getExprValue()->u.hval) ? sal_True : sal_False;
+        case ET_uhyper:
+            return (m_exprValue->u.uhval == pExpr->getExprValue()->u.uhval) ? sal_True : sal_False;
+        case ET_float:
+            return (m_exprValue->u.fval == pExpr->getExprValue()->u.fval) ? sal_True : sal_False;
+        case ET_double:
+            return (m_exprValue->u.dval == pExpr->getExprValue()->u.dval) ? sal_True : sal_False;
+        case ET_char:
+            return (m_exprValue->u.cval == pExpr->getExprValue()->u.cval) ? sal_True : sal_False;
+        case ET_byte:
+            return (m_exprValue->u.byval == pExpr->getExprValue()->u.byval) ? sal_True : sal_False;
+        case ET_boolean:
+            return (m_exprValue->u.lval == pExpr->getExprValue()->u.lval) ? sal_True : sal_False;
+        case ET_string:
+            if (m_exprValue->u.strval == NULL)
+            {
+                if (pExpr->getExprValue()->u.strval == NULL)
+                    return sal_True;
+                else
+                    return sal_False;
+            } else
+                if (pExpr->getExprValue()->u.strval == NULL)
+                    return sal_False;
+                else
+                    return (m_exprValue->u.strval == pExpr->getExprValue()->u.strval) ? sal_True : sal_False;
+        case ET_any:
+        case ET_void:
+        case ET_none:
+            return sal_False;
+    }
+
+    return sal_False;
+}
+
+sal_Bool AstExpression::compare(AstExpression *pExpr)
+{
+    if (m_combOperator != pExpr->getCombOperator())
+        return sal_False;
+    evaluate(EK_const);
+    pExpr->evaluate(EK_const);
+    if (m_exprValue == NULL || pExpr->getExprValue() == NULL)
+        return sal_False;
+    if (m_exprValue->et != pExpr->getExprValue()->et)
+        return sal_False;
+    switch (m_exprValue->et)
+    {
+        case ET_short:
+            return (m_exprValue->u.sval == pExpr->getExprValue()->u.sval) ? sal_True : sal_False;
+        case ET_ushort:
+            return (m_exprValue->u.usval == pExpr->getExprValue()->u.usval) ? sal_True : sal_False;
+        case ET_long:
+            return (m_exprValue->u.lval == pExpr->getExprValue()->u.lval) ? sal_True : sal_False;
+        case ET_ulong:
+            return (m_exprValue->u.ulval == pExpr->getExprValue()->u.ulval) ? sal_True : sal_False;
+        case ET_hyper:
+            return (m_exprValue->u.hval == pExpr->getExprValue()->u.hval) ? sal_True : sal_False;
+        case ET_uhyper:
+            return (m_exprValue->u.uhval == pExpr->getExprValue()->u.uhval) ? sal_True : sal_False;
+        case ET_float:
+            return (m_exprValue->u.fval == pExpr->getExprValue()->u.fval) ? sal_True : sal_False;
+        case ET_double:
+            return (m_exprValue->u.dval == pExpr->getExprValue()->u.dval) ? sal_True : sal_False;
+        case ET_char:
+            return (m_exprValue->u.cval == pExpr->getExprValue()->u.cval) ? sal_True : sal_False;
+        case ET_byte:
+            return (m_exprValue->u.byval == pExpr->getExprValue()->u.byval) ? sal_True : sal_False;
+        case ET_boolean:
+            return (m_exprValue->u.lval == pExpr->getExprValue()->u.lval) ? sal_True : sal_False;
+        case ET_string:
+            if (m_exprValue->u.strval == NULL)
+            {
+                if (pExpr->getExprValue()->u.strval == NULL)
+                    return sal_True;
+                else
+                    return sal_False;
+            } else
+                if (pExpr->getExprValue()->u.strval == NULL)
+                    return sal_False;
+                else
+                    return (m_exprValue->u.strval == pExpr->getExprValue()->u.strval) ? sal_True : sal_False;
+        case ET_any:
+        case ET_void:
+        case ET_none:
+            return sal_False;
+    }
+
+    return sal_False;
+}
+
+void AstExpression::fillDefinitionDetails()
+{
+    m_pScope = idlc()->scopes()->depth() > 0 ? idlc()->scopes()->top() : NULL;
+    m_lineNo = idlc()->getLineNumber();
+    m_fileName = idlc()->getFileName();
+}
+
+AstExprValue* AstExpression::eval_internal(EvalKind ek)
+{
+    /*
+     * Already evaluated?
+     */
+    if ( m_exprValue != NULL )
+        return eval_kind(m_exprValue, ek);
+    /*
+     * OK, must evaluate operator
+     */
+    switch (m_combOperator)
+    {
+        case EC_add:
+        case EC_minus:
+        case EC_mul:
+        case EC_div:
+        case EC_mod:
+            m_exprValue = eval_bin_op(ek);
+            return eval_kind(m_exprValue, ek);
+        case EC_or:
+        case EC_xor:
+        case EC_and:
+        case EC_left:
+        case EC_right:
+            m_exprValue = eval_bit_op(ek);
+            return eval_kind(m_exprValue, ek);
+        case EC_u_plus:
+        case EC_u_minus:
+        case EC_bit_neg:
+            m_exprValue = eval_un_op(ek);
+            return eval_kind(m_exprValue, ek);
+        case EC_symbol:
+            m_exprValue = eval_symbol(ek);
+            return eval_kind(m_exprValue, ek);
+        case EC_none:
+            return NULL;
+    }
+
+    return NULL;
+}
+
+AstExprValue* AstExpression::eval_bin_op(EvalKind ek)
+{
+    AstExprValue *retval = NULL;
+    ExprType eType = ET_double;
+
+    if ( m_combOperator == EC_mod )
+        eType = ET_hyper;
+
+    if (ek != EK_const && ek != EK_positive_int)
+        return NULL;
+    if (m_subExpr1 == NULL || m_subExpr2 == NULL)
+        return NULL;
+    m_subExpr1->setExprValue(m_subExpr1->eval_internal(ek));
+    if (m_subExpr1->getExprValue() == NULL)
+        return NULL;
+    m_subExpr1->setExprValue(m_subExpr1->coerce(eType));
+    if (m_subExpr1->getExprValue() == NULL)
+        return NULL;
+    m_subExpr2->setExprValue(m_subExpr2->eval_internal(ek));
+    if (m_subExpr2->getExprValue() == NULL)
+        return NULL;
+    m_subExpr2->setExprValue(m_subExpr2->coerce(eType));
+    if (m_subExpr2->getExprValue() == NULL)
+        return NULL;
+
+    retval = new AstExprValue();
+    retval->et = eType;
+
+    switch (m_combOperator)
+    {
+        case EC_mod:
+            if (m_subExpr2->getExprValue()->u.hval == 0)
+                return NULL;
+            retval->u.hval = m_subExpr1->getExprValue()->u.hval % m_subExpr2->getExprValue()->u.hval;
+            break;
+        case EC_add:
+            retval->u.dval = m_subExpr1->getExprValue()->u.dval + m_subExpr2->getExprValue()->u.dval;
+            break;
+        case EC_minus:
+            retval->u.dval = m_subExpr1->getExprValue()->u.dval - m_subExpr2->getExprValue()->u.dval;
+            break;
+        case EC_mul:
+            retval->u.dval = m_subExpr1->getExprValue()->u.dval * m_subExpr2->getExprValue()->u.dval;
+            break;
+        case EC_div:
+            if (m_subExpr2->getExprValue()->u.dval == 0.0)
+            return NULL;
+            retval->u.dval = m_subExpr1->getExprValue()->u.dval / m_subExpr2->getExprValue()->u.dval;
+            break;
+        default:
+            return NULL;
+    }
+
+    return retval;
+}
+
+AstExprValue* AstExpression::eval_bit_op(EvalKind ek)
+{
+    AstExprValue    *retval = NULL;
+
+    if (ek != EK_const && ek != EK_positive_int)
+        return NULL;
+    if (m_subExpr1 == NULL || m_subExpr2 == NULL)
+        return NULL;
+    m_subExpr1->setExprValue(m_subExpr1->eval_internal(ek));
+    if (m_subExpr1->getExprValue() == NULL)
+        return NULL;
+    m_subExpr1->setExprValue(m_subExpr1->coerce(ET_long));
+    if (m_subExpr1->getExprValue() == NULL)
+        return NULL;
+    m_subExpr2->setExprValue(m_subExpr2->eval_internal(ek));
+    if (m_subExpr2->getExprValue() == NULL)
+        return NULL;
+    m_subExpr2->setExprValue(m_subExpr2->coerce(ET_long));
+    if (m_subExpr2->getExprValue() == NULL)
+        return NULL;
+
+    retval = new AstExprValue;
+    retval->et = ET_long;
+
+    switch (m_combOperator)
+    {
+        case EC_or:
+            retval->u.lval = m_subExpr1->getExprValue()->u.lval | m_subExpr2->getExprValue()->u.lval;
+            break;
+        case EC_xor:
+            retval->u.lval = m_subExpr1->getExprValue()->u.lval ^ m_subExpr2->getExprValue()->u.lval;
+            break;
+        case EC_and:
+            retval->u.lval = m_subExpr1->getExprValue()->u.lval & m_subExpr2->getExprValue()->u.lval;
+            break;
+        case EC_left:
+            retval->u.lval = m_subExpr1->getExprValue()->u.lval << m_subExpr2->getExprValue()->u.lval;
+            break;
+        case EC_right:
+            retval->u.lval = m_subExpr1->getExprValue()->u.lval >> m_subExpr2->getExprValue()->u.lval;
+            break;
+        default:
+            return NULL;
+    }
+
+    return retval;
+}
+
+AstExprValue* AstExpression::eval_un_op(EvalKind ek)
+{
+    AstExprValue    *retval = NULL;
+
+    if (m_exprValue != NULL)
+        return m_exprValue;
+
+    if (ek != EK_const && ek != EK_positive_int)
+        return NULL;
+    if (m_subExpr1 == NULL)
+        return NULL;
+    m_subExpr1->setExprValue(m_subExpr1->eval_internal(ek));
+    if (m_subExpr1->getExprValue() == NULL)
+        return NULL;
+    m_subExpr1->setExprValue(m_subExpr1->coerce(ET_double));
+    if (m_subExpr1->getExprValue() == NULL)
+        return NULL;
+
+    retval = new AstExprValue();
+    retval->et = ET_double;
+
+    switch (m_combOperator)
+    {
+        case EC_u_plus:
+            retval->u.lval = m_subExpr1->getExprValue()->u.lval;
+            break;
+        case EC_u_minus:
+            retval->u.lval = -(m_subExpr1->getExprValue()->u.lval);
+            break;
+        case EC_bit_neg:
+            m_subExpr1->setExprValue(m_subExpr1->coerce(ET_long));
+            if (m_subExpr1->getExprValue() == NULL)
+                return NULL;
+            retval->u.lval = ~m_subExpr1->getExprValue()->u.lval;
+            break;
+        default:
+            return NULL;
+    }
+
+    return retval;
+}
+
+AstExprValue* AstExpression::eval_symbol(EvalKind ek)
+{
+    AstScope        *pScope;
+    AstDeclaration  *pDecl;
+    AstConstant     *pConst;
+
+    /*
+     * Is there a symbol stored?
+     */
+    if (m_pSymbolicName == NULL)
+    {
+        idlc()->error()->evalError(this);
+        return NULL;
+    }
+    /*
+     * Get current scope for lookup
+     */
+    if (idlc()->scopes()->depth() > 0)
+        pScope = idlc()->scopes()->topNonNull();
+    if ( !pScope )
+    {
+        idlc()->error()->lookupError(*m_pSymbolicName);
+        return NULL;
+    }
+    /*
+     * Do lookup
+     */
+    pDecl = pScope->lookupByName(*m_pSymbolicName);
+    if (pDecl == NULL)
+    {
+        idlc()->error()->lookupError(*m_pSymbolicName);
+        return NULL;
+    }
+    /*
+     * Is it a constant?
+     */
+    if (pDecl->getNodeType() != NT_const &&
+        pDecl->getNodeType() != NT_enum_val)
+    {
+        idlc()->error()->constantExpected(pDecl, *m_pSymbolicName);
+        return NULL;
+    }
+    /*
+     * OK, now evaluate the constant we just got, to produce its value
+     */
+    pConst = reinterpret_cast< AstConstant* >(pDecl);
+    if (pConst == NULL)
+        return NULL;
+    return pConst->getConstValue()->eval_internal(ek);
+}
+
+OString AstExpression::toString()
+{
+    OString exprStr;
+    if ( m_combOperator == EC_symbol )
+        return *m_pSymbolicName;
+
+    if ( m_exprValue )
+    {
+        switch (m_exprValue->et)
+        {
+            case ET_short:
+                return OString::valueOf((sal_Int32)m_exprValue->u.sval);
+            case ET_ushort:
+                return OString::valueOf((sal_Int32)m_exprValue->u.usval);
+            case ET_long:
+                return OString::valueOf(m_exprValue->u.lval);
+            case ET_ulong:
+                return OString::valueOf((sal_Int64)m_exprValue->u.ulval);
+            case ET_hyper:
+                return OString::valueOf(m_exprValue->u.hval);
+            case ET_uhyper:
+                return OString::valueOf((sal_Int64)m_exprValue->u.uhval);
+            case ET_float:
+                return OString::valueOf(m_exprValue->u.fval);
+            case ET_double:
+                return OString::valueOf(m_exprValue->u.dval);
+            case ET_char:
+                return OString::valueOf(m_exprValue->u.cval);
+            case ET_byte:
+                return OString::valueOf((sal_Int32)m_exprValue->u.byval);
+            case ET_boolean:
+                if ( m_exprValue->u.lval == 0)
+                    return OString("FALSE");
+                else
+                    return OString("TRUE");
+            case ET_string:
+                return *(m_exprValue->u.strval);
+            case ET_any:
+            case ET_void:
+            case ET_none:
+                return OString();
+        }
+    }
+
+    switch (m_combOperator)
+    {
+        case EC_u_plus:
+            exprStr += OString("+");
+            break;
+        case EC_u_minus:
+            exprStr += OString("-");
+            break;
+        case EC_bit_neg:
+            exprStr += OString("~");
+    }
+    if ( m_subExpr1 )
+        exprStr += m_subExpr1->toString();
+    switch (m_combOperator)
+    {
+        case EC_add:
+            exprStr += OString(" + ");
+            break;
+        case EC_minus:
+            exprStr += OString(" - ");
+            break;
+        case EC_mul:
+            exprStr += OString(" * ");
+            break;
+        case EC_div:
+            exprStr += OString(" / ");
+            break;
+        case EC_mod:
+            exprStr += OString(" % ");
+            break;
+        case EC_or:
+            exprStr += OString(" | ");
+            break;
+        case EC_xor:
+            exprStr += OString(" ^ ");
+            break;
+        case EC_and:
+            exprStr += OString(" & ");
+            break;
+        case EC_left:
+            exprStr += OString(" << ");
+            break;
+        case EC_right:
+            exprStr += OString(" >> ");
+            break;
+    }
+
+    if ( m_subExpr2 )
+        exprStr += m_subExpr2->toString();
+
+    return exprStr;
+}
+
+// Convert the type of an AST_Expression to a char *
+sal_Char* SAL_CALL exprTypeToString(ExprType t)
+{
+    switch (t)
+    {
+        case ET_short:
+            return "short";
+        case ET_ushort:
+            return "unsigned short";
+        case ET_long:
+            return "long";
+        case ET_ulong:
+            return "unsigned long";
+        case ET_hyper:
+            return "hyper";
+        case ET_uhyper:
+            return "unsigned hyper";
+        case ET_float:
+            return "float";
+        case ET_double:
+            return "double";
+        case ET_char:
+            return "char";
+        case ET_byte:
+            return "byte";
+        case ET_boolean:
+            return "boolean";
+        case ET_string:
+            return "string";
+        case ET_any:
+            return "any";
+        case ET_type:
+            return "type";
+        case ET_void:
+            return "void";
+        case ET_none:
+            return "none";
+    }
+
+    return ("unkown");
+}
diff --git a/idlc/source/astinterface.cxx b/idlc/source/astinterface.cxx
new file mode 100644
index 000000000000..2215d9cfa110
--- /dev/null
+++ b/idlc/source/astinterface.cxx
@@ -0,0 +1,160 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astinterface.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTINTERFACE_HXX_
+#include <idlc/astinterface.hxx>
+#endif
+#ifndef _IDLC_ASTATTRIBUTE_HXX_
+#include <idlc/astattribute.hxx>
+#endif
+#ifndef _IDLC_ASTOPERATION_HXX_
+#include <idlc/astoperation.hxx>
+#endif
+
+using namespace ::rtl;
+
+AstInterface::AstInterface(const ::rtl::OString& name,
+                           DeclList* pInherits,
+                           sal_Bool bIsDefined,
+                           AstScope* pScope)
+    : AstType(NT_interface, name, pScope)
+    , AstScope(NT_interface)
+    , m_bIsDefined(bIsDefined)
+    , m_bForwarded(sal_False)
+    , m_bForwardedInSameFile(sal_False)
+{
+    if ( pInherits )
+        m_inheritedInterfaces = *pInherits;
+}
+
+AstInterface::~AstInterface()
+{
+}
+
+sal_Bool AstInterface::dump(RegistryKey& rKey, RegistryTypeWriterLoader* pLoader)
+{
+    if ( !isDefined() )
+        return sal_True;
+
+    RegistryKey localKey;
+    if (rKey.createKey( OStringToOUString(getFullName(), RTL_TEXTENCODING_UTF8 ), localKey))
+    {
+        fprintf(stderr, "%s: warning, could not create key '%s' in '%s'\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName().getStr(), rKey.getRegistryName().getStr());
+        return sal_False;
+    }
+
+    sal_uInt16 nAttributes = getNodeCount(NT_attribute);
+    sal_uInt16 nMethods = getNodeCount(NT_operation);
+    OUString uBaseTypeName;
+    if ( m_inheritedInterfaces.size() )
+        uBaseTypeName = OStringToOUString(
+                            m_inheritedInterfaces.front()->getRelativName(),
+                            RTL_TEXTENCODING_UTF8);
+
+    RegistryTypeWriter aBlob(pLoader->getApi(), RT_TYPE_INTERFACE,
+                             OStringToOUString(getRelativName(), RTL_TEXTENCODING_UTF8),
+                             uBaseTypeName, nAttributes, nMethods, 0);
+
+    aBlob.setDoku( getDocumentation() );
+    aBlob.setFileName( OStringToOUString(getFileName(), RTL_TEXTENCODING_UTF8));
+
+    RTUik aUik;
+    aUik.m_Data1 = 0;
+    aUik.m_Data2 = 0;
+    aUik.m_Data3 = 0;
+    aUik.m_Data4 = 0;
+    aUik.m_Data5 = 0;
+    aBlob.setUik(aUik);
+
+    DeclList::iterator iter = getIteratorBegin();
+    DeclList::iterator end = getIteratorEnd();
+    AstDeclaration* pDecl = NULL;
+    sal_uInt16  attrIndex = 0;
+    sal_uInt16  methodIndex = 0;
+    while ( iter != end )
+    {
+        pDecl = *iter;
+        if ( pDecl->getNodeType() == NT_attribute )
+        {
+            ((AstAttribute*)pDecl)->dumpBlob(aBlob, attrIndex++);
+        } else
+        if ( pDecl->getNodeType() == NT_operation )
+        {
+            ((AstOperation*)pDecl)->dumpBlob(aBlob, methodIndex++);
+        }
+
+        iter++;
+    }
+
+    const sal_uInt8*    pBlob = aBlob.getBlop();
+    sal_uInt32          aBlobSize = aBlob.getBlopSize();
+
+    if (localKey.setValue(OUString(), RG_VALUETYPE_BINARY, (RegValue)pBlob, aBlobSize))
+    {
+        fprintf(stderr, "%s: warning, could not set value of key \"%s\" in %s\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName(), localKey.getRegistryName());
+        return sal_False;
+    }
+
+    return AstDeclaration::dump(rKey, pLoader);
+}
diff --git a/idlc/source/astoperation.cxx b/idlc/source/astoperation.cxx
new file mode 100644
index 000000000000..9263cd79c7d9
--- /dev/null
+++ b/idlc/source/astoperation.cxx
@@ -0,0 +1,196 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astoperation.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTOPERATION_HXX_
+#include <idlc/astoperation.hxx>
+#endif
+#ifndef _IDLC_ASTTYPE_HXX_
+#include <idlc/asttype.hxx>
+#endif
+#ifndef _IDLC_ASTBASETYPE_HXX_
+#include <idlc/astbasetype.hxx>
+#endif
+#ifndef _IDLC_ASTPARAMETER_HXX_
+#include <idlc/astparameter.hxx>
+#endif
+#ifndef _IDLC_ERRORHANDLER_HXX_
+#include <idlc/errorhandler.hxx>
+#endif
+
+using namespace ::rtl;
+
+void AstOperation::addExceptions(StringList* pExceptions)
+{
+    if ( isOneway() )
+    {
+        idlc()->error()->error1(EIDL_ONEWAY_RAISE_CONFLICT, this);
+    }
+
+    StringList::iterator iter = pExceptions->begin();
+    StringList::iterator end = pExceptions->end();
+    AstDeclaration* pDecl = NULL;
+    while ( iter != end)
+    {
+        pDecl = lookupByName(*iter);
+        if ( !pDecl )
+        {
+            idlc()->error()->lookupError(*iter);
+            return;
+        }
+        if ( (pDecl->getNodeType() == NT_exception) )
+        {
+            m_exceptions.push_back(pDecl);
+        } else
+        {
+            idlc()->error()->error1(EIDL_ILLEGAL_RAISES, this);
+        }
+        iter++;
+    }
+}
+
+sal_Bool AstOperation::isVoid()
+{
+    if ( m_pReturnType && (m_pReturnType->getNodeType() == NT_predefined) )
+    {
+        if ( ((AstBaseType*)m_pReturnType)->getExprType() == ET_void )
+            return sal_True;
+    }
+    return sal_False;
+}
+
+sal_Bool AstOperation::dumpBlob(RegistryTypeWriter& rBlob, sal_uInt16 index)
+{
+    sal_uInt16      nParam = getNodeCount(NT_parameter);
+    sal_uInt16      nExcep = nExceptions();
+    RTMethodMode    methodMode = RT_MODE_TWOWAY;
+
+    if ( isOneway() )
+        methodMode = RT_MODE_ONEWAY;
+
+    rBlob.setMethodData(index, OStringToOUString(getLocalName(), RTL_TEXTENCODING_UTF8),
+                        OStringToOUString(getReturnType()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                        methodMode, nParam, nExcep, getDocumentation());
+
+    if ( nParam )
+    {
+        DeclList::iterator iter = getIteratorBegin();
+        DeclList::iterator end = getIteratorEnd();
+        AstDeclaration* pDecl = NULL;
+        AstParameter* pParam = NULL;
+        RTParamMode paramMode;
+        sal_uInt16 paramIndex = 0;
+        while ( iter != end )
+        {
+            pDecl = *iter;
+            if ( pDecl->getNodeType() == NT_parameter )
+            {
+                AstParameter* pParam = (AstParameter*)pDecl;
+                switch (pParam->getDirection())
+                {
+                    case DIR_IN :
+                        paramMode = RT_PARAM_IN;
+                        break;
+                    case DIR_OUT :
+                        paramMode = RT_PARAM_OUT;
+                        break;
+                    case DIR_INOUT :
+                        paramMode = RT_PARAM_INOUT;
+                        break;
+                }
+
+                rBlob.setParamData(index, paramIndex++,
+                           OStringToOUString(pParam->getType()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                           OStringToOUString(pDecl->getLocalName(), RTL_TEXTENCODING_UTF8),
+                           paramMode);
+            }
+            iter++;
+        }
+    }
+
+    if ( nExcep )
+    {
+        DeclList::iterator iter = m_exceptions.begin();
+        DeclList::iterator end = m_exceptions.end();
+        sal_uInt16 exceptIndex = 0;
+        while ( iter != end )
+        {
+            rBlob.setExcData(index, exceptIndex++,
+                             OStringToOUString((*iter)->getRelativName(), RTL_TEXTENCODING_UTF8) );
+            iter++;
+        }
+    }
+
+    return sal_True;
+}
+
+AstDeclaration* AstOperation::addDeclaration(AstDeclaration* pDecl)
+{
+    if ( pDecl->getNodeType() == NT_parameter )
+    {
+        AstParameter* pParam = (AstParameter*)pDecl;
+        if ( isOneway() &&
+             (pParam->getDirection() == DIR_OUT || pParam->getDirection() == DIR_INOUT) )
+        {
+            idlc()->error()->error2(EIDL_ONEWAY_CONFLICT, pDecl, this);
+            return NULL;
+        }
+    }
+    return AstScope::addDeclaration(pDecl);
+}
diff --git a/idlc/source/astscope.cxx b/idlc/source/astscope.cxx
new file mode 100644
index 000000000000..abc7f112b389
--- /dev/null
+++ b/idlc/source/astscope.cxx
@@ -0,0 +1,385 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astscope.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTSCOPE_HXX_
+#include <idlc/astscope.hxx>
+#endif
+#ifndef _IDLC_ASTBASETYPE_HXX_
+#include <idlc/astbasetype.hxx>
+#endif
+#ifndef _IDLC_ASTINERFACE_HXX_
+#include <idlc/astinterface.hxx>
+#endif
+#ifndef _IDLC_ERRORHANDLER_HXX_
+#include <idlc/errorhandler.hxx>
+#endif
+
+
+using namespace ::rtl;
+
+sal_Bool isGlobal(const OString& scopedName)
+{
+    if ((scopedName.getLength() == 0) || (scopedName.indexOf(':') == 0))
+    {
+        return sal_True;
+    }
+    return sal_False;
+}
+
+AstScope::AstScope(NodeType nodeType)
+    : m_nodeType(nodeType)
+{
+
+}
+
+AstScope::~AstScope()
+{
+
+}
+
+AstDeclaration* AstScope::addDeclaration(AstDeclaration* pDecl)
+{
+    AstDeclaration* pDeclaration = NULL;
+
+    if ((pDeclaration = lookupForAdd(pDecl)) != NULL)
+    {
+        if (pDecl->getNodeType() == NT_union_branch )
+        {
+            m_declarations.push_back(pDecl);
+            return pDecl;
+        }
+        if ( pDecl->hasAncestor(pDeclaration) )
+        {
+            idlc()->error()->error2(EIDL_REDEF_SCOPE, pDecl, pDeclaration);
+            return NULL;
+        }
+        if ( (pDecl->getNodeType() == pDeclaration->getNodeType()) &&
+             ((pDecl->getNodeType() == NT_sequence) || (pDeclaration->getNodeType() == NT_array)) )
+        {
+            return pDeclaration;
+        }
+        if ( (pDeclaration->getNodeType() == NT_interface)
+             && (pDecl->getNodeType() == NT_interface)
+             && !((AstInterface*)pDeclaration)->isDefined() )
+        {
+            m_declarations.push_back(pDecl);
+            return pDecl;
+        }
+
+        idlc()->error()->error2(EIDL_REDEF_SCOPE, scopeAsDecl(this), pDecl);
+        return NULL;
+    }
+
+    m_declarations.push_back(pDecl);
+    return pDecl;
+}
+
+sal_uInt16 AstScope::getNodeCount(NodeType nodeType)
+{
+    DeclList::iterator iter = getIteratorBegin();
+    DeclList::iterator end = getIteratorEnd();
+    AstDeclaration* pDecl = NULL;
+    sal_uInt16 count = 0;
+
+    while ( iter != end )
+    {
+        pDecl = *iter;
+        if ( pDecl->getNodeType() == nodeType )
+            count++;
+        iter++;
+    }
+    return count;
+}
+
+AstDeclaration* AstScope::lookupByName(const OString& scopedName)
+{
+    AstDeclaration* pDecl = NULL;
+    AstScope*       pScope = NULL;
+    if (scopedName.getLength() == 0)
+        return NULL;
+
+    // If name starts with "::" start look up in global scope
+    if ( isGlobal(scopedName) )
+    {
+        pDecl = scopeAsDecl(this);
+        if ( !pDecl )
+            return NULL;
+
+        pScope = pDecl->getScope();
+        // If this is the global scope ...
+        if ( !pScope )
+        {
+            // look up the scopedName part after "::"
+            OString subName = scopedName.copy(2);
+            pDecl = lookupByName(subName);
+            return pDecl;
+            //return pScope->lookupByName();
+        }
+        // OK, not global scope yet, so simply iterate with parent scope
+        pDecl = pScope->lookupByName(scopedName);
+        return pDecl;
+        //return pScope->lookupByName(scopedName);
+    }
+
+    // The name does not start with "::"
+    // Look up in the local scope and start with the first scope
+    OString firstScope = scopedName.indexOf(':') > 0 ?
+                            scopedName.getToken(0, ':') : scopedName;
+    sal_Bool    bFindFirstScope = sal_True;
+    pDecl = lookupByNameLocal(firstScope);
+    if ( !pDecl )
+    {
+        bFindFirstScope = sal_False;
+
+        // OK, not found. Go down parent scope chain
+        pDecl = scopeAsDecl(this);
+        if ( pDecl )
+        {
+            pScope = pDecl->getScope();
+            if ( pScope )
+                   pDecl = pScope->lookupByName(scopedName);
+            else
+                pDecl = NULL;
+
+             // Special case for scope which is an interface. We
+             // have to look in the inherited interfaces as well.
+            if ( !pDecl )
+            {
+                if (m_nodeType == NT_interface)
+                    pDecl = lookupInInherited(scopedName);
+            }
+//          if ( !pDecl )
+//              pDecl = lookupInForwarded(scopedName);
+       }
+    }
+
+    if ( bFindFirstScope && (firstScope != scopedName) )
+    {
+        sal_Int32 count = scopedName.getTokenCount(':');
+        for ( sal_Int32 i = 2; i < count; i += 2 )
+        {
+            pScope = declAsScope(pDecl);
+
+            if ( pScope )
+                pDecl = pScope->lookupByNameLocal(scopedName.getToken(i, ':'));
+
+            if ( !pDecl )
+                return NULL;
+        }
+    }
+
+//  if ( !pDecl )
+//      pDecl = lookupInForwarded(scopedName);
+
+    return pDecl;
+}
+
+AstDeclaration* AstScope::lookupByNameLocal(const OString& name)
+{
+    DeclList::iterator iter = getIteratorBegin();
+    DeclList::iterator end = getIteratorEnd();
+    AstDeclaration* pDecl = NULL;
+
+    while ( iter != end )
+    {
+        pDecl = *iter;
+        if ( pDecl->getLocalName() == name )
+            return pDecl;
+        iter++;
+    }
+    return NULL;
+}
+
+AstDeclaration* AstScope::lookupInInherited(const OString& scopedName)
+{
+    AstDeclaration* pDecl = NULL;
+    AstInterface* pInterface = (AstInterface*)this;
+
+    if ( !pInterface )
+        return NULL;
+
+    // Can't look in an interface which was not yet defined
+    if ( !pInterface->getScope() )
+    {
+        idlc()->error()->forwardLookupError(pInterface, scopedName);
+    }
+
+    // OK, loop through inherited interfaces. Stop when you find it
+    if ( pInterface->nInheritedInterfaces() > 0 )
+    {
+        DeclList::const_iterator iter = pInterface->getInheritedInterfaces().begin();
+        DeclList::const_iterator end = pInterface->getInheritedInterfaces().end();
+
+        while ( iter != end )
+        {
+            pDecl = ((AstInterface*)(*iter))->lookupByName(scopedName);
+            if ( pDecl )
+                return pDecl;;
+        }
+    }
+    // Not found
+    return NULL;
+}
+/*
+AstDeclaration* AstScope::lookupInForwarded(const OString& scopedName)
+{
+    DeclList::iterator iter = getIteratorBegin();
+    DeclList::iterator end = getIteratorEnd();
+    AstDeclaration* pDecl = NULL;
+
+    while ( iter != end )
+    {
+        pDecl = *iter;
+        if ( pDecl->getNodeType() == NT_interface_fwd )
+        {
+            if ( pDecl->getScopedName() == scopedName )
+            {
+                AstInterfaceFwd* pFwd = (AstInterfaceFwd*)pDecl;
+                if ( pFwd )
+                    return pFwd->getFullDefintion();
+            }
+            break;
+        }
+        iter++;
+    }
+    return NULL;
+}
+*/
+AstDeclaration* AstScope::lookupPrimitiveType(ExprType type)
+{
+    AstDeclaration* pDecl = NULL;
+    AstScope*       pScope = NULL;
+    AstBaseType*    pBaseType = NULL;
+    OString         typeName;
+    pDecl = scopeAsDecl(this);
+    if ( !pDecl )
+        return NULL;
+    pScope = pDecl->getScope();
+    if ( pScope)
+        return pScope->lookupPrimitiveType(type);
+
+    switch (type)
+    {
+        case ET_short:
+            typeName = OString("short");
+            break;
+        case ET_ushort:
+            typeName = OString("unsigned short");
+            break;
+        case ET_long:
+            typeName = OString("long");
+            break;
+        case ET_ulong:
+            typeName = OString("unsigned long");
+            break;
+        case ET_hyper:
+            typeName = OString("hyper");
+            break;
+        case ET_uhyper:
+            typeName = OString("unsigned hyper");
+            break;
+        case ET_float:
+            typeName = OString("float");
+            break;
+        case ET_double:
+            typeName = OString("double");
+            break;
+        case ET_char:
+            typeName = OString("char");
+            break;
+        case ET_byte:
+            typeName = OString("byte");
+            break;
+        case ET_boolean:
+            typeName = OString("boolean");
+            break;
+        case ET_any:
+            typeName = OString("any");
+            break;
+        case ET_void:
+            typeName = OString("void");
+            break;
+        case ET_type:
+            typeName = OString("type");
+            break;
+        case ET_string:
+            typeName = OString("string");
+            break;
+    }
+
+    pDecl = lookupByNameLocal(typeName);
+
+    if ( pDecl && (pDecl->getNodeType() == NT_predefined) )
+    {
+        pBaseType = (AstBaseType*)pDecl;
+
+        if ( pBaseType->getExprType() == type )
+            return pDecl;
+    }
+
+    return NULL;
+}
+
+AstDeclaration* AstScope::lookupForAdd(AstDeclaration* pDecl)
+{
+    if ( !pDecl )
+        return NULL;
+   return lookupByNameLocal(pDecl->getLocalName());
+}
diff --git a/idlc/source/aststack.cxx b/idlc/source/aststack.cxx
new file mode 100644
index 000000000000..96e7abeff32f
--- /dev/null
+++ b/idlc/source/aststack.cxx
@@ -0,0 +1,174 @@
+/*************************************************************************
+ *
+ *  $RCSfile: aststack.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _RTL_ALLOC_H_
+#include <rtl/alloc.h>
+#endif
+#ifndef _IDLC_ASTSTACK_HXX_
+#include <idlc/aststack.hxx>
+#endif
+#ifndef _IDLC_ASTSCOPE_HXX_
+#include <idlc/astscope.hxx>
+#endif
+
+#define STACKSIZE_INCREMENT 64
+
+AstStack::AstStack()
+    : m_size(STACKSIZE_INCREMENT)
+    , m_top(0)
+    , m_stack((AstScope**)rtl_allocateZeroMemory(sizeof(AstScope*) * STACKSIZE_INCREMENT))
+{
+}
+
+AstStack::~AstStack()
+{
+    for(sal_uInt32 i=0; i < m_top; i++)
+    {
+        if (m_stack[i])
+            delete(m_stack[i]);
+    }
+
+    rtl_freeMemory(m_stack);
+}
+
+sal_uInt32 AstStack::depth()
+{
+    return m_top;
+}
+
+AstScope* AstStack::top()
+{
+    if (m_top < 1)
+        return NULL;
+    return m_stack[m_top - 1];
+}
+
+AstScope* AstStack::bottom()
+{
+    if (m_top == 0)
+        return NULL;
+    return m_stack[0];
+}
+
+AstScope* AstStack::nextToTop()
+{
+    AstScope *tmp, *retval;
+
+    if (depth() < 2)
+        return NULL;
+
+    tmp = top();        // Save top
+    (void) pop();       // Pop it
+    retval = top();     // Get next one down
+    (void) push(tmp);   // Push top back
+    return retval;      // Return next one down
+}
+
+AstScope* AstStack::topNonNull()
+{
+    for (sal_uInt32 i = m_top - 1; i >= 0; i--)
+    {
+        if ( m_stack[i] )
+            return m_stack[i];
+      }
+    return NULL;
+}
+
+AstStack* AstStack::push(AstScope* pScope)
+{
+    AstScope        **tmp;
+//  AstDeclaration  *pDecl = ScopeAsDecl(pScope);
+    sal_uInt32  newSize;
+    sal_uInt32  i;
+
+    // Make sure there's space for one more
+    if (m_size == m_top)
+    {
+        newSize = m_size;
+        newSize += STACKSIZE_INCREMENT;
+        tmp = (AstScope**)rtl_allocateZeroMemory(sizeof(AstScope*) * newSize);
+
+        for(i=0; i < m_size; i++)
+            tmp[i] = m_stack[i];
+
+        rtl_freeMemory(m_stack);
+        m_stack = tmp;
+    }
+
+    // Insert new scope
+    m_stack[m_top++] = pScope;
+
+    return this;
+}
+
+void AstStack::pop()
+{
+    AstScope *pScope;
+
+    if (m_top < 1)
+        return;
+    pScope = m_stack[--m_top];
+}
+
+void AstStack::clear()
+{
+    m_top = 0;
+}
+
diff --git a/idlc/source/aststruct.cxx b/idlc/source/aststruct.cxx
new file mode 100644
index 000000000000..10dcfa9fc97d
--- /dev/null
+++ b/idlc/source/aststruct.cxx
@@ -0,0 +1,156 @@
+/*************************************************************************
+ *
+ *  $RCSfile: aststruct.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTSTRUCT_HXX_
+#include <idlc/aststruct.hxx>
+#endif
+#ifndef _IDLC_ASTMember_HXX_
+#include <idlc/astmember.hxx>
+#endif
+
+using namespace ::rtl;
+
+AstStruct::AstStruct(const OString& name, AstStruct* pBaseType, AstScope* pScope)
+    : AstType(NT_struct, name, pScope)
+    , AstScope(NT_struct)
+    , m_pBaseType(pBaseType)
+{
+}
+
+AstStruct::AstStruct(const NodeType type,
+                        const OString& name,
+                       AstStruct* pBaseType,
+                     AstScope* pScope)
+    : AstType(type, name, pScope)
+    , AstScope(type)
+    , m_pBaseType(pBaseType)
+{
+}
+
+AstStruct::~AstStruct()
+{
+}
+
+sal_Bool AstStruct::dump(RegistryKey& rKey, RegistryTypeWriterLoader* pLoader)
+{
+    RegistryKey localKey;
+    if (rKey.createKey( OStringToOUString(getFullName(), RTL_TEXTENCODING_UTF8 ), localKey))
+    {
+        fprintf(stderr, "%s: warning, could not create key '%s' in '%s'\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName().getStr(), rKey.getRegistryName().getStr());
+        return sal_False;
+    }
+
+    sal_uInt16 nMember = getNodeCount(NT_member);
+    OUString uBaseTypeName;
+    if ( m_pBaseType )
+        uBaseTypeName = OStringToOUString(m_pBaseType->getRelativName(),
+                                          RTL_TEXTENCODING_UTF8);
+
+    RTTypeClass typeClass = RT_TYPE_STRUCT;
+    if ( getNodeType() == NT_exception )
+        typeClass = RT_TYPE_EXCEPTION;
+
+    RegistryTypeWriter aBlob(pLoader->getApi(), typeClass,
+                             OStringToOUString(getRelativName(), RTL_TEXTENCODING_UTF8),
+                             uBaseTypeName, nMember, 0, 0);
+
+    aBlob.setDoku( getDocumentation() );
+    aBlob.setFileName( OStringToOUString(getFileName(), RTL_TEXTENCODING_UTF8));
+
+    if ( nMember > 0 )
+    {
+        DeclList::iterator iter = getIteratorBegin();
+        DeclList::iterator end = getIteratorEnd();
+        AstDeclaration* pDecl = NULL;
+        AstMember*  pMember = NULL;
+        OUString    docu;
+        sal_uInt16  index = 0;
+        while ( iter != end )
+        {
+            pDecl = *iter;
+            if ( pDecl->getNodeType() == NT_member )
+            {
+                pMember = (AstMember*)pDecl;
+                aBlob.setFieldData(index++,
+                    OStringToOUString(pMember->getLocalName(), RTL_TEXTENCODING_UTF8),
+                    OStringToOUString(pMember->getType()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                    pMember->getDocumentation(), OUString(), RT_ACCESS_READWRITE);
+            }
+            iter++;
+        }
+    }
+
+    const sal_uInt8* pBlob = aBlob.getBlop();
+    sal_uInt32       aBlobSize = aBlob.getBlopSize();
+
+    if (localKey.setValue(OUString(), RG_VALUETYPE_BINARY,
+                            (RegValue)pBlob, aBlobSize))
+    {
+        fprintf(stderr, "%s: warning, could not set value of key \"%s\" in %s\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName(), localKey.getRegistryName());
+        return sal_False;
+    }
+
+    return sal_True;
+}
+
diff --git a/idlc/source/astunion.cxx b/idlc/source/astunion.cxx
new file mode 100644
index 000000000000..71286353d20a
--- /dev/null
+++ b/idlc/source/astunion.cxx
@@ -0,0 +1,430 @@
+/*************************************************************************
+ *
+ *  $RCSfile: astunion.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ASTUNION_HXX_
+#include <idlc/astunion.hxx>
+#endif
+#ifndef _IDLC_ASTBASETYPE_HXX_
+#include <idlc/astbasetype.hxx>
+#endif
+#ifndef _IDLC_ERRORHANDLER_HXX_
+#include <idlc/errorhandler.hxx>
+#endif
+
+using namespace ::rtl;
+
+AstUnion::AstUnion(const ::rtl::OString& name, AstType* pDiscType, AstScope* pScope)
+    : AstStruct(NT_union, name, NULL, pScope)
+    , m_pDiscriminantType(pDiscType)
+    , m_discExprType(ET_long)
+{
+    AstBaseType* pBaseType;
+
+    if ( !pDiscType )
+    {
+        m_pDiscriminantType = NULL;
+        m_discExprType = ET_none;
+        return;
+    }
+    /*
+     * If the discriminator type is a predefined type
+     * then install the equivalent coercion target type in
+     * the pd_udisc_type field.
+     */
+    if ( pDiscType->getNodeType() == NT_predefined )
+    {
+        pBaseType = (AstBaseType*)pDiscType;
+        if ( !pBaseType )
+        {
+            m_pDiscriminantType = NULL;
+            m_discExprType = ET_none;
+            return;
+        }
+        m_pDiscriminantType = pDiscType;
+        switch (pBaseType->getExprType())
+        {
+            case ET_long:
+            case ET_ulong:
+            case ET_short:
+            case ET_ushort:
+            case ET_char:
+            case ET_boolean:
+                m_discExprType = pBaseType->getExprType();
+                break;
+            default:
+                m_discExprType = ET_none;
+                m_pDiscriminantType = NULL;
+                break;
+        }
+    } else
+        if (pDiscType->getNodeType() == NT_enum)
+        {
+            m_discExprType = ET_any;
+            m_pDiscriminantType = pDiscType;
+        } else
+        {
+            m_discExprType = ET_none;
+            m_pDiscriminantType = NULL;
+        }
+
+    if ( !m_pDiscriminantType )
+        idlc()->error()->error2(EIDL_DISC_TYPE, this, pDiscType);
+}
+
+AstUnion::~AstUnion()
+{
+}
+
+AstDeclaration* AstUnion::addDeclaration(AstDeclaration* pDecl)
+{
+    if ( pDecl->getNodeType() == NT_union_branch )
+    {
+        AstUnionBranch* pBranch = (AstUnionBranch*)pDecl;
+        if ( lookupBranch(pBranch) )
+        {
+            idlc()->error()->error2(EIDL_MULTIPLE_BRANCH, this, pDecl);
+            return NULL;
+        }
+    }
+
+    return AstScope::addDeclaration(pDecl);
+}
+
+AstUnionBranch* AstUnion::lookupBranch(AstUnionBranch* pBranch)
+{
+    AstUnionLabel* pLabel = NULL;
+
+    if ( pBranch )
+        pLabel = pBranch->getLabel();
+
+    if ( pLabel )
+    {
+        if (pLabel->getLabelKind() == UL_default)
+            return lookupDefault();
+        if (m_discExprType == ET_any)
+            /* CONVENTION: indicates enum discr */
+            return lookupEnum(pBranch);
+        return lookupLabel(pBranch);
+    }
+    return NULL;
+}
+
+AstUnionBranch* AstUnion::lookupDefault(sal_Bool bReportError)
+{
+    DeclList::iterator iter = getIteratorBegin();
+    DeclList::iterator end = getIteratorEnd();
+    AstUnionBranch      *pBranch = NULL;
+    AstDeclaration      *pDecl = NULL;
+
+    while ( iter != end )
+    {
+        pDecl = *iter;
+        if ( pDecl->getNodeType() == NT_union_branch )
+        {
+            pBranch = (AstUnionBranch*)pDecl;
+            if (pBranch == NULL)
+            {
+                iter++;
+                continue;
+            }
+            if ( pBranch->getLabel() != NULL &&
+                 pBranch->getLabel()->getLabelKind() == UL_default)
+            {
+                if ( bReportError )
+                    idlc()->error()->error2(EIDL_MULTIPLE_BRANCH, this, pBranch);
+                return pBranch;
+            }
+        }
+        iter++;
+    }
+    return NULL;
+}
+
+AstUnionBranch* AstUnion::lookupLabel(AstUnionBranch* pBranch)
+{
+    AstUnionLabel* pLabel = pBranch->getLabel();
+
+    if ( !pLabel->getLabelValue() )
+        return pBranch;
+//  pLabel->getLabelValue()->setExprValue(pLabel->getLabelValue()->coerce(m_discExprType, sal_False));
+    AstExprValue* pLabelValue = NULL;
+    if ( !(pLabelValue = pLabel->getLabelValue()->coerce(m_discExprType, sal_False)) )
+    {
+        idlc()->error()->evalError(pLabel->getLabelValue());
+        return pBranch;
+    } else
+    {
+        pLabel->getLabelValue()->setExprValue(pLabelValue);
+    }
+
+    DeclList::iterator iter = getIteratorBegin();
+    DeclList::iterator end = getIteratorEnd();
+    AstUnionBranch* pB = NULL;
+    AstDeclaration* pDecl = NULL;
+
+    while ( iter != end )
+    {
+        pDecl = *iter;
+        if ( pDecl->getNodeType() == NT_union_branch )
+        {
+            pB = (AstUnionBranch*)pDecl;
+            if ( !pB )
+            {
+                iter++;
+                continue;
+            }
+            if ( pB->getLabel() != NULL &&
+                 pB->getLabel()->getLabelKind() == UL_label &&
+                 pB->getLabel()->getLabelValue()->compare(pLabel->getLabelValue()) )
+            {
+                idlc()->error()->error2(EIDL_MULTIPLE_BRANCH, this, pBranch);
+                return pBranch;
+            }
+        }
+        iter++;
+    }
+    return NULL;
+}
+
+AstUnionBranch* AstUnion::lookupEnum(AstUnionBranch* pBranch)
+{
+    AstType* pType = resolveTypeDef(m_pDiscriminantType);
+    if ( pType->getNodeType() != NT_enum )
+        return NULL;
+
+    AstUnionLabel* pLabel = pBranch->getLabel();
+    AstExpression* pExpr = pLabel->getLabelValue();
+    if ( !pExpr )
+        return pBranch;
+
+    /*
+     * Expecting a symbol label
+     */
+    if ( pExpr->getCombOperator() != EC_symbol)
+    {
+        idlc()->error()->enumValExpected(this, pLabel);
+        return pBranch;
+    }
+
+    /*
+     * See if the symbol defines a constant in the discriminator enum
+     */
+    AstEnum* pEnum = (AstEnum*)pType;
+    AstDeclaration* pDecl = pEnum->lookupByName(*pExpr->getSymbolicName());
+    if ( pDecl == NULL || pDecl->getScope() != pEnum)
+    {
+        idlc()->error()->enumValLookupFailure(this, pEnum, *pExpr->getSymbolicName());
+        return pBranch;
+    }
+
+
+    DeclList::iterator iter = getIteratorBegin();
+    DeclList::iterator end = getIteratorEnd();
+    AstUnionBranch* pB = NULL;
+    pDecl = NULL;
+
+    while ( iter != end )
+    {
+        pDecl = *iter;
+        if ( pDecl->getNodeType() == NT_union_branch )
+        {
+            pB = (AstUnionBranch*)pDecl;
+            if ( !pB )
+            {
+                iter++;
+                continue;
+            }
+            if ( pB->getLabel() != NULL &&
+                 pB->getLabel()->getLabelKind() == UL_label &&
+                 pB->getLabel()->getLabelValue()->compare(pLabel->getLabelValue()) )
+            {
+                idlc()->error()->error2(EIDL_MULTIPLE_BRANCH, this, pBranch);
+                return pBranch;
+            }
+        }
+        iter++;
+    }
+    return NULL;
+}
+
+sal_Bool AstUnion::dump(RegistryKey& rKey, RegistryTypeWriterLoader* pLoader)
+{
+    RegistryKey localKey;
+    if (rKey.createKey( OStringToOUString(getFullName(), RTL_TEXTENCODING_UTF8 ), localKey))
+    {
+        fprintf(stderr, "%s: warning, could not create key '%s' in '%s'\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName().getStr(), rKey.getRegistryName().getStr());
+        return sal_False;
+    }
+
+    sal_uInt16 nMember = getNodeCount(NT_union_branch);
+
+    RegistryTypeWriter aBlob(pLoader->getApi(), RT_TYPE_UNION,
+                             OStringToOUString(getRelativName(), RTL_TEXTENCODING_UTF8),
+                             OStringToOUString(getDiscrimantType()->getScopedName(), RTL_TEXTENCODING_UTF8),
+                             nMember, 0, 0);
+
+    aBlob.setDoku( getDocumentation() );
+    aBlob.setFileName( OStringToOUString(getFileName(), RTL_TEXTENCODING_UTF8));
+
+    if ( nMember > 0 )
+    {
+        DeclList::iterator iter = getIteratorBegin();
+        DeclList::iterator end = getIteratorEnd();
+        AstDeclaration* pDecl = NULL;
+        AstUnionBranch* pBranch = NULL;
+        AstUnionBranch* pDefault = lookupDefault(sal_False);
+        AstUnionLabel*  pLabel = NULL;
+        AstExprValue*   pExprValue = NULL;
+        RTConstValue    aConst;
+        RTFieldAccess   access = RT_ACCESS_READWRITE;
+        OUString    docu;
+        sal_uInt16  index = 0;
+        if ( pDefault )
+            index = 1;
+
+        sal_Int64   disc = 0;
+        while ( iter != end )
+        {
+            pDecl = *iter;
+            if ( pDecl->getNodeType() == NT_union_branch )
+            {
+                pBranch = (AstUnionBranch*)pDecl;
+                if (pBranch == pDefault)
+                {
+                    iter++;
+                    continue;
+                }
+
+                pLabel = pBranch->getLabel();
+                pExprValue = pLabel->getLabelValue()->coerce(ET_hyper, sal_False);
+                aConst.m_type = RT_TYPE_INT64;
+                aConst.m_value.aHyper = pExprValue->u.hval;
+                if ( aConst.m_value.aHyper > disc )
+                    disc = aConst.m_value.aHyper;
+
+                aBlob.setFieldData(index++,
+                        OStringToOUString(pBranch->getLocalName(), RTL_TEXTENCODING_UTF8),
+                        OStringToOUString(pBranch->getType()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                        pBranch->getDocumentation(), OUString(), RT_ACCESS_READWRITE, aConst);
+            }
+            iter++;
+        }
+
+        if ( pDefault )
+        {
+            access = RT_ACCESS_DEFAULT;
+            aConst.m_type = RT_TYPE_INT64;
+            aConst.m_value.aHyper = disc + 1;
+            aBlob.setFieldData(0,
+                    OStringToOUString(pDefault->getLocalName(), RTL_TEXTENCODING_UTF8),
+                    OStringToOUString(pDefault->getType()->getRelativName(), RTL_TEXTENCODING_UTF8),
+                    pDefault->getDocumentation(), OUString(), RT_ACCESS_DEFAULT, aConst);
+        }
+    }
+
+    const sal_uInt8* pBlob = aBlob.getBlop();
+    sal_uInt32       aBlobSize = aBlob.getBlopSize();
+
+    if (localKey.setValue(OUString(), RG_VALUETYPE_BINARY,
+                            (RegValue)pBlob, aBlobSize))
+    {
+        fprintf(stderr, "%s: warning, could not set value of key \"%s\" in %s\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                getFullName(), localKey.getRegistryName());
+        return sal_False;
+    }
+
+    return sal_True;
+}
+
+AstUnionBranch::AstUnionBranch(AstUnionLabel* pLabel, AstType* pType, const ::rtl::OString& name, AstScope* pScope)
+    : AstMember(NT_union_branch, pType, name, pScope)
+    , m_pLabel(pLabel)
+{
+}
+
+AstUnionBranch::~AstUnionBranch()
+{
+    if ( m_pLabel )
+        delete m_pLabel;
+}
+
+AstUnionLabel::AstUnionLabel()
+    : m_label(UL_default)
+    , m_pLabelValue(NULL)
+{
+}
+
+AstUnionLabel::AstUnionLabel(UnionLabel labelKind, AstExpression* pExpr)
+    : m_label(labelKind)
+    , m_pLabelValue(pExpr)
+{
+    if ( m_pLabelValue )
+        m_pLabelValue->evaluate(EK_const);
+}
+
+AstUnionLabel::~AstUnionLabel()
+{
+    if ( m_pLabelValue )
+        delete m_pLabelValue;
+}
+
diff --git a/idlc/source/errorhandler.cxx b/idlc/source/errorhandler.cxx
new file mode 100644
index 000000000000..756e31a1fbf8
--- /dev/null
+++ b/idlc/source/errorhandler.cxx
@@ -0,0 +1,653 @@
+/*************************************************************************
+ *
+ *  $RCSfile: errorhandler.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_ERRORHANDLER_HXX_
+#include <idlc/errorhandler.hxx>
+#endif
+#ifndef _IDLC_ASTINTERFACE_HXX_
+#include <idlc/astinterface.hxx>
+#endif
+
+using namespace ::rtl;
+
+static sal_Char* errorCodeToMessage(ErrorCode eCode)
+{
+    switch (eCode)
+    {
+    case EIDL_NONE:
+        return "all is fine ";
+    case EIDL_SYNTAX_ERROR:
+        return "";
+    case EIDL_REDEF:
+        return "illegal redefinition ";
+    case EIDL_REDEF_SCOPE:
+        return "illegal redefinition in scope ";
+    case EIDL_DEF_USE:
+        return "redefinition after use, ";
+    case EIDL_MULTIPLE_BRANCH:
+        return "union with duplicate branch label ";
+    case EIDL_COERCION_FAILURE:
+        return "coercion failure ";
+    case EIDL_SCOPE_CONFLICT:
+        return "definition scope is different than fwd declare scope, ";
+    case EIDL_ONEWAY_CONFLICT:
+        return "oneway operation with OUT|INOUT parameters or raises exceptions, ";
+    case EIDL_DISC_TYPE:
+        return "union with illegal discriminator type, ";
+    case EIDL_LABEL_TYPE:
+        return "label type incompatible with union discriminator type, ";
+    case EIDL_ILLEGAL_ADD:
+        return "illegal add operation, ";
+    case EIDL_ILLEGAL_USE:
+        return "illegal type used in expression, ";
+    case EIDL_ILLEGAL_RAISES:
+        return "error in raises(..) clause, ";
+    case EIDL_CANT_INHERIT:
+        return "cannot inherit from ";
+    case EIDL_LOOKUP_ERROR:
+        return "error in lookup of symbol: ";
+    case EIDL_INHERIT_FWD_ERROR:
+        return "";
+    case EIDL_CONSTANT_EXPECTED:
+        return "constant expected: ";
+    case EIDL_NAME_CASE_ERROR:
+        return "identifier used with two differing spellings: ";
+    case EIDL_ENUM_VAL_EXPECTED:
+        return "enumerator expected: ";
+    case EIDL_ENUM_VAL_NOT_FOUND:
+        return "enumerator by this name not defined: ";
+    case EIDL_EVAL_ERROR:
+        return "expression evaluation error: ";
+    case EIDL_AMBIGUOUS:
+        return "ambiguous definition: ";
+    case EIDL_DECL_NOT_DEFINED:
+        return "forward declared but never defined: ";
+    case EIDL_FWD_DECL_LOOKUP:
+        return "";
+    case EIDL_RECURSIVE_TYPE:
+        return "illegal recursive use of type: ";
+    case EIDL_NONVOID_ONEWAY:
+        return "non-void return type in oneway operation: ";
+    case EIDL_NOT_A_TYPE:
+        return "specified symbol is not a type: ";
+    case EIDL_TYPE_NOT_VALID:
+        return "specified type is not valid in this context: ";
+    case EIDL_INTERFACEMEMBER_LOOKUP:
+        return "error in lookup of symbol, expected interface is not defined and no forward exists: ";
+    case EIDL_SERVICEMEMBER_LOOKUP:
+        return "error in lookup of symbol, expected service is not defined: ";
+    case EIDL_MULTIBLE_INHERITANCE:
+        return "multible inheritance is not allowed, in inheritance tree: ";
+    case EIDL_TYPE_IDENT_CONFLICT:
+        return "type and parameter/member name are equal: ";
+    case EIDL_ONEWAY_RAISE_CONFLICT:
+        return "oneway operation cannot raises exceptions: ";
+    case EIDL_WRONGATTRIBUTEFLAG:
+        return "the used flag is not valid in this context: ";
+    case EIDL_DEFINED_ATTRIBUTEFLAG:
+        return "flag is already set: ";
+    case EIDL_WRONGATTRIBUTEKEYWORD:
+        return "keyword not allowed: ";
+    case EIDL_MISSINGATTRIBUTEKEYWORD:
+        return "missing keyword: ";
+    case EIDL_ATTRIBUTEREADONLYEXPECTED:
+        return "only the 'attribute'|'readonly' flag is accepted: ";
+    case EIDL_OPTIONALEXPECTED:
+        return "only the 'optional' flag is accepted: ";
+    }
+    return "unknown errror";
+}
+
+static sal_Char* warningCodeToMessage(WarningCode wCode)
+{
+    switch (wCode)
+    {
+    case WIDL_EXPID_CONFLICT:
+        return "exception id conflict: ";
+    case WIDL_REQID_CONFLICT:
+        return "request id conflict: ";
+    case WIDL_INHERIT_IDCONFLICT:
+        return "request id conflict in inheritance tree: ";
+    case WIDL_TYPE_IDENT_CONFLICT:
+        return "type and parameter|member name are equal: ";
+    }
+    return "unkown warning";
+}
+
+static sal_Char* parseStateToMessage(ParseState state)
+{
+    switch (state)
+    {
+    case PS_NoState:
+        return "Statement can not be parsed";
+    case PS_TypeDeclSeen:
+        return "Malformed type declaration";
+    case PS_ConstantDeclSeen:
+        return "Malformed const declaration";
+    case PS_ExceptionDeclSeen:
+        return "Malformed exception declaration";
+    case PS_InterfaceDeclSeen:
+        return "Malformed interface declaration";
+    case PS_ServiceDeclSeen:
+        return "Malformed servicve declaration";
+    case PS_ModuleDeclSeen:
+        return "Malformed module declaration";
+    case PS_AttributeDeclSeen:
+        return "Malformed attribute declaration";
+    case PS_PropertyDeclSeen:
+        return "Malformed property declaration";
+    case PS_OperationDeclSeen:
+        return "Malformed operation declaration";
+    case PS_ConstantsDeclSeen:
+        return "Malformed constants declaration";
+    case PS_ServiceSeen:
+        return "Missing service identifier following SERVICE keyword";
+    case PS_ServiceIDSeen:
+        return "Missing '{' or illegal syntax following service identifier";
+    case PS_ServiceSqSeen:
+        return "Illegal syntax following service '{' opener";
+    case PS_ServiceBodySeen:
+        return "Illegal syntax following service '}' closer";
+    case PS_ServiceMemberSeen:
+        return "Illegal syntax following service member declaration";
+    case PS_ServiceIFHeadSeen:
+        return "Illegal syntax following header of an interface member";
+    case PS_ServiceSHeadSeen:
+        return "Illegal syntax following header of an service member";
+    case PS_ModuleSeen:
+        return "Missing module identifier following MODULE keyword";
+    case PS_ModuleIDSeen:
+        return "Missing '{' or illegal syntax following module identifier";
+    case PS_ModuleSqSeen:
+        return "Illegal syntax following module '{' opener";
+    case PS_ModuleQsSeen:
+        return "Illegal syntax following module '}' closer";
+    case PS_ModuleBodySeen:
+        return "Illegal syntax following module export(s)";
+    case PS_ConstantsSeen:
+        return "Missing constants identifier following CONSTANTS keyword";
+    case PS_ConstantsIDSeen:
+        return "Missing '{' or illegal syntax following constants identifier";
+    case PS_ConstantsSqSeen:
+        return "Illegal syntax following module '{' opener";
+    case PS_ConstantsQsSeen:
+        return "Illegal syntax following module '}' closer";
+    case PS_ConstantsBodySeen:
+        return "Illegal syntax following constants export(s)";
+    case PS_InterfaceSeen:
+        return "Missing interface identifier following INTERFACE keyword";
+    case PS_InterfaceIDSeen:
+        return "Illegal syntax following interface identifier";
+    case PS_InterfaceHeadSeen:
+        return "Illegal syntax following interface head";
+    case PS_InheritSpecSeen:
+        return "Missing '{' or illegal syntax following inheritance spec";
+    case PS_ForwardDeclSeen:
+        return "Missing ';' following forward interface declaration";
+    case PS_InterfaceSqSeen:
+        return "Illegal syntax following interface '{' opener";
+    case PS_InterfaceQsSeen:
+        return "Illegal syntax following interface '}' closer";
+    case PS_InterfaceBodySeen:
+        return "Illegal syntax following interface export(s)";
+    case PS_InheritColonSeen:
+        return "Illegal syntax following ':' starting inheritance list";
+    case PS_SNListCommaSeen:
+        return "Found illegal scoped name in scoped name list";
+    case PS_ScopedNameSeen:
+        return "Missing ',' following scoped name in scoped name list";
+    case PS_SN_IDSeen:
+        return "Illegal component in scoped name";
+    case PS_ScopeDelimSeen:
+        return "Illegal component in scoped name following '::'";
+    case PS_ConstSeen:
+        return "Missing type or illegal syntax following CONST keyword";
+    case PS_ConstTypeSeen:
+        return "Missing identifier or illegal syntax following const type";
+    case PS_ConstIDSeen:
+        return "Missing '=' or illegal syntax after const identifier";
+    case PS_ConstAssignSeen:
+        return "Missing value expr or illegal syntax following '='";
+    case PS_ConstExprSeen:
+        return "Missing ';' or illegal syntax following value expr in const";
+    case PS_TypedefSeen:
+        return "Missing type or illegal syntax following TYPEDEF keyword";
+    case PS_TypeSpecSeen:
+        return "Missing declarators or illegal syntax following type spec";
+    case PS_DeclaratorsSeen:
+        return "Illegal syntax following declarators in TYPEDEF declaration";
+    case PS_StructSeen:
+        return "Missing struct identifier following STRUCT keyword";
+    case PS_StructHeaderSeen:
+        return "Missing '{' or illegal syntax following struct inheritance spec";
+    case PS_StructIDSeen:
+        return "Missing '{' or illegal syntax following struct identifier";
+    case PS_StructSqSeen:
+        return "Illegal syntax following struct '{' opener";
+    case PS_StructQsSeen:
+        return "Illegal syntax following struct '}' closer";
+    case PS_StructBodySeen:
+        return "Illegal syntax following struct member(s)";
+    case PS_MemberTypeSeen:
+        return "Illegal syntax or missing identifier following member type";
+    case PS_MemberDeclsSeen:
+        return "Illegal syntax following member declarator(s)";
+    case PS_MemberDeclsCompleted:
+        return "Missing ',' between member decls of same type(?)";
+    case PS_UnionSeen:
+        return "Missing identifier following UNION keyword";
+    case PS_UnionIDSeen:
+        return "Illegal syntax following union identifier";
+    case PS_SwitchSeen:
+        return "Illegal syntax following SWITCH keyword";
+    case PS_SwitchOpenParSeen:
+        return "Illegal syntax following '(' in switch in union";
+    case PS_SwitchTypeSeen:
+        return "Illegal syntax following type decl in switch in union";
+    case PS_SwitchCloseParSeen:
+        return "Missing union '{' opener";
+    case PS_UnionSqSeen:
+        return "Illegal syntax following union '{' opener";
+    case PS_UnionQsSeen:
+        return "Illegal syntax following union '}' closer";
+    case PS_DefaultSeen:
+        return "Illegal syntax or missing ':' following DEFAULT keyword";
+    case PS_UnionLabelSeen:
+        return "Illegal syntax following branch label in union";
+    case PS_LabelColonSeen:
+        return "Illegal syntax following ':' in branch label in union";
+    case PS_LabelExprSeen:
+        return "Illegal syntax following label expression in union";
+    case PS_UnionElemSeen:
+    case PS_UnionElemCompleted:
+        return "Illegal syntax following union element";
+    case PS_CaseSeen:
+        return "Illegal syntax following CASE keyword in union";
+    case PS_UnionElemTypeSeen:
+        return "Illegal syntax following type decl in union element";
+    case PS_UnionElemDeclSeen:
+        return "Illegal syntax following declarator in union element";
+    case PS_UnionBodySeen:
+        return "Illegal syntax following union body statement(s)";
+    case PS_EnumSeen:
+        return "Illegal syntax or missing identifier following ENUM keyword";
+    case PS_EnumIDSeen:
+        return "Illegal syntax or missing '{' following enum identifier";
+    case PS_EnumSqSeen:
+        return "Illegal syntax following enum '{' opener";
+    case PS_EnumQsSeen:
+        return "Illegal syntax following enum '}' closer";
+    case PS_EnumBodySeen:
+        return "Illegal syntax following enum enumerator(s)";
+    case PS_EnumCommaSeen:
+        return "Illegal syntax or missing identifier following ',' in enum";
+    case PS_SequenceSeen:
+        return "Illegal syntax or missing '<' following SEQUENCE keyword";
+    case PS_SequenceSqSeen:
+        return "Illegal syntax or missing type following '<' in sequence";
+    case PS_SequenceQsSeen:
+        return "Illegal syntax following '>' in sequence";
+    case PS_SequenceTypeSeen:
+        return "Illegal syntax following sequence type declaration";
+    case PS_ArrayIDSeen:
+        return "Illegal syntax or missing dimensions after array identifier";
+    case PS_ArrayCompleted:
+        return "Illegal syntax after array declaration";
+    case PS_DimSqSeen:
+        return "Illegal syntax or missing size expr after '[' in array declaration";
+    case PS_DimQsSeen:
+        return "Illegal syntax after ']' in array declaration";
+    case PS_DimExprSeen:
+        return "Illegal syntax or missing ']' after size expr in array declaration";
+    case PS_FlagHeaderSeen:
+        return "Illegal syntax after flags";
+    case PS_AttrSeen:
+        return "Illegal syntax after ATTRIBUTE keyword";
+    case PS_AttrTypeSeen:
+        return "Illegal syntax after type in attribute declaration";
+    case PS_AttrCompleted:
+        return "Illegal syntax after attribute declaration";
+    case PS_ReadOnlySeen:
+        return "Illegal syntax after READONLY keyword";
+    case PS_OptionalSeen:
+        return "Illegal syntax after OPTIONAL keyword";
+    case PS_MayBeVoidSeen:
+        return "Illegal syntax after MAYBEVOID keyword";
+    case PS_BoundSeen:
+        return "Illegal syntax after BOUND keyword";
+    case PS_ConstrainedSeen:
+        return "Illegal syntax after CONSTRAINED keyword";
+    case PS_TransientSeen:
+        return "Illegal syntax after TRANSIENT keyword";
+    case PS_MayBeAmbigiousSeen:
+        return "Illegal syntax after MAYBEAMBIGIOUS keyword";
+    case PS_MayBeDefaultSeen:
+        return "Illegal syntax after MAYBEDEFAULT keyword";
+    case PS_RemoveableSeen:
+        return "Illegal syntax after REMOVEABLE keyword";
+    case PS_PropertySeen:
+        return "Illegal syntax after PROPERTY keyword";
+    case PS_PropertyTypeSeen:
+        return "Illegal syntax after type in property declaration";
+    case PS_PropertyCompleted:
+        return "Illegal syntax after property declaration";
+    case PS_ExceptSeen:
+        return "Illegal syntax or missing identifier after EXCEPTION keyword";
+    case PS_ExceptHeaderSeen:
+        return "Missing '{' or illegal syntax following exception inheritance spec";
+    case PS_ExceptIDSeen:
+        return "Illegal syntax or missing '{' after exception identifier";
+    case PS_ExceptSqSeen:
+        return "Illegal syntax after exception '{' opener";
+    case PS_ExceptQsSeen:
+        return "Illegal syntax after exception '}' closer";
+    case PS_ExceptBodySeen:
+        return "Illegal syntax after exception member(s)";
+    case PS_OpHeadSeen:
+        return "Illegasl syntax after operation header";
+    case PS_OpTypeSeen:
+        return "Illegal syntax or missing identifier after operation type";
+    case PS_OpIDSeen:
+        return "Illegal syntax or missing '(' after operation identifier";
+    case PS_OpParsCompleted:
+        return "Illegal syntax after operation parameter list";
+    case PS_OpRaiseCompleted:
+        return "Illegal syntax after optional RAISES in operation declaration";
+    case PS_OpCompleted:
+        return "Illegal syntax after operation declaration";
+    case PS_OpSqSeen:
+        return "Illegal syntax after operation parameter list '(' opener";
+    case PS_OpQsSeen:
+        return "Illegal syntax after operation parameter list ')' closer";
+    case PS_OpParCommaSeen:
+        return "Illegal syntax or missing direction in parameter declaration";
+    case PS_OpParDirSeen:
+        return "Illegal syntax or missing type in parameter declaration";
+    case PS_OpParTypeSeen:
+        return "Illegal syntax or missing declarator in parameter declaration";
+    case PS_OpParDeclSeen:
+        return "Illegal syntax following parameter declarator";
+    case PS_OpRaiseSeen:
+        return "Illegal syntax or missing '(' after RAISES keyword";
+    case PS_OpRaiseSqSeen:
+        return "Illegal syntax after RAISES '(' opener";
+    case PS_OpRaiseQsSeen:
+        return "Illegal syntax after RAISES ')' closer";
+    case PS_OpOnewaySeen:
+        return "Illegal syntax after ONEWAY keyword";
+    case PS_DeclsCommaSeen:
+        return "Illegal syntax after ',' in declarators list";
+    case PS_DeclsDeclSeen:
+        return "Illegal syntax after declarator in declarators list";
+    }
+    return "no wider described syntax error";
+}
+
+static OString flagToString(sal_uInt32 flag)
+{
+    OString flagStr;
+    if ( (flag & AF_READONLY) == AF_READONLY )
+        flagStr += "'readonly'";
+    if ( (flag & AF_OPTIONAL) == AF_OPTIONAL )
+        flagStr += "'optional'";
+    if ( (flag & AF_MAYBEVOID) == AF_MAYBEVOID )
+        flagStr += "'maybevoid'";
+    if ( (flag & AF_BOUND) == AF_BOUND )
+        flagStr += "'bound'";
+    if ( (flag & AF_CONSTRAINED) == AF_CONSTRAINED )
+        flagStr += "'constrained'";
+    if ( (flag & AF_TRANSIENT) == AF_TRANSIENT )
+            flagStr += "'transient'";
+    if ( (flag & AF_MAYBEAMBIGUOUS) == AF_MAYBEAMBIGUOUS )
+        flagStr += "'maybeambiguous'";
+    if ( (flag & AF_MAYBEDEFAULT) == AF_MAYBEDEFAULT )
+        flagStr += "'maybedefault'";
+    if ( (flag & AF_REMOVEABLE) == AF_REMOVEABLE )
+        flagStr += "'removeable'";
+    if ( (flag & AF_ATTRIBUTE) == AF_ATTRIBUTE )
+        flagStr += "'attribute'";
+    if ( (flag & AF_PROPERTY) == AF_PROPERTY )
+        flagStr += "'property'";
+    if ( !flagStr.getLength() )
+        flagStr += "'unknown'";
+
+    return flagStr;
+}
+
+static void errorHeader(ErrorCode eCode, sal_Int32 lineNumber)
+{
+    OString file;
+    if ( idlc()->getFileName() == idlc()->getRealFileName() )
+        file = idlc()->getMainFileName();
+    else
+        file = idlc()->getFileName();
+
+    fprintf(stderr, "%s(%d) : %s", file.getStr(), lineNumber,
+            errorCodeToMessage(eCode));
+}
+
+static void errorHeader(ErrorCode eCode)
+{
+    errorHeader(eCode, idlc()->getLineNumber());
+}
+
+static void warningHeader(WarningCode wCode)
+{
+    OString file;
+    if ( idlc()->getFileName() == idlc()->getRealFileName() )
+        file = idlc()->getMainFileName();
+    else
+        file = idlc()->getFileName();
+
+    fprintf(stderr, "%s(%d) : WARNING, %s", file.getStr(), idlc()->getLineNumber(),
+            warningCodeToMessage(wCode));
+}
+
+void ErrorHandler::error0(ErrorCode e)
+{
+    errorHeader(e);
+    fprintf(stderr, "\n");
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::error1(ErrorCode e, AstDeclaration* d)
+{
+    errorHeader(e);
+    fprintf(stderr, "'%s'\n", d->getScopedName().getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::error2(ErrorCode e, AstDeclaration* d1, AstDeclaration* d2)
+{
+    errorHeader(e);
+    fprintf(stderr, "'%s', '%s'\n", d1->getScopedName().getStr(),
+            d2->getScopedName().getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::error3(ErrorCode e, AstDeclaration* d1, AstDeclaration* d2, AstDeclaration* d3)
+{
+    errorHeader(e);
+    fprintf(stderr, "'%s', '%s', '%s'\n", d1->getScopedName().getStr(),
+            d2->getScopedName().getStr(), d3->getScopedName().getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::warning1(WarningCode w, AstDeclaration* d)
+{
+    warningHeader(w);
+    fprintf(stderr, "'%s'\n", d->getScopedName().getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::warning2(WarningCode w, AstDeclaration* d1, AstDeclaration* d2)
+{
+    warningHeader(w);
+    fprintf(stderr, "'%s', '%s'\n", d1->getScopedName().getStr(),
+            d2->getScopedName().getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::syntaxError(ParseState ps, sal_Int32 lineNumber, sal_Char* errmsg)
+{
+    errorHeader(EIDL_SYNTAX_ERROR, lineNumber);
+    fprintf(stderr, "%s%s\n", parseStateToMessage(ps), errmsg + 11);
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::nameCaseError(sal_Char *n, sal_Char *t)
+{
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::coercionError(AstExpression *pExpr, ExprType et)
+{
+    errorHeader(EIDL_COERCION_FAILURE);
+    fprintf(stderr, "'%s' to '%s'\n", pExpr->toString().getStr(),
+            exprTypeToString(et));
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::lookupError(const ::rtl::OString& n)
+{
+    errorHeader(EIDL_LOOKUP_ERROR);
+    fprintf(stderr, "'%s'\n", n.getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::lookupError(ErrorCode e, const ::rtl::OString& n, AstDeclaration* pScope)
+{
+    errorHeader(e);
+    fprintf(stderr, "'%s' in '%s'\n", n.getStr(), pScope->getFullName().getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::flagError(ErrorCode e, sal_uInt32 flag)
+{
+    errorHeader(e);
+    fprintf(stderr, "'%s'\n", flagToString(flag).getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::noTypeError(AstDeclaration* pDecl)
+{
+    errorHeader(EIDL_NOT_A_TYPE);
+    fprintf(stderr, "'%s'\n", pDecl->getScopedName().getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::inheritanceError(OString* name, AstDeclaration* pDecl)
+{
+    if ( (pDecl->getNodeType() == NT_interface) &&
+         !((AstInterface*)pDecl)->isDefined() )
+    {
+        errorHeader(EIDL_INHERIT_FWD_ERROR);
+        fprintf(stderr, "interface '%s' cannot inherit from forward declared interface '%s'\n",
+                name->getStr(), pDecl->getScopedName().getStr());
+    } else
+    {
+        errorHeader(EIDL_CANT_INHERIT);
+        fprintf(stderr, "interface '%s' attempts to inherit from '%s'\n",
+                name->getStr(), pDecl->getScopedName().getStr());
+    }
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::forwardLookupError(AstDeclaration* pForward,
+                                      const ::rtl::OString& name)
+{
+    errorHeader(EIDL_FWD_DECL_LOOKUP);
+    fprintf(stderr, "trying to look up '%s' in undefined forward declared interface '%s'\n",
+            pForward->getScopedName().getStr(), name.getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::constantExpected(AstDeclaration* pDecl,
+                                    const ::rtl::OString& name)
+{
+    errorHeader(EIDL_CONSTANT_EXPECTED);
+    fprintf(stderr, "'%s' is bound to '%s'\n", name.getStr(), pDecl->getScopedName().getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::evalError(AstExpression* pExpr)
+{
+    errorHeader(EIDL_EVAL_ERROR);
+    fprintf(stderr, "'%s'\n", pExpr->toString().getStr());
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::enumValExpected(AstUnion* pUnion, AstUnionLabel *pLabel)
+{
+    errorHeader(EIDL_ENUM_VAL_EXPECTED);
+    fprintf(stderr, " union %s, ", pUnion->getLocalName().getStr());
+//  pLabel->dump();
+    fprintf(stderr, "\n");
+    idlc()->incErrorCount();
+}
+
+void ErrorHandler::enumValLookupFailure(AstUnion* pUnion, AstEnum* pEnum, const ::rtl::OString& name)
+{
+    errorHeader(EIDL_ENUM_VAL_NOT_FOUND);
+    fprintf(stderr, " union %s, enum %s, enumerator %s\n",
+            pUnion->getLocalName().getStr(),
+            pEnum->getLocalName().getStr(), name.getStr());
+    idlc()->incErrorCount();
+}
diff --git a/idlc/source/fehelper.cxx b/idlc/source/fehelper.cxx
new file mode 100644
index 000000000000..66314369016d
--- /dev/null
+++ b/idlc/source/fehelper.cxx
@@ -0,0 +1,192 @@
+/*************************************************************************
+ *
+ *  $RCSfile: fehelper.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_FEHELPER_HXX_
+#include <idlc/fehelper.hxx>
+#endif
+#ifndef _IDLC_ERRORHANDLER_HXX_
+#include <idlc/errorhandler.hxx>
+#endif
+#ifndef _IDLC_ASTARRAY_HXX_
+#include <idlc/astarray.hxx>
+#endif
+
+using namespace ::rtl;
+
+FeDeclarator::FeDeclarator(const OString& name, DeclaratorType declType, AstDeclaration* pComplPart)
+    : m_pComplexPart(pComplPart)
+    , m_name(name)
+    , m_declType(declType)
+{
+}
+
+FeDeclarator::~FeDeclarator()
+{
+}
+
+sal_Bool FeDeclarator::checkType(AstDeclaration *type)
+{
+    OString tmp(m_name);
+    sal_uInt32 count = 0;
+    if ( (count = m_name.getTokenCount(':')) > 0 )
+        tmp = m_name.getToken(count-1, ':');
+
+    if (tmp == type->getLocalName())
+        return sal_False;
+    else
+        return sal_True;
+}
+
+AstType* FeDeclarator::compose(AstDeclaration* pDecl)
+{
+    AstArray*   pArray;
+    AstType*    pType;
+
+    if ( !pDecl->isType() )
+    {
+        idlc()->error()->noTypeError(pDecl);
+        return NULL;
+    }
+    pType = (AstType*)pDecl;
+    if (m_declType == FD_simple || m_pComplexPart == NULL)
+        return pType;
+
+    if (m_pComplexPart->getNodeType() == NT_array)
+    {
+        pArray = (AstArray*)m_pComplexPart;
+        pArray->setType(pType);
+
+        // insert array type in global scope
+        AstScope* pScope = idlc()->scopes()->bottom();
+        AstDeclaration* pDecl = NULL;
+        if ( pScope )
+        {
+            pDecl = pScope->addDeclaration(pArray);
+            if ( (AstDeclaration*)pArray != pDecl )
+            {
+                delete m_pComplexPart;
+                m_pComplexPart = pDecl;
+            }
+        }
+        return pArray;
+    }
+
+    return NULL; // return through this statement should not happen
+}
+
+FeInheritanceHeader::FeInheritanceHeader(NodeType nodeType, ::rtl::OString* pName, StringList* pInherits)
+    : m_nodeType(nodeType)
+    , m_pName(pName)
+    , m_pInherits(NULL)
+{
+    initializeInherits(pInherits);
+}
+
+sal_Bool FeInheritanceHeader::initializeInherits(StringList* pInherits)
+{
+    if ( pInherits && (pInherits->size() > 0) )
+    {
+        StringList::iterator iter = pInherits->begin();
+        StringList::iterator end = pInherits->end();
+        AstScope* pScope = idlc()->scopes()->topNonNull();
+        AstDeclaration* pDecl = NULL;
+
+        m_pInherits = new DeclList();
+        while (pScope && iter != end)
+        {
+            pDecl = pScope->lookupByName(*iter);
+            if ( pDecl )
+            {
+                m_pInherits->push_back(pDecl);
+            } else
+            {
+                idlc()->error()->lookupError(*iter);
+                return sal_False;
+            }
+            iter++;
+        }
+    }
+    return sal_True;
+}
+
+sal_Bool FeInterfaceHeader::initializeInherits(StringList* pInherits)
+{
+    if ( !pInherits )
+        return sal_True;
+
+    if ( !FeInheritanceHeader::initializeInherits(pInherits) )
+        return sal_False;
+
+    DeclList::iterator iter = m_pInherits->begin();
+    DeclList::iterator end  = m_pInherits->end();
+
+    while ( iter != end )
+    {
+        AstInterface* pIface = ((AstInterface*)*iter);
+        if ( ((*iter)->getNodeType() != NT_interface) ||
+             !((AstInterface*)*iter)->isDefined() )
+        {
+            idlc()->error()->inheritanceError(getName(), *iter);
+            return sal_False;
+        }
+        iter++;
+    }
+    return sal_True;
+}
diff --git a/idlc/source/idlc.cxx b/idlc/source/idlc.cxx
new file mode 100644
index 000000000000..756ca6ae5f28
--- /dev/null
+++ b/idlc/source/idlc.cxx
@@ -0,0 +1,323 @@
+/*************************************************************************
+ *
+ *  $RCSfile: idlc.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_IDLC_HXX_
+#include <idlc/idlc.hxx>
+#endif
+
+#ifndef _IDLC_ERRORHANDLER_HXX_
+#include <idlc/errorhandler.hxx>
+#endif
+#ifndef _IDLC_ASTSCOPE_HXX_
+#include <idlc/astscope.hxx>
+#endif
+#ifndef _IDLC_ASTMODULE_HXX_
+#include <idlc/astmodule.hxx>
+#endif
+#ifndef _IDLC_ASTSERVICE_HXX_
+#include <idlc/astservice.hxx>
+#endif
+#ifndef _IDLC_ASTCONSTANTS_HXX_
+#include <idlc/astconstants.hxx>
+#endif
+#ifndef _IDLC_ASTEXCEPTION_HXX_
+#include <idlc/astexception.hxx>
+#endif
+#ifndef _IDLC_ASTUNION_HXX_
+#include <idlc/astunion.hxx>
+#endif
+#ifndef _IDLC_ASTENUM_HXX_
+#include <idlc/astenum.hxx>
+#endif
+#ifndef _IDLC_ASTINTERFACE_HXX_
+#include <idlc/astinterface.hxx>
+#endif
+#ifndef _IDLC_ASTOPERATION_HXX_
+#include <idlc/astoperation.hxx>
+#endif
+#ifndef _IDLC_ASTBASETYPE_HXX_
+#include <idlc/astbasetype.hxx>
+#endif
+
+using namespace ::rtl;
+
+AstDeclaration* SAL_CALL scopeAsDecl(AstScope* pScope)
+{
+    if (pScope == NULL) return NULL;
+
+    switch( pScope->getScopeNodeType() )
+    {
+        case NT_service:
+            return (AstService*)(pScope);
+        case NT_module:
+        case NT_root:
+            return (AstModule*)(pScope);
+        case NT_constants:
+            return (AstConstants*)(pScope);
+        case NT_interface:
+            return (AstInterface*)(pScope);
+        case NT_operation:
+            return (AstOperation*)(pScope);
+        case NT_exception:
+            return (AstException*)(pScope);
+        case NT_union:
+            return (AstUnion*)(pScope);
+        case NT_struct:
+            return (AstStruct*)(pScope);
+        case NT_enum:
+            return (AstEnum*)(pScope);
+        default:
+            return NULL;
+    }
+}
+
+AstScope* SAL_CALL declAsScope(AstDeclaration* pDecl)
+{
+    if (pDecl == NULL) return NULL;
+
+    switch(pDecl->getNodeType())
+    {
+        case NT_interface:
+            return (AstInterface*)(pDecl);
+        case NT_service:
+            return (AstService*)(pDecl);
+        case NT_module:
+        case NT_root:
+            return (AstModule*)(pDecl);
+        case NT_constants:
+            return (AstConstants*)(pDecl);
+        case NT_exception:
+            return (AstException*)(pDecl);
+        case NT_union:
+            return (AstUnion*)(pDecl);
+        case NT_struct:
+            return (AstStruct*)(pDecl);
+        case NT_enum:
+            return (AstEnum*)(pDecl);
+        case NT_operation:
+            return (AstOperation*)(pDecl);
+        default:
+            return NULL;
+   }
+}
+
+static void SAL_CALL initializePredefinedTypes(AstModule* pRoot)
+{
+    AstBaseType* pPredefined = NULL;
+    if ( pRoot )
+    {
+         pPredefined = new AstBaseType(ET_long, OString("long"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_ulong, OString("unsigned long"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_hyper, OString("hyper"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_uhyper, OString("unsigned hyper"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_short, OString("short"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_ushort, OString("unsigned short"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_float, OString("float"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_double, OString("double"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_char, OString("char"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_byte, OString("byte"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_any, OString("any"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_string, OString("string"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_type, OString("type"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_boolean, OString("boolean"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+
+         pPredefined = new AstBaseType(ET_void, OString("void"), pRoot);
+         pRoot->addDeclaration(pPredefined);
+    }
+}
+
+Idlc::Idlc(Options* pOptions)
+    : m_pOptions(pOptions)
+    , m_bIsInMainfile(sal_True)
+    , m_errorCount(0)
+    , m_lineNumber(0)
+    , m_parseState(PS_NoState)
+    , m_bIsDocValid(sal_False)
+{
+    m_pScopes = new AstStack();
+    // init root object after construction
+    m_pRoot = NULL;
+    m_pErrorHandler = new ErrorHandler();
+    m_bGenerateDoc = m_pOptions->isValid("-C");
+}
+
+Idlc::~Idlc()
+{
+    if (m_pRoot)
+        delete m_pRoot;
+    if (m_pScopes)
+        delete m_pScopes;
+    if (m_pErrorHandler)
+        delete m_pErrorHandler;
+}
+
+void Idlc::init()
+{
+    if ( m_pRoot )
+        delete m_pRoot;
+
+    m_pRoot = new AstModule(NT_root, OString(), NULL);
+
+    // push the root node on the stack
+    m_pScopes->push(m_pRoot);
+    initializePredefinedTypes(m_pRoot);
+}
+
+void Idlc::reset()
+{
+    m_errorCount = 0;
+    m_lineNumber = 0;
+    m_parseState = PS_NoState;
+
+    m_fileName = OString();
+    m_mainFileName = OString();
+    m_realFileName = OString();
+    m_documentation = OString();
+
+    m_pScopes->clear();
+    if ( m_pRoot)
+        delete m_pRoot;
+
+    m_pRoot = new AstModule(NT_root, OString(), NULL);
+
+    // push the root node on the stack
+    m_pScopes->push(m_pRoot);
+    initializePredefinedTypes(m_pRoot);
+}
+
+sal_Bool Idlc::isDocValid()
+{
+    if ( m_bGenerateDoc )
+        return m_bIsDocValid;
+    return sal_False;;
+}
+
+static Idlc* pStaticIdlc = NULL;
+
+Idlc* SAL_CALL idlc()
+{
+    return pStaticIdlc;
+}
+
+Idlc* SAL_CALL setIdlc(Options* pOptions)
+{
+    if ( pStaticIdlc )
+    {
+        delete pStaticIdlc;
+    }
+    pStaticIdlc = new Idlc(pOptions);
+    pStaticIdlc->init();
+    return pStaticIdlc;
+}
+
+sal_Bool SAL_CALL canBeRedefined(AstDeclaration *pDecl)
+{
+    switch (pDecl->getNodeType())
+    {
+        case NT_module:
+        case NT_constants:
+        case NT_interface:
+        case NT_const:
+        case NT_exception:
+        case NT_parameter:
+        case NT_enum_val:
+        case NT_array:
+        case NT_sequence:
+        case NT_union:
+        case NT_struct:
+        case NT_enum:
+        case NT_typedef:
+//          return sal_True;
+        case NT_union_branch:
+        case NT_member:
+        case NT_attribute:
+        case NT_operation:
+        case NT_predefined:
+        default:
+            return sal_False;
+    }
+}
diff --git a/idlc/source/idlccompile.cxx b/idlc/source/idlccompile.cxx
new file mode 100644
index 000000000000..fe446ab4a6d7
--- /dev/null
+++ b/idlc/source/idlccompile.cxx
@@ -0,0 +1,332 @@
+/*************************************************************************
+ *
+ *  $RCSfile: idlccompile.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_IDLC_HXX_
+#include <idlc/idlc.hxx>
+#endif
+#ifndef _RTL_USTRING_HXX_
+#include <rtl/ustring.hxx>
+#endif
+#ifndef _RTL_STRBUF_HXX_
+#include <rtl/strbuf.hxx>
+#endif
+
+#ifndef _OSL_PROCESS_H_
+#include <osl/process.h>
+#endif
+#ifndef _OSL_DIAGNOSE_H_
+#include <osl/diagnose.h>
+#endif
+
+#if defined(SAL_W32) || defined(SAL_OS2)
+#include <io.h>
+#endif
+
+#ifdef  SAL_UNX
+#include <unistd.h>
+#ifdef MACOSX
+#include <sys/wait.h>
+#else
+#include <wait.h>
+#endif
+#endif
+
+using namespace ::rtl;
+
+extern int yyparse();
+extern FILE* yyin;
+extern int yydebug;
+
+sal_Int32 lineNumber = 1;
+
+
+static OUString TMP(RTL_CONSTASCII_USTRINGPARAM("TMP"));
+static OUString TEMP(RTL_CONSTASCII_USTRINGPARAM("TEMP"));
+static sal_Char tmpFilePattern[512];
+
+// prefix must be specified, postfix could be empty string
+OString makeTempName(const OString& prefix, const OString& postfix)
+{
+    OUString uTmpPath;
+    OString tmpPath;
+
+    if ( osl_getEnvironment(TMP.pData, &uTmpPath.pData) != osl_Process_E_None )
+    {
+        if ( osl_getEnvironment(TEMP.pData, &uTmpPath.pData) != osl_Process_E_None )
+        {
+#if defined(SAL_W32) || defined(SAL_OS2)
+            tmpPath = OString("c:\\temp");
+#else
+            tmpPath = OString("/tmp");
+#endif
+        }
+    }
+
+    if ( uTmpPath.getLength() )
+        tmpPath = OUStringToOString(uTmpPath, RTL_TEXTENCODING_UTF8);
+
+#if defined(SAL_W32) || defined(SAL_UNX)
+    strcpy(tmpFilePattern, tmpPath);
+#ifdef SAL_UNX
+    strcat(tmpFilePattern, "/");
+#else
+    strcat(tmpFilePattern, "\\");
+#endif
+    strcat(tmpFilePattern, prefix.getStr());
+    strcat(tmpFilePattern, "XXXXXX");
+
+    (void) mktemp(tmpFilePattern);
+    if ( postfix.getLength() )
+        strcat(tmpFilePattern, postfix.getStr());
+#endif
+
+#ifdef __OS2__
+    strcpy(tmpFilePattern, tempnam(NULL, prefix.getStr());
+#endif
+
+    return OString(tmpFilePattern);
+}
+
+void copyFile(const OString& sourceFile, const OString& targetFile)
+{
+    FILE* pSource = fopen(sourceFile.getStr(), "r");
+
+    if ( !pSource )
+    {
+          fprintf(stderr, "%s: couldn't open file: %s\n",
+            idlc()->getOptions()->getProgramName().getStr(), sourceFile.getStr());
+          exit(99);
+    }
+
+    FILE* pTarget = fopen(targetFile.getStr(), "w");
+
+    if ( !pTarget )
+    {
+          fprintf(stderr, "%s: couldn't create file: %s\n",
+            idlc()->getOptions()->getProgramName().getStr(), targetFile.getStr());
+          exit(99);
+    }
+
+    sal_Char pBuffer[513];
+
+    fgets(pBuffer, 512, pSource);
+    while ( !feof(pSource) )
+    {
+        fprintf(pTarget, "%s", pBuffer);
+        fgets(pBuffer, 512, pSource);
+    }
+
+    fclose(pSource);
+    fclose(pTarget);
+}
+
+sal_Int32 compileFile(const OString& fileName)
+{
+    // preporcess input file
+    OString tmpFile = makeTempName(OString("idli_"), OString(".idl"));
+    OString preprocFile = makeTempName(OString("idlf_"), OString(".idl"));
+
+    copyFile(fileName, tmpFile);
+
+    idlc()->setFileName(fileName);
+    idlc()->setMainFileName(fileName);
+    idlc()->setRealFileName(tmpFile);
+
+    OStringBuffer cppArgs(512);
+    cppArgs.append("-DIDL -Xi -Xc -+ -I.");
+    Options* pOptions = idlc()->getOptions();
+
+    OString filePath;
+#if defined(SAL_W32) || defined(SAL_OS2)
+    sal_uInt32 index = fileName.lastIndexOf('\\');
+#else
+    sal_uInt32 index = fileName.lastIndexOf('/');
+#endif
+    if ( index > 0)
+    {
+        filePath = fileName.copy(0, index);
+
+        if ( filePath.getLength() )
+        {
+            cppArgs.append(" -I");
+            cppArgs.append(filePath);
+        }
+    }
+
+    if ( pOptions->isValid("-D") )
+    {
+        cppArgs.append(" ");
+        cppArgs.append(pOptions->getOption("-D"));
+    }
+    if ( pOptions->isValid("-I") )
+    {
+        cppArgs.append(" ");
+        cppArgs.append(pOptions->getOption("-I"));
+    }
+
+    cppArgs.append(" ");
+    cppArgs.append(tmpFile);
+    cppArgs.append(" ");
+    cppArgs.append(preprocFile);
+
+    OString cmdFileName = makeTempName(OString("idlc_"), OString());
+    FILE* pCmdFile = fopen(cmdFileName, "w");
+
+    if ( !pCmdFile )
+    {
+          fprintf(stderr, "%s: couldn't open temporary file for preprocessor commands: %s\n",
+            idlc()->getOptions()->getProgramName().getStr(), cmdFileName.getStr());
+          exit(99);
+    }
+    fprintf(pCmdFile, "%s", cppArgs.getStr());
+    fclose(pCmdFile);
+
+    OUString cmdArg(RTL_CONSTASCII_USTRINGPARAM("@"));
+    cmdArg += OStringToOUString(cmdFileName, RTL_TEXTENCODING_UTF8);
+
+    OUString cpp;
+    OUString startDir;
+    OSL_VERIFY(osl_getExecutableFile(&cpp.pData) == osl_Process_E_None);
+
+#if defined(SAL_W32) || defined(SAL_OS2)
+    cpp = cpp.copy(0, cpp.getLength() - 8);
+    cpp += OUString( RTL_CONSTASCII_USTRINGPARAM("idlcpp.exe"));
+#else
+    cpp = cpp.copy(0, cpp.getLength() - 4);
+    cpp += OUString( RTL_CONSTASCII_USTRINGPARAM("idlcpp"));
+#endif
+
+    oslProcess      hProcess = NULL;
+    oslProcessError procError = osl_Process_E_None;
+
+    procError = osl_executeProcess(cpp.pData, &cmdArg.pData, 1, osl_Process_WAIT,
+                                   0, startDir.pData, 0, 0, 0, &hProcess);
+
+    oslProcessInfo hInfo;
+    hInfo.Size = sizeof(oslProcessInfo);
+    OSL_VERIFY( osl_getProcessInfo(hProcess, osl_Process_EXITCODE, &hInfo) == osl_Process_E_None );
+
+    if ( procError || (hInfo.Code != 0) )
+    {
+        if ( procError != osl_Process_E_None )
+            fprintf(stderr, "%s: starting preprocessor failed\n", pOptions->getProgramName().getStr());
+        else
+            fprintf(stderr, "%s: preprocessing \"%s\" failed\n", pOptions->getProgramName().getStr(), fileName.getStr());
+
+        unlink(tmpFile.getStr());
+        unlink(preprocFile.getStr());
+        unlink(cmdFileName.getStr());
+        osl_freeProcessHandle(hProcess);
+        exit(hInfo.Code ? hInfo.Code : 99);
+    }
+    osl_freeProcessHandle(hProcess);
+
+    if (unlink(tmpFile.getStr()) != 0)
+    {
+        fprintf(stderr, "%s: Could not remove cpp input file %s\n",
+                 pOptions->getProgramName(), tmpFile.getStr());
+        exit(99);
+    }
+
+    if (unlink(cmdFileName.getStr()) != 0)
+    {
+        fprintf(stderr, "%s: Could not remove unocpp command file %s\n",
+                   pOptions->getProgramName(), cmdFileName.getStr());
+
+        exit(99);
+    }
+
+    if ( pOptions->isValid("-E") )
+    {
+        if (unlink(preprocFile) != 0)
+        {
+            fprintf(stderr, "%s: Could not remove parser input file %s\n",
+                       pOptions->getProgramName(), preprocFile.getStr());
+            exit(99);
+        }
+        exit(0);
+    }
+
+    // parse file
+    yyin = fopen(preprocFile.getStr(), "r");
+    if (yyin == NULL)
+    {
+        fprintf(stderr, "%s: Could not open cpp output file %s\n",
+                   pOptions->getProgramName(), preprocFile.getStr());
+        exit(99);
+    }
+
+    //yydebug = 0 no trace information
+    //yydebug = 1 parser produce trace information
+    yydebug = 0;
+
+    sal_Int32 nErrors = yyparse();
+    nErrors = idlc()->getErrorCount();
+
+    fclose(yyin);
+    if (unlink(preprocFile.getStr()) != 0)
+    {
+        fprintf(stderr, "%s: Could not remove parser input file %s\n",
+                pOptions->getProgramName(), preprocFile.getStr());
+        exit(99);
+    }
+
+    return nErrors;
+}
diff --git a/idlc/source/idlcmain.cxx b/idlc/source/idlcmain.cxx
new file mode 100644
index 000000000000..e54b673091e1
--- /dev/null
+++ b/idlc/source/idlcmain.cxx
@@ -0,0 +1,135 @@
+/*************************************************************************
+ *
+ *  $RCSfile: idlcmain.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_IDLC_HXX_
+#include <idlc/idlc.hxx>
+#endif
+
+#ifdef SAL_UNX
+sal_Char SEPERATOR = '/';
+#else
+sal_Char SEPERATOR = '\\';
+#endif
+
+using namespace ::rtl;
+
+void SAL_CALL main( int argc, char** argv )
+{
+    Options options;
+
+    try
+    {
+        if (!options.initOptions(argc, argv))
+            exit(1);
+    }
+    catch( IllegalArgument& e)
+    {
+        fprintf(stderr, "Illegal argument: %s\n%s",
+                e.m_message.getStr(),
+                options.prepareVersion().getStr());
+        exit(99);
+    }
+
+    setIdlc(&options);
+
+    const StringVector& files = options.getInputFiles();
+    sal_Int32   nFiles = files.size();
+    sal_Int32   nErrors = 0;
+    for ( sal_Int32 i=0; i < nFiles; i++ )
+    {
+        fprintf(stdout, "%s: compile '%s' ... \n",
+                options.getProgramName().getStr(), files[i].getStr());
+        nErrors = compileFile(files[i]);
+        if ( nErrors )
+        {
+            OString outputName;
+            if ( options.isValid("-O") )
+            {
+                outputName = options.getOption("-O");
+                sal_Char c = outputName.getStr()[outputName.getLength()-1];
+
+                if ( c != SEPERATOR )
+                    outputName += OString::valueOf(SEPERATOR);
+            }
+
+            OString strippedFileName(files[i].copy(files[i].lastIndexOf(SEPERATOR) + 1));
+            outputName += strippedFileName.replaceAt(strippedFileName.getLength() -3 , 3, "urd");
+            removeIfExists(outputName);
+        } else
+            nErrors = produceFile(files[i]);
+
+        idlc()->reset();
+        if ( nErrors > 0 )
+            break;
+    }
+
+    if ( nErrors > 0 )
+    {
+        fprintf(stdout, "%s: detected %d errors in file '%s'%s",
+                options.getProgramName().getStr(), nErrors,
+                files[i].getStr(), options.prepareVersion().getStr());
+    } else
+    {
+        fprintf(stdout, "%s: returned with %d errors%s",
+                options.getProgramName().getStr(), nErrors,
+                options.prepareVersion().getStr());
+    }
+    exit(nErrors);
+}
diff --git a/idlc/source/idlcproduce.cxx b/idlc/source/idlcproduce.cxx
new file mode 100644
index 000000000000..01fa11e9ba6c
--- /dev/null
+++ b/idlc/source/idlcproduce.cxx
@@ -0,0 +1,284 @@
+/*************************************************************************
+ *
+ *  $RCSfile: idlcproduce.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _IDLC_IDLC_HXX_
+#include <idlc/idlc.hxx>
+#endif
+#ifndef _IDLC_ASTMODULE_HXX_
+#include <idlc/astmodule.hxx>
+#endif
+#ifndef _RTL_STRBUF_HXX_
+#include <rtl/strbuf.hxx>
+#endif
+
+#if defined(SAL_W32) || defined(SAL_OS2)
+#include <io.h>
+#include <direct.h>
+#include <errno.h>
+#endif
+
+#ifdef SAL_UNX
+#include <unistd.h>
+#include <sys/stat.h>
+#include <errno.h>
+#endif
+
+#ifdef SAL_UNX
+extern sal_Char SEPERATOR;
+#else
+extern sal_Char SEPERATOR;
+#endif
+
+using namespace ::rtl;
+
+StringList* pCreatedDirectories = NULL;
+
+static sal_Bool checkOutputPath(const OString& completeName)
+{
+    OStringBuffer buffer(completeName.getLength());
+    sal_Int32 count = completeName.getTokenCount(SEPERATOR) - 1;
+    sal_Int32 offset=0;
+
+    if ( !count )
+        return sal_True;
+
+    OString token(completeName.getToken(0, SEPERATOR));
+    const sal_Char* p = token.getStr();
+    if (strcmp(p, "..") == 0
+        || *(p+1) == ':'
+        || strcmp(p, ".") == 0)
+    {
+        offset++;
+        buffer.append(token);
+        buffer.append(SEPERATOR);
+    }
+
+    for (sal_Int32 i=offset; i < count; i++)
+    {
+        buffer.append(completeName.getToken(i, SEPERATOR));
+
+        if ( buffer.getLength() > 0 )
+        {
+#ifdef SAL_UNX
+            if (mkdir((char*)buffer.getStr(), 0777) == -1)
+#else
+            if (mkdir((char*)buffer.getStr()) == -1)
+#endif
+            {
+                if (errno == ENOENT)
+                {
+                    fprintf(stderr, "%s: cannot create directory '%s'\n",
+                            idlc()->getOptions()->getProgramName().getStr(), buffer.getStr());
+                    return sal_False;
+                }
+            } else
+            {
+                if ( !pCreatedDirectories )
+                    pCreatedDirectories = new StringList();
+                pCreatedDirectories->push_front(buffer.getStr());
+            }
+        }
+        if ( i+1 < count )
+            buffer.append(SEPERATOR);
+    }
+    return sal_True;
+}
+
+static sal_Bool cleanPath()
+{
+    if ( pCreatedDirectories )
+    {
+        StringList::iterator iter = pCreatedDirectories->begin();
+        StringList::iterator end = pCreatedDirectories->end();
+        while ( iter != end )
+        {
+//#ifdef SAL_UNX
+//          if (rmdir((char*)(*iter).getStr(), 0777) == -1)
+//#else
+            if (rmdir((char*)(*iter).getStr()) == -1)
+//#endif
+            {
+                fprintf(stderr, "%s: cannot remove directory '%s'\n",
+                        idlc()->getOptions()->getProgramName().getStr(), (*iter).getStr());
+                return sal_False;
+            }
+            iter++;
+        }
+        delete pCreatedDirectories;
+    }
+    return sal_True;
+}
+
+void SAL_CALL removeIfExists(const OString& fileName)
+{
+    FILE* pDest = fopen(fileName.getStr(), "r");
+    if ( pDest )
+    {
+        fclose(pDest);
+        unlink(fileName.getStr());
+    }
+}
+
+sal_Int32 SAL_CALL produceFile(const OString& fileName)
+{
+    Options* pOptions = idlc()->getOptions();
+
+    OString regFileName;
+    if ( pOptions->isValid("-O") )
+    {
+        regFileName = pOptions->getOption("-O");
+        sal_Char c = regFileName.getStr()[regFileName.getLength()-1];
+
+        if ( c != SEPERATOR )
+            regFileName += OString::valueOf(SEPERATOR);
+    }
+
+    OString regTmpName(regFileName);
+    OString strippedFileName(fileName.copy(fileName.lastIndexOf(SEPERATOR) + 1));
+    regFileName += strippedFileName.replaceAt(strippedFileName.getLength() -3 , 3, "urd");
+    regTmpName += strippedFileName.replaceAt(strippedFileName.getLength() -3 , 3, "_idlc_");
+
+    if ( !checkOutputPath(regTmpName) )
+    {
+        fprintf(stderr, "%s: could not create path of registry file '%s'.\n",
+                pOptions->getProgramName().getStr(), regFileName.getStr());
+        removeIfExists(regFileName);
+        return 1;
+    }
+
+    RegistryLoader              regLoader;
+    RegistryTypeWriterLoader    writerLoader;
+
+    if ( !regLoader.isLoaded() || !writerLoader.isLoaded() )
+    {
+        fprintf(stderr, "%s: could not load registry dll.\n",
+                pOptions->getProgramName().getStr());
+        removeIfExists(regFileName);
+        cleanPath();
+        return 1;
+    }
+
+    Registry regFile(regLoader);
+
+    removeIfExists(regTmpName);
+    if ( regFile.create(OStringToOUString(regTmpName, RTL_TEXTENCODING_UTF8)) )
+    {
+        fprintf(stderr, "%s: could not create registry file '%s'\n",
+                pOptions->getProgramName().getStr(), regTmpName.getStr());
+        removeIfExists(regTmpName);
+        removeIfExists(regFileName);
+        cleanPath();
+        return 1;
+    }
+
+    RegistryKey rootKey;
+    if ( regFile.openRootKey(rootKey) )
+    {
+        fprintf(stderr, "%s: could not open root of registry file '%s'\n",
+                pOptions->getProgramName().getStr(), regFileName.getStr());
+        removeIfExists(regTmpName);
+        removeIfExists(regFileName);
+        cleanPath();
+        return 1;
+    }
+
+    // produce registry file
+    if ( !idlc()->getRoot()->dump(rootKey, &writerLoader) )
+    {
+        rootKey.closeKey();
+        regFile.close();
+        regFile.destroy(OStringToOUString(regFileName, RTL_TEXTENCODING_UTF8));
+        removeIfExists(regFileName);
+        cleanPath();
+        return 1;
+    }
+
+    if ( rootKey.closeKey() )
+    {
+        fprintf(stderr, "%s: could not close root of registry file '%s'\n",
+                pOptions->getProgramName().getStr(), regFileName.getStr());
+        removeIfExists(regTmpName);
+        removeIfExists(regFileName);
+        cleanPath();
+        return 1;
+    }
+    if ( regFile.close() )
+    {
+        fprintf(stderr, "%s: could not close registry file '%s'\n",
+                pOptions->getProgramName().getStr(), regFileName.getStr());
+        removeIfExists(regTmpName);
+        removeIfExists(regFileName);
+        cleanPath();
+        return 1;
+    }
+
+    removeIfExists(regFileName);
+    if ( rename(regTmpName.getStr(), regFileName.getStr()) != 0 )
+    {
+        fprintf(stderr, "%s: cannot rename temporary registry '%s' to '%s'\n",
+                idlc()->getOptions()->getProgramName().getStr(),
+                regTmpName.getStr(), regFileName.getStr());
+        removeIfExists(regTmpName);
+        cleanPath();
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/idlc/source/makefile.mk b/idlc/source/makefile.mk
new file mode 100644
index 000000000000..7d0ce6f8054d
--- /dev/null
+++ b/idlc/source/makefile.mk
@@ -0,0 +1,147 @@
+#*************************************************************************
+#
+#   $RCSfile: makefile.mk,v $
+#
+#   $Revision: 1.1 $
+#
+#   last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+#
+#   The Contents of this file are made available subject to the terms of
+#   either of the following licenses
+#
+#          - GNU Lesser General Public License Version 2.1
+#          - Sun Industry Standards Source License Version 1.1
+#
+#   Sun Microsystems Inc., October, 2000
+#
+#   GNU Lesser General Public License Version 2.1
+#   =============================================
+#   Copyright 2000 by Sun Microsystems, Inc.
+#   901 San Antonio Road, Palo Alto, CA 94303, USA
+#
+#   This library is free software; you can redistribute it and/or
+#   modify it under the terms of the GNU Lesser General Public
+#   License version 2.1, as published by the Free Software Foundation.
+#
+#   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
+#
+#
+#   Sun Industry Standards Source License Version 1.1
+#   =================================================
+#   The contents of this file are subject to the Sun Industry Standards
+#   Source License Version 1.1 (the "License"); You may not use this file
+#   except in compliance with the License. You may obtain a copy of the
+#   License at http://www.openoffice.org/license.html.
+#
+#   Software provided under this License is provided on an "AS IS" basis,
+#   WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+#   WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+#   MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+#   See the License for the specific provisions governing your rights and
+#   obligations concerning the Software.
+#
+#   The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+#
+#   Copyright: 2000 by Sun Microsystems, Inc.
+#
+#   All Rights Reserved.
+#
+#   Contributor(s): _______________________________________
+#
+#
+#
+#*************************************************************************
+
+PRJ=..
+
+PRJNAME=idlc
+TARGET=idlc
+TARGETTYPE=CUI
+LIBTARGET=NO
+
+ENABLE_EXCEPTIONS=TRUE
+
+# --- Settings -----------------------------------------------------
+
+
+.INCLUDE :  svpre.mk
+.INCLUDE :  settings.mk
+.INCLUDE :  sv.mk
+
+
+# --- Files --------------------------------------------------------
+
+CXXFILES=   \
+            $(MISC)$/scanner.cxx \
+            $(MISC)$/parser.cxx	\
+            idlcmain.cxx	\
+            idlc.cxx	\
+            idlccompile.cxx	\
+            idlcproduce.cxx	\
+            errorhandler.cxx	\
+            options.cxx	\
+            fehelper.cxx	\
+            astdeclaration.cxx \
+            astscope.cxx \
+            aststack.cxx \
+            astdump.cxx \
+            astinterface.cxx \
+            aststruct.cxx \
+            astoperation.cxx \
+            astconstant.cxx \
+            astenum.cxx \
+            astarray.cxx \
+            astunion.cxx \
+            astexpression.cxx
+
+OBJFILES=   \
+            $(OBJ)$/scanner.obj	\
+            $(OBJ)$/parser.obj	\
+            $(OBJ)$/idlcmain.obj	\
+            $(OBJ)$/idlc.obj	\
+            $(OBJ)$/idlccompile.obj	\
+            $(OBJ)$/idlcproduce.obj	\
+            $(OBJ)$/errorhandler.obj	\
+            $(OBJ)$/options.obj	\
+            $(OBJ)$/fehelper.obj	\
+            $(OBJ)$/astdeclaration.obj	\
+            $(OBJ)$/astscope.obj	\
+            $(OBJ)$/aststack.obj	\
+            $(OBJ)$/astdump.obj	\
+            $(OBJ)$/astinterface.obj	\
+            $(OBJ)$/aststruct.obj	\
+            $(OBJ)$/astoperation.obj	\
+            $(OBJ)$/astconstant.obj	\
+            $(OBJ)$/astenum.obj	\
+            $(OBJ)$/astarray.obj	\
+            $(OBJ)$/astunion.obj	\
+            $(OBJ)$/astexpression.obj
+
+APP1TARGET= $(TARGET)
+APP1OBJS=   $(OBJFILES)
+
+APP1STDLIBS=\
+        $(SALLIB)	\
+        $(SALHELPERLIB)
+
+# --- Targets ------------------------------------------------------
+
+.INCLUDE :  target.mk
+
+
+$(MISC)$/scanner.cxx:	scanner.ll
+    +flex -o$(MISC)$/scanner.cxx scanner.ll
+
+$(MISC)$/parser.cxx: parser.yy
+    +bison -v -d -o$(MISC)$/parser.cxx parser.yy
+    +$(COPY) $(MISC)$/parser.cxx.h $(OUT)$/inc$/parser.h
+# with line statements (for debugging)
+#	+bison -v -d -o$(MISC)$/parser.cxx parser.yy
diff --git a/idlc/source/options.cxx b/idlc/source/options.cxx
new file mode 100644
index 000000000000..062f43d73c1c
--- /dev/null
+++ b/idlc/source/options.cxx
@@ -0,0 +1,372 @@
+/*************************************************************************
+ *
+ *  $RCSfile: options.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#include <stdio.h>
+
+#ifndef _IDLC_OPTIONS_HXX_
+#include <idlc/options.hxx>
+#endif
+
+using namespace rtl;
+
+Options::Options()
+{
+}
+
+Options::~Options()
+{
+
+}
+
+sal_Bool Options::initOptions(int ac, char* av[], sal_Bool bCmdFile)
+    throw( IllegalArgument )
+{
+    sal_Bool    ret = sal_True;
+    sal_uInt16  i=0;
+
+    if (!bCmdFile)
+    {
+        bCmdFile = sal_True;
+
+        m_program = av[0];
+
+        if (ac < 2)
+        {
+            fprintf(stderr, "%s", prepareHelp().getStr());
+            ret = sal_False;
+        }
+
+        i = 1;
+    } else
+    {
+        i = 0;
+    }
+
+    char    *s=NULL;
+    for (i; i < ac; i++)
+    {
+        if (av[i][0] == '-')
+        {
+            switch (av[i][1])
+            {
+                case 'O':
+                    if (av[i][2] == '\0')
+                    {
+                        if (i < ac - 1 && av[i+1][0] != '-')
+                        {
+                            i++;
+                            s = av[i];
+                        } else
+                        {
+                            OString tmp("'-O', please check");
+                            if (i <= ac - 1)
+                            {
+                                tmp += " your input '" + OString(av[i+1]) + "'";
+                            }
+
+                            throw IllegalArgument(tmp);
+                        }
+                    } else
+                    {
+                        s = av[i] + 2;
+                    }
+
+                    m_options["-O"] = OString(s);
+                    break;
+                case 'I':
+                {
+                    if (av[i][2] == '\0')
+                    {
+                        if (i < ac - 1 && av[i+1][0] != '-')
+                        {
+                            i++;
+                            s = av[i];
+                        } else
+                        {
+                            OString tmp("'-I', please check");
+                            if (i <= ac - 1)
+                            {
+                                tmp += " your input '" + OString(av[i+1]) + "'";
+                            }
+
+                            throw IllegalArgument(tmp);
+                        }
+                    } else
+                    {
+                        s = av[i] + 2;
+                    }
+
+                    OString inc(s);
+                    if ( inc.indexOf(';') > 0 )
+                    {
+                        OString tmp(s);
+                        sal_Int32 count = tmp.getTokenCount(';');
+                        inc = OString();
+                        for (sal_Int32 i=0; i < count; i++)
+                            inc = inc + " -I" + tmp.getToken(i, ';');
+                    } else
+                        inc = OString("-I") + s;
+
+                    if (m_options.count("-I") > 0)
+                    {
+                        OString tmp(m_options["-I"]);
+                        tmp = tmp + " " + inc;
+                        m_options["-I"] = tmp;
+                    } else
+                    {
+                        m_options["-I"] = inc;
+                    }
+                }
+                    break;
+                case 'D':
+                    if (av[i][2] == '\0')
+                    {
+                        if (i < ac - 1 && av[i+1][0] != '-')
+                        {
+                            i++;
+                            s = av[i];
+                        } else
+                        {
+                            OString tmp("'-D', please check");
+                            if (i <= ac - 1)
+                            {
+                                tmp += " your input '" + OString(av[i+1]) + "'";
+                            }
+
+                            throw IllegalArgument(tmp);
+                        }
+                    } else
+                    {
+                        s = av[i];
+                    }
+
+                    if (m_options.count("-D") > 0)
+                    {
+                        OString tmp(m_options["-D"]);
+                        tmp = tmp + " " + s;
+                        m_options["-D"] = tmp;
+                    } else
+                    {
+                        m_options["-D"] = OString(s);
+                    }
+                    break;
+                case 'C':
+                    if (av[i][2] != '\0')
+                    {
+                        throw IllegalArgument(OString(av[i]) + ", please check your input");
+                    }
+                    if (m_options.count("-C") == 0)
+                    {
+                        m_options["-C"] = OString(s);
+                    }
+                    break;
+                case 'h':
+                case '?':
+                    if (av[i][2] != '\0')
+                    {
+                        throw IllegalArgument(OString(av[i]) + ", please check your input");
+                    } else
+                    {
+                        fprintf(stdout, "%s", prepareHelp().getStr());
+                        exit(0);
+                    }
+                    break;
+                default:
+                    throw IllegalArgument("the option is unknown" + OString(av[i]));
+                    break;
+            }
+        } else
+        {
+            if (av[i][0] == '@')
+            {
+                FILE* cmdFile = fopen(av[i]+1, "r");
+                  if( cmdFile == NULL )
+                  {
+                    fprintf(stderr, "%s", prepareHelp().getStr());
+                    ret = sal_False;
+                } else
+                {
+                    int rargc=0;
+                    char* rargv[512];
+                    char  buffer[512];
+
+                    while ( fscanf(cmdFile, "%s", buffer) != EOF )
+                    {
+                        rargv[rargc]= strdup(buffer);
+                        rargc++;
+                    }
+                    fclose(cmdFile);
+
+                    ret = initOptions(rargc, rargv, bCmdFile);
+
+                    for (long i=0; i < rargc; i++)
+                    {
+                        free(rargv[i]);
+                    }
+                }
+            } else
+            {
+                OString name(av[i]);
+                name = name.toLowerCase();
+                if ( name.lastIndexOf(".idl") != (name.getLength() - 4) )
+                {
+                    throw IllegalArgument("'" + OString(av[i]) +
+                        "' is not a valid input file, only '*.idl' files will be accepted");
+                }
+                m_inputFiles.push_back(av[i]);
+            }
+        }
+    }
+
+    return ret;
+}
+
+OString Options::prepareHelp()
+{
+    OString help("\nusing: ");
+    help += m_program + " [-options] file_1 ... file_n | @<filename>\n";
+    help += "    file_n      = file_n specifies one or more idl files.\n";
+    help += "                  Only files with the extension '.idl' are valid.\n";
+    help += "    @<filename> = filename specifies the name of a command file.\n";
+    help += "  Options:\n";
+    help += "    -O<path>   = path describes the output directory.\n";
+    help += "                 The generated output is a registry file with\n";
+    help += "                 the same name as the idl input file.\n";
+    help += "    -I<path>   = path specifies a directory where are include\n";
+    help += "                 files will be searched by the preprcessor.\n";
+    help += "                 Multible directories could be combined with ';'.\n";
+    help += "    -D<name>   = name defines a macro for the preprocessor.\n";
+    help += "    -C         = generate complete type information, including\n";
+    help += "                 additional service information and documentation.\n";
+    help += "    -h|-?      = print this help message and exit.\n";
+    help += prepareVersion();
+
+    return help;
+}
+
+OString Options::prepareVersion()
+{
+    OString version("\nSun Microsystems (R) ");
+    version += m_program + " Version 1.0\n\n";
+    return version;
+}
+
+const OString& Options::getProgramName() const
+{
+    return m_program;
+}
+
+sal_uInt16 Options::getNumberOfOptions() const
+{
+    return m_options.size();
+}
+
+sal_Bool Options::isValid(const OString& option)
+{
+    return (m_options.count(option) > 0);
+}
+
+const OString Options::getOption(const OString& option)
+    throw( IllegalArgument )
+{
+    const OString ret;
+
+    if (m_options.count(option) > 0)
+    {
+        return m_options[option];
+    } else
+    {
+        throw IllegalArgument("Option is not valid or currently not set.");
+    }
+
+    return ret;
+}
+
+const OptionMap& Options::getOptions()
+{
+    return m_options;
+}
+
+sal_uInt16 Options::getNumberOfInputFiles() const
+{
+    return m_inputFiles.size();
+}
+
+const OString Options::getInputFile(sal_uInt16 index)
+    throw( IllegalArgument )
+{
+    const OString ret;
+
+    if (index < m_inputFiles.size())
+    {
+        return m_inputFiles[index];
+    } else
+    {
+        throw IllegalArgument("index is out of bound.");
+    }
+
+    return ret;
+}
+
+const StringVector& Options::getInputFiles()
+{
+    return m_inputFiles;
+}
+
diff --git a/idlc/source/scanner.ll b/idlc/source/scanner.ll
new file mode 100644
index 000000000000..c6c0478a7eb9
--- /dev/null
+++ b/idlc/source/scanner.ll
@@ -0,0 +1,466 @@
+/*************************************************************************
+ *
+ *  $RCSfile: scanner.ll,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-03-15 12:30:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+%{
+/*
+ * scanner.ll - Lexical scanner for IDLC 1.0
+ */
+#include <ctype.h>
+
+#ifndef _IDLC_IDLC_HXX_
+#include <idlc/idlc.hxx>
+#endif
+#ifndef _IDLC_FEHELPER_HXX_
+#include <idlc/fehelper.hxx>
+#endif
+
+class AstExpression;
+class AstArray;
+class AstMember;
+
+#include <parser.h>
+
+sal_Int32		beginLine = 0;
+::rtl::OString	docu;
+
+static sal_Int64 asciiToInteger( sal_Int8 base, const sal_Char *s )
+{
+	sal_Int64    r = 0;
+	sal_Int64    negative = 0;
+
+	if (*s == '-')
+   	{
+    	negative = 1;
+      	s++;
+   	}
+   	if (base == 8 && *s == '0')
+		s++;
+   	else if (base == 16 && *s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))
+    	s += 2;
+
+   	for (; *s; s++)
+   	{
+   		if (*s <= '9' && *s >= '0')
+        	r = (r * base) + (*s - '0');
+      	else if (base > 10 && *s <= 'f' && *s >= 'a')
+        	r = (r * base) + (*s - 'a' + 10);
+      	else if (base > 10 && *s <= 'F' && *s >= 'A')
+        	r = (r * base) + (*s - 'A' + 10);
+       	else
+        	break;
+	}
+   	if (negative) r *= -1;
+	return r;
+}
+
+static double asciiToFloat(const sal_Char *s)
+{
+	sal_Char    *h = (sal_Char*)s;
+   	double  	d = 0.0;
+   	double  	f = 0.0;
+   	double  	e, k;
+   	sal_Int32  	neg = 0, negexp = 0;
+
+   	if (*s == '-')
+   	{
+    	neg = 1;
+       	s++;
+   	}
+   	while (*s >= '0' && *s <= '9')
+   	{
+    	d = (d * 10) + *s - '0';
+       	s++;
+   	}
+   	if (*s == '.')
+   	{
+    	s++;
+       	e = 10;
+       	while (*s >= '0' && *s <= '9')
+       	{
+        	d += (*s - '0') / (e * 1.0);
+           	e *= 10;
+           	s++;
+       	}
+   	}
+   	if (*s == 'e' || *s == 'E')
+   	{
+    	s++;
+       	if (*s == '-')
+        {
+        	negexp = 1;
+           	s++;
+       	} else
+       	{
+        	if (*s == '+')
+            	s++;
+           	e = 0;
+           	while (*s >= '0' && *s <= '9')
+           	{
+            	e = (e * 10) + *s - '0';
+             	s++;
+           	}
+           	if (e > 0)
+           	{
+            	for (k = 1; e > 0; k *= 10, e--);
+               	if (negexp)
+                	d /= k;
+               	else
+                	d *= k;
+           	}
+		}
+   	}
+   	if (neg) d *= -1.0;
+   	return d;
+}
+
+static void	idlParsePragma(sal_Char* pPragma)
+{
+	::rtl::OString pragma(pPragma);
+	sal_Int32 index = pragma.indexOf("include");
+	sal_Char* begin = pPragma + index + 8;
+	sal_Char* offset = begin;
+	while (*offset != ',') offset++;
+	//::rtl::OString include = pragma.copy(index + 8, offset - begin);
+	idlc()->insertInclude(pragma.copy(index + 8, offset - begin));
+}	
+
+static void parseLineAndFile(sal_Char* pBuf)
+{
+	sal_Char	*r = pBuf;
+	sal_Char    *h;
+	sal_Bool	bIsInMain = sal_False;
+
+	/* Skip initial '#' */
+	if (*r != '#')
+		return;
+
+	/* Find line number */
+	for (r++; *r == ' ' || *r == '\t' || isalpha(*r); r++);
+	h = r;
+	for (; *r != '\0' && *r != ' ' && *r != '\t'; r++);
+	*r++ = 0;
+	idlc()->setLineNumber((sal_uInt32)asciiToInteger(10, h));
+
+	/* Find file name, if present */
+	for (; *r != '"'; r++)
+	{
+		if (*r == '\n' || *r == '\0')
+			return;
+	}
+	h = ++r;
+	for (; *r != '"'; r++);
+	*r = 0;
+	if (*h == '\0')
+		idlc()->setFileName(::rtl::OString("standard input"));
+	else
+		idlc()->setFileName(::rtl::OString(h));
+
+	bIsInMain = (idlc()->getFileName() == idlc()->getRealFileName()) ? sal_True : sal_False;
+	idlc()->setInMainfile(bIsInMain);		
+}	
+
+%}
+
+%option noyywrap
+%option never-interactive
+
+%x DOCU
+%x COMMENT
+
+DIGIT			[0-9]
+OCT_DIGIT       [0-7]
+HEX_DIGIT       [a-fA-F0-9]
+ALPHA			[a-zA-Z]
+INT_LITERAL		[1-9][0-9]*
+OCT_LITERAL		0{OCT_DIGIT}*
+HEX_LITERAL		(0x|0X){HEX_DIGIT}*
+ESC_SEQUENCE1	"\\"[ntvbrfa\\\?\'\"]
+ESC_SEQUENCE2   "\\"{OCT_DIGIT}{1,3}
+ESC_SEQUENCE3   "\\"(x|X){HEX_DIGIT}{1,2}
+ESC_SEQUENCE    ({ESC_SEQUENCE1}|{ESC_SEQUENCE2}|{ESC_SEQUENCE3})
+CHAR        	([^\n\t\"\'\\]|{ESC_SEQUENCE})
+CHAR_LITERAL    "'"({CHAR}|\")"'"
+STRING_LITERAL	\"({CHAR}|"'")*\"
+
+IDENTIFIER		({ALPHA}|_{ALPHA})({ALPHA}|{DIGIT}|_)*
+
+%%
+
+[ \t\r]+	; /* eat up whitespace */
+[\n] 		{
+	idlc()->incLineNumber();
+}
+
+attribute		return IDL_ATTRIBUTE;
+bound			return IDL_BOUND;
+case			return IDL_CASE;
+const			return IDL_CONST;
+constants		return IDL_CONSTANTS;
+constrained		return IDL_CONSTRAINED;
+default			return IDL_DEFAULT;
+enum			return IDL_ENUM;
+exception		return IDL_EXCEPTION;
+interface		return IDL_INTERFACE;
+maybeambiguous 	return IDL_MAYBEAMBIGUOUS;
+maybedefault	return IDL_MAYBEDEFAULT;
+maybevoid		return IDL_MAYBEVOID;
+module			return IDL_MODULE;
+needs			return IDL_NEEDS;
+observes		return IDL_OBSERVES;
+optional		return IDL_OPTIONAL;
+property		return IDL_PROPERTY;
+raises			return IDL_RAISES;
+readonly		return IDL_READONLY;
+removable 		return IDL_REMOVEABLE;
+service			return IDL_SERVICE;
+sequence		return IDL_SEQUENCE;
+struct			return IDL_STRUCT;
+switch			return IDL_SWITCH;
+transient 		return IDL_TRANSIENT;
+typedef			return IDL_TYPEDEF;
+union			return IDL_UNION;
+
+any			return IDL_ANY;				
+boolean		return IDL_BOOLEAN;
+byte		return IDL_BYTE;
+char		return IDL_CHAR;
+double		return IDL_DOUBLE;
+float		return IDL_FLOAT;
+hyper		return IDL_HYPER;
+long		return IDL_LONG;
+short		return IDL_SHORT;
+string		return IDL_STRING;
+type		return IDL_TYPE;
+unsigned	return IDL_UNSIGNED;
+void		return IDL_VOID;
+
+TRUE		return IDL_TRUE;
+True		return IDL_TRUE;
+FALSE		return IDL_FALSE;
+False		return IDL_FALSE;
+
+in			return IDL_IN;
+out			return IDL_OUT;
+inout		return IDL_INOUT;
+oneway		return IDL_ONEWAY;
+
+("-")?{INT_LITERAL}+(l|L|u|U)?    {
+            	yylval.ival = asciiToInteger( 10, yytext );
+				return IDL_INTEGER_LITERAL;
+            }
+
+("-")?{OCT_LITERAL}+(l|L|u|U)?    {
+            	yylval.ival = asciiToInteger( 8, yytext+1 );
+				return IDL_INTEGER_LITERAL;
+            }
+
+("-")?{HEX_LITERAL}+(l|L|u|U)?    {
+            	yylval.ival = asciiToInteger( 16, yytext+2 );
+				return IDL_INTEGER_LITERAL;
+            }
+
+{CHAR_LITERAL}	{
+            	yylval.cval = *yytext;
+				return IDL_CHARACTER_LITERAL;
+			}
+
+{STRING_LITERAL}	{
+            	yylval.sval = new ::rtl::OString(yytext);
+				return IDL_STRING_LITERAL;
+			}
+
+("-")?{DIGIT}*(e|E){1}(("+"|"-")?{DIGIT}+)+(f|F)?	|
+("-")?"."{DIGIT}*((e|E)("+"|"-")?{DIGIT}+)?(f|F)?	|
+("-")?{DIGIT}*"."{DIGIT}*((e|E)("+"|"-")?{DIGIT}+)?(f|F)?        {
+            	yylval.dval = asciiToFloat( yytext );
+				return IDL_FLOATING_PT_LITERAL;
+            }
+
+{IDENTIFIER}	{
+				yylval.sval = new ::rtl::OString(yytext);
+				return IDL_IDENTIFIER;
+			}
+
+\<\<  	{
+		yylval.strval = yytext;
+		return IDL_LEFTSHIFT;
+	}
+\>\>	{
+		yylval.strval = yytext;
+		return IDL_RIGHTSHIFT;
+	}
+\:\:	{
+		yylval.strval = yytext;
+		return IDL_SCOPESEPERATOR;
+	}
+
+"/*"	{ 
+			BEGIN( COMMENT );
+			docu = ::rtl::OString();
+			beginLine = idlc()->getLineNumber();
+		}
+
+"/***"	{ 
+			BEGIN( COMMENT );
+			docu = ::rtl::OString();
+			beginLine = idlc()->getLineNumber();
+		}
+
+<COMMENT>[^*]+	{
+				docu += ::rtl::OString(yytext);
+			} 
+
+<COMMENT>"*"[^*/]+ 	{
+				docu += ::rtl::OString(yytext);
+			}
+
+<COMMENT>"**" 	{
+				docu += ::rtl::OString(yytext);
+			}
+
+<COMMENT>[*]+"/"  {
+				docu = docu.trim();
+				idlc()->setLineNumber( beginLine + docu.getTokenCount('\n') - 1);
+			  	BEGIN( INITIAL );
+			}
+
+"/**"	{
+			BEGIN( DOCU );
+			docu = ::rtl::OString();
+			beginLine = idlc()->getLineNumber();
+		}
+
+<DOCU>[^*\n]+	{
+				docu += ::rtl::OString(yytext);
+			} 
+<DOCU>"\n"[ \t]*"*"{1} 	{
+				docu += ::rtl::OString("\n");
+			}
+
+<DOCU>"\n"	{
+				docu += ::rtl::OString(yytext);
+			}
+
+<DOCU>"*"[^*/\n]+ 	{
+				docu += ::rtl::OString(yytext);
+			}
+
+<DOCU>"\n"[ \t]*"*/" 	{
+				docu = docu.trim();
+				idlc()->setLineNumber( beginLine + docu.getTokenCount('\n') - 1);
+				idlc()->setDocumentation(docu);
+			  	BEGIN( INITIAL );
+			}
+
+<DOCU>"*/"	{
+				docu = docu.trim();
+				idlc()->setLineNumber( beginLine + docu.getTokenCount('\n') - 1);
+				idlc()->setDocumentation(docu);
+			  	BEGIN( INITIAL );
+			}
+
+"//"[^/]{1}.*"\n" {
+				/* only a comment */
+				::rtl::OString docStr(yytext);
+				docStr = docStr.copy( 0, docStr.lastIndexOf('\n') );
+				docStr = docStr.copy( docStr.lastIndexOf('/')+1 );
+				docStr = docStr.trim();
+				idlc()->incLineNumber();
+			}
+
+"///".*"\n"  {
+				::rtl::OString docStr(yytext);
+				docStr = docStr.copy( 0, docStr.lastIndexOf('\n') );
+				docStr = docStr.copy( docStr.lastIndexOf('/')+1 );
+				docStr = docStr.trim();
+				idlc()->incLineNumber();
+				idlc()->setDocumentation(docStr);
+			}
+
+.	return yytext[0];
+
+^#[ \t]*line[ \t]*[0-9]*" ""\""[^\"]*"\""\n    {
+	parseLineAndFile(yytext);
+}
+
+^#[ \t]*[0-9]*" ""\""[^\"]*"\""" "[0-9]*\n {
+	parseLineAndFile(yytext);
+}
+
+^#[ \t]*[0-9]*" ""\""[^\"]*"\""\n {
+	parseLineAndFile(yytext);
+}
+
+^#[ \t]*[0-9]*\n {
+	parseLineAndFile(yytext);
+}
+
+^#[ \t]*ident.*\n {
+	/* ignore cpp ident */
+	idlc()->incLineNumber();
+}
+
+^#[ \t]*pragma[ \t].*\n        {       /* remember pragma */
+	idlParsePragma(yytext);
+	idlc()->incLineNumber();
+}
+
+%%