codemaker/source/bonobowrappermaker/corbamaker.cxx

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2008 by Sun Microsystems, Inc.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * $RCSfile: corbamaker.cxx,v $
  11  * $Revision: 1.7 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_codemaker.hxx"
  34
  35 #include <stdio.h>
  36
  37 #include "sal/main.h"
  38
  39 #include <codemaker/typemanager.hxx>
  40 #include <codemaker/dependency.hxx>
  41
  42 #include "corbaoptions.hxx"
  43 #include "corbatype.hxx"
  44
  45 using namespace rtl;
  46
  47 sal_Bool produceAllTypes(const OString& typeName,
  48                         TypeManager& typeMgr,
  49                         TypeDependency& typeDependencies,
  50                         CorbaOptions* pOptions,
  51                         sal_Bool bFullScope,
  52                         FileStream& o,
  53                         TypeSet* pAllreadyDumped,
  54                         TypeSet* generatedConversion)
  55
  56     throw( CannotDumpException )
  57 {
  58     if (!produceType(typeName, typeMgr, typeDependencies, pOptions, o, pAllreadyDumped, generatedConversion))
  59     {
  60         fprintf(stderr, "%s ERROR: %s\n",
  61                 pOptions->getProgramName().getStr(),
  62                 OString("cannot dump Type '" + typeName + "'").getStr());
  63         exit(99);
  64     }
  65
  66     RegistryKey typeKey = typeMgr.getTypeKey(typeName);
  67     RegistryKeyNames subKeys;
  68
  69     if (typeKey.getKeyNames(OUString(), subKeys))
  70         return sal_False;
  71
  72     OString tmpName;
  73     for (sal_uInt32 i=0; i < subKeys.getLength(); i++)
  74     {
  75         tmpName = OUStringToOString(subKeys.getElement(i), RTL_TEXTENCODING_UTF8);
  76
  77         if (pOptions->isValid("-B"))
  78             tmpName = tmpName.copy(tmpName.indexOf('/', 1) + 1);
  79         else
  80             tmpName = tmpName.copy(1);
  81
  82         if (bFullScope)
  83         {
  84             if (!produceAllTypes(tmpName, typeMgr, typeDependencies, pOptions, sal_True, o, pAllreadyDumped, generatedConversion))
  85                 return sal_False;
  86         } else
  87         {
  88             if (!produceType(tmpName, typeMgr, typeDependencies, pOptions, o, pAllreadyDumped, generatedConversion))
  89                 return sal_False;
  90         }
  91     }
  92
  93     return sal_True;
  94 }
  95
  96 SAL_IMPLEMENT_MAIN_WITH_ARGS(argc, argv)
  97 {
  98     CorbaOptions options;
  99
 100     try
 101     {
 102         if (!options.initOptions(argc, argv))
 103         {
 104             exit(1);
 105         }
 106     }
 107     catch( IllegalArgument& e)
 108     {
 109         fprintf(stderr, "Illegal option: %s\n", e.m_message.getStr());
 110         exit(99);
 111     }
 112
 113     RegistryTypeManager typeMgr;
 114     TypeDependency              typeDependencies;
 115
 116     if (!typeMgr.init(!options.isValid("-T"), options.getInputFiles()))
 117     {
 118         fprintf(stderr, "%s : init registries failed, check your registry files.\n", options.getProgramName().getStr());
 119         exit(99);
 120     }
 121
 122     if (options.isValid("-B"))
 123     {
 124         typeMgr.setBase(options.getOption("-B"));
 125     }
 126
 127     try
 128     {
 129         TypeSet generatedConversion;
 130         FileStream cppFile;
 131         OString outPath;
 132         if (options.isValid("-O"))
 133             outPath = options.getOption("-O");
 134
 135         cppFile.open(outPath);
 136
 137         if(!cppFile.isValid())
 138         {
 139             OString message("cannot open ");
 140             message += outPath + " for writing";
 141             throw CannotDumpException(message);
 142         }
 143
 144         if (options.isValid("-H"))
 145         {
 146             OString corbaHeader = options.getOption("-H");
 147
 148             cppFile << "#include <"
 149                     << corbaHeader
 150                     << ">\n\n";
 151
 152             CorbaType::dumpDefaultHxxIncludes(cppFile);
 153             cppFile << "\n";
 154         }
 155
 156         if (options.isValid("-T"))
 157         {
 158             OString tOption(options.getOption("-T"));
 159
 160             OString typeName, tmpName;
 161             sal_Bool ret = sal_False;
 162             sal_Int32 nIndex = 0;
 163             do
 164             {
 165                 typeName = tOption.getToken(0, ';', nIndex);
 166
 167                 sal_Int32 nPos = typeName.lastIndexOf( '.' );
 168                 tmpName = typeName.copy( nPos != -1 ? nPos+1 : 0 );
 169                 if (tmpName == "*")
 170                 {
 171                     // produce this type and his scope, but the scope is not recursively  generated.
 172                     if (typeName.equals("*"))
 173                     {
 174                         tmpName = "/";
 175                     } else
 176                     {
 177                         tmpName = typeName.copy(0, typeName.lastIndexOf('.')).replace('.', '/');
 178                         if (tmpName.getLength() == 0)
 179                             tmpName = "/";
 180                         else
 181                             tmpName.replace('.', '/');
 182                     }
 183                     ret = produceAllTypes(tmpName, typeMgr, typeDependencies, &options, sal_False, cppFile, NULL, &generatedConversion);
 184                 } else
 185                 {
 186                     // produce only this type
 187                     ret = produceType(typeName.replace('.', '/'), typeMgr, typeDependencies, &options, cppFile, NULL, &generatedConversion);
 188                 }
 189
 190                 if (!ret)
 191                 {
 192                     fprintf(stderr, "%s ERROR: %s\n",
 193                             options.getProgramName().getStr(),
 194                             OString("cannot dump Type '" + typeName + "'").getStr());
 195                     exit(99);
 196                 }
 197             } while( nIndex != -1 );
 198         } else
 199         {
 200             // produce all types
 201             if (!produceAllTypes("/", typeMgr, typeDependencies, &options, sal_True, cppFile, NULL, &generatedConversion))
 202             {
 203                 fprintf(stderr, "%s ERROR: %s\n",
 204                         options.getProgramName().getStr(),
 205                         "an error occurs while dumping all types.");
 206                 exit(99);
 207             }
 208         }
 209
 210         cppFile << "namespace bonobobridge {\n"
 211                 << "const ConversionInfo* get_conversion_functions() {\n"
 212                 << "  static ConversionInfo allFunctions[" << generatedConversion.size()+1<< "] = {\n";
 213
 214         for (TypeSet::iterator iter = generatedConversion.begin(); iter != generatedConversion.end(); iter++)
 215         {
 216             cppFile << "    {\"" << (*iter).getStr() << "\""
 217                     << ", &TC_" << (*iter).replace('/','_').getStr() << "_struct"
 218                     << ", sizeof(" << (*iter).replace('/','_').getStr() << ")"
 219                     << ", convert_b2u_" << (*iter).replace('/','_').getStr()
 220                     << ", convert_u2b_" <<  (*iter).replace('/','_').getStr()
 221                     << " },\n";
 222         }
 223
 224         cppFile << "    {NULL, NULL, 0 , NULL, NULL} };\n"
 225                 << "  return allFunctions;\n"
 226                 << "}\n"
 227                 << "}; // namespace bonobobridge\n";
 228
 229         cppFile.close();
 230     }
 231     catch( CannotDumpException& e)
 232     {
 233         fprintf(stderr, "%s ERROR: %s\n",
 234                 options.getProgramName().getStr(),
 235                 e.m_message.getStr());
 236         exit(99);
 237     }
 238
 239     return 0;
 240 }
 241
 242