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 %" SAL_PRIdINT64 " warnings compiling file '%s'\n",
  94                         options.getProgramName().getStr(),
  95                         sal_Int64(idlc()->getWarningCount()),
  96                         elem.getStr());
  97
  98             // prepare output file name
  99             OString const strippedFileName(
 100                     sysFileName.copy(sysFileName.lastIndexOf(SEPARATOR) + 1));
 101             OString outputFile;
 102             if ( options.isValid("-O") )
 103             {
 104                 outputFile = options.getOption("-O");
 105                 if (!outputFile.endsWith("/")) {
 106                     outputFile += "/";
 107                 }
 108                 outputFile += strippedFileName.replaceAt(
 109                         strippedFileName.getLength() -3 , 3, "urd");
 110             } else {
 111                 outputFile =
 112                     sysFileName.replaceAt(sysFileName.getLength() -3 , 3, "urd");
 113             }
 114             OString const outputFileUrl = convertToFileUrl(outputFile);
 115
 116             OString depFileUrl;
 117             if (options.isValid("-M")) {
 118                 depFileUrl = convertToFileUrl(options.getOption("-M"));
 119                 if (!depFileUrl.endsWith("/")) {
 120                     depFileUrl += "/";
 121                 }
 122                 depFileUrl += strippedFileName.replaceAt(
 123                         strippedFileName.getLength() -3 , 3, "d");
 124             }
 125
 126             if ( nErrors ) {
 127                 if (options.isValid("-M")) {
 128                     removeIfExists(depFileUrl);
 129                 }
 130                 removeIfExists(outputFileUrl);
 131             } else {
 132                 sPair_t const pair(depFileUrl, outputFile);
 133                 nErrors = produceFile(outputFileUrl,
 134                             (options.isValid("-M")) ? &pair : nullptr);
 135             }
 136
 137             idlc()->reset();
 138         }
 139
 140         if ( nErrors > 0 )
 141         {
 142             fprintf(stderr, "%s: detected %" SAL_PRIdINT64 " errors%s",
 143                 options.getProgramName().getStr(),
 144                 sal_Int64(nErrors),
 145                 options.prepareVersion().getStr());
 146         } else
 147         {
 148             if ( options.verbose() )
 149                 fprintf(stdout, "%s: returned successful%s",
 150                     options.getProgramName().getStr(),
 151                     options.prepareVersion().getStr());
 152         }
 153     } catch(const IllegalArgument& e)
 154     {
 155         fprintf(stderr, "Illegal argument: %s\n%s",
 156             e.m_message.getStr(),
 157             options.prepareVersion().getStr());
 158         return 99;
 159     }
 160
 161     return nErrors;
 162 }
 163
 164 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */