├── .gitignore
├── Api.cpp
├── Dnlang
    ├── DnLexer.cpp
    ├── DnParser.cpp
    ├── Dnlang.bnf
    ├── IR
    │   ├── 3_addr.syntax
    │   ├── AST.cpp
    │   ├── AST.syntax
    │   └── ASTVisitor.cpp
    ├── Lexer.cpp
    ├── Parser.cpp
    ├── Scope.cpp
    ├── Symbol.cpp
    ├── Symbols.cpp
    ├── Token.cpp
    ├── runtime
    │   ├── DnInLexer.cpp
    │   ├── DnInParser.cpp
    │   └── Interprter.cpp
    └── sample
    │   ├── enemy.dn
    │   └── test01.dn
├── Dnscript.cpp
├── Dntest
├── Event.cpp
├── Frame.cpp
├── Game.cpp
├── Game
    ├── Bullet.cpp
    ├── Clear.cpp
    ├── Enemy.cpp
    ├── Load.cpp
    ├── Menu.cpp
    ├── Play.cpp
    └── Player.cpp
├── Keyboard.cpp
├── LICENSE
├── Main.cpp
├── Makefile
├── Object.cpp
├── README.md
├── Select.cpp
├── Title.cpp
├── doc
    └── api_list.md
├── img
    ├── CutinReimu.png
    ├── Enemy.png
    ├── ExRumia.png
    ├── Reimu.png
    ├── Rumia.png
    ├── bullet.png
    ├── bullets.png
    ├── circle.png
    ├── demo.png
    ├── load.png
    ├── play.jpg
    ├── select.png
    └── title.png
├── include
    ├── AST.hpp
    ├── ASTVisitor.hpp
    ├── Action.hpp
    ├── Api.hpp
    ├── Bullet.hpp
    ├── Clear.hpp
    ├── DnInLexer.hpp
    ├── DnInParser.hpp
    ├── DnLexer.hpp
    ├── DnParser.hpp
    ├── Dnscript.hpp
    ├── Enemy.hpp
    ├── Event.hpp
    ├── Frame.hpp
    ├── Game.hpp
    ├── Interprter.hpp
    ├── Keyboard.hpp
    ├── Lexer.hpp
    ├── Load.hpp
    ├── Menu.hpp
    ├── Object.hpp
    ├── Parser.hpp
    ├── Play.hpp
    ├── Player.hpp
    ├── Register.hpp
    ├── Scope.hpp
    ├── Select.hpp
    ├── Symbol.hpp
    ├── Symbols.hpp
    ├── Title.hpp
    ├── Token.hpp
    ├── Utility.hpp
    ├── Window.hpp
    └── test
    │   ├── enemy_test.hpp
    │   └── player_test.hpp
└── test
    ├── dnlang_test01.cpp
    ├── enemy_test.cpp
    └── player_test.cpp


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | *.obj
 6 | 
 7 | # Precompiled Headers
 8 | *.gch
 9 | *.pch
10 | 
11 | # Compiled Dynamic libraries
12 | *.so
13 | *.dylib
14 | *.dll
15 | 
16 | # Fortran module files
17 | *.mod
18 | 
19 | # Compiled Static libraries
20 | *.lai
21 | *.la
22 | *.a
23 | *.lib
24 | 
25 | # Executables
26 | *.exe
27 | *.out
28 | *.app
29 | 
30 | # Backup file
31 | *~


--------------------------------------------------------------------------------
/Api.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <string>
  3 | #include <cstdio>
  4 | #include <unistd.h>
  5 | #include <fstream>
  6 | #include <map>
  7 | #include <vector>
  8 | #include <list>
  9 | #include <SDL2_rotozoom.h>
 10 | #include "Object.hpp"
 11 | #include "Api.hpp"
 12 | #include "Dnscript.hpp"
 13 | #include "Window.hpp"
 14 | #include "Interprter.hpp"
 15 | #include "Play.hpp"
 16 | 
 17 | 
 18 | Api* Api::mInstance = 0;
 19 | 
 20 | Api* Api::instance(){
 21 |     return mInstance;
 22 | }
 23 | 
 24 | void Api::create(){
 25 |   try{
 26 |     if(mInstance) throw "[*ERROR*] Api::create() cannnot create instance twice";
 27 |     mInstance = new Api();
 28 |   }catch(const char *error){
 29 |     fprintf(stderr,"%s\n",error);
 30 |     abort();
 31 |   }
 32 | }
 33 | 
 34 | void Api::destroy(){
 35 |   delete mInstance;
 36 |   mInstance = 0;
 37 | }
 38 | 
 39 | Api::Api(){
 40 |   keyboard = Keyboard::instance();
 41 | }
 42 | /* ### API list ### */
 43 | /* Graphics */
 44 | void Api::LoadGraphic(Object* target,std::string filename){
 45 |   target->set_image(IMG_Load(filename.c_str()));
 46 | }
 47 | 
 48 | void Api::SetTexture(Object* target,std::string filename){
 49 |   SDL_Renderer* renderer = Window::renderer;
 50 |   SDL_Texture* tex = SDL_CreateTextureFromSurface(renderer,target->get_image());
 51 |   target->set_texture(tex);
 52 | }
 53 | 
 54 | void Api::SetGraphicRect(Object* target,Uint32 sx,Uint32 sy,Uint32 dx,Uint32 dy){
 55 |   Uint32 width = dx - sx;
 56 |   Uint32 height = dy - sy;
 57 |   target->set_obj_rect(sx,sy,width,height);
 58 | }
 59 | 
 60 | void Api::SetGraphicAngle(Object* target,Uint32 angle){
 61 |   rotozoomSurface(target->get_image(),angle,1,1);
 62 |   SetTexture(target,"dummy"); //rebind
 63 | }
 64 | 
 65 | void Api::DrawGraphic(Object* target,Uint32 x,Uint32 y){
 66 |   target->set_obj_pos(x,y);
 67 |   SDL_Renderer* renderer = Window::renderer;
 68 |   SDL_Rect *src = target->get_obj_rect();
 69 |   SDL_Rect * dest = target->get_obj_pos();
 70 |   SDL_RenderCopy(renderer, target->get_texture(),src,dest);
 71 | }
 72 | 
 73 | /* Status*/
 74 | void Api::SetSpeed(Object* target,int speed){
 75 |   target->set_speed(speed);
 76 | }
 77 | void Api::SetLife(Object* target,int life){
 78 |   target->set_life(life);
 79 | }
 80 | void Api::SetX(Object* target,int x){
 81 |   target->set_x(x);
 82 | }
 83 | void Api::SetY(Object* target,int y){
 84 |   target->set_y(y);
 85 | }
 86 | int Api::GetPlayerX(Object* target){
 87 |   return target->get_x();
 88 | }
 89 | int Api::GetPlayerY(Object* target){
 90 |   return target->get_y();
 91 | }
 92 | int Api::GetSpeedX(Object* target){
 93 |   return target->get_dx();
 94 | }
 95 | int Api::GetSpeedY(Object* target){
 96 |   return target->get_dy();
 97 | }
 98 | int Api::GetX(Object* target){
 99 |   return target->get_x();
100 | }
101 | int Api::GetY(Object* target){
102 |   return target->get_y();
103 | }
104 | int Api::GetMX(Object* target){
105 |   return target->get_mx();
106 | }
107 | int Api::GetMY(Object* target){
108 |   return target->get_my();
109 | }
110 | int Api::GetW(Object* target){
111 |   return target->get_width();
112 | }
113 | int Api::GetH(Object* target){
114 |   return target->get_height();
115 | }
116 | int Api::GetCenterX(){
117 |   return Play::win_rect.w / 2;
118 | }
119 | int Api::GetCenterY(){
120 |   return Play::win_rect.h / 2;
121 | }
122 | 
123 | /* Danmaku */
124 | void Api::CreatePlayerShot01(Object* target,int x,int y,
125 |                             double speed,double angle,double damage,
126 |                             int pene,int id){
127 |   target->shoot(x,y,speed,angle,damage,pene,id);
128 | }
129 | void Api::CreateShot01(Object* target,int x,int y,
130 |                       double speed,double angle,Bullet::Color color,int delay){
131 |   target->shoot(x,y,speed,angle,999999,10000,color,delay);
132 | }
133 | 
134 | /* SpellCard */
135 | void Api::CutIn(Object* target,std::string label,std::string img,int x1,int y1,int x2,int y2){
136 |   target->CutIn(label,img,x1,y1,x2,y2);
137 | }
138 | /* Action */
139 | void Api::SetMovePosition02(Object* target,int x,int y,int frame){
140 |   target->start_move(x,y,frame);
141 | }
142 | 
143 | /* Keyboard */
144 | Api::KeyState Api::GetKeyState(SDL_Keycode key){
145 |   if(keyboard->is_keyon(key)) return KEY_PUSH;
146 |   if(keyboard->is_keytoggle(key)) return KEY_HOLD;
147 |   if(keyboard->is_keyoff(key)) return KEY_RELEASE;
148 | }
149 | 
150 | /* Other */
151 | std::string Api::GetCurrentScriptDirectory(){
152 |   char buf[256];
153 |   getcwd(buf,256);
154 |   std::string path = buf;
155 |   return path;
156 | }
157 | 
158 | /* Unofficial API (hidden) */
159 | void Api::RenderClear(){
160 |   SDL_RenderClear(Window::renderer);
161 | }
162 | void Api::RenderPresent(){
163 |   SDL_RenderPresent(Window::renderer);
164 | }
165 | 
166 | 
167 | /* ### ABI list ### */
168 | /* Graphics */
169 | void Api::_LoadGraphic(Object* target,double filename){
170 |   //std::cout<<(unsigned long)filename<<std::endl;
171 |   const char *fnamep = reinterpret_cast<const char*>((unsigned long)(filename));
172 |   std::string filename_s = std::string(fnamep);
173 |   std::cout<<"LoadGraphic: "<<filename_s<<std::endl;
174 |   LoadGraphic(target, filename_s);
175 | }
176 | 
177 | void Api::_SetTexture(Object* target,double filename){
178 |   const char *fnamep = reinterpret_cast<const char*>((unsigned long)(filename));
179 |   std::string filename_s = std::string(fnamep);
180 |   SetTexture(target, filename_s);
181 | }
182 | 
183 | void Api::_SetGraphicRect(Object* target,double sx,double sy,double dx,double dy){
184 |   Uint32 sxi = (int)(sx);
185 |   Uint32 syi = (int)(sy);
186 |   Uint32 dxi = (int)(dx);
187 |   Uint32 dyi = (int)(dy);
188 |   SetGraphicRect(target, sxi, syi, dxi, dyi);
189 | }
190 | 
191 | void Api::_SetGraphicAngle(Object* target,double angle){
192 |   Uint32 anglei = (Uint32)(angle);
193 |   SetGraphicAngle(target, anglei);
194 | }
195 | 
196 | void Api::_DrawGraphic(Object* target,double x,double y){
197 |   Uint32 xi = (int)(x);
198 |   Uint32 yi = (int)(y);
199 |   DrawGraphic(target,xi,yi);
200 | }
201 | 
202 | /* Status*/
203 | void Api::_SetSpeed(Object* target,double speed){
204 |   int speedi = (int)(speed);
205 |   SetSpeed(target, speedi);
206 | }
207 | void Api::_SetLife(Object* target,double life){
208 |   int lifei = (int)(life);
209 |   SetLife(target, lifei);
210 | }
211 | void Api::_SetX(Object* target,double x){
212 |   double xi = (int)(x);
213 |   SetX(target, xi);
214 | }
215 | void Api::_SetY(Object* target,double y){
216 |   double yi = (int)(y);
217 |   SetY(target, yi);
218 | }
219 | int Api::_GetPlayerX(Object* target){
220 |   GetPlayerX(target);
221 | }
222 | int Api::_GetPlayerY(Object* target){
223 |   GetPlayerY(target);
224 | }
225 | int Api::_GetSpeedX(Object* target){
226 |   GetSpeedX(target);
227 | }
228 | int Api::_GetSpeedY(Object* target){
229 |   GetSpeedY(target);
230 | }
231 | int Api::_GetX(Object* target){
232 |   return GetX(target);
233 | }
234 | int Api::_GetY(Object* target){
235 |   return GetY(target);
236 | }
237 | int Api::_GetMX(Object* target){
238 |   return GetMX(target);
239 | }
240 | int Api::_GetMY(Object* target){
241 |   return GetMY(target);
242 | }
243 | int Api::_GetW(Object* target){
244 |   return GetW(target);
245 | }
246 | int Api::_GetH(Object* target){
247 |   return GetH(target);
248 | }
249 | int Api::_GetCenterX(){
250 |   return GetCenterX();
251 | }
252 | int Api::_GetCenterY(){
253 |   return GetCenterY();
254 | }
255 | 
256 | /* Danmaku */
257 | void Api::_CreatePlayerShot01(Object* target,double x,double y,
258 |                             double speed,double angle,double damage,
259 |                             double pene,double id){
260 |   int xi = (int)x;
261 |   int yi = (int)y;
262 |   int penei = (int)pene;
263 |   int idi = (int)id;
264 |   CreatePlayerShot01(target,xi,yi,speed,angle,damage,penei,idi);
265 | }
266 | void Api::_CreateShot01(Object* target,double x,double y,
267 |                       double speed,double angle,double color,double delay){
268 |   int xi = (int)x;
269 |   int yi = (int)y;
270 |   Bullet::Color colorc= (Bullet::Color)((int)color);
271 |   int delayi = (int)delay;
272 |   CreateShot01(target,xi,yi,speed,angle,colorc, delayi);
273 | }
274 | 
275 | /* SpellCard */
276 | void Api::_CutIn(Object* target,double label,double img,double x1,double y1,double x2,double y2){
277 |   const char *labelp = reinterpret_cast<const char*>((unsigned long)(label));
278 |   std::string label_s = std::string(labelp);
279 |   const char *imgp = reinterpret_cast<const char*>((unsigned long)(img));
280 |   std::string img_s = std::string(imgp);
281 | 
282 |   int x1i = (int)x1;
283 |   int y1i = (int)y1;
284 |   int x2i = (int)x2;
285 |   int y2i = (int)y2;
286 | 
287 |   CutIn(target,label_s,img_s,x1i,y1i,x2i,y2i);
288 | }
289 | /* Action */
290 | void Api::_SetMovePosition02(Object* target,double x,double y,double frame){
291 |   int xi = (int)x;
292 |   int yi = (int)y;
293 |   int framei = (int)frame;
294 |   SetMovePosition02(target,xi,yi,framei);
295 | }
296 | 
297 | /* Keyboard */
298 | Api::KeyState Api::_GetKeyState(double key){
299 |   SDL_Keycode keys = (SDL_Keycode)key;
300 |   GetKeyState(keys);
301 | }
302 | 
303 | /* Other */
304 | std::string Api::_GetCurrentScriptDirectory(){
305 |   return GetCurrentScriptDirectory();
306 | }
307 | 


