Subversion Repositories gecko3

/* GECKO3COM

 *

 * Copyright (C) 2009 by

 *   ___    ____  _   _

 *  (  _`\ (  __)( ) ( )

 *  | (_) )| (_  | |_| |   Berne University of Applied Sciences

 *  |  _ <'|  _) |  _  |   School of Engineering and

 *  | (_) )| |   | | | |   Information Technology

 *  (____/'(_)   (_) (_)

 *

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see .

 */

/*********************************************************************/

/** \cond EXAMPLE \file     scpi_parser.re

 *********************************************************************

 * \brief     Parser for the SCPI commands. Excecutes the necessary

 *            Function.

 *

 *            The SCPI Parser is developed as a set of regular

 *            expressions and blocks of C code to excecute. \n

 *            We use the opensource programm re2c (http://re2c.org/) to

 *            generate the parser. With solution we have an easy to

 *            maintain and extend parser definitions without the hassle

 *            of optimizing the parser sourcecode by hand. \n \n

 *            Don't forget to use the "-s" option with re2c to generate

 *            nested ifs for some switches because sdcc hates long

 *            switch case structures.

 *

 * \todo      use newer re2c to generate state event diagramm to include here

 *

 * \author    Christoph Zimmermann bfh.ch

 * \date      2009-02-04

 *

 * \endcond

*/

#include 

#include 

#include "scpi_parser.h"

#include "debugprint.h"

#define YYCTYPE         uint8_t

#define YYCURSOR        s->cur

#define YYLIMIT         s->lim

#define YYMARKER        s->ptr

#define YYFILL(n)       {YYCURSOR = fill(s, buffer, n);}

/*!max:re2c */          /* this will define YYMAXFILL */

uint8_t* fill(Scanner *s, int16_t *buffer, uint8_t n){

  uint8_t i = 0;

  for(i;i

    buffer[i] = tolower(*(s->source));

    s->source++;

  }

  s->cur = buffer;

  s->lim = &buffer[n];

  return s->cur;

}

int8_t scpi_scan(Scanner *s){

  int8_t buffer[YYMAXFILL];

  /** \cond SCANNER

   * this is a ugly hack to avoid that the regular expressions are included in

   * the doxygen documentation

  */

  /*!re2c

  /* place here the regular expressions to detect the end of a message */

  /* FIXME end detection missing */

  "\n"                                  { /* end of message reached */

                                          return 99;

                                        }

  /* this set of regular expressions are for the mandatory IEEE488 commands */

  "*cls"                                { /* clear status command */

                                          return 1;

                                        }

  "*ese"                                { /* standard event status enable command */

                                          return 1;

                                        }

  "*ese?"                               { /* standard event status enable query */

                                          return 1;

                                        }

  "*esr?"                               { /* standard event status register query */

                                          return 1;

                                        }

  "*idn?"                               { /* identification query */

                                          return 1;

                                        }

  "*opc"                                { /* operation complete command */

                                          return 1;

                                        }

  "*opc?"                               { /* operation complete query */

                                          return 1;

                                        }

  "*rst"                                { /* reset command */

                                          return 1;

                                        }

  "*sre"                                { /* service request enable command */

                                          return 1;

                                        }

  "*sre?"                               { /* service request enable query */

                                          return 1;

                                        }

  "*stb?"                               { /* read status byte query */

                                          return 1;

                                        }

  "*tst?"                               { /* self-test query */

                                          return 1;

                                        }

  "*wai"                                { /* wait-to-continue command */

                                          return 1;

                                        }

  /* this set of regular expressions are for the mandatory SCPI 99 commands */

  "syst:err?"|"syst:err:next?"          { /* gets an error message if ther is one */

                                          return 1;

                                        }

  "syst:vers"                           { /* returns the firmware version number */

                                          return 1;

                                        }

  "stat:oper?"|"stat:oper:even?"        { /* dfsg */

                                          return 1;

                                        }

  "stat:oper:cond?"                     { // fsdgsg

                                          return 1;

                                        }

  "stat:oper:enab"                      { // sfgsdf

                                          return 1;

                                        }

  "stat:oper:enab?"                     { // sfgfsdg

                                          return 1;

                                        }

  "stat:ques?"|"stat:ques:even?"        { // sfgfsdg

                                          return 1;

                                        }

  "stat:ques:cond?"                     { // sfgsdfg

                                          return 1;

                                        }

  "stat:ques:enab"                      { // sfgsdfg

                                          return 1;

                                        }

  "stat:ques:enab?"                     { // sfgfg

                                          return 1;

                                        }

  "stat:pres"                           { // sfgfg

                                          return 1;

                                        }

  /* this set of regular expressions are for the device functions */

  "diag:mes?"                           { /* ask if there is a message to read available */

                                          print_info("scpi: diag:mes?\n");

                                          return 1;

                                        }

  "diag:mes"                            { /* reads the message from the message buffer */

                                          print_info("scpi: diag:mes\n");

                                          return 1;

                                        }

  "diag:gpif?"                          { /* reads the GPIF state */

                                          print_info("scpi: diag:gpif?\n");

                                          return 1;

                                        }

*/

/** \endcond */

}