ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/applications/atom2md/atom2md.cpp
(Generate patch)

Comparing trunk/src/applications/atom2md/atom2md.cpp (file contents):
Revision 1020 by gezelter, Wed Aug 2 18:06:18 2006 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

# Line 1 | Line 1
1   /**********************************************************************
2 < main.cpp - Main conversion program, command-line handling.
2 > atom2md.cpp - OpenBabel-based conversion program to OpenMD file,
3 >              command-line handling.
4  
5   Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
6 < Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
7 < Some portions Copyright (C) 2004-2005 by Chris Morley
6 > Some portions Copyright (C) 2001-2006 by Geoffrey R. Hutchison
7 > Some portions Copyright (C) 2004-2006 by Chris Morley
8 > Some portions Copyright (C) 2008-2009 by J. Daniel Gezelter
9  
10 < This file is part of the Open Babel project.
11 < For more information, see <http://openbabel.sourceforge.net/>
10 > This file is part of both the OpenMD and Open Babel projects.
11 > For more information, see <http://openmd.net> and <http://openbabel.sourceforge.net/>
12  
13   This program is free software; you can redistribute it and/or modify
14   it under the terms of the GNU General Public License as published by
# Line 19 | Line 21 | GNU General Public License for more details.
21   ***********************************************************************/
22  
23   #include "config.h"
24 < #if HAVE_IOSTREAM
25 <        #include <iostream>
26 < #elif HAVE_IOSTREAM_H
27 <        #include <iostream.h>
24 >
25 > // used to set import/export for Cygwin DLLs
26 > #ifdef WIN32
27 > #define USING_OBDLL
28   #endif
27 #if HAVE_FSTREAM
28        #include <fstream>
29 #elif HAVE_FSTREAM_H
30        #include <fstream.h>
31 #endif
32 #if HAVE_SSTREAM
33        #include <sstream>
34 #elif
35        #include <sstream.h>
36 #endif
29  
30 + #include <openbabel/babelconfig.h>
31 +
32 + #include <iostream>
33 + #include <fstream>
34 + #include <sstream>
35 +
36   #include <string>
37   #include <map>
38   #if HAVE_CONIO_H
# Line 45 | Line 43 | extern "C" int strncasecmp(const char *s1, const char
43   extern "C" int strncasecmp(const char *s1, const char *s2, size_t n);
44   #endif
45  
46 < #include "openbabel/obconversion.hpp"
47 < #include "brains/Register.hpp"
46 > #include <openbabel/obconversion.h>
47 > #include <openbabel/plugin.h>
48 > #include <cstdlib>
49 > #include <cstring>
50  
51   using namespace std;
52   using namespace OpenBabel;
53 < using namespace oopse;
54 < void DoOption(const char* p, OBConversion& Conv, OBConversion::Option_type typ,
55 <                                                        int& arg, int argc, char *argv[]);
53 >
54 > void DoOption(const char* p, OBConversion& Conv, OBConversion::Option_type typ,
55 >              int& arg, int argc, char *argv[]);
56   void usage();
57   void help();
58  
# Line 61 | Line 61 | int main(int argc,char *argv[])
61  
62   int main(int argc,char *argv[])
63   {
64  registerOBFormats();  
64    OBConversion Conv(&cin, &cout); //default input and output are console
65  
67 //  string GenOptions;
66    OBFormat* pInFormat = NULL;
67    OBFormat* pOutFormat = NULL;
68    vector<string> FileList, OutputFileList;
69    string OutputFileName;
72 //  obMessageLevel filterLevel = obWarning; // 2 out of 5
70  
71    // Parse commandline
72    bool gotInType = false, gotOutType = false;
73 <  bool UseSavedOptions = false;
73 >  bool SplitOrBatch=false;
74  
75 <  char *oext;
76 <  char *iext;
75 >  char *oext = NULL;
76 >  char *iext = NULL;
77 >
78 >  // for use with command name to type conversion
79    string inputExt;
80    string outputExt;
81  
82    //Save name of program without its path (and .exe)
83    string pn(argv[0]);
84 <  unsigned int pos;
84 >  string::size_type pos;
85   #ifdef _WIN32
86    pos = pn.find(".exe");
87    if(pos!=string::npos)
# Line 94 | Line 93 | int main(int argc,char *argv[])
93    else
94      program_name=argv[0]+pos+1;
95  
96 <        const char* p;
97 <        int arg;
98 <        for (arg = 1; arg < argc; arg++)
99 <        {
100 <                if (argv[arg])
101 <                {
102 <                        if (argv[arg][0] == '-')
103 <                        {
104 <                                switch (argv[arg][1])
105 <                                {
96 >  const char* p;
97 >  int arg;
98 >  for (arg = 1; arg < argc; ++arg)
99 >    {
100 >      if (argv[arg])
101 >        {
102 >          if (argv[arg][0] == '-')
103 >            {
104 >              switch (argv[arg][1])
105 >                {
106  
107 <                                case 'V':
108 <                                {
109 <                                        cout << "Open Babel " << BABEL_VERSION << " -- "
110 <                                       << __DATE__ << " -- " << __TIME__ << endl;
111 <                                        exit(0);
112 <                                }
107 >                case 'V':
108 >                  {
109 >                    cout << program_name << ": part of OpenMD " <<
110 >                      OPENMD_VERSION_MAJOR << "." << OPENMD_VERSION_MINOR <<
111 >                      "." << OPENMD_VERSION_TINY <<
112 >                      " and Open Babel " << BABEL_VERSION << " -- "
113 >                         << __DATE__ << " -- " << __TIME__ << endl;
114 >                    exit(0);
115 >                  }
116  
117 <                                case 'i':
118 <                                        gotInType = true;
119 <                                        iext = argv[arg] + 2;
120 <                                        if(!*iext)
121 <                                                iext = argv[++arg]; //space left after -i: use next argument
117 >                case 'i':
118 >                  gotInType = true;
119 >                  iext = argv[arg] + 2;
120 >                  if(!*iext)
121 >                    iext = argv[++arg]; //space left after -i: use next argument
122  
123 <                                        if (strncasecmp(iext, "MIME", 4) == 0)
124 <                                        {
125 <                                                // get the MIME type from the next argument
126 <                                                iext = argv[++arg];
127 <                                                pInFormat = Conv.FormatFromMIME(iext);
128 <                                        }
129 <                                        else
130 <                                        {
131 <                                                //The ID provided by the OBFormat class is used as the identifying file extension
132 <                                                pInFormat = Conv.FindFormat(iext);
133 <                                        }
134 <                                        if(pInFormat==NULL)
135 <                                        {
136 <                                                cerr << program_name << ": cannot read input format!" << endl;
137 <                                                usage();
138 <                                        }
139 <                                inputExt = iext;
140 <                                        break;
123 >                  if (strncasecmp(iext, "MIME", 4) == 0)
124 >                    {
125 >                      // get the MIME type from the next argument
126 >                      iext = argv[++arg];
127 >                      pInFormat = Conv.FormatFromMIME(iext);
128 >                    }
129 >                  else
130 >                    {
131 >                      //The ID provided by the OBFormat class is used as the identifying file extension
132 >                      pInFormat = Conv.FindFormat(iext);
133 >                    }
134 >                  if(pInFormat==NULL)
135 >                    {
136 >                      cerr << program_name << ": cannot read input format!" << endl;
137 >                      usage();
138 >                    }
139 >                  break;
140 >                  
141 >                case 'o':
142 >                  gotOutType = true;
143 >                  oext = argv[arg] + 2;
144 >                  if(!*oext)
145 >                    oext = argv[++arg]; //space left after -i: use next argument
146                                          
147 <                                case 'o':
148 <                                        gotOutType = true;
149 <                                        oext = argv[arg] + 2;
150 <                                        if(!*oext)
151 <                                                oext = argv[++arg]; //space left after -i: use next argument
152 <                                        
153 <                                        if (strncasecmp(oext, "MIME", 4) == 0)
154 <                                        {
148 <                                                // get the MIME type from the next argument
149 <                                                oext = argv[++arg];
150 <                                                pOutFormat = Conv.FormatFromMIME(oext);
151 <                                        }
152 <                                        else
153 <                                                pOutFormat = Conv.FindFormat(oext);
147 >                  if (strncasecmp(oext, "MIME", 4) == 0)
148 >                    {
149 >                      // get the MIME type from the next argument
150 >                      oext = argv[++arg];
151 >                      pOutFormat = Conv.FormatFromMIME(oext);
152 >                    }
153 >                  else
154 >                    pOutFormat = Conv.FindFormat(oext);
155  
156 <                                        if(pOutFormat==NULL)
157 <                                        {
158 <                                                cerr << program_name << ": cannot write output format!" << endl;
159 <                                                usage();
160 <                                        }
161 <                                outputExt = oext;
162 <                                        break;                          
163 <                                
164 <                                case '?':
165 <                                case 'H':
166 <                                        if(isalnum(argv[arg][2]))
167 <                                        {
168 <                                                if(strncasecmp(argv[arg]+2,"all",3))
169 <                                                {
170 <                                                        OBFormat* pFormat = Conv.FindFormat(argv[arg]+2);
171 <                                                        if(pFormat)
172 <                                                                {
173 <                                                                        cout << argv[arg]+2 << "  " << pFormat->Description() << endl;
174 <                                                                        if(strlen(pFormat->SpecificationURL()))
175 <                                                        cout << "Specification at: " << pFormat->SpecificationURL() << endl;
176 <                                                                }
177 <                                                        else
178 <                                                                cout << "Format type: " << argv[arg]+2 << " was not recognized" <<endl;
179 <                                                }
180 <                                                else
181 <                                                {
182 <                                                        Formatpos pos;
183 <                                                        OBFormat* pFormat;
184 <                                                        const char* str=NULL;
185 <                                                        while(OBConversion::GetNextFormat(pos,str,pFormat))
186 <                                                                {
187 <                                                                        if((pFormat->Flags() & NOTWRITABLE) && (pFormat->Flags() & NOTREADABLE))
188 <                                                                                continue;
189 <                                                                        cout << str << endl;
190 <                                                                        const char* p = strchr(pFormat->Description(),'\n');
191 <                                                                        cout << p+1; //second line of description
192 <                                                                        if(strlen(pFormat->SpecificationURL()))
193 <                                                        cout << "Specification at: " << pFormat->SpecificationURL();
194 <                                                                        cout << endl << endl;
195 <                                                                }
196 <                                                }
197 <                                        }
198 <                                        else
199 <                                                help();
200 <                                                exit(0);                                        
156 >                  if(pOutFormat==NULL)
157 >                    {
158 >                      cerr << program_name << ": cannot write output format!" << endl;
159 >                      usage();
160 >                    }
161 >                  break;
162 >
163 >                /*case 'F':
164 >                  if(!Conv.SetOutFormat("fpt"))
165 >                    cout << "FingerprintFormat needs to be loaded" << endl;
166 >                  else
167 >                    {
168 >                      Conv.AddOption("F",OBConversion::OUTOPTIONS);
169 >                      Conv.Write(NULL);
170 >                    }
171 >                  return 0;
172 >                  */
173 >                case 'L': //display a list of plugin type or classes
174 >                  {
175 >                    const char* param=NULL;
176 >                    if(argc>arg+1)
177 >                      param = argv[arg+2];
178 >                    OBPlugin::List(argv[arg+1], param);
179 >                    return 0;
180 >                  }
181 >                case '?':
182 >                case 'H':
183 >                  if(isalnum(argv[arg][2]) || arg==argc-2)
184 >                    {
185 >                      if(strncasecmp(argv[arg]+2,"all",3))
186 >                        {
187 >                          const char* pID= (arg==argc-2) ? argv[arg+1] : argv[arg]+2;
188 >                          OBFormat* pFormat = Conv.FindFormat(pID);
189 >                          if(pFormat)
190 >                            {
191 >                              cout << pID << "  " << pFormat->Description() << endl;
192 >                              if(pFormat->Flags() & NOTWRITABLE)
193 >                                cout << " This format is Read-only" << endl;
194 >                              if(pFormat->Flags() & NOTREADABLE)
195 >                                cout << " This format is Write-only" << endl;
196 >
197 >                              if(strlen(pFormat->SpecificationURL()))
198 >                                cout << "Specification at: " << pFormat->SpecificationURL() << endl;
199 >                            }
200 >                          else
201 >                            cout << "Format type: " << pID << " was not recognized" <<endl;
202 >                        }
203 >                      else
204 >                        {
205 >                          OBPlugin::List("formats","verbose");
206 >                        }
207 >                    }
208 >                  else
209 >                    help();
210 >                  return 0;
211                                          
212 +                case '-': //long option --name text
213 +                  {
214 +                    //Do nothing if name is empty
215 +                    //Option's text is the next arg provided it doesn't start with -
216 +                    char* nam = argv[arg]+2;
217 +                    if(*nam != '\0')
218 +                      {
219 +                        string txt;
220 +                        int i;
221 +                        for(i=0; i<Conv.GetOptionParams(nam, OBConversion::GENOPTIONS)
222 +                              && arg<argc-1 && argv[arg+1];++i) //removed  && *argv[arg+1]!='-'
223 +                          {
224 +                            if(!txt.empty()) txt+=' ';
225 +                            txt += argv[++arg];
226 +                          }
227 +                        if(*nam=='-')
228 +                          {
229 +                            // Is a API directive, e.g.---errorlevel
230 +                            //Send to the pseudoformat "obapi" (without any leading -)
231 +                            OBConversion apiConv;
232 +                            OBFormat* pAPI= OBConversion::FindFormat("obapi");
233 +                            if(pAPI)
234 +                              {
235 +                                apiConv.SetOutFormat(pAPI);
236 +                                apiConv.AddOption(nam+1, OBConversion::GENOPTIONS, txt.c_str());
237 +                                apiConv.Write(NULL, &std::cout);
238 +                              }
239 +                          }
240 +                        else
241 +                          // Is a long option name, e.g --addtotitle
242 +                          Conv.AddOption(nam,OBConversion::GENOPTIONS,txt.c_str());
243 +                      }
244 +                  }
245 +                  break;
246                                          
247 <                                default: //single character general option
248 <                                        p = argv[arg]+1;
249 <                                        DoOption(p,Conv,OBConversion::GENOPTIONS,arg,argc,argv);
250 <                                        break;
251 <                                }
252 <                        }
253 <                        else
254 <                        {
255 <                                //filenames
256 <                                if(!gotOutType)
257 <                                        FileList.push_back(argv[arg]);
258 <                                else
259 <                                        OutputFileName = argv[arg];
260 <                        }
261 <                }
262 <        }
263 <    
264 <  //user didn't specify input and output format in commandline option
265 <  //try to parse it from program name (pdb2mdin means input format is pdb, output format is mdin)
247 >                case 'm': //multiple output files
248 >                  SplitOrBatch=true;
249 >                  break;
250 >                                        
251 >                case 'a': //single character input option
252 >                  p = argv[arg]+2;
253 >                  DoOption(p,Conv,OBConversion::INOPTIONS,arg,argc,argv);
254 >                  break;
255 >
256 >                case 'x': //single character output option
257 >                  p = argv[arg]+2;
258 >                  DoOption(p,Conv,OBConversion::OUTOPTIONS,arg,argc,argv);
259 >                  break;
260 >                                        
261 >                default: //single character general option
262 >                  p = argv[arg]+1;
263 >                  DoOption(p,Conv,OBConversion::GENOPTIONS,arg,argc,argv);
264 >                  break;
265 >                }
266 >            }
267 >          else
268 >            {
269 >              //filenames
270 >              if(!gotOutType)
271 >                FileList.push_back(argv[arg]);
272 >              else
273 >                OutputFileName = argv[arg];
274 >            }
275 >        }
276 >    }
277 >  
278 >  // user didn't specify input and output format in commandline option
279 >  // try to parse it from program name (pdb2md means input format is pdb,
280 >  // output format is md)
281 >
282    string formatName(program_name);
283    pos = formatName.find_first_of("2");
284    if(pos!=string::npos) {
285      if (!gotInType)
286 <    {
286 >      {
287          string tmpExt = formatName.substr(0, pos);
288          pInFormat = Conv.FindFormat(tmpExt.c_str());
289 <         if(pInFormat==NULL)
290 <         {
291 <                cerr << program_name << ": cannot read input format!" << endl;
292 <                usage();
293 <         } else
294 <        {
289 >        if(pInFormat==NULL)
290 >          {
291 >            cerr << program_name << ": cannot read input format!" << endl;
292 >            usage();
293 >          } else
294 >          {
295              gotInType = true;
296              inputExt = tmpExt;
297 <         }
298 <    }
297 >          }
298 >      }
299  
300      if (!gotOutType)
301 <    {
301 >      {
302          string tmpExt = formatName.substr(pos+1, string::npos);
303          pOutFormat = Conv.FindFormat(tmpExt.c_str());
304 <         if(pOutFormat==NULL)
305 <         {
306 <                cerr << program_name << ": cannot write output format!" << endl;
307 <                usage();
308 <         }else {
309 <            gotOutType = true;
310 <            outputExt = tmpExt;
311 <         }
304 >        if(pOutFormat==NULL)
305 >          {
306 >            cerr << program_name << ": cannot write output format!" << endl;
307 >            usage();
308 >          }else {
309 >          gotOutType = true;
310 >          outputExt = tmpExt;
311 >        }
312 >      }
313 >  }
314 >
315 >  if(!gotOutType) //the last file is the output
316 >    {
317 >      if(FileList.empty())
318 >        {
319 >          cerr << "No output file or format spec!" << endl;
320 >          usage();
321 >        }
322 >      OutputFileName = FileList.back();
323 >      FileList.pop_back();
324      }
252  }
325  
326 <    if(FileList.empty())
326 > #ifdef _WIN32
327 >  //Expand wildcards in input filenames and add to FileList
328 >  vector<string> tempFileList(FileList);
329 >  FileList.clear();
330 >  vector<string>::iterator itr;
331 >  for(itr=tempFileList.begin();itr!=tempFileList.end();++itr)
332 >    DLHandler::findFiles (FileList, *itr);
333 > #endif
334 >  
335 >  if (!gotInType)
336      {
337 <        cerr << "No input file or format spec!" <<endl;
338 <        usage();
337 >      if(FileList.empty())
338 >        {
339 >          cerr << "No input file or format spec!" <<endl;
340 >          usage();
341 >        }
342      }
343  
344 <   if (OutputFileName.empty())
345 <   {
346 <        pos = FileList.front().rfind(".");
347 <        if(pos==string::npos)
348 <            OutputFileName = FileList.front()+ "." + outputExt;
349 <        else
350 <            OutputFileName = FileList.front().substr(0, pos) + "." + outputExt;            
344 >  if (!gotOutType)
345 >    {
346 >      pOutFormat = Conv.FormatFromExt(OutputFileName.c_str());
347 >      if(pOutFormat==NULL)
348 >        {
349 >          cerr << program_name << ": cannot write output format!" << endl;
350 >          usage();
351 >        }
352      }
353    
354 <  Conv.SetInAndOutFormats(pInFormat,pOutFormat);
354 >    if(!Conv.SetInFormat(pInFormat))
355 >    {
356 >      cerr << "Invalid input format" << endl;
357 >      usage();
358 >    }
359 >    if(!Conv.SetOutFormat(pOutFormat))
360 >    {
361 >      cerr << "Invalid output format" << endl;
362 >      usage();
363 >    }
364  
365 +  if(SplitOrBatch)
366 +    {
367 +      //Put * into output file name before extension (or ext.gz)
368 +      if(OutputFileName.empty())
369 +        {
370 +          OutputFileName = "*.";
371 +          if (oext != NULL)
372 +            OutputFileName += oext;
373 +        }
374 +      else
375 +        {
376 +          string::size_type pos = OutputFileName.rfind(".gz");
377 +          if(pos==string::npos)
378 +            pos = OutputFileName.rfind('.');
379 +          else
380 +            pos = OutputFileName.rfind('.',pos-1);
381 +          if(pos==string::npos)
382 +            OutputFileName += '*';
383 +          else
384 +            OutputFileName.insert(pos,"*");
385 +        }
386 +    }
387  
272  // send info message to clog -- don't mess up cerr or cout for user programs
388    int count = Conv.FullConvert(FileList, OutputFileName, OutputFileList);
389 <  if ( count == 1 )
390 <    clog << count << " molecule converted" << endl;
391 <  else
277 <    clog << count << " molecules converted" << endl;
278 <  
389 >
390 >  Conv.ReportNumberConverted(count);
391 >
392    if(OutputFileList.size()>1)
393 <  {
394 <    clog << OutputFileList.size() << " files output. The first is " << OutputFileList[0] <<endl;
395 <  }
393 >    {
394 >      clog << OutputFileList.size() << " files output. The first is " << OutputFileList[0] <<endl;
395 >    }
396  
397 +  std::string messageSummary = obErrorLog.GetMessageSummary();
398 +  if (messageSummary.size())
399 +    {
400 +      clog << messageSummary << endl;
401 +    }
402 +
403   #ifdef _DEBUG
404    //CM keep window open
405    cout << "Press any key to finish" <<endl;
# Line 290 | Line 409 | int main(int argc,char *argv[])
409    return 0;
410   }
411  
412 < void DoOption(const char* p, OBConversion& Conv, OBConversion::Option_type typ, int& arg, int argc, char *argv[])
412 > void DoOption(const char* p, OBConversion& Conv,
413 >              OBConversion::Option_type typ, int& arg, int argc, char *argv[])
414   {
415 <        while(p && *p) //can have multiple single char options
416 <        {
417 <                char ch[2]="?";
418 <                *ch = *p++;
419 <                const char* txt=NULL;                          
420 <                //Get the option text if needed
421 <                int nParams = Conv.GetOptionParams(ch, typ);
422 <                if(nParams)
423 <                {
424 <                        if(*p)
425 <                        {
426 <                                txt = p; //use text immediately following the option letter
427 <                                p=NULL; //no more single char options
428 <                        }
429 <                        else if(arg<argc-1)
430 <                        {
431 <                                txt = argv[++arg]; //use text from next arg
432 <                                if(*txt=='-')
433 <                                {
434 <                                        //...unless it is another option
435 <                                        cerr << "Option -" << ch << " takes a parameter" << endl;
436 <                                        exit(0);
437 <                                }
438 <                        }
439 <                }
440 <                Conv.AddOption(ch, typ, txt);
441 <        }
415 >  while(p && *p) //can have multiple single char options
416 >  {
417 >    char ch[2]="?";
418 >    *ch = *p++;
419 >    const char* txt=NULL;                              
420 >    //Get the option text if needed
421 >    int nParams = Conv.GetOptionParams(ch, typ);
422 >    if(nParams)
423 >    {
424 >      if(*p)
425 >      {
426 >        txt = p; //use text immediately following the option letter
427 >        p=NULL; //no more single char options
428 >      }
429 >      else if(arg<argc-1)
430 >      {
431 >        txt = argv[++arg]; //use text from next arg
432 >        if(*txt=='-')
433 >        {
434 >          //...unless it is another option
435 >          cerr << "Option -" << ch << " takes a parameter" << endl;
436 >          exit(0);
437 >        }
438 >      }
439 >    }
440 >    Conv.AddOption(ch, typ, txt);
441 >  }
442   }
443  
444   void usage()
445   {
446 <  cout << "Open Babel " << BABEL_VERSION << " -- " << __DATE__ << " -- "
447 <       << __TIME__ << endl;
446 >  cout << program_name << ": part of OpenMD " <<
447 >    OPENMD_VERSION_MAJOR << "." << OPENMD_VERSION_MINOR << "." <<
448 >    OPENMD_VERSION_TINY << " and OpenBabel " << BABEL_VERSION << " -- "
449 >       << __DATE__ << " -- " << __TIME__ << endl;
450    cout << "Usage: " << program_name
451         << " [-i<input-type>] <name> [-o<output-type>] <name>" << endl;
452    cout << "Try  -H option for more information." << endl;
453 < /*  
453 >
454   #ifdef _DEBUG
455    //CM keep window open
456    cout << "Press any key to finish" <<endl;
457    getch();
458   #endif
337 */  
459    exit (0);
460   }
461  
462   void help()
463   {
464 <  cout << "Open Babel converts chemical structures from one file format to another"<< endl << endl;
464 >  cout << program_name << " converts chemical structures from one file format to another"<< endl << endl;
465    cout << "Usage: " << program_name << " <input spec> <output spec> [Options]" << endl << endl;
466    cout << "Each spec can be a file whose extension decides the format." << endl;
467    cout << "Optionally the format can be specified by preceding the file by" << endl;
# Line 358 | Line 479 | void help()
479  
480    
481    OBFormat* pDefault = OBConversion::GetDefaultFormat();
482 <        if(pDefault)
483 <                cout << pDefault->TargetClassDescription();// some more options probably for OBMol
482 >  if(pDefault)
483 >    cout << pDefault->TargetClassDescription();// some more options probably for OBMol
484    
485 <        OBFormat* pAPI= OBConversion::FindFormat("obapi");
486 <        if(pAPI)
487 <                cout << pAPI->Description();
488 <
489 <        cout << "The following file formats are recognized:" << endl;
485 >  OBFormat* pAPI= OBConversion::FindFormat("obapi");
486 >  if(pAPI)
487 >    cout << pAPI->Description();
488 >  
489 >  cout << "The following file formats are recognized:" << endl;
490    Formatpos pos;
491    OBFormat* pFormat;
492    const char* str=NULL;
493    while(OBConversion::GetNextFormat(pos,str,pFormat))
494 <  {
495 <                if((pFormat->Flags() & NOTWRITABLE) && (pFormat->Flags() & NOTREADABLE))
496 <                        continue;
497 <                cout << "  " << str << endl;
498 <        }
494 >    {
495 >      if((pFormat->Flags() & NOTWRITABLE) && (pFormat->Flags() & NOTREADABLE))
496 >        continue;
497 >      cout << "  " << str << endl;
498 >    }
499    cout << "\nSee further specific info and options using -H<format-type>, e.g. -Hpdb" << endl;
500   }
501  

Comparing trunk/src/applications/atom2md/atom2md.cpp (property svn:keywords):
Revision 1020 by gezelter, Wed Aug 2 18:06:18 2006 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

# Line 0 | Line 1
1 + Author Id Revision Date

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines