bel 0.3.0.beta1-x64-mingw32

data/ext/mri/bel-parser.c

@@ -0,0 +1,91 @@
+/*
+ * Parses BEL terms.
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "bel-parser.h"
+
+#define LINE_CHAR_LEN 1024 * 32 // 32 kilobytes
+
+int main(int argc, char *argv[]) {
+    FILE *input;
+    int len;
+    char line[LINE_CHAR_LEN];
+    int type;
+    int print;
+    int verbose;
+    bel_ast* tree;
+    bel_token_list* token_list;
+
+    if (argc == 2) {
+        type = 0;
+        if (strcmp(argv[1], "tk") == 0) {
+            type = 1;
+            input = stdin;
+        } else {
+            input = fopen(argv[1], "rb");
+        }
+    } else if (argc == 3) {
+        if (strcmp(argv[1], "tk") == 0) {
+            type = 1;
+        } else {
+            type = 0;
+        }
+        input = fopen(argv[2], "rb");
+    } else {
+        type = 0;
+        input = stdin;
+    }
+
+    print = 0;
+    if (getenv("AST_PRINT") != NULL) {
+        print = 1;
+    }
+
+    verbose = 0;
+    if (getenv("AST_VERBOSE") != NULL) {
+        verbose = 1;
+    }
+
+    if (argc > 1) {
+    }
+
+    while (fgets(line, LINE_CHAR_LEN, input) != NULL) {
+        // force newline if statement ends with closed paren; aids parser
+        len = strlen(line);
+        if (line[len - 1] == ')') {
+            line[len - 1] = '\n';
+        }
+
+        if (verbose) {
+            fprintf(stdout, "parsing line -> %s\n", line);
+        }
+
+        if (type == 0) {
+            if (verbose) {
+                fprintf(stdout, "using default statement parser\n");
+            }
+            tree = bel_parse_statement(line);
+
+            if (!tree->root) {
+                fprintf(stderr, "parse failed\n");
+            }
+
+            if (print) {
+                bel_print_ast(tree);
+            }
+            bel_free_ast(tree);
+        } else if (type == 1) {
+            if (verbose) {
+                fprintf(stdout, "using lookahead term parser\n");
+            }
+            token_list = bel_tokenize_term(line);
+            bel_print_token_list(token_list);
+            free_bel_token_list(token_list);
+        }
+    }
+    fclose(input);
+    return 0;
+}
+// vim: ft=c sw=4 ts=4 sts=4 expandtab

data/ext/mri/bel-parser.h

@@ -0,0 +1,13 @@
+#include "bel-ast.h"
+#include "bel-token.h"
+
+#ifndef _BEL_PARSER_H
+#define _BEL_PARSER_H
+
+bel_ast* bel_parse_term(char* line);
+
+bel_ast* bel_parse_statement(char* line);
+
+bel_token_list* bel_tokenize_term(char* line);
+
+#endif /* not defined _BEL_PARSER_H */

data/ext/mri/bel-token.c

