LEX, YACC Problem..

[Holm T. (Gast)]

Hi.

Ich möchte einen simplen Kommandozeilenparser mit lex und yacc basteln 
aber trotz Lesens diverser (online) Literatur, Manuals und auch 
Beispielcode
habe ich wohl einen Knoten im Kopf der mich hindert vorwärts zu kommen.
Ich habe mir 2 Bücher bestellt die hoffentlich heute kommen...

Ich möchte simple Kommandozeilen wie z.B. diese hier parsen und 
Variablen setzen und lesen:

set meas dac 0 offset 33<lf>

oder halt

get meas dac 0 offset<lf>

Dazu habe ich folgendes lex file gebastelt:

%{
#include <stdio.h>
#include "y.tab.h"

#ifndef YYERRCODE
#define YYERRCODE 256
#endif

extern int yylval;
extern int tmpint;
extern char tmpchr;
%}
%%
acloops                 return TOKACLOO;
autocal                 return TOKAUTOC;
adc                     return TOKADC;
calib                   return TOKCALIB;
cycle                   return TOKCYC;
ctrl                    return TOKCTRL;
dispb10                 return TOKDBEL10;
dismod                  return TOKDISPMD;
dac                     return TOKDAC;
eeprom                  return TOKEEPROM;
offset                  return TOKOFFSET;
order                   return TOKORDER;
solenoid                return TOKSOL;
staples                 return TOKSTAPLES;
staple                  return TOKSTAP;
smooth                  return TOKSMOOTH;
saving                  return TOKSAV;
slope                   return TOKSLOPE;
set                     return TOKSET;
get                     return TOKGET;
rounding                return TOKROUND;
rtc                     return TOKRTC;
median                  return TOKMEDIAN;
mwcorr                  return TOKMWCOR;
meas                    return TOKMEAS;
tcoff                   return TOKTCOFF;
tcalib                  return TOKTCALIB;
warmup                  return TOKWARM;
[abc][01]               yylval=(int)((yytext[0]-'a')<<1)|yytext[1]-'0'; return N
UMBER;
on|off                  yylval=(!strcmp(yytext,"on")); return STATE;
[0-9]+                  yylval=atoi(yytext); return NUMBER;
\r                      /* ignore carriage return */;
[ \t]+                  /* ignore whitespace */;
\n                      return TOKNL;
.                       printf("unrecognized char"); return YYERRCODE;
%%

und den folgenden Spielzeugparser:

%{
#include <stdio.h>
#include <string.h>
int     yylex();
int     yyparse();
;
#define DEBUG
#ifdef DEBUG
#       define DPRINTF(...) fprintf(stdout, __VA_ARGS__)
#else
#       define DPRINTF(...) /* nothing */
#endif

int     tmpval;
int     dac_0_offset;
int     dac_1_offset;
int     dac_0_slope;
int     dac_1_slope;
int     dac_order;
int     adc_order;
int     solenoid;
int     smoothing;
int     rounding;
int     staple;
int     staples;
int     autocal;
int     warmup=20;
int     saving;
int     acloops;
int     cycle=6;
int     mwcorr;
int     tcoff;
int     tcalib;

struct  meas {
        int     offset;
        int     slope;
        int     median;
};

struct meas mfield[6];

 
void yyerror(const char *str)
{
        fprintf(stderr,"error: %s\n",str);
}
 
int yywrap()
{
        return 1;
} 

void promptl()
{
        printf("L>");
}
void promptok()
{
        printf("ok>");
}
  
int main()
{
        while(1)
                yyparse();
} 

%}

%token NUMBER STATE TOKSET TOKGET TOKCTRL TOKMEAS TOKCALIB TOKDAC TOKADC
%token TOKSOL TOKAUTOC TOKWARM TOKDBEL10 TOKDISPMD TOKRTC TOKEEPROM
%token TOKOFFSET TOKSLOPE TOKORDER TOKSMOOTH TOKROUND TOKSTAP TOKSTAPLES
%token TOKSAV TOKACLOO TOKCYC TOKMWCOR TOKTCOFF TOKTCALIB TOKNL TOKMEDIAN


%%
commands: /* empty */ { promptl(); } |
        command { promptok(); }
        ;

command: 
        value_set
        |
        value_get
        |
        error '\n'      { YYABORT; }
        ;

