Nie możesz wybrać więcej, niż 25 tematów
Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
167 wiersze
3.2 KiB
167 wiersze
3.2 KiB
%{
|
|
|
|
/* compile: leg -o calc.c calc.leg
|
|
* cc -o calc calc.c
|
|
*
|
|
* run: echo "2+3" | ./calc
|
|
*/
|
|
|
|
#include <stdbool.h>
|
|
|
|
union u_t {
|
|
int ival;
|
|
char *sval;
|
|
};
|
|
#define YYSTYPE union u_t
|
|
YYSTYPE yylval;
|
|
|
|
#define SYMBOL_TABLE_CHUNK 1024
|
|
|
|
typedef struct symbol_t {
|
|
char *ident;
|
|
bool defined;
|
|
int value;
|
|
} symbol_t;
|
|
|
|
typedef struct table_t {
|
|
symbol_t **array;
|
|
int size;
|
|
int capacity;
|
|
} table_t;
|
|
|
|
table_t table;
|
|
|
|
typedef struct bsearch_t {
|
|
int pos;
|
|
bool found;
|
|
} bsearch_t;
|
|
|
|
char *ident_buf;
|
|
|
|
bsearch_t binary_search(symbol_t *arr[], int l, int r, char *ident)
|
|
{
|
|
while (r >= l) {
|
|
int mid = l + (r - l) / 2;
|
|
int cmpres = strcmp(arr[mid]->ident, ident);
|
|
if (cmpres > 0) {
|
|
r = mid - 1;
|
|
} else if (cmpres < 0) {
|
|
l = mid + 1;
|
|
} else {
|
|
bsearch_t res = { mid, true };
|
|
return res;
|
|
}
|
|
}
|
|
bsearch_t res = { l, false };
|
|
return res;
|
|
}
|
|
|
|
int insert(table_t *table, symbol_t *element, int pos)
|
|
{
|
|
if (pos < 0 || pos > table->size) {
|
|
return -1;
|
|
}
|
|
|
|
if (table->size >= table->capacity) {
|
|
table->array = realloc(table->array, sizeof(symbol_t *) * (table->capacity + SYMBOL_TABLE_CHUNK));
|
|
if (table->array == NULL) {
|
|
printf("Error: running out of memory\n");
|
|
exit(1);
|
|
}
|
|
table->capacity += SYMBOL_TABLE_CHUNK;
|
|
}
|
|
|
|
for (int i = table->size; i > pos; i--) {
|
|
table->array[i] = table->array[i-1];
|
|
}
|
|
table->array[pos] = element;
|
|
return ++(table->size);
|
|
}
|
|
|
|
symbol_t *intern(char *ident, bool create)
|
|
{
|
|
bsearch_t res = binary_search(table.array, 0, table.size - 1, ident);
|
|
if (res.found) {
|
|
return table.array[res.pos];
|
|
}
|
|
|
|
if (create) {
|
|
symbol_t *new_symbol = malloc(sizeof(symbol_t));
|
|
new_symbol->ident = strdup(ident);
|
|
new_symbol->defined = false;
|
|
insert(&table, new_symbol, res.pos);
|
|
return new_symbol;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
symbol_t *update_value(symbol_t * s, int value)
|
|
{
|
|
s->value = value;
|
|
s->defined = true;
|
|
return s;
|
|
}
|
|
|
|
|
|
void init_table()
|
|
{
|
|
table.array = malloc(sizeof(symbol_t *) * SYMBOL_TABLE_CHUNK);
|
|
if (table.array == NULL) {
|
|
printf("Error: running out of memory\n");
|
|
exit(1);
|
|
}
|
|
table.size = 0;
|
|
table.capacity = SYMBOL_TABLE_CHUNK;
|
|
}
|
|
|
|
|
|
%}
|
|
|
|
start = e:exp { yylval = e }
|
|
|
|
exp = - (a:assign { $$ = a }
|
|
| s:sum { $$ = s }
|
|
)
|
|
|
|
assign = l:IDENT { ident_buf = strdup(l.sval) }
|
|
EQUAL n:sum { symbol_t *nsymb = intern(ident_buf, true); $$.ival = update_value(nsymb, n.ival)->value; free(ident_buf) }
|
|
|
|
sum = PLUS* l:prod
|
|
( PLUS+ r:prod { l.ival += r.ival }
|
|
| MINUS r:prod { l.ival -= r.ival }
|
|
)* { $$.ival = l.ival }
|
|
|
|
prod = l:neg
|
|
( MULTI r:neg { l.ival *= r.ival }
|
|
| DIVIDE r:neg { l.ival /= r.ival }
|
|
| MODULO r:neg { l.ival %= r.ival }
|
|
)* { $$.ival = l.ival }
|
|
|
|
neg = MINUS n:neg { $$.ival = -n.ival }
|
|
| n:value { $$.ival = n.ival }
|
|
|
|
value = n:NUMBER { $$.ival = n.ival }
|
|
| l:IDENT { symbol_t *fsymb = intern(l.sval, false); $$.ival = (fsymb != NULL) ? (fsymb->defined == true) ? fsymb->value : 0 : 0 }
|
|
|
|
- = [ \t]*
|
|
NUMBER = < [0-9]+ > - { $$.ival = atoi(yytext) }
|
|
PLUS = '+' -
|
|
MINUS = '-' -
|
|
MULTI = '*' -
|
|
DIVIDE = '/' -
|
|
MODULO = '%' -
|
|
EQUAL = '=' -
|
|
IDENT = < [a-zA-Z]+ > - { $$.sval = yytext }
|
|
|
|
%%
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
init_table();
|
|
while (yyparse()) {
|
|
printf("%d\n", yylval.ival);
|
|
}
|
|
|
|
return 0;
|
|
}
|