236 lines
8.1 KiB
C
236 lines
8.1 KiB
C
// SPDX-FileCopyrightText: 2016 pancake <pancake@nopcode.org>
|
|
// SPDX-License-Identifier: LGPL-3.0-only
|
|
|
|
/* Radare Language Code Compiler */
|
|
|
|
#include <mpc.h>
|
|
#define eprintf(x, y...) fprintf(stderr, x, ##y)
|
|
|
|
static int isComment(mpc_ast_t *node) {
|
|
if (!strcmp(node->tag, "comment|regex")) {
|
|
return 1;
|
|
}
|
|
if (!strcmp(node->tag, "linecomment|regex")) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int isInlineAssembly(mpc_ast_t *node) {
|
|
if (!strcmp(node->tag, "asm|regex")) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int isStatement(mpc_ast_t *node) {
|
|
if (!strcmp(node->tag, "stmt|>")) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int isSigdef(mpc_ast_t *node) {
|
|
if (!strcmp(node->tag, "sigdef|>")) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int isProcedure(mpc_ast_t *node) {
|
|
if (!strcmp(node->tag, "procedure|>")) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void processNode(mpc_ast_t *node) {
|
|
if (isStatement(node)) {
|
|
int i, narg = 0;
|
|
const char *args[32];
|
|
for (i = 0; i < node->children_num; i++) {
|
|
const char *tag = node->children[i]->tag;
|
|
const char *val = node->children[i]->contents;
|
|
if (strcmp(tag, "char")) {
|
|
printf("TAG (%s) = (%s)\n", tag, val);
|
|
args[narg++] = val;
|
|
}
|
|
}
|
|
printf("; CALL WITH %d ARGS\n", narg);
|
|
} else if (isProcedure(node)) {
|
|
int i, j;
|
|
const char *name = node->children[0]->contents;
|
|
printf("%s:\n", name);
|
|
for (i = 0; i < node->children_num; i++) {
|
|
if (!strcmp(node->children[i]->tag, "body|>")) {
|
|
node = node->children[i];
|
|
for (i = 0; i < node->children_num; i++) {
|
|
if (!strcmp(node->children[i]->tag, "stmt|>")) {
|
|
processNode(node->children[i]);
|
|
} else {
|
|
eprintf("UNK %s\n", node->children[i]->tag);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} else if (isSigdef(node)) {
|
|
if (node->children_num > 4) {
|
|
const char *name = node->children[0]->contents;
|
|
const char *type = node->children[2]->contents;
|
|
const char *size = node->children[4]->contents;
|
|
if (!strcmp(type, "alias")) {
|
|
printf(".equ %s,%s\n", name, size);
|
|
} else if (!strcmp(type, "syscall")) {
|
|
printf("; TODO: register syscall %s number %s\n", name, size);
|
|
} else if (!strcmp(type, "global")) {
|
|
printf("; TODO: global \n");
|
|
} else {
|
|
printf("; UNKNOWN EXPRESISON: NAME = '%s' ", name);
|
|
printf("TYPE = '%s' ", type);
|
|
printf("SIZE = '%s'\n", size);
|
|
}
|
|
}
|
|
} else if (isComment(node)) {
|
|
char *s = strdup(node->contents + 2);
|
|
int len = strlen(s);
|
|
if (node->contents[1] == '*') {
|
|
s[len - 2] = 0;
|
|
}
|
|
while (s) {
|
|
char *nl = strchr(s, '\n');
|
|
if (nl) {
|
|
*nl = 0;
|
|
printf("; %s\n", s);
|
|
s = nl + 1;
|
|
} else {
|
|
printf("; %s\n", s);
|
|
s = NULL;
|
|
}
|
|
}
|
|
free(s);
|
|
} else if (isInlineAssembly(node)) {
|
|
printf("%s\n", node->contents + 1);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
mpc_parser_t *Ident = mpc_new("ident");
|
|
mpc_parser_t *Number = mpc_new("number");
|
|
mpc_parser_t *Character = mpc_new("character");
|
|
mpc_parser_t *String = mpc_new("string");
|
|
mpc_parser_t *Factor = mpc_new("factor");
|
|
mpc_parser_t *Term = mpc_new("term");
|
|
mpc_parser_t *Lexp = mpc_new("lexp");
|
|
mpc_parser_t *Stmt = mpc_new("stmt");
|
|
mpc_parser_t *Exp = mpc_new("exp");
|
|
mpc_parser_t *Vartype = mpc_new("vartype");
|
|
mpc_parser_t *Typeident = mpc_new("typeident");
|
|
mpc_parser_t *Decls = mpc_new("decls");
|
|
mpc_parser_t *Args = mpc_new("args");
|
|
mpc_parser_t *Body = mpc_new("body");
|
|
mpc_parser_t *Comment = mpc_new("comment");
|
|
mpc_parser_t *Linecomment = mpc_new("linecomment");
|
|
mpc_parser_t *Asm = mpc_new("asm");
|
|
mpc_parser_t *Procedure = mpc_new("procedure");
|
|
mpc_parser_t *CProcedure = mpc_new("cprocedure");
|
|
mpc_parser_t *Sigdef = mpc_new("sigdef");
|
|
mpc_parser_t *Sigbody = mpc_new("sigbody");
|
|
mpc_parser_t *Includes = mpc_new("includes");
|
|
mpc_parser_t *Smallc = mpc_new("smallc");
|
|
|
|
mpc_err_t *err = mpca_lang(MPCA_LANG_DEFAULT,
|
|
" ident : /[a-zA-Z_][a-zA-Z0-9_]*/ ; \n"
|
|
" number : /[0-9]+/ ; \n"
|
|
" character : /'.'/ ; \n"
|
|
" string : /\"(\\\\.|[^\"])*\"/ ; \n"
|
|
" \n"
|
|
" factor : '(' <lexp> ')' \n"
|
|
" | <number> \n"
|
|
" | <character> \n"
|
|
" | <string> \n"
|
|
" | <ident> '(' <lexp>? (',' <lexp>)* ')' \n"
|
|
" | <ident> ; \n"
|
|
" \n"
|
|
" term : <factor> (('*' | '/' | '%') <factor>)* ; \n"
|
|
" lexp : <term> (('+' | '-') <term>)* ; \n"
|
|
" \n"
|
|
" stmt : '{' <stmt>* '}' \n"
|
|
" | \"while\" '(' <exp> ')' <stmt> \n"
|
|
" | \"if\" '(' <exp> ')' <stmt> \n"
|
|
" | <ident> '=' <lexp> ';' \n"
|
|
" | \"print\" '(' <lexp>? ')' ';' \n"
|
|
" | \"return\" <lexp>? ';' \n"
|
|
" | <ident> '(' (<number>|<ident>|<string>)? (',' (<string>|<number>|<ident>))* ')' ';' ; \n"
|
|
" \n"
|
|
" exp : <lexp> '>' <lexp> \n"
|
|
" | <lexp> '<' <lexp> \n"
|
|
" | <lexp> \">=\" <lexp> \n"
|
|
" | <lexp> \"<=\" <lexp> \n"
|
|
" | <lexp> \"!=\" <lexp> \n"
|
|
" | <lexp> \"==\" <lexp> ; \n"
|
|
" \n"
|
|
" vartype : (\"int\" | \"char\") ; \n"
|
|
" typeident : <vartype> <ident> ; \n"
|
|
" decls : (<typeident> ';')* ; \n"
|
|
" args : <typeident>? (',' <typeident>)* ; \n"
|
|
" body : '{' <decls> <stmt>* '}' ; \n"
|
|
" comment : /\\/\\*([^\\*])*\\*\\// ; \n"
|
|
" linecomment : /\\/\\/([^\\n])*/ ; \n"
|
|
" asm : /\\:([^\\n])*/ ; \n"
|
|
" procedure : <ident> '@' \"global\" '(' <number>? ')' <body> ; \n"
|
|
" cprocedure : <vartype> <ident> '(' <args> ')' <body> ; \n"
|
|
" sigdef : <ident> '@' <ident> '(' <number> ')' ';' ; \n"
|
|
" sigbody : '@' <ident> '(' <number> ')' ';' ; \n"
|
|
" includes : (\"#include\" <string>)* ; \n"
|
|
" smallc : /^/ (<comment>|<asm>|<linecomment>|<sigdef>|<sigbody>|<procedure>|<cprocedure>)* <includes> <decls> /$/ ; \n",
|
|
Ident, Number, Character, String, Factor, Term, Lexp, Stmt, Exp,
|
|
Vartype, Typeident, Decls, Args, Body, Comment, Linecomment, Asm, Procedure, CProcedure,
|
|
Sigdef, Sigbody, Includes, Smallc, NULL);
|
|
|
|
if (err != NULL) {
|
|
mpc_err_print(err);
|
|
mpc_err_delete(err);
|
|
return -1;
|
|
}
|
|
|
|
#if 1
|
|
if (argc > 1) {
|
|
|
|
mpc_result_t r;
|
|
if (mpc_parse_contents(argv[1], Smallc, &r)) {
|
|
mpc_ast_print_to(r.output, stderr);
|
|
{
|
|
int i;
|
|
mpc_ast_t *root = r.output;
|
|
for (i = 0; i < root->children_num; i++) {
|
|
mpc_ast_t *node = root->children[i];
|
|
eprintf("; TAG = %s (%s)\n", node->tag, node->contents);
|
|
processNode(node);
|
|
}
|
|
}
|
|
mpc_ast_delete(r.output);
|
|
} else {
|
|
mpc_err_print(r.error);
|
|
mpc_err_delete(r.error);
|
|
}
|
|
|
|
} else {
|
|
|
|
mpc_result_t r;
|
|
if (mpc_parse_pipe("<stdin>", stdin, Smallc, &r)) {
|
|
mpc_ast_print(r.output);
|
|
mpc_ast_delete(r.output);
|
|
} else {
|
|
mpc_err_print(r.error);
|
|
mpc_err_delete(r.error);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
mpc_cleanup(17, Ident, Number, Character, String, Factor, Term, Lexp, Stmt, Exp,
|
|
Vartype, Typeident, Decls, Args, Body, Comment, Procedure, CProcedure,
|
|
Sigdef, Includes, Smallc);
|
|
|
|
return 0;
|
|
}
|