df/d27/a02921_source.html

//

// Class MacroCmd

//

//   This class parses the MACRO command.

//   Encapsulate the buffer for the ``archetypes'' of all macros.

//   The macro is stored as a MacroStream.  For execution, first the

//   parameters are replaced, then the resulting stream is sent to the parser.

//

// Copyright (c) 2008 - 2020, Paul Scherrer Institut, Villigen PSI, Switzerland

//

// All rights reserved

//

// This file is part of OPAL.

//

// OPAL 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 3 of the License, or

// (at your option) any later version.

//

// You should have received a copy of the GNU General Public License

// along with OPAL. If not, see <https://www.gnu.org/licenses/>.

//


#include "OpalParser/MacroCmd.h"


#include "Utility/PAssert.h"


#include "AbstractObjects/OpalData.h"

#include "OpalParser/OpalParser.h"

#include "Parser/Statement.h"

#include "Utilities/ParseError.h"

#include <vector>


MacroCmd::MacroCmd():

    Macro(0u, "MACRO",

          "A \"MACRO\" command defines a subroutine:\n"

          "\t<name>(<arguments>):MACRO{<body>}"),

    body(0)

{}


MacroCmd::MacroCmd(const std::string &name, MacroCmd *parent):

    Macro(name, parent), body() {

    body = new MacroStream(name);

}


MacroCmd::~MacroCmd()

{}


void MacroCmd::execute() {

    body->start();

    itsParser->run(&*body);

}


Object *MacroCmd::makeInstance

(const std::string &name, Statement &statement, const Parser *parser) {

    parseActuals(statement);


    // Check for consistency in argument number.

    if(formals.size() != actuals.size()) {

        throw ParseError("MacroCmd::makeInstance()",

                         "Inconsistent number of macro arguments.");

    }


    // Substitute the actual arguments.

    MacroCmd *macro = new MacroCmd(name, this);

    macro->itsParser = parser;

    body->start();

    Token token = body->readToken();


    while(! token.isEOF()) {

        bool found = false;


        if(token.isWord()) {

            std::string word = token.getWord();


            for(std::vector<std::string>::size_type i = 0;

                i < formals.size(); i++) {

                if(word == formals[i]) {

                    std::vector<Token> act = actuals[i];

                    for(Token t : act) {

                        macro->body->append(t);

                    }

                    found = true;

                    break;

                }

            }

        }


        if(! found) macro->body->append(token);

        token = body->readToken();

    }


    return macro;

}


Object *MacroCmd::makeTemplate

(const std::string &name, TokenStream &, Statement &statement) {

    MacroCmd *macro = new MacroCmd(name, this);

    macro->parseFormals(statement);


    // Parse macro body->

    bool isMacro = statement.keyword("MACRO");

    PAssert(isMacro);

    Token token;


    if(statement.delimiter('{')) {

        int level = 1;

        while(true) {

            if(statement.atEnd()) {

                throw ParseError("MacroCmd::makeTemplate()",

                                 "MACRO body is not closed.");

            } else {

                token = statement.getCurrent();


                if(token.isDel('{')) {

                    ++level;

                } else if(token.isDel('}')) {

                    if(--level == 0) break;

                }


                macro->body->append(token);

            }

        }

    } else {

        throw ParseError("MacroCmd::makeTemplate()",

                         "Missing MACRO body, should be \"{...}\".");

    }


    return macro;

}

Statement.h

ParseError.h

OpalParser.h

MacroCmd.h

OpalData.h

PAssert.h

PAssert
#define PAssert(c)
Definition: PAssert.h:102

name
const std::string name
Definition: MaxNormRadialPeak.cpp:32

Object
The base class for all OPAL objects.
Definition: Object.h:48

Parser
Interface for abstract language parser.
Definition: Parser.h:31

Parser::run
virtual void run(TokenStream *ts) const =0
Read statements and parse.

Statement
Interface for statements.
Definition: Statement.h:38

Statement::getCurrent
Token & getCurrent()
Return current token and skip it.
Definition: Statement.cpp:74

Statement::keyword
bool keyword(const char *s)
Test for keyword.
Definition: Statement.cpp:121

Statement::atEnd
bool atEnd() const
Test for end of command.
Definition: Statement.cpp:50

Statement::delimiter
bool delimiter(char c)
Test for delimiter.
Definition: Statement.cpp:101

Token
Representation of a single input token.
Definition: Token.h:33

Token::isDel
bool isDel(char del) const
Test for delimiter.
Definition: Token.cpp:92

Token::isWord
bool isWord() const
Test for word.
Definition: Token.cpp:127

Token::isEOF
bool isEOF() const
Test for end of file.
Definition: Token.cpp:107

Token::getWord
std::string getWord() const
Return word value.
Definition: Token.cpp:190

TokenStream
Abstract interface for a stream of input tokens.
Definition: TokenStream.h:33

ParseError
Parse exception.
Definition: ParseError.h:32

Macro
Abstract base class for macros.
Definition: Macro.h:34

Macro::parseFormals
virtual void parseFormals(Statement &)
Parse formal arguments.
Definition: Macro.cpp:100

Macro::formals
std::vector< std::string > formals
The formal argument list.
Definition: Macro.h:78

Macro::actuals
std::vector< std::vector< Token > > actuals
The actual argument list.
Definition: Macro.h:82

Macro::parseActuals
virtual void parseActuals(Statement &)
Parse actual arguments.
Definition: Macro.cpp:64

MacroCmd
Definition: MacroCmd.h:35

MacroCmd::makeInstance
virtual Object * makeInstance(const std::string &name, Statement &, const Parser *)
Make a macro instance.
Definition: MacroCmd.cpp:59

MacroCmd::makeTemplate
virtual Object * makeTemplate(const std::string &, TokenStream &, Statement &)
Make a macro template.
Definition: MacroCmd.cpp:102

MacroCmd::body
Pointer< MacroStream > body
Definition: MacroCmd.h:64

MacroCmd::itsParser
const Parser * itsParser
Definition: MacroCmd.h:67

MacroCmd::~MacroCmd
virtual ~MacroCmd()
Definition: MacroCmd.cpp:48

MacroCmd::execute
virtual void execute()
Execute the macro command.
Definition: MacroCmd.cpp:52

MacroCmd::MacroCmd
MacroCmd()
Definition: MacroCmd.cpp:34

MacroStream
An input buffer for macro commands.
Definition: MacroStream.h:31

MacroStream::append
void append(Token &)
Append a token to the stream.
Definition: MacroStream.cpp:36

MacroStream::start
void start()
Reset stream to start.
Definition: MacroStream.cpp:53

MacroStream::readToken
virtual Token readToken()
Read a token from the stream.
Definition: MacroStream.cpp:41