Грамматика эта слишком простая для бизона: бизон предназначен для контекстно-свободных грамматик, а эта --- регулярная, описывается к примеру регулярным выражением [0-9]+ "." [0-9]+ "+" [0-9]+ "." [0-9]+.

Но если уж так надо именно на бизоне (то есть если это учебный пример), то можно просто различать нетерминалы для целой и дробной части:

S: E { cout << "Output string: " << $1 << endl; }

E: T '+' T { $$ = $1 + $3; }

T: H '.' L { $$ = $1 + $3 / 10; }

H   : B   { $$ = $1; }
    | H B { $$ = $1 * 10 + $2; }

L   : B   { $$ = $1; }
    | B L { $$ = $2 / 10 + $1; }

B   : '0' { $$ = 0; }
    | '1' { $$ = 1; }
    | '2' { $$ = 2; }

В дробной части используется правая рекурсия, в целой части --- левая. Это не принципиально (оба случая можно переделать на другую), просто здесь так удобно сворачивать числа.

Спасибо, но уже этой тропой ходили. Такой код не примет числа разной размерности, т.е. например 2.2+1.1 он посчитает. А вот 2.01+1.1 он сосчитает неверно. Там, во-первых, при наборе чисел уже в пятом правиле потеряются нули в дробной части, а во-вторых, в правиле с точкой, оно запишет число только с определенной длинной: десятые, сотые.

Спасибо!

Извините за предыдущий комментарий. Долбился в глаза, суть не сразу ухватил. Это было отличной идеей преобразовать сами правила. Очень надеюсь, что с таким решением не пошлют. Очень выручили, спасибо!

:)

На всякий случай запощщу пример рабочей программы:

/*
 * $ bison 1.y && gcc 1.tab.c && ./a.out
 * 2.01+1.1
 * Output string: 3.110000
 *
 */

%{
#include <stdlib.h>
#include <stdio.h>

int yylex()
{
    char c = getc(stdin);
    return (c == '\n') ? 0 : c;
}

void yyerror(const char *s)
{
    fprintf(stderr, "%s\n", s);
    exit(1);
}

%}

%union {
        double d;
};

%type <d> S E T H L B

%%

S: E { printf("Output string: %lf\n", $1); }

E: T '+' T { $$ = $1 + $3; }

T: H '.' L { $$ = $1 + $3 / 10; }

H   : B   { $$ = $1; }
    | H B { $$ = $1 * 10 + $2; }

L   : B   { $$ = $1; }
    | B L { $$ = $2 / 10 + $1; }

B   : '0' { $$ = 0; }
    | '1' { $$ = 1; }
    | '2' { $$ = 2; }

%%

int main()
{
    return yyparse();
}

Парзить числа лучше в лексере, что бы он кушал их в виде -1.234e-15 и выдавал уже эту сроку на гора. (Это именно его задача.) А дальше просто atof.

ну вдруг чуваку понадобятся long numbers...

А лексеру без разницы. Он всего лишь выплёвывает строки.

ну тады без atof

ТС, глянь сюда: http://openports.se/math/hc — простой калькулятор на lex/yacc.

Сказали, низзя atof. Типа, это уже не будет синтаксически управляемым сложением.

Спасибо еще раз.

Я запустил с этим:

#ifndef YYSTYPE

#define YYSTYPE double

#endif

вместо union

А чисто теоретически, есть ли метод запилить не преобразуя изначальную грамматику?

А чисто теоретически, есть ли метод запилить не преобразуя изначальную грамматику?

Да. Нужно всего лишь считать экспоненту (тебе придется поменять тип данных):

%union {
  struct {
    double val;
    int exp;
  } acc;
  double val;
}
%type<acc> L
%type<val> S E T B

/* ... */
T: L '.' L { $$ = $1.val + $2.val * exp10(10, -$2.exp); }

L: B { $$.exp = 1; $$.val = $1; }
 | L B { $$.exp = 1 + $1.exp; $$.val = $1.val * 10 + $2; }