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 "sourcetext.h"
#include "methods.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);

    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_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 */