@@ -0,0 +1,161 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "bel-token.h"
+
+bel_token* bel_new_token(bel_token_type type, char* input, char* ts, char* te) {
+    bel_token *new_token;
+    int       length;
+    char      *match_copy;
+
+    new_token = malloc(sizeof(bel_token));
+    new_token->type = type;
+    new_token->pos_start = ts - input;
+    new_token->pos_end   = te - input;
+
+    length = te - ts;
+    match_copy = malloc(length + 1);
+    strncpy(match_copy, ts, length);
+    match_copy[length] = '\0';
+    new_token->value = match_copy;
+    return new_token;
+};
+
+bel_token_list* bel_new_token_list(int length) {
+    bel_token_list       *list;
+    list               = malloc(sizeof(bel_token_list));
+    list->length       = length;
+    list->tokens       = calloc(length, sizeof(bel_token));
+    return list;
+};
+
+bel_token_iterator* bel_new_token_iterator(bel_token_list *list) {
+    bel_token_iterator *iterator;
+    bel_token *tokens;
+
+    if (!list) {
+        return NULL;
+    }
+
+    tokens  = list->tokens;
+
+    iterator = malloc(sizeof(bel_token_iterator));
+    iterator->index         = 0;
+    iterator->list          = list;
+    iterator->current_token = &tokens[0];
+    return iterator;
+};
+
+bel_token* bel_token_iterator_get(bel_token_iterator *iterator) {
+    if (!iterator) {
+	      return NULL;
+    }
+    return iterator->current_token;
+};
+
+void bel_token_iterator_next(bel_token_iterator *iterator) {
+    bel_token *tokens;
+
+    if (!iterator || !iterator->list) {
+	      return;
+    }
+
+    tokens = iterator->list->tokens;
+    iterator->current_token = &tokens[++iterator->index];
+};
+
+int bel_token_iterator_end(bel_token_iterator *iterator) {
+    if (!iterator || !(iterator->list)) {
+	      return 1;
+    }
+    return (iterator->index < iterator->list->length) ? 0 : 1;
+};
+
+void bel_print_token(bel_token* token) {
+    if (!token) {
+	      return;
+    }
+
+    switch(token->type) {
+    case IDENT:
+        fprintf(stdout, "IDENT(\"%s\", %d, %d) ", token->value, token->pos_start, token->pos_end);
+        break;
+    case STRING:
+        fprintf(stdout, "STRING(\"%s\", %d, %d) ", token->value, token->pos_start, token->pos_end);
+        break;
+    case O_PAREN:
+        fprintf(stdout, "O_PAREN(\"%s\", %d, %d) ", token->value, token->pos_start, token->pos_end);
+        break;
+    case C_PAREN:
+        fprintf(stdout, "C_PAREN(\"%s\", %d, %d) ", token->value, token->pos_start, token->pos_end);
+        break;
+    case COLON:
+        fprintf(stdout, "COLON(\"%s\", %d, %d) ", token->value, token->pos_start, token->pos_end);
+        break;
+    case COMMA:
+        fprintf(stdout, "COMMA(\"%s\", %d, %d) ", token->value, token->pos_start, token->pos_end);
+        break;
+    case SPACES:
+        fprintf(stdout, "SPACES(\"%s\", %d, %d) ", token->value, token->pos_start, token->pos_end);
+        break;
+    };
+};
+
+void bel_print_token_list(bel_token_list* token_list) {
+    bel_token *tokens;
+    bel_token *next;
+    int       token_i;
+    int       list_length;
+
+    if (!token_list) {
+        return;
+    }
+
+    tokens  = token_list->tokens;
+    list_length = token_list->length;
+    for (token_i = 0; token_i < list_length; token_i++) {
+        next = &tokens[token_i];
+        bel_print_token(next);
+    }
+    fprintf(stdout, "\n");
+};
+
+void free_bel_token(bel_token* token) {
+    if (!token) {
+        return;
+    }
+    if (token->value) {
+        free(token->value);
+    }
+};
+
+void free_bel_token_list(bel_token_list* token_list) {
+    int       token_i;
+    int       list_length;
+    bel_token *next;
+
+    if (!token_list) {
+        return;
+    }
+
+    list_length = token_list->length;
+    for (token_i = 0; token_i < list_length; token_i++) {
+        next = &token_list->tokens[token_i];
+        if (!next && next->value) {
+            free(next->value);
+        }
+	// FIXME Memory leak, cannot free, yields, "free(): invalid size"
+  //    free(next);
+    }
+
+    free(token_list->tokens);
+    free(token_list);
+};
+
+void free_bel_token_iterator(bel_token_iterator *iterator) {
+    if (!iterator) {
+        return;
+    }
+    free(iterator);
+};
+

data/ext/mri/bel-token.h

