RP

RP

关注
发信
关注(28)粉丝(399)

c++ - 嵌套循环，用于简单的逻辑解析器

我正在为一种简单的编程语言编写一个解析器，该解析器可能包含一个轴号，一个两个字母的命令以及一个输入值。所有命令都用逗号分隔。我有一个解析器，它通过分界符分割输入，并一次运行一个有效命令。我在编程循环功能RP时遇到问题。

我可以有这样的命令

MD1,TP,RP5,TT,RP10

我希望它在其中运行

for (int i = 0; i < 10; i++) {
    TT();
    for (int j = 0; j < 5; j++) {
        TP();
    }
}


到目前为止，我拥有的主解析器将看到第一个RP命令并运行它，然后看到第二个RP命令并运行它。 RP命令设置为从最后一个RP命令的末尾开始循环，给出更多类似信息。

for (int j = 0; j < 5; j++) {
    TP();
}
for (int i = 0; i < 10; i++) {
    TT();
}


我尝试了几种不同的方法，但到目前为止还没有运气。任何和所有帮助表示赞赏。

最佳答案

实际上，我认为这个问题有点太广泛了。另一方面，我忍不住要“尝试”。

前言

首先，我想批评一下问题标题。对我来说，简单的逻辑解析器听起来像boolean expressions的解释器。但是，我记得我的工程同事经常谈论“程序逻辑”（并且我还没有实现他们摆脱这一点的想法）。因此，我的建议是：如果您（提问者）正在与计算机科学家交谈，请使用术语“逻辑”明智的（否则有时他们可能会感到困惑...）

示例代码MD1,TP,RP5,TT,RP10在我看来有点熟悉。简短的google / wikipedia研究使我头脑清醒：Wikipedia文章Numerical control与CNC机床有关。在本文结尾处，提到了编程。 （德语的“同级”文章提供了更多内容。）恕我直言，代码看起来确实有点相似，但是看起来更简单。 （没有冒犯–我认为使事情尽可能简单是最好的。）

似乎打算使用的程序表示法类似于Reverse Polish notation。我想至少提及该词，因为对“ rpn解释器”进行谷歌搜索会抛出很多足够的命中，包括github站点。实际上，目标语言的描述太短了，无法确定哪个现有的S / W项目可能是合适的。

话虽如此，我想展示我得到的...

解析器

我首先从解析器开始（因为发问者不敢公开他的信息）。这是mci1.cc的代码：

#include <iostream>
#include <sstream>

using namespace std;

typedef unsigned char uchar;

enum Token {
  TkMD = 'M' | 'D' << 8,
  TkRP = 'R' | 'P' << 8,
  TkTP = 'T' | 'P' << 8,
  TkTT = 'T' | 'T' << 8
};

inline Token tokenize(uchar c0, uchar c1) { return (Token)(c0 | c1 << 8); }

bool parse(istream &in)
{
  for (;;) {
    // read command (2 chars)
    char cmd[2];
    if (in >> cmd[0] >> cmd[1]) {
      //cout << "DEBUG: token: " << hex << tokenize(cmd[0], cmd[1]) << endl;
      switch (tokenize(cmd[0], cmd[1])) {
        case TkMD: { // MD<num>
          int num;
          if (in >> num) {
            cout << "Received 'MD" << dec << num << "'." << endl;
          } else {
            cerr << "ERROR: Number expected after 'MD'!" << endl;
            return false;
          }
        } break;
        case TkRP:  { // RP<num>
          int num;
          if (in >> num) {
            cout << "Received 'RP" << dec << num << "'." << endl;
          } else {
            cerr << "ERROR: Number expected after 'RP'!" << endl;
            return false;
          }
        } break;
        case TkTP: // TP
          cout << "Received 'TP'." << endl;
          break;
        case TkTT: // TT
          cout << "Received 'TT'." << endl;
          break;
        default:
          cerr << "ERROR: Wrong command '" << cmd[0] << cmd[1] << "'!" << endl;
          return false;
      }
    } else {
      cerr << "ERROR: Command expected!" << endl;
      return false;
    }
    // try to read separator
    char sep;
    if (!(in >> sep)) break; // probably EOF (further checks possible)
    if (sep != ',') {
      cerr << "ERROR: ',' expected!" << endl;
      return false;
    }
  }
  return true;
}