value_set:      // set meas dac 0 offset 0
        TOKSET TOKMEAS TOKDAC NUMBER TOKOFFSET NUMBER TOKNL
        {
                DPRINTF("\tDAC %d offset set to %d\n",$4,$6);
                if($4==0)
                        dac_0_offset=$6;
                else
                        dac_1_offset=$6;
        }
        ;
        |       // set meas dac 0 slope 0
        TOKSET TOKMEAS TOKDAC NUMBER TOKSLOPE NUMBER TOKNL
        {
                DPRINTF("\tDAC %d slope set to %d\n",$4,$6);
                if($4==0)
                        dac_0_slope=$6;
                else
                        dac_1_slope=$6;
        }


value_get:      // get meas dac 0 offset
        TOKGET TOKMEAS TOKDAC NUMBER TOKOFFSET TOKNL
        {
                if($4==0)
                        printf("\tDAC 0 OFFSET actual= %d\n",dac_0_offset);
                else
                        printf("\tDAC 1 OFFSET actual= %d\n",dac_1_offset);
                        
        }
        ;
        |       // get meas dac 0 slope
        TOKGET TOKMEAS TOKDAC NUMBER TOKSLOPE TOKNL
        {
                if($4==0)
                        printf("\tDAC 0 SLOPE actual=%d\n",dac_0_slope);
                else
                        printf("\tDAC 1 SLOPE actual=%d\n",dac_1_slope);
        }

Das ist ne gekürzte Variante, länger wäre noch langweiliger...

Mein Problem dabei ist nicht das das nicht funktioniert, sondern das 
Ganze gegen Unfug abzudichten, Ich möchte bei Syntaxfehlern Meldungen, 
und nach Fehlern gerne das die fehlerhafte Zeile verworfen wird und 
wieder ein Prompt erscheint. Nach einem einzelnen Newline hätte ich 
gerne einen neuen Prompt..
Ich habe jetzt schon seit ein paar Tagen die lustigsten Spielchen durch, 
aber ich kriege das nicht hin..was mache ich falsch?

Gruß,

Holm

[udok (Gast)]

Du verwendest lex und yacc, das machst du falsch :-)

Die Buffern ihren I/O und sind nicht für
Kommandozeilenverwendung gedacht.
Das lässt sich irgendwie abdrehen, eventuell mit setvbuf,
ich glaube aber, dass die Algorithmen dahinter ziemlich
viele Token vorrausschauen, wird ja oft als Vorteil gesehen.

[Holm T. (Gast)]

udok schrieb:
> Du verwendest lex und yacc, das machst du falsch :-)


Hmm...

>
> Die Buffern ihren I/O und sind nicht für
> Kommandozeilenverwendung gedacht.
> Das lässt sich irgendwie abdrehen, eventuell mit setvbuf,
> ich glaube aber, dass die Algorithmen dahinter ziemlich
> viele Token vorrausschauen, wird ja oft als Vorteil gesehen.

