summaryrefslogtreecommitdiff
path: root/src/spell-convert/lexer.lpp
blob: b6c6d769ba5efe5cb6c22be0488ab6b3b3567e8d (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
%{
/* vim: set ft=lex: */
//#include "lexer.hpp"
//    magic-interpreter-lexer.lpp - Old magic tokenizer
//
//    Copyright © 2004-2011 The Mana World Development Team
//    Copyright © 2011-2014 Ben Longbons <b.r.longbons@gmail.com>
//
//    This file is part of The Mana World (Athena server)
//
//    This program is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "../strings/rstring.hpp"
#include "../strings/zstring.hpp"

#include "../io/cxxstdio.hpp"

#include "../sexpr/lexer.hpp"

#include "parser.hpp"

#define yylval spell_converterlval

RString *str(const char *s)
{
    return new RString(ZString(strings::really_construct_from_a_pointer, s, nullptr));
}
%}

%option noyywrap
%option prefix="spell_converter"
%option nounput
%option noinput

%%

"S"                     { yylval.s = str(yytext); return DIR; }
"SW"                    { yylval.s = str(yytext); return DIR; }
"W"                     { yylval.s = str(yytext); return DIR; }
"NW"                    { yylval.s = str(yytext); return DIR; }
"N"                     { yylval.s = str(yytext); return DIR; }
"NE"                    { yylval.s = str(yytext); return DIR; }
"E"                     { yylval.s = str(yytext); return DIR; }
"SE"                    { yylval.s = str(yytext); return DIR; }
"="                     { return '='; }
"=="                    { return EQ; }
"<>"                    { return NEQ; }
"!="                    { return NEQ; }
">"                     { return '>'; }
"<"                     { return '<'; }
">="                    { return GTE; }
"<="                    { return LTE; }
"("                     { return '('; }
")"                     { return ')'; }
"+"                     { return '+'; }
"-"                     { return '-'; }
"*"                     { return '*'; }
"/"                     { return '/'; }
"%"                     { return '%'; }
"&&"                    { return ANDAND; }
"||"                    { return OROR; }
";"                     { return ';'; }
":"                     { return ':'; }
","                     { return ','; }
"@"                     { return '@'; }
"|"                     { return '|'; }
"["                     { return '['; }
"]"                     { return ']'; }
"&"                     { return '&'; }
"^"                     { return '^'; }
"."                     { return '.'; }
"<<"                    { return SHL; }
">>"                    { return SHR; }
"PROCEDURE"             { return PROCEDURE; }
"CALL"                  { return CALL; }
"OR"                    { return OR; }
"TO"                    { return TO; }
"TOWARDS"               { return TOWARDS; }
"TELEPORT-ANCHOR"       { return TELEPORT_ANCHOR; }
"SILENT"                { return SILENT; }
"LOCAL"                 { return LOCAL; }
"NONMAGIC"              { return NONMAGIC; }
"SPELL"                 { return SPELL; }
"LET"                   { return LET; }
"IN"                    { return IN; }
"END"                   { return END; }
"=>"                    { return DARROW; }
"STRING"                { return STRING_TY; }
"REQUIRE"               { return REQUIRE; }
"CATALYSTS"             { return CATALYSTS; }
"COMPONENTS"            { return COMPONENTS; }
"MANA"                  { return MANA; }
"CASTTIME"              { return CASTTIME; }
"SKIP"                  { return SKIP; }
"ABORT"                 { return ABORT; }
"BREAK"                 { return BREAK; }
"EFFECT"                { return EFFECT_; }
"ATEND"                 { return ATEND; }
"ATTRIGGER"             { return ATTRIGGER; }
"CONST"                 { return CONST; }
"PC"                    { return PC_F; }
"NPC"                   { return NPC_F; }
"MOB"                   { return MOB_F; }
"ENTITY"                { return ENTITY_F; }
"TARGET"                { return TARGET_F; }
"IF"                    { return IF; }
"THEN"                  { return THEN; }
"ELSE"                  { return ELSE; }
"FOREACH"               { return FOREACH; }
"FOR"                   { return FOR; }
"DO"                    { return DO; }
"WAIT"                  { return SLEEP; }

\{([^\}]|\\.)*\}        { yylval.s = str(yytext); return SCRIPT_DATA; }
\"([^\"]|\\.)*\"        { yylval.s = str(yytext); return STRING; }
"-"?[0-9]+              { yylval.s = str(yytext); return INT; }
"0x"[0-9a-fA-F]+        { yylval.s = str(yytext); return INT; }
[a-zA-Z][-_a-zA-Z0-9]*  { yylval.s = str(yytext); return ID; }
"#".*$                  { PRINTF("%s\n", sexpr::escape(*str(yytext + 1))); }
"//".*$                 { PRINTF("%s\n", sexpr::escape(*str(yytext + 2))); }
[ \n\t\r]               /* ignore whitespace */
.                       { abort(); }

%%
// nothing to see here, move along