int main()
{
  // test string
  string sample("MD1,TP,RP5,TT,RP10");
  // read test string
  istringstream in(sample);
  if (parse(in)) cout << "Done." << endl;
  else cerr << "Interpreting aborted!" << endl;
  // done
  return 0;
}


我在Windows 10的Cygwin中使用g++和bash进行了编译和测试：



$ g++ --version
g++ (GCC) 6.4.0

$ g++ -std=c++11 -o mci mci1.cc

$ ./mci
Received 'MD1'.
Received 'TP'.
Received 'RP5'.
Received 'TT'.
Received 'RP10'.
Done.

$


在ideone上上传了终生演示。

我在更新中引入了功能tokenize()。 （当我刷牙和研究时，我想到了如何摆脱以前版本的丑陋嵌套switch es的想法。）Tokenizing是解析中的一种常见技术–但是，实现通常略有不同。

因此，解析器似乎可以正常工作。还不是下一件大事，但足以进行下一步...

口译员

为了解释解析的命令，我开始做一个回应。后端–一组可以存储和执行所需操作的类。

第一步的parse()函数变为compile()函数，其中简单的标准输出被代码构建和嵌套操作所代替。 mci2.cc：

#include <cassert>
#include <iostream>
#include <stack>
#include <sstream>
#include <string>
#include <vector>

using namespace std;

// super class of all operations
class Op {
  protected:
    Op() = default;
  public:
    virtual ~Op() = default;
    virtual void exec() const = 0;
  // disabled: (to prevent accidental usage)
    Op(const Op&) = delete;
    Op& operator=(const Op&) = delete;
};

// super class of grouping operations
class Grp: public Op {
  protected:
    vector<Op*> _pOps; // nested operations

  protected:
    Grp() = default;
    virtual ~Grp()
    {
      for (Op *pOp : _pOps) delete pOp;
    }
  public:
    void add(Op *pOp) { _pOps.push_back(pOp); }
  // disabled: (to prevent accidental usage)
    Grp(const Grp&) = delete;
    Grp& operator=(const Grp&) = delete;
};

// class for repeat op.
class RP: public Grp {
  private:
    unsigned _n; // repeat count
  public:
    RP(unsigned n): Grp(), _n(n) { }
    virtual ~RP() = default;
    virtual void exec() const
    {
      cout << "Exec. RP" << _n << endl;
      for (unsigned i = 0; i < _n; ++i) {
        for (const Op *pOp : _pOps) pOp->exec();
      }
    }
  // disabled: (to prevent accidental usage)
    RP(const RP&) = delete;
    RP& operator=(const RP&) = delete;
};

// class for TP op.
class TP: public Op {
  public:
    TP() = default;
    virtual ~TP() = default;
    virtual void exec() const
    {
      cout << "Exec. TP" << endl;
    }
};

// class for TT op.
class TT: public Op {
  public:
    TT() = default;
    virtual ~TT() = default;
    virtual void exec() const
    {
      cout << "Exec. TT" << endl;
    }
};

// class for MD sequence
class MD: public Grp {
  private:
    unsigned _axis;
  public:
    MD(unsigned axis): Grp(), _axis(axis) { }
    virtual ~MD() = default;
    virtual void exec() const
    {
      cout << "Exec. MD" << _axis << endl;
      for (const Op *pOp : _pOps) pOp->exec();
    }
};

typedef unsigned char uchar;

enum Token {
  TkMD = 'M' | 'D' << 8,
  TkRP = 'R' | 'P' << 8,
  TkTP = 'T' | 'P' << 8,
  TkTT = 'T' | 'T' << 8
};

