C++博客-龙与地下城的世界-随笔分类-编译原理/脚本语言开发

第2个简单的语言

Reno — Thu, 24 Dec 2009 15:51:00 GMT

编写了路径控制脚本后，准备尝试编写一个比它稍微复杂一点的脚本，该脚本具有变量定义，流程控制语句，和比较完善的布尔逻辑和混合四则表达式运算的功能.

// Unnamed simple script language products define as the flowing:
program ::= declaration_list
declaration_list ::= var_declaration | fun_declaration
var_declaration ::= DECLARE type_specifier_list ID; END
type_specifier_list ::= type_specifier type_specifier_list | EMPTY
type_specifier ::= VAR
fun_declaration ::= BEGIN statement_list END
statement_list ::= statement statement_list | EMPTY
statement ::= expression_stmt | compund_list | selection_stmt | iteration_stmt
expression_stmt ::= expression; | ;
compund_list ::= { statement_list }
selection_stmt :: IF ( expression ) statement | IF ( expression ) statement ELSE statement
ireation_stmt ::= WHILE ( expression ) statement
expression ::= var = expression | simple_expression
var ::= ID
simple_expression ::= additive_expression relop additive_expression | additive_expression
relop ::= <= | < | > | >= | == | !=
additive_expression ::= additive_expression addop term | term
addop ::= + | -
term ::= term mulop factor | factor
mulop ::= * | /
factor ::= ( expression ) | var | NUM

Reno 2009-12-24 23:51 发表评论

PathInterpreter.h

Reno — Wed, 23 Dec 2009 14:03:00 GMT

  1 #ifndef PATH_INTERPRETER
  2 #define PATH_INTERPRETER
  3
  4 #define WIN32_LEAN_AND_MEAN
  5 #include <windows.h>
  6 #include <string.h>
  7 #include <stdlib.h>
  8 #include <ctype.h>
  9 #include <string>
10 #include <list>
11
12 using std::string;
13 using std::list;
14
15 #define MAX_WORD_LEN 8 // 8 Bytes
16
17 class ContexScan;
18
19 // CPathScriptLoader
20 class CPathScriptLoader
21 {
22 public:
23  string Context;
24
25  void LoadScript( const char *szFile );
26 };
27
28 //
29 // Contex Lex
30 //
31 //
32 // ContexScan
33 class ContexScan
34 {
35 public:
36  enum ScanState { WORD, NOPRINT, };
37
38 public:
39  ContexScan();
40  ~ContexScan();
41
42  void SetExpression( const char *szExpr );
43
44  bool SkipWord( const char *szWord );
45  char *  GetNextWord();
46  char *  CurrentWord() { return m_szCurrWord; }
47  bool NextWord();
48  void RebackWordByCount( int n ); // 退几个?
49  void RebackNearestWordByName( const char *szWord ); // 退到哪个?
50
51 private:
52  char * m_szExpr;
53  char * m_pLastChar;
54  char * m_pCurrChar;
55  char m_szCurrWord[MAX_WORD_LEN];
56  ScanState m_eState;
57 };
58
59 //
60 // Syntax Tree Nodes
61 //
62 // AbstractNode
63 class AbstractNode
64 {
65 public:
66    AbstractNode( ContexScan& contex );
67  virtual ~AbstractNode();
68
69  virtual void Parse() = 0;
70
71 protected:
72  ContexScan& m_RefContexScan;
73  list<AbstractNode *> m_Nodes;
74 };
75
76 // ProgramNode
77 class ProgramNode : public AbstractNode
78 {
79 public:
80    ProgramNode( ContexScan& contex );
81  virtual ~ProgramNode();
82
83  virtual void Parse();
84 };
85
86 // CommandListNode
87 class CommandListNode : public AbstractNode
88 {
89 public:
90    CommandListNode( ContexScan& contex );
91  virtual ~CommandListNode();
92
93  virtual void Parse();
94 };
95
96 // CommandNode
97 class CommandNode : public AbstractNode
98 {
99 public:
100    CommandNode( ContexScan& contex );
101  virtual ~CommandNode();
102
103  virtual void Parse();
104 };
105
106 // RepeatNode
107 class RepeatNode : public AbstractNode
108 {
109 public:
110    RepeatNode( ContexScan& contex );
111  virtual ~RepeatNode();
112
113  virtual void Parse();
114 };
115
116 // BlockNode
117 class BlockNode : public AbstractNode
118 {
119 public:
120    BlockNode( ContexScan& contex );
121  virtual ~BlockNode();
122
123  virtual void Parse();
124 };
125
126 // PrimitiveNode
127 class PrimitiveNode : public AbstractNode
128 {
129 public:
130    PrimitiveNode( ContexScan& contex );
131  virtual ~PrimitiveNode();
132
133  virtual void Parse();
134 };
135
136 // CPathInterpret
137 // The Interpreter Facade interface
138 class CPathInterpret
139 {
140 public:
141  enum InterpretMode { NDEBUG, DEBUG, };
142
143 public:
144  static InterpretMode m_Mode;
145
146 public:
147  void LoadScript( const char *szFile );
148  void Interpret( InterpretMode mode = NDEBUG );
149
150 private:
151  CPathScriptLoader m_ScriptLoader;
152  ContexScan   m_ContexScaner;
153
154 };
155
156 #endif // PATH_INTERPRETER
157