Ja, es gibt diese Mechanismen, yacc löffelt 3 Tokens bis er aus dem 
Fehlerstatus wieder heraus kommt und man kann ihn resynchronisieren..was 
mir allerdings mit '\n' als Synchronisationscharakter nicht recht 
gelingen will.
Das Puffern der Eingabe macht mir wenig Sorgen, ich übertrage die 
Kommandos
sowieso Zeilenweise und durch '\n' abgeschlossen. Mir reicht es, wenn 
nach einer fehlerfreien Zeile ein OK kommt und nach einer 
Fehlerbehafteten ein ERROR, aber bitte nicht 3.7 Stück davon. Außerdem 
hätte ich gerne nach einer leeren Eingabezeile wieder ein OK (der 
Versuch das zu basteln ist mit promptl() im Parser zu sehen, L für 
..leer....

Warum soll die Verwendung von lex und yacc falsch sein? Die wurden mal 
für solche Zwecke gemacht, ich unterfordere sie eher...

Gruß,
Holm

[Jörg W. (dl8dtl) (Moderator)]

udok schrieb:
> Die Buffern ihren I/O und sind nicht für Kommandozeilenverwendung
> gedacht.
> Das lässt sich irgendwie abdrehen

Meiner Erinnerung nach hat flex dafür irgendeine Option.

Yep, -I.  Die Doku sagt dazu:

'flex' scanners default to 'interactive' unless you use the '-Cf'
or '-CF' table-compression options (*note Performance::).  That's
because if you're looking for high-performance you should be using
one of these options, so if you didn't, 'flex' assumes you'd rather
trade off a bit of run-time performance for intuitive interactive
behavior.

Sollte also kein grundlegendes Problem sein.  Habe auch schon mal
(spaßeshalber) einen kleinen BASIC-Interpreter für AVRs mit flex und
byacc geschrieben; das funktionierte durchaus, auch interaktiv.

[Holm T. (Gast)]

...hab das -I ausprobiert...kein Unterschied. So richtig verwunderlich 
isses aber nicht:

" Flex scanners default to interactive unless you use the -Cf or
  -CF table-compression options (see below). "

Hmm...

..sehe gerade Jörg hat das auch geschrieben. Es sollte also prinzipiell 
funktionieren.

..muß erst mal was Andres machen.

Gruß,

Holm

[Karl der erste von oben (Gast)]

Ich hab nicht alles gelesen oder verstanden. Daher bitte um Nachsicht, 
aber man kann den Buffer von flex zur Laufzeit flushen. Yy_flush_buffer. 
Dann muss er neu einlesen.
Ich benutze das weil ich verschiedene Sachen aus einer Datei parsen mir 
und dazu Lexer und Parser tausche. Beim Wechsel muss die Datei an der 
richtigen Stelle stehen und der ziel-lexer muss geflusht sein damit es 
geht.

[Johann L. (gjlayde)]

Holm T. schrieb:
> Mein Problem dabei ist nicht das das nicht funktioniert, sondern das
> Ganze gegen Unfug abzudichten, Ich möchte bei Syntaxfehlern Meldungen,
> und nach Fehlern gerne ...

Das dürfte mit Bison / YACC nicht so einfach sein.  Zum Beispiel werden 
entsprechende Parser im GCC seit langem nicht mehr durch Generatoren 
erzeugt sondern sind handgeklöppelt.  Ein Grund dafür ist, dass es fast 
unmöglich war, sinnvolle Diagnostics zu bekommen bzw. sinnvolle 
Diagnostics und weiteres Verhalten nur in unbefriedigendem Umfang ode 
nicht mit vertretbarem Aufwand oder Wartbarkeitsverlust zu realisieren 
war.

Zwar verwendest zu eine deutlich einfachere Sprache als die von GCC zu 
parsenden, aber dennoch erhälst du besser zu kontrollierendes Verhalten, 
insbesondere bei Syntaxproblemen, wohl am einfachstem mit eigenem 
Parser.

Die Hacks und Tricks, die in einem Parser-Generator nötig wären, werden 
einen Großteil des Comforts, den der Einsatz eines solchen Generators 
bieten soll, zunichte gemacht.

[Holm T. (Gast)]

..naja..ganz so schlimm isses ja wohl auch wieder nicht und ein Projekt 
in der Größe eines GCC habe ich nicht vor.
Jörg (Tm) hat den Parser von avrdude auch mit lex und yacc 
gebastelt..scheint doch zu funktionieren :-)

Ich habe Jörg über meinen Krempel mal drüber gucken lassen und das 
funktioniert jetzt schon ganz brauchbar. Mal sehen zu welcher Größe das 
sich auswächst, im Endeffekt soll das mal auf einen Xmega.

Gruß,
Holm

[Jörg W. (dl8dtl) (Moderator)]

Für den Xmega solltest du aber meine AVR-Patches für flex und byacc
benutzen, damit er die Tabellen nicht in den RAM sondern in den Flash
wirft.

https://www.avrfreaks.net/comment/366056#comment-366056

[Possetitjel (Gast)]

Johann L. schrieb:

> Die Hacks und Tricks, die in einem Parser-Generator
> nötig wären, werden einen Großteil des Comforts, den
> der Einsatz eines solchen Generators bieten soll,
> zunichte gemacht.

Könntest Du dafür ein, zwei Beispiele geben, die auch
für einen Nicht-Compilerbauer verständlich sind?

[Holm T. (Gast)]

Jörg W. schrieb:
> Für den Xmega solltest du aber meine AVR-Patches für flex und byacc
> benutzen, damit er die Tabellen nicht in den RAM sondern in den Flash
> wirft.
>
> https://www.avrfreaks.net/comment/366056#comment-366056

Ok, das sehe ich mir an.. hatte sowieso vor den Output in dieser 
Richtung zu überarbeiten. Wenn das schon "aus der Dose" gibt, ist das ne 
feine Sache!

Gruß,

Holm