--------------------------------------------------------------------------------
/Dnlang/DnLexer.cpp:
--------------------------------------------------------------------------------
  1 | #include <string>
  2 | #include <algorithm>
  3 | #include <iostream>
  4 | #include "Token.hpp"
  5 | #include "Lexer.hpp"
  6 | #include "DnLexer.hpp"
  7 | 
  8 | 
  9 | /* TODO: These macros are bit ugly. Refactor it to better one. */
 10 | #define STR(str) #str
 11 | #define ASSIGNCON(__o,__o2,__token) \
 12 | consume(); \
 13 | switch(c) { \
 14 |   case '=': consume(); return Token(__token##ASSIGN, STR(__o##=)); \
 15 |   case __o2: consume(); return Token(__token##__token, STR(__o##__o)); \
 16 |   default: return Token(__token, #__o); \
 17 | }
 18 | #define ASSIGN(__o,__token) \
 19 | consume(); \
 20 | switch(c) { \
 21 |   case '=': consume(); return Token(__token##ASSIGN, STR(__o##=)); \
 22 |   default: return Token(__token, #__o); \
 23 | }
 24 | 
 25 | #define EQUALCON(__o,__o2,__token) \
 26 | consume(); \
 27 | switch(c) { \
 28 |   case '=': consume(); return Token(__token##EQUAL, STR(__o##=)); \
 29 |   case __o2: consume(); return Token(__token##__token, STR(__o##__o)); \
 30 |   default: return Token(__token, #__o); \
 31 | }
 32 | #define EQUALL(__o,__token) \
 33 | consume(); \
 34 | switch(c) { \
 35 |   case '=': consume(); return Token(__token##EQUAL, STR(__o##=)); \
 36 |   default: return Token(__token, #__o); \
 37 | }
 38 | 
 39 | namespace Dnlang {
 40 | 
 41 | const std::string DnLexer::token_names[] = {
 42 |   "n/a", "<EOF>",
 43 |   "BREAK", "CONTINUE", "ELSE", "FOR", "FUNCTION", "IF", "LET", "RETURN", "SWITCH",
 44 |   "WHILE",
 45 |   "ID", "INTCONST", "CHARCONST", "FLOATCONST", "STRING", "SEMICORON", "COMMA",
 46 |   "LBRACKA", "RBRACKA", "LBRACK", "RBRACK", "LBRACKB", "RBRACKB",
 47 |   "MULASSIGN", "DIVASSIGN", "MODASSIGN", "PLUSASSIGN", "MINUSASSIGN",
 48 |   "ANDASSIGN", "ORASSIGN", "XORASSIGN","EQUAL",
 49 |   "OROR", "OR", "ANDAND", "AND", "XOR", "NOT", "PLUS", "MINUS", "MUL", "DIV", "MOD",
 50 |   "PLUSPLUS", "MINUSMINUS",
 51 |   "LESSLESS", "ABOVEABOVE", "EQUALEQUAL", "NOTEQUAL",
 52 |   "LESS", "LESSEQUAL", "ABOVE", "ABOVEEQUAL",
 53 |   /* virtual token for AST */
 54 |   "FUNC_DEF", "DECL", "AREF", "CALL", "PARAM", "ASSIGN",
 55 |   "INITIALIZER", "EXP", "BLOCK", "UNARYEXP", "PRIMARYEXP",
 56 | };
 57 | 
 58 | const std::string DnLexer::reserved[] = {
 59 |   "break", "continue", "else", "for", "function", "if", "let", "return", "switch", "while",
 60 | };
 61 | 
 62 | Token DnLexer::nextToken() {
 63 |     while(c != LEX_EOF) {
 64 |       switch(c) {
 65 |         case ' ': case '\t': case '\n': case '\r': skipSpaces(); continue;
 66 |         case ';': consume(); return Token(SEMICORON, ";");
 67 |         case ',': consume(); return Token(COMMA, ",");
 68 |         case '(': consume(); return Token(LBRACKA, "(");
 69 |         case ')': consume(); return Token(RBRACKA, ")");
 70 |         case '[': consume(); return Token(LBRACK, "[");
 71 |         case ']': consume(); return Token(RBRACK, "]");
 72 |         case '{': consume(); return Token(LBRACKB, "{");
 73 |         case '}': consume(); return Token(RBRACKB, "}");
 74 |         case '=':
 75 |           EQUALL(=, EQUAL)
 76 |         case '+':
 77 |           ASSIGNCON(+, '+', PLUS)
 78 |         case '-':
 79 |           ASSIGNCON(-, '-', MINUS)
 80 |         case '/':
 81 |           ASSIGN(/, DIV)
 82 |         case '*':
 83 |           ASSIGN(*, MUL)
 84 |         case '%':
 85 |           ASSIGN(%, MOD)
 86 |         case '&':
 87 |           ASSIGNCON(&, '&', AND)
 88 |         case '|':
 89 |           ASSIGNCON(|, '|', OR)
 90 |         case '^':
 91 |           ASSIGN(^, XOR)
 92 |         case '!':
 93 |           EQUALL(!, NOT)
 94 |         case '<':
 95 |           EQUALCON(<, '<', LESS)
 96 |         case '>':
 97 |           EQUALCON(>, '>', ABOVE)
 98 |         case '\"':
 99 |           /* "hoge" (string) */
100 |           if(isString()) return String();
101 |         case '\'':
102 |           /* 'X' (char) */
103 |           if(isChar()) return CharConst();
104 |         default:
105 |           if(isDecimal()) {
106 |             /* {D} */
107 |             if(isFloat()) return FloatConst();
108 |             else return IntConst();
109 |           }else if(isId()) {
110 |             /* {L} It could be id or reserved word */
111 |             return Id();
112 |           }
113 |           break;
114 |     }
115 |   }
116 |   return Token(EOF_TYPE, "<EOF>");
117 | }
118 | 
119 | /* TODO: Is it reserved word? It's judged by using binary search. */
120 | int DnLexer::isReserved(std::string str) {
121 |   int rsize = sizeof(reserved) / sizeof(std::string *);
122 |   for(int i = 0; i < rsize; i++){
123 |     if(reserved[i] == str) return i;
124 |   }
125 |   return -1;
126 |   /*std::string *pos = std::lower_bound(reserved, reserved + rsize, str);
127 |   return (pos != rsize && *pos == str); */
128 | }
129 | 
130 | Token DnLexer::IntConst() {
131 |   std::string buf;
132 |   do { buf.append(1, c); consume(); } while(isDecimal());
133 |   return Token(INTCONST, buf);
134 | }
135 | 
136 | Token DnLexer::CharConst() {
137 |   std::string buf;
138 |   consume();
139 |   buf.append(1,c);
140 |   consume();
141 |   return Token(CHARCONST, buf);
142 | }
143 | 
144 | Token DnLexer::FloatConst() {
145 |   std::string buf;
146 |   do { buf.append(1, c); consume(); } while(isDecimal() || c == '.');
147 |   return Token(FLOATCONST, buf);
148 | }
149 | 
150 | Token DnLexer::String() {
151 |   std::string buf;
152 |   do { buf.append(1, c); consume(); } while(isDecimal() || isLetter() || isSym() || c == '\"' || c == '\"');
153 |   return Token(STRING, buf);
154 | }
155 | 
156 | Token DnLexer::Id() {
157 |   std::string buf;
158 |   int resv = -1;
159 |   do { buf.append(1, c); consume(); } while(isDecimal() || isLetter() || isSym());
160 |   if((resv = isReserved(buf)) != -1){
161 |     /* Is this id reserved word? */
162 |     return Token(2 + resv, buf);
163 |   }
164 |   return Token(ID, buf);
165 | }
166 | 
167 | }
168 | 


--------------------------------------------------------------------------------
/Dnlang/DnParser.cpp:
--------------------------------------------------------------------------------
  1 | #include <vector>
  2 | #include <string>
  3 | #include <sstream>
  4 | #include <map>
  5 | #include <iostream>
  6 | #include "Token.hpp"
  7 | #include "Lexer.hpp"
  8 | #include "DnLexer.hpp"
  9 | #include "Symbol.hpp"
 10 | #include "Scope.hpp"
 11 | #include "Register.hpp"
 12 | #include "AST.hpp"
 13 | #include "Parser.hpp"
 14 | #include "DnParser.hpp"
 15 | 
 16 | 
 17 | #define SPECULATE(x) \
 18 | [this]() { \
 19 |   bool success = true; \
 20 |   mark(); \
 21 |   try { x } \
 22 |   catch (std::string &str) { success = false; } \
 23 |   release(); \
 24 |   return success; \
 25 | }
 26 | #define DEFINE_MEMO(x, fp) \
 27 |   bool failed = false; \
 28 |   int startTokenIndex = index(); \
 29 |   if(isSpeculating() && alreadyParsedRule(#x)) return; \
 30 |   try { _##fp } \
 31 |   catch(std::string &s) { \
 32 |     failed = true; \
 33 |     if(isSpeculating()) memorize(#x, startTokenIndex, failed); \
 34 |     throw s; \
 35 |   } \
 36 |   if(isSpeculating()) memorize(#x, startTokenIndex, failed); \
 37 | 
 38 | #define ADD_TOKEN(type, str) \
 39 |   if(!isSpeculating()) { \
 40 |     AST *child= new AST(Token(type, str)); \
 41 |     ast_root->addChild(ast_root, child); \
 42 |   } \
 43 | 
 44 | #define ADD_ROOT_CHROOT(root) \
 45 |   if(!isSpeculating()) { \
 46 |     AST *child = new AST(root); \
 47 |     ast_root = ast_root->addChild(ast_root, child); \
 48 |   } \
 49 | 
 50 | #define ADD_TOKEN_CHROOT(type, str) \
 51 |   if(!isSpeculating()) { \
 52 |     AST *child = new AST(Token(type, str)); \
 53 |     ast_root = ast_root->addChild(ast_root, child); \
 54 |   } \
 55 | 
 56 | #define BREAK_UP \
 57 |   if(!isSpeculating()) { \
 58 |     ast_root = ast_root->parent; \
 59 |   } \
 60 | 
 61 | namespace Dnlang {
 62 |   /* type inference
 63 |      XXX bit ugly. Is there any better solution? */
 64 | void DnParser::_TranslationUnit() {
 65 |   if(SPECULATE( ExternalDecl(); TranslationUnit(); match(DnLexer::EOF_TYPE); )()) {
 66 |     ExternalDecl(); TranslationUnit(); match(DnLexer::EOF_TYPE);
 67 |   }
 68 |   else if(SPECULATE( ExternalDecl(); match(DnLexer::EOF_TYPE); )()) {
 69 |     ExternalDecl(); match(DnLexer::EOF_TYPE);
 70 |   }
 71 |   else {
 72 |     std::stringstream error;
 73 |     error << "Error: " << LT(1) << LT(2);
 74 |     throw error.str();
 75 |   }
 76 | }
 77 | void DnParser::_ExternalDecl() {
 78 |   if(SPECULATE( FunctionDef(); )()) {
 79 |     FunctionDef();
 80 |   }
 81 |   else if(SPECULATE( Decl(); )()) {
 82 |     Decl();
 83 |   }
 84 |   else {
 85 |     std::stringstream error;
 86 |     error << "Error: " << LT(1) << LT(2);
 87 |     throw error.str();
 88 |   }
 89 | }
 90 | void DnParser::_FunctionDef() {
 91 |   if(SPECULATE( DeclSpecs(); Declarator(); CompoundStat(); )()) {
 92 |     ADD_ROOT_CHROOT(DnLexer::FUNC_DEF)
 93 |     DeclSpecs(); Declarator(); CompoundStat();
 94 |     BREAK_UP
 95 |   }
 96 |   else {
 97 |     std::stringstream error;
 98 |     error << "Error: " << LT(1) << LT(2);
 99 |     throw error.str();
100 |   }
101 | }
102 | void DnParser::_Decl() {
103 |   if(SPECULATE( DeclSpecs(); InitDecl(); match(DnLexer::SEMICORON); )()) {
104 |     ADD_ROOT_CHROOT(DnLexer::DECL)
105 |     DeclSpecs();
106 |     InitDecl();
107 |     match(DnLexer::SEMICORON);
108 |     BREAK_UP
109 |   }
110 |   else {
111 |     std::stringstream error;
112 |     error << "Error: " << LT(1) << LT(2);
113 |     throw error.str();
114 |   }
115 | }
116 | void DnParser::_DeclList() {
117 |   if(SPECULATE( Decl(); DeclList(); )()) {
118 |     Decl(); DeclList();
119 |   }
120 |   else if(SPECULATE( Decl(); )()) {
121 |     Decl();
122 |   }
123 |   else {
124 |     std::stringstream error;
125 |     error << "Error: " << LT(1) << LT(2);
126 |     throw error.str();
127 |   }
128 | }
129 | void DnParser::_DeclSpecs() {
130 |   if(SPECULATE( FuncSpec(); )()) {
131 |     FuncSpec();
132 |   }
133 |   else if(SPECULATE( TypeSpec(); )()) {
134 |     TypeSpec();
135 |   }
136 |   else {
137 |     std::stringstream error;
138 |     error << "Error: " << LT(1) << LT(2);
139 |     throw error.str();
140 |   }
141 | }
142 | void DnParser::_FuncSpec() {
143 |   if(SPECULATE( match(DnLexer::FUNCTION); )()) {
144 |     match(DnLexer::FUNCTION);
145 |   }
146 |   else {
147 |     std::stringstream error;
148 |     error << "Error: " << LT(1) << LT(2);
149 |     throw error.str();
150 |   }
151 | }
152 | void DnParser::_TypeSpec() {
153 |   if(SPECULATE( match(DnLexer::LET); )()) {
154 |     match(DnLexer::LET);
155 |   }
156 |   else {
157 |     std::stringstream error;
158 |     error << "Error: " << LT(1) << LT(2);
159 |     throw error.str();
160 |   }
161 | }
162 | void DnParser::_InitDeclList() {
163 |   if(SPECULATE( InitDecl(); match(DnLexer::COMMA); InitDeclList(); )()) {
164 |     InitDecl(); match(DnLexer::COMMA); InitDeclList();
165 |   }
166 |   else if(SPECULATE( InitDecl();  )()) {
167 |     InitDecl();
168 |   }
169 |   else {
170 |     std::stringstream error;
171 |     error << "Error: " << LT(1) << LT(2);
172 |     throw error.str();
173 |   }
174 | }
175 | void DnParser::_InitDecl() {
176 |   if(SPECULATE( Declarator(); match(DnLexer::EQUAL); Initializer(); )()) {
177 |     Declarator(); match(DnLexer::EQUAL); Initializer();
178 |   }
179 |   else if(SPECULATE( Declarator();  )()) {
180 |     Declarator();
181 |   }
182 |   else {
183 |     std::stringstream error;
184 |     error << "Error: " << LT(1) << LT(2);
185 |     throw error.str();
186 |   }
187 | }
188 | void DnParser::_Declarator() {
189 |   if(SPECULATE( match(DnLexer::ID); match(DnLexer::LBRACKA); IdList(); match(DnLexer::RBRACKA); )()) {
190 |     ADD_TOKEN(DnLexer::ID, LT(1).text)
191 |     match(DnLexer::ID);
192 |     ADD_ROOT_CHROOT(DnLexer::PARAM)
193 |     match(DnLexer::LBRACKA); IdList(); match(DnLexer::RBRACKA);
194 |     BREAK_UP
195 |   }
196 |   else if(SPECULATE( match(DnLexer::ID); match(DnLexer::LBRACKA); match(DnLexer::RBRACKA); )()) {
197 |     ADD_TOKEN(DnLexer::ID, LT(1).text)
198 |     match(DnLexer::ID);
199 |     ADD_ROOT_CHROOT(DnLexer::PARAM)
200 |     match(DnLexer::LBRACKA); match(DnLexer::RBRACKA);
201 |     BREAK_UP
202 |   }
203 |   else if(SPECULATE( match(DnLexer::ID); match(DnLexer::LBRACK); match(DnLexer::INTCONST); match(DnLexer::RBRACK); )()) {
204 |     ADD_TOKEN(DnLexer::ID, LT(1).text)
205 |     match(DnLexer::ID);
206 |     /* TODO: Implement declaration of array */
207 |   }
208 |   else if(SPECULATE( match(DnLexer::ID); )()) {
209 |       ADD_TOKEN(DnLexer::ID, LT(1).text)
210 |       match(DnLexer::ID);
211 |   }
212 |   else {
213 |     std::stringstream error;
214 |     error << "Error: " << LT(1) << LT(2);
215 |     throw error.str();
216 |   }
217 | }
218 | void DnParser::_IdList() {
219 |   if(SPECULATE( match(DnLexer::ID); match(DnLexer::COMMA); IdList(); )()) {
220 |     ADD_TOKEN(DnLexer::ID, LT(1).text)
221 |     match(DnLexer::ID);
222 |     match(DnLexer::COMMA); IdList();
223 |   }
224 |   else if(SPECULATE( match(DnLexer::ID); )()) {
225 |     ADD_TOKEN(DnLexer::ID, LT(1).text)
226 |     match(DnLexer::ID);
227 |   }
228 |   else {
229 |     std::stringstream error;
230 |     error << "Error: " << LT(1) << LT(2);
231 |     throw error.str();
232 |   }
233 | }
234 | void DnParser::_Initializer() {
235 |   if(SPECULATE( AssignExp(); )()) {
236 |     AssignExp();
237 |   }
238 |   else {
239 |     std::stringstream error;
240 |     error << "Error: " << LT(1) << LT(2);
241 |     throw error.str();
242 |   }
243 | }
244 | void DnParser::_Stat() {
245 |   if(SPECULATE( ExpStat(); )()) {
246 |     ExpStat();
247 |   }
248 |   else if(SPECULATE( CompoundStat(); )()) {
249 |     CompoundStat();
250 |   }
251 |   else if(SPECULATE( SelectionStat(); )()) {
252 |     SelectionStat();
253 |   }
254 |   else if(SPECULATE( IterationStat(); )()) {
255 |     IterationStat();
256 |   }
257 |   else if(SPECULATE( JumpStat(); )()) {
258 |     JumpStat();
259 |   }
260 |   else {
261 |     std::stringstream error;
262 |     error << "Error: " << LT(1) << LT(2);
263 |     throw error.str();
264 |   }
265 | }
266 | void DnParser::_ExpStat() {
267 |   if(SPECULATE( Exp(); match(DnLexer::SEMICORON); )()) {
268 |     Exp(); match(DnLexer::SEMICORON);
269 |   }
270 |   else if(SPECULATE( match(DnLexer::SEMICORON); )()) {
271 |     match(DnLexer::SEMICORON);
272 |   }
273 |   else {
274 |     std::stringstream error;
275 |     error << "Error: " << LT(1) << LT(2);
276 |     throw error.str();
277 |   }
278 | }
279 | void DnParser::_CompoundStat() {
280 |   if(SPECULATE( match(DnLexer::LBRACKB); match(DnLexer::RBRACKB); )()) {
281 |     ADD_ROOT_CHROOT(DnLexer::BLOCK)
282 |     match(DnLexer::LBRACKB); match(DnLexer::RBRACKB);
283 |     BREAK_UP
284 |   }
285 |   else if(SPECULATE( match(DnLexer::LBRACKB); DeclList(); StatList(); match(DnLexer::RBRACKB); )()) {
286 |     ADD_ROOT_CHROOT(DnLexer::BLOCK)
287 |     match(DnLexer::LBRACKB); DeclList(); StatList(); match(DnLexer::RBRACKB);
288 |     BREAK_UP
289 |   }
290 |   else if(SPECULATE( match(DnLexer::LBRACKB); DeclList(); match(DnLexer::RBRACKB); )()) {
291 |     ADD_ROOT_CHROOT(DnLexer::BLOCK)
292 |     match(DnLexer::LBRACKB); DeclList(); match(DnLexer::RBRACKB);
293 |     BREAK_UP
294 |   }
295 |   else if(SPECULATE( match(DnLexer::LBRACKB); StatList(); match(DnLexer::RBRACKB); )()) {
296 |     ADD_ROOT_CHROOT(DnLexer::BLOCK)
297 |     match(DnLexer::LBRACKB); StatList(); match(DnLexer::RBRACKB);
298 |     BREAK_UP
299 |   }
300 |   else {
301 |     std::stringstream error;
302 |     error << "Error: " << LT(1) << LT(2);
303 |     throw error.str();
304 |   }
305 | }
306 | void DnParser::_StatList() {
307 |   if(SPECULATE( Stat(); StatList(); )()) {
308 |     Stat(); StatList();
309 |   }
310 |   else if(SPECULATE( Stat(); )()) {
311 |     Stat();
312 |   }
313 |   else {
314 |     std::stringstream error;
315 |     error << "Error: " << LT(1) << LT(2);
316 |     throw error.str();
317 |   }
318 | }
319 | void DnParser::_SelectionStat() {
320 |   if(SPECULATE( match(DnLexer::IF); match(DnLexer::LBRACKA); Exp(); match(DnLexer::RBRACKA); Stat(); match(DnLexer::ELSE); Stat(); )()) {
321 |     ADD_TOKEN_CHROOT(DnLexer::IF, "IF")
322 |     match(DnLexer::IF);
323 |     match(DnLexer::LBRACKA); Exp(); match(DnLexer::RBRACKA); Stat();
324 |     match(DnLexer::ELSE); Stat();
325 |     BREAK_UP
326 |   }
327 |   else if(SPECULATE( match(DnLexer::IF); match(DnLexer::LBRACKA); Exp(); match(DnLexer::RBRACKA); Stat(); )()) {
328 |     ADD_TOKEN_CHROOT(DnLexer::IF, "IF")
329 |     match(DnLexer::IF);
330 |     match(DnLexer::LBRACKA); Exp(); match(DnLexer::RBRACKA); Stat();
331 |     BREAK_UP
332 |   }
333 |   else {
334 |     std::stringstream error;
335 |     error << "Error: " << LT(1) << LT(2);
336 |     throw error.str();
337 |   }
338 | }
339 | void DnParser::_IterationStat() {
340 |   if(SPECULATE( match(DnLexer::WHILE); match(DnLexer::LBRACKA); Exp(); match(DnLexer::RBRACKA); Stat(); )()) {
341 |     ADD_TOKEN_CHROOT(DnLexer::WHILE, "WHILE")
342 |     match(DnLexer::WHILE);
343 |     match(DnLexer::LBRACKA); Exp(); match(DnLexer::RBRACKA); Stat();
344 |     BREAK_UP
345 |   }
346 |   else if(SPECULATE( match(DnLexer::FOR); match(DnLexer::LBRACKA); Exp(); match(DnLexer::SEMICORON); Exp(); match(DnLexer::SEMICORON); Exp(); match(DnLexer::RBRACKA); Stat(); )()) {
347 |     ADD_TOKEN_CHROOT(DnLexer::FOR, "FOR")
348 |     match(DnLexer::FOR);
349 |     match(DnLexer::LBRACKA);
350 |     Exp(); match(DnLexer::SEMICORON);
351 |     Exp(); match(DnLexer::SEMICORON);
352 |     Exp();
353 |     match(DnLexer::RBRACKA); Stat();
354 |     BREAK_UP
355 |   }
356 |   else {
357 |     std::stringstream error;
358 |     error << "Error: " << LT(1) << LT(2);
359 |     throw error.str();
360 |   }
361 | 
362 | }
363 | void DnParser::_JumpStat() {
364 |   if(SPECULATE( match(DnLexer::CONTINUE); match(DnLexer::SEMICORON); )()) {
365 |     ADD_TOKEN(DnLexer::CONTINUE, "CONTINUE")
366 |     match(DnLexer::CONTINUE);
367 |     match(DnLexer::SEMICORON);
368 |   }
369 |   else if(SPECULATE( match(DnLexer::BREAK); match(DnLexer::SEMICORON); )()) {
370 |     ADD_TOKEN(DnLexer::BREAK, "BREAK")
371 |     match(DnLexer::BREAK);
372 |     match(DnLexer::SEMICORON);
373 |   }
374 |   else if(SPECULATE( match(DnLexer::RETURN); Exp(); match(DnLexer::SEMICORON); )()) {
375 |     ADD_TOKEN_CHROOT(DnLexer::RETURN, "RETURN")
376 |     match(DnLexer::RETURN);
377 |     Exp(); match(DnLexer::SEMICORON);
378 |     BREAK_UP
379 |   }
380 |   else if(SPECULATE( match(DnLexer::RETURN); match(DnLexer::SEMICORON); )()) {
381 |     ADD_TOKEN(DnLexer::RETURN, "RETURN")
382 |     match(DnLexer::RETURN);
383 |     match(DnLexer::SEMICORON);
384 |   }
385 |   else {
386 |     std::stringstream error;
387 |     error << "Error: " << LT(1) << LT(2);
388 |     throw error.str();
389 |   }
390 | }
391 | void DnParser::_Exp() {
392 |   if(SPECULATE( AssignExp(); match(DnLexer::COMMA); Exp(); )()) {
393 |     AssignExp(); match(DnLexer::COMMA); Exp();
394 |   }
395 |   else if(SPECULATE( AssignExp(); )()) {
396 |     AssignExp();
397 |   }
398 |   else {
399 |     std::stringstream error;
400 |     error << "Error: " << LT(1) << LT(2);
401 |     throw error.str();
402 |   }
403 | }
404 | void DnParser::_AssignExp() {
405 |   if(SPECULATE( UnaryExp(); AssignOperator(); AssignExp(); )()) {
406 |     ADD_TOKEN_CHROOT(DnLexer::ASSIGN, "ASSIGN");
407 |     UnaryExp(); AssignOperator(); AssignExp();
408 |     BREAK_UP
409 |   }
410 |   else if(SPECULATE( ConditionalExp(); )()) {
411 |     ConditionalExp();
412 |   }
413 |   else {
414 |     std::stringstream error;
415 |     error << "Error: " << LT(1) << LT(2);
416 |     throw error.str();
417 |   }
418 | }
419 | void DnParser::_AssignOperator() {
420 |   if(SPECULATE( match(DnLexer::EQUAL); )()) {
421 |     ADD_TOKEN(DnLexer::EQUAL, "=")
422 |     match(DnLexer::EQUAL);
423 |   }
424 |   else if(SPECULATE( match(DnLexer::MULASSIGN); )()) {
425 |     ADD_TOKEN(DnLexer::MULASSIGN, "*=")
426 |     match(DnLexer::MULASSIGN);
427 |   }
428 |   else if(SPECULATE( match(DnLexer::DIVASSIGN); )()) {
429 |     ADD_TOKEN(DnLexer::DIVASSIGN, "/=")
430 |     match(DnLexer::DIVASSIGN);
431 |   }
432 |   else if(SPECULATE( match(DnLexer::MODASSIGN); )()) {
433 |     ADD_TOKEN(DnLexer::MODASSIGN, "%=")
434 |     match(DnLexer::MODASSIGN);
435 |   }
436 |   else if(SPECULATE( match(DnLexer::PLUSASSIGN); )()) {
437 |     ADD_TOKEN(DnLexer::PLUSASSIGN, "+=")
438 |     match(DnLexer::PLUSASSIGN);
439 |   }
440 |   else if(SPECULATE( match(DnLexer::MINUSASSIGN); )()) {
441 |     ADD_TOKEN(DnLexer::MINUSASSIGN, "-=")
442 |     match(DnLexer::MINUSASSIGN);
443 |   }
444 |   else if(SPECULATE( match(DnLexer::ANDASSIGN); )()) {
445 |     ADD_TOKEN(DnLexer::ANDASSIGN, "&=")
446 |     match(DnLexer::ANDASSIGN);
447 |   }
448 |   else if(SPECULATE( match(DnLexer::ORASSIGN); )()) {
449 |     match(DnLexer::ORASSIGN);
450 |     ADD_TOKEN(DnLexer::ORASSIGN, "|=")
451 |   }
452 |   else if(SPECULATE( match(DnLexer::XORASSIGN); )()) {
453 |     match(DnLexer::XORASSIGN);
454 |     ADD_TOKEN(DnLexer::XORASSIGN, "^=")
455 |   }
456 |   else {
457 |     std::stringstream error;
458 |     error << "Error: " << LT(1) << LT(2);
459 |     throw error.str();
460 |   }
461 | }
462 | void DnParser::_ConditionalExp() {
463 |   if(SPECULATE( LogicalOrExp(); )()) {
464 |     LogicalOrExp();
465 |   }
466 |   else {
467 |     std::stringstream error;
468 |     error << "Error: " << LT(1) << LT(2);
469 |     throw error.str();
470 |   }
471 | }
472 | void DnParser::_LogicalOrExp() {
473 |   if(SPECULATE( LogicalAndExp(); )()) {
474 |     LogicalAndExp();
475 |   }
476 |   else if(SPECULATE( LogicalAndExp(); match(DnLexer::OROR); LogicalOrExp(); )()) {
477 |     ADD_TOKEN_CHROOT(DnLexer::OROR, "||")
478 |     LogicalAndExp(); match(DnLexer::OROR); LogicalOrExp();
479 |     BREAK_UP
480 |   }
481 |   else {
482 |     std::stringstream error;
483 |     error << "Error: " << LT(1) << LT(2);
484 |     throw error.str();
485 |   }
486 | }
487 | void DnParser::_LogicalAndExp() {
488 |   if(SPECULATE( InclusiveOrExp(); match(DnLexer::ANDAND); LogicalAndExp(); )()) {
489 |     ADD_TOKEN_CHROOT(DnLexer::ANDAND, "&&")
490 |     InclusiveOrExp(); match(DnLexer::ANDAND); LogicalAndExp();
491 |     BREAK_UP
492 |   }
493 |   else if(SPECULATE( InclusiveOrExp(); )()) {
494 |     InclusiveOrExp();
495 |   }
496 |   else {
497 |     std::stringstream error;
498 |     error << "Error: " << LT(1) << LT(2);
499 |     throw error.str();
500 |   }
501 | }
502 | void DnParser::_InclusiveOrExp() {
503 |   if(SPECULATE( ExclusiveOrExp(); match(DnLexer::OR); InclusiveOrExp(); )()) {
504 |     ADD_TOKEN_CHROOT(DnLexer::OR, "|")
505 |     ExclusiveOrExp(); match(DnLexer::OR); InclusiveOrExp();
506 |     BREAK_UP
507 |   }
508 |   else if(SPECULATE( ExclusiveOrExp(); )()) {
509 |     ExclusiveOrExp();
510 |   }
511 |   else {
512 |     std::stringstream error;
513 |     error << "Error: " << LT(1) << LT(2);
514 |     throw error.str();
515 |   }
516 | }
517 | void DnParser::_ExclusiveOrExp() {
518 |   if(SPECULATE( AndExp(); match(DnLexer::XOR); ExclusiveOrExp(); )()) {
519 |     ADD_TOKEN_CHROOT(DnLexer::XOR, "^")
520 |     AndExp(); match(DnLexer::XOR); ExclusiveOrExp();
521 |     BREAK_UP
522 |   }
523 |   else if(SPECULATE( AndExp(); )()) {
524 |     AndExp();
525 |   }
526 |   else {
527 |     std::stringstream error;
528 |     error << "Error: " << LT(1) << LT(2);
529 |     throw error.str();
530 |   }
531 | 
532 | }
533 | void DnParser::_AndExp() {
534 |   if(SPECULATE( EqualityExp(); match(DnLexer::AND); AndExp(); )()) {
535 |     ADD_TOKEN_CHROOT(DnLexer::AND, "&")
536 |     EqualityExp(); match(DnLexer::AND); AndExp();
537 |     BREAK_UP
538 |   }
539 |   else if(SPECULATE( EqualityExp(); )()) {
540 |     EqualityExp();
541 |   }
542 |   else {
543 |     std::stringstream error;
544 |     error << "Error: " << LT(1) << LT(2);
545 |     throw error.str();
546 |   }
547 | }
548 | void DnParser::_EqualityExp() {
549 |   if(SPECULATE( RelationalExp(); match(DnLexer::EQUALEQUAL); EqualityExp(); )()) {
550 |     ADD_TOKEN_CHROOT(DnLexer::EQUALEQUAL, "==")
551 |     RelationalExp(); match(DnLexer::EQUALEQUAL); EqualityExp();
552 |     BREAK_UP
553 |   }
554 |   else if(SPECULATE( RelationalExp(); match(DnLexer::NOTEQUAL); EqualityExp(); )()) {
555 |     ADD_TOKEN_CHROOT(DnLexer::NOTEQUAL, "!=")
556 |     RelationalExp(); match(DnLexer::NOTEQUAL); EqualityExp();
557 |     BREAK_UP
558 |   }
559 |   else if(SPECULATE( RelationalExp(); )()) {
560 |     RelationalExp();
561 |   }
562 |   else {
563 |     std::stringstream error;
564 |     error << "Error: " << LT(1) << LT(2);
565 |     throw error.str();
566 |   }
567 | }
568 | void DnParser::_RelationalExp() {
569 |   if(SPECULATE( ShiftExp(); match(DnLexer::LESS); RelationalExp(); )()) {
570 |     ADD_TOKEN_CHROOT(DnLexer::LESS, "<")
571 |     ShiftExp(); match(DnLexer::LESS); RelationalExp();
572 |     BREAK_UP
573 |   }
574 |   else if(SPECULATE( ShiftExp(); match(DnLexer::ABOVE); RelationalExp(); )()) {
575 |     ADD_TOKEN_CHROOT(DnLexer::ABOVE, ">")
576 |     ShiftExp(); match(DnLexer::ABOVE); RelationalExp();
577 |     BREAK_UP
578 |   }
579 |   else if(SPECULATE( ShiftExp(); match(DnLexer::LESSEQUAL); RelationalExp(); )()) {
580 |     ADD_TOKEN_CHROOT(DnLexer::LESSEQUAL, "<=")
581 |     ShiftExp(); match(DnLexer::LESSEQUAL); RelationalExp();
582 |     BREAK_UP
583 |   }
584 |   else if(SPECULATE( ShiftExp(); match(DnLexer::ABOVEEQUAL); RelationalExp(); )()) {
585 |     ADD_TOKEN_CHROOT(DnLexer::ABOVEEQUAL, ">=")
586 |     ShiftExp(); match(DnLexer::ABOVEEQUAL); RelationalExp();
587 |     BREAK_UP
588 |   }
589 |   else if(SPECULATE( ShiftExp(); )()) {
590 |     ShiftExp();
591 |   }
592 |   else {
593 |     std::stringstream error;
594 |     error << "Error: " << LT(1) << LT(2);
595 |     throw error.str();
596 |   }
597 | }
598 | void DnParser::_ShiftExp() {
599 |   if(SPECULATE( AdditiveExp(); match(DnLexer::LESSLESS); ShiftExp(); )()) {
600 |     ADD_TOKEN_CHROOT(DnLexer::LESSLESS, "<<")
601 |     AdditiveExp(); match(DnLexer::LESSLESS); ShiftExp();
602 |     BREAK_UP
603 |   }
604 |   else if(SPECULATE( AdditiveExp(); match(DnLexer::ABOVEABOVE); ShiftExp(); )()) {
605 |     ADD_TOKEN_CHROOT(DnLexer::ABOVEABOVE, ">>")
606 |     AdditiveExp(); match(DnLexer::ABOVEABOVE); ShiftExp();
607 |     BREAK_UP
608 |   }
609 |   else if(SPECULATE( AdditiveExp(); )()) {
610 |     AdditiveExp();
611 |   }
612 |   else {
613 |     std::stringstream error;
614 |     error << "Error: " << LT(1) << LT(2);
615 |     throw error.str();
616 |   }
617 | }
618 | void DnParser::_AdditiveExp() {
619 |   if(SPECULATE( MultExp(); match(DnLexer::PLUS); AdditiveExp(); )()) {
620 |     ADD_TOKEN_CHROOT(DnLexer::PLUS, "+")
621 |     MultExp(); match(DnLexer::PLUS); AdditiveExp();
622 |     BREAK_UP
623 |   }
624 |   else if(SPECULATE( MultExp(); match(DnLexer::MINUS); AdditiveExp(); )()) {
625 |     ADD_TOKEN_CHROOT(DnLexer::MINUS, "-")
626 |     MultExp(); match(DnLexer::MINUS); AdditiveExp();
627 |     BREAK_UP
628 |   }
629 |   else if(SPECULATE( MultExp(); )()) {
630 |     MultExp();
631 |   }
632 |   else {
633 |     std::stringstream error;
634 |     error << "Error: " << LT(1) << LT(2);
635 |     throw error.str();
636 |   }
637 | }
638 | void DnParser::_MultExp() {
639 |   if(SPECULATE( UnaryExp(); match(DnLexer::MUL); MultExp(); )()) {
640 |     ADD_TOKEN_CHROOT(DnLexer::MUL, "*")
641 |     UnaryExp(); match(DnLexer::MUL); MultExp();
642 |     BREAK_UP
643 |   }
644 |   else if(SPECULATE( UnaryExp(); match(DnLexer::DIV); MultExp(); )()) {
645 |     ADD_TOKEN_CHROOT(DnLexer::DIV, "/")
646 |     UnaryExp(); match(DnLexer::DIV); MultExp();
647 |     BREAK_UP
648 |   }
649 |   else if(SPECULATE( UnaryExp(); match(DnLexer::MOD); MultExp(); )()) {
650 |     ADD_TOKEN_CHROOT(DnLexer::MOD, "%")
651 |     UnaryExp(); match(DnLexer::MOD); MultExp();
652 |     BREAK_UP
653 |   }
654 |   else if(SPECULATE( UnaryExp(); )()) {
655 |     UnaryExp();
656 |   }
657 |   else {
658 |     std::stringstream error;
659 |     error << "Error: " << LT(1) << LT(2);
660 |     throw error.str();
661 |   }
662 | }
663 | void DnParser::_UnaryExp() {
664 |   if(SPECULATE( PostfixExp(); )()) {
665 |     PostfixExp();
666 |   }
667 |   else if(SPECULATE( match(DnLexer::PLUSPLUS); UnaryExp(); )()) {
668 |     ADD_TOKEN_CHROOT(DnLexer::PLUSPLUS, "++")
669 |     match(DnLexer::PLUSPLUS); UnaryExp();
670 |     BREAK_UP
671 |   }
672 |   else if(SPECULATE( match(DnLexer::MINUSMINUS); UnaryExp(); )()) {
673 |     ADD_TOKEN_CHROOT(DnLexer::MINUSMINUS, "--")
674 |     match(DnLexer::MINUSMINUS); UnaryExp();
675 |     BREAK_UP
676 |   }
677 |   else if(SPECULATE( UnaryOperator(); UnaryExp(); )()) {
678 |     UnaryOperator(); UnaryExp();
679 |     BREAK_UP
680 |   }
681 |   else {
682 |     std::stringstream error;
683 |     error << "Error: " << LT(1) << LT(2);
684 |     throw error.str();
685 |   }
686 | }
687 | void DnParser::_UnaryOperator() {
688 |   if(SPECULATE( match(DnLexer::PLUS); )()) {
689 |     ADD_TOKEN_CHROOT(DnLexer::PLUS, "+")
690 |     match(DnLexer::PLUS);
691 |   }
692 |   else if(SPECULATE( match(DnLexer::MINUS); )()) {
693 |     ADD_TOKEN_CHROOT(DnLexer::MINUS, "-")
694 |     match(DnLexer::MINUS);
695 |   }
696 |   else if(SPECULATE( match(DnLexer::NOT); )()) {
697 |     ADD_TOKEN_CHROOT(DnLexer::NOT, "!")
698 |     match(DnLexer::NOT);
699 |   }
700 |   else {
701 |     std::stringstream error;
702 |     error << "Error: " << LT(1) << LT(2);
703 |     throw error.str();
704 |   }
705 | }
706 | void DnParser::_PostfixExp() {
707 |   if(SPECULATE( PrimaryExp(); match(DnLexer::LBRACK); Exp(); match(DnLexer::RBRACK); )()) {
708 |     ADD_ROOT_CHROOT(DnLexer::AREF)
709 |     PrimaryExp(); match(DnLexer::LBRACK); Exp(); match(DnLexer::RBRACK);
710 |     BREAK_UP
711 |   }
712 |   else if(SPECULATE( PrimaryExp(); match(DnLexer::LBRACKA); ArgumentExpList(); match(DnLexer::RBRACKA); )()) {
713 |     ADD_ROOT_CHROOT(DnLexer::CALL)
714 |     PrimaryExp(); match(DnLexer::LBRACKA); ArgumentExpList(); match(DnLexer::RBRACKA);
715 |     BREAK_UP
716 |   }
717 |   else if(SPECULATE( PrimaryExp(); match(DnLexer::LBRACKA); match(DnLexer::RBRACKA); )()) {
718 |     ADD_ROOT_CHROOT(DnLexer::CALL)
719 |     PrimaryExp(); match(DnLexer::LBRACKA); match(DnLexer::RBRACKA);
720 |     BREAK_UP
721 |   }
722 |   else if(SPECULATE( PrimaryExp(); )()) {
723 |     PrimaryExp();
724 |   }
725 |   else {
726 |     std::stringstream error;
727 |     error << "Error: " << LT(1) << LT(2);
728 |     throw error.str();
729 |   }
730 | 
731 | }
732 | void DnParser::_PrimaryExp() {
733 |   if(SPECULATE( match(DnLexer::ID); )()) {
734 |     ADD_TOKEN(DnLexer::ID, LT(1).text);
735 |     match(DnLexer::ID);
736 |   }
737 |   else if(SPECULATE( Const(); )()) {
738 |     Const();
739 |   }
740 |   else if(SPECULATE( match(DnLexer::STRING); )()) {
741 |     ADD_TOKEN(DnLexer::STRING, LT(1).text);
742 |     match(DnLexer::STRING);
743 |   }
744 |   else if(SPECULATE( match(DnLexer::LBRACKA); Exp(); match(DnLexer::RBRACKA); )()) {
745 |     match(DnLexer::LBRACKA); Exp(); match(DnLexer::RBRACKA);
746 |   }
747 |   else {
748 |     std::stringstream error;
749 |     error << "Error: " << LT(1) << LT(2);
750 |     throw error.str();
751 |   }
752 | }
753 | void DnParser::_ArgumentExpList() {
754 |   if(SPECULATE( AssignExp(); match(DnLexer::COMMA); ArgumentExpList(); )()) {
755 |     AssignExp(); match(DnLexer::COMMA); ArgumentExpList();
756 |   }
757 |   else if(SPECULATE( AssignExp(); )()) {
758 |     AssignExp();
759 |   }
760 |   else {
761 |     std::stringstream error;
762 |     error << "Error: " << LT(1) << LT(2);
763 |     throw error.str();
764 |   }
765 | }
766 | void DnParser::_Const() {
767 |   if(SPECULATE( match(DnLexer::INTCONST); )()) {
768 |     ADD_TOKEN(DnLexer::INTCONST, LT(1).text);
769 |     match(DnLexer::INTCONST);
770 |   }
771 |   else if(SPECULATE( match(DnLexer::CHARCONST); )()) {
772 |     ADD_TOKEN(DnLexer::CHARCONST, LT(1).text);
773 |     match(DnLexer::CHARCONST);
774 |   }
775 |   else if(SPECULATE( match(DnLexer::FLOATCONST); )()) {
776 |     ADD_TOKEN(DnLexer::FLOATCONST, LT(1).text);
777 |     match(DnLexer::FLOATCONST);
778 |   }
779 |   else {
780 |     std::stringstream error;
781 |     error << "Error: " << LT(1) << LT(2);
782 |     throw error.str();
783 |   }
784 | }
785 | void DnParser::TranslationUnit() { DEFINE_MEMO(TranslationUnit,TranslationUnit();) }
786 | void DnParser::ExternalDecl() { DEFINE_MEMO(ExternalDecl,ExternalDecl();) }
787 | void DnParser::FunctionDef() { DEFINE_MEMO(FunctionDef,FunctionDef();) }
788 | void DnParser::Decl() { DEFINE_MEMO(Decl,Decl();) }
789 | void DnParser::DeclList() { DEFINE_MEMO(DeclList,DeclList();) }
790 | void DnParser::DeclSpecs() { DEFINE_MEMO(DeclSpecs,DeclSpecs();) }
791 | void DnParser::FuncSpec() { DEFINE_MEMO(FuncSpec,FuncSpec();) }
792 | void DnParser::TypeSpec() { DEFINE_MEMO(TypeSpec,TypeSpec();) }
793 | void DnParser::InitDeclList() { DEFINE_MEMO(InitDeclList,InitDeclList();) }
794 | void DnParser::InitDecl() { DEFINE_MEMO(InitDecl,InitDecl();) }
795 | void DnParser::Declarator() { DEFINE_MEMO(Declarator,Declarator();) }
796 | void DnParser::IdList() { DEFINE_MEMO(IdList,IdList();) }
797 | void DnParser::Initializer() { DEFINE_MEMO(Initializer,Initializer();) }
798 | void DnParser::Stat() { DEFINE_MEMO(Stat,Stat();) }
799 | void DnParser::ExpStat() { DEFINE_MEMO(ExpStat,ExpStat();) }
800 | void DnParser::CompoundStat() { DEFINE_MEMO(CompoundStat,CompoundStat();) }
801 | void DnParser::StatList() { DEFINE_MEMO(StatList,StatList();) }
802 | void DnParser::SelectionStat() { DEFINE_MEMO(SelectionStat,SelectionStat();) }
803 | void DnParser::IterationStat() { DEFINE_MEMO(IterationStat,IterationStat();) }
804 | void DnParser::JumpStat() { DEFINE_MEMO(JumpStat,JumpStat();) }
805 | void DnParser::Exp() { DEFINE_MEMO(Exp,Exp();) }
806 | void DnParser::AssignExp() { DEFINE_MEMO(AssignExp,AssignExp();) }
807 | void DnParser::AssignOperator() { DEFINE_MEMO(AssignOperator,AssignOperator();) }
808 | void DnParser::ConditionalExp() { DEFINE_MEMO(ConditionalExp,ConditionalExp();) }
809 | void DnParser::LogicalOrExp() { DEFINE_MEMO(LogicalOrExp,LogicalOrExp();) }
810 | void DnParser::LogicalAndExp() { DEFINE_MEMO(LogicalAndExp,LogicalAndExp();) }
811 | void DnParser::InclusiveOrExp() { DEFINE_MEMO(InclusiveOrExp,InclusiveOrExp();) }
812 | void DnParser::ExclusiveOrExp() { DEFINE_MEMO(ExclusiveOrExp,ExclusiveOrExp();) }
813 | void DnParser::AndExp() { DEFINE_MEMO(AndExp,AndExp();) }
814 | void DnParser::EqualityExp() { DEFINE_MEMO(EqualityExp,EqualityExp();) }
815 | void DnParser::RelationalExp() { DEFINE_MEMO(RelationalExp,RelationalExp();) }
816 | void DnParser::ShiftExp() { DEFINE_MEMO(ShiftExp,ShiftExp();) }
817 | void DnParser::AdditiveExp() { DEFINE_MEMO(AdditiveExp,AdditiveExp();) }
818 | void DnParser::MultExp() { DEFINE_MEMO(MultExp,MultExp();) }
819 | void DnParser::UnaryExp() { DEFINE_MEMO(UnaryExp,UnaryExp();) }
820 | void DnParser::UnaryOperator() { DEFINE_MEMO(UnaryOperator,UnaryOperator();) }
821 | void DnParser::PostfixExp() { DEFINE_MEMO(PostfixExp,PostfixExp();) }
822 | void DnParser::PrimaryExp() { DEFINE_MEMO(PrimaryExp,PrimaryExp();) }
823 | void DnParser::ArgumentExpList() { DEFINE_MEMO(ArgumentExpList,ArgumentExpList();) }
824 | void DnParser::Const() { DEFINE_MEMO(Const,Const();) }
825 | }
826 | 


--------------------------------------------------------------------------------
/Dnlang/Dnlang.bnf:
--------------------------------------------------------------------------------
  1 | <translation_unit>  ::=    <external_decl> <translation_unit>
  2 |                       |    <external_decl> 
  3 | <external_decl>     ::=    <function_def>
  4 |                       |    <decl>
  5 | <function_def>      ::=    <decl_specs> <declarator> <compound_stat>
  6 | <decl>              ::=    <decl_specs> <init_decl> ";"
  7 | <decl_list>         ::=    <decl> <decl_list>
  8 |                       |    <decl> 
  9 | <decl_specs>        ::=    <func_spec>
 10 |                       |    <type_spec> 
 11 | <func_spec>         ::=    "function"
 12 | <type_spec>         ::=    "let"
 13 | <init_decl>         ::=    <declarator> "=" <initializer>
 14 |                       |    <declarator> 
 15 | <declarator>        ::=    <id> "(" <id_list> ")"
 16 |                       |    <id> "("           ")"
 17 |                       |    <id> "["<int_const>"]"
 18 | 		      |    <id>
 19 | <id_list>           ::=    <id> "," <id_list>
 20 |                       |    <id>
 21 | <initializer>       ::=    <assign_exp>
 22 | <stat>              ::=    <exp_stat>
 23 |                       |    <compound_stat>
 24 |                       |    <selection_stat>
 25 |                       |    <iteration_stat>
 26 |                       |    <jump_stat>
 27 | <exp_stat>          ::=    <exp> ";"
 28 |                       |          ";"
 29 | <compound_stat>     ::=    "{"                         "}"
 30 |                       |    "{" <decl_list>             "}"
 31 |                       |    "{"             <stat_list> "}"
 32 | 		      |	   "{" <decl_list> <stat_list> "}"
 33 | <stat_list>         ::=    <stat> <stat_list>
 34 |                       |    <stat>
 35 | <selection_stat>    ::=    "if" "(" <exp> ")" <stat> "else" <stat>
 36 |                       |    "if" "(" <exp> ")" <stat>
 37 | <iteration_stat>    ::=    "while" "(" <exp> ")" <stat>
 38 |                       |    "for" "(" <exp> ";" <exp> ";" <exp> ")" <stat>
 39 | <jump_stat>         ::=    "continue" ";"
 40 |                       |    "break" ";"
 41 |                       |    "return" <exp> ";"
 42 |                       |    "return" ";"
 43 | <exp>               ::=    <assign_exp> "," <exp>
 44 |                       |    <assign_exp>    
 45 | <assign_exp>        ::=    <unary_exp> <assign_operator> <assign_exp>
 46 | 		      |    <conditional_exp>
 47 | <assign_operator>   ::=    "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "&=" | "|=" | "^="
 48 | <conditional_exp>   ::=    <logical_or_exp>
 49 | <logical_or_exp>    ::=    <logical_and_exp>
 50 |                       |    <logical_and_exp> "||" <logical_or_exp>
 51 | <logical_and_exp>   ::=    <inclusive_or_exp> "&&" <logical_and_exp>
 52 |                       |    <inclusive_or_exp>
 53 | <inclusive_or_exp>  ::=    <exclusive_or_exp> "|" <inclusive_or_exp>
 54 |                       |    <exclusive_or_exp>
 55 | <exclusive_or_exp>  ::=    <and_exp> "^" <exclusive_or_exp>
 56 |                       |    <and_exp>
 57 | <and_exp>           ::=    <equality_exp> "&" <and_exp>
 58 |                       |    <equality_exp>
 59 | <equality_exp>      ::=    <relational_exp> "==" <equality_exp>
 60 |                       |    <relational_exp> "!=" <equality_exp>
 61 |                       |    <relational_exp>
 62 | <relational_exp>    ::=    <shift_exp> "<" <relational_exp>
 63 |                       |    <shift_exp> ">" <relational_exp>
 64 |                       |    <shift_exp> "<=" <relational_exp>
 65 |                       |    <shift_exp> ">=" <relational_exp>
 66 |                       |    <shift_exp>
 67 | <shift_exp>         ::=    <additive_exp> "<<" <shift_exp>
 68 |                       |    <additive_exp> ">>" <shift_exp>
 69 |                       |    <additive_exp>
 70 | <additive_exp>      ::=    <mult_exp> "+" <additive_exp>
 71 |                       |    <mult_exp> "-" <additive_exp>
 72 |                       |    <mult_exp>
 73 | <mult_exp>          ::=    <unary_exp> "*" <mult_exp>
 74 |                       |    <unary_exp> "/" <mult_exp>
 75 |                       |    <unary_exp> "%" <mult_exp>
 76 |                       |    <unary_exp>
 77 | <unary_exp>         ::=    <postfix_exp>
 78 |                       |    "++" <unary_exp>
 79 |                       |    "--" <unary_exp>
 80 |                       |    <unary_operator> <unary_exp>
 81 | <unary_operator>    ::=    "+" | "-" | "!"
 82 | <postfix_exp>       ::=    <primary_exp> "[" <exp> "]"
 83 |                       |    <primary_exp> "(" <argument_exp_list> ")"
 84 |                       |    <primary_exp> "("  ")"
 85 |                       |    <primary_exp>
 86 | <primary_exp>       ::=    <id>
 87 |                       |    <const>
 88 |                       |    <string>
 89 |                       |    "(" <exp> ")"
 90 | <argument_exp_list> ::=    <assign_exp> "," <argument_exp_list>
 91 |                       |    <assign_exp>
 92 | <const>             ::=    <int_const>
 93 |                       |    <char_const>
 94 |                       |    <float_const>
 95 | 
 96 | D                   ::=    [0-9]          //Decimal
 97 | L                   ::=    [a-zA-Z_]      //Literal
 98 | H                   ::=    [a-fA-F0-9]    //Hexadecimal
 99 | <int_const>         ::=    {D}+
100 | <char_const>        ::=    \'({L}|{D})\'
101 | <float_const>       ::=    {D}+"."{D}
102 | <string>            ::=    \"{L}({L}|{D})*\"
103 | <id>                ::=    {L}({L}|{D})*
104 | 


--------------------------------------------------------------------------------
/Dnlang/IR/3_addr.syntax:
--------------------------------------------------------------------------------
 1 | ## 3_address code
 2 | 
 3 | ## LL(1) pre-read 1 words from head to determine a statement.
 4 | stat		head
 5 | <assign>	<addr>
 6 | <jump>		'goto'
 7 | <cond_jump>	'if'
 8 | <param>		'param'
 9 | <call_func>	'call'
10 | <ret>		'ret'
11 | 
12 | <3_addr>    ::=   <assign> | <jump> | <cond_jump> | <call_func>
13 | 
14 | # assign = l op r
15 | <assign>    ::=   <l-val> '=' <r-val>
16 | <l-val>     ::=   <addr>
17 | <r-val>     ::=   <operation>
18 |             
19 | # x = y op z, x = op y, x = y
20 | <operation> ::=   <addr> <arth> <addr>
21 | 	    |	  <addr> <arth> <decimal>
22 |             |     <addr>
23 | <arth>      ::=   '+' | '-' | '*' | '/' | '%'
24 | 
25 | # goto L
26 | <jump>      ::=   'goto' <label>
27 | 
28 | # if t < v goto L
29 | <cond_jump> ::=   'if' <cond> 'goto' <label>
30 | <cond>      ::=   <addr> <rel> <addr>
31 | <rel>       ::=   '<' | '<=' | '>' | '>=' | '=='
32 | 
33 | # param x_1
34 | # param x_2
35 | # call  func, 2
36 | <param>     ::=   'param' <addr>
37 | <call_func> ::=	  'call' <label> <decimal>
38 | 
39 | <ret>	    ::=	  'ret'
40 | 	    |	  'ret' <addr>
41 | 


--------------------------------------------------------------------------------
/Dnlang/IR/AST.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <sstream>
 3 | #include <string>
 4 | #include <vector>
 5 | #include <map>
 6 | #include "Token.hpp"
 7 | #include "Lexer.hpp"
 8 | #include "DnLexer.hpp"
 9 | #include "Token.hpp"
10 | #include "Symbol.hpp"
11 | #include "Scope.hpp"
12 | #include "Register.hpp"
13 | #include "AST.hpp"
14 | #include "Symbols.hpp"
15 | 
16 | namespace Dnlang {
17 | 
18 | std::string AST::toString() {
19 |   if(symbol) return symbol->toString();
20 |   if(scope) return scope->getScopeName();
21 |   return !isNil()?token.toString():"nil";
22 | }
23 | 
24 | std::string AST::toStringTree(int depth) {
25 |   if(children.size() == 0) {
26 |     //std::string pstr = "[" + this->parent->toString() + "]";
27 |     return this->toString();
28 |   }
29 |   //if(children.size() == 0) return this->toString();
30 |   std::string buf;
31 |   if(!isNil()) {
32 |     if(token.text == "") {
33 |       std::string align(depth - 1, '\t');
34 |       buf += "\n";
35 |       buf += align;
36 |     }
37 |     buf += "(";
38 |     //buf += "[" + this->parent->toString() + "]";
39 |     buf += this->toString();
40 |     buf += " ";
41 |   }
42 |   //std::cout << "<buf>" << buf << std::endl;
43 |   for(int i = 0; i < children.size(); i++) {
44 |     AST *t = children[i];
45 |     if(i > 0) buf += " ";
46 |     buf += t->toStringTree(depth + 1);
47 |   }
48 |   if(!isNil()) buf += ")";
49 |   //std::cout << "</buf>" << buf << std::endl;
50 |   return buf;
51 | }
52 | 
53 | std::string AST::getRegId() {
54 |   if(this->getNodeType() == DnLexer::AREF) {
55 |     return this->children[0]->reg->getId() + "[ " + this->reg->getId() + " ]";
56 |   }
57 |   return reg->getId();
58 | }
59 | 
60 | }
61 | 


--------------------------------------------------------------------------------
/Dnlang/IR/AST.syntax:
--------------------------------------------------------------------------------
  1 | ## AST
  2 | <function_def>
  3 | (FUNC_DEF
  4 | 	id 		# <id>
  5 | 	(PARAM id id..) # <id_list>
  6 | 	(BLOCK ...)	# <compound_stat>
  7 | )
  8 | <decl>
  9 | (DECL
 10 | 	id		# <id>
 11 | 	(+ x y)		# <exp>
 12 | )
 13 | <compound_stat>
 14 | (BLOCK
 15 | 	(DECL ...)	# <decl>
 16 | 	(DECL ...)	# <decl>
 17 | 	(IF ...)	# <selection_stat>
 18 | 	(WHILE ...)	# <iteration_stat>
 19 | 	(FOR ...)	# <iteration_stat>
 20 | 	(CONTINUE) 	# <jump_stat>
 21 | 	(BREAK) 	# <jump_stat>
 22 | 	(RETURN ...) 	# <jump_stat>
 23 | 	(= (+ (|| (&& x y) (&& y z)) 3)...) # <exp>
 24 | 	(BLOCK ...)	# <compound_stat>
 25 | )
 26 | <selection_stat>
 27 | (IF
 28 | 	(<= x y) 	# <exp>
 29 | 	(BLOCK ...) 	# <stat>
 30 | 	(++ x) 		# <stat>
 31 | )
 32 | 
 33 | <iteration_stat>
 34 | (WHILE
 35 | 	(<= x y) 	# <exp>
 36 | 	(BLOCK ...) 	# <stat>
 37 | )
 38 | (FOR
 39 | 	(= x 0) 	# <exp>
 40 | 	(<= x y) 	# <exp>
 41 | 	(++ x) 		# <exp>
 42 | 	(BLOCK ...) 	# <stat>
 43 | )
 44 | 
 45 | <jump_stat>
 46 | (RETURN
 47 | 	(++ x) 		# <exp>
 48 | )
 49 | (RETURN)
 50 | (BREAK)
 51 | (CONTINUE)
 52 | 
 53 | <postfix_exp>
 54 | (AREF
 55 | 	id 		# <id>
 56 | 	exp		# <exp>
 57 | ) # id[exp]
 58 | (CALL
 59 | 	id		# <id>
 60 | 	arg1 
 61 | 	arg2
 62 | 	...
 63 | )
 64 | 
 65 | <assign_exp> 
 66 | (ASSIGN
 67 | 	(++ x)		# <unary_exp>
 68 | 	+=		# <assign_operator>
 69 | 	(|| (* x y) z)  # <conditional_exp>
 70 | )
 71 | 
 72 | <logical_or_exp>
 73 | (|| x y)
 74 | <logical_and_exp>
 75 | (&& x y)
 76 | <inclusive_or_exp>
 77 | (| x y)
 78 | <exclusive_or_exp>
 79 | (^ x y)
 80 | <and_exp>
 81 | (& x y)
 82 | <equality_exp>
 83 | (== x y)
 84 | (!= x y)
 85 | <relational_exp>
 86 | (< x y)
 87 | (> x y)
 88 | (<= x y)
 89 | (>= x y)
 90 | <shift_exp>
 91 | (<< x y)
 92 | (>> x y)
 93 | <additive_exp>
 94 | (+ x y)
 95 | (- x y)
 96 | <mult_exp>
 97 | (* x y)
 98 | (/ x y)
 99 | (% x y)
100 | <unary_exp>
101 | (++ x)
102 | (-- x)
103 | (+ x)
104 | (- x)
105 | (! x)
106 | 


--------------------------------------------------------------------------------
/Dnlang/IR/ASTVisitor.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <sstream>
  3 | #include <string>
  4 | #include <vector>
  5 | #include <map>
  6 | #include <boost/format.hpp>
  7 | #include "Token.hpp"
  8 | #include "Lexer.hpp"
  9 | #include "DnLexer.hpp"
 10 | #include "Symbol.hpp"
 11 | #include "Scope.hpp"
 12 | #include "Symbols.hpp"
 13 | #include "Register.hpp"
 14 | #include "AST.hpp"
 15 | #include "ASTVisitor.hpp"
 16 | 
 17 | namespace Dnlang {
 18 | 
 19 | void ASTVisitor::downup(AST *root) {
 20 |   enter(root);
 21 |   for(int i = 0; i < root->children.size(); i++) {
 22 |     AST *t = root->children[i];
 23 |     downup(t);
 24 |   }
 25 |   exit(root);
 26 | }
 27 | 
 28 | void ASTVisitor::enter(AST *t) {
 29 |   std::cout<<"[ENTER]"<<t->token<<std::endl;
 30 |   if(t->getNodeType() == -1) {
 31 |     /* Root */
 32 |     enterRoot(t);
 33 |   }
 34 |   else if(t->getNodeType() == DnLexer::BLOCK) {
 35 |     enterBlock(t);
 36 |   }
 37 |   else if(t->getNodeType() == DnLexer::FUNC_DEF) {
 38 |     enterMethod(t);
 39 |   }
 40 |   else if(t->getNodeType() == DnLexer::ID) {
 41 |     enterId(t);
 42 |   }
 43 |   else if(t->getNodeType() == DnLexer::DECL) {
 44 |     enterDecl(t);
 45 |   }
 46 |   else if(t->getNodeType() == DnLexer::CALL) {
 47 |     enterCall(t);
 48 |   }
 49 |   else if(t->getNodeType() == DnLexer::RETURN) {
 50 |     enterReturn(t);
 51 |   }
 52 |   else if(t->getNodeType() == DnLexer::IF) {
 53 |     enterIf(t);
 54 |   }
 55 |   else if(t->getNodeType() == DnLexer::WHILE) {
 56 |     enterWhile(t);
 57 |   }
 58 |   else if(t->getNodeType() == DnLexer::ASSIGN) {
 59 |     enterAssign(t);
 60 |   }
 61 |   else if(t->getNodeType() == DnLexer::AREF) {
 62 |     enterAref(t);
 63 |   }
 64 |   else if(t->getNodeType() == DnLexer::OROR) {
 65 |     enterOror(t);
 66 |   }
 67 |   else if(t->getNodeType() == DnLexer::ANDAND) {
 68 |     enterAndand(t);
 69 |   }
 70 |   else if(t->getNodeType() == DnLexer::NOT) {
 71 |     enterNot(t);
 72 |   }
 73 |   else if(isRel(t->getNodeType())) {
 74 |     enterRel(t);
 75 |   }
 76 |   else if(isConst(t->getNodeType())) {
 77 |     enterConst(t);
 78 |   }
 79 |   else if(isExp(t->getNodeType())) {
 80 |     enterExp(t);
 81 |   }
 82 | }
 83 | 
 84 | void ASTVisitor::exit(AST *t) {
 85 |   std::cout<<"[EXIT]"<<t->token<<std::endl;
 86 |   if(t->getNodeType() == -1) {
 87 |     /* Root */
 88 |     exitRoot(t);
 89 |   }
 90 |   else if(t->getNodeType() == DnLexer::BLOCK) {
 91 |     exitBlock(t);
 92 |   }
 93 |   else if(t->getNodeType() == DnLexer::FUNC_DEF) {
 94 |     exitMethod(t);
 95 |   }
 96 |   else if(t->getNodeType() == DnLexer::ID) {
 97 |     exitId(t);
 98 |   }
 99 |   else if(t->getNodeType() == DnLexer::DECL) {
100 |     exitDecl(t);
101 |   }
102 |   else if(t->getNodeType() == DnLexer::CALL) {
103 |     exitCall(t);
104 |   }
105 |   else if(t->getNodeType() == DnLexer::RETURN) {
106 |     exitReturn(t);
107 |   }
108 |   else if(t->getNodeType() == DnLexer::IF) {
109 |     exitIf(t);
110 |   }
111 |   else if(t->getNodeType() == DnLexer::WHILE) {
112 |     exitWhile(t);
113 |   }
114 |   else if(t->getNodeType() == DnLexer::ASSIGN) {
115 |     exitAssign(t);
116 |   }
117 |   else if(t->getNodeType() == DnLexer::AREF) {
118 |     exitAref(t);
119 |   }
120 |   else if(t->getNodeType() == DnLexer::OROR) {
121 |     exitOror(t);
122 |   }
123 |   else if(t->getNodeType() == DnLexer::ANDAND) {
124 |     exitAndand(t);
125 |   }
126 |   else if(t->getNodeType() == DnLexer::NOT) {
127 |     exitNot(t);
128 |   }
129 |   else if(isRel(t->getNodeType())) {
130 |     exitRel(t);
131 |   }
132 |   else if(isConst(t->getNodeType())) {
133 |     exitConst(t);
134 |   }
135 |   else if(isExp(t->getNodeType())) {
136 |     exitExp(t);
137 |   }
138 | }
139 | void ASTVisitor::enterRoot(AST *root) {}
140 | void ASTVisitor::exitRoot(AST *root) {}
141 | void ASTVisitor::enterBlock(AST *block) {}
142 | void ASTVisitor::exitBlock(AST *block) {}
143 | void ASTVisitor::enterId(AST *id) {}
144 | void ASTVisitor::exitId(AST *id) {}
145 | void ASTVisitor::enterMethod(AST *method) {}
146 | void ASTVisitor::exitMethod(AST *method) {}
147 | void ASTVisitor::enterAssign(AST *assign) {}
148 | void ASTVisitor::exitAssign(AST *assign) {}
149 | void ASTVisitor::enterWhile(AST *loop) {}
150 | void ASTVisitor::exitWhile(AST *loop) {}
151 | void ASTVisitor::enterIf(AST *cond) {}
152 | void ASTVisitor::exitIf(AST *cond) {}
153 | void ASTVisitor::enterOror(AST *oror) {}
154 | void ASTVisitor::exitOror(AST *oror) {}
155 | void ASTVisitor::enterAndand(AST *andand) {}
156 | void ASTVisitor::exitAndand(AST *andand) {}
157 | void ASTVisitor::enterNot(AST *_not) {}
158 | void ASTVisitor::exitNot(AST *_not) {}
159 | void ASTVisitor::enterRel(AST *rel) {}
160 | void ASTVisitor::exitRel(AST *rel) {}
161 | void ASTVisitor::enterDecl(AST *decl) {}
162 | void ASTVisitor::exitDecl(AST *decl) {}
163 | void ASTVisitor::enterReturn(AST *ret) {}
164 | void ASTVisitor::exitReturn(AST *ret) {}
165 | void ASTVisitor::enterAref(AST *aref) {}
166 | void ASTVisitor::exitAref(AST *aref) {}
167 | void ASTVisitor::enterCall(AST *call) {}
168 | void ASTVisitor::exitCall(AST *call) {}
169 | void ASTVisitor::enterExp(AST *exp) {}
170 | void ASTVisitor::exitExp(AST *exp) {}
171 | void ASTVisitor::enterConst(AST *_const) {}
172 | void ASTVisitor::exitConst(AST *_const) {}
173 | bool ASTVisitor::isExp(int type) {
174 |   return DnLexer::OROR <= type && type <= DnLexer::ABOVEEQUAL;
175 | }
176 | bool ASTVisitor::isConst(int type) {
177 |   return DnLexer::INTCONST <= type && type <= DnLexer::STRING;
178 | }
179 | bool ASTVisitor::isAssign(int type) {
180 |   return DnLexer::MULASSIGN <= type && type <= DnLexer::EQUAL;
181 | }
182 | bool ASTVisitor::isRel(int type) {
183 |   return DnLexer::LESSLESS <= type && type <= DnLexer::ABOVEEQUAL;
184 | }
185 | void Semantics::enterBlock(AST *block) {
186 |   currentScope = new LocalScope("LocalScope", currentScope);
187 | }
188 | 
189 | void Semantics::exitBlock(AST *block) {
190 |   /* If BLOCK is nested, the evalType of this BLOCK is propageted to parent. */
191 |   if(block->parent->getNodeType() == DnLexer::BLOCK)
192 |     block->parent->evalType = block->evalType;
193 |   //std::cout<<"[exitBlock]"<<currentScope->scopeName<<std::endl;
194 |   currentScope = currentScope->getEnclosingScope();
195 | }
196 | 
197 | void Semantics::enterMethod(AST *method) {
198 |   std::string MethodName = method->children[0]->getNodeText();
199 |   AST *param = method->children[1];
200 |   //std::cout<<"[enterMethod]"<<currentScope->scopeName<<std::endl;
201 |   MethodSymbol *ms = new MethodSymbol(MethodName, currentScope);
202 |   currentScope->define(*ms);
203 |   currentScope = ms;
204 |   for(int i = 0; i < param->children.size(); i++) {
205 |     std::string arg = param->children[i]->getNodeText();
206 |     currentScope->define(Symbol(arg, Type()));
207 |   }
208 | }
209 | 
210 | void Semantics::exitMethod(AST *method) {
211 |   std::string MethodName = method->children[0]->getNodeText();
212 |   AST *block = method->children[1];
213 |   method->symbol = new Symbol(MethodName, block->evalType);
214 |   currentScope = currentScope->getEnclosingScope();
215 |   //std::cout<<"[exitMethod]"<<currentScope->scopeName<<std::endl;
216 | }
217 | 
218 | void Semantics::exitDecl(AST *decl) {
219 |   /* Define new symbol */
220 |   AST *id = decl->children[0];
221 |   AST *exp = decl->children[1];
222 |   //std::cout<<"[DEFINE]"<<id->getNodeText()<<","<<exp->evalType.toString()<<std::endl;
223 |   id->symbol = new Symbol(id->getNodeText(), exp->evalType);
224 |   currentScope->define(*id->symbol);
225 | }
226 | 
227 | void Semantics::exitReturn(AST *ret) {
228 |   if(ret->children.empty()) {
229 |     ret->evalType = Type::VOID;
230 |     return;
231 |   }
232 |   AST *exp = ret->children[0];
233 |   ret->evalType = exp->evalType;
234 |   /* The parent of RETURN node must be always BLOCK. */
235 |   ret->parent->evalType = exp->evalType;
236 | }
237 | 
238 | void Semantics::exitAref(AST *aref) {
239 |   aref->evalType = aref->children[0]->evalType;
240 | }
241 | 
242 | void Semantics::exitCall(AST *call) {
243 |   AST *id = call->children[0];
244 |   Symbol *func = currentScope->resolve(id->getNodeText());
245 |   call->evalType = func->type;
246 | }
247 | 
248 | void Semantics::enterId(AST *id) {
249 |   if(id->parent->getNodeType() == DnLexer::DECL ||
250 |      id->parent->getNodeType() == DnLexer::FUNC_DEF ) return;
251 |   /* Not definition but reference */
252 |   Symbol *sym = currentScope->resolve(id->getNodeText());
253 |   if(!sym) throw (boost::format("%s is not declared") % id->getNodeText()).str();
254 |   id->symbol = sym;
255 |   id->evalType = sym->type;
256 | }
257 | 
258 | void Semantics::exitExp(AST *exp) {
259 |   /* Are all types of sub-expressions are same? */
260 |   unsigned long long flag = 0LL;
261 |   for(int i = 0; i < exp->children.size(); i++) {
262 |     AST *child = exp->children[i];
263 |     unsigned long long tflag = (1 << child->evalType.type);
264 |     flag |= tflag;
265 |     /* If different type exists, flag has already different tflag. */
266 |     //if(flag & ~tflag) throw (boost::format("[ERROR] type confusion")).str();
267 |   }
268 |   exp->evalType = exp->children[0]->evalType;
269 | }
270 | 
271 | void Semantics::enterConst(AST *_const) {
272 |   if(_const->getNodeType() == DnLexer::INTCONST) _const->evalType = Type::INT;
273 |   else if(_const->getNodeType() == DnLexer::CHARCONST) _const->evalType = Type::CHAR;
274 |   else if(_const->getNodeType() == DnLexer::FLOATCONST) _const->evalType = Type::FLOAT;
275 |   else if(_const->getNodeType() == DnLexer::STRING) _const->evalType = Type::STRING;
276 | }
277 | 
278 | void Semantics::exitAssign(AST *assign) {
279 |   assign->children[0]->evalType = assign->children[2]->evalType;
280 |   assign->evalType = assign->children[0]->evalType;
281 | }
282 | 
283 | CodeGen::CodeGen(AST *root) : ASTVisitor(root), reg_index(1), label_index(0) {
284 |   r0 = new Register("r0");
285 | }
286 | 
287 | void CodeGen::exitRoot(AST *root) {
288 |   root->code = "_Init:\n";
289 |   joinCodes(root);
290 | }
291 | 
292 | void CodeGen::exitBlock(AST *block) {
293 |   joinCodes(block);
294 |   //std::cout<<block->code;
295 | }
296 | 
297 | void CodeGen::exitId(AST *id) {
298 |   id->reg = new Register(id->getNodeText());
299 |   id->code = "";
300 | }
301 | 
302 | void CodeGen::exitMethod(AST *method) {
303 |   method->code = method->children[0]->getNodeText() + ":\n";
304 |   joinCodes(method);
305 | }
306 | 
307 | void CodeGen::exitDecl(AST *decl) {
308 |   AST *left = decl->children[0];
309 |   AST *right = decl->children[1];
310 |   decl->code = left->code + right->code;
311 |   // if (left->getNodeType() == DnLexer::AREF) {
312 |   //   /* 1. array[index] = right */
313 |   //   std::string array_id = left->children[0]->getNodeText();
314 |   //   decl->code += array_id + " [ " + left->getRegId() + " ] " + " = " +
315 |   //                  right->getRegId() + "\n";
316 |   // }
317 |   // else if (right->getNodeType() == DnLexer::AREF) {
318 |   //   /* 2. left = array[index] */
319 |   //   std::string array_id = right->children[1]->getNodeText();
320 |   //   decl->code += left->reg->getId() + " = " + array_id + " [ " + right->reg->getId() + " ] " + "\n";
321 |   // }
322 |   {
323 |     /* 3. left = right */
324 |     decl->code += left->getRegId() + " = " + right->getRegId() + "\n";
325 |   }
326 | }
327 | void CodeGen::exitReturn(AST *ret) {
328 |   if(ret->children.empty()) ret->code = "ret\n";
329 |   else {
330 |     AST *val = ret->children[0];
331 |     ret->code += val->code;
332 |     ret->code += "ret " + val->getRegId() + "\n";
333 |   }
334 | }
335 | void CodeGen::exitAref(AST *aref) {
336 |   /* id [E]   <--->   E * sizeof(id) */
337 |   AST *id = aref->children[0];
338 |   AST *exp = aref->children[1];
339 |   aref->reg = genReg();
340 |   std::stringstream ss;
341 |   ss << exp->code;
342 |   ss << aref->reg->getId() + " = " + exp->reg->getId() + " * "  << "4";//aref->evalType.getSize();
343 |   aref->code = ss.str() + "\n";
344 |   //std::cout<< aref->code << std::endl;
345 | }
346 | 
347 | void CodeGen::exitCall(AST *call) {
348 |   /* TODO: Now, ids are only allowed for arguments.
349 |            Support nested expression in argument. */
350 |   std::string f_name = call->children[0]->getNodeText();
351 |   for(int i = 1; i < call->children.size(); i++) {
352 |     AST *arg = call->children[i];
353 |     call->code += arg->code;
354 |   }
355 |   for(int i = 1; i < call->children.size(); i++) {
356 |     AST *arg = call->children[i];
357 |     call->code += "param " + arg->getRegId() + "\n";
358 |   }
359 |   call->reg = genReg();
360 |   std::stringstream ss;
361 |   ss << "call " + f_name + " " << call->children.size() - 1 << "\n";
362 |   ss << call->getRegId() << " = " << getRetReg()->getId() << "\n";
363 |   call->code += ss.str();
364 | }
365 | 
366 | void CodeGen::exitExp(AST *exp) {
367 |   /* XXX: Proceed both expression unary and binary. */
368 |   exp->reg = genReg();
369 |   for(int i = 0; i < exp->children.size(); i++) {
370 |     AST *child = exp->children[i];
371 |     exp->code += child->code;
372 |   }
373 |   if(exp->children.size() <= 1) {//unary expression
374 |     if (exp->getNodeType() == DnLexer::PLUSPLUS) {
375 |       exp->code += exp->children[0]->getRegId() + " = " + exp->children[0]->getRegId() + " + 1\n";
376 |     } else if (exp->getNodeType() == DnLexer::MINUSMINUS) {
377 |       exp->code += exp->children[0]->getRegId() + " = " + exp->children[0]->getRegId() + " - 1\n";
378 |     }
379 |     exp->code += exp->getRegId() + " = " + exp->children[0]->getRegId() + "\n";
380 |   } else {                         // binary expression
381 |     exp->code += exp->getRegId() + " = " + exp->children[0]->getRegId() +
382 |                  " " + exp->getNodeText() + " " + exp->children[1]->getRegId() + "\n";
383 |   }
384 |   //std::cout << "exitExp\n" << exp->code <<std::endl;
385 | }
386 | 
387 | void CodeGen::exitConst(AST *_const) {
388 |   _const->reg = genReg();
389 |   _const->code = _const->getRegId() + " = " + _const->getNodeText() + "\n";
390 |   //std::cout << "exitConst\n" << _const->code <<std::endl;
391 | }
392 | 
393 | void CodeGen::exitAssign(AST *assign) {
394 |   AST *left = assign->children[0];
395 |   AST *right = assign->children[2];
396 |   std::string op = assign->children[1]->getNodeText();
397 |   assign->code = left->code + right->code;
398 |   // if (left->getNodeType() == DnLexer::AREF) {
399 |   //   /* 1. array[index] = right */
400 |   //   std::string array_id = left->children[0]->getNodeText();
401 |   //   assign->code += array_id + " [ " + left->reg->getId() + " ] " + " " + op + " " +
402 |   //                  right->reg->getId() + "\n";
403 |   // }
404 |   // else if (right->getNodeType() == DnLexer::AREF) {
405 |   //   /* 2. left = array[index] */
406 |   //   std::string array_id = right->children[0]->getNodeText();
407 |   //   assign->code += left->reg->getId() + " " + op + " " + array_id + " [ " + right->reg->getId() + " ] " + "\n";
408 |   // }
409 |   {
410 |     /* 3. left = right */
411 |     if (op.size() == 2) {
412 |       /* "*=" | "/=" | "%=" | "+=" | "-=" | "&=" | "|=" | "^=" */
413 |       std::string subop = op.substr(0,1);
414 |       assign->code += left->getRegId() + " = " + left->getRegId() + " " + subop + " " + right->getRegId() + "\n";
415 |     } else {
416 |       assign->code += left->getRegId() + " " + op + " " + right->getRegId() + "\n";
417 |     }
418 |   }
419 | }
420 | 
421 | void CodeGen::enterWhile(AST *loop) {
422 |   //AST *c_s = loop->children[0];
423 |   loop->_begin = genLabel();
424 |   genTfLabel(loop);
425 | }
426 | 
427 | void CodeGen::exitWhile(AST *loop) {
428 |   AST *c_s = loop->children[0];
429 |   AST *t_s = loop->children[1];
430 |   AST *next = loop->parent->children[loop->child_idx + 1];
431 |   loop->code = loop->_begin->getId() + ":\n" + c_s->code +
432 |                c_s->_true->getId() + ":\n" + t_s->code +
433 |                "goto " + loop->_begin->getId() + "\n" +
434 |                c_s->_false->getId() + ":\n";
435 |   //std::cout << "exitWhile\n" << loop->code <<std::endl;
436 | }
437 | 
438 | void CodeGen::enterIf(AST *cond) {
439 |   //AST *c_s = cond->children[0];
440 |   genTfLabel(cond);
441 | }
442 | 
443 | void CodeGen::exitIf(AST *cond) {
444 |   AST *c_s = cond->children[0];
445 |   AST *t_s = cond->children[1];
446 |   AST *next = cond->parent->children[cond->child_idx + 1];
447 |   Label *n_label = genLabel();
448 |   if (cond->children.size() == 3) {
449 |     /* if () {...} else() {...} */
450 |     AST *f_s = cond->children[2];
451 |     t_s->next = f_s->next = n_label;
452 |     cond->code = c_s->code +
453 |                  c_s->_true->getId() + ":\n" + t_s->code +
454 |                  "goto " + n_label->getId() + "\n" +
455 |                  c_s->_false->getId() + ":\n" +
456 |                  n_label->getId() + ":\n";
457 |   } else if (cond->children.size() == 2) {
458 |     /* if () {...} */
459 |     t_s->next = n_label;
460 |     cond->code = c_s->code +
461 |                  c_s->_true->getId() + ":\n" + t_s->code +
462 |                  "goto " + n_label->getId() + "\n" +
463 |                  c_s->_false->getId() + ":\n" +
464 |                  n_label->getId() + ":\n";
465 |   }
466 | }
467 | 
468 | void CodeGen::enterOror(AST *oror) {
469 |   //genTfLabel(oror);
470 |   oror->_true = oror->parent->_true;
471 |   oror->_false = oror->parent->_false;
472 | }
473 | 
474 | void CodeGen::exitOror(AST *oror) {
475 |   AST *left = oror->children[0];
476 |   AST *right = oror->children[1];
477 |   left->_true = genLabel();
478 |   right->_true = oror->_true;
479 |   right->_false = oror->_false;
480 |   oror->code = left->code  +
481 |                left->_false->getId() + ":\n" +
482 |                right->code;
483 | }
484 | 
485 | void CodeGen::enterAndand(AST *andand) {
486 |   //genTfLabel(andand);
487 |   andand->_true = andand->parent->_true;
488 |   andand->_false = andand->parent->_false;
489 | }
490 | 
491 | void CodeGen::exitAndand(AST *andand) {
492 |   AST *left = andand->children[0];
493 |   AST *right = andand->children[1];
494 |   left->_true = genLabel();
495 |   left->_false = andand->_false;
496 |   right->_true = andand->_true;
497 |   right->_false = andand->_false;
498 |   andand->code = left->code +
499 |                  left->_true->getId() + ":\n" +
500 |                  right->code;
501 | }
502 | 
503 | void CodeGen::enterNot(AST *_not) {
504 |   //genTfLabel(_not);
505 |   _not->_true = _not->parent->_true;
506 |   _not->_false = _not->parent->_false;
507 | 
508 | }
509 | 
510 | void CodeGen::exitNot(AST *_not) {
511 |   AST *stat = _not->children[0];
512 |   stat->_true = _not->_false;
513 |   stat->_false = _not->_true;
514 |   _not->code = stat->code;
515 | }
516 | 
517 | void CodeGen::enterRel(AST *rel) {
518 |   /* XXX: When enter a relation node, new label should be created only if
519 |           its parent isn't while nor if.
520 |           Because while and if statements have already created new labels when it's entered. */
521 |   // if (rel->parent->getNodeType() != DnLexer::WHILE && rel->parent->getNodeType() != DnLexer::IF) {
522 |   //   genTfLabel(rel);
523 |   // }
524 |   rel->_true = rel->parent->_true;
525 |   rel->_false = rel->parent->_false;
526 | }
527 | 
528 | void CodeGen::exitRel(AST *rel) {
529 |   AST *left = rel->children[0];
530 |   AST *right = rel->children[1];
531 |   rel->code = left->code +
532 |               right->code +
533 |               "if " + left->getRegId() + " " + rel->getNodeText() + " " + right->getRegId() + " " +
534 |               "goto " + rel->_true->getId() + "\n" +
535 |               "goto " + rel->_false->getId() + "\n";
536 | }
537 | 
538 | void CodeGen::genTfLabel(AST *tf) {
539 |   tf->_true = genLabel();
540 |   tf->_false = genLabel();
541 | }
542 | 
543 | void CodeGen::joinCodes(AST *parent) {
544 |   for(int i = 0; i < parent->children.size(); i++) {
545 |     AST *child = parent->children[i];
546 |     parent->code += child->code;
547 |   }
548 | }
549 | 
550 | Register *CodeGen::genReg() {
551 |   std::stringstream reg_id;
552 |   reg_id << "r" << reg_index;
553 |   reg_index++;
554 |   return new Register(reg_id.str());
555 | }
556 | 
557 | Label *CodeGen::genLabel() {
558 |   std::stringstream label_id;
559 |   label_id << "label" << label_index;
560 |   label_index++;
561 |   return new Label(label_id.str());
562 | }
563 | 
564 | }
565 | 


--------------------------------------------------------------------------------
/Dnlang/Lexer.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <boost/format.hpp>
 3 | #include "Token.hpp"
 4 | #include "Lexer.hpp"
 5 | 
 6 | const char Lexer::LEX_EOF = (char)-1;
 7 | Lexer::Lexer() {
 8 |   p = 0;
 9 | }
10 | Lexer::Lexer(std::string _input) : input(_input) {
11 |   p = 0;
12 |   c = input[p];
13 | }
14 | 
15 | void Lexer::consume() {
16 |   p++;
17 |   if(p >= input.size()) c = LEX_EOF;
18 |   else c = input[p];
19 | }
20 | 
21 | void Lexer::match(char x) {
22 |   if(c == x) consume();
23 |   else {
24 |     std::string error = (boost::format("expecting %c; found %c") % x % c).str();
25 |     throw error;
26 |   }
27 | }
28 | void Lexer::skipSpaces() {
29 |     while(c == ' ' || c == '\t' || c == '\n' || c == '\r') consume();
30 | }
31 | 
32 | bool Lexer::isLetter() {
33 |   return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
34 | }
35 | 
36 | bool Lexer::isDecimal() {
37 |   return '0' <= c && c <= '9';
38 | }
39 | 
40 | bool Lexer::isChar() {
41 |   return c == '\'' && (p + 2) < input.size() && input[p + 2] == '\'';
42 | }
43 | 
44 | bool Lexer::isSym() {
45 |   return c == '_' || c == '@' || c == '\\' || c == '.' || c == '/';
46 | }
47 | 
48 | bool Lexer::isFloat() {
49 |   return input.find(".") != std::string::npos;
50 | }
51 | 
52 | bool Lexer::isString() {
53 |   return c == '\"' && input.find("\"", p + 1) != std::string::npos;
54 | }
55 | 
56 | bool Lexer::isId() {
57 |   return isLetter() || isSym();
58 | }
59 | 


--------------------------------------------------------------------------------
/Dnlang/Parser.cpp:
--------------------------------------------------------------------------------
  1 | #include <string>
  2 | #include <boost/format.hpp>
  3 | #include <vector>
  4 | #include <map>
  5 | #include <iostream>
  6 | #include "Token.hpp"
  7 | #include "Lexer.hpp"
  8 | #include "DnLexer.hpp"
  9 | #include "Parser.hpp"
 10 | 
 11 | const int Parser::FAILED = -1;
 12 | 
 13 | Token Parser::LT(int i) {
 14 |   sync(i);
 15 |   //if (p + i - 1 >= lookahead.size()) return 0;
 16 |   //std::cout<<"lookahead:\n";
 17 |   //for (int i = 0; i < lookahead.size(); i++) std::cout<<lookahead[i]<<std::endl;
 18 |   return lookahead[p + i - 1];
 19 | }
 20 | 
 21 | int Parser::LA(int i) {
 22 |   return LT(i).type;
 23 | }
 24 | 
 25 | void Parser::match(int x) {
 26 |   // if(isSpeculating()) std::cout << "[SPEC]";
 27 |   // std::cout<< "["<< markers.size() <<"]";
 28 |   // std::cout<< "[::match] trying " << input->get_token_name(x)<<std::endl;
 29 |   if(LA(1) == x) consume();
 30 |   else {
 31 |     //std::cout<<"...MissMatched"<<std::endl;
 32 |     std::string error = (boost::format("expecting %s; ") % input->get_token_name(x) ).str();
 33 |     throw error;
 34 |   }
 35 | }
 36 | 
 37 | void Parser::sync(int i) {
 38 |   if(p + i - 1 > ((int)lookahead.size() - 1)) {
 39 |     int n = (p + i - 1) - ((int)lookahead.size() - 1);
 40 |     fill(n);
 41 |   }
 42 | }
 43 | 
 44 | void Parser::fill(int n) {
 45 |   //std::cout<<"fill"<<n<<std::endl;
 46 |   for(int i = 0; i < n; i++) { Token ne = input->nextToken(); lookahead.push_back(ne); }
 47 | }
 48 | 
 49 | void Parser::consume() {
 50 |   p++;
 51 |   if(p == lookahead.size() && !isSpeculating() ) {
 52 |     //std::cout<<"fin and clear\n";
 53 |     finished = true;
 54 |     p = 0;
 55 |     lookahead.clear();
 56 |   }
 57 |   sync(1);
 58 | }
 59 | 
 60 | int Parser::mark() {
 61 |   markers.push_back(p);
 62 |   return p;
 63 | }
 64 | 
 65 | void Parser::release() {
 66 |   int marker = markers[markers.size() - 1];
 67 |   markers.pop_back();
 68 |   seek(marker);
 69 | }
 70 | 
 71 | bool Parser::alreadyParsedRule(std::string rule) {
 72 |   std::map<int,int> memo = memos[rule];
 73 |   if(memo.find(index()) == memo.end()) return false;
 74 |   int memoI = memo[index()];
 75 |   if(memoI == FAILED) {
 76 |     std::string error = "Previous parse has already failed";
 77 |     throw error;
 78 |   }
 79 |   seek(memoI);
 80 |   return true;
 81 | }
 82 | 
 83 | void Parser::memorize(std::string rule, int startTokenIndex, bool failed) {
 84 |   int stopTokenIndex = failed ? FAILED : index();
 85 |   if(memos.find(rule) == memos.end()) memos[rule] = std::map<int,int>();
 86 |   memos[rule][startTokenIndex] = stopTokenIndex;
 87 | }
 88 | 
 89 | int Parser::index() {
 90 |   return p;
 91 | }
 92 | 
 93 | void Parser::seek(int index) {
 94 |   p = index;
 95 | }
 96 | 
 97 | bool Parser::isSpeculating() {
 98 |   return markers.size() > 0;
 99 | }
100 | 


--------------------------------------------------------------------------------
/Dnlang/Scope.cpp:
--------------------------------------------------------------------------------
 1 | #include <map>
 2 | #include <string>
 3 | #include "Symbol.hpp"
 4 | #include "Scope.hpp"
 5 | #include "Symbols.hpp"
 6 | 
 7 | #define DEF_API(name,type) new MethodSymbol(name,type,0)
 8 | namespace Dnlang {
 9 | 
10 | Symbol *Scope::resolve(std::string name) {
11 |   if(symbols.find(name) != symbols.end()) return &symbols[name];
12 |   if(parent != 0) {
13 |     return parent->resolve(name);
14 |   }
15 |   return 0;
16 | }
17 | GlobalScope::GlobalScope() : Scope("global", 0) {
18 |   for(int i = 0; apis[i] != 0; i++) {
19 |     /* Pre define apis. */
20 |     this->define(*apis[i]);
21 |   }
22 | }
23 | 
24 | MethodSymbol *GlobalScope::apis[GlobalScope::api_num] = {
25 |   DEF_API("LoadGraphic",Type::VOID), DEF_API("DeleteGraphic",Type::VOID),
26 |   DEF_API("SetTexture", Type::VOID), DEF_API("SetGraphicRect", Type::VOID),
27 |   DEF_API("SetGraphicPos", Type::VOID),  
28 |   DEF_API("SetGraphicAngle",Type::VOID), DEF_API("DrawGraphic", Type::VOID),
29 |   DEF_API("SetCollisionA",Type::VOID), DEF_API("SetInitialBombCount", Type::VOID),
30 |   DEF_API("SetGrazeCircle", Type::VOID), DEF_API("SetIntersectionCircle", Type::VOID),
31 |   DEF_API("SetSpeed", Type::VOID), DEF_API("SetLife", Type::VOID),
32 |   DEF_API("SetX", Type::VOID), DEF_API("SetY", Type::VOID),
33 |   DEF_API("GetPlayerX", Type::FLOAT), DEF_API("GetPlayerY", Type::FLOAT),
34 |   DEF_API("GetSpeedX", Type::FLOAT), DEF_API("GetSpeedY", Type::FLOAT),
35 |   DEF_API("GetX", Type::FLOAT), DEF_API("GetY", Type::FLOAT),
36 |   DEF_API("GetW", Type::FLOAT), DEF_API("GetH", Type::FLOAT),
37 |   DEF_API("GetCenterX", Type::FLOAT), DEF_API("GetCenterY", Type::FLOAT),
38 |   DEF_API("CreatePlayerShot01", Type::VOID), DEF_API("CreateShot01", Type::VOID),
39 |   DEF_API("CutIn", Type::VOID), DEF_API("SetMovePosition02", Type::VOID),
40 |   DEF_API("GetKeyState", Type::INT), DEF_API("GetCurrentScriptDirectory", Type::STRING),0
41 | };
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/Dnlang/Symbol.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <boost/format.hpp>
 3 | #include "Symbol.hpp"
 4 | namespace Dnlang {
 5 | 
 6 | const std::string Type::type_names[] = {
 7 |   "<n/a>","int","char","float","string","void",
 8 | };
 9 | const int Type::type_sizes[] = {
10 |   0, 4, 1, 4, 4, 4,
11 | };
12 | std::string Symbol::toString() {
13 |   std::string stype = type.toString();
14 |   return (boost::format("%s<%s>") % name % stype).str();
15 | }
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/Dnlang/Symbols.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/Dnlang/Symbols.cpp


--------------------------------------------------------------------------------
/Dnlang/Token.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <sstream>
 3 | #include <string>
 4 | #include "Token.hpp"
 5 | #include "Lexer.hpp"
 6 | #include "DnLexer.hpp"
 7 | 
 8 | std::ostream& operator<<(std::ostream& os, const Token& tk) {
 9 |   if(tk.type == -1) {
10 |     os << "root";
11 |   }
12 |   else {
13 |     //os << Dnlang::DnLexer::token_names[tk.type] << "," << tk.text;
14 |     os << tk.type << "," << tk.text;
15 |   }
16 | }
17 | std::string Token::toString() {
18 |   std::stringstream ss;
19 |   if(this->text == "")
20 |     ss << Dnlang::DnLexer::token_names[this->type];
21 |   else
22 |     ss << this->text;
23 |   return ss.str();
24 | }
25 | 


--------------------------------------------------------------------------------
/Dnlang/runtime/DnInLexer.cpp:
--------------------------------------------------------------------------------
  1 | #include <string>
  2 | #include <algorithm>
  3 | #include <iostream>
  4 | #include "Token.hpp"
  5 | #include "Lexer.hpp"
  6 | #include "DnInLexer.hpp"
  7 | 
  8 | namespace Dnlang {
  9 | 
 10 | const std::string DnInLexer::token_names[] = {
 11 |   "n/a", "<EOF>", "EQUAL",
 12 |   "IF", "GOTO", "CALL", "PARAM", "EQUAL", "RET",
 13 |   "MUL", "PLUS", "MINUS", "AND", "DIV", "MOD", "NOT",
 14 |   "LESS", "LESSEQUAL", "ABOVE", "ABOVEEQUAL", "EQUALEQUAL",
 15 |   "INTCONST", "FLOATCONST", "STRING",
 16 |   "ADDR",
 17 | };
 18 | 
 19 | const std::string DnInLexer::reserved[] = {
 20 |   "if", "goto", "call", "param", "ret",
 21 | };
 22 | 
 23 | Token DnInLexer::nextToken() {
 24 |   while(c != LEX_EOF) {
 25 |     switch(c) {
 26 |       case ' ': case '\t': case '\n': case '\r': skipSpaces(); continue;
 27 |       case '=':
 28 |         consume();
 29 |         if (c == '=') { // ==
 30 |           consume();
 31 |           return Token(EQUALEQUAL, "==");
 32 |         } else {
 33 |           return Token(EQUAL, "=");
 34 |         }
 35 |       case '+':
 36 |           consume();
 37 |           return Token(PLUS, "+");
 38 |       case '-':
 39 |           consume();
 40 |           return Token(MINUS, "-");
 41 |       case '/':
 42 |           consume();
 43 |           return Token(DIV, "/");
 44 |       case '*':
 45 |           consume();
 46 |           return Token(MUL, "*");
 47 |       case '%':
 48 |           consume();
 49 |           return Token(MOD, "%");
 50 |       case '&':
 51 |           consume();
 52 |           return Token(AND, "&");
 53 |       case '!':
 54 |           consume();
 55 |           return Token(NOT, "!");
 56 |       case '<':
 57 |         consume();
 58 |         if (c == '=') { // <=
 59 |           consume();
 60 |           return Token(LESSEQUAL, "<=");
 61 |         } else {
 62 |           return Token(LESS, "<");
 63 |         }
 64 |       case '>':
 65 |         consume();
 66 |         if (c == '=') { // >=
 67 |           consume();
 68 |           return Token(ABOVEEQUAL, ">=");
 69 |         } else {
 70 |           return Token(ABOVE, ">");
 71 |         }
 72 |       case '\"':
 73 |         /* "hoge" (string) */
 74 |         if(isString()) return String();
 75 |       default:
 76 |         if(isDecimal()) {
 77 |           /* {D} */
 78 |           if(isFloat()) return FloatConst();
 79 |           else return IntConst();
 80 |         }else {
 81 |           /* {L} It could be id or reserved word */
 82 |           return Addr();
 83 |         }
 84 |         break;
 85 |       }
 86 |   }
 87 |   return Token(EOF_TYPE, "<EOF>");
 88 | }
 89 | /* TODO: Is it reserved word? It's judged by using binary search. */
 90 | int DnInLexer::isReserved(std::string str) {
 91 |   int rsize = sizeof(reserved) / sizeof(std::string *);
 92 |   for(int i = 0; i < rsize; i++){
 93 |     if(reserved[i] == str) return i;
 94 |   }
 95 |   return -1;
 96 |   /*std::string *pos = std::lower_bound(reserved, reserved + rsize, str);
 97 |   return (pos != rsize && *pos == str); */
 98 | }
 99 | 
100 | Token DnInLexer::IntConst() {
101 |   std::string buf;
102 |   do { buf.append(1, c); consume(); } while(isDecimal());
103 |   return Token(INTCONST, buf);
104 | }
105 | 
106 | Token DnInLexer::FloatConst() {
107 |   std::string buf;
108 |   do { buf.append(1, c); consume(); } while(isDecimal() || c == '.');
109 |   return Token(FLOATCONST, buf);
110 | }
111 | 
112 | Token DnInLexer::String() {
113 |   std::string buf;
114 |   consume();  
115 |   do { buf.append(1, c); consume(); } while(isDecimal() || isLetter() || isSym());
116 |   consume();
117 |   return Token(STRING, buf);
118 | }
119 | 
120 | Token DnInLexer::Addr() {
121 |   std::string buf;
122 |   int resv = -1;
123 |   do { buf.append(1, c); consume(); } while(isDecimal() || isLetter() || isSym() || c == '[' || c == ']');
124 |   if((resv = isReserved(buf)) != -1){
125 |     /* Is this id reserved word? */
126 |     return Token(2 + resv, buf);
127 |   }
128 |   return Token(ADDR, buf);
129 | }
130 | 
131 | }
132 | 


--------------------------------------------------------------------------------
/Dnlang/runtime/DnInParser.cpp:
--------------------------------------------------------------------------------
  1 | #include <vector>
  2 | #include <string>
  3 | #include <sstream>
  4 | #include <map>
  5 | #include <iostream>
  6 | #include <cstdlib>
  7 | #include <typeinfo>
  8 | #include <cstdio>
  9 | #include <algorithm>
 10 | #include "Object.hpp"
 11 | #include "Api.hpp"
 12 | #include "Token.hpp"
 13 | #include "Lexer.hpp"
 14 | #include "DnInLexer.hpp"
 15 | #include "Symbol.hpp"
 16 | #include "Scope.hpp"
 17 | #include "Parser.hpp"
 18 | #include "DnInParser.hpp"
 19 | 
 20 | namespace Dnlang {
 21 | 
 22 | void DnInParser::Addr3() {
 23 |   //std::cout<<"Next:"<<LT(1)<<std::endl;
 24 |   if (LA(1) == DnInLexer::ADDR) {
 25 |     Assign();
 26 |   } else if (LA(1) == DnInLexer::GOTO) {
 27 |     Jump();
 28 |   } else if (LA(1) == DnInLexer::IF) {
 29 |     CondJump();
 30 |   } else if (LA(1) == DnInLexer::PARAM) {
 31 |     Param();
 32 |   } else if (LA(1) == DnInLexer::CALL) {
 33 |     CallFunc();
 34 |   } else if (LA(1) == DnInLexer::RET) {
 35 |     Ret();
 36 |   } else {
 37 |     std::stringstream error;
 38 |     error << "Error: " << LT(1) << LT(2);
 39 |     throw error.str();
 40 |   }
 41 | }
 42 | 
 43 | void DnInParser::Assign() {
 44 |   //std::cout<<"[ENTER] Assign\n";
 45 |   Token left = LT(1);
 46 |   consume();
 47 |   if ( LA(1) == DnInLexer::EQUAL ) {
 48 |     consume();
 49 |     int op_res = (int)RVal();
 50 |     setVal(left, op_res); //define register value
 51 |     pc++;
 52 |   } else {
 53 |     std::stringstream error;
 54 |     error << "Error: " << LT(1) << LT(2);
 55 |     throw error.str();
 56 |   }
 57 | }
 58 | 
 59 | double DnInParser::RVal() {
 60 |   return Operation();
 61 | }
 62 | 
 63 | double DnInParser::Operation() {
 64 |   //std::cout<<"[ENTER] Op\n";
 65 |   int op_res = 0;
 66 |   Token addr = LT(1);
 67 |   double res = getVal(addr);
 68 |   consume();
 69 |   //if (!isFin()) {
 70 |     if ( LA(1) == DnInLexer::PLUS ) {
 71 |       consume();
 72 |       //std::cout<<"calc:"<<res<<"+"<<LT(1)<<LT(2)<<std::endl;
 73 |       res += getVal(LT(1));
 74 |       consume();
 75 |     } else if ( LA(1) == DnInLexer::MINUS ) {
 76 |       consume();
 77 |       res -= getVal(LT(1));
 78 |       consume();
 79 |     } else if ( LA(1) == DnInLexer::MUL ) {
 80 |       consume();
 81 |       res *= getVal(LT(1));
 82 |       consume();
 83 |     } else if ( LA(1) == DnInLexer::DIV ) {
 84 |       consume();
 85 |       res /= getVal(LT(1));
 86 |       consume();
 87 |     } else if ( LA(1) == DnInLexer::MOD ) {
 88 |       consume();
 89 |       int mod_res = (int)res % (int)getVal(LT(1));
 90 |       res = mod_res;
 91 |       consume();
 92 |     }
 93 |   //}
 94 |   return res;
 95 | }
 96 | 
 97 | void DnInParser::Jump() {
 98 |   consume();
 99 |   Token label = LT(1);
100 |   int line = getLabel(label.text);
101 |   pc = line; //jump to line
102 |   consume();
103 | }
104 | 
105 | void DnInParser::CondJump() {
106 |   consume(); // "if"
107 |   if (Cond()) {
108 |     Token label = LT(2);
109 |     int line = getLabel(label.text);
110 |     pc = line;
111 |   }
112 |   consume(); // "goto"
113 |   consume(); //"label"
114 |   pc++;
115 | }
116 | 
117 | bool DnInParser::Cond() {
118 |   Token left = LT(1);
119 |   double lval = getVal(left);
120 |   consume();
121 |   if (LA(1) == DnInLexer::LESS) {
122 |     consume();
123 |     Token right = LT(1);
124 |     double rval = getVal(right);
125 |     consume();
126 |     return lval < rval;
127 |   } else if (LA(1) == DnInLexer::LESSEQUAL) {
128 |     consume();
129 |     Token right = LT(1);
130 |     double rval = getVal(right);
131 |     consume();
132 |     return lval <= rval;
133 |   } else if (LA(1) == DnInLexer::ABOVE) {
134 |     consume();
135 |     Token right = LT(1);
136 |     double rval = getVal(right);
137 |     consume();
138 |     return lval > rval;
139 |   } else if (LA(1) == DnInLexer::ABOVEEQUAL) {
140 |     consume();
141 |     Token right = LT(1);
142 |     double rval = getVal(right);
143 |     consume();
144 |     return lval >= rval;
145 |   } else if (LA(1) == DnInLexer::EQUALEQUAL) {
146 |     consume();
147 |     Token right = LT(1);
148 |     double rval = getVal(right);
149 |     consume();
150 |     return lval == rval;
151 |   }
152 |   return false;
153 | }
154 | 
155 | void DnInParser::Param() {
156 |   consume();
157 |   Token addr = LT(1);
158 |   double val = getVal(addr);
159 |   stack.push_back(val);
160 |   consume();
161 |   pc++;
162 | }
163 | 
164 | void DnInParser::Ret() {
165 |   consume();
166 |   if (LA(1) == DnInLexer::ADDR) {
167 |     double val = getVal(LT(1));
168 |     setRetVal(val);
169 |     consume();
170 |   }
171 |   pc++;
172 | }
173 | 
174 | void DnInParser::CallFunc() {
175 |   consume();
176 |   Token label = LT(1);
177 |   int argc = std::atoi(LT(2).text.c_str());
178 |   int fn_line = getLabel(label.text);
179 |   std::vector<double>argv;
180 |   consume();
181 |   consume();
182 |   for(int i = 0; i < argc; i++) {
183 |     argv.push_back(stack[stack.size() - 1]);
184 |     stack.pop_back();
185 |   }
186 |   std::reverse(argv.begin(),argv.end());
187 |   if(fn_line == -1) {
188 |     std::string api_name = label.text;
189 |     std::cout<<"[API] "<<api_name<<"(";
190 |     for(int i = 0; i < argc; i++) std::cout<<argv[i]<<",";
191 |     std::cout<<")\n";
192 |     if (api_name == "LoadGraphic") { api->_LoadGraphic(target, argv[0]); }
193 |     else if (api_name == "DeleteGraphic"){}
194 |     else if (api_name == "SetTexture") { api->_SetTexture(target, argv[0]); }
195 |     else if (api_name == "SetGraphicRect") { api->_SetGraphicRect(target, argv[0],argv[1],argv[2],argv[3]); }
196 |     //else if (api_name == "SetGraphicPos") { api->_SetGraphicPos(target, argv[0],argv[1],argv[2],argv[3]); }
197 |     else if (api_name == "SetGraphicAngle") { api->_SetGraphicAngle(target, argv[0]); }
198 |     else if (api_name == "DrawGraphic") { api->_DrawGraphic(target, argv[0], argv[1]); }
199 |     else if (api_name == "SetCollisionA"){}
200 |     else if (api_name == "SetInitialBombCount"){}
201 |     else if (api_name == "SetGrazeCircle"){}
202 |     else if (api_name == "SetIntersectionCircle"){}
203 |     else if (api_name == "SetSpeed") { api->_SetSpeed(target, argv[0]); }
204 |     else if (api_name == "SetLife") { api->_SetLife(target, argv[0]); }
205 |     else if (api_name == "SetX") { api->_SetX(target, argv[0]); }
206 |     else if (api_name == "SetY") { api->_SetY(target, argv[0]); }
207 |     else if (api_name == "GetPlayerX") { setRetVal(api->_GetPlayerX(target)); }
208 |     else if (api_name == "GetPlayerY") { setRetVal(api->_GetPlayerX(target)); }
209 |     else if (api_name == "GetSpeedX") { setRetVal(api->_GetSpeedX(target)); }
210 |     else if (api_name == "GetSpeedY") { setRetVal(api->_GetSpeedY(target)); }
211 |     else if (api_name == "GetX") { setRetVal(api->_GetX(target)); }
212 |     else if (api_name == "GetY") { setRetVal(api->_GetY(target)); }
213 |     else if (api_name == "GetW") { setRetVal(api->_GetW(target)); }
214 |     else if (api_name == "GetH") { setRetVal(api->_GetH(target)); }
215 |     else if (api_name == "GetCenterX") { setRetVal(api->_GetCenterX()); }
216 |     else if (api_name == "GetCenterY") { setRetVal(api->_GetCenterY()); }
217 |     else if (api_name == "CreatePlayerShot01") { api->_CreatePlayerShot01(target, argv[0],argv[1],argv[2],argv[3],argv[4],argv[5],argv[6]); }
218 |     else if (api_name == "CreateShot01") { api->_CreateShot01(target,argv[0],argv[1],argv[2],argv[3],argv[4],argv[5]); }
219 |     else if (api_name == "CutIn") { api->_CutIn(target,argv[0],argv[1],argv[2],argv[3],argv[4],argv[5]); }
220 |     else if (api_name == "SetMovePosition02") { api->_SetMovePosition02(target,argv[0],argv[1],argv[2]); }
221 |     else if (api_name == "GetKeyState"){
222 |       int key = (int)api->_GetKeyState(argv[0]);
223 |       setRetVal(key);
224 |     }
225 |     else if (api_name == "GetCurrentScriptDirectory") {
226 |       std::string *namep = new std::string(api->_GetCurrentScriptDirectory());
227 |       setRetVal(reinterpret_cast<unsigned long>(namep->c_str()));
228 |     }
229 |     pc++;
230 |   } else {
231 |     /* TODO: Implment calling normal function */
232 |     pc = fn_line;
233 |   }
234 | }
235 | 
236 | void DnInParser::execline(std::string oneline, int _pc) {
237 |   /* Execute only one line of code */
238 |   lexer = new DnInLexer(oneline);
239 |   input = lexer;
240 |   pc = _pc;
241 |   this->Addr3();
242 |   delete lexer;
243 |   Clear();
244 | }
245 | 
246 | int DnInParser::defString(std::string str) {
247 |   std::string *strp = new std::string(str);
248 |   printf("defval:%p\n",strp->c_str());
249 |   int addr = reinterpret_cast<unsigned long>(strp->c_str());
250 |   syms[str] = addr;
251 |   revmap[addr] = str;
252 |   return addr;
253 | };
254 | 
255 | double DnInParser::getVal(Token token) {
256 |   if (token.type == DnInLexer::INTCONST || token.type == DnInLexer::FLOATCONST) {
257 |     return std::stod(token.text.c_str());
258 |   } else if(token.type == DnInLexer::STRING) {
259 |     if(syms.find(token.text) == syms.end()) {
260 |       /* alloc new string data and return its address */
261 |       return static_cast<double>(defString(token.text));
262 |     }
263 |   }
264 |   return syms[token.text];
265 | }
266 | 
267 | void DnInParser::setVal(Token token, double val) {
268 |   syms[token.text] = val;
269 | }
270 | 
271 | void DnInParser::setRetVal(double val) {
272 |   syms["r0"] = val;
273 | }
274 | 
275 | void DnInParser::TestLex() {
276 | 
277 | }
278 | 
279 | void DnInParser::dump() {
280 |   std::map<std::string, double>::iterator it = syms.begin();
281 |   while (it != syms.end()) {
282 |     std::cout<<it->first<<":"<<it->second<<std::endl;
283 |     ++it;
284 |   }
285 | }
286 | 
287 | }
288 | 


--------------------------------------------------------------------------------
/Dnlang/runtime/Interprter.cpp:
--------------------------------------------------------------------------------
  1 | #include <fstream>
  2 | #include <iostream>
  3 | #include <string>
  4 | #include <map>
  5 | #include <vector>
  6 | #include <cstdlib>
  7 | #include <boost/algorithm/string.hpp>
  8 | #include <boost/foreach.hpp>
  9 | 
 10 | #include "Object.hpp"
 11 | #include "Api.hpp"
 12 | #include "Interprter.hpp"
 13 | 
 14 | namespace Dnlang {
 15 | 
 16 | Interprter::Interprter(Object *obj, std::string _path) : target(obj), path(_path) {
 17 |   this->load_script();
 18 |   parser = new DnParser(script);
 19 |   inparser = new DnInParser(target);
 20 | }
 21 | 
 22 | Interprter::~Interprter() {
 23 |   delete parser;
 24 |   delete seman;
 25 |   delete cgen;
 26 |   delete inparser;
 27 | }
 28 | 
 29 | void Interprter::load_script() {
 30 |   std::ifstream ifs(path);
 31 |   if(ifs.fail()) {
 32 |     std::cerr << "Failed to open script file" << std::endl;
 33 |     abort();
 34 |   }
 35 |   std::string script((std::istreambuf_iterator<char>(ifs)),
 36 |                       std::istreambuf_iterator<char>());
 37 |   this->script = script;
 38 |   std::cout << this->script << std::endl;
 39 | }
 40 | 
 41 | void Interprter::compile() {
 42 |   try{
 43 |     std::cout<<"compiling..."<<std::endl;
 44 |     parser->TranslationUnit();
 45 |     ast = parser->get_AST();
 46 |     std::cout << ast->toStringTree(0) << std::endl;
 47 |     seman = new Dnlang::Semantics(ast);
 48 |     seman->downup(ast);
 49 |     std::cout<<"Semantics: complete\n";
 50 |     cgen = new Dnlang::CodeGen(ast);
 51 |     cgen->downup(ast);
 52 |     //std::cout<<ast->code<<std::endl;
 53 |     std::string delim("\n");
 54 |     boost::algorithm::split(this->code, ast->code, boost::is_any_of(delim));
 55 |     BOOST_FOREACH(std::string s, this->code) {
 56 |       std::cout << s << std::endl;
 57 |     }
 58 |     preprocess();
 59 |   }catch(std::string s) {
 60 |     std::cout<<s<<std::endl;
 61 |     abort();
 62 |   }
 63 | }
 64 | 
 65 | void Interprter::Initialize() {
 66 |   this->execLabel("@Initialize");
 67 | }
 68 | void Interprter::MainLoop() {
 69 |   this->execLabel("@MainLoop");
 70 | }
 71 | void Interprter::DrawLoop() {
 72 |   this->execLabel("@DrawLoop");
 73 | }
 74 | void Interprter::_Init() {
 75 |   this->execLabel("_Init");
 76 | }
 77 | 
 78 | void Interprter::execLabel(std::string lab) {
 79 |   //std::cout<<"Start "<<lab<<std::endl;
 80 |   int lab_pc = inparser->getLabel(lab);
 81 |   int pc = lab_pc + 1;
 82 |   std::string oneline;
 83 |   while (oneline.find("ret") == std::string::npos && oneline.find("@") == std::string::npos) {
 84 |     /* XXX: User defined function can't adjsut this structure.
 85 |             I'll implment it in the near future.... */
 86 |     oneline = this->code[pc];
 87 |     if (oneline == "" || oneline.find(":") != std::string::npos) { pc++; continue; }
 88 |     std::cout<<"execute: "<<oneline<<std::endl;
 89 |     inparser->execline(oneline, pc); //execute one line
 90 |     //inparser->dump(); //dump for DEBUG
 91 |     pc = inparser->getPC(); // go to next instruction
 92 |   }
 93 | }
 94 | 
 95 | void Interprter::preprocess() {
 96 |   int i = 0;
 97 |   BOOST_FOREACH(std::string s, this->code) {
 98 |     if (s.find(":") != std::string::npos) {
 99 |       std::string lname = s.substr(0,s.size() - 1);
100 |       std::cout<<lname<<std::endl;
101 |       inparser->defLabel(lname, i);
102 |     }
103 |     i++;
104 |   }
105 | }
106 | 
107 | }
108 | 


--------------------------------------------------------------------------------
/Dnlang/sample/enemy.dn:
--------------------------------------------------------------------------------
 1 | let count=0;
 2 | let cx=GetCenterX();
 3 | let imgEnemy = "img/Enemy.png";
 4 | let imgAngle=0;
 5 | let shotAngle=0;
 6 | 
 7 | function @Initialize() {
 8 | 	LoadGraphic(imgEnemy);
 9 | 	SetLife(1500);
10 | 	SetGraphicRect(1,1,32,32);
11 | 	SetTexture(imgEnemy);
12 | 	SetMovePosition02(cx+0,60,60);
13 | 	return;
14 | }
15 | 
16 | function @MainLoop() {
17 | 	if (count >= 30) {
18 | 		if (count % 180 == 0 && count < 4000) {
19 | 			SetMovePosition02(cx-50,100,20);
20 | 		}
21 | 		if(count % 180 == 90 && count < 4000){
22 | 			SetMovePosition02(cx+50,100,20);
23 | 		}
24 | 		if(count % 10 == 0){
25 | 			let angle = 0;
26 | 			while(angle < 360) {
27 | 				CreateShot01(GetX() + GetW() / 2, GetY() + GetH() / 2,10,angle,0,1);
28 | 				angle += 20;
29 | 			}
30 | 		}
31 | 	}
32 | 	++count;
33 | 	return;
34 | }
35 | 
36 | function @Finalize() {
37 | }
38 | 
39 | function @DrawLoop() {
40 | 	DrawGraphic(GetX(), GetY());
41 | 	return;
42 | }
43 | 


--------------------------------------------------------------------------------
/Dnlang/sample/test01.dn:
--------------------------------------------------------------------------------
 1 | let GetX = 0;
 2 | let GetY = 0; 
 3 | let frame = 0;
 4 | let angleBase = 90;
 5 | let YELLOW01 = 1;
 6 | let WHITE01 = 10;
 7 | function script_enemy_main() {
 8 |     let imgBoss   = "script\img\ExRumia.png";
 9 |     let frame     =  0;
10 |     let res = frame * 3 + angleBase / 2;
11 |     return res;
12 | }
13 | function Initialize() {
14 |     
15 | }
16 | function nway(dir, way, span, color) {
17 |     way = dir[++span];
18 |     dir[++span] = way;
19 |     while(dir[span] > 0) {
20 | 	++span;
21 | 	dir[span] -= dir[span - 1];
22 |     }
23 |     return;
24 | }
25 | function @MainLoop() {
26 |     ++frame;
27 |     if(frame == 30) {
28 |         nway(angleBase, 3, 5, YELLOW01);
29 |         angleBase += 8;
30 |     } 
31 |     else { }
32 |     if(frame == 60) {
33 |         nway(angleBase, 5, 3, WHITE01);
34 |         angleBase += 8;
35 |         frame = 0;
36 |     }
37 |     else { }
38 | }
39 | function @DrawLoop() {
40 |     
41 | }
42 | function @Finalize() {
43 | 
44 | }
45 | 
46 | 


--------------------------------------------------------------------------------
/Dnscript.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdlib>
 2 | #include <cstdio>
 3 | 
 4 | #include "Api.hpp"
 5 | #include "Object.hpp"
 6 | #include "Select.hpp"
 7 | #include "Title.hpp"
 8 | #include "Game.hpp"
 9 | #include "Dnscript.hpp"
10 | #include "Utility.hpp"
11 | 
12 | Dnscript::Dnscript():title(0),select(0),game(0){
13 |   title = new Title();
14 |   next = SEQ_NONE;
15 | }
16 | Dnscript::~Dnscript(){
17 |   SAFE_DELETE(title);
18 |   SAFE_DELETE(select);
19 |   SAFE_DELETE(game);
20 | }
21 | void Dnscript::update(void){
22 |   if(title){
23 |     title->update(this);
24 |   }else if(select){
25 |     select->update(this);
26 |   }else if(game){
27 |     game->update(this);
28 |   }else{
29 |     abort();
30 |   }
31 |   switch(next){
32 |     case SEQ_TITLE:
33 |       SAFE_DELETE(select);
34 |       SAFE_DELETE(game);
35 |       title = new Title();
36 |       break;
37 |     case SEQ_STAGE_SELECT:
38 |       SAFE_DELETE(title);
39 |       SAFE_DELETE(game);
40 |       select = new Select();
41 |       break;
42 |     case SEQ_GAME:
43 |       SAFE_DELETE(title);
44 |       SAFE_DELETE(select);
45 |       game = new Game();
46 |       break;
47 |     default:
48 |       break;
49 |   }
50 |   next = SEQ_NONE;
51 | }
52 | void Dnscript::draw(void){
53 |   if(title){
54 |     title->draw();
55 |   }else if(select){
56 |     select->draw();
57 |   }else if(game){
58 |     game->draw();
59 |   }else{
60 |     abort();
61 |   }
62 | }
63 | void Dnscript::moveTo(SeqID _next){
64 |   next = _next;
65 | }
66 | 


--------------------------------------------------------------------------------
/Dntest:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/Dntest


--------------------------------------------------------------------------------
/Event.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <map>
 3 | #include "Event.hpp"
 4 | 
 5 | Event* Event::mInstance = 0;
 6 | 
 7 | Event* Event::instance(){
 8 |     return mInstance;
 9 | }
10 | 
11 | void Event::create(){
12 |   try{
13 |     if(mInstance) throw "[*ERROR*] Event::create() cannnot create instance twice";
14 |     mInstance = new Event();
15 |   }catch(char *error){
16 |     std::cerr << error << "\n";
17 |     abort();
18 |   }
19 | }
20 | 
21 | void Event::destroy(){
22 |   delete mInstance;
23 | }
24 | 


--------------------------------------------------------------------------------
/Frame.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | #include <cstdlib>
 3 | #include "Frame.hpp"
 4 | 
 5 | Frame* Frame::mInstance = 0;
 6 | 
 7 | Frame* Frame::instance(){
 8 |     return mInstance;
 9 | }
10 | 
11 | void Frame::create(){
12 |   try{
13 |     if(mInstance) throw "[*ERROR*] Frame::create() cannnot create instance twice";
14 |     mInstance = new Frame();
15 |   }catch(const char *error){
16 |     fprintf(stderr,"%s\n",error);
17 |     abort();
18 |   }
19 | }
20 | 
21 | void Frame::destroy(){
22 |   delete mInstance;
23 |   mInstance = 0;
24 | }
25 | 
26 | Frame::Frame(){
27 |   frame = 0;
28 | }
29 | 
30 | void Frame::count_up(){
31 |   frame = (frame + 1) % FRAME_MAX;
32 | }
33 | 
34 | int Frame::get_frame(){
35 |   return frame;
36 | }
37 | 
38 | int Frame::get_next_frame(int plus){
39 |     return (frame + plus) % FRAME_MAX;
40 | }
41 | 


--------------------------------------------------------------------------------
/Game.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdlib>
 2 | #include <cstdio>
 3 | 
 4 | #include "Api.hpp"
 5 | #include "Object.hpp"
 6 | #include "Load.hpp"
 7 | #include "Clear.hpp"
 8 | #include "Play.hpp"
 9 | #include "Menu.hpp"
10 | #include "Game.hpp"
11 | #include "Utility.hpp"
12 | #include "Dnscript.hpp"
13 | 
14 | Game::Game():load(0),clear(0),play(0),menu(0){
15 |   Api::create();
16 |   load = new Load();
17 |   next = SEQ_NONE;
18 | }
19 | Game::~Game(){
20 |   Api::destroy();
21 |   SAFE_DELETE(load);
22 |   SAFE_DELETE(clear);
23 |   SAFE_DELETE(play);
24 |   SAFE_DELETE(menu);
25 | }
26 | void Game::update(Dnscript* parent){
27 |   if(load){
28 |     load->update(this);
29 |   }else if(clear){
30 |     clear->update(this);
31 |   }else if(play){
32 |     play->update(this);
33 |   }else if(menu){
34 |     menu->update(this);
35 |   }else{
36 |     abort();
37 |   }
38 |   switch(next){
39 |     case SEQ_LOAD:
40 |       load = new Load();
41 |       break;
42 |     case SEQ_CLEAR:
43 |       SAFE_DELETE(play);
44 |       SAFE_DELETE(menu);
45 |       clear = new Clear();
46 |       break;
47 |     case SEQ_PLAY:
48 |       SAFE_DELETE(load);
49 |       play = new Play();
50 |       break;
51 |     case SEQ_MENU:
52 |       menu = new Menu();
53 |       break;
54 | 
55 |     default:
56 |       break;
57 |   }
58 |   next = SEQ_NONE;
59 | }
60 | void Game::draw(void){
61 |   if(load){
62 |     load->draw();
63 |   }else if(clear){
64 |     clear->draw();
65 |   }else if(play){
66 |     play->draw();
67 |   }else if(menu){
68 |     menu->draw();
69 |   }else{
70 |     abort();
71 |   }
72 | }
73 | 
74 | void Game::load_data(void){
75 | 
76 | }
77 | void Game::moveTo(SeqID _next){
78 |   next = _next;
79 | }
80 | 


--------------------------------------------------------------------------------
/Game/Bullet.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <math.h>
 3 | #include "Api.hpp"
 4 | #include "Object.hpp"
 5 | #include "Bullet.hpp"
 6 | #include "Play.hpp"
 7 | 
 8 | Bullet::Bullet(){
 9 |   api = Api::instance();
10 |   obj_back = new Object();
11 | 
12 |   state = STATE_NONE;
13 |   id = 1;
14 |   std::string filename("img/bullets.png");
15 |   obj_back = new Object();
16 |   api->LoadGraphic(obj_back,filename);
17 |   api->SetTexture(obj_back,filename);
18 |   set_type(TYPE_NORMAL,RED);
19 | }
20 | 
21 | Bullet::~Bullet(){
22 |   delete obj_back;
23 | }
24 | 
25 | void Bullet::update(){
26 |   if(Play::in_monitor(x,y)){
27 |     double tx = speed * cos(angle * M_PI / 180.0) * 100;
28 |     double ty = speed * sin(angle * M_PI / 180.0) * 100;
29 |     x = (x * 100 + tx) / 100;
30 |     y = (y * 100 + ty) / 100;
31 |   }else{
32 |     state = STATE_NONE;
33 |   }
34 | }
35 | void Bullet::draw(){
36 |   api->DrawGraphic(obj_back,x,y);
37 | }
38 | void Bullet::set_state(int x,int y,
39 |                   double speed,double angle,double damage,
40 |                   int pene){
41 |   this->x = x;
42 |   this->y = y;
43 |   this->speed = speed;
44 |   this->angle = angle;
45 |   this->damage = damage;
46 |   this->pene = pene;
47 | }
48 | void Bullet::shoot(){
49 |   state = STATE_SHOT;
50 | }
51 | void Bullet::reserve(){
52 |   state = STATE_RESERVE;
53 | }
54 | void Bullet::set_type(Type _type,Color _color){
55 |   type = _type;
56 |   color = _color;
57 |   load_data(type,color);
58 | }
59 | void Bullet::load_data(Type _type,Color _color){
60 |   /* FIXME: These datas must separeted from source code. */
61 |   int size = 20;
62 |   api->SetGraphicRect(obj_back,(int)color * size,0,((int)color + 1) * size,size);
63 | }
64 | 
65 | bool Bullet::available(){
66 |   return state == STATE_NONE;
67 | }
68 | bool Bullet::is_shoot(){
69 |   return state == STATE_SHOT;
70 | }
71 | int Bullet::get_id(){
72 |   return id;
73 | }
74 | 


--------------------------------------------------------------------------------
/Game/Clear.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include "Api.hpp"
 3 | #include "Object.hpp"
 4 | #include "Keyboard.hpp"
 5 | #include "Clear.hpp"
 6 | #include "Game.hpp"
 7 | 
 8 | Clear::Clear(){
 9 |   api = Api::instance();
10 |   keyboard = Keyboard::instance();
11 |   std::string filename("img/Clear.png");
12 |   obj_back = new Object();
13 |   api->LoadGraphic(obj_back,filename);
14 |   api->SetTexture(obj_back,filename);
15 |   SDL_Surface* image = obj_back->get_image();
16 |   api->SetGraphicRect(obj_back,0,0,image->w,image->h);
17 | }
18 | 
19 | Clear::~Clear(){
20 |   delete obj_back;
21 | }
22 | 
23 | void Clear::update(Game* parent){
24 | }
25 | void Clear::draw(){
26 |   SDL_Surface* image = obj_back->get_image();
27 |   api->DrawGraphic(obj_back,0,0);
28 | }
29 | 


--------------------------------------------------------------------------------
/Game/Enemy.cpp:
--------------------------------------------------------------------------------
  1 | #include <string>
  2 | #include <SDL.h>
  3 | #include <cstdio>
  4 | #include "Api.hpp"
  5 | #include "Keyboard.hpp"
  6 | #include "Enemy.hpp"
  7 | #include "Bullet.hpp"
  8 | #include "Window.hpp"
  9 | #include "Play.hpp"
 10 | #include "Frame.hpp"
 11 | 
 12 | Enemy::Enemy() : speed(0),life(0),bomb_num(0),graze(0),
 13 |                   move_frame(0), state(0){
 14 |   api = Api::instance();
 15 |   keyboard = Keyboard::instance();
 16 |   frame = Frame::instance();
 17 |   bullets.resize(bullet_num);
 18 |   for(int i = 0; i < bullet_num; i++){
 19 |     bullets[i] = new Bullet();
 20 |   }
 21 |   obj_pos->x = Play::win_rect.w / 2;
 22 |   obj_pos->y = 10;
 23 |   clear_state();
 24 | }
 25 | 
 26 | Enemy::~Enemy(){
 27 |   for(int i = 0; i < bullet_num; i++){
 28 |     delete bullets[i];
 29 |   }
 30 | }
 31 | void Enemy::shoot(int x,int y,
 32 |                   double speed,double angle,double damage,
 33 |                   int pene,int id){
 34 | }
 35 | void Enemy::shoot(int x,int y,double speed,
 36 |                   double angle,double damage,int pene,Bullet::Color color,int delay){
 37 |   for(int i = 0; i < bullet_num; i++){
 38 |       if(bullets[i]->available()){
 39 |         bullets[i]->set_type(Bullet::TYPE_NORMAL,color);
 40 |         bullets[i]->set_state(x,y,speed,angle,damage,pene);
 41 |         bullets[i]->reserve();
 42 |         Action sh_act(Action::TYPE_SHOOT);
 43 |         sh_act.set_bullet(bullets[i]);
 44 |         action_list->add_action(frame->get_next_frame(delay),sh_act);//lazy shoot
 45 |         break;
 46 |       }
 47 |   }
 48 | }
 49 | void Enemy::update(){
 50 |   int now_frame = frame->get_frame();
 51 |   //printf("%d\n",now_frame);
 52 |   while(true){
 53 |     Action action = action_list->get_action(now_frame);
 54 |     if(action.get_type() == Action::TYPE_MOVE){
 55 |       set_state(STATE_MOVE);
 56 |       move_frame = action.get_move_frame();
 57 |     }
 58 |     else if(action.get_type() == Action::TYPE_SHOOT){
 59 |       set_state(STATE_SHOOT);
 60 |     }
 61 |     else{
 62 |       break;
 63 |     }
 64 | 
 65 |     if(is_state(STATE_SHOOT)){
 66 |       action.get_bullet()->shoot();
 67 |       remove_state(STATE_SHOOT);
 68 |     }
 69 |   }
 70 |   if(is_state(STATE_MOVE)){
 71 |     if(move_frame > 0){
 72 |       obj_pos->x += dx;
 73 |       obj_pos->y += dy;
 74 |       move_frame--;
 75 |     }else{
 76 |       remove_state(STATE_MOVE);
 77 |     }
 78 |   }
 79 | 
 80 |   for(int i = 0; i < bullet_num; i++){
 81 |     if(bullets[i]->is_shoot()){
 82 |       bullets[i]->update();
 83 |     }
 84 |   }
 85 | 
 86 | }
 87 | 
 88 | void Enemy::start_move(int x,int y,int fr){
 89 |   mx = x;
 90 |   my = y;
 91 |   dx = (mx - obj_pos->x) / fr;
 92 |   dy = (my - obj_pos->y) / fr;
 93 | //printf("%d,%d\n",dx,dy);
 94 |   Action move_act(Action::TYPE_MOVE);
 95 |   move_act.set_move(x,y,dx,dy,fr);
 96 |   action_list->add_action(frame->get_frame() + 2,move_act); //move immediately
 97 |   //printf("move_y:%d,%d\n",obj_pos->y,move_y);
 98 | }
 99 | 
100 | void Enemy::draw(){
101 |   for(int i = 0; i < bullet_num; i++){
102 |     if(bullets[i]->is_shoot()){
103 |       bullets[i]->draw();
104 |     }
105 |   }
106 | }
107 | void Enemy::set_state(State _s){
108 |   state |= (unsigned int)_s;
109 | }
110 | void Enemy::remove_state(State _s){
111 |   state &= ~((unsigned int)_s);
112 | }
113 | bool Enemy::is_state(State _s){
114 |   return (state & (unsigned int)_s);
115 | }
116 | 


--------------------------------------------------------------------------------
/Game/Load.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include "Api.hpp"
 3 | #include "Object.hpp"
 4 | #include "Keyboard.hpp"
 5 | #include "Load.hpp"
 6 | #include "Game.hpp"
 7 | 
 8 | Load::Load(){
 9 |   api = Api::instance();
10 |   keyboard = Keyboard::instance();
11 |   std::string filename("img/load.png");
12 |   loading = false;
13 |   obj_back = new Object();
14 |   api->LoadGraphic(obj_back,filename);
15 |   api->SetTexture(obj_back,filename);
16 |   SDL_Surface* image = obj_back->get_image();
17 |   api->SetGraphicRect(obj_back,0,0,image->w,image->h);
18 | }
19 | 
20 | Load::~Load(){
21 |   delete obj_back;
22 | }
23 | 
24 | void Load::update(Game* parent){
25 |   static int count;
26 |   if(!loading){
27 |     parent->load_data();
28 |     loading = true;
29 |   }else if(count >= 10){
30 |     parent->moveTo(Game::SEQ_PLAY);
31 |   }
32 |   ++count;
33 | }
34 | 
35 | void Load::draw(){
36 |   api->RenderClear();
37 |   api->DrawGraphic(obj_back,0,0);
38 |   api->RenderPresent();
39 | }
40 | 


--------------------------------------------------------------------------------
/Game/Menu.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include "Api.hpp"
 3 | #include "Object.hpp"
 4 | #include "Keyboard.hpp"
 5 | #include "Menu.hpp"
 6 | #include "Game.hpp"
 7 | 
 8 | Menu::Menu(){
 9 |   api = Api::instance();
10 |   keyboard = Keyboard::instance();
11 |   std::string filename("img/menu.png");
12 |   obj_back = new Object();
13 |   api->LoadGraphic(obj_back,filename);
14 |   api->SetTexture(obj_back,filename);
15 |   SDL_Surface* image = obj_back->get_image();
16 |   api->SetGraphicRect(obj_back,0,0,image->w,image->h);
17 | }
18 | 
19 | Menu::~Menu(){
20 |   delete obj_back;
21 | }
22 | 
23 | void Menu::update(Game* parent){
24 | }
25 | void Menu::draw(){
26 |   SDL_Surface* image = obj_back->get_image();
27 |   api->DrawGraphic(obj_back,0,0);
28 | }
29 | 


--------------------------------------------------------------------------------
/Game/Play.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <fstream>
 3 | #include <iostream>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <list>
 7 | #include "Api.hpp"
 8 | #include "Object.hpp"
 9 | #include "Keyboard.hpp"
10 | #include "Enemy.hpp"
11 | #include "Play.hpp"
12 | #include "Game.hpp"
13 | #include "Window.hpp"
14 | #include "Player.hpp"
15 | #include "test/player_test.hpp"
16 | #include "test/enemy_test.hpp"
17 | SDL_Rect Play::win_rect;
18 | 
19 | Play::Play(){
20 |   api = Api::instance();
21 |   keyboard = Keyboard::instance();
22 |   Play::win_rect.x = 20;
23 |   Play::win_rect.y = 10;
24 |   Play::win_rect.w = Window::win_rect.w / 4 * 3;
25 |   Play::win_rect.h = Window::win_rect.h / 12 * 11;
26 | 
27 |   std::string filename("img/play.jpg");
28 |   obj_back = new Object();
29 |   api->LoadGraphic(obj_back,filename);
30 |   api->SetTexture(obj_back,filename);
31 |   SDL_Surface* image = obj_back->get_image();
32 |   api->SetGraphicRect(obj_back,0,0,image->w,image->h);
33 | 
34 |   player = new Player();
35 |   p_test = new player_test(player);
36 |   p_test->Initialize();
37 |   enemies.push_back(new Enemy());
38 | 
39 |   /* Compile the script code and execute @Initialize function */
40 |   interp = new Dnlang::Interprter(enemies.front(), "Dnlang/sample/enemy.dn");
41 |   interp->compile();
42 |   interp->_Init();
43 |   interp->Initialize();
44 |   std::cout<<"enemy_0"<<enemies.front()<<std::endl;
45 |   //e_test = new enemy_test(enemies.front());
46 |   //e_test->Initialize();
47 | 
48 | 
49 | 
50 | }
51 | 
52 | Play::~Play(){
53 |   delete obj_back;
54 |   delete player;
55 |   delete p_test;
56 |   //delete e_test;
57 |   while(!enemies.empty()){
58 |     Enemy* e = enemies.front();
59 |     delete e;
60 |     enemies.pop_front();
61 |   }
62 |   delete interp;
63 | }
64 | 
65 | void Play::update(Game* parent){
66 |   player->update();
67 |   p_test->MainLoop();
68 |   for(int i = 0; i < enemies.size(); i++){
69 |     enemies[i]->update();
70 |   }
71 |   //e_test->MainLoop();
72 |   interp->MainLoop();
73 | }
74 | void Play::draw(){
75 |   api->RenderClear();
76 |   api->DrawGraphic(obj_back,Play::win_rect.x,Play::win_rect.y);
77 |   player->draw();
78 |   p_test->DrawLoop();
79 |   for(int i = 0; i < enemies.size(); i++){
80 |     enemies[i]->draw();
81 |   }
82 |   //e_test->DrawLoop();
83 |   interp->DrawLoop();
84 |   api->RenderPresent();
85 | }
86 | 
87 | bool Play::in_monitor(int x,int y){
88 |   return win_rect.x <= x && x < win_rect.w && win_rect.y <= y && y <= win_rect.h;
89 | }
90 | 


--------------------------------------------------------------------------------
/Game/Player.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <SDL.h>
 3 | #include <cstdio>
 4 | #include "Api.hpp"
 5 | #include "Keyboard.hpp"
 6 | #include "Player.hpp"
 7 | #include "Bullet.hpp"
 8 | #include "Window.hpp"
 9 | #include "Play.hpp"
10 | 
11 | Player::Player() : speed(0),life(0),bomb_num(0),graze(0){
12 |   api = Api::instance();
13 |   keyboard = Keyboard::instance();
14 |   obj_cutin = new Object();
15 |   bullets.resize(bullet_num);
16 |   for(int i = 0; i < bullet_num; i++){
17 |     bullets[i] = new Bullet();
18 |   }
19 |   obj_pos->x = Play::win_rect.w / 2;
20 |   obj_pos->y = Play::win_rect.h - obj_rect->h - 10;
21 | }
22 | 
23 | Player::~Player(){
24 |   delete obj_cutin;
25 |   for(int i = 0; i < bullet_num; i++){
26 |     delete bullets[i];
27 |   }
28 | }
29 | void Player::shoot(int x,int y,
30 |                   double speed,double angle,double damage,
31 |                   int pene,int id){
32 |   for(int i = 0; i < bullet_num; i++){
33 |     if(bullets[i]->available() && bullets[i]->get_id() == id){
34 |       bullets[i]->set_state(x,y,speed,angle,damage,pene);
35 |       bullets[i]->shoot();
36 |       //printf("shoot %d\n",i);
37 |       break;
38 |     }
39 |   }
40 | }
41 | 
42 | void Player::update(){
43 |   for(int i = 0; i < bullet_num; i++){
44 |     if(!bullets[i]->available()){
45 |       bullets[i]->update();
46 |     }
47 |   }
48 |   move();
49 |   if(is_state(STATE_CUTIN)){
50 |   }
51 | }
52 | 
53 | void Player::move(){
54 |   dx = 0; dy = 0;
55 |   if(keyboard->is_keyon(SDLK_LEFT)){
56 |     dx = -speed;
57 |   }else if(keyboard->is_keyon(SDLK_RIGHT)){
58 |     dx = speed;
59 |   }
60 |   if(keyboard->is_keyon(SDLK_UP)){
61 |     dy = -speed;
62 |   }else if(keyboard->is_keyon(SDLK_DOWN)){
63 |     dy = speed;
64 |   }
65 |   if(!Play::in_monitor(obj_pos->x + dx,obj_pos->y + dy)) return;
66 |   obj_pos->x += dx;
67 |   obj_pos->y += dy;
68 | }
69 | void Player::CutIn(std::string label,std::string img,
70 |                     int x1,int y1,int x2,int y2){
71 |   api->LoadGraphic(obj_cutin,img);
72 |   api->SetTexture(obj_cutin,img);
73 |                       printf("cutin\n");
74 |   api->SetGraphicRect(obj_cutin,x1,y1,x2,y2);
75 |   set_state(STATE_CUTIN);
76 | }
77 | 
78 | void Player::draw(){
79 |   for(int i = 0; i < bullet_num; i++){
80 |     if(!bullets[i]->available()){
81 |       bullets[i]->draw();
82 |     }
83 |   }
84 |   if(is_state(STATE_CUTIN)){
85 |       api->DrawGraphic(obj_cutin,20,100);
86 |   }
87 | }
88 | 
89 | void Player::set_state(State _s){
90 |   state |= (unsigned int)_s;
91 | }
92 | void Player::remove_state(State _s){
93 |   state &= ~((unsigned int)_s);
94 | }
95 | bool Player::is_state(State _s){
96 |   return (state & (unsigned int)_s);
97 | }
98 | 


--------------------------------------------------------------------------------
/Keyboard.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <SDL.h>
 3 | #include "Keyboard.hpp"
 4 | 
 5 | Keyboard* Keyboard::mInstance = 0;
 6 | 
 7 | Keyboard* Keyboard::instance(){
 8 |     return mInstance;
 9 | }
10 | 
11 | void Keyboard::create(){
12 |   try{
13 |     if(mInstance) throw "[*ERROR*] Keyboard::create() cannnot create instance twice";
14 |     mInstance = new Keyboard();
15 |   }catch(char *error){
16 |     fprintf(stderr,"%s\n",error);
17 | 	  abort();
18 |   }
19 | }
20 | 
21 | void Keyboard::destroy(){
22 |   delete mInstance;
23 | }
24 | 
25 | bool Keyboard::is_keyon(SDL_Keycode key){
26 |   if(keys.find( key ) == keys.end()) return false;
27 |   return keys[key] == KEY_PUSH;
28 | }
29 | 
30 | bool Keyboard::is_keyoff(SDL_Keycode key){
31 |   if(keys.find( key ) == keys.end()) return true;
32 |   return keys[key] == KEY_RELEASE;
33 | }
34 | 
35 | bool Keyboard::is_keytoggle(SDL_Keycode key){
36 |   if(keys.find( key ) == keys.end()) return false;  
37 |   return keys[key] == KEY_TOGGLE;
38 | }
39 | 
40 | void Keyboard::keyon(SDL_Keycode key){
41 |   if(keys[key] != KEY_TOGGLE)
42 |     keys[key] = KEY_PUSH;
43 | }
44 | 
45 | void Keyboard::keyoff(SDL_Keycode key){
46 |   keys[key] = KEY_RELEASE;
47 | }
48 | void Keyboard::keytoggle(SDL_Keycode key){
49 |   keys[key] = KEY_TOGGLE;
50 | }
51 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 2, June 1991
  3 | 
  4 |  Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
  5 |  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  6 |  Everyone is permitted to copy and distribute verbatim copies
  7 |  of this license document, but changing it is not allowed.
  8 | 
  9 |                             Preamble
 10 | 
 11 |   The licenses for most software are designed to take away your
 12 | freedom to share and change it.  By contrast, the GNU General Public
 13 | License is intended to guarantee your freedom to share and change free
 14 | software--to make sure the software is free for all its users.  This
 15 | General Public License applies to most of the Free Software
 16 | Foundation's software and to any other program whose authors commit to
 17 | using it.  (Some other Free Software Foundation software is covered by
 18 | the GNU Lesser General Public License instead.)  You can apply it to
 19 | your programs, too.
 20 | 
 21 |   When we speak of free software, we are referring to freedom, not
 22 | price.  Our General Public Licenses are designed to make sure that you
 23 | have the freedom to distribute copies of free software (and charge for
 24 | this service if you wish), that you receive source code or can get it
 25 | if you want it, that you can change the software or use pieces of it
 26 | in new free programs; and that you know you can do these things.
 27 | 
 28 |   To protect your rights, we need to make restrictions that forbid
 29 | anyone to deny you these rights or to ask you to surrender the rights.
 30 | These restrictions translate to certain responsibilities for you if you
 31 | distribute copies of the software, or if you modify it.
 32 | 
 33 |   For example, if you distribute copies of such a program, whether
 34 | gratis or for a fee, you must give the recipients all the rights that
 35 | you have.  You must make sure that they, too, receive or can get the
 36 | source code.  And you must show them these terms so they know their
 37 | rights.
 38 | 
 39 |   We protect your rights with two steps: (1) copyright the software, and
 40 | (2) offer you this license which gives you legal permission to copy,
 41 | distribute and/or modify the software.
 42 | 
 43 |   Also, for each author's protection and ours, we want to make certain
 44 | that everyone understands that there is no warranty for this free
 45 | software.  If the software is modified by someone else and passed on, we
 46 | want its recipients to know that what they have is not the original, so
 47 | that any problems introduced by others will not reflect on the original
 48 | authors' reputations.
 49 | 
 50 |   Finally, any free program is threatened constantly by software
 51 | patents.  We wish to avoid the danger that redistributors of a free
 52 | program will individually obtain patent licenses, in effect making the
 53 | program proprietary.  To prevent this, we have made it clear that any
 54 | patent must be licensed for everyone's free use or not licensed at all.
 55 | 
 56 |   The precise terms and conditions for copying, distribution and
 57 | modification follow.
 58 | 
 59 |                     GNU GENERAL PUBLIC LICENSE
 60 |    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 61 | 
 62 |   0. This License applies to any program or other work which contains
 63 | a notice placed by the copyright holder saying it may be distributed
 64 | under the terms of this General Public License.  The "Program", below,
 65 | refers to any such program or work, and a "work based on the Program"
 66 | means either the Program or any derivative work under copyright law:
 67 | that is to say, a work containing the Program or a portion of it,
 68 | either verbatim or with modifications and/or translated into another
 69 | language.  (Hereinafter, translation is included without limitation in
 70 | the term "modification".)  Each licensee is addressed as "you".
 71 | 
 72 | Activities other than copying, distribution and modification are not
 73 | covered by this License; they are outside its scope.  The act of
 74 | running the Program is not restricted, and the output from the Program
 75 | is covered only if its contents constitute a work based on the
 76 | Program (independent of having been made by running the Program).
 77 | Whether that is true depends on what the Program does.
 78 | 
 79 |   1. You may copy and distribute verbatim copies of the Program's
 80 | source code as you receive it, in any medium, provided that you
 81 | conspicuously and appropriately publish on each copy an appropriate
 82 | copyright notice and disclaimer of warranty; keep intact all the
 83 | notices that refer to this License and to the absence of any warranty;
 84 | and give any other recipients of the Program a copy of this License
 85 | along with the Program.
 86 | 
 87 | You may charge a fee for the physical act of transferring a copy, and
 88 | you may at your option offer warranty protection in exchange for a fee.
 89 | 
 90 |   2. You may modify your copy or copies of the Program or any portion
 91 | of it, thus forming a work based on the Program, and copy and
 92 | distribute such modifications or work under the terms of Section 1
 93 | above, provided that you also meet all of these conditions:
 94 | 
 95 |     a) You must cause the modified files to carry prominent notices
 96 |     stating that you changed the files and the date of any change.
 97 | 
 98 |     b) You must cause any work that you distribute or publish, that in
 99 |     whole or in part contains or is derived from the Program or any
100 |     part thereof, to be licensed as a whole at no charge to all third
101 |     parties under the terms of this License.
102 | 
103 |     c) If the modified program normally reads commands interactively
104 |     when run, you must cause it, when started running for such
105 |     interactive use in the most ordinary way, to print or display an
106 |     announcement including an appropriate copyright notice and a
107 |     notice that there is no warranty (or else, saying that you provide
108 |     a warranty) and that users may redistribute the program under
109 |     these conditions, and telling the user how to view a copy of this
110 |     License.  (Exception: if the Program itself is interactive but
111 |     does not normally print such an announcement, your work based on
112 |     the Program is not required to print an announcement.)
113 | 
114 | These requirements apply to the modified work as a whole.  If
115 | identifiable sections of that work are not derived from the Program,
116 | and can be reasonably considered independent and separate works in
117 | themselves, then this License, and its terms, do not apply to those
118 | sections when you distribute them as separate works.  But when you
119 | distribute the same sections as part of a whole which is a work based
120 | on the Program, the distribution of the whole must be on the terms of
121 | this License, whose permissions for other licensees extend to the
122 | entire whole, and thus to each and every part regardless of who wrote it.
123 | 
124 | Thus, it is not the intent of this section to claim rights or contest
125 | your rights to work written entirely by you; rather, the intent is to
126 | exercise the right to control the distribution of derivative or
127 | collective works based on the Program.
128 | 
129 | In addition, mere aggregation of another work not based on the Program
130 | with the Program (or with a work based on the Program) on a volume of
131 | a storage or distribution medium does not bring the other work under
132 | the scope of this License.
133 | 
134 |   3. You may copy and distribute the Program (or a work based on it,
135 | under Section 2) in object code or executable form under the terms of
136 | Sections 1 and 2 above provided that you also do one of the following:
137 | 
138 |     a) Accompany it with the complete corresponding machine-readable
139 |     source code, which must be distributed under the terms of Sections
140 |     1 and 2 above on a medium customarily used for software interchange; or,
141 | 
142 |     b) Accompany it with a written offer, valid for at least three
143 |     years, to give any third party, for a charge no more than your
144 |     cost of physically performing source distribution, a complete
145 |     machine-readable copy of the corresponding source code, to be
146 |     distributed under the terms of Sections 1 and 2 above on a medium
147 |     customarily used for software interchange; or,
148 | 
149 |     c) Accompany it with the information you received as to the offer
150 |     to distribute corresponding source code.  (This alternative is
151 |     allowed only for noncommercial distribution and only if you
152 |     received the program in object code or executable form with such
153 |     an offer, in accord with Subsection b above.)
154 | 
155 | The source code for a work means the preferred form of the work for
156 | making modifications to it.  For an executable work, complete source
157 | code means all the source code for all modules it contains, plus any
158 | associated interface definition files, plus the scripts used to
159 | control compilation and installation of the executable.  However, as a
160 | special exception, the source code distributed need not include
161 | anything that is normally distributed (in either source or binary
162 | form) with the major components (compiler, kernel, and so on) of the
163 | operating system on which the executable runs, unless that component
164 | itself accompanies the executable.
165 | 
166 | If distribution of executable or object code is made by offering
167 | access to copy from a designated place, then offering equivalent
168 | access to copy the source code from the same place counts as
169 | distribution of the source code, even though third parties are not
170 | compelled to copy the source along with the object code.
171 | 
172 |   4. You may not copy, modify, sublicense, or distribute the Program
173 | except as expressly provided under this License.  Any attempt
174 | otherwise to copy, modify, sublicense or distribute the Program is
175 | void, and will automatically terminate your rights under this License.
176 | However, parties who have received copies, or rights, from you under
177 | this License will not have their licenses terminated so long as such
178 | parties remain in full compliance.
179 | 
180 |   5. You are not required to accept this License, since you have not
181 | signed it.  However, nothing else grants you permission to modify or
182 | distribute the Program or its derivative works.  These actions are
183 | prohibited by law if you do not accept this License.  Therefore, by
184 | modifying or distributing the Program (or any work based on the
185 | Program), you indicate your acceptance of this License to do so, and
186 | all its terms and conditions for copying, distributing or modifying
187 | the Program or works based on it.
188 | 
189 |   6. Each time you redistribute the Program (or any work based on the
190 | Program), the recipient automatically receives a license from the
191 | original licensor to copy, distribute or modify the Program subject to
192 | these terms and conditions.  You may not impose any further
193 | restrictions on the recipients' exercise of the rights granted herein.
194 | You are not responsible for enforcing compliance by third parties to
195 | this License.
196 | 
197 |   7. If, as a consequence of a court judgment or allegation of patent
198 | infringement or for any other reason (not limited to patent issues),
199 | conditions are imposed on you (whether by court order, agreement or
200 | otherwise) that contradict the conditions of this License, they do not
201 | excuse you from the conditions of this License.  If you cannot
202 | distribute so as to satisfy simultaneously your obligations under this
203 | License and any other pertinent obligations, then as a consequence you
204 | may not distribute the Program at all.  For example, if a patent
205 | license would not permit royalty-free redistribution of the Program by
206 | all those who receive copies directly or indirectly through you, then
207 | the only way you could satisfy both it and this License would be to
208 | refrain entirely from distribution of the Program.
209 | 
210 | If any portion of this section is held invalid or unenforceable under
211 | any particular circumstance, the balance of the section is intended to
212 | apply and the section as a whole is intended to apply in other
213 | circumstances.
214 | 
215 | It is not the purpose of this section to induce you to infringe any
216 | patents or other property right claims or to contest validity of any
217 | such claims; this section has the sole purpose of protecting the
218 | integrity of the free software distribution system, which is
219 | implemented by public license practices.  Many people have made
220 | generous contributions to the wide range of software distributed
221 | through that system in reliance on consistent application of that
222 | system; it is up to the author/donor to decide if he or she is willing
223 | to distribute software through any other system and a licensee cannot
224 | impose that choice.
225 | 
226 | This section is intended to make thoroughly clear what is believed to
227 | be a consequence of the rest of this License.
228 | 
229 |   8. If the distribution and/or use of the Program is restricted in
230 | certain countries either by patents or by copyrighted interfaces, the
231 | original copyright holder who places the Program under this License
232 | may add an explicit geographical distribution limitation excluding
233 | those countries, so that distribution is permitted only in or among
234 | countries not thus excluded.  In such case, this License incorporates
235 | the limitation as if written in the body of this License.
236 | 
237 |   9. The Free Software Foundation may publish revised and/or new versions
238 | of the General Public License from time to time.  Such new versions will
239 | be similar in spirit to the present version, but may differ in detail to
240 | address new problems or concerns.
241 | 
242 | Each version is given a distinguishing version number.  If the Program
243 | specifies a version number of this License which applies to it and "any
244 | later version", you have the option of following the terms and conditions
245 | either of that version or of any later version published by the Free
246 | Software Foundation.  If the Program does not specify a version number of
247 | this License, you may choose any version ever published by the Free Software
248 | Foundation.
249 | 
250 |   10. If you wish to incorporate parts of the Program into other free
251 | programs whose distribution conditions are different, write to the author
252 | to ask for permission.  For software which is copyrighted by the Free
253 | Software Foundation, write to the Free Software Foundation; we sometimes
254 | make exceptions for this.  Our decision will be guided by the two goals
255 | of preserving the free status of all derivatives of our free software and
256 | of promoting the sharing and reuse of software generally.
257 | 
258 |                             NO WARRANTY
259 | 
260 |   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
261 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
262 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
263 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
264 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
265 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
266 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
267 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
268 | REPAIR OR CORRECTION.
269 | 
270 |   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
271 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
272 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
273 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
274 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
275 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
276 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
277 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
278 | POSSIBILITY OF SUCH DAMAGES.
279 | 
280 |                      END OF TERMS AND CONDITIONS
281 | 
282 |             How to Apply These Terms to Your New Programs
283 | 
284 |   If you develop a new program, and you want it to be of the greatest
285 | possible use to the public, the best way to achieve this is to make it
286 | free software which everyone can redistribute and change under these terms.
287 | 
288 |   To do so, attach the following notices to the program.  It is safest
289 | to attach them to the start of each source file to most effectively
290 | convey the exclusion of warranty; and each file should have at least
291 | the "copyright" line and a pointer to where the full notice is found.
292 | 
293 |     {description}
294 |     Copyright (C) {year}  {fullname}
295 | 
296 |     This program is free software; you can redistribute it and/or modify
297 |     it under the terms of the GNU General Public License as published by
298 |     the Free Software Foundation; either version 2 of the License, or
299 |     (at your option) any later version.
300 | 
301 |     This program is distributed in the hope that it will be useful,
302 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
303 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
304 |     GNU General Public License for more details.
305 | 
306 |     You should have received a copy of the GNU General Public License along
307 |     with this program; if not, write to the Free Software Foundation, Inc.,
308 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
309 | 
310 | Also add information on how to contact you by electronic and paper mail.
311 | 
312 | If the program is interactive, make it output a short notice like this
313 | when it starts in an interactive mode:
314 | 
315 |     Gnomovision version 69, Copyright (C) year name of author
316 |     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
317 |     This is free software, and you are welcome to redistribute it
318 |     under certain conditions; type `show c' for details.
319 | 
320 | The hypothetical commands `show w' and `show c' should show the appropriate
321 | parts of the General Public License.  Of course, the commands you use may
322 | be called something other than `show w' and `show c'; they could even be
323 | mouse-clicks or menu items--whatever suits your program.
324 | 
325 | You should also get your employer (if you work as a programmer) or your
326 | school, if any, to sign a "copyright disclaimer" for the program, if
327 | necessary.  Here is a sample; alter the names:
328 | 
329 |   Yoyodyne, Inc., hereby disclaims all copyright interest in the program
330 |   `Gnomovision' (which makes passes at compilers) written by James Hacker.
331 | 
332 |   {signature of Ty Coon}, 1 April 1989
333 |   Ty Coon, President of Vice
334 | 
335 | This General Public License does not permit incorporating your program into
336 | proprietary programs.  If your program is a subroutine library, you may
337 | consider it more useful to permit linking proprietary applications with the
338 | library.  If this is what you want to do, use the GNU Lesser General
339 | Public License instead of this License.
340 | 
341 | 


--------------------------------------------------------------------------------
/Main.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | 
 3 | #include "Event.hpp"
 4 | #include "Window.hpp"
 5 | 
 6 | SDL_Window* Window::window;
 7 | SDL_Renderer* Window::renderer;
 8 | SDL_Rect Window::win_rect;
 9 | const double Window::fps = 30;
10 | const int Window::timer_wait_mil = 1.0 / Window::fps * 1000;
11 | Dnscript* Window::dnscript;
12 | const char* Window::win_title = "Dnscript ver 1.0";
13 | Event* Window::event;
14 | Keyboard* Window::keyboard;
15 | Frame* Window::frame;
16 | 
17 | /* entry point */
18 | int main(int argc,char *argv[]){
19 |   Window::win_rect.x = 100;
20 |   Window::win_rect.y = 100;
21 |   Window::win_rect.w = 900;
22 |   Window::win_rect.h = 600;
23 |   Window::init();
24 |   Window::dnscript = new Dnscript();
25 |   Window::main(argc,argv);
26 |   delete Window::dnscript;
27 | }
28 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | DEBUG		=  1
 2 | DNLANG 	=  Dnlang
 3 | DNLANGIR=  $(DNLANG)/IR
 4 | DNLANGRT=  $(DNLANG)/runtime
 5 | OBJS		=		Main.o Dnscript.o Title.o Select.o Game.o \
 6 | 						Event.o Keyboard.o Api.o Frame.o Object.o\
 7 | 						Game/Load.o Game/Clear.o Game/Play.o Game/Menu.o Game/Player.o\
 8 | 						Game/Bullet.o Game/Enemy.o\
 9 | 						test/player_test.o test/enemy_test.o\
10 | 
11 | DN_OBJS =	  $(DNLANG)/Lexer.o $(DNLANG)/DnLexer.o $(DNLANG)/Token.o $(DNLANG)/Parser.o \
12 | 						$(DNLANG)/DnParser.o $(DNLANG)/Scope.o $(DNLANG)/Symbol.o $(DNLANG)/Symbols.o \
13 | 						$(DNLANGIR)/AST.o $(DNLANGIR)/ASTVisitor.o \
14 | 
15 | IN_OBJS	=		$(DNLANGRT)/DnInLexer.o $(DNLANGRT)/DnInParser.o $(DNLANGRT)/Interprter.o \
16 | 
17 | CURPATH = 	$(shell pwd)
18 | INCLUDE =		$(CURPATH)/include
19 | DNSCRIPT=		$(CURPATH)/Dnscript
20 | DNTEST	=		$(CURPATH)/Dntest
21 | 
22 | CXX 		= 	g++ -fstack-protector-all -D_FORTIFY_SOURCE=2
23 | LIBSDL_CXXFLAGS = $(shell sdl2-config --cflags)
24 | LIBSDL_LDFLAGS  = $(shell sdl2-config --libs)
25 | 
26 | ifdef DEBUG
27 | 	CXXFLAG =		-Wall -I$(INCLUDE) -std=c++11 $(LIBSDL_CXXFLAGS) -fexceptions -g -o
28 | else
29 | 	CXXFLAG =		-Wall -I$(INCLUDE) -std=c++11 $(LIBSDL_CXXFLAGS) -fexceptions -o
30 | endif
31 | 
32 | LDFLAG	=		-Wl,-z,relro,-z,now -lSDL2_image $(LIBSDL_LDFLAGS) -lSDL2_gfx
33 | 
34 | CHKSEC	=		$(shell which checksec.sh)
35 | 
36 | all:
37 | 	$(MAKE) $(DNSCRIPT)
38 | 
39 | test:
40 | 	$(MAKE) $(DNTEST)
41 | 
42 | $(DNSCRIPT) : $(OBJS) $(DN_OBJS) $(IN_OBJS)
43 | 	$(CXX) $(CXXFLAG) $@ $^ $(LDFLAG)
44 | 
45 | $(DNTEST) : test/dnlang_test01.o $(DN_OBJS)
46 | 	$(CXX) $(CXXFLAG) $@ $^ $(LDFLAG)
47 | 
48 | security:
49 | ifneq ("$(CHKSEC)","")
50 | 	$(CHKSEC) --file $(DNSCRIPT)
51 | else
52 | 	echo '[**ERROR**] checksec.sh not found'
53 | endif
54 | 
55 | clean :
56 | 	rm -rf $(DNSCRIPT) $(DNTEST)
57 | 	find . -regex ".*\.o" -exec rm -rf {} \;
58 | 
59 | %.o : %.cpp
60 | 	$(CXX) $(CXXFLAG) $*.o -c $*.cpp
61 | 


--------------------------------------------------------------------------------
/Object.cpp:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Dnscript
 2 | Dnscript is specific scripting language specializing to build the "danmaku" in shooting game.
 3 | 
 4 | It's not stable yet. Any kind of bugs can be caused.
 5 | 
 6 | ## Usage
 7 | You can script action of enemy by changing DSL code in Dnlang/sample/enemy.dn
 8 | 
 9 | ```javascript:enemy.dn
10 | let count=0;
11 | let cx=GetCenterX();
12 | let imgEnemy = "img/Enemy.png";
13 | let imgAngle=0;
14 | let shotAngle=0;
15 | 
16 | function @Initialize() {
17 | 	LoadGraphic(imgEnemy);
18 | 	SetLife(1500);
19 | 	SetGraphicRect(1,1,32,32);
20 | 	SetTexture(imgEnemy);
21 | 	SetMovePosition02(cx+0,60,60);
22 | 	return;
23 | }
24 | 
25 | function @MainLoop() {
26 | 	if (count >= 30) {
27 | 		if (count % 180 == 0 && count < 4000) {
28 | 			SetMovePosition02(cx-50,100,20);
29 | 		}
30 | 		if(count % 180 == 90 && count < 4000){
31 | 			SetMovePosition02(cx+50,100,20);
32 | 		}
33 | 		if(count % 10 == 0){
34 | 			let angle = 0;
35 | 			while(angle < 360) {
36 | 				CreateShot01(GetX() + GetW() / 2, GetY() + GetH() / 2,10,angle,0,1);
37 | 				angle += 20;
38 | 			}
39 | 		}
40 | 	}
41 | 	++count;
42 | 	return;
43 | }
44 | 
45 | function @Finalize() {
46 | }
47 | 
48 | function @DrawLoop() {
49 | 	DrawGraphic(GetX(), GetY());
50 | 	return;
51 | }
52 | ```
53 | 
54 | ## Preview
55 | ![figure1](img/demo.png "Enemy action demo")
56 | 


--------------------------------------------------------------------------------
/Select.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include "Api.hpp"
 3 | #include "Object.hpp"
 4 | #include "Keyboard.hpp"
 5 | #include "Select.hpp"
 6 | #include "Dnscript.hpp"
 7 | 
 8 | Select::Select(){
 9 |   Api::create();
10 |   api = Api::instance();
11 |   keyboard = Keyboard::instance();
12 |   std::string filename("img/select.png");
13 |   obj_back = new Object();
14 |   api->LoadGraphic(obj_back,filename);
15 |   api->SetTexture(obj_back,filename);
16 |   SDL_Surface* image = obj_back->get_image();
17 |   api->SetGraphicRect(obj_back,0,0,image->w,image->h);
18 | }
19 | 
20 | Select::~Select(){
21 |   Api::destroy();
22 |   delete obj_back;
23 | }
24 | 
25 | void Select::update(Dnscript* parent){
26 |   if(keyboard->is_keyon(SDLK_SPACE)){
27 |     keyboard->keytoggle(SDLK_SPACE);
28 |     parent->moveTo(Dnscript::SEQ_GAME);
29 |   }
30 | }
31 | void Select::draw(){
32 |   api->RenderClear();
33 |   api->DrawGraphic(obj_back,0,0);
34 |   api->RenderPresent();  
35 | }
36 | 


--------------------------------------------------------------------------------
/Title.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <SDL.h>
 3 | #include "Api.hpp"
 4 | #include "Event.hpp"
 5 | #include "Object.hpp"
 6 | #include "Keyboard.hpp"
 7 | #include "Title.hpp"
 8 | #include "Dnscript.hpp"
 9 | 
10 | Title::Title(){
11 |   Api::create();
12 |   api = Api::instance();
13 |   keyboard = Keyboard::instance();
14 |   obj_back = new Object();
15 |   std::string filename("img/title.png");
16 |   api->LoadGraphic(obj_back,filename);
17 |   api->SetTexture(obj_back,filename);
18 |   SDL_Surface* image = obj_back->get_image();
19 |   api->SetGraphicRect(obj_back,0,0,image->w,image->h);
20 | }
21 | 
22 | Title::~Title(){
23 |   Api::destroy();
24 |   delete obj_back;
25 | }
26 | 
27 | void Title::update(Dnscript *parent){
28 |   if(keyboard->is_keyon(SDLK_SPACE)){
29 |     keyboard->keytoggle(SDLK_SPACE);
30 |     parent->moveTo(Dnscript::SEQ_STAGE_SELECT);
31 |   }
32 | }
33 | 
34 | void Title::draw(){
35 |   api->RenderClear();
36 |   api->DrawGraphic(obj_back,0,0);
37 |   api->RenderPresent();  
38 | }
39 | 


--------------------------------------------------------------------------------
/doc/api_list.md:
--------------------------------------------------------------------------------
 1 | #API List
 2 | 
 3 | ## Graphic
 4 | ### LoadGraphic(filename) *
 5 | filenameで指定された画像データを読み込む
 6 | ### DeleteGraphic(filename) 
 7 | filenameで指定された画像データを破棄する
 8 | ### SetTexture(filename) *
 9 | filenameで指定された画像データをテクスチャに設定する
10 | ### SetGraphicRect(sx,sy,dx,dy) *
11 | 左上,右下のテクスチャ座標で指定された長方形の描画範囲を設定する
12 | ### SetGraphicAngle(angle)
13 | グラフィックをangle度回転させる
14 | ### DrawGraphic(x,y) *
15 | 指定されたスクリーン座標を中心として描画する
16 | 
17 | ## Status
18 | ### SetCollisionA
19 | ### SetInitialBombCount(count) [プレイヤーのみ]
20 | 初期のボム数を設定する
21 | ### SetItemCollectLine(y) [プレイヤーのみ]
22 | アイテム回収ライン(y軸)
23 | ### SetGrazeCircle(r) [プレイヤーのみ]
24 | かすり判定の半径r
25 | ### SetIntersectionCircle(x,y,r) [プレイヤーのみ]
26 | 当たり判定の中心座標(x,y)と半径r
27 | ### SetSpeed(speed) *
28 | スピードを設定する
29 | ### SetLife(life) *
30 | 体力を設定する
31 | ### SetX(x) *
32 | x座標を設定する
33 | ### SetY(y) *
34 | y座標を設定する
35 | ### GetPlayerX() [プレイヤーのみ]*
36 | プレイヤーのx座標を取得する
37 | ### GetPlayerY() [プレイヤーのみ]*
38 | プレイヤーのy座標を取得する
39 | ### GetSpeedX() *
40 | x方向の速さdxを取得する
41 | ### GetSpeedY() *
42 | y方向の速さdyを取得する
43 | ### GetX() *
44 | 現在のx座標を取得する
45 | ### GetY() *
46 | 現在のx座標を取得する
47 | ### GetW() *
48 | 横幅を取得する
49 | ### GetH() *
50 | 縦幅を取得する
51 | ### GetCenterX() *
52 | マップの中心座標xを取得する
53 | ### GetCenterY() *
54 | マップの中心座標yを取得する
55 | 
56 | 
57 | ## Danmaku
58 | ### CreatePlayerShot01(x,y,speed,angle,damage,pene,id) ［プレイヤーのみ] -
59 | 座標(x,y)から速度speed,角度angle,貫通力peneの弾(id値で指定)を1発打つ
60 | ### CreateShot01(x,y,speed,angle,color,delay) *
61 | 座標(x,y)から速度speed,角度angleの弾を1発打つ
62 | colorは弾の色,delayは初弾が発射されるまでの遅延フレーム数
63 | 
64 | ## SpellCard
65 | ### CutIn(name,img,x1,y1,x2,y2)
66 | ラベルnameのカットインを表示する
67 | imgは表示画像,(x1,y1)(x2,y2)は描画元矩形
68 | 
69 | ## Action
70 | ### SetMovePosition02(x,y,frame) *
71 | 座標(x,y)にframeフレームかけて移動する
72 | 
73 | ## Keyboard 
74 | ### GetKeyState(key) *
75 | 指定したキーのステータスを返す
76 | (KEY_PUSH,KEY_HOLD)
77 | ## Other
78 | ### GetCurrentScriptDirectory() *
79 | 現在のディレクトリパスを取得する
80 | 
81 | 


--------------------------------------------------------------------------------
/img/CutinReimu.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/CutinReimu.png


--------------------------------------------------------------------------------
/img/Enemy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/Enemy.png


--------------------------------------------------------------------------------
/img/ExRumia.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/ExRumia.png


--------------------------------------------------------------------------------
/img/Reimu.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/Reimu.png


--------------------------------------------------------------------------------
/img/Rumia.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/Rumia.png


--------------------------------------------------------------------------------
/img/bullet.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/bullet.png


--------------------------------------------------------------------------------
/img/bullets.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/bullets.png


--------------------------------------------------------------------------------
/img/circle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/circle.png


--------------------------------------------------------------------------------
/img/demo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/demo.png


--------------------------------------------------------------------------------
/img/load.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/load.png


--------------------------------------------------------------------------------
/img/play.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/play.jpg


--------------------------------------------------------------------------------
/img/select.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/select.png


--------------------------------------------------------------------------------
/img/title.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RKX1209/Dnscript/fbbab172bfec8c7f1d43a650d44fa1a08e16cf1f/img/title.png


--------------------------------------------------------------------------------
/include/AST.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __AST_HPP__
 2 | #define __AST_HPP__
 3 | 
 4 | namespace Dnlang {
 5 | 
 6 | class AST {
 7 | public:
 8 |   Token token;
 9 |   std::vector<AST*> children;
10 |   AST *parent;
11 |   Scope *scope;
12 |   Symbol *symbol;
13 |   Type evalType;
14 |   Register *reg;
15 |   Label *_true, *_false, *_begin, *next; // if, while statement
16 |   std::string code;
17 |   int child_idx;
18 |   AST() : scope(0), symbol(0), parent(0), code("") { this->token.type = -1; this->token.text = ""; }
19 |   AST(Token _token) : scope(0), symbol(0), parent(0), code("") { this->token = _token; }
20 |   AST(int type) : scope(0), symbol(0), parent(0), code("") { this->token = Token(type); }
21 |   AST(const AST &ast) {
22 |     token = ast.token; parent = ast.parent;
23 |     evalType = ast.evalType;
24 |     scope = ast.scope; symbol = ast.symbol;
25 |   }
26 |   int getNodeType() { return token.type; }
27 |   std::string getRegId();
28 |   std::string getNodeText() { return token.text; }
29 |   AST *addChild(AST *_parent, AST *t) {
30 |     t->parent = _parent;
31 |     t->child_idx = children.size();
32 |     children.push_back(t);
33 |     return children[children.size() - 1];
34 |   }
35 |   bool isNil() { return token.type == -1; }
36 |   std::string toString();
37 |   std::string toStringTree(int depth);
38 | };
39 | 
40 | }
41 | #endif
42 | 


--------------------------------------------------------------------------------
/include/ASTVisitor.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef __AST_VISITOR_HPP__
  2 | #define __AST_VISITOR_HPP__
  3 | 
  4 | #include "Register.hpp"
  5 | 
  6 | namespace Dnlang {
  7 | 
  8 | class ASTVisitor {
  9 | public:
 10 |   Scope *currentScope;
 11 |   ASTVisitor(AST *root) { currentScope = root->scope; }
 12 |   void downup(AST *root);
 13 |   void enter(AST *t);
 14 |   void exit(AST *t);
 15 |   bool isExp(int type);
 16 |   bool isConst(int type);
 17 | 
 18 |   // = += /= ...
 19 |   bool isAssign(int type);
 20 | 
 21 |   // Relation == != <= >= < > ...
 22 |   bool isRel(int type);
 23 | 
 24 |   // ROOT
 25 |   virtual void enterRoot(AST *root);
 26 |   virtual void exitRoot(AST *root);
 27 | 
 28 |   // DECL
 29 |   virtual void enterDecl(AST *decl);
 30 |   virtual void exitDecl(AST *decl);
 31 | 
 32 |   // BLOCK
 33 |   virtual void enterBlock(AST *block);
 34 |   virtual void exitBlock(AST *block);
 35 | 
 36 |   // FUNC_DEF
 37 |   virtual void enterMethod(AST *method);
 38 |   virtual void exitMethod(AST *method);
 39 | 
 40 |   // RETURN
 41 |   virtual void enterReturn(AST *ret);
 42 |   virtual void exitReturn(AST *ret);
 43 | 
 44 |   // AREF
 45 |   virtual void enterAref(AST *aref);
 46 |   virtual void exitAref(AST *aref);
 47 | 
 48 |   // CALL
 49 |   virtual void enterCall(AST *call);
 50 |   virtual void exitCall(AST *call);
 51 | 
 52 |   // ASSIGN
 53 |   virtual void enterAssign(AST *assign);
 54 |   virtual void exitAssign(AST *assign);
 55 | 
 56 |   // WHILE
 57 |   virtual void enterWhile(AST *loop);
 58 |   virtual void exitWhile(AST *loop);
 59 | 
 60 |   // IF
 61 |   virtual void enterIf(AST *cond);
 62 |   virtual void exitIf(AST *cond);
 63 | 
 64 |   // OROR(||)
 65 |   virtual void enterOror(AST *oror);
 66 |   virtual void exitOror(AST *oror);
 67 | 
 68 |   // ANDAND(&&)
 69 |   virtual void enterAndand(AST *andand);
 70 |   virtual void exitAndand(AST *andand);
 71 | 
 72 |   // NOT(!)
 73 |   virtual void enterNot(AST *_not);
 74 |   virtual void exitNot(AST *_not);
 75 | 
 76 |   //Relations
 77 |   virtual void enterRel(AST *rel);
 78 |   virtual void exitRel(AST *rel);
 79 | 
 80 |   virtual void enterId(AST *id);
 81 |   virtual void exitId(AST *id);
 82 | 
 83 |   virtual void enterExp(AST *exp);
 84 |   virtual void exitExp(AST *exp);
 85 | 
 86 |   virtual void enterConst(AST *_const);
 87 |   virtual void exitConst(AST *_const);
 88 | 
 89 | };
 90 | 
 91 | class Semantics : public ASTVisitor {
 92 | public:
 93 |   Semantics(AST *root) : ASTVisitor(root) {}
 94 |   void enterBlock(AST *block);
 95 |   void exitBlock(AST *block);
 96 |   void enterId(AST *id);
 97 |   void enterMethod(AST *method);
 98 |   void exitMethod(AST *method);
 99 |   void exitDecl(AST *decl);
100 |   void exitReturn(AST *ret);
101 |   void exitAref(AST *aref);
102 |   void exitCall(AST *call);
103 |   void exitExp(AST *exp);
104 |   void enterConst(AST *_const);
105 |   void exitAssign(AST *assign);
106 | };
107 | 
108 | class CodeGen : public ASTVisitor {
109 | public:
110 |   Register *r0;
111 |   int reg_index;
112 |   int label_index;
113 |   CodeGen(AST *root);
114 |   Register *genReg();
115 |   Register *getRetReg() { return r0; };
116 |   Label *genLabel();
117 |   void exitRoot(AST *root);
118 |   void exitBlock(AST *block);
119 |   void exitId(AST *id);
120 |   void exitMethod(AST *method);
121 |   void exitDecl(AST *decl);
122 |   void exitReturn(AST *ret);
123 |   void exitAref(AST *aref);
124 |   void exitCall(AST *call);
125 |   void exitExp(AST *exp);
126 |   void exitConst(AST *_const);
127 |   void exitAssign(AST *assign);
128 |   void enterWhile(AST *loop);
129 |   void exitWhile(AST *loop);
130 |   void enterIf(AST *cond);
131 |   void exitIf(AST *cond);
132 |   void enterOror(AST *oror);
133 |   void exitOror(AST *oror);
134 |   void enterAndand(AST *andand);
135 |   void exitAndand(AST *andand);
136 |   void enterNot(AST *_not);
137 |   void exitNot(AST *_not);
138 |   void enterRel(AST *rel);
139 |   void exitRel(AST *rel);
140 |   void joinCodes(AST *parent);
141 |   void genTfLabel(AST *tf);
142 | };
143 | 
144 | }
145 | #endif
146 | 


--------------------------------------------------------------------------------
/include/Action.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __ACTION_HPP__
 2 | #define __ACTION_HPP__
 3 | 
 4 | #include <map>
 5 | #include <deque>
 6 | 
 7 | class Bullet;
 8 | class Action{
 9 | public:
10 |   enum Type{
11 |     TYPE_MOVE,
12 |     TYPE_SHOOT,
13 |     TYPE_NONE,
14 |   };
15 | private:
16 |   Type type;
17 |   /* Move Action */
18 |   int mx;
19 |   int my;
20 |   int dx;
21 |   int dy;
22 |   int move_frame;
23 |   /* Shoot Action */
24 |   Bullet* bullet;
25 | public:
26 |   Action(Type _type){ type = _type; }
27 |   ~Action(){}
28 |   Type get_type(){ return type; }
29 |   void set_move(int _x,int _y,int _dx,int _dy,int _mframe){ mx = _x; my = _y; dx = _dx; dy = _dy; move_frame = _mframe; }
30 |   void set_bullet(Bullet* _bullet){ bullet = _bullet; }
31 |   int get_move_frame(){ return move_frame; }
32 |   int get_dx(){ return dx; }
33 |   int get_dy(){ return dy; }
34 |   Bullet* get_bullet(){ return bullet; }
35 | };
36 | 
37 | class ActionList{
38 | private:
39 |   std::map<int, std::deque<Action> > actions;
40 | public:
41 |   void add_action(int _f,Action act){
42 |     if(actions.find(_f) == actions.end()){
43 |       actions[_f] = std::deque<Action>();
44 |     }
45 |     actions[_f].push_back(act);
46 |   }
47 |   Action get_action(int _f){
48 |     if(actions.find(_f) == actions.end()){
49 |       return Action(Action::TYPE_NONE);
50 |     }
51 |     if(actions[_f].empty()){
52 |       return Action(Action::TYPE_NONE);
53 |     }
54 |     
55 |     Action res = actions[_f].front();
56 |     actions[_f].pop_front();
57 |     return res;
58 |   }
59 | };
60 | 
61 | #endif
62 | 


--------------------------------------------------------------------------------
/include/Api.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef __API_HPP__
  2 | #define __API_HPP__
  3 | 
  4 | #include <string>
  5 | #include <SDL.h>
  6 | #include <SDL_image.h>
  7 | #include "Bullet.hpp"
  8 | /* ### Singleton class ### */
  9 | class Object;
 10 | class Keyboard;
 11 | class Api{
 12 | public:
 13 |   enum KeyState{
 14 |     KEY_PUSH,
 15 |     KEY_HOLD,
 16 |     KEY_RELEASE,
 17 |   };
 18 | private:
 19 |   Api();
 20 |   ~Api(){;}
 21 |   Api(const Api&){;}
 22 |   static Api* mInstance;
 23 |   Keyboard* keyboard;
 24 | public:
 25 |   static Api* instance();
 26 |   static void create();
 27 |   static void destroy();
 28 | 
 29 |   /* Graphic */
 30 |   void LoadGraphic(Object*,std::string);
 31 |   void SetTexture(Object*,std::string);
 32 |   void SetGraphicRect(Object*,Uint32,Uint32,Uint32,Uint32);
 33 |   //void SetGraphicPos(Object*,Uint32,Uint32,Uint32,Uint32);
 34 |   void SetGraphicAngle(Object*,Uint32);
 35 |   void DrawGraphic(Object*,Uint32,Uint32);
 36 | 
 37 |   /* Status */
 38 |   void SetSpeed(Object*,int);
 39 |   void SetLife(Object*,int);
 40 |   void SetX(Object*,int);
 41 |   void SetY(Object*,int);
 42 |   int GetPlayerX(Object*);
 43 |   int GetPlayerY(Object*);
 44 |   int GetSpeedX(Object*);
 45 |   int GetSpeedY(Object*);
 46 |   int GetX(Object*);
 47 |   int GetY(Object*);
 48 |   int GetMX(Object*);
 49 |   int GetMY(Object*);
 50 |   int GetW(Object*);
 51 |   int GetH(Object*);
 52 |   int GetCenterX();
 53 |   int GetCenterY();
 54 | 
 55 |   /* Danmaku */
 56 |   void CreatePlayerShot01(Object*,int,int,double,double,double,int,int);
 57 |   void CreateShot01(Object*,int,int,double,double,Bullet::Color,int);
 58 |   /* SpellCard */
 59 |   void CutIn(Object*,std::string,std::string,int,int,int,int);
 60 |   /* Action */
 61 |   void SetMovePosition02(Object*,int,int,int);
 62 |   /* Keyboard */
 63 |   KeyState GetKeyState(SDL_Keycode);
 64 |   /* Other */
 65 |   std::string GetCurrentScriptDirectory();
 66 |   /* Unofficial API (hidden) */
 67 |   void RenderClear();
 68 |   void RenderPresent();
 69 | 
 70 |   /* ####### ABI (interface to Dnlang) ####### */
 71 |   /* Graphic */
 72 |   void _LoadGraphic(Object*,double);
 73 |   void _SetTexture(Object*,double);
 74 |   void _SetGraphicRect(Object*,double,double,double,double);
 75 |   void _SetGraphicPos(Object*,double,double,double,double);
 76 |   void _SetGraphicAngle(Object*,double);
 77 |   void _DrawGraphic(Object*,double,double);
 78 | 
 79 |   /* Status */
 80 |   void _SetSpeed(Object*,double);
 81 |   void _SetLife(Object*,double);
 82 |   void _SetX(Object*,double);
 83 |   void _SetY(Object*,double);
 84 |   int _GetPlayerX(Object*);
 85 |   int _GetPlayerY(Object*);
 86 |   int _GetSpeedX(Object*);
 87 |   int _GetSpeedY(Object*);
 88 |   int _GetX(Object*);
 89 |   int _GetY(Object*);
 90 |   int _GetMX(Object*);
 91 |   int _GetMY(Object*);
 92 |   int _GetW(Object*);
 93 |   int _GetH(Object*);
 94 |   int _GetCenterX();
 95 |   int _GetCenterY();
 96 | 
 97 |   /* Danmaku */
 98 |   void _CreatePlayerShot01(Object*,double,double,double,double,double,double,double);
 99 |   void _CreateShot01(Object*,double,double,double,double,double,double);
100 |   /* SpellCard */
101 |   void _CutIn(Object*,double,double,double,double,double,double);
102 |   /* Action */
103 |   void _SetMovePosition02(Object*,double,double,double);
104 |   /* Keyboard */
105 |   KeyState _GetKeyState(double);
106 |   /* Other */
107 |   std::string _GetCurrentScriptDirectory();
108 | 
109 | };
110 | 
111 | #endif
112 | 


--------------------------------------------------------------------------------
/include/Bullet.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __BULLET_HPP__
 2 | #define __BULLET_HPP__
 3 | 
 4 | #include <SDL.h>
 5 | 
 6 | class Api;
 7 | class Object;
 8 | class Bullet{
 9 | public:
10 |   enum Type{
11 |     TYPE_NORMAL,
12 |     TYPE_BOMB,
13 |   };
14 |   enum State{
15 |     STATE_SHOT,
16 |     STATE_RESERVE,
17 |     STATE_NONE,
18 |   };
19 |   enum Color{
20 |     RED,
21 |     GREEN,
22 |     BLUE,
23 |     YELLOW,
24 |     PURPLE,
25 |     LIGHT_BLUE,
26 |     GRAY,
27 |     ORANGE,
28 |   };
29 | private:
30 |   Api* api;
31 |   int id;
32 |   SDL_Rect draw_rect;
33 |   int x;
34 |   int y;
35 |   double speed;
36 |   double angle;
37 |   double damage;
38 |   int pene;
39 |   State state;
40 |   Type type;
41 |   Color color;
42 | public:
43 |   Object* obj_back;
44 |   Bullet();
45 |   ~Bullet();
46 |   void update();
47 |   void draw();
48 |   bool available();
49 |   bool is_shoot();
50 |   int get_id();
51 |   void shoot();
52 |   void reserve();
53 |   void set_state(int,int,double,double,double,int);
54 |   void set_type(Type,Color);
55 |   void load_data(Type,Color);
56 | };
57 | 
58 | #endif
59 | 


--------------------------------------------------------------------------------
/include/Clear.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __CLEAR_HPP__
 2 | #define __CLEAR_HPP__
 3 | class Object;
 4 | class Game;
 5 | class Api;
 6 | class Keyboard;
 7 | 
 8 | class Clear{
 9 | private:
10 |   Api* api;
11 |   Keyboard* keyboard;
12 | public:
13 |   Object* obj_back;
14 |   Clear();
15 |   ~Clear();
16 |   void update(Game*);
17 |   void draw();
18 | };
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/include/DnInLexer.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __DNINLEXER_HPP__
 2 | #define __DNINLEXER_HPP__
 3 | 
 4 | namespace Dnlang {
 5 | class DnInLexer : public Lexer {
 6 | public:
 7 |   enum {
 8 |     EOF_TYPE = 1,
 9 |     /* reserved words */
10 |     IF, GOTO, CALL, PARAM, RET,
11 |     /* assign words */
12 |     EQUAL,
13 |     /* binary operations */
14 |     MUL, PLUS, MINUS, AND, DIV, MOD, NOT,
15 |     /* relations */
16 |     LESS, LESSEQUAL, ABOVE, ABOVEEQUAL, EQUALEQUAL,
17 |     /* const*/
18 |     INTCONST, FLOATCONST, STRING,
19 |     ADDR,
20 |   };
21 |   static const std::string token_names[];
22 |   static const std::string reserved[];
23 |   DnInLexer(std::string input) : Lexer(input) { }
24 |   virtual std::string get_token_name(int x) { return token_names[x]; }
25 |   virtual Token nextToken();
26 |   int isReserved(std::string str);
27 |   Token IntConst();
28 |   Token FloatConst();
29 |   Token String();
30 |   Token Addr();
31 | };
32 | 
33 | }
34 | #endif
35 | 


--------------------------------------------------------------------------------
/include/DnInParser.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __DNINPARSER_HPP__
 2 | #define __DNINPARSER_HPP__
 3 | 
 4 | namespace Dnlang {
 5 | 
 6 | class DnInParser : Parser {
 7 | public:
 8 |   std::map<std::string, double> syms;
 9 |   std::map<int, std::string> revmap; // addr |-> string value
10 |   std::map<std::string, int> labels;
11 |   std::vector<double> stack;
12 |   DnInLexer *lexer;
13 |   Api *api;
14 |   Object *target;
15 |   int pc;
16 |   DnInParser(Object *_target) : Parser(""), pc(0), target(_target){
17 |     api = Api::instance();
18 |   }
19 |   ~DnInParser() {
20 |   }
21 |   void execline(std::string oneline, int _pc);
22 |   void defLabel(std::string lab, int line) { labels[lab] = line; }
23 |   int defString(std::string str);
24 |   int getLabel(std::string lab) {
25 |     if (labels.find(lab) == labels.end()) return -1;
26 |     return labels[lab];
27 |   }
28 |   int getPC() { return pc; }
29 |   void setRetVal(double val);
30 |   double getVal(Token token);
31 |   void setVal(Token token, double val);
32 |   void Addr3();
33 |   void Assign();
34 |   double RVal();
35 |   double Operation();
36 |   void Jump();
37 |   void CondJump();
38 |   bool Cond();
39 |   void CallFunc();
40 |   void Param();
41 |   void Ret();
42 |   void dump();
43 |   void TestLex();
44 | };
45 | 
46 | }
47 | #endif
48 | 


--------------------------------------------------------------------------------
/include/DnLexer.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __DNLEXER_HPP__
 2 | #define __DNLEXER_HPP__
 3 | 
 4 | namespace Dnlang {
 5 | class DnLexer : public Lexer {
 6 | public:
 7 |   enum {
 8 |     EOF_TYPE = 1,
 9 |     /* Reserved words */
10 |     BREAK, CONTINUE, ELSE, FOR, FUNCTION, IF, LET, RETURN, SWITCH,
11 |     WHILE, ID,
12 |     /* Constants */
13 |     INTCONST, CHARCONST, FLOATCONST, STRING,
14 | 
15 |     SEMICORON, COMMA, LBRACKA, RBRACKA, LBRACK, RBRACK, LBRACKB, RBRACKB,
16 |     /* Assignment */
17 |     MULASSIGN, DIVASSIGN, MODASSIGN, PLUSASSIGN, MINUSASSIGN,
18 |     ANDASSIGN, ORASSIGN, XORASSIGN, EQUAL,
19 |     /* Expressions */
20 |     OROR, OR, ANDAND, AND, XOR, NOT, PLUS, MINUS, MUL, DIV, MOD,
21 |     PLUSPLUS, MINUSMINUS,
22 |     /* Relation */
23 |     LESSLESS, ABOVEABOVE, EQUALEQUAL, NOTEQUAL,
24 |     LESS, LESSEQUAL, ABOVE, ABOVEEQUAL,
25 | 
26 |     /* virtual token for AST */
27 |     FUNC_DEF, DECL, AREF, CALL, PARAM, ASSIGN,
28 |     INITIALIZER, EXP, BLOCK, UNARYEXP, PRIMARYEXP,
29 |   };
30 |   static const std::string token_names[];
31 |   static const std::string reserved[];
32 |   DnLexer(std::string input) : Lexer(input) { }
33 |   virtual std::string get_token_name(int x) { return token_names[x]; }
34 |   virtual Token nextToken();
35 |   int isReserved(std::string str);
36 |   Token IntConst();
37 |   Token CharConst();
38 |   Token FloatConst();
39 |   Token String();
40 |   Token Id();  
41 | };
42 | 
43 | }
44 | #endif
45 | 


--------------------------------------------------------------------------------
/include/DnParser.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef __DNPARSER_HPP__
  2 | #define __DNPARSER_HPP__
  3 | 
  4 | namespace Dnlang {
  5 | class DnParser : public Parser {
  6 | public:
  7 |   DnLexer *dnlexer;
  8 |   AST *ast_root;
  9 |   DnParser(std::string script) : Parser(script) {
 10 |     dnlexer = new DnLexer(script);
 11 |     ast_root = new AST();
 12 |     ast_root->scope = new GlobalScope();
 13 |     input = dnlexer;
 14 |   }
 15 |   ~DnParser() {
 16 |     delete ast_root;
 17 |     delete dnlexer;
 18 |   }
 19 |   AST *get_AST() { return ast_root; }
 20 |   void TranslationUnit();
 21 |   void ExternalDecl();
 22 |   void FunctionDef();
 23 |   void Decl();
 24 |   void DeclList();
 25 |   void DeclSpecs();
 26 |   void FuncSpec();
 27 |   void TypeSpec();
 28 |   void InitDeclList();
 29 |   void InitDecl();
 30 |   void Declarator();
 31 |   void IdList();
 32 |   void Initializer();
 33 |   void Stat();
 34 |   void ExpStat();
 35 |   void CompoundStat();
 36 |   void StatList();
 37 |   void SelectionStat();
 38 |   void IterationStat();
 39 |   void JumpStat();
 40 |   void Exp();
 41 |   void AssignExp();
 42 |   void AssignOperator();
 43 |   void ConditionalExp();
 44 |   void LogicalOrExp();
 45 |   void LogicalAndExp();
 46 |   void InclusiveOrExp();
 47 |   void ExclusiveOrExp();
 48 |   void AndExp();
 49 |   void EqualityExp();
 50 |   void RelationalExp();
 51 |   void ShiftExp();
 52 |   void AdditiveExp();
 53 |   void MultExp();
 54 |   void UnaryExp();
 55 |   void UnaryOperator();
 56 |   void PostfixExp();
 57 |   void PrimaryExp();
 58 |   void ArgumentExpList();
 59 |   void Const();
 60 | 
 61 |   void _TranslationUnit();
 62 |   void _ExternalDecl();
 63 |   void _FunctionDef();
 64 |   void _Decl();
 65 |   void _DeclList();
 66 |   void _DeclSpecs();
 67 |   void _FuncSpec();
 68 |   void _TypeSpec();
 69 |   void _InitDeclList();
 70 |   void _InitDecl();
 71 |   void _Declarator();
 72 |   void _IdList();
 73 |   void _Initializer();
 74 |   void _Stat();
 75 |   void _ExpStat();
 76 |   void _CompoundStat();
 77 |   void _StatList();
 78 |   void _SelectionStat();
 79 |   void _IterationStat();
 80 |   void _JumpStat();
 81 |   void _Exp();
 82 |   void _AssignExp();
 83 |   void _AssignOperator();
 84 |   void _ConditionalExp();
 85 |   void _LogicalOrExp();
 86 |   void _LogicalAndExp();
 87 |   void _InclusiveOrExp();
 88 |   void _ExclusiveOrExp();
 89 |   void _AndExp();
 90 |   void _EqualityExp();
 91 |   void _RelationalExp();
 92 |   void _ShiftExp();
 93 |   void _AdditiveExp();
 94 |   void _MultExp();
 95 |   void _UnaryExp();
 96 |   void _UnaryOperator();
 97 |   void _PostfixExp();
 98 |   void _PrimaryExp();
 99 |   void _ArgumentExpList();
100 |   void _Const();
101 | };
102 | }
103 | #endif
104 | 


--------------------------------------------------------------------------------
/include/Dnscript.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __DNSCRIPT_HPP__
 2 | #define __DNSCRIPT_HPP__
 3 | 
 4 | class Title;
 5 | class Select;
 6 | class Game;
 7 | class Event;
 8 | 
 9 | class Dnscript{
10 | public:
11 |   enum SeqID{
12 |     SEQ_TITLE,
13 |     SEQ_STAGE_SELECT,
14 |     SEQ_GAME,
15 |     SEQ_NONE,
16 |   };
17 | private:
18 |   Title* title;
19 |   Select* select;
20 |   Game* game;
21 |   SeqID next;
22 | public:
23 |   Dnscript(void);
24 |   ~Dnscript(void);
25 |   void update(void);
26 |   void draw(void);
27 |   void moveTo(SeqID);
28 | };
29 | 
30 | #endif
31 | 


--------------------------------------------------------------------------------
/include/Enemy.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __ENEMY_HPP__
 2 | #define __ENEMY_HPP__
 3 | 
 4 | #include <vector>
 5 | #include "Object.hpp"
 6 | 
 7 | class Object;
 8 | class Api;
 9 | class Keyboard;
10 | class Bullet;
11 | class Frame;
12 | class Enemy : public Object{
13 | public:
14 |   enum State{
15 |     STATE_MOVE = 1,
16 |     STATE_SHOOT = 2,
17 |   };
18 | private:
19 |   Api* api;
20 |   Keyboard* keyboard;
21 |   static const int bullet_num = 500;
22 |   std::vector<Bullet*>bullets;
23 |   unsigned int state;
24 |   Frame* frame;
25 |   int speed;
26 |   int life;
27 |   int bomb_num;
28 |   int graze;
29 |   int move_frame;
30 | public:
31 |   Enemy();
32 |   ~Enemy();
33 |   void update();
34 |   void draw();
35 |   virtual void shoot(int,int,double,double,double,int,int);
36 |   virtual void shoot(int,int,double,double,double,int,Bullet::Color,int);
37 |   void start_move(int,int,int);
38 |   virtual void set_x(int _x){ obj_pos->x = _x; }
39 |   virtual void set_y(int _y){ obj_pos->y = _y; }
40 |   virtual int get_x(){ return obj_pos->x; }
41 |   virtual int get_y(){ return obj_pos->y; }
42 |   virtual int get_mx(){ return mx; }
43 |   virtual int get_my(){ return my; }
44 |   virtual int get_width(){ return obj_rect->w; }
45 |   virtual int get_height(){ return obj_rect->h; }
46 |   virtual void set_speed(int _speed){ speed = _speed; }
47 |   virtual void set_life(int _life){ life = _life; }
48 |   virtual void set_bomb_num(int _bnum){ bomb_num = _bnum; }
49 |   virtual void set_graze(int _graze){ graze = _graze; }
50 |   void set_state(State);
51 |   void remove_state(State);
52 |   bool is_state(State);
53 |   void clear_state(){ state = 0; }
54 | };
55 | 
56 | #endif
57 | 


--------------------------------------------------------------------------------
/include/Event.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __EVENT_HPP__
 2 | #define __EVENT_HPP__
 3 | 
 4 | #include <SDL.h>
 5 | /* ### Singleton class ### */
 6 | class Event{
 7 | private:
 8 |   SDL_Event event;
 9 |   Event(){;}
10 |   ~Event(){;}
11 |   Event(const Event&){;}
12 |   static Event* mInstance;
13 | public:
14 |   static Event* instance();
15 |   static void create();
16 |   static void destroy();
17 |   void set_event(SDL_Event _ev){ event = _ev; }
18 |   SDL_Event get_event(){ return event; }
19 |   SDL_Keycode get_keycode(){ return event.key.keysym.sym; }
20 | };
21 | 
22 | #endif
23 | 


--------------------------------------------------------------------------------
/include/Frame.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __FRAME_HPP__
 2 | #define __FRAME_HPP__
 3 | 
 4 | /* ### Singleton class ### */
 5 | class Frame{
 6 | private:
 7 |   int frame;
 8 |   Frame();
 9 |   ~Frame(){;}
10 |   Frame(const Frame&){;}
11 |   static Frame* mInstance;
12 | public:
13 |   void count_up();
14 |   int get_frame();
15 |   int get_next_frame(int);
16 |   static const int FRAME_MAX = 0x1000000;
17 |   static Frame* instance();
18 |   static void create();
19 |   static void destroy();
20 | };
21 | #endif
22 | 


--------------------------------------------------------------------------------
/include/Game.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __GAME_HPP__
 2 | #define __GAME_HPP__
 3 | 
 4 | #include "Dnscript.hpp"
 5 | 
 6 | class Load;
 7 | class Clear;
 8 | class Play;
 9 | class Menu;
10 | 
11 | 
12 | class Game{
13 | public:
14 |   enum SeqID{
15 |     SEQ_LOAD,
16 |     SEQ_CLEAR,
17 |     SEQ_PLAY,
18 |     SEQ_MENU,
19 |     SEQ_NONE,
20 |   };
21 | private:
22 |   Load* load;
23 |   Clear* clear;
24 |   Play* play;
25 |   Menu* menu;
26 |   SeqID next;
27 | public:
28 |   Game();
29 |   ~Game();
30 |   void update(Dnscript*);
31 |   void draw();
32 |   void moveTo(SeqID);
33 |   void load_data();
34 | };
35 | 
36 | #endif
37 | 


--------------------------------------------------------------------------------
/include/Interprter.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __INTERPRETER_HPP__
 2 | #define __INTERPRETER_HPP__
 3 | 
 4 | #include "Token.hpp"
 5 | #include "Lexer.hpp"
 6 | #include "DnLexer.hpp"
 7 | #include "DnInLexer.hpp"
 8 | #include "Parser.hpp"
 9 | #include "Symbol.hpp"
10 | #include "Scope.hpp"
11 | #include "Symbols.hpp"
12 | #include "Register.hpp"
13 | #include "AST.hpp"
14 | #include "DnParser.hpp"
15 | #include "ASTVisitor.hpp"
16 | #include "DnInParser.hpp"
17 | 
18 | namespace Dnlang {
19 | 
20 | class Interprter {
21 | public:
22 |   Object *target;
23 |   std::string path;
24 |   std::string script;
25 |   std::vector<std::string> code;
26 | 
27 |   Dnlang::DnParser *parser;
28 |   Dnlang::AST *ast;
29 |   Dnlang::Semantics *seman;
30 |   Dnlang::CodeGen *cgen;
31 | 
32 |   Dnlang::DnInParser *inparser;
33 | 
34 |   Interprter(Object *obj, std::string _path);
35 |   ~Interprter();
36 |   void load_script();
37 |   void compile();
38 |   void preprocess();
39 |   void execLabel(std::string lab);
40 |   void Initialize();
41 |   void MainLoop();
42 |   void DrawLoop();
43 |   void _Init();
44 | };
45 | 
46 | }
47 | 
48 | #endif
49 | 


--------------------------------------------------------------------------------
/include/Keyboard.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __KEYBOARD_HPP__
 2 | #define __KEYBOARD_HPP__
 3 | 
 4 | #include <map>
 5 | 
 6 | /* ### Singleton class ### */
 7 | class Keyboard{
 8 | private:
 9 |   enum State{
10 |     KEY_PUSH,
11 |     KEY_RELEASE,
12 |     KEY_TOGGLE
13 |   };
14 |   std::map<SDL_Keycode,State> keys;
15 |   Keyboard(){;}
16 |   ~Keyboard(){;}
17 |   Keyboard(const Keyboard&){;}
18 |   static Keyboard* mInstance;
19 | public:
20 |   bool is_keyon(SDL_Keycode key);
21 |   bool is_keyoff(SDL_Keycode key);
22 |   bool is_keytoggle(SDL_Keycode key);
23 |   void keyon(SDL_Keycode key);
24 |   void keyoff(SDL_Keycode key);
25 |   void keytoggle(SDL_Keycode key);
26 |   static Keyboard* instance();
27 |   static void create();
28 |   static void destroy();
29 | 
30 | };
31 | 
32 | #endif
33 | 


--------------------------------------------------------------------------------
/include/Lexer.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __LEXER_HPP__
 2 | #define __LEXER_HPP__
 3 | 
 4 | 
 5 | class Lexer {
 6 | public:
 7 |   static const char LEX_EOF;
 8 |   std::string input;
 9 |   int p;
10 |   char c;
11 |   Lexer();
12 |   Lexer(std::string _input);
13 |   void consume();
14 |   void match(char x);
15 |   virtual std::string get_token_name(int x) {}
16 |   virtual Token nextToken() {}
17 |   virtual bool isDecimal();
18 |   virtual bool isLetter();
19 |   virtual bool isChar();
20 |   virtual bool isFloat();
21 |   virtual bool isString();
22 |   virtual bool isSym();
23 |   virtual bool isId();
24 |   virtual void skipSpaces();
25 | };
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/include/Load.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __LOAD_HPP__
 2 | #define __LOAD_HPP__
 3 | class Object;
 4 | class Game;
 5 | class Api;
 6 | class Keyboard;
 7 | 
 8 | class Load{
 9 | private:
10 |   Api* api;
11 |   Keyboard* keyboard;
12 |   bool loading;
13 | public:
14 |   Object* obj_back;
15 |   Load();
16 |   ~Load();
17 |   void update(Game*);
18 |   void draw();
19 | };
20 | 
21 | #endif
22 | 


--------------------------------------------------------------------------------
/include/Menu.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __MENU_HPP__
 2 | #define __MENU_HPP__
 3 | class Object;
 4 | class Game;
 5 | class Api;
 6 | class Keyboard;
 7 | 
 8 | class Menu{
 9 | private:
10 |   Api* api;
11 |   Keyboard* keyboard;
12 | public:
13 |   Object* obj_back;
14 |   Menu();
15 |   ~Menu();
16 |   void update(Game*);
17 |   void draw();
18 | };
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/include/Object.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __OBJECT_HPP__
 2 | #define __OBJECT_HPP__
 3 | 
 4 | #include <SDL.h>
 5 | #include "Bullet.hpp"
 6 | #include "Action.hpp"
 7 | class Texture;
 8 | class Bullet;
 9 | class Object{
10 | private:
11 |   SDL_Surface* image;
12 |   SDL_Texture* texture;
13 | protected:
14 |   SDL_Rect* obj_rect;
15 |   SDL_Rect* obj_pos;
16 |   int dx;
17 |   int dy;
18 |   int mx;
19 |   int my;
20 |   ActionList* action_list;
21 | public:
22 |   Object(){
23 |     obj_rect = new SDL_Rect;
24 |     obj_pos = new SDL_Rect;
25 |     obj_pos->x = 0;
26 |     obj_pos->y = 0;
27 |     obj_pos->w = 0;
28 |     obj_pos->h = 0;
29 |     action_list = new ActionList();
30 |   }
31 |   ~Object(){
32 |     delete obj_rect;
33 |     delete obj_pos;
34 |     delete action_list;
35 |     SDL_FreeSurface(image);
36 |     SDL_DestroyTexture(texture);
37 |   }
38 |   SDL_Surface* get_image(){ return this->image; }
39 |   void set_image(SDL_Surface *_image){ this->image = _image; }
40 | 
41 |   SDL_Texture* get_texture(){ return this->texture; }
42 |   void set_texture(SDL_Texture *_tex){ this->texture = _tex; }
43 | 
44 |   SDL_Rect* get_obj_rect(){ return this->obj_rect; }
45 |   void set_obj_rect(Uint32 _x,Uint32 _y,Uint32 _w,Uint32 _h){
46 |     obj_rect->x = _x;
47 |     obj_rect->y = _y;
48 |     obj_rect->w = _w;
49 |     obj_rect->h = _h;
50 |   }
51 |   SDL_Rect* get_obj_pos(){ return this->obj_pos; }
52 |   void set_obj_pos(Uint32 _x,Uint32 _y){
53 |     obj_pos->x = _x;
54 |     obj_pos->y = _y;
55 |     obj_pos->w = obj_rect->w;
56 |     obj_pos->h = obj_rect->h;
57 |   }
58 |   int get_dx(){ return dx; }
59 |   int get_dy(){ return dy; }
60 |   virtual void shoot(int,int,double,double,double,int,int){}
61 |   virtual void shoot(int,int,double,double,double,int,Bullet::Color,int){}
62 |   virtual void start_move(int,int,int){}
63 |   virtual void set_x(int){}
64 |   virtual void set_y(int){}
65 |   virtual int get_x(){ return obj_pos->x; }
66 |   virtual int get_y(){ return obj_pos->y; }
67 |   virtual int get_mx(){};
68 |   virtual int get_my(){};
69 |   virtual int get_width(){ return obj_pos->w; }
70 |   virtual int get_height(){ return obj_pos->h; }
71 |   virtual void set_speed(int){}
72 |   virtual void set_life(int){}
73 |   virtual void set_bomb_num(int){}
74 |   virtual void set_graze(int){}
75 |   virtual void CutIn(std::string,std::string,int,int,int,int){}
76 | };
77 | 
78 | #endif
79 | 


--------------------------------------------------------------------------------
/include/Parser.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __PARSER_HPP__
 2 | #define __PARSER_HPP__
 3 | 
 4 | class Parser {
 5 | public:
 6 |   Lexer *input;
 7 |   /* record points of tokens to role back */
 8 |   std::vector<int> markers;
 9 |   std::vector<Token> lookahead;
10 |   std::map<std::string, std::map<int, int> > memos;
11 |   static const int FAILED;
12 |   int p;
13 |   bool finished;
14 |   Parser(std::string script) : p(0), finished(false) {}
15 |   ~Parser() {
16 |     Clear();
17 |   }
18 |   void Clear() {
19 |     p = 0;
20 |     finished = false;
21 |     lookahead.clear();
22 |     markers.clear();
23 |     memos.clear();
24 |   }
25 |   Token LT(int i);
26 |   int LA(int i);
27 |   void match(int x);
28 |   void sync(int i);
29 |   void fill(int n);
30 |   void consume();
31 |   int mark();
32 |   void release();
33 |   void seek(int index);
34 |   bool isSpeculating();
35 |   bool alreadyParsedRule(std::string rule);
36 |   void memorize(std::string rule, int startTokenIndex, bool failed);
37 |   int index();
38 |   bool isFin() { return finished; }
39 | };
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/include/Play.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __PLAY_HPP__
 2 | #define __PLAY_HPP__
 3 | #include <SDL.h>
 4 | #include <deque>
 5 | #include <string>
 6 | #include <fstream>
 7 | #include <iostream>
 8 | #include <map>
 9 | #include <vector>
10 | #include <list>
11 | 
12 | #include "Interprter.hpp"
13 | 
14 | class Object;
15 | class Game;
16 | class Api;
17 | class Keyboard;
18 | class Player;
19 | class Enemy;
20 | class player_test;
21 | class enemy_test;
22 | class Window;
23 | 
24 | class Play{
25 | private:
26 |   Api* api;
27 |   Keyboard* keyboard;
28 |   Player* player;
29 |   std::deque<Enemy*> enemies;
30 |   player_test* p_test;
31 |   enemy_test* e_test;
32 |   Dnlang::Interprter *interp;
33 | public:
34 |   static SDL_Rect win_rect;
35 |   Object* obj_back;
36 |   Play();
37 |   ~Play();
38 |   void update(Game*);
39 |   void draw();
40 |   static bool in_monitor(int,int);
41 | };
42 | 
43 | #endif
44 | 


--------------------------------------------------------------------------------
/include/Player.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __PLAYER_HPP__
 2 | #define __PLAYER_HPP__
 3 | 
 4 | #include <vector>
 5 | #include <string>
 6 | #include "Object.hpp"
 7 | 
 8 | class Object;
 9 | class Api;
10 | class Keyboard;
11 | class Bullet;
12 | class Player : public Object{
13 | public:
14 |   enum State{
15 |     STATE_CUTIN = 1,
16 |   };
17 | private:
18 |   Api* api;
19 |   Keyboard* keyboard;
20 |   Object* obj_cutin;
21 |   unsigned int state;
22 |   static const int bullet_num = 40;
23 |   std::vector<Bullet*>bullets;
24 |   int speed;
25 |   int life;
26 |   int bomb_num;
27 |   int graze;
28 | public:
29 |   Player();
30 |   ~Player();
31 |   void update();
32 |   void draw();
33 |   void shoot(int,int,double,double,double,int,int);
34 |   void move();
35 |   void set_x(int _x){ obj_pos->x = _x; }
36 |   void set_y(int _y){ obj_pos->y = _y; }
37 |   int get_x(){ return obj_pos->x; }
38 |   int get_y(){ return obj_pos->y; }
39 |   int get_width(){ return obj_rect->w; }
40 |   int get_height(){ return obj_rect->h; }
41 |   void set_speed(int _speed){ speed = _speed; }
42 |   void set_life(int _life){ life = _life; }
43 |   void set_bomb_num(int _bnum){ bomb_num = _bnum; }
44 |   void set_graze(int _graze){ graze = _graze; }
45 |   void CutIn(std::string,std::string,int,int,int,int);
46 |   void set_state(State);
47 |   void remove_state(State);
48 |   bool is_state(State);
49 |   void clear_state(){ state = 0; }
50 | };
51 | 
52 | #endif
53 | 


--------------------------------------------------------------------------------
/include/Register.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __REGISTER_HPP__
 2 | #define __REGISTER_HPP__
 3 | 
 4 | class Register {
 5 | public:
 6 |   std::string id;
 7 |   Register() : id("") {}
 8 |   Register(std::string _id) : id(_id) {}
 9 |   std::string getId() { return id; }
10 | };
11 | 
12 | class Label {
13 | public:
14 |   std::string id;
15 |   Label() : id("") {}
16 |   Label(std::string _id) : id(_id) {}
17 |   std::string getId() { return id; }
18 | };
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/include/Scope.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __SCOPE_HPP__
 2 | #define __SCOPE_HPP__
 3 | 
 4 | namespace Dnlang {
 5 | 
 6 | class MethodSymbol;
 7 | class Scope {
 8 | public:
 9 |   std::string scopeName;
10 |   Scope *parent;
11 |   std::map<std::string, Symbol> symbols;
12 | 
13 |   Scope() { scopeName = ""; parent = 0; }
14 |   Scope(std::string name, Scope *_parent) : scopeName(name), parent(_parent){}
15 |   std::string getScopeName() { return scopeName; }
16 |   virtual Scope *getEnclosingScope() { return parent; }
17 |   void define(Symbol sym) { symbols[sym.name] = sym; }
18 |   Symbol *resolve(std::string name);
19 | };
20 | 
21 | class GlobalScope : public Scope {
22 | public:
23 |   static const int api_num = 128;
24 |   static MethodSymbol *apis[api_num];
25 |   GlobalScope();
26 |   Scope *getEnclosingScope() { return 0; }
27 | };
28 | 
29 | class LocalScope : public Scope {
30 | public:
31 |   LocalScope(std::string name, Scope *parent) : Scope(name, parent) {}
32 |   Scope *getEnclosingScope() { return parent; }
33 | };
34 | 
35 | }
36 | #endif
37 | 


--------------------------------------------------------------------------------
/include/Select.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __SELECT_HPP__
 2 | #define __SELECT_HPP__
 3 | class Object;
 4 | class Dnscript;
 5 | class Api;
 6 | class Keyboard;
 7 | 
 8 | class Select{
 9 | private:
10 |   Api* api;
11 |   Keyboard* keyboard;
12 | public:
13 |   Object* obj_back;
14 |   Select();
15 |   ~Select();
16 |   void update(Dnscript*);
17 |   void draw();
18 | };
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/include/Symbol.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __SYMBOL_HPP__
 2 | #define __SYMBOL_HPP__
 3 | 
 4 | namespace Dnlang {
 5 | 
 6 | class Type {
 7 | public:
 8 |   enum {
 9 |     INVALID, INT, CHAR, FLOAT, STRING, VOID,
10 |   };
11 |   static const std::string type_names[];
12 |   static const int type_sizes[];
13 |   int type;
14 |   Type(){ type = INVALID; }
15 |   Type(int _type) : type(_type) {}
16 |   std::string toString() { return type_names[type]; }
17 |   int getSize() { return type_sizes[type]; }
18 | };
19 | 
20 | class Symbol {
21 | public:
22 |   std::string name;
23 |   Type type;
24 |   Symbol() {}
25 |   Symbol(std::string _name, Type _type) : name(_name), type(_type) {}
26 |   std::string toString();
27 | };
28 | 
29 | }
30 | 
31 | #endif
32 | 


--------------------------------------------------------------------------------
/include/Symbols.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __SYMBOLS_HPP__
 2 | #define __SYMBOLS_HPP__
 3 | 
 4 | namespace Dnlang {
 5 | 
 6 | class VariableSymbol : public Symbol {
 7 | public:
 8 |   VariableSymbol(std::string name, Type type) : Symbol(name, type) {}
 9 | };
10 | 
11 | class MethodSymbol : public Symbol, public Scope {
12 | public:
13 |   MethodSymbol(std::string name, Scope *_parent) : Symbol(name, Type::INVALID) , Scope(name, _parent){
14 |   }
15 |   MethodSymbol(std::string name, Type type, Scope *_parent) : Symbol(name, type) , Scope(name, _parent){
16 |   }
17 | };
18 | 
19 | }
20 | 
21 | #endif
22 | 


--------------------------------------------------------------------------------
/include/Title.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __TITLE_HPP__
 2 | #define __TITLE_HPP__
 3 | class Object;
 4 | class Dnscript;
 5 | class Api;
 6 | class Keyboard;
 7 | 
 8 | class Title{
 9 | private:
10 |   Api* api;
11 |   Keyboard* keyboard;
12 | public:
13 |   Object* obj_back;
14 |   Title();
15 |   ~Title();
16 |   void update(Dnscript*);
17 |   void draw();
18 | };
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/include/Token.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef __TOKEN_HPP__
 2 | #define __TOKEN_HPP__
 3 | 
 4 | class Token {
 5 | public:
 6 |   int type;
 7 |   std::string text;
 8 |   Token() { type = -1; text = ""; }
 9 |   Token(int _type) : type(_type) { text = ""; }
10 |   Token(int _type,std::string _text) : type(_type), text(_text){}
11 |   std::string toString();
12 |   friend std::ostream& operator<<(std::ostream& os, const Token& tk);
13 | };
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/include/Utility.hpp:
--------------------------------------------------------------------------------
1 | #ifndef __UTILITY_HPP__
2 | #define __UTILITY_HPP__
3 | 
4 | #define SAFE_DELETE(x) if(x) delete x,x = 0
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/include/Window.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef __WINDOW_HPP__
  2 | #define __WINDOW_HPP__
  3 | 
  4 | #include <SDL.h>
  5 | #include "Event.hpp"
  6 | #include "Keyboard.hpp"
  7 | #include "Dnscript.hpp"
  8 | #include "Frame.hpp"
  9 | 
 10 | class Window{
 11 | public:
 12 |   static SDL_Window* window;
 13 |   static SDL_Renderer* renderer;
 14 |   static SDL_Rect win_rect;
 15 |   static const char* win_title;
 16 |   static const double fps;
 17 |   static const int timer_wait_mil;
 18 |   static Dnscript* dnscript;
 19 |   static Event* event;
 20 |   static Keyboard* keyboard;
 21 |   static Frame* frame;
 22 | 
 23 |   Window(void) { ; }
 24 | 
 25 |   static void init(void){
 26 |     try{
 27 |         if( SDL_Init(SDL_INIT_EVERYTHING) < 0 ) throw "[*ERROR*] Window::main SDL_Init fail";
 28 |         SDL_CreateWindowAndRenderer(win_rect.w, win_rect.h,0,&window,&renderer);
 29 |         Event::create();
 30 |         Keyboard::create();
 31 |         Frame::create();
 32 |         event = Event::instance();
 33 |         keyboard = Keyboard::instance();
 34 |         frame = Frame::instance();
 35 |       }catch(char *error){
 36 |         fprintf(stderr,"%s\n",error);
 37 |         Event::destroy();
 38 |         Keyboard::destroy();
 39 |         Frame::destroy();
 40 |         abort();
 41 |       }
 42 |   }
 43 | 
 44 |   static void update(void){
 45 |     dnscript->update();
 46 |   }
 47 | 
 48 |   static void draw(void){
 49 |     dnscript->draw();
 50 |   }
 51 | 
 52 |   static void quit(void){
 53 |     Event::destroy();
 54 |     Keyboard::destroy();
 55 |     Frame::destroy();
 56 |     SDL_DestroyRenderer(renderer);
 57 |     SDL_DestroyWindow(window);
 58 |     SDL_Quit();
 59 |   }
 60 | 
 61 |   static bool polling_event(void){
 62 |     SDL_Event ev;
 63 |     SDL_Keycode key;
 64 |     while ( SDL_PollEvent(&ev) ){
 65 |       event->set_event(ev);
 66 |       switch(ev.type){
 67 |         case SDL_QUIT:
 68 |           return false;
 69 |           break;
 70 |         case SDL_KEYDOWN:
 71 |         {
 72 |           key = ev.key.keysym.sym;
 73 |           keyboard->keyon(key);
 74 |           if(key == SDLK_ESCAPE){ return false; }
 75 |         }
 76 |           break;
 77 |         case SDL_KEYUP:
 78 |         {
 79 |           key = ev.key.keysym.sym;
 80 |           keyboard->keyoff(key);
 81 |           break;
 82 |         }
 83 |       }
 84 |     }
 85 |     return true;
 86 |   }
 87 |   static int main(int argc,char *argv[]){
 88 |     while (polling_event()) {
 89 |       update();
 90 |       draw();
 91 |       frame->count_up();
 92 |       SDL_Delay((Uint32)timer_wait_mil);
 93 |     }
 94 |     quit();
 95 |     return 0;
 96 |   }
 97 | };
 98 | 
 99 | #endif
100 | 


--------------------------------------------------------------------------------
/include/test/enemy_test.hpp:
--------------------------------------------------------------------------------
 1 | class Api;
 2 | class Enemy;
 3 | class enemy_test{
 4 | private:
 5 |   Api* api;
 6 |   Enemy* enemy;
 7 |   int count;
 8 |   int cx;
 9 |   int imgAngle;
10 |   int shotAngle;
11 | public:
12 |   enemy_test(Enemy*);
13 |   ~enemy_test();
14 |   void Initialize();
15 |   void MainLoop();
16 |   void DrawLoop();
17 | 
18 | };
19 | 


--------------------------------------------------------------------------------
/include/test/player_test.hpp:
--------------------------------------------------------------------------------
 1 | class Api;
 2 | class Player;
 3 | class player_test{
 4 | private:
 5 |   Api* api;
 6 |   Player* player;
 7 |   bool bNextShot;
 8 |   int shotCount;
 9 | public:
10 |   player_test(Player*);
11 |   ~player_test();
12 |   void Initialize();
13 |   void MainLoop();
14 |   void DrawLoop();
15 |   void SpellCard();
16 | };
17 | 


--------------------------------------------------------------------------------
/test/dnlang_test01.cpp:
--------------------------------------------------------------------------------
 1 | #include <fstream>
 2 | #include <iostream>
 3 | #include <string>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <list>
 7 | #include "Object.hpp"
 8 | #include "Api.hpp"
 9 | #include "Interprter.hpp"
10 | 
11 | int main() {
12 |   Object *dummy;
13 |   Dnlang::Interprter interp(dummy, "Dnlang/sample/enemy.dn");
14 |   interp.compile();
15 | }
16 | 


--------------------------------------------------------------------------------
/test/enemy_test.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <SDL.h>
 3 | #include <cstdio>
 4 | #include "Api.hpp"
 5 | #include "test/enemy_test.hpp"
 6 | #include "Enemy.hpp"
 7 | #include "Bullet.hpp"
 8 | 
 9 | /* Script test */
10 | enemy_test::enemy_test(Enemy* _enemy){
11 |   api = Api::instance();
12 |   enemy = _enemy;
13 |   count = 1;
14 |   cx = api->GetCenterX();
15 |   imgAngle = 10;
16 |   shotAngle = 0;
17 | }
18 | enemy_test::~enemy_test(){
19 | }
20 | 
21 | void enemy_test::Initialize(){
22 |   std::string current = api->GetCurrentScriptDirectory();
23 |   std::string imgEnemy = current + "/img/Enemy.png";
24 |   printf("%s\n",imgEnemy.c_str());
25 |   //std::string imgRumiaCutIn = current + "img/RumiaCutIn.png";
26 | 
27 |   api->LoadGraphic(enemy,imgEnemy);
28 |   api->SetLife(enemy,1500);
29 |   api->SetGraphicRect(enemy,1,1,32,32);
30 |   api->SetTexture(enemy,imgEnemy);
31 |   api->SetMovePosition02(enemy,cx + 0,api->GetCenterY(),30);
32 | }
33 | void enemy_test::MainLoop(){
34 |   if(count >= 30){
35 |     if(count%720==0&&count<4000){
36 |     		api->SetMovePosition02(enemy,cx-50,100,20);
37 |     }
38 |     if(count%720==360&&count<4000){
39 |     		api->SetMovePosition02(enemy,cx+50,100,20);
40 |     }
41 |     if(count % 10 == 0){
42 |       for(int angle = 0; angle < 360; angle += 20){
43 |         api->CreateShot01(enemy,api->GetX(enemy) + api->GetW(enemy) / 2,api->GetY(enemy) + api->GetH(enemy) / 2,10,angle,Bullet::RED,1);
44 |         //api->CreateShot01(enemy,api->GetX(enemy),api->GetY(enemy),5,angle,Bullet::YELLOW,3);
45 |       }
46 |     }
47 | 
48 |   }
49 |   count++;
50 | }
51 | void enemy_test::DrawLoop(){
52 |   //api->SetGraphicAngle(enemy,imgAngle);
53 |   //printf("(%d,%d)\n",api->GetX(enemy),api->GetY(enemy));
54 | 	api->DrawGraphic(enemy,api->GetX(enemy), api->GetY(enemy));
55 | }
56 | 


--------------------------------------------------------------------------------
/test/player_test.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <SDL.h>
 3 | #include <cstdio>
 4 | #include "Api.hpp"
 5 | #include "test/player_test.hpp"
 6 | #include "Player.hpp"
 7 | 
 8 | /* Script test */
 9 | player_test::player_test(Player* _player){
10 |   api = Api::instance();
11 |   player = _player;
12 | }
13 | player_test::~player_test(){
14 | }
15 | 
16 | void player_test::Initialize(){
17 |   shotCount = -1;
18 |   bNextShot = false;
19 |   std::string current = api->GetCurrentScriptDirectory();
20 |   std::string imgRumia = current + "/img/Reimu.png";
21 |   printf("%s\n",imgRumia.c_str());
22 |   //std::string imgRumiaCutIn = current + "img/RumiaCutIn.png";
23 | 
24 |   api->LoadGraphic(player,imgRumia);
25 |   api->SetSpeed(player,10);
26 |   api->SetTexture(player,imgRumia);
27 | }
28 | void player_test::MainLoop(){
29 |   if((api->GetKeyState(SDLK_z) == Api::KEY_PUSH ||
30 |       api->GetKeyState(SDLK_z) == Api::KEY_HOLD || bNextShot==true)
31 |       && shotCount==-1){
32 |   			shotCount = 0;
33 |   			bNextShot = false;
34 |   }
35 |   if(api->GetKeyState(SDLK_x) == Api::KEY_PUSH ||
36 |     api->GetKeyState(SDLK_x) == Api::KEY_HOLD){
37 |       this->SpellCard();
38 |   }
39 |   if(api->GetKeyState(SDLK_z) == Api::KEY_HOLD && shotCount>0){
40 |   			bNextShot = true;
41 |   }
42 |   if(shotCount % 5 == 0){
43 |     api->CreatePlayerShot01(player,api->GetPlayerX(player), api->GetPlayerY(player), 15, 255, 1.3, 1, 1);
44 |   	api->CreatePlayerShot01(player,api->GetPlayerX(player), api->GetPlayerY(player), 15, 265, 1.5, 2, 1);
45 |   	api->CreatePlayerShot01(player,api->GetPlayerX(player), api->GetPlayerY(player), 15, 270, 1.7, 3, 1);
46 |   	api->CreatePlayerShot01(player,api->GetPlayerX(player), api->GetPlayerY(player), 15, 275, 1.5, 2, 1);
47 |   	api->CreatePlayerShot01(player,api->GetPlayerX(player), api->GetPlayerY(player), 15, 285, 1.3, 1, 1);
48 |   }
49 |   if(shotCount >= 0){
50 |   	shotCount++;
51 |   }
52 |   if(shotCount == 30){
53 |   	shotCount=-1;
54 |   }
55 | }
56 | void player_test::SpellCard(){
57 |   std::string current = api->GetCurrentScriptDirectory();
58 |   api->CutIn(player,"Test",current + "/img/CutinReimu.png",0,0,256,256);
59 | }
60 | 
61 | void player_test::DrawLoop(){
62 |   if(api->GetKeyState(SDLK_LEFT) == Api::KEY_PUSH || api->GetKeyState(SDLK_LEFT) == Api::KEY_HOLD){
63 |     api->SetGraphicRect(player,1, 51, 50, 100);
64 | 	}else if(api->GetKeyState(SDLK_RIGHT) == Api::KEY_PUSH || api->GetKeyState(SDLK_RIGHT) == Api::KEY_HOLD){
65 | 		api->SetGraphicRect(player,1, 101, 50, 150);
66 | 	}else {
67 | 		api->SetGraphicRect(player,1, 1, 50, 50);
68 | 	}
69 |   //printf("(%d,%d)\n",api->GetPlayerX(player),api->GetPlayerY(player));
70 | 	api->DrawGraphic(player,api->GetPlayerX(player), api->GetPlayerY(player));
71 | }
72 | 


--------------------------------------------------------------------------------