adsedgelabel.tab.c

这个工具集提供以下结构化分析和UML分析中所用的图形化绘图工具：ER-diagrams, data and event flow diagrams and state-transition diagr

/*  A Bison parser, made from adsedgelabel.y
    by GNU Bison version 1.28  */

#define YYBISON 1  /* Identify Bison output.  */

#define yyparse adsedgelabelparse
#define yylex adsedgelabellex
#define yyerror adsedgelabelerror
#define yylval adsedgelabellval
#define yychar adsedgelabelchar
#define yydebug adsedgelabeldebug
#define yynerrs adsedgelabelnerrs
#define	QUOTE	257
#define	OPEN	258
#define	CLOSE	259
#define	OPENB	260
#define	CLOSEB	261
#define	NL	262
#define	DAYS	263
#define	HOURS	264
#define	MINUTES	265
#define	SECONDS	266
#define	TIME	267
#define	COLON	268
#define	WHENTOKEN	269
#define	AFTERTOKEN	270
#define	ELSE	271
#define	TRUE	272
#define	LEQ	273
#define	GEQ	274
#define	EQ	275
#define	NEQ	276
#define	GT	277
#define	LT	278
#define	IDENTIFIER	279
#define	INTEGER	280
#define	MINUS	281
#define	PLUS	282
#define	OR	283
#define	TIMES	284
#define	DIV	285
#define	AND	286
#define	NEG	287
#define	NOT	288
#define	IN	289

#line 1 "adsedgelabel.y"

#include "adsedgelabelparse.h"
#include "adspropertytype.h"
#include "adsclocktypes.h"
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>


 





/*
typedef char *CHAR_PTR;
#define YYSTYPE CHAR_PTR
#define YYDEBUG 1
*/



/* variables for normal guards */
 int iprop; /* index on propname and proptype */
 int isintorstrexp; /* bool to check wether integer of string expression is meant */
 int ivar; /* index on varname and vartype */
 int indexin; /* index on in nodes */
 int notindexin; /* index on in nodes */
 int isvar; /* true iff variable occurs in edge label */
 int iselse; /* true iff else clause exists */
 char temp[100];
 char *propname[200];  /* name of prop */
 char *varname[100];    /* name of var */
 char *inname[100];    /* name of in nodes */
 char *notinname[100];    /* name of in nodes */
 enum PropType proptype[200];
 enum PropType vartype[200];

 
/* variables for clock constraints */
 int timetype; /* h/s/m */
 int isclock;  
 int iclock;  /* index on clockconstraint, clockconstrainttype and clocktype */
 int clockconstraint[200]; /* amount */
 enum PropType clockconstrainttype[200];/*,  after, when (mod) */
 enum ClockType clocktype[200];  /* h/s/m  */

/* variables for send actions */
 int hasaction; /* true iff action clause exists */
 char *sendeventname;
 int broadcast;  /* is the action event also directed to the environment? 1= system+environment, 0= only system */



#line 61 "adsedgelabel.y"
typedef union  {
  char *str_ptr;
      } YYSTYPE;
#include <stdio.h>

#ifndef __cplusplus
#ifndef __STDC__
#define const
#endif
#endif



#define	YYFINAL		80
#define	YYFLAG		-32768
#define	YYNTBASE	37

#define YYTRANSLATE(x) ((unsigned)(x) <= 289 ? yytranslate[x] : 54)

static const char yytranslate[] = {     0,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,    36,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    27,    28,    29,    30,    31,    32,    33,    34,    35
};

#if YYDEBUG != 0
static const short yyprhs[] = {     0,
     0,     2,     6,     7,     9,    11,    17,    18,    20,    22,
    24,    26,    27,    31,    32,    40,    41,    54,    55,    69,
    70,    79,    80,    82,    84,    88,    92,    95,    99,   101,
   102,   106,   107,   110,   113,   115,   117,   119,   121,   123,
   125,   127,   129,   130
};

static const short yyrhs[] = {    38,
     0,    39,    42,    53,     0,     0,    40,     0,    25,     0,
    16,     4,    26,    41,     5,     0,     0,    10,     0,    11,
     0,    12,     0,     9,     0,     0,     6,    47,     7,     0,
     0,     6,    35,     4,    25,    43,     5,     7,     0,     0,
     6,    34,     4,     4,    35,     4,    25,    44,     5,     5,
     5,     7,     0,     0,     6,    34,     4,     4,    34,    35,
     4,    25,    45,     5,     5,     5,     7,     0,     0,     6,
    34,    35,     4,    25,    46,     5,     7,     0,     0,    17,
     0,    48,     0,    47,    29,    47,     0,    47,    32,    47,
     0,    34,    47,     0,     4,    47,     5,     0,    18,     0,
     0,    25,    49,    50,     0,     0,    51,    26,     0,    52,
     3,     0,    21,     0,    22,     0,    23,     0,    24,     0,
    20,     0,    19,     0,    21,     0,    22,     0,     0,    31,
    25,     0
};