@@ -0,0 +1,58 @@
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef _BEL_TOKEN_H
+#define _BEL_TOKEN_H
+
+typedef enum {
+    IDENT,
+    STRING,
+    O_PAREN,
+    C_PAREN,
+    COLON,
+    COMMA,
+    SPACES
+} bel_token_type;
+
+typedef struct {
+    bel_token_type  type;
+    int             pos_start;
+    int             pos_end;
+    char            *value;
+} bel_token;
+
+typedef struct {
+    int             length;
+    bel_token       *tokens;
+} bel_token_list;
+
+typedef struct {
+    int             index;
+    bel_token_list  *list;
+    bel_token       *current_token;
+} bel_token_iterator;
+
+bel_token*          bel_new_token(bel_token_type type, char* input, char* ts, char* te);
+
+bel_token_list*     bel_new_token_list(int length);
+
+bel_token_iterator* bel_new_token_iterator(bel_token_list *list);
+
+bel_token*          bel_token_iterator_get(bel_token_iterator *token_iterator);
+
+void                bel_token_iterator_next(bel_token_iterator *token_iterator);
+
+int                 bel_token_iterator_end(bel_token_iterator *token_iterator);
+
+void                bel_print_token(bel_token* token);
+
+void                bel_print_token_list(bel_token_list* token_list);
+
+void                free_bel_token(bel_token* token);
+
+void                free_bel_token_list(bel_token_list* token_list);
+
+void                free_bel_token_iterator(bel_token_iterator *token_iterator);
+
+#endif /* not defined _BEL_TOKEN_H */
+

data/ext/mri/bel-tokenize-term.c

