idlc/source/idlcmain.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <idlc.hxx>
  22 #include <sal/main.h>
  23
  24 #include <string.h>
  25
  26 SAL_IMPLEMENT_MAIN_WITH_ARGS(argc, argv)
  27 {
  28     std::vector< std::string > args;
  29     for (int i = 1; i < argc; i++)
  30     {
  31         if (!Options::checkArgument (args, argv[i], strlen(argv[i])))
  32             return 1;
  33     }
  34
  35     Options options(argv[0]);
  36     sal_Int32 nErrors = 0;
  37
  38     try
  39     {
  40         if (!options.initOptions(args))
  41            return 0;
  42
  43         setIdlc(&options);
  44
  45         if (options.readStdin()) {
  46             if ( !options.quiet() )
  47                 fprintf(
  48                     stdout, "%s: Compiling stdin\n",
  49                     options.getProgramName().getStr());
  50             nErrors = compileFile(nullptr);
  51             if ( ( idlc()->getWarningCount() > 0 ) && !options.quiet() ) {
  52                 fprintf(
  53                     stdout, "%s: detected %lu warnings compiling stdin\n",
  54                     options.getProgramName().getStr(),
  55                     sal::static_int_cast< unsigned long >(
  56                         idlc()->getWarningCount()));
  57             }
  58             OString outputUrl;
  59             if (options.isValid("-O")) {
  60                 outputUrl = convertToFileUrl(options.getOption("-O"));
  61                 if (!outputUrl.endsWith("/")) {
  62                     outputUrl += "/";
  63                 }
  64                 outputUrl += "stdin.urd";
  65             } else {
  66                 outputUrl = convertToFileUrl("stdin.urd");
  67             }
  68             if (nErrors > 0) {
  69                 removeIfExists(outputUrl);
  70             } else {
  71                 nErrors = produceFile(outputUrl, nullptr);
  72             }
  73             idlc()->reset();
  74         }
  75         std::vector< OString > const & files = options.getInputFiles();
  76         if ( options.verbose() )
  77         {
  78             fprintf( stdout, "%s: compiling %i source files ... \n",
  79                 options.getProgramName().getStr(), static_cast<int>(files.size()) );
  80             fflush( stdout );
  81         }
  82         for (auto const& elem : files)
  83         {
  84             if (nErrors)
  85                 break;
  86             OString sysFileName( convertToAbsoluteSystemPath(elem) );
  87
  88             if ( !options.quiet() )
  89                 fprintf(stdout, "Compiling: %s\n", elem.getStr());
  90             nErrors = compileFile(&sysFileName);
  91
  92             if ( idlc()->getWarningCount() && !options.quiet() )
  93                 fprintf(stdout, "%s: detected %lu warnings compiling file '%s'\n",
  94                         options.getProgramName().getStr(),
  95                         sal::static_int_cast< unsigned long >(
  96                             idlc()->getWarningCount()),
  97                         elem.getStr());
  98
  99             // prepare output file name
 100             OString const strippedFileName(
 101                     sysFileName.copy(sysFileName.lastIndexOf(SEPARATOR) + 1));
 102             OString outputFile;
 103             if ( options.isValid("-O") )
 104             {
 105                 outputFile = options.getOption("-O");
 106                 if (!outputFile.endsWith("/")) {
 107                     outputFile += OString('/');
 108                 }
 109                 outputFile += strippedFileName.replaceAt(
 110                         strippedFileName.getLength() -3 , 3, "urd");
 111             } else {
 112                 outputFile =
 113                     sysFileName.replaceAt(sysFileName.getLength() -3 , 3, "urd");
 114             }
 115             OString const outputFileUrl = convertToFileUrl(outputFile);
 116
 117             OString depFileUrl;
 118             if (options.isValid("-M")) {
 119                 depFileUrl = convertToFileUrl(options.getOption("-M"));
 120                 if (!depFileUrl.endsWith("/")) {
 121                     depFileUrl += "/";
 122                 }
 123                 depFileUrl += strippedFileName.replaceAt(
 124                         strippedFileName.getLength() -3 , 3, "d");
 125             }
 126
 127             if ( nErrors ) {
 128                 if (options.isValid("-M")) {
 129                     removeIfExists(depFileUrl);
 130                 }
 131                 removeIfExists(outputFileUrl);
 132             } else {
 133                 sPair_t const pair(depFileUrl, outputFile);
 134                 nErrors = produceFile(outputFileUrl,
 135                             (options.isValid("-M")) ? &pair : nullptr);
 136             }
 137
 138             idlc()->reset();
 139         }
 140
 141         if ( nErrors > 0 )
 142         {
 143             fprintf(stderr, "%s: detected %ld errors%s",
 144                 options.getProgramName().getStr(),
 145                 sal::static_int_cast< long >(nErrors),
 146                 options.prepareVersion().getStr());
 147         } else
 148         {
 149             if ( options.verbose() )
 150                 fprintf(stdout, "%s: returned successful%s",
 151                     options.getProgramName().getStr(),
 152                     options.prepareVersion().getStr());
 153         }
 154     } catch(const IllegalArgument& e)
 155     {
 156         fprintf(stderr, "Illegal argument: %s\n%s",
 157             e.m_message.getStr(),
 158             options.prepareVersion().getStr());
 159         return 99;
 160     }
 161
 162     return nErrors;
 163 }
 164
 165 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */