Kparser/Kparser.l at main · taaki2311/Kparser · GitHub

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
137
138
139
140
141
142
143
144
%{
#include "Kparser.h"
#include "y.tab.h"
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>

void yyerror(const char *error);

void getHelp(void);
void getText(void);
void getType(void);
void getDefType(void);

void getString(void);
void getInteger(void);
void getHexvalue(void);
void getTristate(bool isTristate);
%}

%%

#.*                                     { ; }
choice                                  { return T_CHOICE; }
config                                  { return T_CONFIG; }
default                                 { return T_DEFAULT; }
"depends on"                            { return T_DEPENDS; }
endchoice                               { return T_ENDCHOICE; }
endmenu                                 { return T_ENDMENU; }
if                                      { return T_IF; }
menu                                    { return T_MENU; }
!                                       { return T_NOT; }
prompt                                  { return T_PROMPT; }
range                                   { return T_RANGE; }
source                                  { return T_SOURCE; }
select                                  { return T_SELECT; }

help\n([ \t]+.*\n)+                     { getHelp(); return T_HELP; }
string|int|hex|bool|tristate            { getType(); return T_TYPE; }
def_bool|def_tristate                   { getDefType(); return T_DEF_TYPE; }
&&                                      { getText(); return T_OPERATOR; }
[0-9_]*[A-Z][A-Z0-9_]+                  { getText(); return T_VARIABLE; }

\".*\"                                  { getString(); return T_STRING; }
[0-9]+                                  { getInteger(); return T_INTEGER; }
[0-9a-fA-F]+                            { getHexvalue(); return T_HEX_VALUE; }
y|n                                     { getTristate(false); return T_BOOL; }
y|n|m                                   { getTristate(true); return T_TRISTATE; }
[ \t\n\r]+                              { ; }
.                                       { ECHO; yyerror("unexpected character"); }

%%

void getHelp(void) {
    yylval.string = malloc(yyleng - 6);
    if (yylval.string == NULL) {
        yyerror("Failed to allocate memory");
    }
    yylval.string = strncpy(yylval.string, yytext + 5, yyleng - 6);
    yylval.string[yyleng - 6] = '\0';
}

void getText(void) {
    yylval.string = malloc(yyleng);
    if (yylval.string == NULL) {
        yyerror("Failed to allocate memory");
    }
    yylval.string = strncpy(yylval.string, yytext, yyleng);
}

void getType(void) {
    if (strcmp("string", yytext) == 0) {
        yylval.type = STRING;
    }
    else if (strcmp("int", yytext) == 0) {
        yylval.type = INTEGER;
    }
    else if (strcmp("hex", yytext) == 0) {
        yylval.type = HEX_VALUE;
    }
    else if (strcmp("bool", yytext) == 0) {
        yylval.type = BOOL;
    }
    else if (strcmp("tristate", yytext) == 0) {
        yylval.type = TRISTATE;
    }
    else {
        yyerror("Invalid Type");
    }
}

void getDefType(void) {
    if (strcmp("def_bool", yytext) == 0) {
        yylval.type = BOOL;
    }
    else if (strcmp("def_tristate", yytext) == 0) {
        yylval.type = TRISTATE;
    }
    else {
        yyerror("Invalid Def_Type");
    }
}

void getString(void) {
    yylval.string = malloc(yyleng - 2);
    if (yylval.string == NULL) {
        yyerror("Failed to allocate memory");
    }
    yylval.string = strncpy(yylval.string, yytext + 1, yyleng - 2);
    yylval.string[yyleng - 2] = '\0';
}

void getInteger(void) {
    yylval.number = strtol(yytext, NULL, 10);
}

void getHexvalue(void) {
    yylval.number = strtol(yytext, NULL, 16);
}

void getTristate(bool isTristate) {
    switch(yytext[0]) {
        case 'n':
            yylval.number = 0;
            break;
        case 'y':
            yylval.number = 1;
            break;
        case 'm':
            if (isTristate) {
                yylval.number = 2;
                break;
            }
            else {
                yyerror("Value is a boolean not a tristate");
            }
            break;
        default:
            yyerror("Tristate that is not y/n/m");
            break;
    }
}

int yywrap(void) { return 1; }