@@ -0,0 +1,391 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "bel-token.h"
+
+static const int  set_start  = 1;
+static const int  set_first_final  = 1;
+static const int  set_error  = 0;
+static const int  set_en_term  = 1;
+bel_token_list* bel_tokenize_term(char* line) {
+    int                  cs;
+    char                 *p;
+    char                 *pe;
+    char                 *ts;
+    char                 *te;
+    char                 *eof;
+    int                  token_i;
+    bel_token_list       *token_list;
+    bel_token            *tokens;
+    bel_token            *new_token;
+
+    p                  = line;
+    pe                 = line + strlen(line);
+    eof                = pe;
+    token_i            = 0;
+    token_list         = bel_new_token_list(256);
+    tokens             = token_list->tokens;
+
+    
+	{
+	cs = set_start;
+ts = 0;
+te = 0;
+}
+
+	{
+	if ( p == pe  )
+	goto _test_eof;
+	
+switch ( cs  ) {
+	case 1:
+goto st_case_1;
+	case 0:
+goto st_case_0;
+	case 2:
+goto st_case_2;
+	case 3:
+goto st_case_3;
+	case 4:
+goto st_case_4;
+	case 5:
+goto st_case_5;
+	
+}
+goto st_out;
+ctr3:
+	{{te = p+1;
+{new_token = bel_new_token(O_PAREN, line, ts, te);
+            tokens[token_i++] = *new_token;
+        }
+}}
+
+
+	goto st1;
+ctr4:
+	{{te = p+1;
+{new_token = bel_new_token(C_PAREN, line, ts, te);
+            tokens[token_i++] = *new_token;
+        }
+}}
+
+
+	goto st1;
+ctr5:
+	{{te = p+1;
+{new_token = bel_new_token(COMMA, line, ts, te);
+            tokens[token_i++] = *new_token;
+        }
+}}
+
+
+	goto st1;
+ctr7:
+	{{te = p+1;
+{new_token = bel_new_token(COLON, line, ts, te);
+            tokens[token_i++] = *new_token;
+        }
+}}
+
+
+	goto st1;
+ctr8:
+	{{te = p;
+p = p - 1;
+{new_token = bel_new_token(SPACES, line, ts, te);
+            tokens[token_i++] = *new_token;
+        }
+}}
+
+
+	goto st1;
+ctr9:
+	{{te = p;
+p = p - 1;
+{new_token = bel_new_token(STRING, line, ts, te);
+            tokens[token_i++] = *new_token;
+        }
+}}
+
+
+	goto st1;
+ctr10:
+	{{te = p+1;
+{new_token = bel_new_token(STRING, line, ts, te);
+            tokens[token_i++] = *new_token;
+        }
+}}
+
+
+	goto st1;
+ctr12:
+	{{te = p;
+p = p - 1;
+{new_token = bel_new_token(IDENT, line, ts, te);
+            tokens[token_i++] = *new_token;
+        }
+}}
+
+
+	goto st1;
+st1:
+	{{ts = 0;
+}}
+
+	p+= 1;
+if ( p == pe  )
+	goto _test_eof1;
+
+st_case_1:
+	{{ts = p;
+}}
+switch ( ( (*( p  ))
+)  ) {
+	case 32:
+{
+goto st2;
+	}
+		 case 34:
+{
+goto st3;
+	}
+		 case 40:
+{
+goto ctr3;
+	}
+		 case 41:
+{
+goto ctr4;
+	}
+		 case 44:
+{
+goto ctr5;
+	}
+		 case 58:
+{
+goto ctr7;
+	}
+		 case 95:
+{
+goto st5;
+	}
+	
+}
+if ( ( (*( p  ))
+) < 65  )
+	{
+		if ( 48 <= ( (*( p  ))
+) && ( (*( p  ))
+) <= 57  )
+	{
+			goto st5;
+		}
+	
+} 
+else if ( ( (*( p  ))
+) > 90  )
+	{
+		if ( 97 <= ( (*( p  ))
+) && ( (*( p  ))
+) <= 122  )
+	{
+			goto st5;
+		}
+	
+} 
+else
+	{
+		goto st5;
+	}
+
+{
+	goto st0;
+}
+st_case_0:
+st0:
+cs = 0;
+goto _out;
+st2:
+	p+= 1;
+if ( p == pe  )
+	goto _test_eof2;
+
+st_case_2:
+	if ( ( (*( p  ))
+) == 32  )
+	{
+		goto st2;
+	}
+	
+if ( 33 <= ( (*( p  ))
+)  )
+	{
+		goto ctr8;
+	}
+
+{
+	goto ctr8;
+}
+st3:
+	p+= 1;
+if ( p == pe  )
+	goto _test_eof3;
+
+st_case_3:
+	switch ( ( (*( p  ))
+)  ) {
+	case 34:
+{
+goto ctr10;
+	}
+		 case 92:
+{
+goto st4;
+	}
+	
+}
+if ( ( (*( p  ))
+) > 91  )
+	{
+		if ( 93 <= ( (*( p  ))
+)  )
+	{
+			goto st3;
+		}
+	
+} 
+else if ( ( (*( p  ))
+) >= 35  )
+	{
+		goto st3;
+	}
+
+{
+	goto st3;
+}
+st4:
+	p+= 1;
+if ( p == pe  )
+	goto _test_eof4;
+
+st_case_4:
+	if ( ( (*( p  ))
+) == 92  )
+	{
+		goto st4;
+	}
+	
+if ( 93 <= ( (*( p  ))
+)  )
+	{
+		goto st3;
+	}
+
+{
+	goto st3;
+}
+st5:
+	p+= 1;
+if ( p == pe  )
+	goto _test_eof5;
+
+st_case_5:
+	switch ( ( (*( p  ))
+)  ) {
+	case 95:
+{
+goto st5;
+	}
+		 case 96:
+{
+goto ctr12;
+	}
+	
+}
+if ( ( (*( p  ))
+) < 65  )
+	{
+		if ( ( (*( p  ))
+) > 57  )
+	{
+			{
+				goto ctr12;
+			}
+		} 
+else if ( ( (*( p  ))
+) >= 48  )
+	{
+			goto st5;
+		}
+	
+} 
+else if ( ( (*( p  ))
+) > 90  )
+	{
+		if ( ( (*( p  ))
+) < 97  )
+	{
+			if ( ( (*( p  ))
+) <= 94  )
+	{
+				goto ctr12;
+			}
+		
+} 
+else if ( ( (*( p  ))
+) > 122  )
+	{
+			{
+				goto ctr12;
+			}
+		} 
+else
+	{
+			goto st5;
+		}
+	
+} 
+else
+	{
+		goto st5;
+	}
+
+{
+	goto ctr12;
+}
+	st_out:
+	_test_eof1: cs = 1;
+goto _test_eof; 
+	_test_eof2: cs = 2;
+goto _test_eof; 
+	_test_eof3: cs = 3;
+goto _test_eof; 
+	_test_eof4: cs = 4;
+goto _test_eof; 
+	_test_eof5: cs = 5;
+goto _test_eof; 
+
+	_test_eof: {}
+	if ( p == eof  )
+	{
+	switch ( cs  ) {
+	case 2:
+goto ctr8;
+	case 3:
+goto ctr9;
+	case 4:
+goto ctr9;
+	case 5:
+goto ctr12;
+	
+}
+}
+
+	
+_out: {}
+	}
+token_list->length = token_i;
+    return token_list;
+};
+// vim: ft=c sw=4 ts=4 sts=4 expandtab
+