parser.h

Go to the documentation of this file.

/* Copyright (C) 2012 Oliver Lemke <olemke@core-dump.info>
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. */
 
#ifndef parser_h
#define parser_h
 
#include <map>
#include "agenda_class.h"
#include "methods.h"
#include "sourcetext.h"
 
class ArtsParser {
 public:
  ArtsParser(Agenda& tasklist, String controlfile, const Verbosity& verbosity);
 
  void parse_tasklist();
 
 private:
  typedef struct {
    String name;
    Index line;
    Index column;
  } NamedArgument;
 
  typedef vector<NamedArgument> NamedArguments;
 
  void find_named_arguments(vector<NamedArgument>& named_args);
 
  void skip_to_next_argument();
 
  void at_end_of_argument(const String& argname);
 
  void get_argument_index_by_name(Index& arg_index,
                                  NamedArguments& named_args,
                                  String name);
 
  void parse_main();
 
  void parse_agenda(Agenda& tasklist, const String& agenda_name);
 
  void parse_method(Index& id,
                    ArrayOfIndex& output,
                    ArrayOfIndex& input,
                    Agenda& tasks,
                    ArrayOfIndex& auto_vars,
                    Array<TokVal>& auto_vars_values,
                    String& include_file,
                    bool no_eot = false);
 
  void parse_generic_input(const MdRecord*& mdd,
                           Index& id,
                           String& methodname,
                           ArrayOfIndex& input,
                           ArrayOfIndex& auto_vars,
                           Array<TokVal>& auto_vars_values,
                           bool& first,
                           bool& still_supergeneric,
                           String& supergeneric_args,
                           Index& supergeneric_index,
                           NamedArguments& named_args,
                           bool call_by_name);
 
  void parse_generic_output(const MdRecord*& mdd,
                            Index& id,
                            String& methodname,
                            ArrayOfIndex& output,
                            bool& first,
                            bool& still_supergeneric,
                            String& supergeneric_args,
                            Index& supergeneric_index,
                            NamedArguments& named_args,
                            bool call_by_name);
 
  void parse_specific_input(const MdRecord* mdd,
                            ArrayOfIndex& input,
                            ArrayOfIndex& auto_vars,
                            Array<TokVal>& auto_vars_values,
                            bool& first,
                            NamedArguments& named_args,
                            bool call_by_name);
 
  void parse_specific_output(const MdRecord* mdd,
                             ArrayOfIndex& output,
                             bool& first,
                             NamedArguments& named_args,
                             bool call_by_name);
 
  void parse_method_args(const MdRecord*& mdd,
                         Index& id,
                         String& methodname,
                         ArrayOfIndex& output,
                         ArrayOfIndex& input,
                         ArrayOfIndex& auto_vars,
                         Array<TokVal>& auto_vars_values);
 
  String set_gin_to_default(const MdRecord* mdd,
                            ArrayOfIndex& auto_vars,
                            Array<TokVal>& auto_vars_values,
                            Index keyword_index);
 
  void tasklist_insert_set_delete(const ArrayOfIndex& auto_vars,
                                  const Array<TokVal>& auto_vars_values,
                                  const Index method_type,
                                  Agenda& tasklist);
 
  bool is_whitespace(const char c);
 
  void eat_whitespace();
 
  void eat_whitespace_from_string(String& str, size_t& pos);
 
  void read_name(String& name);
 
  Index read_name_or_value(String& name,
                           ArrayOfIndex& auto_vars,
                           Array<TokVal>& auto_vars_values,
                           const String& default_name,
                           const MdRecord* mdd,
                           const Index group);
 
  void assertain_character(char c);
 
  void parse_String(String& res);
 
  void read_integer(String& res);
 
  void read_numeric(String& res);
 
  void parse_integer(Index& n);
 
  void parse_numeric(Numeric& n);
 
  void parse_Stringvector(ArrayOfString& res);
 
  void parse_intvector(ArrayOfIndex& res);
 
  void parse_numvector(Vector& res);
 
  void parse_matrix(Matrix& res);
 
  bool parse_intvector_from_string(ArrayOfIndex& res, String& str);
 
  bool parse_numvector_from_string(Vector& res, String& str);
 
  bool parse_stringarray_from_string(ArrayOfString& res, String& str);
 
  Agenda& mtasklist;
 
  String mcfile;
 
  SourceText msource;
 
  Index mcfile_version;
 
  const Verbosity& verbosity;
};
 
#endif /* parser_h */