155 lines
4.9 KiB
C++
155 lines
4.9 KiB
C++
/*
|
|
* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License, version 2.0,
|
|
* as published by the Free Software Foundation.
|
|
*
|
|
* This program is also distributed with certain software (including
|
|
* but not limited to OpenSSL) that is licensed under separate terms,
|
|
* as designated in a particular file or component or in included license
|
|
* documentation. The authors of MySQL hereby grant you an additional
|
|
* permission to link the program and your derivative works with the
|
|
* separately licensed software that they have included with MySQL.
|
|
*
|
|
* 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, version 2.0, 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "macro.h"
|
|
|
|
#include <algorithm>
|
|
#include <list>
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "../../common/utils_string_parsing.h"
|
|
#include "../execution_context.h"
|
|
#include "../stream_processor.h"
|
|
|
|
std::string Macro::get_expanded_macro_body(const Strings &args,
|
|
const Script_stack *stack,
|
|
const Console &console) const {
|
|
if (!m_accepts_variadic_arguments) {
|
|
if (args.size() != m_accepts_args.size()) {
|
|
if (m_accepts_args.empty() && 1 == args.size() && args.front().empty())
|
|
return get_expanded_macro_body({}, stack, console);
|
|
|
|
console.print_error(*stack, "Invalid number of arguments for macro ",
|
|
m_name, ", expected:", m_accepts_args.size(),
|
|
" actual:", args.size(), '\n');
|
|
|
|
for (const auto &v : args) {
|
|
console.print_error(" argument: \"", v, "\"\n");
|
|
}
|
|
|
|
return "";
|
|
}
|
|
} else {
|
|
if (args.size() < m_accepts_args.size()) {
|
|
console.print_error(*stack, "Invalid number of arguments for macro ",
|
|
m_name, ", expected at last:", m_accepts_args.size(),
|
|
" actual:", args.size(), '\n');
|
|
|
|
for (const auto &v : args) {
|
|
console.print_error(" argument: \"", v, "\"\n");
|
|
}
|
|
|
|
return "";
|
|
}
|
|
}
|
|
|
|
std::string text = m_body;
|
|
auto n = m_accepts_args.begin();
|
|
auto v = args.begin();
|
|
size_t index_of_argument = 0;
|
|
|
|
for (; index_of_argument < m_accepts_args.size(); index_of_argument++) {
|
|
aux::replace_all(text, *(n++), *(v++));
|
|
}
|
|
|
|
if (m_accepts_variadic_arguments) {
|
|
std::string variadic_arguments;
|
|
|
|
for (; index_of_argument < args.size() - 1; index_of_argument++) {
|
|
variadic_arguments += *(v++) + '\t';
|
|
}
|
|
|
|
if (index_of_argument < args.size()) variadic_arguments += *(v++);
|
|
|
|
aux::replace_all(text, "%VAR_ARGS%", variadic_arguments);
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
void Macro_container::add_macro(std::shared_ptr<Macro> macro) {
|
|
m_macros.push_back(macro);
|
|
}
|
|
|
|
void Macro_container::set_compress_option(const bool compress) {
|
|
m_compress = compress;
|
|
}
|
|
|
|
std::string Macro_container::get_expanded_macro(Execution_context *context,
|
|
const std::string &cmd,
|
|
std::string *r_name,
|
|
const Script_stack *stack,
|
|
const Console &console) {
|
|
Strings args;
|
|
std::string::size_type p = std::min(cmd.find(' '), cmd.find('\t'));
|
|
|
|
if (p == std::string::npos) {
|
|
*r_name = cmd;
|
|
} else {
|
|
*r_name = cmd.substr(0, p);
|
|
std::string rest = cmd.substr(p + 1);
|
|
aux::split(args, rest, "\t", m_compress);
|
|
}
|
|
|
|
if (r_name->empty()) {
|
|
console.print_error(*stack, "Missing macro name for macro call\n");
|
|
return "";
|
|
}
|
|
|
|
context->m_variables->replace(r_name);
|
|
|
|
for (auto iter = m_macros.begin(); iter != m_macros.end(); ++iter) {
|
|
if ((*iter)->name() == *r_name) {
|
|
return (*iter)->get_expanded_macro_body(args, stack, console);
|
|
}
|
|
}
|
|
|
|
console.print_error(*stack, "Undefined macro ", *r_name, '\n');
|
|
|
|
return "";
|
|
}
|
|
|
|
bool Macro_container::call(Execution_context *context, const std::string &cmd) {
|
|
std::string name;
|
|
std::string macro = get_expanded_macro(
|
|
context, cmd, &name, &context->m_script_stack, context->m_console);
|
|
|
|
context->m_script_stack.push({0, "macro " + name});
|
|
|
|
std::stringstream stream(macro);
|
|
std::vector<Block_processor_ptr> processors{
|
|
create_macro_block_processors(context)};
|
|
|
|
const bool r =
|
|
0 == process_client_input(stream, &processors, &context->m_script_stack,
|
|
context->m_console);
|
|
|
|
context->m_script_stack.pop();
|
|
|
|
return r;
|
|
}
|