xml2cmp/source/xcd/main.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: main.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <iostream>
  32 #include <fstream>
  33 #include <stdio.h>
  34
  35
  36 #include <string.h>
  37 #include "../support/cmdline.hxx"
  38 #include "cr_metho.hxx"
  39 #include "cr_html.hxx"
  40 #include "cr_index.hxx"
  41 #include "xmlelem.hxx"
  42 #include "xmltree.hxx"
  43 #include "parse.hxx"
  44 #include "../support/syshelp.hxx"
  45 #include "../support/heap.hxx"
  46
  47
  48
  49 int                                     Do_IndexCommandLine(
  50                             const CommandLine &         i_rCommandLine );
  51 int                                     Do_SingleFileCommandLine(
  52                             const CommandLine &         i_rCommandLine );
  53 void                                    Create_TypeInfo(
  54                             const char *                        o_sOutputFile,
  55                             ModuleDescription &     i_rData );
  56
  57
  58 int
  59 #ifdef WNT
  60 _cdecl
  61 #endif
  62 main( int               argc,
  63       char *    argv[] )
  64 {
  65     // Variables
  66     CommandLine                         aCommandLine(argc, argv);
  67     int ret = 0;
  68
  69     if (! aCommandLine.IsOk())
  70     {
  71         std::cerr <<  aCommandLine.ErrorText() << std::endl ;
  72         return 1;
  73     }
  74
  75     if ( aCommandLine.IsIndexCommand() )
  76         ret = Do_IndexCommandLine(aCommandLine);
  77     else
  78         ret = Do_SingleFileCommandLine(aCommandLine);
  79
  80     return ret;
  81 }
  82
  83
  84 int
  85 Do_SingleFileCommandLine(const CommandLine & i_rCommandLine)
  86 {
  87     ModuleDescription   aDescr;
  88     X2CParser                   aParser(aDescr);
  89
  90     // Load file and create Function-file
  91     bool bLoadResult = aParser.LoadFile(i_rCommandLine.XmlSrcFile());
  92     if (! bLoadResult)
  93     {
  94         std::cerr << "Error: File %s could not be loaded." << i_rCommandLine.XmlSrcFile() << std::endl;
  95         return 1;
  96     }
  97
  98     if ( strlen(i_rCommandLine.FuncFile()) > 0 )
  99     {
 100         Create_AccessMethod( i_rCommandLine.FuncFile(),
 101                              aParser.PureText() );
 102
 103         std::cout << "File "
 104              << i_rCommandLine.FuncFile()
 105              << " with component_getDescriptionFunc() is created now."
 106              << std::endl;
 107     }
 108
 109     // Parse
 110     aParser.Parse();
 111
 112     // Produce output
 113     if ( strlen(i_rCommandLine.HtmlFile()) > 0 )
 114     {
 115         HtmlCreator aHtmlCreator( i_rCommandLine.HtmlFile(),
 116                                   aDescr,
 117                                   i_rCommandLine.IdlRootPath() );
 118         aHtmlCreator.Run();
 119     }
 120
 121     if (strlen(i_rCommandLine.TypeInfoFile()) > 0)
 122     {
 123         Create_TypeInfo( i_rCommandLine.TypeInfoFile(),
 124                          aDescr );
 125     }
 126
 127     return 0;
 128 };
 129
 130 int
 131 Do_IndexCommandLine(const CommandLine & i_rCommandLine)
 132 {
 133     // Parsen files:
 134     List<Simstr>        aFiles;
 135     Index               aIndex( i_rCommandLine.OutputDirectory(),
 136                             i_rCommandLine.IdlRootPath(),
 137                             i_rCommandLine.IndexedTags() );
 138
 139     std::cout << "Gather xml-files ..." << std::endl;
 140     GatherFileNames( aFiles, i_rCommandLine.XmlSrcDirectory() );
 141
 142     std::cout << "Create output ..." << std::endl;
 143     aIndex.GatherData(aFiles);
 144     aIndex.WriteOutput( i_rCommandLine.IndexOutputFile() );
 145
 146     std::cout << "... done." << std::endl;
 147
 148     return 0;
 149 };
 150
 151
 152
 153 //********************      Creating of typeinfo       ********************//
 154
 155
 156 void                                    Put2StdOut_TypeInfo(
 157                             ModuleDescription &     i_rData );
 158 void                                    Put2File_TypeInfo(
 159                             const char *            i_sOutputFile,
 160                             ModuleDescription &     i_rData );
 161 void                                    StreamOut_TypeInfo(
 162                             std::ostream &               o_rOut,
 163                             ModuleDescription &     i_rData,
 164                             const char *            i_sSeparator );
 165
 166
 167
 168
 169 void
 170 Create_TypeInfo( const char *                   o_sOutputFile,
 171                  ModuleDescription &    i_rData )
 172 {
 173     if ( strcmp(o_sOutputFile, "stdout") == 0 )
 174         Put2StdOut_TypeInfo(i_rData);
 175     else
 176         Put2File_TypeInfo(o_sOutputFile,i_rData);
 177
 178 #if 0
 179     std::ofstream aOut(o_sOutputFile, std::ios::out
 180 #if defined(WNT) || defined(OS2)
 181                                                | std::ios::binary
 182 #endif
 183     );
 184     if ( !aOut )
 185     {
 186         std::cerr << "Error: " << o_sOutputFile << " could not be created." << std::endl;
 187         return;
 188     }
 189
 190     Heap        aTypesHeap(12);
 191     Simstr      sLibPrefix = i_rData.ModuleName();
 192
 193     // Gather types:
 194     List< const MultipleTextElement * > aTypes;
 195     i_rData.Get_Types(aTypes);
 196
 197     for ( unsigned t = 0; t < aTypes.size(); ++t )
 198     {
 199         unsigned i_max = aTypes[t]->Size();
 200         for ( unsigned  i = 0; i < i_max; ++i )
 201         {
 202             aTypesHeap.InsertValue( aTypes[t]->Data(i), "" );
 203         }  // end for
 204     }
 205
 206     // Write types:
 207     WriteStr( aOut, sLibPrefix );
 208     WriteStr( aOut, "_XML2CMPTYPES= ");
 209
 210     HeapItem * pLastHeapTop = 0;
 211     for ( HeapItem * pHeapTop = aTypesHeap.ReleaseTop(); pHeapTop != 0; pHeapTop = aTypesHeap.ReleaseTop() )
 212     {
 213         if (pLastHeapTop != 0)
 214         {
 215             if ( 0 == strcmp(pHeapTop->Key(), pLastHeapTop->Key()) )
 216                 continue;
 217             delete pLastHeapTop;
 218             // pLastHeapTop = 0;
 219         }
 220         pLastHeapTop = pHeapTop;
 221
 222         WriteStr( aOut, "\t\\\n\t\t" );
 223
 224         const char * sEnd = strchr( pHeapTop->Key(), ' ' );
 225         if (sEnd != 0)
 226         {
 227             const char * sQuali = strrchr( pHeapTop->Key(), ' ' )+1;
 228             WriteStr( aOut, sQuali );
 229             WriteStr( aOut, "." );
 230             aOut.write( pHeapTop->Key(), sEnd - pHeapTop->Key() );
 231         }
 232         else
 233             WriteStr( aOut, pHeapTop->Key() );
 234     }   // end for
 235
 236     if (pLastHeapTop != 0)
 237     {
 238         delete pLastHeapTop;
 239         pLastHeapTop = 0;
 240     }
 241
 242     aOut.close();
 243 #endif // 0
 244 }
 245
 246 void
 247 Put2StdOut_TypeInfo( ModuleDescription &        i_rData )
 248 {
 249     StreamOut_TypeInfo(std::cout, i_rData, " ");
 250 }
 251
 252 void
 253 Put2File_TypeInfo( const char *            i_sOutputFile,
 254                    ModuleDescription &     i_rData )
 255 {
 256     std::ofstream aOut(i_sOutputFile, std::ios::out
 257 #if defined(WNT) || defined(OS2)
 258                                                | std::ios::binary
 259 #endif
 260     );
 261     if ( !aOut )
 262     {
 263         std::cerr << "Error: " << i_sOutputFile << " could not be created." << std::endl;
 264         return;
 265     }
 266
 267     Simstr      sLibPrefix = i_rData.ModuleName();
 268     WriteStr( aOut, sLibPrefix );
 269     WriteStr( aOut, "_XML2CMPTYPES= ");
 270
 271     StreamOut_TypeInfo(aOut, i_rData, "\t\\\n\t\t");
 272
 273     aOut.close();
 274 }
 275
 276 void
 277 StreamOut_TypeInfo( std::ostream &               o_rOut,
 278                     ModuleDescription &     i_rData,
 279                     const char *            i_sSeparator )
 280 {
 281     Heap        aTypesHeap(12);
 282
 283     // Gather types:
 284     List< const MultipleTextElement * > aTypes;
 285     i_rData.Get_Types(aTypes);
 286
 287     for ( unsigned t = 0; t < aTypes.size(); ++t )
 288     {
 289         unsigned i_max = aTypes[t]->Size();
 290         for ( unsigned  i = 0; i < i_max; ++i )
 291         {
 292             aTypesHeap.InsertValue( aTypes[t]->Data(i), "" );
 293         }  // end for
 294     }
 295
 296     // Write types:
 297     HeapItem * pLastHeapTop = 0;
 298     for ( HeapItem * pHeapTop = aTypesHeap.ReleaseTop(); pHeapTop != 0; pHeapTop = aTypesHeap.ReleaseTop() )
 299     {
 300         if (pLastHeapTop != 0)
 301         {
 302             if ( 0 == strcmp(pHeapTop->Key(), pLastHeapTop->Key()) )
 303                 continue;
 304             delete pLastHeapTop;
 305             // pLastHeapTop = 0;
 306         }
 307         pLastHeapTop = pHeapTop;
 308
 309         WriteStr( o_rOut, i_sSeparator );
 310
 311         const char * sEnd = strchr( pHeapTop->Key(), ' ' );
 312         if (sEnd != 0)
 313         {
 314             const char * sQuali = strrchr( pHeapTop->Key(), ' ' ) + 1;
 315             WriteStr( o_rOut, sQuali );
 316             WriteStr( o_rOut, "." );
 317             o_rOut.write( pHeapTop->Key(), sEnd - pHeapTop->Key() );
 318         }
 319         else
 320             WriteStr( o_rOut, pHeapTop->Key() );
 321     }   // end for
 322
 323     if (pLastHeapTop != 0)
 324     {
 325         delete pLastHeapTop;
 326         pLastHeapTop = 0;
 327     }
 328 }
 329