xref: /trunk/main/codemaker/source/bonobowrappermaker/corbaoptions.cxx (revision af7f2cbf3d6a5481a2f45e7fae5e85a32449c47d)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 // MARKER(update_precomp.py): autogen include statement, do not remove
23 #include "precompiled_codemaker.hxx"
24 #include    <stdio.h>
25 
26 #include    "corbaoptions.hxx"
27 
28 using namespace rtl;
29 
30 sal_Bool CorbaOptions::initOptions(int ac, char* av[], sal_Bool bCmdFile)
31     throw( IllegalArgument )
32 {
33     sal_Bool    ret = sal_True;
34     sal_uInt16  i=0;
35 
36     if (!bCmdFile)
37     {
38         bCmdFile = sal_True;
39 
40         m_program = av[0];
41 
42         if (ac < 2)
43         {
44             fprintf(stderr, "%s", prepareHelp().getStr());
45             ret = sal_False;
46         }
47 
48         i = 1;
49     } else
50     {
51         i = 0;
52     }
53 
54     char    *s=NULL;
55     for (i; i < ac; i++)
56     {
57         if (av[i][0] == '-')
58         {
59             switch (av[i][1])
60             {
61                 case 'O':
62                     if (av[i][2] == '\0')
63                     {
64                         if (i < ac - 1 && av[i+1][0] != '-')
65                         {
66                             i++;
67                             s = av[i];
68                         } else
69                         {
70                             OString tmp("'-O', please check");
71                             if (i <= ac - 1)
72                             {
73                                 tmp += " your input '" + OString(av[i+1]) + "'";
74                             }
75 
76                             throw IllegalArgument(tmp);
77                         }
78                     } else
79                     {
80                         s = av[i] + 2;
81                     }
82 
83                     m_options["-O"] = OString(s);
84                     break;
85                 case 'H':
86                     if (av[i][2] == '\0')
87                     {
88                         if (i < ac - 1 && av[i+1][0] != '-')
89                         {
90                             i++;
91                             s = av[i];
92                         } else
93                         {
94                             OString tmp("'-H', please check");
95                             if (i <= ac - 1)
96                             {
97                                 tmp += " your input '" + OString(av[i+1]) + "'";
98                             }
99 
100                             throw IllegalArgument(tmp);
101                         }
102                     } else
103                     {
104                         s = av[i] + 2;
105                     }
106 
107                     m_options["-H"] = OString(s);
108                     break;
109                 case 'B':
110                     if (av[i][2] == '\0')
111                     {
112                         if (i < ac - 1 && av[i+1][0] != '-')
113                         {
114                             i++;
115                             s = av[i];
116                         } else
117                         {
118                             OString tmp("'-B', please check");
119                             if (i <= ac - 1)
120                             {
121                                 tmp += " your input '" + OString(av[i+1]) + "'";
122                             }
123 
124                             throw IllegalArgument(tmp);
125                         }
126                     } else
127                     {
128                         s = av[i] + 2;
129                     }
130 
131                     m_options["-B"] = OString(s);
132                     break;
133                 case 'T':
134                     if (av[i][2] == '\0')
135                     {
136                         if (i < ac - 1 && av[i+1][0] != '-')
137                         {
138                             i++;
139                             s = av[i];
140                         } else
141                         {
142                             OString tmp("'-T', please check");
143                             if (i <= ac - 1)
144                             {
145                                 tmp += " your input '" + OString(av[i+1]) + "'";
146                             }
147 
148                             throw IllegalArgument(tmp);
149                         }
150                     } else
151                     {
152                         s = av[i] + 2;
153                     }
154 
155                     if (m_options.count("-T") > 0)
156                     {
157                         OString tmp(m_options["-T"]);
158                         tmp = tmp + ";" + s;
159                         m_options["-T"] = tmp;
160                     } else
161                     {
162                         m_options["-T"] = OString(s);
163                     }
164                     break;
165                 case 'G':
166                     if (av[i][2] != '\0')
167                     {
168                         OString tmp("'-G', please check");
169                         if (i <= ac - 1)
170                         {
171                             tmp += " your input '" + OString(av[i]) + "'";
172                         }
173 
174                         throw IllegalArgument(tmp);
175                     }
176 
177                     m_options["-G"] = OString("");
178                     break;
179                 default:
180                     throw IllegalArgument("the option is unknown" + OString(av[i]));
181                     break;
182             }
183         } else
184         {
185             if (av[i][0] == '@')
186             {
187                 FILE* cmdFile = fopen(av[i]+1, "r");
188                 if( cmdFile == NULL )
189                 {
190                     fprintf(stderr, "%s", prepareHelp().getStr());
191                     ret = sal_False;
192                 } else
193                 {
194                     int rargc=0;
195                     char* rargv[512];
196                     char  buffer[512];
197 
198                     while ( fscanf(cmdFile, "%s", buffer) != EOF )
199                     {
200                         rargv[rargc]= strdup(buffer);
201                         rargc++;
202                     }
203                     fclose(cmdFile);
204 
205                     ret = initOptions(rargc, rargv, bCmdFile);
206 
207                     for (long i=0; i < rargc; i++)
208                     {
209                         free(rargv[i]);
210                     }
211                 }
212             } else
213             {
214                 m_inputFiles.push_back(av[i]);
215             }
216         }
217     }
218     printf("-T: %s\n",                      m_options["-T"].getStr());
219 
220     return ret;
221 }
222 
223 OString CorbaOptions::prepareHelp()
224 {
225     OString help("\nusing: ");
226     help += m_program + " [-options] file_1 ... file_n\nOptions:\n";
227     help += "    -O<file>   = file name for the generated output.\n";
228     help += "                 The output directory tree is generated under this directory.\n";
229     help += "    -T<name>   = name specifies a type or a list of types. The output for this\n";
230     help += "      [t1;...]   type is generated. If no '-T' option is specified,\n";
231     help += "                 then output for all types is generated.\n";
232     help += "                 Example: 'com.sun.star.uno.XInterface' is a valid type.\n";
233     help += "    -B<name>   = name specifies the base node. All types are searched under this\n";
234     help += "                 node. Default is the root '/' of the registry files.\n";
235     help += "    -G         = generate only target files which does not exists.\n";
236     help += "    -H<header> = include CORBA generated <header>.\n";
237     help += prepareVersion();
238 
239     return help;
240 }
241 
242 OString CorbaOptions::prepareVersion()
243 {
244     OString version(m_program);
245     version += m_program + " Version 2.0\n\n";
246     return version;
247 }
248 
249 /* vim: set noet sw=4 ts=4: */
250