inline Token tokenize(uchar c0, uchar c1) { return (Token)(c0 | c1 << 8); }

MD* compile(istream &in)
{
  MD *pMD = nullptr;
  stack<Op*> pOpsNested;
#define ERROR \
  delete pMD; \
  while (pOpsNested.size()) { delete pOpsNested.top(); pOpsNested.pop(); } \
  return nullptr
  for (;;) {
    // read command (2 chars)
    char cmd[2];
    if (in >> cmd[0] >> cmd[1]) {
      //cout << "DEBUG: token: " << hex << tokenize(cmd[0], cmd[1]) << dec << endl;
      switch (tokenize(cmd[0], cmd[1])) {
        case TkMD: { // MD<num>
          int num;
          if (in >> num) {
            if (pMD) {
              cerr << "ERROR: Unexpected command 'MD" << num << "'!" << endl;
              ERROR;
            }
            pMD = new MD(num);
          } else {
            cerr << "ERROR: Number expected after 'MD'!" << endl;
            ERROR;
          }
        } break;
        case TkRP:  { // RP<num>
          int num;
          if (in >> num) {
            if (!pMD) {
              cerr << "ERROR: Unexpected command 'RP" << num << "'!" << endl;
              ERROR;
            }
            RP *pRP = new RP(num);
            while (pOpsNested.size()) {
              pRP->add(pOpsNested.top());
              pOpsNested.pop();
            }
            pOpsNested.push(pRP);
          } else {
            cerr << "ERROR: Number expected after 'RP'!" << endl;
            ERROR;
          }
        } break;
        case TkTP: { // TP
          if (!pMD) {
            cerr << "ERROR: Unexpected command 'TP'!" << endl;
            ERROR;
          }
          pOpsNested.push(new TP());
        } break;
        case TkTT: { // TT
          if (pOpsNested.empty()) {
            cerr << "ERROR: Unexpected command 'TT'!" << endl;
            ERROR;
          }
          pOpsNested.push(new TT());
        } break;
        default:
          cerr << "ERROR: Wrong command '" << cmd[0] << cmd[1] << "'!" << endl;
          ERROR;
      }
    } else {
      cerr << "ERROR: Command expected!" << endl;
      ERROR;
    }
    // try to read separator
    char sep;
    if (!(in >> sep)) break; // probably EOF (further checks possible)
    if (sep != ',') {
      cerr << "ERROR: ',' expected!" << endl;
      ERROR;
    }
  }
#undef ERROR
  assert(pMD != nullptr);
  while (pOpsNested.size()) {
    pMD->add(pOpsNested.top());
    pOpsNested.pop();
  }
  return pMD;
}

int main()
{
  // test string
  string sample("MD1,TP,RP3,TT,RP2");
  // read test string
  istringstream in(sample);
  MD *pMD = compile(in);
  if (!pMD) {
    cerr << "Interpreting aborted!" << endl;
    return 1;
  }
  // execute sequence
  pMD->exec();
  delete pMD;
  // done
  return 0;
}


同样，我在Windows 10的Cygwin中使用g++和bash进行了编译和测试：



$ g++ -std=c++11 -o mci mci2.cc

$ ./mci
Exec. MD1
Exec. RP2
Exec. TT
Exec. RP3
Exec. TP
Exec. TP
Exec. TP
Exec. TT
Exec. RP3
Exec. TP
Exec. TP
Exec. TP

$


在ideone上上传了终生演示。

在compile()函数中完成嵌套的技巧很简单：


命令TP和TT被添加到临时堆栈pOpsNested
对于命令RP，所有收集的操作都会添加到RP实例中，并弹出pOpsNested堆栈（从而颠倒其顺序），
之后，将RP实例本身推入pOpsNested堆栈
最后，将缓冲区pOpsNested的内容添加到序列MD中（因为这些是顶级操作）。

关于c++ - 嵌套循环，用于简单的逻辑解析器，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/47716719/

10-13 01:29
Powered by LMLPHP ©2024 RP 0.028303