From db5ddc0e4cf902c395151fb3d69445af977851c8 Mon Sep 17 00:00:00 2001
From: hm19 <hm19@inf.ufpr.br>
Date: Tue, 3 Dec 2024 14:58:26 -0300
Subject: [PATCH] retira procedimentos e funcoes da ts
---
compilador | Bin 0 -> 54640 bytes
compilador.o | Bin 0 -> 2736 bytes
compilador.tab.c | 2427 ++++++++++++++++++++++++++++++++++++++++++++++
compilador.tab.h | 107 ++
compilador.y | 6 +-
lex.yy.c | 2196 +++++++++++++++++++++++++++++++++++++++++
stack/stack.o | Bin 0 -> 3200 bytes
ts/ts.c | 68 ++
ts/ts.h | 4 +
ts/ts.o | Bin 0 -> 11840 bytes
10 files changed, 4806 insertions(+), 2 deletions(-)
create mode 100755 compilador
create mode 100644 compilador.o
create mode 100644 compilador.tab.c
create mode 100644 compilador.tab.h
create mode 100644 lex.yy.c
create mode 100644 stack/stack.o
create mode 100644 ts/ts.o
diff --git a/compilador b/compilador
new file mode 100755
index 0000000000000000000000000000000000000000..ea2bab45adb9f6e6ebb169ff830776d45c59415a
GIT binary patch
literal 54640
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
literal 0
HcmV?d00001
diff --git a/compilador.o b/compilador.o
new file mode 100644
index 0000000000000000000000000000000000000000..5d54ba2ec447c88f824aa9d112807c77cff6b70d
GIT binary patch
literal 2736
zcmb<-^>JfjWMqH=Mg}_u1P><4z+k|RU^{@B4h(z@ybPcD<$i^FbUyWHek0(~S^LAI
zv-E>UH!DbmN9%!7DUV)LFuT_lM7;nJ9-R>B=Gq?&r3Ns?-Ju^~YCDhb0I7p0hMLuR
z9L#-f1Xu6-!J|9$2N8NEoIH%~%5G7R1qh?C8ngfZ|NsBNwlXj<lr#9c1~@V(fPiW-
z7lUfCm4a%q0vCg8QBl4^UZO%yW?n|3f@+F_t^!D&!QI)}N<kwusWh*oRKZfuM9)Ci
zuoTQQtTQsuGceIJ(u9bEoWj7uz`!8Dz`y_s8h5`?1||lE10XSGuq*?E2$W{53SwZa
z5MY$%Vdt2@$iN`O0Kp*XWgx<pPoRy-nU{@eE)P2gM9u~z&cMK6529i6AT}NhN&_qm
zAOB-h!i+VAFfcGPz+8)}iy7=YR51{b8SGmS3l%dnASE^=DP{%^Bp!mv%)p7@AhDPk
z*pPS-CO-oMgCN7F|Ddo1iNI)a9OCj&aZucV)Wc|1usBRN1KedA3=9lHNZ|vH69xtb
zV`%(>%s|GTIK=&Nh==14kAvC^vkx5C3=9leIMnCj5HG<Y&XAm+TacNPn37-QrkBi6
zoSB=HpOeo}l$w*6oS4s0lAoQL$B<UQke*tU=$xODnV!!O@9yL8<meOc@8%Zl8WJDk
z=;Y%X&ybd109IL)nOBm=kd~HHTAaa<nOjhlnVSmAOAL8A48<iWsYOK$sTG+Z=YWF?
z6h9ya69WSSF9QR^A5iA}|Np--NRWX6lwZK92_~+ECjJkqULPtBiaAhR!ql5V#nH`o
z!66QcACMGCJt)t@Qhp3bkbwc5;suf1nG6*NsYiByHdGws9w8+4Fps0FZ-%M|iG%Fr
zf$}FnX^=U{_D+Y2gVZD2J0B_zQjcsexa5U~C#cMUh0lJddXPDw!V@Nb3P~K~9*`VJ
z=sJkN5)KcM#Kn;Os{j=TnGeEHE(4^lfy6IJ9G1Qr^olEUOA?b9^omQ0Aan+d1xl29
zC8-r940<VvC5a4rNyWtsdPVsVPI7*3Zfaf$gI->KNvfW^U#M<zNn&y~l%Jkgs#j2y
zUyxc<QpunPHYqhDKCLJ*Hx=e2ifE8OL1im?$prJ~Q#8{-YLSJcp<xPB50hH~ibw_q
zh6hj$+zbrhQV3RJN<bB=LB(O|6)Mc23e^YW!)SD29R^5Qhpt}(st{%$Og}o`5Nbat
zE@5gwG)%t%h=YWo#==D`q59F)ML-pT+y_?-RSV)nr5T)%#6aRO+yYYo6M)j_!a)oS
z;Mxh@{T)z+p!kJq1ykt$2bISlrRe%sfCL#B7$U&B5Cpn@P$~pPHG2GaKob-!TtM*;
zsuf}SVet>L2HkG3ZBRiCC=DuCxS(+jl85OBnTa0vAbAatqZk+%DnT4146+Z2%K$2y
Ru<73cbw8}!gXuxn4**=#WG?^!
literal 0
HcmV?d00001
diff --git a/compilador.tab.c b/compilador.tab.c
new file mode 100644
index 0000000..fe1feac
--- /dev/null
+++ b/compilador.tab.c
@@ -0,0 +1,2427 @@
+/* A Bison parser, made by GNU Bison 3.5.1. */
+
+/* Bison implementation for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 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 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 <http://www.gnu.org/licenses/>. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+ simplifying the original so-called "semantic" parser. */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+ infringing on user name space. This should be done even for local
+ variables, as they might otherwise be expanded by user macros.
+ There are some unavoidable exceptions within include files to
+ define necessary library symbols; they are noted "INFRINGES ON
+ USER NAME SPACE" below. */
+
+/* Undocumented macros, especially those whose name start with YY_,
+ are private implementation details. Do not rely on them. */
+
+/* Identify Bison output. */
+#define YYBISON 1
+
+/* Bison version. */
+#define YYBISON_VERSION "3.5.1"
+
+/* Skeleton name. */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers. */
+#define YYPURE 0
+
+/* Push parsers. */
+#define YYPUSH 0
+
+/* Pull parsers. */
+#define YYPULL 1
+
+
+
+
+/* First part of user prologue. */
+#line 6 "compilador.y"
+
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include "compilador.h"
+#include "ts/ts.h"
+#include "stack/stack.h"
+
+int num_vars;
+int num_param;
+ts_t *ts;
+int nivel_lexico;
+int desloc;
+int destino_nivel;
+int destino_desloc;
+simb_t *l_elem;
+int rot_id;
+custom_stack_t *rot;
+custom_stack_t *proc;
+
+int val_ou_ref;
+int atr_indireto;
+
+
+#line 96 "compilador.tab.c"
+
+# ifndef YY_CAST
+# ifdef __cplusplus
+# define YY_CAST(Type, Val) static_cast<Type> (Val)
+# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
+# else
+# define YY_CAST(Type, Val) ((Type) (Val))
+# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
+# endif
+# endif
+# ifndef YY_NULLPTR
+# if defined __cplusplus
+# if 201103L <= __cplusplus
+# define YY_NULLPTR nullptr
+# else
+# define YY_NULLPTR 0
+# endif
+# else
+# define YY_NULLPTR ((void*)0)
+# endif
+# endif
+
+/* Enabling verbose error messages. */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Use api.header.include to #include this header
+ instead of duplicating it here. */
+#ifndef YY_YY_COMPILADOR_TAB_H_INCLUDED
+# define YY_YY_COMPILADOR_TAB_H_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token type. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ PROGRAM = 258,
+ ABRE_PARENTESES = 259,
+ FECHA_PARENTESES = 260,
+ VIRGULA = 261,
+ PONTO_E_VIRGULA = 262,
+ DOIS_PONTOS = 263,
+ PONTO = 264,
+ T_BEGIN = 265,
+ T_END = 266,
+ VAR = 267,
+ IDENT = 268,
+ ATRIBUICAO = 269,
+ LABEL = 270,
+ TYPE = 271,
+ ARRAY = 272,
+ PROCEDURE = 273,
+ FUNCTION = 274,
+ GOTO = 275,
+ IF = 276,
+ THEN = 277,
+ ELSE = 278,
+ WHILE = 279,
+ DO = 280,
+ OR = 281,
+ DIV = 282,
+ AND = 283,
+ NOT = 284,
+ IGUAL = 285,
+ DIFERENTE = 286,
+ MENOR_IGUAL = 287,
+ MAIOR_IGUAL = 288,
+ MENOR = 289,
+ MAIOR = 290,
+ MAIS = 291,
+ MENOS = 292,
+ ASTERISCO = 293,
+ NUMERO = 294,
+ READ = 295,
+ WRITE = 296,
+ LOWER_THAN_ELSE = 297
+ };
+#endif
+
+/* Value type. */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef int YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+extern YYSTYPE yylval;
+
+int yyparse (void);
+
+#endif /* !YY_YY_COMPILADOR_TAB_H_INCLUDED */
+
+
+
+#ifdef short
+# undef short
+#endif
+
+/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
+ <limits.h> and (if available) <stdint.h> are included
+ so that the code can choose integer types of a good width. */
+
+#ifndef __PTRDIFF_MAX__
+# include <limits.h> /* INFRINGES ON USER NAME SPACE */
+# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
+# define YY_STDINT_H
+# endif
+#endif
+
+/* Narrow types that promote to a signed type and that can represent a
+ signed or unsigned integer of at least N bits. In tables they can
+ save space and decrease cache pressure. Promoting to a signed type
+ helps avoid bugs in integer arithmetic. */
+
+#ifdef __INT_LEAST8_MAX__
+typedef __INT_LEAST8_TYPE__ yytype_int8;
+#elif defined YY_STDINT_H
+typedef int_least8_t yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef __INT_LEAST16_MAX__
+typedef __INT_LEAST16_TYPE__ yytype_int16;
+#elif defined YY_STDINT_H
+typedef int_least16_t yytype_int16;
+#else
+typedef short yytype_int16;
+#endif
+
+#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST8_TYPE__ yytype_uint8;
+#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
+ && UINT_LEAST8_MAX <= INT_MAX)
+typedef uint_least8_t yytype_uint8;
+#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
+typedef unsigned char yytype_uint8;
+#else
+typedef short yytype_uint8;
+#endif
+
+#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST16_TYPE__ yytype_uint16;
+#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
+ && UINT_LEAST16_MAX <= INT_MAX)
+typedef uint_least16_t yytype_uint16;
+#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
+typedef unsigned short yytype_uint16;
+#else
+typedef int yytype_uint16;
+#endif
+
+#ifndef YYPTRDIFF_T
+# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
+# define YYPTRDIFF_T __PTRDIFF_TYPE__
+# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
+# elif defined PTRDIFF_MAX
+# ifndef ptrdiff_t
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# endif
+# define YYPTRDIFF_T ptrdiff_t
+# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
+# else
+# define YYPTRDIFF_T long
+# define YYPTRDIFF_MAXIMUM LONG_MAX
+# endif
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+# define YYSIZE_T size_t
+# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# else
+# define YYSIZE_T unsigned
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM \
+ YY_CAST (YYPTRDIFF_T, \
+ (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
+ ? YYPTRDIFF_MAXIMUM \
+ : YY_CAST (YYSIZE_T, -1)))
+
+#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
+
+/* Stored state numbers (used for stacks). */
+typedef yytype_uint8 yy_state_t;
+
+/* State numbers in computations. */
+typedef int yy_state_fast_t;
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+# if ENABLE_NLS
+# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+# endif
+# endif
+# ifndef YY_
+# define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
+# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
+# else
+# define YY_ATTRIBUTE_PURE
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
+# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+# else
+# define YY_ATTRIBUTE_UNUSED
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E. */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized. */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
+ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+ _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
+# define YY_IGNORE_USELESS_CAST_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
+# define YY_IGNORE_USELESS_CAST_END \
+ _Pragma ("GCC diagnostic pop")
+#endif
+#ifndef YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_END
+#endif
+
+
+#define YY_ASSERT(E) ((void) (0 && (E)))
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# ifdef YYSTACK_USE_ALLOCA
+# if YYSTACK_USE_ALLOCA
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# elif defined __BUILTIN_VA_ARG_INCR
+# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+# elif defined _AIX
+# define YYSTACK_ALLOC __alloca
+# elif defined _MSC_VER
+# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+# define alloca _alloca
+# else
+# define YYSTACK_ALLOC alloca
+# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+ /* Use EXIT_SUCCESS as a witness for stdlib.h. */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's 'empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# ifndef YYSTACK_ALLOC_MAXIMUM
+ /* The OS might guarantee only one guard page at the bottom of the stack,
+ and a page size can be as small as 4096 bytes. So we cannot safely
+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
+ to allow for a few compiler-allocated temporary stack slots. */
+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+# endif
+# else
+# define YYSTACK_ALLOC YYMALLOC
+# define YYSTACK_FREE YYFREE
+# ifndef YYSTACK_ALLOC_MAXIMUM
+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+# endif
+# if (defined __cplusplus && ! defined EXIT_SUCCESS \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# ifndef YYMALLOC
+# define YYMALLOC malloc
+# if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# ifndef YYFREE
+# define YYFREE free
+# if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+ && (! defined __cplusplus \
+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ yy_state_t yyss_alloc;
+ YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# define YYSTACK_BYTES(N) \
+ ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
+ + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
+ do \
+ { \
+ YYPTRDIFF_T yynewbytes; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
+ yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
+ yyptr += yynewbytes / YYSIZEOF (*yyptr); \
+ } \
+ while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if defined __GNUC__ && 1 < __GNUC__
+# define YYCOPY(Dst, Src, Count) \
+ __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
+# else
+# define YYCOPY(Dst, Src, Count) \
+ do \
+ { \
+ YYPTRDIFF_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (Dst)[yyi] = (Src)[yyi]; \
+ } \
+ while (0)
+# endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL 3
+/* YYLAST -- Last index in YYTABLE. */
+#define YYLAST 128
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS 43
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS 67
+/* YYNRULES -- Number of rules. */
+#define YYNRULES 103
+/* YYNSTATES -- Number of states. */
+#define YYNSTATES 173
+
+#define YYUNDEFTOK 2
+#define YYMAXUTOK 297
+
+
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex, with out-of-bounds checking. */
+#define YYTRANSLATE(YYX) \
+ (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex. */
+static const yytype_int8 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, 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, 2, 1, 2, 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, 36, 37, 38, 39, 40, 41, 42
+};
+
+#if YYDEBUG
+ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
+static const yytype_int16 yyrline[] =
+{
+ 0, 47, 47, 47, 63, 74, 60, 93, 94, 97,
+ 101, 101, 102, 105, 106, 110, 113, 110, 121, 134,
+ 143, 154, 155, 159, 161, 162, 167, 191, 167, 210,
+ 234, 238, 210, 246, 247, 245, 255, 258, 259, 263,
+ 262, 272, 272, 280, 281, 284, 294, 297, 298, 299,
+ 302, 303, 306, 307, 308, 309, 310, 311, 314, 314,
+ 318, 319, 322, 322, 345, 345, 388, 391, 395, 394,
+ 407, 407, 421, 424, 425, 428, 437, 440, 443, 448,
+ 451, 454, 457, 460, 463, 466, 469, 475, 481, 484,
+ 487, 490, 493, 493, 524, 535, 537, 544, 537, 570,
+ 577, 579, 582, 582
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 0
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+static const char *const yytname[] =
+{
+ "$end", "error", "$undefined", "PROGRAM", "ABRE_PARENTESES",
+ "FECHA_PARENTESES", "VIRGULA", "PONTO_E_VIRGULA", "DOIS_PONTOS", "PONTO",
+ "T_BEGIN", "T_END", "VAR", "IDENT", "ATRIBUICAO", "LABEL", "TYPE",
+ "ARRAY", "PROCEDURE", "FUNCTION", "GOTO", "IF", "THEN", "ELSE", "WHILE",
+ "DO", "OR", "DIV", "AND", "NOT", "IGUAL", "DIFERENTE", "MENOR_IGUAL",
+ "MAIOR_IGUAL", "MENOR", "MAIOR", "MAIS", "MENOS", "ASTERISCO", "NUMERO",
+ "READ", "WRITE", "LOWER_THAN_ELSE", "$accept", "programa", "$@1",
+ "bloco", "$@2", "$@3", "parte_declara_rotulos", "parte_declara_vars",
+ "var", "$@4", "declara_vars", "declara_var", "$@5", "$@6", "tipo",
+ "lista_id_var", "lista_idents", "parte_declara_subrotinas",
+ "declaracao_procedimento", "$@7", "$@8", "declaracao_funcao", "$@9",
+ "$@10", "$@11", "parametros_ou_nada", "$@12", "$@13",
+ "paramentros_formais", "secao_pfs", "$@14", "$@15", "lista_id_pf",
+ "parametro", "comando_composto", "comandos", "comando",
+ "comando_sem_rotulo", "atribuicao_ou_procedimento", "$@16",
+ "atribuicao_ou_procedimento_token", "atribuicao", "$@17",
+ "chamada_procedimento", "$@18", "lista_parametros",
+ "lista_parametros_parenteses", "$@19", "$@20", "leitura",
+ "lista_leituras", "simb_leitura", "escrita", "lista_escritas",
+ "expressao", "expressao_simples", "termo", "fator", "$@21", "numero",
+ "comando_repetitivo", "$@22", "$@23", "comando_condicional", "cond_else",
+ "if_then", "$@24", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+ (internal) symbol number NUM (which must be that of a token). */
+static const yytype_int16 yytoknum[] =
+{
+ 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
+ 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
+ 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
+ 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
+ 295, 296, 297
+};
+# endif
+
+#define YYPACT_NINF (-113)
+
+#define yypact_value_is_default(Yyn) \
+ ((Yyn) == YYPACT_NINF)
+
+#define YYTABLE_NINF (-97)
+
+#define yytable_value_is_error(Yyn) \
+ 0
+
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+ STATE-NUM. */
+static const yytype_int8 yypact[] =
+{
+ -113, 10, 11, -113, 4, 24, 43, -113, 7, 52,
+ 45, 46, -113, 54, 55, 56, -113, -113, -113, -113,
+ 57, 44, -113, 53, 59, -113, 58, -113, 61, -113,
+ 62, 60, -113, -113, -113, 1, 68, -113, 5, -113,
+ 66, 74, -113, 80, 68, -113, -7, -113, 85, 86,
+ -113, 81, 84, -113, -113, -113, -113, 87, -113, 69,
+ -113, 73, -113, -113, -113, 88, -113, 90, 89, -113,
+ -113, 20, -6, -11, -113, 91, -7, -113, 5, -2,
+ -7, -2, -113, 92, -113, 94, -113, 93, 74, 46,
+ -113, -113, 95, -113, 98, -113, -7, -7, -7, -7,
+ -7, -7, 76, -7, -7, -7, -7, -113, 28, -113,
+ 30, -6, -113, -113, 51, -113, -113, 93, 88, 100,
+ -113, 99, 102, 103, -113, -7, -113, -113, -113, -6,
+ -6, -6, -6, -6, -6, -2, -11, -11, -113, -113,
+ -113, 91, -113, -7, -113, 104, -113, -113, 74, 93,
+ 46, 106, -6, 35, -7, -113, -113, -6, -2, 74,
+ -113, -113, -113, -113, -113, -113, -6, -113, -113, 107,
+ -7, -113, -6
+};
+
+ /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+ Performed when YYTABLE does not specify something else to do. Zero
+ means the default is an error. */
+static const yytype_int8 yydefact[] =
+{
+ 2, 0, 0, 1, 0, 0, 0, 22, 0, 0,
+ 0, 8, 21, 0, 0, 12, 7, 3, 4, 9,
+ 0, 25, 15, 0, 5, 24, 11, 14, 0, 29,
+ 0, 0, 23, 13, 20, 0, 36, 26, 49, 6,
+ 0, 0, 33, 0, 36, 58, 0, 95, 0, 0,
+ 53, 0, 0, 51, 52, 56, 57, 0, 55, 0,
+ 54, 101, 19, 18, 16, 41, 30, 0, 64, 92,
+ 94, 102, 85, 88, 91, 0, 0, 46, 48, 96,
+ 0, 96, 99, 0, 39, 34, 37, 0, 0, 8,
+ 59, 60, 0, 61, 67, 64, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 75, 0, 74,
+ 0, 78, 47, 50, 0, 100, 17, 0, 41, 0,
+ 45, 0, 44, 0, 27, 0, 70, 65, 93, 79,
+ 80, 82, 84, 81, 83, 96, 86, 87, 90, 89,
+ 72, 0, 76, 0, 97, 0, 38, 35, 0, 0,
+ 8, 0, 63, 0, 0, 103, 73, 77, 96, 0,
+ 42, 43, 31, 28, 66, 68, 71, 98, 40, 0,
+ 0, 32, 69
+};
+
+ /* YYPGOTO[NTERM-NUM]. */
+static const yytype_int8 yypgoto[] =
+{
+ -113, -113, -113, -85, -113, -113, -113, -113, -113, -113,
+ -113, 96, -113, -113, -86, -113, -113, -113, -113, -113,
+ -113, -113, -113, -113, -113, 67, -113, -113, -113, -3,
+ -113, -113, -112, -113, 97, 38, -113, -78, -113, -113,
+ -113, -113, -113, 22, -113, -113, -113, -113, -113, -113,
+ -113, -23, -113, -113, 39, -76, -61, -58, -113, -113,
+ -113, -113, -113, -113, -113, -113, -113
+};
+
+ /* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int16 yydefgoto[] =
+{
+ -1, 1, 2, 14, 21, 31, 15, 18, 19, 20,
+ 26, 27, 28, 83, 64, 35, 8, 24, 32, 44,
+ 151, 25, 36, 88, 169, 43, 65, 119, 85, 86,
+ 117, 87, 121, 122, 50, 51, 52, 53, 54, 68,
+ 90, 91, 92, 93, 94, 127, 153, 170, 154, 55,
+ 108, 109, 56, 110, 71, 72, 73, 74, 95, 57,
+ 58, 59, 158, 60, 82, 61, 102
+};
+
+ /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
+ positive, shift that token. If negative, reduce the rule whose
+ number is the opposite. If YYTABLE_NINF, syntax error. */
+static const yytype_int16 yytable[] =
+{
+ 111, 113, 123, 115, 124, 145, 69, 40, 38, 41,
+ 3, 45, 9, 10, 4, 38, 105, 5, 45, 46,
+ 129, 130, 131, 132, 133, 134, 46, 106, 6, -96,
+ 103, 104, 70, 140, 141, 142, 143, 161, 48, 49,
+ 164, 165, 136, 137, 47, 48, 49, 138, 139, 152,
+ 96, 97, 98, 99, 100, 101, 7, 155, 12, 11,
+ 16, 13, 160, 23, 17, 162, 29, 157, -10, 22,
+ 38, -15, 42, 168, 34, 37, 144, 30, 166, 62,
+ 167, 96, 97, 98, 99, 100, 101, 63, 66, 75,
+ 76, 78, 77, 80, 172, 79, 81, 89, 135, 116,
+ 84, 118, 126, -62, 107, 147, 120, 148, 149, 125,
+ 150, 67, 159, 163, 171, 146, 112, 128, 156, 114,
+ 0, 0, 33, 0, 0, 0, 0, 0, 39
+};
+
+static const yytype_int16 yycheck[] =
+{
+ 76, 79, 88, 81, 89, 117, 13, 6, 10, 8,
+ 0, 13, 5, 6, 3, 10, 27, 13, 13, 21,
+ 96, 97, 98, 99, 100, 101, 21, 38, 4, 24,
+ 36, 37, 39, 5, 6, 5, 6, 149, 40, 41,
+ 5, 6, 103, 104, 39, 40, 41, 105, 106, 125,
+ 30, 31, 32, 33, 34, 35, 13, 135, 13, 7,
+ 6, 15, 148, 19, 9, 150, 13, 143, 12, 12,
+ 10, 13, 4, 159, 13, 13, 25, 18, 154, 13,
+ 158, 30, 31, 32, 33, 34, 35, 13, 8, 4,
+ 4, 7, 11, 24, 170, 8, 23, 7, 22, 7,
+ 12, 7, 4, 14, 13, 5, 13, 8, 6, 14,
+ 7, 44, 8, 7, 7, 118, 78, 95, 141, 80,
+ -1, -1, 26, -1, -1, -1, -1, -1, 31
+};
+
+ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
+static const yytype_int8 yystos[] =
+{
+ 0, 44, 45, 0, 3, 13, 4, 13, 59, 5,
+ 6, 7, 13, 15, 46, 49, 6, 9, 50, 51,
+ 52, 47, 12, 19, 60, 64, 53, 54, 55, 13,
+ 18, 48, 61, 54, 13, 58, 65, 13, 10, 77,
+ 6, 8, 4, 68, 62, 13, 21, 39, 40, 41,
+ 77, 78, 79, 80, 81, 92, 95, 102, 103, 104,
+ 106, 108, 13, 13, 57, 69, 8, 68, 82, 13,
+ 39, 97, 98, 99, 100, 4, 4, 11, 7, 8,
+ 24, 23, 107, 56, 12, 71, 72, 74, 66, 7,
+ 83, 84, 85, 86, 87, 101, 30, 31, 32, 33,
+ 34, 35, 109, 36, 37, 27, 38, 13, 93, 94,
+ 96, 98, 78, 80, 97, 80, 7, 73, 7, 70,
+ 13, 75, 76, 57, 46, 14, 4, 88, 86, 98,
+ 98, 98, 98, 98, 98, 22, 99, 99, 100, 100,
+ 5, 6, 5, 6, 25, 75, 72, 5, 8, 6,
+ 7, 63, 98, 89, 91, 80, 94, 98, 105, 8,
+ 57, 75, 46, 7, 5, 6, 98, 80, 57, 67,
+ 90, 7, 98
+};
+
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const yytype_int8 yyr1[] =
+{
+ 0, 43, 45, 44, 47, 48, 46, 49, 49, 50,
+ 52, 51, 51, 53, 53, 55, 56, 54, 57, 58,
+ 58, 59, 59, 60, 60, 60, 62, 63, 61, 65,
+ 66, 67, 64, 69, 70, 68, 68, 71, 71, 73,
+ 72, 74, 72, 75, 75, 76, 77, 78, 78, 78,
+ 79, 79, 80, 80, 80, 80, 80, 80, 82, 81,
+ 83, 83, 85, 84, 87, 86, 88, 88, 90, 89,
+ 91, 89, 92, 93, 93, 94, 95, 96, 96, 97,
+ 97, 97, 97, 97, 97, 97, 98, 98, 98, 99,
+ 99, 99, 101, 100, 100, 102, 104, 105, 103, 106,
+ 107, 107, 109, 108
+};
+
+ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
+static const yytype_int8 yyr2[] =
+{
+ 0, 2, 0, 9, 0, 0, 6, 2, 0, 1,
+ 0, 3, 0, 2, 1, 0, 0, 6, 1, 3,
+ 1, 3, 1, 2, 1, 0, 0, 0, 8, 0,
+ 0, 0, 11, 0, 0, 5, 0, 1, 3, 0,
+ 5, 0, 4, 3, 1, 1, 3, 3, 2, 0,
+ 3, 1, 1, 1, 1, 1, 1, 1, 0, 3,
+ 1, 1, 0, 3, 0, 2, 3, 0, 0, 4,
+ 0, 2, 4, 3, 1, 1, 4, 3, 1, 3,
+ 3, 3, 3, 3, 3, 1, 3, 3, 1, 3,
+ 3, 1, 0, 3, 1, 1, 0, 0, 6, 2,
+ 2, 0, 0, 5
+};
+
+
+#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 yyerrorlab
+
+
+#define YYRECOVERING() (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value) \
+ do \
+ if (yychar == YYEMPTY) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ YYPOPSTACK (yylen); \
+ yystate = *yyssp; \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror (YY_("syntax error: cannot back up")); \
+ YYERROR; \
+ } \
+ while (0)
+
+/* Error token number */
+#define YYTERROR 1
+#define YYERRCODE 256
+
+
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Type, Value); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (0)
+
+
+/*-----------------------------------.
+| Print this symbol's value on YYO. |
+`-----------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
+{
+ FILE *yyoutput = yyo;
+ YYUSE (yyoutput);
+ if (!yyvaluep)
+ return;
+# ifdef YYPRINT
+ if (yytype < YYNTOKENS)
+ YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
+# endif
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ YYUSE (yytype);
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+/*---------------------------.
+| Print this symbol on YYO. |
+`---------------------------*/
+
+static void
+yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
+{
+ YYFPRINTF (yyo, "%s %s (",
+ yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+ yy_symbol_value_print (yyo, yytype, yyvaluep);
+ YYFPRINTF (yyo, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included). |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
+{
+ YYFPRINTF (stderr, "Stack now");
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
+ YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top) \
+do { \
+ if (yydebug) \
+ yy_stack_print ((Bottom), (Top)); \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced. |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
+{
+ int yylno = yyrline[yyrule];
+ int yynrhs = yyr2[yyrule];
+ int yyi;
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
+ yyrule - 1, yylno);
+ /* The symbols being reduced. */
+ for (yyi = 0; yyi < yynrhs; yyi++)
+ {
+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
+ yy_symbol_print (stderr,
+ yystos[+yyssp[yyi + 1 - yynrhs]],
+ &yyvsp[(yyi + 1) - (yynrhs)]
+ );
+ YYFPRINTF (stderr, "\n");
+ }
+}
+
+# define YY_REDUCE_PRINT(Rule) \
+do { \
+ if (yydebug) \
+ yy_reduce_print (yyssp, yyvsp, Rule); \
+} while (0)
+
+/* Nonzero means print parse trace. It is left uninitialized so that
+ multiple parsers can coexist. */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks. */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+ if the built-in stack extension method is used).
+
+ Do not make this value too large; the results are undefined if
+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+# if defined __GLIBC__ && defined _STRING_H
+# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
+# else
+/* Return the length of YYSTR. */
+static YYPTRDIFF_T
+yystrlen (const char *yystr)
+{
+ YYPTRDIFF_T yylen;
+ for (yylen = 0; yystr[yylen]; yylen++)
+ continue;
+ return yylen;
+}
+# endif
+# endif
+
+# ifndef yystpcpy
+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+# define yystpcpy stpcpy
+# else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+ YYDEST. */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+ char *yyd = yydest;
+ const char *yys = yysrc;
+
+ while ((*yyd++ = *yys++) != '\0')
+ continue;
+
+ return yyd - 1;
+}
+# endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+ quotes and backslashes, so that it's suitable for yyerror. The
+ heuristic is that double-quoting is unnecessary unless the string
+ contains an apostrophe, a comma, or backslash (other than
+ backslash-backslash). YYSTR is taken from yytname. If YYRES is
+ null, do not copy; instead, return the length of what the result
+ would have been. */
+static YYPTRDIFF_T
+yytnamerr (char *yyres, const char *yystr)
+{
+ if (*yystr == '"')
+ {
+ YYPTRDIFF_T yyn = 0;
+ char const *yyp = yystr;
+
+ for (;;)
+ switch (*++yyp)
+ {
+ case '\'':
+ case ',':
+ goto do_not_strip_quotes;
+
+ case '\\':
+ if (*++yyp != '\\')
+ goto do_not_strip_quotes;
+ else
+ goto append;
+
+ append:
+ default:
+ if (yyres)
+ yyres[yyn] = *yyp;
+ yyn++;
+ break;
+
+ case '"':
+ if (yyres)
+ yyres[yyn] = '\0';
+ return yyn;
+ }
+ do_not_strip_quotes: ;
+ }
+
+ if (yyres)
+ return yystpcpy (yyres, yystr) - yyres;
+ else
+ return yystrlen (yystr);
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+ about the unexpected token YYTOKEN for the state stack whose top is
+ YYSSP.
+
+ Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
+ not large enough to hold the message. In that case, also set
+ *YYMSG_ALLOC to the required number of bytes. Return 2 if the
+ required number of bytes is too large to store. */
+static int
+yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
+ yy_state_t *yyssp, int yytoken)
+{
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ /* Internationalized format string. */
+ const char *yyformat = YY_NULLPTR;
+ /* Arguments of yyformat: reported tokens (one for the "unexpected",
+ one per "expected"). */
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ /* Actual size of YYARG. */
+ int yycount = 0;
+ /* Cumulated lengths of YYARG. */
+ YYPTRDIFF_T yysize = 0;
+
+ /* There are many possibilities here to consider:
+ - If this state is a consistent state with a default action, then
+ the only way this function was invoked is if the default action
+ is an error action. In that case, don't check for expected
+ tokens because there are none.
+ - The only way there can be no lookahead present (in yychar) is if
+ this state is a consistent state with a default action. Thus,
+ detecting the absence of a lookahead is sufficient to determine
+ that there is no unexpected or expected token to report. In that
+ case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this state is a
+ consistent state with a default action. There might have been a
+ previous inconsistent state, consistent state with a non-default
+ action, or user semantic action that manipulated yychar.
+ - Of course, the expected token list depends on states to have
+ correct lookahead information, and it depends on the parser not
+ to perform extra reductions after fetching a lookahead from the
+ scanner and before detecting a syntax error. Thus, state merging
+ (from LALR or IELR) and default reductions corrupt the expected
+ token list. However, the list is correct for canonical LR with
+ one exception: it will still contain any token that will not be
+ accepted due to an error action in a later state.
+ */
+ if (yytoken != YYEMPTY)
+ {
+ int yyn = yypact[+*yyssp];
+ YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+ yysize = yysize0;
+ yyarg[yycount++] = yytname[yytoken];
+ if (!yypact_value_is_default (yyn))
+ {
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. In other words, skip the first -YYN actions for
+ this state because they are default actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = YYLAST - yyn + 1;
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+ int yyx;
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+ && !yytable_value_is_error (yytable[yyx + yyn]))
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ break;
+ }
+ yyarg[yycount++] = yytname[yyx];
+ {
+ YYPTRDIFF_T yysize1
+ = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+ if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+ yysize = yysize1;
+ else
+ return 2;
+ }
+ }
+ }
+ }
+
+ switch (yycount)
+ {
+# define YYCASE_(N, S) \
+ case N: \
+ yyformat = S; \
+ break
+ default: /* Avoid compiler warnings. */
+ YYCASE_(0, YY_("syntax error"));
+ YYCASE_(1, YY_("syntax error, unexpected %s"));
+ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+ }
+
+ {
+ /* Don't count the "%s"s in the final size, but reserve room for
+ the terminator. */
+ YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
+ if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+ yysize = yysize1;
+ else
+ return 2;
+ }
+
+ if (*yymsg_alloc < yysize)
+ {
+ *yymsg_alloc = 2 * yysize;
+ if (! (yysize <= *yymsg_alloc
+ && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+ *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+ return 1;
+ }
+
+ /* Avoid sprintf, as that infringes on the user's name space.
+ Don't have undefined behavior even if the translation
+ produced a string with the wrong number of "%s"s. */
+ {
+ char *yyp = *yymsg;
+ int yyi = 0;
+ while ((*yyp = *yyformat) != '\0')
+ if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+ {
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyformat += 2;
+ }
+ else
+ {
+ ++yyp;
+ ++yyformat;
+ }
+ }
+ return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol. |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
+{
+ YYUSE (yyvaluep);
+ if (!yymsg)
+ yymsg = "Deleting";
+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ YYUSE (yytype);
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/* The lookahead symbol. */
+int yychar;
+
+/* The semantic value of the lookahead symbol. */
+YYSTYPE yylval;
+/* Number of syntax errors so far. */
+int yynerrs;
+
+
+/*----------.
+| yyparse. |
+`----------*/
+
+int
+yyparse (void)
+{
+ yy_state_fast_t yystate;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+
+ /* The stacks and their tools:
+ 'yyss': related to states.
+ 'yyvs': related to semantic values.
+
+ Refer to the stacks through separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ yy_state_t yyssa[YYINITDEPTH];
+ yy_state_t *yyss;
+ yy_state_t *yyssp;
+
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs;
+ YYSTYPE *yyvsp;
+
+ YYPTRDIFF_T yystacksize;
+
+ int yyn;
+ int yyresult;
+ /* Lookahead token as an internal (translated) token number. */
+ int yytoken = 0;
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+ /* Buffer for error messages, and its allocated size. */
+ char yymsgbuf[128];
+ char *yymsg = yymsgbuf;
+ YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
+
+ /* The number of symbols on the RHS of the reduced rule.
+ Keep to zero when no symbol should be popped. */
+ int yylen = 0;
+
+ yyssp = yyss = yyssa;
+ yyvsp = yyvs = yyvsa;
+ yystacksize = YYINITDEPTH;
+
+ YYDPRINTF ((stderr, "Starting parse\n"));
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+ goto yysetstate;
+
+
+/*------------------------------------------------------------.
+| yynewstate -- push a new state, which is found in yystate. |
+`------------------------------------------------------------*/
+yynewstate:
+ /* In all cases, when you get here, the value and location stacks
+ have just been pushed. So pushing a state here evens the stacks. */
+ yyssp++;
+
+
+/*--------------------------------------------------------------------.
+| yysetstate -- set current state (the top of the stack) to yystate. |
+`--------------------------------------------------------------------*/
+yysetstate:
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+ YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
+ YY_IGNORE_USELESS_CAST_BEGIN
+ *yyssp = YY_CAST (yy_state_t, yystate);
+ YY_IGNORE_USELESS_CAST_END
+
+ if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+ goto yyexhaustedlab;
+#else
+ {
+ /* Get the current used size of the three stacks, in elements. */
+ YYPTRDIFF_T yysize = yyssp - yyss + 1;
+
+# if defined yyoverflow
+ {
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ yy_state_t *yyss1 = yyss;
+ YYSTYPE *yyvs1 = yyvs;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. This used to be a
+ conditional around just the two extra args, but that might
+ be undefined if yyoverflow is a macro. */
+ yyoverflow (YY_("memory exhausted"),
+ &yyss1, yysize * YYSIZEOF (*yyssp),
+ &yyvs1, yysize * YYSIZEOF (*yyvsp),
+ &yystacksize);
+ yyss = yyss1;
+ yyvs = yyvs1;
+ }
+# else /* defined YYSTACK_RELOCATE */
+ /* Extend the stack our own way. */
+ if (YYMAXDEPTH <= yystacksize)
+ goto yyexhaustedlab;
+ yystacksize *= 2;
+ if (YYMAXDEPTH < yystacksize)
+ yystacksize = YYMAXDEPTH;
+
+ {
+ yy_state_t *yyss1 = yyss;
+ union yyalloc *yyptr =
+ YY_CAST (union yyalloc *,
+ YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
+ if (! yyptr)
+ goto yyexhaustedlab;
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
+# endif
+
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+
+ YY_IGNORE_USELESS_CAST_BEGIN
+ YYDPRINTF ((stderr, "Stack size increased to %ld\n",
+ YY_CAST (long, yystacksize)));
+ YY_IGNORE_USELESS_CAST_END
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ YYABORT;
+ }
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
+
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
+ goto yybackup;
+
+
+/*-----------.
+| yybackup. |
+`-----------*/
+yybackup:
+ /* Do appropriate processing given the current state. Read a
+ lookahead token if we need one and don't already have one. */
+
+ /* First try to decide what to do without reference to lookahead token. */
+ yyn = yypact[yystate];
+ if (yypact_value_is_default (yyn))
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
+ if (yychar == YYEMPTY)
+ {
+ YYDPRINTF ((stderr, "Reading a token: "));
+ yychar = yylex ();
+ }
+
+ if (yychar <= YYEOF)
+ {
+ yychar = yytoken = YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+ }
+
+ /* If the proper action on seeing token YYTOKEN is to reduce or to
+ detect an error, take that action. */
+ yyn += yytoken;
+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+ goto yydefault;
+ yyn = yytable[yyn];
+ if (yyn <= 0)
+ {
+ if (yytable_value_is_error (yyn))
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
+ /* Shift the lookahead token. */
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+ yystate = yyn;
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
+ goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+ goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- do a reduction. |
+`-----------------------------*/
+yyreduce:
+ /* yyn is the number of a rule to reduce with. */
+ yylen = yyr2[yyn];
+
+ /* If YYLEN is nonzero, implement the default value of the action:
+ '$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to garbage.
+ This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+
+ YY_REDUCE_PRINT (yyn);
+ switch (yyn)
+ {
+ case 2:
+#line 47 "compilador.y"
+ {
+ geraCodigo (NULL, "INPP");
+ }
+#line 1495 "compilador.tab.c"
+ break;
+
+ case 3:
+#line 53 "compilador.y"
+ {
+ geraCodigo (NULL, "PARA");
+ }
+#line 1503 "compilador.tab.c"
+ break;
+
+ case 4:
+#line 63 "compilador.y"
+ {
+ char r_main[4];
+ sprintf(r_main, "R%02d", rot_id);
+ empilha(r_main, rot);
+ rot_id += 1;
+ char buffer[50];
+ strcpy(buffer,"DSVS ");
+ strcat(buffer,r_main);
+ geraCodigo(NULL,buffer);
+ }
+#line 1518 "compilador.tab.c"
+ break;
+
+ case 5:
+#line 74 "compilador.y"
+ {
+ char r_main[4];
+ desempilha(r_main,rot);
+ geraCodigo(r_main,"NADA");
+ }
+#line 1528 "compilador.tab.c"
+ break;
+
+ case 6:
+#line 80 "compilador.y"
+ {
+ char buffer[50];
+ sprintf(buffer,"DMEM %d",desloc);
+ desloc = retira_pr_fun(ts);
+ desloc = retira_vs_pf(ts);
+ geraCodigo(NULL,buffer);
+ if (nivel_lexico > 0)
+ nivel_lexico += 1;
+ mostra_ts(ts);
+ }
+#line 1543 "compilador.tab.c"
+ break;
+
+ case 10:
+#line 101 "compilador.y"
+ { }
+#line 1549 "compilador.tab.c"
+ break;
+
+ case 15:
+#line 110 "compilador.y"
+ { num_vars = 0; }
+#line 1555 "compilador.tab.c"
+ break;
+
+ case 16:
+#line 113 "compilador.y"
+ {
+ char buffer[50];
+ sprintf(buffer, "AMEM %d", num_vars);
+ geraCodigo(NULL, buffer);
+ }
+#line 1565 "compilador.tab.c"
+ break;
+
+ case 18:
+#line 122 "compilador.y"
+ {
+ if (strcmp(token, "integer") == 0) {
+ atualiza_tipo(num_vars, INTEIRO, ts);
+ } else if (strcmp(token, "boolean") == 0) {
+ atualiza_tipo(num_vars, BOOLEAN, ts);
+ } else {
+ yyerror("Tipo não reconhecido. Somente 'integer' ou 'boolean' são permitidos.");
+ }
+ mostra_ts(ts); // Mostra a tabela após a inserção
+ }
+#line 1580 "compilador.tab.c"
+ break;
+
+ case 19:
+#line 135 "compilador.y"
+ { /* insere �ltima vars na tabela de s�mbolos */
+ num_vars += 1;
+ info_t info;
+ info.vs.tipo = NSEI;
+ info.vs.desloc = desloc;
+ insere_ts(token,VS,nivel_lexico,info,ts);
+ desloc += 1;
+ }
+#line 1593 "compilador.tab.c"
+ break;
+
+ case 20:
+#line 143 "compilador.y"
+ {
+ num_vars += 1;
+ info_t info;
+ info.vs.tipo = NSEI;
+ info.vs.desloc = desloc;
+ insere_ts(token,VS,nivel_lexico,info,ts);
+ desloc += 1;
+ /* insere vars na tabela de s�mbolos */
+ }
+#line 1607 "compilador.tab.c"
+ break;
+
+ case 26:
+#line 167 "compilador.y"
+ {
+ // Insere o procedimento na tabela de símbolos
+ info_t info;
+ char r_proc[4];
+ sprintf(r_proc, "R%02d", rot_id);
+ rot_id += 1;
+ strcpy(info.pr.rot,r_proc);
+ info.pr.quant = 0;
+ info.pr.param = NULL;
+
+ // Incrementa o nível léxico
+ nivel_lexico += 1;
+ desloc = 0; // Reinicia deslocamento para variáveis locais do novo nível
+
+ insere_ts(token, PR, nivel_lexico, info, ts);
+ empilha(token,proc);
+
+ char buffer[50];
+ sprintf(buffer,"ENPR %d",nivel_lexico);
+ geraCodigo(r_proc,buffer);
+ mostra_ts(ts);
+ }
+#line 1634 "compilador.tab.c"
+ break;
+
+ case 27:
+#line 191 "compilador.y"
+ {
+ char buffer[50];
+ desempilha(buffer,proc);
+ l_elem = busca(buffer,ts);
+ int n;
+ if(l_elem->categ == PR)
+ n = l_elem->info.pr.quant;
+ else if (l_elem->categ == FUN)
+ n = l_elem->info.pr.quant;
+ sprintf(buffer,"RTPR %d,%d",l_elem->nivel,n);
+ geraCodigo(NULL,buffer);
+ desloc = retira_vs_pf(ts);
+ mostra_ts(ts);
+ }
+#line 1653 "compilador.tab.c"
+ break;
+
+ case 29:
+#line 210 "compilador.y"
+ {
+ // Insere o funcao na tabela de símbolos
+ info_t info;
+ char r_func[4];
+ sprintf(r_func, "R%02d", rot_id);
+ rot_id += 1;
+ strcpy(info.fun.rot,r_func);
+ info.fun.quant = 0;
+ info.fun.param = NULL;
+ info.fun.tipo = NSEI;
+
+ // Incrementa o nível léxico
+ nivel_lexico += 1;
+ desloc = 0; // Reinicia deslocamento para variáveis locais do novo nível
+
+ insere_ts(token, FUN, nivel_lexico, info, ts);
+ empilha(token,proc);
+
+ char buffer[50];
+ sprintf(buffer,"ENPR %d",nivel_lexico);
+ geraCodigo(r_func,buffer);
+ mostra_ts(ts);
+ }
+#line 1681 "compilador.tab.c"
+ break;
+
+ case 30:
+#line 234 "compilador.y"
+ {
+ num_vars = 1;
+ }
+#line 1689 "compilador.tab.c"
+ break;
+
+ case 31:
+#line 238 "compilador.y"
+ {
+ // Retorna ao nível léxico anterior e mantém o deslocamento atualizado
+ nivel_lexico -= 1;
+ }
+#line 1698 "compilador.tab.c"
+ break;
+
+ case 33:
+#line 246 "compilador.y"
+ {num_param = 0;}
+#line 1704 "compilador.tab.c"
+ break;
+
+ case 34:
+#line 247 "compilador.y"
+ {
+ char proc_ident[50];
+ desempilha(proc_ident,proc);
+ adiciona_param(proc_ident,num_param,ts);
+ empilha(proc_ident,proc);
+ mostra_ts(ts);
+ }
+#line 1716 "compilador.tab.c"
+ break;
+
+ case 39:
+#line 263 "compilador.y"
+ {
+ num_vars = 0;
+ val_ou_ref = REF;
+ }
+#line 1725 "compilador.tab.c"
+ break;
+
+ case 40:
+#line 268 "compilador.y"
+ {
+ num_param += num_vars;
+ val_ou_ref = VLR;
+ }
+#line 1734 "compilador.tab.c"
+ break;
+
+ case 41:
+#line 272 "compilador.y"
+ {
+ num_vars = 0;
+ val_ou_ref = VLR;
+ }
+#line 1743 "compilador.tab.c"
+ break;
+
+ case 42:
+#line 277 "compilador.y"
+ {num_param += num_vars;}
+#line 1749 "compilador.tab.c"
+ break;
+
+ case 45:
+#line 284 "compilador.y"
+ {
+ num_vars += 1;
+ info_t info;
+ info.pf.tipo = NSEI;
+ info.pf.desloc = NSEI;
+ info.pf.passagem = val_ou_ref;
+ insere_ts(token,PF,nivel_lexico,info,ts);
+ }
+#line 1762 "compilador.tab.c"
+ break;
+
+ case 58:
+#line 314 "compilador.y"
+ {l_elem = busca(token, ts);}
+#line 1768 "compilador.tab.c"
+ break;
+
+ case 62:
+#line 322 "compilador.y"
+ {
+ if (l_elem == NULL) {
+ yyerror("Variável de destino não declarada");
+ } else {
+ if (l_elem->categ == PF && l_elem->info.pf.passagem == REF)
+ atr_indireto = REF;
+ else atr_indireto = VLR;
+ destino_nivel = l_elem->nivel;
+ destino_desloc = l_elem->info.vs.desloc;
+ }
+}
+#line 1784 "compilador.tab.c"
+ break;
+
+ case 63:
+#line 332 "compilador.y"
+ {
+ // Gera código ARMZ para armazenar valor
+ char buffer[50];
+ if (atr_indireto == REF) {
+ sprintf(buffer, "ARMI %d,%d", destino_nivel, destino_desloc);
+ } else {
+ sprintf(buffer, "ARMZ %d,%d", destino_nivel, destino_desloc);
+ }
+ geraCodigo(NULL, buffer);
+}
+#line 1799 "compilador.tab.c"
+ break;
+
+ case 64:
+#line 345 "compilador.y"
+ {
+ if (l_elem == NULL){
+ yyerror("Procedimento não declarado");
+ } else if (l_elem->categ == PR || l_elem->categ == FUN) {
+ // Gera código para chamar o procedimento
+ empilha(l_elem->ident, proc);
+ }
+ if (l_elem->categ == FUN)
+ geraCodigo(NULL, "AMEM 1");
+ num_param = 0; // Reinicia a contagem de parâmetros reais
+ }
+#line 1815 "compilador.tab.c"
+ break;
+
+ case 65:
+#line 359 "compilador.y"
+ {
+ if (l_elem->categ == PR || l_elem->categ ==FUN) {
+ char buffer[50];
+ mostra_ts(ts);
+ desempilha(buffer, proc);
+ l_elem = busca(buffer, ts);
+
+ // Verifica se o número de parâmetros reais bate com os formais
+ if (num_param != l_elem->info.pr.quant) {
+ char error_msg[100];
+ if(l_elem->categ == PR){
+ sprintf(error_msg, "Erro: número de parâmetros incorreto. Esperado: %d, recebido: %d.",
+ l_elem->info.pr.quant, num_param);
+ yyerror(error_msg);
+ } else if(l_elem->categ == FUN){
+ sprintf(error_msg, "Erro: número de parâmetros incorreto. Esperado: %d, recebido: %d.",
+ l_elem->info.fun.quant, num_param);
+ yyerror(error_msg);
+ }
+ }
+
+ // Gera o código de chamada do procedimento
+
+ sprintf(buffer, "CHPR %s,%d", l_elem->info.pr.rot, nivel_lexico);
+ geraCodigo(NULL, buffer);
+ }
+ }
+#line 1847 "compilador.tab.c"
+ break;
+
+ case 68:
+#line 395 "compilador.y"
+ {
+ char buffer[50];
+ desempilha(buffer,proc);
+ l_elem = busca(buffer,ts);
+ val_ou_ref = l_elem->info.pr.param[num_param][1];
+ empilha(buffer,proc);
+ }
+#line 1859 "compilador.tab.c"
+ break;
+
+ case 69:
+#line 403 "compilador.y"
+ {
+ num_param++; // Incrementa para cada parâmetro real
+ val_ou_ref = VLR;
+ }
+#line 1868 "compilador.tab.c"
+ break;
+
+ case 70:
+#line 407 "compilador.y"
+ {
+ char buffer[50];
+ desempilha(buffer,proc);
+ l_elem = busca(buffer,ts);
+ val_ou_ref = l_elem->info.pr.param[num_param][1];
+ empilha(buffer,proc);
+ }
+#line 1880 "compilador.tab.c"
+ break;
+
+ case 71:
+#line 415 "compilador.y"
+ {
+ num_param++; // Conta o primeiro parâmetro real
+ val_ou_ref = VLR;
+ }
+#line 1889 "compilador.tab.c"
+ break;
+
+ case 75:
+#line 428 "compilador.y"
+ {
+ geraCodigo(NULL, "LEIT");
+ l_elem = busca(token,ts);
+ char buffer[50];
+ sprintf(buffer,"ARMZ %d,%d",l_elem->nivel,l_elem->info.vs.desloc);
+ geraCodigo(NULL,buffer);
+ }
+#line 1901 "compilador.tab.c"
+ break;
+
+ case 77:
+#line 440 "compilador.y"
+ {
+ geraCodigo(NULL,"IMPR");
+ }
+#line 1909 "compilador.tab.c"
+ break;
+
+ case 78:
+#line 443 "compilador.y"
+ {
+ geraCodigo(NULL,"IMPR");
+ }
+#line 1917 "compilador.tab.c"
+ break;
+
+ case 79:
+#line 448 "compilador.y"
+ {
+ geraCodigo(NULL, "CMIG"); // Adiciona operação de cmig
+ }
+#line 1925 "compilador.tab.c"
+ break;
+
+ case 80:
+#line 451 "compilador.y"
+ {
+ geraCodigo(NULL, "CMDG"); // Adiciona operação de cmdg
+ }
+#line 1933 "compilador.tab.c"
+ break;
+
+ case 81:
+#line 454 "compilador.y"
+ {
+ geraCodigo(NULL, "CMME"); // Adiciona operação de cmme
+ }
+#line 1941 "compilador.tab.c"
+ break;
+
+ case 82:
+#line 457 "compilador.y"
+ {
+ geraCodigo(NULL, "CMEG"); // Adiciona operação de cmeg
+ }
+#line 1949 "compilador.tab.c"
+ break;
+
+ case 83:
+#line 460 "compilador.y"
+ {
+ geraCodigo(NULL, "CMMA"); // Adiciona operação de cmma
+ }
+#line 1957 "compilador.tab.c"
+ break;
+
+ case 84:
+#line 463 "compilador.y"
+ {
+ geraCodigo(NULL, "CMAG"); // Adiciona operação de cmag
+ }
+#line 1965 "compilador.tab.c"
+ break;
+
+ case 86:
+#line 469 "compilador.y"
+ {
+ if (val_ou_ref == REF)
+ yyerror("Erro: tentativa de EXPRESSAO em passagem por REFERENCIA\n");
+ else
+ geraCodigo(NULL, "SOMA"); // Adiciona operação de soma
+ }
+#line 1976 "compilador.tab.c"
+ break;
+
+ case 87:
+#line 475 "compilador.y"
+ {
+ if (val_ou_ref == REF)
+ yyerror("Erro: tentativa de EXPRESSAO em passagem por REFERENCIA\n");
+ else
+ geraCodigo(NULL, "SUBT"); // Adiciona operação de subt
+ }
+#line 1987 "compilador.tab.c"
+ break;
+
+ case 89:
+#line 484 "compilador.y"
+ {
+ geraCodigo(NULL, "MULT"); // Adiciona operação de mult
+ }
+#line 1995 "compilador.tab.c"
+ break;
+
+ case 90:
+#line 487 "compilador.y"
+ {
+ geraCodigo(NULL, "DIVI"); // Adiciona operação de divi
+ }
+#line 2003 "compilador.tab.c"
+ break;
+
+ case 92:
+#line 493 "compilador.y"
+ {
+ // Carrega variável
+ l_elem = busca(token, ts);
+ empilha(token, proc);
+ }
+#line 2013 "compilador.tab.c"
+ break;
+
+ case 93:
+#line 499 "compilador.y"
+ {
+ char buffer[50];
+ desempilha(buffer, proc);
+ l_elem = busca(buffer, ts);
+ if (l_elem == NULL) {
+ yyerror("Variável não declarada");
+ } else {
+ if (val_ou_ref == REF) {
+ if (l_elem->categ == VS)
+ sprintf(buffer, "CREN %d,%d", l_elem->nivel, l_elem->info.vs.desloc);
+ else if (l_elem->categ == FUN)
+ sprintf(buffer, "CREN %d,%d", l_elem->nivel, l_elem->info.fun.desloc);
+ }
+ else if (l_elem->categ == PF && l_elem->info.pf.passagem == REF) {
+ sprintf(buffer, "CRVI %d,%d", l_elem->nivel, l_elem->info.pf.desloc);
+ }
+ else {
+ if (l_elem->categ == VS)
+ sprintf(buffer, "CRVL %d,%d", l_elem->nivel, l_elem->info.vs.desloc);
+ else if (l_elem->categ == FUN)
+ sprintf(buffer, "CRVL %d,%d", l_elem->nivel, l_elem->info.fun.desloc);
+ }
+ geraCodigo(NULL, buffer);
+ }
+ }
+#line 2043 "compilador.tab.c"
+ break;
+
+ case 94:
+#line 524 "compilador.y"
+ {
+ // Empilha constante
+ char buffer[50];
+ if (val_ou_ref == VLR)
+ sprintf(buffer, "CRCT %s", token);
+ else {
+ yyerror("Erro: passagem de constante por REFERENCIA.\n");
+ }
+ geraCodigo(NULL, buffer);
+}
+#line 2058 "compilador.tab.c"
+ break;
+
+ case 96:
+#line 537 "compilador.y"
+ {
+ char r_ini[4];
+ sprintf(r_ini, "R%02d", rot_id);
+ empilha(r_ini, rot);
+ rot_id += 1;
+ geraCodigo(r_ini,"NADA");
+ }
+#line 2070 "compilador.tab.c"
+ break;
+
+ case 97:
+#line 544 "compilador.y"
+ {
+ char r_fim[4];
+ sprintf(r_fim, "R%02d", rot_id);
+ empilha(r_fim, rot);
+ rot_id += 1;
+ char buffer[50];
+ strcpy(buffer, "DSVF ");
+ strcat(buffer,r_fim);
+ geraCodigo(NULL,buffer);
+ }
+#line 2085 "compilador.tab.c"
+ break;
+
+ case 98:
+#line 554 "compilador.y"
+ {
+ char r_ini[4];
+ char r_fim[4];
+
+ desempilha(r_fim,rot);
+ desempilha(r_ini,rot);
+
+ char buffer[50];
+ strcpy(buffer,"DSVS ");
+ strcat(buffer,r_ini);
+ geraCodigo(NULL,buffer);
+
+ geraCodigo(r_fim,"NADA");
+ }
+#line 2104 "compilador.tab.c"
+ break;
+
+ case 99:
+#line 570 "compilador.y"
+ {
+ char r_fim[4];
+ desempilha(r_fim,rot);
+ geraCodigo(r_fim,"NADA");
+ }
+#line 2114 "compilador.tab.c"
+ break;
+
+ case 102:
+#line 582 "compilador.y"
+ {
+ char r_else[4];
+ sprintf(r_else,"R%02d",rot_id);
+ empilha(r_else,rot);
+ rot_id += 1;
+ char buffer[50];
+ strcpy(buffer, "DSVF ");
+ strcat(buffer,r_else);
+ geraCodigo(NULL,buffer);
+
+ char r_fim[4];
+ sprintf(r_fim, "R%02d", rot_id);
+ empilha(r_fim, rot);
+ rot_id += 1;
+ }
+#line 2134 "compilador.tab.c"
+ break;
+
+ case 103:
+#line 597 "compilador.y"
+ {
+ char r_fim[4];
+ desempilha(r_fim,rot);
+ char r_else[4];
+ desempilha(r_else,rot);
+
+ empilha(r_fim,rot);
+ char buffer[50];
+ strcpy(buffer, "DSVS ");
+ strcat(buffer,r_fim);
+ geraCodigo(NULL,buffer);
+
+ geraCodigo(r_else,"NADA");
+ }
+#line 2153 "compilador.tab.c"
+ break;
+
+
+#line 2157 "compilador.tab.c"
+
+ default: break;
+ }
+ /* User semantic actions sometimes alter yychar, and that requires
+ that yytoken be updated with the new translation. We take the
+ approach of translating immediately before every use of yytoken.
+ One alternative is translating here after every semantic action,
+ but that translation would be missed if the semantic action invokes
+ YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+ if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
+ incorrect destructor might then be invoked immediately. In the
+ case of YYERROR or YYBACKUP, subsequent parser actions might lead
+ to an incorrect destructor call or verbose syntax error message
+ before the lookahead is translated. */
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+
+ *++yyvsp = yyval;
+
+ /* Now 'shift' the result of the reduction. Determine what state
+ that goes to, based on the state we popped back to and the rule
+ number reduced by. */
+ {
+ const int yylhs = yyr1[yyn] - YYNTOKENS;
+ const int yyi = yypgoto[yylhs] + *yyssp;
+ yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+ ? yytable[yyi]
+ : yydefgoto[yylhs]);
+ }
+
+ goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error. |
+`--------------------------------------*/
+yyerrlab:
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
+ {
+ ++yynerrs;
+#if ! YYERROR_VERBOSE
+ yyerror (YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+ yyssp, yytoken)
+ {
+ char const *yymsgp = YY_("syntax error");
+ int yysyntax_error_status;
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ if (yysyntax_error_status == 0)
+ yymsgp = yymsg;
+ else if (yysyntax_error_status == 1)
+ {
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+ yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
+ if (!yymsg)
+ {
+ yymsg = yymsgbuf;
+ yymsg_alloc = sizeof yymsgbuf;
+ yysyntax_error_status = 2;
+ }
+ else
+ {
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ yymsgp = yymsg;
+ }
+ }
+ yyerror (yymsgp);
+ if (yysyntax_error_status == 2)
+ goto yyexhaustedlab;
+ }
+# undef YYSYNTAX_ERROR
+#endif
+ }
+
+
+
+ if (yyerrstatus == 3)
+ {
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
+
+ if (yychar <= YYEOF)
+ {
+ /* Return failure if at end of input. */
+ if (yychar == YYEOF)
+ YYABORT;
+ }
+ else
+ {
+ yydestruct ("Error: discarding",
+ yytoken, &yylval);
+ yychar = YYEMPTY;
+ }
+ }
+
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
+ goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR. |
+`---------------------------------------------------*/
+yyerrorlab:
+ /* Pacify compilers when the user code never invokes YYERROR and the
+ label yyerrorlab therefore never appears in user code. */
+ if (0)
+ YYERROR;
+
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYERROR. */
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+ yystate = *yyssp;
+ goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR. |
+`-------------------------------------------------------------*/
+yyerrlab1:
+ yyerrstatus = 3; /* Each real token shifted decrements this. */
+
+ for (;;)
+ {
+ yyn = yypact[yystate];
+ if (!yypact_value_is_default (yyn))
+ {
+ yyn += YYTERROR;
+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+ {
+ yyn = yytable[yyn];
+ if (0 < yyn)
+ break;
+ }
+ }
+
+ /* Pop the current state because it cannot handle the error token. */
+ if (yyssp == yyss)
+ YYABORT;
+
+
+ yydestruct ("Error: popping",
+ yystos[yystate], yyvsp);
+ YYPOPSTACK (1);
+ yystate = *yyssp;
+ YY_STACK_PRINT (yyss, yyssp);
+ }
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+ /* Shift the error token. */
+ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here. |
+`-------------------------------------------------*/
+yyexhaustedlab:
+ yyerror (YY_("memory exhausted"));
+ yyresult = 2;
+ /* Fall through. */
+#endif
+
+
+/*-----------------------------------------------------.
+| yyreturn -- parsing is finished, return the result. |
+`-----------------------------------------------------*/
+yyreturn:
+ if (yychar != YYEMPTY)
+ {
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = YYTRANSLATE (yychar);
+ yydestruct ("Cleanup: discarding lookahead",
+ yytoken, &yylval);
+ }
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYABORT or YYACCEPT. */
+ YYPOPSTACK (yylen);
+ YY_STACK_PRINT (yyss, yyssp);
+ while (yyssp != yyss)
+ {
+ yydestruct ("Cleanup: popping",
+ yystos[+*yyssp], yyvsp);
+ YYPOPSTACK (1);
+ }
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+#endif
+ return yyresult;
+}
+#line 614 "compilador.y"
+
+
+int main (int argc, char** argv) {
+ FILE* fp;
+ extern FILE* yyin;
+
+ if (argc<2 || argc>2) {
+ printf("usage compilador <arq>a %d\n", argc);
+ return(-1);
+ }
+
+ fp=fopen (argv[1], "r");
+ if (fp == NULL) {
+ printf("usage compilador <arq>b\n");
+ return(-1);
+ }
+
+
+/* -------------------------------------------------------------------
+ * Inicia a Tabela de S�mbolos
+ * ------------------------------------------------------------------- */
+ ts = (ts_t *)malloc(sizeof(ts_t));
+ inicializa_ts(ts);
+ nivel_lexico = 0;
+ desloc = 0;
+
+ // Inicializa Rotulos
+ rot = (custom_stack_t *)malloc(sizeof(custom_stack_t));
+ inicializa_stack(rot);
+ rot_id = 0;
+
+ proc = (custom_stack_t *)malloc(sizeof(custom_stack_t));
+ inicializa_stack(proc);
+
+ yyin=fp;
+ yyparse();
+
+ return 0;
+}
diff --git a/compilador.tab.h b/compilador.tab.h
new file mode 100644
index 0000000..2be6c98
--- /dev/null
+++ b/compilador.tab.h
@@ -0,0 +1,107 @@
+/* A Bison parser, made by GNU Bison 3.5.1. */
+
+/* Bison interface for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 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 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 <http://www.gnu.org/licenses/>. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+/* Undocumented macros, especially those whose name start with YY_,
+ are private implementation details. Do not rely on them. */
+
+#ifndef YY_YY_COMPILADOR_TAB_H_INCLUDED
+# define YY_YY_COMPILADOR_TAB_H_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token type. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ PROGRAM = 258,
+ ABRE_PARENTESES = 259,
+ FECHA_PARENTESES = 260,
+ VIRGULA = 261,
+ PONTO_E_VIRGULA = 262,
+ DOIS_PONTOS = 263,
+ PONTO = 264,
+ T_BEGIN = 265,
+ T_END = 266,
+ VAR = 267,
+ IDENT = 268,
+ ATRIBUICAO = 269,
+ LABEL = 270,
+ TYPE = 271,
+ ARRAY = 272,
+ PROCEDURE = 273,
+ FUNCTION = 274,
+ GOTO = 275,
+ IF = 276,
+ THEN = 277,
+ ELSE = 278,
+ WHILE = 279,
+ DO = 280,
+ OR = 281,
+ DIV = 282,
+ AND = 283,
+ NOT = 284,
+ IGUAL = 285,
+ DIFERENTE = 286,
+ MENOR_IGUAL = 287,
+ MAIOR_IGUAL = 288,
+ MENOR = 289,
+ MAIOR = 290,
+ MAIS = 291,
+ MENOS = 292,
+ ASTERISCO = 293,
+ NUMERO = 294,
+ READ = 295,
+ WRITE = 296,
+ LOWER_THAN_ELSE = 297
+ };
+#endif
+
+/* Value type. */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef int YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+extern YYSTYPE yylval;
+
+int yyparse (void);
+
+#endif /* !YY_YY_COMPILADOR_TAB_H_INCLUDED */
diff --git a/compilador.y b/compilador.y
index 24419a4..50d3bdd 100644
--- a/compilador.y
+++ b/compilador.y
@@ -80,10 +80,12 @@ bloco :
comando_composto {
char buffer[50];
sprintf(buffer,"DMEM %d",desloc);
- desloc = retira(desloc,ts);
+ desloc = retira_pr_fun(ts);
+ desloc = retira_vs_pf(ts);
geraCodigo(NULL,buffer);
if (nivel_lexico > 0)
nivel_lexico += 1;
+ mostra_ts(ts);
}
;
@@ -197,7 +199,7 @@ declaracao_procedimento: PROCEDURE IDENT {
n = l_elem->info.pr.quant;
sprintf(buffer,"RTPR %d,%d",l_elem->nivel,n);
geraCodigo(NULL,buffer);
- desloc = retira(n,ts);
+ desloc = retira_vs_pf(ts);
mostra_ts(ts);
}
PONTO_E_VIRGULA
diff --git a/lex.yy.c b/lex.yy.c
new file mode 100644
index 0000000..ef6ad0e
--- /dev/null
+++ b/lex.yy.c
@@ -0,0 +1,2196 @@
+
+#line 3 "lex.yy.c"
+
+#define YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX (4294967295U)
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ * integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* Enter a start condition. This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN (yy_start) = 1 + 2 *
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state. The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START (((yy_start) - 1) / 2)
+#define YYSTATE YY_START
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+extern int yyleng;
+
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+ #define YY_LESS_LINENO(n)
+ #define YY_LINENO_REWIND_TO(ptr)
+
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+ do \
+ { \
+ /* Undo effects of setting up yytext. */ \
+ int yyless_macro_arg = (n); \
+ YY_LESS_LINENO(yyless_macro_arg);\
+ *yy_cp = (yy_hold_char); \
+ YY_RESTORE_YY_MORE_OFFSET \
+ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+ YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+ } \
+ while ( 0 )
+#define unput(c) yyunput( c, (yytext_ptr) )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+ {
+ FILE *yy_input_file;
+
+ char *yy_ch_buf; /* input buffer */
+ char *yy_buf_pos; /* current position in input buffer */
+
+ /* Size of input buffer in bytes, not including room for EOB
+ * characters.
+ */
+ int yy_buf_size;
+
+ /* Number of characters read into yy_ch_buf, not including EOB
+ * characters.
+ */
+ int yy_n_chars;
+
+ /* Whether we "own" the buffer - i.e., we know we created it,
+ * and can realloc() it to grow it, and should free() it to
+ * delete it.
+ */
+ int yy_is_our_buffer;
+
+ /* Whether this is an "interactive" input source; if so, and
+ * if we're using stdio for input, then we want to use getc()
+ * instead of fread(), to make sure we stop fetching input after
+ * each newline.
+ */
+ int yy_is_interactive;
+
+ /* Whether we're considered to be at the beginning of a line.
+ * If so, '^' rules will be active on the next match, otherwise
+ * not.
+ */
+ int yy_at_bol;
+
+ int yy_bs_lineno; /**< The line count. */
+ int yy_bs_column; /**< The column count. */
+
+ /* Whether to try to fill the input buffer when we reach the
+ * end of it.
+ */
+ int yy_fill_buffer;
+
+ int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+ /* When an EOF's been seen but there's still some text to process
+ * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+ * shouldn't try reading from the input source any more. We might
+ * still have a bunch of tokens to match, though, because of
+ * possible backing-up.
+ *
+ * When we actually see the EOF, we change the status to "new"
+ * (via yyrestart()), so that the user can continue scanning by
+ * just pointing yyin at a new input file.
+ */
+#define YY_BUFFER_EOF_PENDING 2
+
+ };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+ : NULL)
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+static int yy_n_chars; /* number of characters read into yy_ch_buf */
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = NULL;
+static int yy_init = 0; /* whether we need to initialize */
+static int yy_start = 0; /* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin. A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart ( FILE *input_file );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
+void yy_delete_buffer ( YY_BUFFER_STATE b );
+void yy_flush_buffer ( YY_BUFFER_STATE b );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
+void yypop_buffer_state ( void );
+
+static void yyensure_buffer_stack ( void );
+static void yy_load_buffer_state ( void );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
+
+void *yyalloc ( yy_size_t );
+void *yyrealloc ( void *, yy_size_t );
+void yyfree ( void * );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+ { \
+ if ( ! YY_CURRENT_BUFFER ){ \
+ yyensure_buffer_stack (); \
+ YY_CURRENT_BUFFER_LVALUE = \
+ yy_create_buffer( yyin, YY_BUF_SIZE ); \
+ } \
+ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+ }
+#define yy_set_bol(at_bol) \
+ { \
+ if ( ! YY_CURRENT_BUFFER ){\
+ yyensure_buffer_stack (); \
+ YY_CURRENT_BUFFER_LVALUE = \
+ yy_create_buffer( yyin, YY_BUF_SIZE ); \
+ } \
+ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+ }
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+typedef flex_uint8_t YY_CHAR;
+
+FILE *yyin = NULL, *yyout = NULL;
+
+typedef int yy_state_type;
+
+extern int yylineno;
+int yylineno = 1;
+
+extern char *yytext;
+#ifdef yytext_ptr
+#undef yytext_ptr
+#endif
+#define yytext_ptr yytext
+
+static yy_state_type yy_get_previous_state ( void );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
+static int yy_get_next_buffer ( void );
+static void yynoreturn yy_fatal_error ( const char* msg );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+ (yytext_ptr) = yy_bp; \
+ yyleng = (int) (yy_cp - yy_bp); \
+ (yy_hold_char) = *yy_cp; \
+ *yy_cp = '\0'; \
+ (yy_c_buf_p) = yy_cp;
+#define YY_NUM_RULES 43
+#define YY_END_OF_BUFFER 44
+/* This struct is not used in this scanner,
+ but its presence is necessary. */
+struct yy_trans_info
+ {
+ flex_int32_t yy_verify;
+ flex_int32_t yy_nxt;
+ };
+static const flex_int16_t yy_accept[115] =
+ { 0,
+ 0, 0, 44, 43, 2, 1, 15, 16, 40, 38,
+ 13, 39, 14, 41, 12, 11, 36, 32, 37, 42,
+ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+ 42, 42, 42, 42, 42, 2, 0, 41, 10, 34,
+ 33, 35, 42, 42, 42, 42, 42, 27, 42, 42,
+ 42, 42, 23, 42, 42, 28, 42, 42, 42, 42,
+ 42, 42, 42, 0, 0, 30, 42, 42, 29, 42,
+ 7, 42, 42, 42, 31, 42, 42, 42, 42, 5,
+ 42, 42, 3, 42, 42, 25, 42, 22, 42, 42,
+ 42, 8, 24, 18, 42, 42, 19, 6, 42, 17,
+
+ 42, 42, 26, 9, 42, 42, 42, 42, 42, 4,
+ 21, 42, 20, 0
+ } ;
+
+static const YY_CHAR yy_ec[256] =
+ { 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 2, 1, 1, 1, 1, 1, 1, 1, 4,
+ 5, 6, 7, 8, 9, 10, 1, 11, 11, 11,
+ 11, 11, 11, 11, 11, 11, 11, 12, 13, 14,
+ 15, 16, 1, 1, 17, 17, 17, 17, 17, 17,
+ 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+ 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+ 1, 1, 1, 1, 1, 1, 18, 19, 20, 21,
+
+ 22, 23, 24, 25, 26, 17, 17, 27, 28, 29,
+ 30, 31, 17, 32, 33, 34, 35, 36, 37, 17,
+ 38, 17, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1
+ } ;
+
+static const YY_CHAR yy_meta[39] =
+ { 0,
+ 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
+ 3, 1, 1, 1, 1, 1, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3
+ } ;
+
+static const flex_int16_t yy_base[117] =
+ { 0,
+ 0, 0, 123, 124, 120, 124, 115, 124, 124, 124,
+ 124, 124, 124, 109, 104, 124, 24, 124, 103, 0,
+ 12, 95, 16, 16, 81, 85, 91, 95, 82, 79,
+ 78, 87, 22, 90, 23, 105, 100, 94, 124, 124,
+ 124, 124, 0, 83, 71, 78, 65, 0, 67, 78,
+ 69, 63, 0, 77, 61, 0, 64, 75, 70, 60,
+ 58, 63, 62, 81, 44, 0, 68, 59, 0, 62,
+ 0, 63, 52, 59, 0, 32, 59, 50, 56, 0,
+ 50, 42, 69, 36, 44, 0, 38, 0, 44, 48,
+ 37, 0, 0, 0, 46, 45, 0, 0, 40, 0,
+
+ 44, 46, 0, 0, 32, 24, 30, 28, 22, 0,
+ 0, 31, 0, 124, 48, 60
+ } ;
+
+static const flex_int16_t yy_def[117] =
+ { 0,
+ 114, 1, 114, 114, 114, 114, 114, 114, 114, 114,
+ 114, 114, 114, 114, 114, 114, 114, 114, 114, 115,
+ 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
+ 115, 115, 115, 115, 115, 114, 116, 114, 114, 114,
+ 114, 114, 115, 115, 115, 115, 115, 115, 115, 115,
+ 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
+ 115, 115, 115, 116, 116, 115, 115, 115, 115, 115,
+ 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
+ 115, 115, 116, 115, 115, 115, 115, 115, 115, 115,
+ 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
+
+ 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
+ 115, 115, 115, 0, 114, 114
+ } ;
+
+static const flex_int16_t yy_nxt[163] =
+ { 0,
+ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 20,
+ 23, 24, 25, 26, 20, 27, 28, 20, 29, 30,
+ 31, 32, 20, 33, 20, 34, 35, 20, 40, 41,
+ 44, 47, 49, 45, 50, 48, 59, 62, 83, 65,
+ 43, 90, 113, 112, 63, 91, 111, 110, 109, 60,
+ 64, 108, 64, 107, 106, 105, 104, 103, 102, 101,
+ 100, 99, 98, 97, 65, 96, 95, 94, 93, 92,
+ 89, 88, 87, 86, 85, 84, 65, 82, 81, 80,
+ 79, 78, 77, 76, 75, 74, 73, 72, 71, 70,
+
+ 69, 68, 67, 66, 38, 65, 36, 61, 58, 57,
+ 56, 55, 54, 53, 52, 51, 46, 42, 39, 38,
+ 37, 36, 114, 3, 114, 114, 114, 114, 114, 114,
+ 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
+ 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
+ 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
+ 114, 114
+ } ;
+
+static const flex_int16_t yy_chk[163] =
+ { 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 17, 17,
+ 21, 23, 24, 21, 24, 23, 33, 35, 65, 65,
+ 115, 76, 112, 109, 35, 76, 108, 107, 106, 33,
+ 116, 105, 116, 102, 101, 99, 96, 95, 91, 90,
+ 89, 87, 85, 84, 83, 82, 81, 79, 78, 77,
+ 74, 73, 72, 70, 68, 67, 64, 63, 62, 61,
+ 60, 59, 58, 57, 55, 54, 52, 51, 50, 49,
+
+ 47, 46, 45, 44, 38, 37, 36, 34, 32, 31,
+ 30, 29, 28, 27, 26, 25, 22, 19, 15, 14,
+ 7, 5, 3, 114, 114, 114, 114, 114, 114, 114,
+ 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
+ 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
+ 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
+ 114, 114
+ } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+extern int yy_flex_debug;
+int yy_flex_debug = 0;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+char *yytext;
+#line 1 "compilador.l"
+/* -------------------------------------------------------------------
+ * Arquivo: compilador.l
+ * -------------------------------------------------------------------
+ * Autor: Bruno Muller Junior
+ * Data: 08/2007
+ * Atualizado em: [09/08/2020, 19h:01m]
+ *
+ * -------------------------------------------------------------------
+ *
+ * Tipos, protótipos e variáveis globais do compilador (via extern)
+ *
+ * ------------------------------------------------------------------- */
+#line 16 "compilador.l"
+
+
+#include<stdio.h>
+#include<string.h>
+
+#include "compilador.h"
+#include "compilador.tab.h"
+
+//#define IMPRIME(STR) {};
+#define IMPRIME(STR) printf("%s # %s \n", STR, token);
+
+int nl = 1;
+
+#line 540 "lex.yy.c"
+#line 541 "lex.yy.c"
+
+#define INITIAL 0
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+static int yy_init_globals ( void );
+
+/* Accessor methods to globals.
+ These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( void );
+
+int yyget_debug ( void );
+
+void yyset_debug ( int debug_flag );
+
+YY_EXTRA_TYPE yyget_extra ( void );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined );
+
+FILE *yyget_in ( void );
+
+void yyset_in ( FILE * _in_str );
+
+FILE *yyget_out ( void );
+
+void yyset_out ( FILE * _out_str );
+
+ int yyget_leng ( void );
+
+char *yyget_text ( void );
+
+int yyget_lineno ( void );
+
+void yyset_lineno ( int _line_number );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( void );
+#else
+extern int yywrap ( void );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+
+ static void yyunput ( int c, char *buf_ptr );
+
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int );
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * );
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( void );
+#else
+static int input ( void );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+ { \
+ int c = '*'; \
+ int n; \
+ for ( n = 0; n < max_size && \
+ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+ buf[n] = (char) c; \
+ if ( c == '\n' ) \
+ buf[n++] = (char) c; \
+ if ( c == EOF && ferror( yyin ) ) \
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \
+ result = n; \
+ } \
+ else \
+ { \
+ errno=0; \
+ while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+ { \
+ if( errno != EINTR) \
+ { \
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \
+ break; \
+ } \
+ errno=0; \
+ clearerr(yyin); \
+ } \
+ }\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (void);
+
+#define YY_DECL int yylex (void)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+ YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+ yy_state_type yy_current_state;
+ char *yy_cp, *yy_bp;
+ int yy_act;
+
+ if ( !(yy_init) )
+ {
+ (yy_init) = 1;
+
+#ifdef YY_USER_INIT
+ YY_USER_INIT;
+#endif
+
+ if ( ! (yy_start) )
+ (yy_start) = 1; /* first start state */
+
+ if ( ! yyin )
+ yyin = stdin;
+
+ if ( ! yyout )
+ yyout = stdout;
+
+ if ( ! YY_CURRENT_BUFFER ) {
+ yyensure_buffer_stack ();
+ YY_CURRENT_BUFFER_LVALUE =
+ yy_create_buffer( yyin, YY_BUF_SIZE );
+ }
+
+ yy_load_buffer_state( );
+ }
+
+ {
+#line 41 "compilador.l"
+
+
+#line 761 "lex.yy.c"
+
+ while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
+ {
+ yy_cp = (yy_c_buf_p);
+
+ /* Support of yytext. */
+ *yy_cp = (yy_hold_char);
+
+ /* yy_bp points to the position in yy_ch_buf of the start of
+ * the current run.
+ */
+ yy_bp = yy_cp;
+
+ yy_current_state = (yy_start);
+yy_match:
+ do
+ {
+ YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+ if ( yy_accept[yy_current_state] )
+ {
+ (yy_last_accepting_state) = yy_current_state;
+ (yy_last_accepting_cpos) = yy_cp;
+ }
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 115 )
+ yy_c = yy_meta[yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+ ++yy_cp;
+ }
+ while ( yy_base[yy_current_state] != 124 );
+
+yy_find_action:
+ yy_act = yy_accept[yy_current_state];
+ if ( yy_act == 0 )
+ { /* have to back up */
+ yy_cp = (yy_last_accepting_cpos);
+ yy_current_state = (yy_last_accepting_state);
+ yy_act = yy_accept[yy_current_state];
+ }
+
+ YY_DO_BEFORE_ACTION;
+
+do_action: /* This label is used only to access EOF actions. */
+
+ switch ( yy_act )
+ { /* beginning of action switch */
+ case 0: /* must back up */
+ /* undo the effects of YY_DO_BEFORE_ACTION */
+ *yy_cp = (yy_hold_char);
+ yy_cp = (yy_last_accepting_cpos);
+ yy_current_state = (yy_last_accepting_state);
+ goto yy_find_action;
+
+case 1:
+/* rule 1 can match eol */
+YY_RULE_SETUP
+#line 43 "compilador.l"
+{nl++;}
+ YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 45 "compilador.l"
+
+ YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 47 "compilador.l"
+
+ YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 49 "compilador.l"
+{ simbolo = simb_program;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("program ");
+ return PROGRAM;
+ }
+ YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 55 "compilador.l"
+{ simbolo = simb_var;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("var ");
+ return VAR;
+ }
+ YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 61 "compilador.l"
+{ simbolo = simb_begin;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("begin ");
+ return T_BEGIN;
+ }
+ YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 67 "compilador.l"
+{ simbolo = simb_end;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("end ");
+ return T_END;
+ }
+ YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 73 "compilador.l"
+{ simbolo = simb_read;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("read ");
+ return READ;
+}
+ YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 79 "compilador.l"
+{ simbolo = simb_write;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("write ");
+ return WRITE;
+}
+ YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 85 "compilador.l"
+{ simbolo = simb_atribuicao;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" atribuicao ");
+ return ATRIBUICAO;
+ }
+ YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 91 "compilador.l"
+{ simbolo = simb_ponto_e_virgula;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" pt_virgula ");
+ return PONTO_E_VIRGULA;
+ }
+ YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 97 "compilador.l"
+{ simbolo = simb_dois_pontos;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" dois pontos ");
+ return DOIS_PONTOS;
+ }
+ YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 103 "compilador.l"
+{ simbolo = simb_virgula;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" virgula ");
+ return VIRGULA;
+ }
+ YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 110 "compilador.l"
+{ simbolo = simb_ponto;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" ponto ");
+ return PONTO;
+ }
+ YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 116 "compilador.l"
+{ simbolo = simb_abre_parenteses;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" abre_parenteses ");
+ return ABRE_PARENTESES;
+ }
+ YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 122 "compilador.l"
+{ simbolo = simb_fecha_parenteses;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" fecha_parenteses ");
+ return FECHA_PARENTESES;
+ }
+ YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 128 "compilador.l"
+{ simbolo = simb_label;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("label ");
+ return LABEL;
+ }
+ YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 134 "compilador.l"
+{ simbolo = simb_type;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("type ");
+ return TYPE;
+ }
+ YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 140 "compilador.l"
+{ simbolo = simb_array;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("array ");
+ return ARRAY;
+ }
+ YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 146 "compilador.l"
+{ simbolo = simb_procedure;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("procedure ");
+ return PROCEDURE;
+ }
+ YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 152 "compilador.l"
+{ simbolo = simb_function;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("function ");
+ return FUNCTION;
+ }
+ YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 158 "compilador.l"
+{ simbolo = simb_goto;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("goto ");
+ return GOTO;
+ }
+ YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 164 "compilador.l"
+{ simbolo = simb_if;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("if ");
+ return IF;
+ }
+ YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 170 "compilador.l"
+{ simbolo = simb_then;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" then ");
+ return THEN;
+ }
+ YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 176 "compilador.l"
+{ simbolo = simb_else;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" else ");
+ return ELSE;
+ }
+ YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 182 "compilador.l"
+{ simbolo = simb_while;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME("while ");
+ return WHILE;
+ }
+ YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 188 "compilador.l"
+{ simbolo = simb_do;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" do ");
+ return DO;
+ }
+ YY_BREAK
+case 28:
+YY_RULE_SETUP
+#line 194 "compilador.l"
+{ simbolo = simb_or;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" or ");
+ return OR;
+ }
+ YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 200 "compilador.l"
+{ simbolo = simb_div;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" div ");
+ return DIV;
+ }
+ YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 206 "compilador.l"
+{ simbolo = simb_and;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" and ");
+ return AND;
+ }
+ YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 212 "compilador.l"
+{ simbolo = simb_not;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" not ");
+ return NOT;
+ }
+ YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 218 "compilador.l"
+{ simbolo = simb_igual;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" igual ");
+ return IGUAL;
+ }
+ YY_BREAK
+case 33:
+YY_RULE_SETUP
+#line 224 "compilador.l"
+{ simbolo = simb_diferente;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" diferente ");
+ return DIFERENTE;
+ }
+ YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 230 "compilador.l"
+{ simbolo = simb_menor_igual;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" menor_igual ");
+ return MENOR_IGUAL;
+ }
+ YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 236 "compilador.l"
+{ simbolo = simb_maior_igual;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" maior_igual ");
+ return MAIOR_IGUAL;
+ }
+ YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 242 "compilador.l"
+{ simbolo = simb_menor;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" menor ");
+ return MENOR;
+ }
+ YY_BREAK
+case 37:
+YY_RULE_SETUP
+#line 248 "compilador.l"
+{ simbolo = simb_maior;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" maior ");
+ return MAIOR;
+ }
+ YY_BREAK
+case 38:
+YY_RULE_SETUP
+#line 254 "compilador.l"
+{ simbolo = simb_mais;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" mais ");
+ return MAIS;
+ }
+ YY_BREAK
+case 39:
+YY_RULE_SETUP
+#line 260 "compilador.l"
+{ simbolo = simb_menos;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" menos ");
+ return MENOS;
+ }
+ YY_BREAK
+case 40:
+YY_RULE_SETUP
+#line 266 "compilador.l"
+{ simbolo = simb_asterisco;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" asterisco ");
+ return ASTERISCO;
+ }
+ YY_BREAK
+case 41:
+YY_RULE_SETUP
+#line 272 "compilador.l"
+{ simbolo = simb_numero;
+ strncpy (token, yytext,TAM_TOKEN);
+ IMPRIME(" numero ");
+ return NUMERO;
+ }
+ YY_BREAK
+case 42:
+YY_RULE_SETUP
+#line 278 "compilador.l"
+{ simbolo = simb_identificador;
+ strncpy (token, yytext, TAM_TOKEN);
+ IMPRIME(" ident ");
+ return IDENT;
+ }
+ YY_BREAK
+case 43:
+YY_RULE_SETUP
+#line 284 "compilador.l"
+ECHO;
+ YY_BREAK
+#line 1190 "lex.yy.c"
+case YY_STATE_EOF(INITIAL):
+ yyterminate();
+
+ case YY_END_OF_BUFFER:
+ {
+ /* Amount of text matched not including the EOB char. */
+ int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
+
+ /* Undo the effects of YY_DO_BEFORE_ACTION. */
+ *yy_cp = (yy_hold_char);
+ YY_RESTORE_YY_MORE_OFFSET
+
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+ {
+ /* We're scanning a new file or input source. It's
+ * possible that this happened because the user
+ * just pointed yyin at a new source and called
+ * yylex(). If so, then we have to assure
+ * consistency between YY_CURRENT_BUFFER and our
+ * globals. Here is the right place to do so, because
+ * this is the first action (other than possibly a
+ * back-up) that will match for the new input source.
+ */
+ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+ }
+
+ /* Note that here we test for yy_c_buf_p "<=" to the position
+ * of the first EOB in the buffer, since yy_c_buf_p will
+ * already have been incremented past the NUL character
+ * (since all states make transitions on EOB to the
+ * end-of-buffer state). Contrast this with the test
+ * in input().
+ */
+ if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+ { /* This was really a NUL. */
+ yy_state_type yy_next_state;
+
+ (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state( );
+
+ /* Okay, we're now positioned to make the NUL
+ * transition. We couldn't have
+ * yy_get_previous_state() go ahead and do it
+ * for us because it doesn't know how to deal
+ * with the possibility of jamming (and we don't
+ * want to build jamming into it because then it
+ * will run more slowly).
+ */
+
+ yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+ yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+
+ if ( yy_next_state )
+ {
+ /* Consume the NUL. */
+ yy_cp = ++(yy_c_buf_p);
+ yy_current_state = yy_next_state;
+ goto yy_match;
+ }
+
+ else
+ {
+ yy_cp = (yy_c_buf_p);
+ goto yy_find_action;
+ }
+ }
+
+ else switch ( yy_get_next_buffer( ) )
+ {
+ case EOB_ACT_END_OF_FILE:
+ {
+ (yy_did_buffer_switch_on_eof) = 0;
+
+ if ( yywrap( ) )
+ {
+ /* Note: because we've taken care in
+ * yy_get_next_buffer() to have set up
+ * yytext, we can now set up
+ * yy_c_buf_p so that if some total
+ * hoser (like flex itself) wants to
+ * call the scanner after we return the
+ * YY_NULL, it'll still work - another
+ * YY_NULL will get returned.
+ */
+ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
+
+ yy_act = YY_STATE_EOF(YY_START);
+ goto do_action;
+ }
+
+ else
+ {
+ if ( ! (yy_did_buffer_switch_on_eof) )
+ YY_NEW_FILE;
+ }
+ break;
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ (yy_c_buf_p) =
+ (yytext_ptr) + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state( );
+
+ yy_cp = (yy_c_buf_p);
+ yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+ goto yy_match;
+
+ case EOB_ACT_LAST_MATCH:
+ (yy_c_buf_p) =
+ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+
+ yy_current_state = yy_get_previous_state( );
+
+ yy_cp = (yy_c_buf_p);
+ yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+ goto yy_find_action;
+ }
+ break;
+ }
+
+ default:
+ YY_FATAL_ERROR(
+ "fatal flex scanner internal error--no action found" );
+ } /* end of action switch */
+ } /* end of scanning one token */
+ } /* end of user's declarations */
+} /* end of yylex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ * EOB_ACT_LAST_MATCH -
+ * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ * EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (void)
+{
+ char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+ char *source = (yytext_ptr);
+ int number_to_move, i;
+ int ret_val;
+
+ if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+ YY_FATAL_ERROR(
+ "fatal flex scanner internal error--end of buffer missed" );
+
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+ { /* Don't try to fill the buffer, so this is an EOF. */
+ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
+ {
+ /* We matched a single character, the EOB, so
+ * treat this as a final EOF.
+ */
+ return EOB_ACT_END_OF_FILE;
+ }
+
+ else
+ {
+ /* We matched some text prior to the EOB, first
+ * process it.
+ */
+ return EOB_ACT_LAST_MATCH;
+ }
+ }
+
+ /* Try to read more data. */
+
+ /* First move last chars to start of buffer. */
+ number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
+
+ for ( i = 0; i < number_to_move; ++i )
+ *(dest++) = *(source++);
+
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+ /* don't do the read, it's not guaranteed to return an EOF,
+ * just force an EOF
+ */
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
+
+ else
+ {
+ int num_to_read =
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+ while ( num_to_read <= 0 )
+ { /* Not enough room in the buffer - grow it. */
+
+ /* just a shorter name for the current buffer */
+ YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+ int yy_c_buf_p_offset =
+ (int) ((yy_c_buf_p) - b->yy_ch_buf);
+
+ if ( b->yy_is_our_buffer )
+ {
+ int new_size = b->yy_buf_size * 2;
+
+ if ( new_size <= 0 )
+ b->yy_buf_size += b->yy_buf_size / 8;
+ else
+ b->yy_buf_size *= 2;
+
+ b->yy_ch_buf = (char *)
+ /* Include room in for 2 EOB chars. */
+ yyrealloc( (void *) b->yy_ch_buf,
+ (yy_size_t) (b->yy_buf_size + 2) );
+ }
+ else
+ /* Can't grow it, we don't own it. */
+ b->yy_ch_buf = NULL;
+
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR(
+ "fatal error - scanner input buffer overflow" );
+
+ (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+ num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+ number_to_move - 1;
+
+ }
+
+ if ( num_to_read > YY_READ_BUF_SIZE )
+ num_to_read = YY_READ_BUF_SIZE;
+
+ /* Read in more data. */
+ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+ (yy_n_chars), num_to_read );
+
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+ }
+
+ if ( (yy_n_chars) == 0 )
+ {
+ if ( number_to_move == YY_MORE_ADJ )
+ {
+ ret_val = EOB_ACT_END_OF_FILE;
+ yyrestart( yyin );
+ }
+
+ else
+ {
+ ret_val = EOB_ACT_LAST_MATCH;
+ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+ YY_BUFFER_EOF_PENDING;
+ }
+ }
+
+ else
+ ret_val = EOB_ACT_CONTINUE_SCAN;
+
+ if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+ /* Extend the array by 50%, plus the number we really need. */
+ int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+ (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
+ if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+ /* "- 2" to take care of EOB's */
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+ }
+
+ (yy_n_chars) += number_to_move;
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+ (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+ return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+ static yy_state_type yy_get_previous_state (void)
+{
+ yy_state_type yy_current_state;
+ char *yy_cp;
+
+ yy_current_state = (yy_start);
+
+ for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+ {
+ YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+ if ( yy_accept[yy_current_state] )
+ {
+ (yy_last_accepting_state) = yy_current_state;
+ (yy_last_accepting_cpos) = yy_cp;
+ }
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 115 )
+ yy_c = yy_meta[yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+ }
+
+ return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ * next_state = yy_try_NUL_trans( current_state );
+ */
+ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
+{
+ int yy_is_jam;
+ char *yy_cp = (yy_c_buf_p);
+
+ YY_CHAR yy_c = 1;
+ if ( yy_accept[yy_current_state] )
+ {
+ (yy_last_accepting_state) = yy_current_state;
+ (yy_last_accepting_cpos) = yy_cp;
+ }
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 115 )
+ yy_c = yy_meta[yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+ yy_is_jam = (yy_current_state == 114);
+
+ return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+ static void yyunput (int c, char * yy_bp )
+{
+ char *yy_cp;
+
+ yy_cp = (yy_c_buf_p);
+
+ /* undo effects of setting up yytext */
+ *yy_cp = (yy_hold_char);
+
+ if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+ { /* need to shift things up to make room */
+ /* +2 for EOB chars. */
+ int number_to_move = (yy_n_chars) + 2;
+ char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+ char *source =
+ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+ while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+ *--dest = *--source;
+
+ yy_cp += (int) (dest - source);
+ yy_bp += (int) (dest - source);
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+ (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+ if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+ YY_FATAL_ERROR( "flex scanner push-back overflow" );
+ }
+
+ *--yy_cp = (char) c;
+
+ (yytext_ptr) = yy_bp;
+ (yy_hold_char) = *yy_cp;
+ (yy_c_buf_p) = yy_cp;
+}
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+ static int yyinput (void)
+#else
+ static int input (void)
+#endif
+
+{
+ int c;
+
+ *(yy_c_buf_p) = (yy_hold_char);
+
+ if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+ {
+ /* yy_c_buf_p now points to the character we want to return.
+ * If this occurs *before* the EOB characters, then it's a
+ * valid NUL; if not, then we've hit the end of the buffer.
+ */
+ if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+ /* This was really a NUL. */
+ *(yy_c_buf_p) = '\0';
+
+ else
+ { /* need more input */
+ int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
+ ++(yy_c_buf_p);
+
+ switch ( yy_get_next_buffer( ) )
+ {
+ case EOB_ACT_LAST_MATCH:
+ /* This happens because yy_g_n_b()
+ * sees that we've accumulated a
+ * token and flags that we need to
+ * try matching the token before
+ * proceeding. But for input(),
+ * there's no matching to consider.
+ * So convert the EOB_ACT_LAST_MATCH
+ * to EOB_ACT_END_OF_FILE.
+ */
+
+ /* Reset buffer status. */
+ yyrestart( yyin );
+
+ /*FALLTHROUGH*/
+
+ case EOB_ACT_END_OF_FILE:
+ {
+ if ( yywrap( ) )
+ return 0;
+
+ if ( ! (yy_did_buffer_switch_on_eof) )
+ YY_NEW_FILE;
+#ifdef __cplusplus
+ return yyinput();
+#else
+ return input();
+#endif
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ (yy_c_buf_p) = (yytext_ptr) + offset;
+ break;
+ }
+ }
+ }
+
+ c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
+ *(yy_c_buf_p) = '\0'; /* preserve yytext */
+ (yy_hold_char) = *++(yy_c_buf_p);
+
+ return c;
+}
+#endif /* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ *
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+ void yyrestart (FILE * input_file )
+{
+
+ if ( ! YY_CURRENT_BUFFER ){
+ yyensure_buffer_stack ();
+ YY_CURRENT_BUFFER_LVALUE =
+ yy_create_buffer( yyin, YY_BUF_SIZE );
+ }
+
+ yy_init_buffer( YY_CURRENT_BUFFER, input_file );
+ yy_load_buffer_state( );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ *
+ */
+ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
+{
+
+ /* TODO. We should be able to replace this entire function body
+ * with
+ * yypop_buffer_state();
+ * yypush_buffer_state(new_buffer);
+ */
+ yyensure_buffer_stack ();
+ if ( YY_CURRENT_BUFFER == new_buffer )
+ return;
+
+ if ( YY_CURRENT_BUFFER )
+ {
+ /* Flush out information for old buffer. */
+ *(yy_c_buf_p) = (yy_hold_char);
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+ }
+
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+ yy_load_buffer_state( );
+
+ /* We don't actually know whether we did this switch during
+ * EOF (yywrap()) processing, but the only time this flag
+ * is looked at is after yywrap() is called, so it's safe
+ * to go ahead and always set it.
+ */
+ (yy_did_buffer_switch_on_eof) = 1;
+}
+
+static void yy_load_buffer_state (void)
+{
+ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+ (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+ (yy_hold_char) = *(yy_c_buf_p);
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ *
+ * @return the allocated buffer state.
+ */
+ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
+{
+ YY_BUFFER_STATE b;
+
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+ b->yy_buf_size = size;
+
+ /* yy_ch_buf has to be 2 characters longer than the size given because
+ * we need to put in 2 end-of-buffer characters.
+ */
+ b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+ b->yy_is_our_buffer = 1;
+
+ yy_init_buffer( b, file );
+
+ return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ *
+ */
+ void yy_delete_buffer (YY_BUFFER_STATE b )
+{
+
+ if ( ! b )
+ return;
+
+ if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+ if ( b->yy_is_our_buffer )
+ yyfree( (void *) b->yy_ch_buf );
+
+ yyfree( (void *) b );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
+
+{
+ int oerrno = errno;
+
+ yy_flush_buffer( b );
+
+ b->yy_input_file = file;
+ b->yy_fill_buffer = 1;
+
+ /* If b is the current buffer, then yy_init_buffer was _probably_
+ * called from yyrestart() or through yy_get_next_buffer.
+ * In that case, we don't want to reset the lineno or column.
+ */
+ if (b != YY_CURRENT_BUFFER){
+ b->yy_bs_lineno = 1;
+ b->yy_bs_column = 0;
+ }
+
+ b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+
+ errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ *
+ */
+ void yy_flush_buffer (YY_BUFFER_STATE b )
+{
+ if ( ! b )
+ return;
+
+ b->yy_n_chars = 0;
+
+ /* We always need two end-of-buffer characters. The first causes
+ * a transition to the end-of-buffer state. The second causes
+ * a jam in that state.
+ */
+ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+ b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+ b->yy_buf_pos = &b->yy_ch_buf[0];
+
+ b->yy_at_bol = 1;
+ b->yy_buffer_status = YY_BUFFER_NEW;
+
+ if ( b == YY_CURRENT_BUFFER )
+ yy_load_buffer_state( );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ * the current state. This function will allocate the stack
+ * if necessary.
+ * @param new_buffer The new state.
+ *
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+ if (new_buffer == NULL)
+ return;
+
+ yyensure_buffer_stack();
+
+ /* This block is copied from yy_switch_to_buffer. */
+ if ( YY_CURRENT_BUFFER )
+ {
+ /* Flush out information for old buffer. */
+ *(yy_c_buf_p) = (yy_hold_char);
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+ }
+
+ /* Only push if top exists. Otherwise, replace top. */
+ if (YY_CURRENT_BUFFER)
+ (yy_buffer_stack_top)++;
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+ /* copied from yy_switch_to_buffer. */
+ yy_load_buffer_state( );
+ (yy_did_buffer_switch_on_eof) = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ * The next element becomes the new top.
+ *
+ */
+void yypop_buffer_state (void)
+{
+ if (!YY_CURRENT_BUFFER)
+ return;
+
+ yy_delete_buffer(YY_CURRENT_BUFFER );
+ YY_CURRENT_BUFFER_LVALUE = NULL;
+ if ((yy_buffer_stack_top) > 0)
+ --(yy_buffer_stack_top);
+
+ if (YY_CURRENT_BUFFER) {
+ yy_load_buffer_state( );
+ (yy_did_buffer_switch_on_eof) = 1;
+ }
+}
+
+/* Allocates the stack if it does not exist.
+ * Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (void)
+{
+ yy_size_t num_to_alloc;
+
+ if (!(yy_buffer_stack)) {
+
+ /* First allocation is just for 2 elements, since we don't know if this
+ * scanner will even need a stack. We use 2 instead of 1 to avoid an
+ * immediate realloc on the next call.
+ */
+ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+ (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
+ (num_to_alloc * sizeof(struct yy_buffer_state*)
+ );
+ if ( ! (yy_buffer_stack) )
+ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+ memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+ (yy_buffer_stack_max) = num_to_alloc;
+ (yy_buffer_stack_top) = 0;
+ return;
+ }
+
+ if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+ /* Increase the buffer to prepare for a possible push. */
+ yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+ num_to_alloc = (yy_buffer_stack_max) + grow_size;
+ (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
+ ((yy_buffer_stack),
+ num_to_alloc * sizeof(struct yy_buffer_state*)
+ );
+ if ( ! (yy_buffer_stack) )
+ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+ /* zero only the new slots.*/
+ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+ (yy_buffer_stack_max) = num_to_alloc;
+ }
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ *
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
+{
+ YY_BUFFER_STATE b;
+
+ if ( size < 2 ||
+ base[size-2] != YY_END_OF_BUFFER_CHAR ||
+ base[size-1] != YY_END_OF_BUFFER_CHAR )
+ /* They forgot to leave room for the EOB's. */
+ return NULL;
+
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+ b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
+ b->yy_buf_pos = b->yy_ch_buf = base;
+ b->yy_is_our_buffer = 0;
+ b->yy_input_file = NULL;
+ b->yy_n_chars = b->yy_buf_size;
+ b->yy_is_interactive = 0;
+ b->yy_at_bol = 1;
+ b->yy_fill_buffer = 0;
+ b->yy_buffer_status = YY_BUFFER_NEW;
+
+ yy_switch_to_buffer( b );
+
+ return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ *
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ * yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr )
+{
+
+ return yy_scan_bytes( yystr, (int) strlen(yystr) );
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ *
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
+{
+ YY_BUFFER_STATE b;
+ char *buf;
+ yy_size_t n;
+ int i;
+
+ /* Get memory for full buffer, including space for trailing EOB's. */
+ n = (yy_size_t) (_yybytes_len + 2);
+ buf = (char *) yyalloc( n );
+ if ( ! buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+ for ( i = 0; i < _yybytes_len; ++i )
+ buf[i] = yybytes[i];
+
+ buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+ b = yy_scan_buffer( buf, n );
+ if ( ! b )
+ YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+ /* It's okay to grow etc. this buffer, and we should throw it
+ * away when we're done.
+ */
+ b->yy_is_our_buffer = 1;
+
+ return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (const char* msg )
+{
+ fprintf( stderr, "%s\n", msg );
+ exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+ do \
+ { \
+ /* Undo effects of setting up yytext. */ \
+ int yyless_macro_arg = (n); \
+ YY_LESS_LINENO(yyless_macro_arg);\
+ yytext[yyleng] = (yy_hold_char); \
+ (yy_c_buf_p) = yytext + yyless_macro_arg; \
+ (yy_hold_char) = *(yy_c_buf_p); \
+ *(yy_c_buf_p) = '\0'; \
+ yyleng = yyless_macro_arg; \
+ } \
+ while ( 0 )
+
+/* Accessor methods (get/set functions) to struct members. */
+
+/** Get the current line number.
+ *
+ */
+int yyget_lineno (void)
+{
+
+ return yylineno;
+}
+
+/** Get the input stream.
+ *
+ */
+FILE *yyget_in (void)
+{
+ return yyin;
+}
+
+/** Get the output stream.
+ *
+ */
+FILE *yyget_out (void)
+{
+ return yyout;
+}
+
+/** Get the length of the current token.
+ *
+ */
+int yyget_leng (void)
+{
+ return yyleng;
+}
+
+/** Get the current token.
+ *
+ */
+
+char *yyget_text (void)
+{
+ return yytext;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ *
+ */
+void yyset_lineno (int _line_number )
+{
+
+ yylineno = _line_number;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ *
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE * _in_str )
+{
+ yyin = _in_str ;
+}
+
+void yyset_out (FILE * _out_str )
+{
+ yyout = _out_str ;
+}
+
+int yyget_debug (void)
+{
+ return yy_flex_debug;
+}
+
+void yyset_debug (int _bdebug )
+{
+ yy_flex_debug = _bdebug ;
+}
+
+static int yy_init_globals (void)
+{
+ /* Initialization is the same as for the non-reentrant scanner.
+ * This function is called from yylex_destroy(), so don't allocate here.
+ */
+
+ (yy_buffer_stack) = NULL;
+ (yy_buffer_stack_top) = 0;
+ (yy_buffer_stack_max) = 0;
+ (yy_c_buf_p) = NULL;
+ (yy_init) = 0;
+ (yy_start) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+ yyin = stdin;
+ yyout = stdout;
+#else
+ yyin = NULL;
+ yyout = NULL;
+#endif
+
+ /* For future reference: Set errno on error, since we are called by
+ * yylex_init()
+ */
+ return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy (void)
+{
+
+ /* Pop the buffer stack, destroying each element. */
+ while(YY_CURRENT_BUFFER){
+ yy_delete_buffer( YY_CURRENT_BUFFER );
+ YY_CURRENT_BUFFER_LVALUE = NULL;
+ yypop_buffer_state();
+ }
+
+ /* Destroy the stack itself. */
+ yyfree((yy_buffer_stack) );
+ (yy_buffer_stack) = NULL;
+
+ /* Reset the globals. This is important in a non-reentrant scanner so the next time
+ * yylex() is called, initialization will occur. */
+ yy_init_globals( );
+
+ return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n )
+{
+
+ int i;
+ for ( i = 0; i < n; ++i )
+ s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s )
+{
+ int n;
+ for ( n = 0; s[n]; ++n )
+ ;
+
+ return n;
+}
+#endif
+
+void *yyalloc (yy_size_t size )
+{
+ return malloc(size);
+}
+
+void *yyrealloc (void * ptr, yy_size_t size )
+{
+
+ /* The cast to (char *) in the following accommodates both
+ * implementations that use char* generic pointers, and those
+ * that use void* generic pointers. It works with the latter
+ * because both ANSI C and C++ allow castless assignment from
+ * any pointer type to void*, and deal with argument conversions
+ * as though doing an assignment.
+ */
+ return realloc(ptr, size);
+}
+
+void yyfree (void * ptr )
+{
+ free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 284 "compilador.l"
+
+
diff --git a/stack/stack.o b/stack/stack.o
new file mode 100644
index 0000000000000000000000000000000000000000..5aa85557f8e7200312cb4b8bf4bffa3dbbe4b327
GIT binary patch
literal 3200
zcmb<-^>JfjWMqH=Mg}_u1P><4z`($XU^{@B4h(z@ybPcD<$i^FbUyXyto`B9?fS#x
zI9L+IJnp~&Vo!)Y3|G|rM!}=A_Jv1h=>w1E+6N3J#rp*q7#LoF)OmEef=qbf(Rm!g
zZ$7{XXLlX~nds3e0H(SbJi0?)cywNa%Xhmz@aTp}b_Q^GfVrVRAnG4<J8<*{FoFa-
z12|qYPB@9jL0KSW9^DKctp`ftU~GuXet2|4jRrddV(fpA8i<uYATB_2*AI|kFfV}u
z2+GFpj^^4I3?)1s-L5Y{+FB2k3VQU~f<gxzBrls87#NTRP}!y+g;1d#AU0SNQ~<(;
z8r<pn<Fz_0C_9fql_2Q>Ikek>0~{yKwLch2FG1CSjX8OkAs{m+BT*r>xa9Ccg|ft|
z%tVF!QiZ(3i}MvS^D>h&6LT`F5>pcO7`VU+tr&Ev4j4R3Qgaz<6jXH$4T=?NxEL7R
zot>=|G(wX~^GZq;EcHzE40H`k!92q{BLh7H6FnnMh&TfS3j+fKDCw~>Ffh3Lg)%TP
zFdP7hF@wU5fq_8;N;6gkF)&sLFiP{Vb4*}lV31*eV34#bh;Zc-Xk&8bWsBiq2PJoq
zybVa4fq`Knh=$2Cb$}Is<YPeM3=9k%AQ~=T50|e2i8C-T>;%zp`3+!skPtQu%CjsC
zAOB;MW5%AN8JHPhzD3o=3=SPsF%XZL0Tfyw7Aj_DU`G{z@|YPwAp+$fQOwAN35qxy
z5)Z-z6+1#m?gxiCC>Jm=Fo48id~jGZFfd3#;}xPCK^ou?H^(7vheO;IYVS6v(cm~_
zU|<Nqp*|F<-VPK&usCI4U`WEDJ{^ZRLvcxBa<*PF10s9HgM}F4-F^I>9DU;b-Q0p*
zL*hdmoqSy58FCYIa`KZIic5-eQu9DmazQ0SN@{UxZUHFgGNcuyrZVK_7nc+zLd_{C
zEh%OwD9X$$Nn>DOaD(~}lqYx@7#RNihk!67aXut*kbgi@=<1t5f((%S#*d_43K||D
z^~mCyNaBJ>>P>Nor$EJ-7#P5*6XwoLs5r=cVI*@(q2e(0Dp2=TLB-M4H$uf>>UE&%
z+o0m;>U*K$F!l9N^;6KqTcG0epyD8NKxGch{Y#<ZFmqt`u7Zk#)Fb=r1XLWR9%lX}
zs5nSHviWbI;xP3v^FKnxLF$psSAe<~q#lH!Tn0#6fB{r~f-x*VCO{Q{)PgW9zciqU
z!}0}#UU6k^Nn#R%UU5kggwBAmic)hD^-5AJN*MG~5=#;p^pc8;8T5+sA)Ms=+}zZ>
z5(d4z{E}2XcfU|wNWOsZ)ALI83X1XzQj1C|8T7y=rDnvZ6(#1TLR~@`1qv5XkfE1c
zuyFYfl0>osjmsbn%^NWFFr^Yu0|h{V$H2hA&A<RI1z{zs1XQ6KR2;n|H;3wjDuYw#
z_JiUbWG1=#4Wag<TW0|km<+cW!T{L?VL?bssD4oS3=x5lr=j{m?t_RxNSOO!v=dZ6
zL>57Qhw4X&Kv*z+5FP_V5Ca3a_Ci<w11bQDUzl1Djqd&|sQpmoASGZd0S(X@U><@%
z*AGgCpuC12{~Az*uzUoHe^6Zr6=s0NKgd7mc7tr&0JZ-INC5)_0}lfO0~Z4WyheuU
r2bl>~3epD0E1*?<9$W;%fEowkFfcHH%4lr*JD?6Nfvbct(DefVb8G5m
literal 0
HcmV?d00001
diff --git a/ts/ts.c b/ts/ts.c
index 0d488ff..97491ea 100644
--- a/ts/ts.c
+++ b/ts/ts.c
@@ -67,6 +67,74 @@ simb_t *topo(ts_t *ts){
return ts->topo;
}
+int retira_vs_pf(ts_t *ts) {
+ if (ts == NULL || ts->topo == NULL) {
+ return 0; // Nenhum elemento a ser removido
+ }
+
+ int i; // Contador de elementos removidos
+ simb_t *temp = ts->topo;
+ while (ts->topo != NULL && (ts->topo->categ == VS || ts->topo->categ == PF)) {
+ temp = ts->topo;
+ ts->topo = ts->topo->prox;
+ //free the intern stuff
+ if (temp->categ == VS) {
+ free(temp->ident);
+ } else if (temp->categ == PF) {
+ free(temp->ident);
+ }
+ free(temp);
+ ts->tam--;
+ }
+
+ //retorna novo deslocamento
+ while (temp != NULL) {
+ if (temp->categ == VS || temp->categ == PF) {
+ return temp->info.vs.desloc + 1;
+ }
+ temp = temp->prox;
+ }
+ return 0;
+}
+
+int retira_pr_fun(ts_t *ts) {
+ if (ts == NULL || ts->topo == NULL) {
+ return 0; // Nenhum elemento a ser removido
+ }
+
+ int i; // Contador de elementos removidos
+ simb_t *temp = ts->topo;
+ while (ts->topo != NULL && (ts->topo->categ == PR || ts->topo->categ == FUN)) {
+ temp = ts->topo;
+ ts->topo = ts->topo->prox;
+ //free the intern stuff
+ if (temp->categ == PR) {
+ free(temp->ident);
+ for (int i = 0; i < temp->info.pr.quant; i++) {
+ free(temp->info.pr.param[i]);
+ }
+ free(temp->info.pr.param);
+ } else if (temp->categ == FUN) {
+ free(temp->ident);
+ for (int i = 0; i < temp->info.fun.quant; i++) {
+ free(temp->info.fun.param[i]);
+ }
+ free(temp->info.fun.param);
+ }
+ free(temp);
+ ts->tam--;
+ }
+
+ //retorna novo deslocamento
+ while (temp != NULL) {
+ if (temp->categ == VS || temp->categ == PF) {
+ return temp->info.vs.desloc + 1;
+ }
+ temp = temp->prox;
+ }
+ return 0;
+}
+
int retira(int n, ts_t *ts) {
if (ts == NULL || ts->topo == NULL) {
return 0; // Nenhum elemento a ser removido
diff --git a/ts/ts.h b/ts/ts.h
index 8c2c536..30aa963 100644
--- a/ts/ts.h
+++ b/ts/ts.h
@@ -71,6 +71,10 @@ simb_t *topo(ts_t *ts);
int retira(int n, ts_t *ts);
+int retira_vs_pf(ts_t *ts);
+
+int retira_pr_fun(ts_t *ts);
+
void atualiza_tipo(int n, int tipo, ts_t *ts);
void adiciona_param(char *ident, int n, ts_t *ts);
diff --git a/ts/ts.o b/ts/ts.o
new file mode 100644
index 0000000000000000000000000000000000000000..babaf3b5062470db8121b6d0b67998e38bbdd582
GIT binary patch
literal 11840
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%0AUW2
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
Z1&{y~qj`q`RDEOB4_)sKA8^K@9{>&1@$vuw
literal 0
HcmV?d00001
--
GitLab