#endif

#if YYDEBUG != 0
static const short yyrline[] = { 0,
    79,    82,    88,    89,    90,   100,   111,   112,   113,   114,
   115,   120,   121,   122,   126,   127,   131,   132,   136,   137,
   141,   145,   145,   146,   147,   148,   149,   150,   156,   157,
   163,   182,   183,   189,   197,   198,   199,   200,   201,   202,
   207,   208,   212,   216
};
#endif


#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)

static const char * const yytname[] = {   "$","error","$undefined.","QUOTE",
"OPEN","CLOSE","OPENB","CLOSEB","NL","DAYS","HOURS","MINUTES","SECONDS","TIME",
"COLON","WHENTOKEN","AFTERTOKEN","ELSE","TRUE","LEQ","GEQ","EQ","NEQ","GT","LT",
"IDENTIFIER","INTEGER","MINUS","PLUS","OR","TIMES","DIV","AND","NEG","NOT","IN",
"'^'","input","line","event","time","type","guard","@1","@2","@3","@4","pexp",
"atomic","@5","isexp","irel","srel","action", NULL
};
#endif

static const short yyr1[] = {     0,
    37,    38,    39,    39,    39,    40,    41,    41,    41,    41,
    41,    42,    42,    43,    42,    44,    42,    45,    42,    46,
    42,    47,    47,    47,    47,    47,    47,    47,    48,    49,
    48,    50,    50,    50,    51,    51,    51,    51,    51,    51,
    52,    52,    53,    53
};

static const short yyr2[] = {     0,
     1,     3,     0,     1,     1,     5,     0,     1,     1,     1,
     1,     0,     3,     0,     7,     0,    12,     0,    13,     0,
     8,     0,     1,     1,     3,     3,     2,     3,     1,     0,
     3,     0,     2,     2,     1,     1,     1,     1,     1,     1,
     1,     1,     0,     2
};

static const short yydefact[] = {     3,
     0,     5,     1,    12,     4,     0,    22,    43,     7,    22,
    23,    29,    30,    22,     0,     0,    24,     0,     2,    11,
     8,     9,    10,     0,    22,     0,    32,    22,     0,    27,
     0,    13,    22,    22,    44,     6,    28,    40,    39,    35,
    36,    37,    38,    31,     0,     0,    22,     0,    14,    25,
    26,    33,    34,    22,     0,    20,     0,     0,     0,     0,
     0,     0,    16,     0,    15,    18,     0,    21,     0,     0,
     0,     0,     0,     0,     0,    17,    19,     0,     0,     0
};

static const short yydefgoto[] = {    78,
     3,     4,     5,    24,     8,    57,    67,    69,    60,    26,
    17,    27,    44,    45,    46,    19
};

static const short yypact[] = {   -14,
     0,-32768,-32768,     2,-32768,   -21,    -3,   -25,    70,    24,
-32768,-32768,-32768,    -1,     5,    28,-32768,   -15,-32768,-32768,
-32768,-32768,-32768,     7,    24,    35,    51,    44,     9,-32768,
    -6,-32768,    24,    24,-32768,-32768,-32768,-32768,-32768,    17,
    18,-32768,-32768,-32768,     3,    27,    19,    20,-32768,    11,
-32768,-32768,-32768,    21,    46,-32768,    47,    55,    26,    58,
    59,    40,-32768,    61,-32768,-32768,    71,-32768,    72,    78,
    79,    80,    81,    82,    83,-32768,-32768,    87,    88,-32768
};

static const short yypgoto[] = {-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    -7,
-32768,-32768,-32768,-32768,-32768,-32768
};


#define	YYLAST		90


static const short yytable[] = {    16,
    10,     1,    28,     6,     9,    18,    30,     7,    31,    35,
     2,    36,    48,    11,    12,    11,    12,    30,    49,   -41,
   -42,    13,    10,    13,    10,    50,    51,    10,    52,    53,
    14,    15,    25,    29,    32,    11,    12,    11,    12,    37,
    11,    12,    34,    13,    56,    13,    30,    47,    13,    59,
    63,    61,    54,    55,    25,    58,    33,    25,    62,    34,
    11,    12,    64,    33,    66,    65,    34,    68,    13,    38,
    39,    40,    41,    42,    43,    70,    71,    25,    20,    21,
    22,    23,    72,    73,    74,    75,    79,    80,    76,    77
};

