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
|
#include <stdlib.h>
#include <stdio.h>
#include "expression.h"
struct li_production_t * li_production_alloc(size_t seq_len) {
struct li_production_t *prod = malloc(sizeof(struct li_production_t));
if (prod == NULL) {
fprintf(stderr, "failed to allocate production rule\n");
return NULL;
}
prod->seq = malloc(seq_len * sizeof(int));
if (prod->seq == NULL) {
fprintf(stderr, "failed to allocate production sequence buffer\n");
free(prod);
return NULL;
}
prod->seq_len = seq_len;
prod->next = NULL;
return prod;
}
void li_production_free(struct li_production_t *prod) {
if (prod != NULL) {
li_production_free(prod->next);
free(prod->seq);
free(prod);
}
}
struct li_production_rule_t * li_prod_rule_alloc() {
struct li_production_rule_t *rule = malloc(sizeof(struct li_production_rule_t));
if (rule == NULL) {
fprintf(stderr, "failed to allocate production rule\n");
return NULL;
}
rule->num_productions = 0;
rule->head = NULL;
return rule;
}
void li_prod_rule_free(struct li_production_rule_t *rule) {
if (rule != NULL) {
li_production_free(rule->head);
free(rule);
}
}
int li_prod_rule_add(
struct li_production_rule_t *rule, size_t seq_len, int *seq
) {
struct li_production_t *prod = li_production_alloc(seq_len);
if (prod == NULL) {
return 1;
}
memcpy(prod->seq, seq, seq_len*sizeof(int));
prod->next = rule->head;
rule->head = prod;
rule->num_productions += 1;
return 0;
}
li_grammar_t * li_grammar_alloc(size_t num_nonterminal) {
li_grammar_t *grammar = malloc(sizeof(li_grammar_t));
if (grammar == NULL) {
fprintf(stderr, "failed to allocate grammar\n");
return NULL;
}
grammar->rules = malloc(num_nonterminal * sizeof(struct li_production_rule_t));
if (grammar->rules == NULL) {
fprintf(stderr, "failed to allocate grammar rules buffer\n");
free(grammar);
return NULL;
}
for (size_t i=0; i<num_nonterminal; i++) {
grammar->rules[i].num_productions = 0;
grammar->rules[i].head = NULL;
}
grammar->num_nonterminal = NULL;
return grammar;
}
void li_grammar_free(li_grammar_t *grammar) {
if (grammar != NULL) {
for (size_t i=0; i<grammar->num_nonterminal; i++) {
li_production_free(grammar->rules[i].head);
}
free(grammar->rules);
free(grammar);
}
}
int li_grammar_rule_add(
li_grammar_t *grammar, int nonterminal, size_t seq_len, int *seq
) {
if (nonterminal < 0 || nonterminal >= grammar->num_nonterminal) {
return 2;
}
return li_prod_rule_add(grammar->rules + nonterminal, seq_len, seq);
}
|
