src/parse_l.l

   1 /* $Id$ */
   2
   3 %{
   4 /*
   5  *                            COPYRIGHT
   6  *
   7  *  PCB, interactive printed circuit board design
   8  *  Copyright (C) 1994,1995,1996,2006 Thomas Nau
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  *
  24  *  Contact addresses for paper mail and Email:
  25  *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
  26  *  Thomas.Nau@rz.uni-ulm.de
  27  *
  28  */
  29
  30 /* lexical definitions to parse ASCII input of PCB and Element description
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <ctype.h>
  40
  41 #if defined(_POSIX_SOURCE) || defined(_HPUX_SOURCE)
  42 #include <unistd.h>
  43 #endif
  44
  45 #include "global.h"
  46
  47 #ifdef HAVE_LIBDMALLOC
  48 # include <dmalloc.h> /* see http://dmalloc.com */
  49 #endif
  50
  51 RCSID("$Id$");
  52
  53
  54 #include "global.h"
  55 #include "crosshair.h"
  56 #include "data.h"
  57 #include "error.h"
  58 #include "file.h"
  59 #include "mymem.h"
  60 #include "misc.h"
  61 #include "strflags.h"
  62 #include "parse_l.h"
  63 #include "parse_y.h"
  64
  65 /* ---------------------------------------------------------------------------
  66  * some shared parser identifiers
  67  */
  68 #ifdef FLEX_SCANNER
  69 int                             yylineno;               /* linenumber */
  70 #define yyunput ATTRIBUTE_UNUSED yyunput
  71 #endif
  72
  73 char                    *yyfilename;    /* in this file */
  74 PCBTypePtr              yyPCB;                  /* used by parser */
  75 DataTypePtr             yyData;
  76 ElementTypePtr          yyElement;
  77 FontTypePtr             yyFont;
  78
  79 static int parse_number (double);
  80
  81 /* ---------------------------------------------------------------------------
  82  * an external prototypes
  83  */
  84 int     yyparse(void);
  85
  86 /* ---------------------------------------------------------------------------
  87  * some local prototypes
  88  */
  89 static  int             Parse(char *, char *, char *, char *);
  90
  91 %}
  92
  93 HEX                             0x[0-9a-fA-F]+
  94 DECIMAL                 -?[1-9][0-9]*|0
  95 FLOATING                [+-]?[0-9]*("."[0-9]*)?
  96 FLOATINGMM              {FLOATING}[mM][mM]
  97 FLOATINGUM              {FLOATING}[uU][mM]
  98 FLOATINGIN              {FLOATING}[iI][nN]
  99 FLOATINGMIL             {FLOATING}[mM][iI][lL]
 100 CARDINAL                [1-9][0-9]*|0
 101 STRINGCHAR              ([^"\n\r\\]|\\.)
 102
 103 %option yylineno
 104
 105 %%
 106
 107 FileVersion     { return(T_FILEVERSION); }
 108 PCB                     { return(T_PCB); }
 109 Grid            { return(T_GRID); }
 110 Cursor          { return(T_CURSOR); }
 111 Thermal         { return(T_THERMAL); }
 112 PolyArea        { return(T_AREA); }
 113 DRC             { return(T_DRC); }
 114 Flags           { return(T_FLAGS); }
 115 Layer           { return(T_LAYER); }
 116 Pin                     { return(T_PIN); }
 117 Pad                     { return(T_PAD); }
 118 Via                     { return(T_VIA); }
 119 Line            { return(T_LINE); }
 120 Rat             { return(T_RAT); }
 121 Rectangle       { return(T_RECTANGLE); }
 122 Text            { return(T_TEXT); }
 123 ElementLine     { return(T_ELEMENTLINE); }
 124 ElementArc      { return(T_ELEMENTARC); }
 125 Element         { return(T_ELEMENT); }
 126 SymbolLine      { return(T_SYMBOLLINE); }
 127 Symbol          { return(T_SYMBOL); }
 128 Mark            { return(T_MARK); }
 129 Groups          { return(T_GROUPS); }
 130 Styles          { return(T_STYLES); }
 131 Polygon         { return(T_POLYGON); }
 132 Arc             { return(T_ARC); }
 133 NetList         { return(T_NETLIST); }
 134 Net             { return(T_NET); }
 135 Connect         { return(T_CONN); }
 136 Attribute       { return(T_ATTRIBUTE); }
 137
 138 \'.\'                           {
 139                                                 yylval.number = (unsigned) *(yytext+1);
 140                                                 return(CHAR_CONST);
 141                                         }
 142 {FLOATINGMM}            {       return parse_number(3937.0079); }
 143 {FLOATINGUM}            {       return parse_number(3.9370079); }
 144 {FLOATINGIN}            {       return parse_number(100000.0); }
 145 {FLOATINGMIL}           {       return parse_number(100.0); }
 146 {DECIMAL}               {       return parse_number(1.0); }
 147
 148 {HEX}                   {
 149                                                 sscanf((char *) yytext, "%x", &yylval.number);
 150                                                 return(NUMBER);
 151                                         }
 152 {FLOATING}                      {
 153                                                 yylval.floating = c_strtod (yytext);
 154                                                 return(FLOAT);
 155                                         }
 156 \"{STRINGCHAR}*\"       {
 157                                                 char    *p1, *p2;
 158
 159                                                         /* return NULL on empty string */
 160                                                 if (yyleng == 2)
 161                                                 {
 162                                                         yylval.string = NULL;
 163                                                         return(STRING);
 164                                                 }
 165
 166                                                         /* allocate memory and copy string;
 167                                                          * stringlength is counted and copied without
 168                                                          * leading and trailing '"'
 169                                                          */
 170                                                 yyleng -= 2;
 171                                                 yylval.string = MyCalloc(yyleng+1, sizeof(char), "LEX");
 172                                                 p1 = (char *) (yytext +1);
 173                                                 p2 = yylval.string;
 174                                                 while(yyleng--)
 175                                                 {
 176                                                                 /* check for special character */
 177                                                         if (*p1 == '\\')
 178                                                         {
 179                                                                 yyleng--;
 180                                                                 p1++;
 181
 182                                                         }
 183                                                         *p2++ = *p1++;
 184                                                 }
 185                                                 *p2 = '\0';
 186                                                 return(STRING);
 187                                         }
 188 #.*                                     {}
 189 [ \t]+                          {}
 190 [\n]                            {
 191 #ifndef FLEX_SCANNER
 192                                                 yylineno++;
 193 #endif
 194                                         }
 195 [\r]                            {}
 196 .                                       { return(*yytext); }
 197
 198 %%
 199
 200 /* ---------------------------------------------------------------------------
 201  * sets up the preprocessor command
 202  */
 203 static int Parse(char *Executable, char *Path, char *Filename, char *Parameter)
 204 {
 205         static  char    *command = NULL;
 206         int             returncode;
 207         int             used_popen = 0;
 208         char *tmps;
 209         size_t l;
 210 #ifdef FLEX_SCANNER
 211         static  Boolean firsttime = True;
 212 #endif
 213
 214         if (EMPTY_STRING_P (Executable))
 215           {
 216             l = 2;
 217             if ( Path != NULL )
 218               l += strlen (Path);
 219
 220             l += strlen (Filename);
 221
 222             if ( (tmps = (char *) malloc ( l * sizeof (char))) == NULL)
 223               {
 224                 fprintf (stderr, "Parse():  malloc failed\n");
 225                 exit (1);
 226               }
 227
 228             if ( Path != NULL && *Path != '\0')
 229               sprintf (tmps, "%s%s%s", Path, PCB_DIR_SEPARATOR_S, Filename);
 230             else
 231               sprintf (tmps, "%s", Filename);
 232
 233             yyin = fopen (tmps, "r");
 234             if (!yyin)
 235               {
 236                 Message("Can't open %s for reading\n", tmps);
 237                 return(1);
 238               }
 239             free (tmps);
 240           }
 241         else
 242           {
 243             used_popen = 1;
 244             /* release old command and create new from template */
 245             if (command)
 246               MYFREE (command);
 247             command = EvaluateFilename(Executable, Path, Filename, Parameter);
 248
 249             /* open pipe to stdout of command */
 250             if (*command == '\0' || (yyin = popen(command, "r")) == NULL)
 251               {
 252                 PopenErrorMessage(command);
 253                 return(1);
 254               }
 255           }
 256
 257 #ifdef FLEX_SCANNER
 258                 /* reset parser if not called the first time */
 259         if (!firsttime)
 260                 yyrestart(yyin);
 261         firsttime = False;
 262 #endif
 263
 264                 /* init linenumber and filename for yyerror() */
 265         yylineno = 1;
 266         yyfilename = Filename;
 267
 268                 /* We need to save the data temporarily because lex-yacc are able
 269                  * to break the application if the input file has an illegal format.
 270                  * It's not necessary if the system supports the call of functions
 271                  * on termination.
 272                  */
 273
 274 #if !defined(HAS_ATEXIT) && !defined(HAS_ON_EXIT)
 275         if (PCB)
 276           SaveTMPData();
 277         returncode = yyparse();
 278         RemoveTMPData();
 279 #else
 280         returncode = yyparse();
 281 #endif
 282         /* clean up parse buffer */
 283         yy_delete_buffer(YY_CURRENT_BUFFER);
 284
 285         if (used_popen)
 286           return(pclose(yyin) ? 1 : returncode);
 287         return(fclose(yyin) ? 1 : returncode);
 288 }
 289
 290 /* ---------------------------------------------------------------------------
 291  * initializes LEX and calls parser for a single element file
 292  */
 293 int ParseElementFile(DataTypePtr Ptr, char *Filename)
 294 {
 295         yyPCB = NULL;
 296         yyData = Ptr;
 297         yyFont = &PCB->Font;
 298         yyElement = NULL;
 299         return(Parse(NULL,NULL,Filename,NULL));
 300 }
 301
 302 /* ---------------------------------------------------------------------------
 303  * initializes LEX and calls parser for a single library entry
 304  */
 305 int ParseLibraryEntry(DataTypePtr Ptr, char *Template)
 306 {
 307         yyPCB = NULL;
 308         yyData = Ptr;
 309         yyFont = &PCB->Font;
 310         yyElement = NULL;
 311         return(Parse(Settings.LibraryCommand, Settings.LibraryPath,
 312                 Settings.LibraryFilename, Template));
 313 }
 314
 315 /* ---------------------------------------------------------------------------
 316  * initializes LEX and calls parser for a complete board
 317  */
 318 int ParsePCB(PCBTypePtr Ptr, char *Filename)
 319 {
 320         yyPCB = Ptr;
 321         yyData = NULL;
 322         yyFont = NULL;
 323         yyElement = NULL;
 324         return(Parse(Settings.FileCommand, Settings.FilePath, Filename, NULL));
 325 }
 326
 327 /* ---------------------------------------------------------------------------
 328  * initializes LEX and calls parser for a font
 329  */
 330 int ParseFont(FontTypePtr Ptr, char *Filename)
 331 {
 332         int r = 0;
 333         char *path, *p;
 334         yyPCB = NULL;
 335         yyFont = Ptr;
 336         yyElement = NULL;
 337
 338         path = strdup (Settings.FontPath);
 339
 340         /* search through the font path for a font file */
 341         for (p = strtok (path, PCB_PATH_DELIMETER); p && *p;
 342                 p = strtok (NULL, PCB_PATH_DELIMETER))
 343           {
 344             Message ("Looking for %s in %s\n", Filename, p);
 345             r = Parse(Settings.FontCommand, p, Filename, NULL);
 346             if (r == 0)
 347               {
 348                 Message ("Found %s in %s\n", Filename, p);
 349                 break;
 350               }
 351           }
 352         free (path);
 353
 354         return r;
 355 }
 356
 357 static int
 358 parse_number (double scale)
 359 {
 360   double val;
 361   sscanf ((char *) yytext, "%lf", &val);
 362   val *= scale;
 363   /* Round towards nearest means we have to check the sign first.  */
 364   if (val < 0)
 365     val -= 0.49;
 366   else
 367     val += 0.49;
 368   yylval.number = (int)(val);
 369   return NUMBER;
 370 }