codemaker/source/cppumaker/cppuoptions.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 #include <stdio.h>
  21 #include <string.h>
  22
  23 #include "cppuoptions.hxx"
  24
  25 #ifdef SAL_UNX
  26 #define SEPARATOR '/'
  27 #else
  28 #define SEPARATOR '\\'
  29 #endif
  30
  31 bool CppuOptions::initOptions(int ac, char* av[], bool bCmdFile)
  32 {
  33     bool    ret = true;
  34     int i=0;
  35
  36     if (!bCmdFile)
  37     {
  38         bCmdFile = true;
  39
  40         OString name(av[0]);
  41         sal_Int32 index = name.lastIndexOf(SEPARATOR);
  42         m_program = name.copy(index > 0 ? index+1 : 0);
  43
  44         if (ac < 2)
  45         {
  46             fprintf(stderr, "%s", prepareHelp().getStr());
  47             ret = false;
  48         }
  49
  50         i = 1;
  51     }
  52     else
  53     {
  54         i = 0;
  55     }
  56
  57     char    *s=nullptr;
  58     for( ; i < ac; i++)
  59     {
  60         if (av[i][0] == '-')
  61         {
  62             switch (av[i][1])
  63             {
  64                 case 'O':
  65                     if (av[i][2] == '\0')
  66                     {
  67                         if (i < ac - 1 && av[i+1][0] != '-')
  68                         {
  69                             i++;
  70                             s = av[i];
  71                         }
  72                         else
  73                         {
  74                             OString tmp("'-O', please check"_ostr);
  75                             if (i <= ac - 1)
  76                             {
  77                                 tmp += OString::Concat(" your input '") + av[i+1] + "'";
  78                             }
  79
  80                             throw IllegalArgument(tmp);
  81                         }
  82                     }
  83                     else
  84                     {
  85                         s = av[i] + 2;
  86                     }
  87
  88                     m_options["-O"_ostr] = OString(s);
  89                     break;
  90                 case 'n':
  91                     if (av[i][2] != 'D' || av[i][3] != '\0')
  92                     {
  93                         OString tmp = OString::Concat("'-nD', please check your input '") + av[i] + "'";
  94                         throw IllegalArgument(tmp);
  95                     }
  96
  97                     m_options["-nD"_ostr] = OString();
  98                     break;
  99                 case 'T':
 100                     if (av[i][2] == '\0')
 101                     {
 102                         if (i < ac - 1 && av[i+1][0] != '-')
 103                         {
 104                             i++;
 105                             s = av[i];
 106                         }
 107                         else
 108                         {
 109                             OString tmp("'-T', please check"_ostr);
 110                             if (i <= ac - 1)
 111                             {
 112                                 tmp += OString::Concat(" your input '") + av[i+1] + "'";
 113                             }
 114
 115                             throw IllegalArgument(tmp);
 116                         }
 117                     }
 118                     else
 119                     {
 120                         s = av[i] + 2;
 121                     }
 122
 123                     if (m_options.count("-T"_ostr) > 0)
 124                     {
 125                         OString tmp = m_options["-T"_ostr] + ";" + s;
 126                         m_options["-T"_ostr] = tmp;
 127                     }
 128                     else
 129                     {
 130                         m_options["-T"_ostr] = OString(s);
 131                     }
 132                     break;
 133                 case 'L':
 134                     if (av[i][2] != '\0')
 135                     {
 136                         OString tmp("'-L', please check"_ostr);
 137                         if (i <= ac - 1)
 138                         {
 139                             tmp += OString::Concat(" your input '") + av[i] + "'";
 140                         }
 141
 142                         throw IllegalArgument(tmp);
 143                     }
 144
 145                     if (isValid("-C"_ostr) || isValid("-CS"_ostr))
 146                     {
 147                         throw IllegalArgument("'-L' could not be combined with '-C' or '-CS' option"_ostr);
 148                     }
 149                     m_options["-L"_ostr] = OString();
 150                     break;
 151                 case 'C':
 152                     if (av[i][2] == 'S')
 153                     {
 154                         if (av[i][3] != '\0')
 155                         {
 156                             OString tmp("'-CS', please check"_ostr);
 157                             if (i <= ac - 1)
 158                             {
 159                                 tmp += OString::Concat(" your input '") + av[i] + "'";
 160                             }
 161
 162                             throw IllegalArgument(tmp);
 163                         }
 164
 165                         if (isValid("-L"_ostr) || isValid("-C"_ostr))
 166                         {
 167                             throw IllegalArgument("'-CS' could not be combined with '-L' or '-C' option"_ostr);
 168                         }
 169                         m_options["-CS"_ostr] = OString();
 170                         break;
 171                     }
 172                     else if (av[i][2] != '\0')
 173                     {
 174                         OString tmp("'-C', please check"_ostr);
 175                         if (i <= ac - 1)
 176                         {
 177                             tmp += OString::Concat(" your input '") + av[i] + "'";
 178                         }
 179
 180                         throw IllegalArgument(tmp);
 181                     }
 182
 183                     if (isValid("-L"_ostr) || isValid("-CS"_ostr))
 184                     {
 185                         throw IllegalArgument("'-C' could not be combined with '-L' or '-CS' option"_ostr);
 186                     }
 187                     m_options["-C"_ostr] = OString();
 188                     break;
 189                 case 'G':
 190                     if (av[i][2] == 'c')
 191                     {
 192                         if (av[i][3] != '\0')
 193                         {
 194                             OString tmp("'-Gc', please check"_ostr);
 195                             if (i <= ac - 1)
 196                             {
 197                                 tmp += OString::Concat(" your input '") + av[i] + "'";
 198                             }
 199
 200                             throw IllegalArgument(tmp);
 201                         }
 202
 203                         m_options["-Gc"_ostr] = OString();
 204                         break;
 205                     }
 206                     else if (av[i][2] != '\0')
 207                     {
 208                         OString tmp("'-G', please check"_ostr);
 209                         if (i <= ac - 1)
 210                         {
 211                             tmp += OString::Concat(" your input '") + av[i] + "'";
 212                         }
 213
 214                         throw IllegalArgument(tmp);
 215                     }
 216
 217                     m_options["-G"_ostr] = OString();
 218                     break;
 219                 case 'W': // generate embind javascript bindings for LOWA
 220                     if (av[i][2] != '\0')
 221                     {
 222                         OString tmp("'-W', please check"_ostr);
 223                         if (i <= ac - 1)
 224                         {
 225                             tmp += OString::Concat(" your input '") + av[i] + "'";
 226                         }
 227
 228                         throw IllegalArgument(tmp);
 229                     }
 230
 231                     if (!isValid("-C"_ostr) && !isValid("-CS"_ostr) && !isValid("-L"_ostr))
 232                     {
 233                         throw IllegalArgument("'-W' requires '-C' or '-CS' or '-L' option"_ostr);
 234                     }
 235                     m_options["-W"_ostr] = OString();
 236                     break;
 237                 case 'X': // support for eXtra type rdbs
 238                 {
 239                     if (av[i][2] == '\0')
 240                     {
 241                         if (i < ac - 1 && av[i+1][0] != '-')
 242                         {
 243                             i++;
 244                             s = av[i];
 245                         }
 246                         else
 247                         {
 248                             OString tmp("'-X', please check"_ostr);
 249                             if (i <= ac - 1)
 250                             {
 251                                 tmp += OString::Concat(" your input '") + av[i+1] + "'";
 252                             }
 253
 254                             throw IllegalArgument(tmp);
 255                         }
 256                     }
 257                     else
 258                     {
 259                         s = av[i] + 2;
 260                     }
 261
 262                     m_extra_input_files.emplace_back(s );
 263                     break;
 264                 }
 265
 266                 default:
 267                     throw IllegalArgument(OString::Concat("the option is unknown") + av[i]);
 268             }
 269         } else
 270         {
 271             if (av[i][0] == '@')
 272             {
 273                 FILE* cmdFile = fopen(av[i]+1, "r");
 274                 if( cmdFile == nullptr )
 275                 {
 276                     fprintf(stderr, "%s", prepareHelp().getStr());
 277                     ret = false;
 278                 }
 279                 else
 280                 {
 281                     int rargc=0;
 282                     char* rargv[512];
 283                     char  buffer[512];
 284
 285                     while (fscanf(cmdFile, "%511s", buffer) != EOF && rargc < 512)
 286                     {
 287                         rargv[rargc]= strdup(buffer);
 288                         rargc++;
 289                     }
 290                     fclose(cmdFile);
 291
 292                     ret = initOptions(rargc, rargv, bCmdFile);
 293
 294                     for (int j=0; j < rargc; j++)
 295                     {
 296                         free(rargv[j]);
 297                     }
 298                 }
 299             }
 300             else
 301             {
 302                 m_inputFiles.emplace_back(av[i]);
 303             }
 304         }
 305     }
 306
 307     return ret;
 308 }
 309
 310 OString CppuOptions::prepareHelp()
 311 {
 312     OString help = "\nusing: " +
 313         m_program + " [-options] file_1 ... file_n\nOptions:\n"
 314         "    -O<path>   = path describes the root directory for the generated output.\n"
 315         "                 The output directory tree is generated under this directory.\n"
 316         "    -T<name>   = name specifies a type or a list of types. The output for this\n"
 317         "      [t1;...]   type is generated. If no '-T' option is specified,\n"
 318         "                 then output for all types is generated.\n"
 319         "                 Example: 'com.sun.star.uno.XInterface' is a valid type.\n"
 320         "    -L         = UNO type functions are generated lightweight, that means only\n"
 321         "                 the name and typeclass are given and everything else is retrieved\n"
 322         "                 from the type library dynamically. The default is that UNO type\n"
 323         "                 functions provides enough type information for bootstrapping C++.\n"
 324         "                 '-L' should be the default for external components.\n"
 325         "    -C         = UNO type functions are generated comprehensive that means all\n"
 326         "                 necessary information is available for bridging the type in UNO.\n"
 327         "    -nD        = no dependent types are generated.\n"
 328         "    -G         = generate only target files which does not exists.\n"
 329         "    -Gc        = generate only target files which content will be changed.\n"
 330         "    -X<file>   = extra types which will not be taken into account for generation.\n\n" +
 331         prepareVersion();
 332
 333     return help;
 334 }
 335
 336 OString CppuOptions::prepareVersion() const
 337 {
 338     OString version = m_program + " Version 2.0\n\n";
 339     return version;
 340 }
 341
 342
 343 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */