Date:2012-05-21 04:16:51 (11 years 10 months ago)
Author:Werner Almesberger
Commit:6fd5313917db95d97c0e2ea3119acff90e0cbb95
Message:b2/: assigments to can express inequalities

Files: b2/SUBST (1 diff)
b2/boom.c (3 diffs)
b2/lang.l (1 diff)
b2/lang.y (1 diff)
b2/subex.c (4 diffs)
b2/subex.h (1 diff)
b2/subst.c (3 diffs)
b2/subst.h (3 diffs)

Change Details

b2/SUBST
11REF=R[0-9]* {
22    T=R
33    VAL=(#R) { R=$1 }
4    TOL = 5%
5    FN=*% { TOL=$$ }
4    TOL <= 5%
5    FN=*% { TOL<=$$ }
66    break REF
77// end break again
88}
b2/boom.c
1616
1717#include "util.h"
1818#include "lang.h"
19#include "param.h"
1920#include "subex.h"
2021
2122
...... 
3334        exit(1);
3435    }
3536    *eq = 0;
36    *last_var = make_var(tmp, eq+1);
37    *last_var = make_var(tmp, rel_eq, eq+1);
3738    last_var = &(*last_var)->next;
3839}
3940
...... 
4445    const struct var *var;
4546
4647    out = substitute(substitutions, vars);
47    for (var = out; var; var = var->next)
48        printf("%s=%s\n", var->name, var->value);
48    for (var = out; var; var = var->next) {
49        printf("%s", var->name);
50        dump_relop(stdout, var->op);
51        printf("%s\n", var->value);
52    }
4953    free_vars(out);
5054}
5155
b2/lang.l
119119    }
120120%}
121121
122<INITIAL,ID>{ID}({ID}|"%")* { yylval.s = unique(yytext);
122<INITIAL,ID>{ID}({ID}|"%")* { yylval.s = unique(yytext);
123123                  return WORD; }
124124
125125<PAT>{PAT}* { BEGIN(ID);
126126                  yylval.s = stralloc(yytext);
127127                  return PATTERN; }
128128
129"=" { if (pattern)
129[<>=] { if (pattern)
130130                    BEGIN(PAT);
131                  return '='; }
131                  return *yytext; }
132132
133"<=" return TOK_LE;
134">=" return TOK_GE;
133"<=" { if (pattern)
134                    BEGIN(PAT);
135                  return TOK_LE; }
136">=" { if (pattern)
137                    BEGIN(PAT);
138                  return TOK_GE; }
135139
136140"//"[^\n]* ;
137141"/*"([^*]|("*"+([^*/])))*"*"+"/" { const char *s = yytext;
b2/lang.y
587587        {
588588            $$ = NULL;
589589        }
590    | WORD '=' PATTERN opt_block block
590    | WORD relop PATTERN opt_block block
591591        {
592592            if ($4) {
593                if ($2 != rel_eq)
594                    yyerror("only = allow for matching");
593595                $$ = subst_match($1, $3);
594596                $$->u.match.block = $4;
595597            } else {
596                $$ = subst_assign($1, $3);
598                $$ = subst_assign($1, $2, $3);
597599            }
598600            free((void *) $3);
599601            $$->next = $5;
b2/subex.c
2121#include "util.h"
2222#include "vstring.h"
2323#include "lang.h"
24#include "relop.h"
2425#include "subst.h"
2526#include "subex.h"
2627
...... 
138139}
139140
140141
141struct var *make_var(const char *name, const char *val)
142struct var *make_var(const char *name, enum relop op, const char *val)
142143{
143144    struct var *var;
144145
145146    var = alloc_type(struct var);
146147    var->name = unique(name);
148    var->op = op;
147149    var->value = unique(val);
148150    var->next = NULL;
149151    return var;
150152}
151153
152154
153static void do_assign(const char *name, struct var **out, const char *val)
155static void do_assign(const char *name, struct var **out, enum relop op,
156    const char *val)
154157{
155158    while (*out) {
156159        if ((*out)->name == name)
...... 
161164        free((void *) (*out)->value);
162165        (*out)->value = val;
163166    } else {
164        *out = make_var(name, val);
167        *out = make_var(name, op, val);
165168    }
166169}
167170
...... 
217220        case st_assign:
218221            tmp = compose(sub->u.assign.pat, in, *out, s, match,
219222                units);
220            do_assign(sub->u.assign.dst, out, tmp);
223            do_assign(sub->u.assign.dst, out, sub->u.assign.op,
224                tmp);
221225            break;
222226        case st_end:
223227            return &jump_end;
b2/subex.h
1313#ifndef SUBEX_H
1414#define SUBEX_H
1515
16#include "relop.h"
1617#include "subst.h"
1718
1819
1920struct var {
2021    const char *name;
22    enum relop op;
2123    const char *value;
2224    struct var *next;
2325};
2426
2527
2628struct var *substitute(const struct subst *sub, const struct var *in);
27struct var *make_var(const char *name, const char *val);
29struct var *make_var(const char *name, enum relop op, const char *val);
2830const char *var_lookup(const struct var *vars, const char *name);
2931void free_vars(struct var *vars);
3032
b2/subst.c
2121#include "util.h"
2222#include "vstring.h"
2323#include "lang.h"
24#include "relop.h"
2425#include "subst.h"
2526
2627
...... 
226227}
227228
228229
229struct subst *subst_assign(const char *dst, const char *pat)
230struct subst *subst_assign(const char *dst, enum relop op, const char *pat)
230231{
231232    struct subst *sub;
232233
233234    sub = alloc_subst(st_assign);
234235    sub->u.assign.dst = dst;
236    sub->u.assign.op = op;
235237    sub->u.assign.pat = parse_pattern(pat);
236238    return sub;
237239}
...... 
358360            fprintf(file, "%*s}\n", INDENT*level, "");
359361            break;
360362        case st_assign:
361            fprintf(file, "%s=", sub->u.assign.dst);
363            fprintf(file, "%s", sub->u.assign.dst);
364            dump_relop(file, sub->u.assign.op);
362365            dump_chunks(file, sub->u.assign.pat);
363366            fprintf(file, "\n");
364367            break;
b2/subst.h
1717#include <sys/types.h>
1818#include <regex.h>
1919
20#include "relop.h"
21
2022
2123enum chunk_type {
2224    ct_string,
...... 
5355        } match;
5456        struct {
5557            const char *dst;
58            enum relop op;
5659            struct chunk *pat;
5760        } assign;
5861        const struct subst *jump;
...... 
6669
6770
6871struct subst *subst_match(const char *src, const char *re);
69struct subst *subst_assign(const char *dst, const char *pat);
72struct subst *subst_assign(const char *dst, enum relop op, const char *pat);
7073struct subst *subst_end(void);
7174struct subst *subst_break(const char *block);
7275struct subst *subst_again(const char *block);

Archive Download the corresponding diff file

Branches:
master



interactive