static const short yycheck[] = {     7,
     4,    16,     4,     4,    26,    31,    14,     6,     4,    25,
    25,     5,     4,    17,    18,    17,    18,    25,    25,     3,
     3,    25,     4,    25,     4,    33,    34,     4,    26,     3,
    34,    35,    34,    35,     7,    17,    18,    17,    18,     5,
    17,    18,    32,    25,    25,    25,    54,     4,    25,     4,
    25,     5,    34,    35,    34,    35,    29,    34,     4,    32,
    17,    18,     5,    29,    25,     7,    32,     7,    25,    19,
    20,    21,    22,    23,    24,     5,     5,    34,     9,    10,
    11,    12,     5,     5,     5,     5,     0,     0,     7,     7
};
/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
#line 3 "/usr/lib/bison.simple"
/* This file comes from bison-1.28.  */

/* Skeleton output parser for bison,
   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.

   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 2, 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/* As a special exception, when this file is copied by Bison into a
   Bison output file, you may use that output file without restriction.
   This special exception was added by the Free Software Foundation
   in version 1.24 of Bison.  */

/* This is the parser code that is written into each bison parser
  when the %semantic_parser declaration is not specified in the grammar.
  It was written by Richard Stallman by simplifying the hairy parser
  used when %semantic_parser is specified.  */

#ifndef YYSTACK_USE_ALLOCA
#ifdef alloca
#define YYSTACK_USE_ALLOCA
#else /* alloca not defined */
#ifdef __GNUC__
#define YYSTACK_USE_ALLOCA
#define alloca __builtin_alloca
#else /* not GNU C.  */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
#define YYSTACK_USE_ALLOCA
#include <alloca.h>
#else /* not sparc */
/* We think this test detects Watcom and Microsoft C.  */
/* This used to test MSDOS, but that is a bad idea
   since that symbol is in the user namespace.  */
#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
#if 0 /* No need for malloc.h, which pollutes the namespace;
	 instead, just don't use alloca.  */
#include <malloc.h>
#endif
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
/* I don't know what this was needed for, but it pollutes the namespace.
   So I turned it off.   rms, 2 May 1997.  */
/* #include <malloc.h>  */
 #pragma alloca
#define YYSTACK_USE_ALLOCA
#else /* not MSDOS, or __TURBOC__, or _AIX */
#if 0
#ifdef __hpux /* [e-mail] says this works for HPUX 9.05 and up,
		 and on HPUX 10.  Eventually we can turn this on.  */
#define YYSTACK_USE_ALLOCA
#define alloca __builtin_alloca
#endif /* __hpux */
#endif
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc */
#endif /* not GNU C */
#endif /* alloca not defined */
#endif /* YYSTACK_USE_ALLOCA not defined */

#ifdef YYSTACK_USE_ALLOCA
#define YYSTACK_ALLOC alloca
#else
#define YYSTACK_ALLOC malloc
#endif

/* Note: there must be only one dollar sign in this file.
   It is replaced by the list of actions, each action
   as one case of the switch.  */

#define yyerrok		(yyerrstatus = 0)
#define yyclearin	(yychar = YYEMPTY)
#define YYEMPTY		-2
#define YYEOF		0
#define YYACCEPT	goto yyacceptlab
#define YYABORT 	goto yyabortlab
#define YYERROR		goto yyerrlab1
/* Like YYERROR except do call yyerror.
   This remains here temporarily to ease the
   transition to the new meaning of YYERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */
#define YYFAIL		goto yyerrlab
#define YYRECOVERING()  (!!yyerrstatus)
#define YYBACKUP(token, value) \
do								\
  if (yychar == YYEMPTY && yylen == 1)				\
    { yychar = (token), yylval = (value);			\
      yychar1 = YYTRANSLATE (yychar);				\
      YYPOPSTACK;						\
      goto yybackup;						\
    }								\
  else								\
    { yyerror ("syntax error: cannot back up"); YYERROR; }	\
while (0)

#define YYTERROR	1
#define YYERRCODE	256

#ifndef YYPURE
#define YYLEX		yylex()
#endif

#ifdef YYPURE
#ifdef YYLSP_NEEDED
#ifdef YYLEX_PARAM
#define YYLEX		yylex(&yylval, &yylloc, YYLEX_PARAM)
#else
#define YYLEX		yylex(&yylval, &yylloc)
#endif