Reno 2009-12-23 22:03 发表评论

ConsoleMain.cpp

Reno — Wed, 23 Dec 2009 14:03:00 GMT

1 #include <stdio.h>
2 #include <string.h>
3 #include "PathInterpreter.h"
4
5 int main( int argc, char *argv[] )
6 {
7  if ( argc < 2 )
8  {
9   printf( "Usage: ExecuableFileName ScriptFileName [-DEBUG|-debug] \n" );
10   return 0;
11  }
12
13  if ( argc > 3 )
14  {
15   printf( "Warning: More parameters have expected, after the third has ignored!\n" );
16   return 0;
17  }
18
19  CPathInterpret Instance;
20  Instance.LoadScript( argv[1] );
21  if ( argc == 3 )
22  {
23   if ( strcmp( argv[2], "-DEBUG" ) == 0 || strcmp( argv[2], "-debug" ) == 0 )
24    Instance.Interpret( CPathInterpret::DEBUG );
25   else
26    printf( "Warning: Unknown about the third parameter!\n" );
27  }
28  else
29   Instance.Interpret();
30
31  return 0;
32 }
33
34

Reno 2009-12-23 22:03 发表评论

PathInterpreter.cpp

Reno — Wed, 23 Dec 2009 13:57:00 GMT

摘要: 1 #include "PathInterpreter.h" 2 3 // CPathScriptLoader 4 void CPathScriptLoader::LoadScript( const c... 阅读全文

Reno 2009-12-23 21:57 发表评论

运动路线控制脚本语言

Reno — Wed, 23 Dec 2009 08:58:00 GMT

最近在做仿雷电的游戏，其中敌人飞船的运动路线和特征需要能灵活的设置，并且尽量少动其他部分的代码，于是我的想法是把每种类型的飞船指定的运动路线存入脚本中，然后由引擎根据脚本执行.
因此可以把飞船的路线看成是由一系列的关键点组成，每个点有比如3个属性，X速度，Y速度和保持该速度的持续时间。而路线的运动轨迹可以由简单的脚本语言来定义，比如也许需要在某几个点之间重复移动一定的次数。

以下是一个Script Demo:

GO
    BEGIN
        1.0 0.0 500
    END
    BEGIN
        -1.0 0.0 500
    END
    REPEAT 4
        BEGIN
             0.0 1.0 500
        END
        BEGIN
             1.0 0.0 500
        END
        BEGIN
             0.0 -1.0 500
        END
        BEGIN
            -1.0 0.0 500
        END
    END
END

表示先左右移动一次，然后向下，向右，向上，向左呈矩形移动4次，通过设置速度分量可以实现任何路线的移动以及其他特征。
该脚本语言解释器采用了2个设计模式，Facade和Interpret模式，其中的解释器使用了几乎和任何设计模式书上介绍的一样的结构，很经典呐~

附上语言的文法定义:
program ::= GO command_list
command_list ::= command* END
command ::= begin_end_block | repeat
begin_end_block ::= BEGIN primitive END // Leaf Node on the Syntax tree
repeat ::= REPEAT INT command_list
primitive ::= SpeedX,SpeedY,Time // Recursive exit

// TestScript.txt
GO
  BEGIN
   1.0,0.0,500
  END
  BEGIN
   -1.0,0.0,500
  END
  REPEAT 4
   BEGIN
    0.0,1.0,500
   END
   BEGIN
    0.0,-1.0,500
   END
  END
END

// Execute result:

Reno 2009-12-23 16:58 发表评论