From b153b9acab69298369d50a1b9112422b7a84aeb9 Mon Sep 17 00:00:00 2001
From: hm19 <hm19@inf.ufpr.br>
Date: Tue, 3 Dec 2024 12:00:09 -0300
Subject: [PATCH] deslocamento funcao
---
MEPA | 8 +-
compilador | Bin 0 -> 54568 bytes
compilador.o | Bin 0 -> 2736 bytes
compilador.tab.c | 2425 ++++++++++++++++++++++++++++++++++++++++++++++
compilador.tab.h | 107 ++
lex.yy.c | 2196 +++++++++++++++++++++++++++++++++++++++++
stack/stack.o | Bin 0 -> 3200 bytes
ts/ts.c | 6 +-
ts/ts.o | Bin 0 -> 10696 bytes
9 files changed, 4737 insertions(+), 5 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/MEPA b/MEPA
index 1b8ad2f..a4aa486 100644
--- a/MEPA
+++ b/MEPA
@@ -10,14 +10,14 @@ R02: NADA
CRCT 1
ARMI 1,-5
DMEM 1
- RTPR 1,2
R00: NADA
- CRCT 8
- ARMZ 0,0
+ AMEM 1
CREN 0,0
CRCT 2
CRCT 3
SOMA
- CHPR R01,2
+ CHPR R01,1
+ CRVL 1,-6
+ ARMZ 0,0
DMEM 1
PARA
diff --git a/compilador b/compilador
new file mode 100755
index 0000000000000000000000000000000000000000..5d43220309af6300d59e77a2d3f4bfa79b98b5f0
GIT binary patch
literal 54568
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
MF#JOZfm!JK0iZb5ivR!s
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..3febb65
--- /dev/null
+++ b/compilador.tab.c
@@ -0,0 +1,2425 @@
+/* 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, 91, 92, 95,
+ 99, 99, 100, 103, 104, 108, 111, 108, 119, 132,
+ 141, 152, 153, 157, 159, 160, 165, 189, 165, 208,
+ 232, 236, 208, 244, 245, 243, 253, 256, 257, 261,
+ 260, 270, 270, 278, 279, 282, 292, 295, 296, 297,
+ 300, 301, 304, 305, 306, 307, 308, 309, 312, 312,
+ 316, 317, 320, 320, 343, 343, 386, 389, 393, 392,
+ 405, 405, 419, 422, 423, 426, 435, 438, 441, 446,
+ 449, 452, 455, 458, 461, 464, 467, 473, 479, 482,
+ 485, 488, 491, 491, 522, 533, 535, 542, 535, 568,
+ 575, 577, 580, 580
+};
+#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(desloc,ts);
+ geraCodigo(NULL,buffer);
+ if (nivel_lexico > 0)
+ nivel_lexico += 1;
+ }
+#line 1541 "compilador.tab.c"
+ break;
+
+ case 10:
+#line 99 "compilador.y"
+ { }
+#line 1547 "compilador.tab.c"
+ break;
+
+ case 15:
+#line 108 "compilador.y"
+ { num_vars = 0; }
+#line 1553 "compilador.tab.c"
+ break;
+
+ case 16:
+#line 111 "compilador.y"
+ {
+ char buffer[50];
+ sprintf(buffer, "AMEM %d", num_vars);
+ geraCodigo(NULL, buffer);
+ }
+#line 1563 "compilador.tab.c"
+ break;
+
+ case 18:
+#line 120 "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 1578 "compilador.tab.c"
+ break;
+
+ case 19:
+#line 133 "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 1591 "compilador.tab.c"
+ break;
+
+ case 20:
+#line 141 "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 1605 "compilador.tab.c"
+ break;
+
+ case 26:
+#line 165 "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 1632 "compilador.tab.c"
+ break;
+
+ case 27:
+#line 189 "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(n,ts);
+ mostra_ts(ts);
+ }
+#line 1651 "compilador.tab.c"
+ break;
+
+ case 29:
+#line 208 "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 1679 "compilador.tab.c"
+ break;
+
+ case 30:
+#line 232 "compilador.y"
+ {
+ num_vars = 1;
+ }
+#line 1687 "compilador.tab.c"
+ break;
+
+ case 31:
+#line 236 "compilador.y"
+ {
+ // Retorna ao nível léxico anterior e mantém o deslocamento atualizado
+ nivel_lexico -= 1;
+ }
+#line 1696 "compilador.tab.c"
+ break;
+
+ case 33:
+#line 244 "compilador.y"
+ {num_param = 0;}
+#line 1702 "compilador.tab.c"
+ break;
+
+ case 34:
+#line 245 "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 1714 "compilador.tab.c"
+ break;
+
+ case 39:
+#line 261 "compilador.y"
+ {
+ num_vars = 0;
+ val_ou_ref = REF;
+ }
+#line 1723 "compilador.tab.c"
+ break;
+
+ case 40:
+#line 266 "compilador.y"
+ {
+ num_param += num_vars;
+ val_ou_ref = VLR;
+ }
+#line 1732 "compilador.tab.c"
+ break;
+
+ case 41:
+#line 270 "compilador.y"
+ {
+ num_vars = 0;
+ val_ou_ref = VLR;
+ }
+#line 1741 "compilador.tab.c"
+ break;
+
+ case 42:
+#line 275 "compilador.y"
+ {num_param += num_vars;}
+#line 1747 "compilador.tab.c"
+ break;
+
+ case 45:
+#line 282 "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 1760 "compilador.tab.c"
+ break;
+
+ case 58:
+#line 312 "compilador.y"
+ {l_elem = busca(token, ts);}
+#line 1766 "compilador.tab.c"
+ break;
+
+ case 62:
+#line 320 "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 1782 "compilador.tab.c"
+ break;
+
+ case 63:
+#line 330 "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 1797 "compilador.tab.c"
+ break;
+
+ case 64:
+#line 343 "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 1813 "compilador.tab.c"
+ break;
+
+ case 65:
+#line 357 "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 1845 "compilador.tab.c"
+ break;
+
+ case 68:
+#line 393 "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 1857 "compilador.tab.c"
+ break;
+
+ case 69:
+#line 401 "compilador.y"
+ {
+ num_param++; // Incrementa para cada parâmetro real
+ val_ou_ref = VLR;
+ }
+#line 1866 "compilador.tab.c"
+ break;
+
+ case 70:
+#line 405 "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 1878 "compilador.tab.c"
+ break;
+
+ case 71:
+#line 413 "compilador.y"
+ {
+ num_param++; // Conta o primeiro parâmetro real
+ val_ou_ref = VLR;
+ }
+#line 1887 "compilador.tab.c"
+ break;
+
+ case 75:
+#line 426 "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 1899 "compilador.tab.c"
+ break;
+
+ case 77:
+#line 438 "compilador.y"
+ {
+ geraCodigo(NULL,"IMPR");
+ }
+#line 1907 "compilador.tab.c"
+ break;
+
+ case 78:
+#line 441 "compilador.y"
+ {
+ geraCodigo(NULL,"IMPR");
+ }
+#line 1915 "compilador.tab.c"
+ break;
+
+ case 79:
+#line 446 "compilador.y"
+ {
+ geraCodigo(NULL, "CMIG"); // Adiciona operação de cmig
+ }
+#line 1923 "compilador.tab.c"
+ break;
+
+ case 80:
+#line 449 "compilador.y"
+ {
+ geraCodigo(NULL, "CMDG"); // Adiciona operação de cmdg
+ }
+#line 1931 "compilador.tab.c"
+ break;
+
+ case 81:
+#line 452 "compilador.y"
+ {
+ geraCodigo(NULL, "CMME"); // Adiciona operação de cmme
+ }
+#line 1939 "compilador.tab.c"
+ break;
+
+ case 82:
+#line 455 "compilador.y"
+ {
+ geraCodigo(NULL, "CMEG"); // Adiciona operação de cmeg
+ }
+#line 1947 "compilador.tab.c"
+ break;
+
+ case 83:
+#line 458 "compilador.y"
+ {
+ geraCodigo(NULL, "CMMA"); // Adiciona operação de cmma
+ }
+#line 1955 "compilador.tab.c"
+ break;
+
+ case 84:
+#line 461 "compilador.y"
+ {
+ geraCodigo(NULL, "CMAG"); // Adiciona operação de cmag
+ }
+#line 1963 "compilador.tab.c"
+ break;
+
+ case 86:
+#line 467 "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 1974 "compilador.tab.c"
+ break;
+
+ case 87:
+#line 473 "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 1985 "compilador.tab.c"
+ break;
+
+ case 89:
+#line 482 "compilador.y"
+ {
+ geraCodigo(NULL, "MULT"); // Adiciona operação de mult
+ }
+#line 1993 "compilador.tab.c"
+ break;
+
+ case 90:
+#line 485 "compilador.y"
+ {
+ geraCodigo(NULL, "DIVI"); // Adiciona operação de divi
+ }
+#line 2001 "compilador.tab.c"
+ break;
+
+ case 92:
+#line 491 "compilador.y"
+ {
+ // Carrega variável
+ l_elem = busca(token, ts);
+ empilha(token, proc);
+ }
+#line 2011 "compilador.tab.c"
+ break;
+
+ case 93:
+#line 497 "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 2041 "compilador.tab.c"
+ break;
+
+ case 94:
+#line 522 "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 2056 "compilador.tab.c"
+ break;
+
+ case 96:
+#line 535 "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 2068 "compilador.tab.c"
+ break;
+
+ case 97:
+#line 542 "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 2083 "compilador.tab.c"
+ break;
+
+ case 98:
+#line 552 "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 2102 "compilador.tab.c"
+ break;
+
+ case 99:
+#line 568 "compilador.y"
+ {
+ char r_fim[4];
+ desempilha(r_fim,rot);
+ geraCodigo(r_fim,"NADA");
+ }
+#line 2112 "compilador.tab.c"
+ break;
+
+ case 102:
+#line 580 "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 2132 "compilador.tab.c"
+ break;
+
+ case 103:
+#line 595 "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 2151 "compilador.tab.c"
+ break;
+
+
+#line 2155 "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 612 "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/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 a291481..0d488ff 100644
--- a/ts/ts.c
+++ b/ts/ts.c
@@ -42,6 +42,7 @@ void insere_ts(char *ident, int categ, int nivel, info_t info, ts_t *ts){
new->info.fun.param[i][1] = info.fun.param[i][1];
}
new->info.fun.tipo = info.fun.tipo;
+ new->info.fun.desloc = info.fun.desloc;
}
new->prox = ts->topo;
@@ -144,7 +145,8 @@ void adiciona_param(char *ident, int n, ts_t *ts){
p->info.fun.quant = n;
simb_t *pf = ts->topo;
- for (int i = n-1, j = 0; i >= 0 && pf != NULL; i--, j++) {
+ int i,j;
+ for (i = n-1, j = 0; i >= 0 && pf != NULL; i--, j++) {
if (pf->categ == PF) {
p->info.fun.param[i] = (int *)malloc(2 * sizeof(int));
p->info.fun.param[i][0] = pf->info.pf.tipo;
@@ -153,6 +155,7 @@ void adiciona_param(char *ident, int n, ts_t *ts){
}
pf = pf->prox;
}
+ p->info.fun.desloc = -4 - j;
}
}
@@ -249,6 +252,7 @@ void mostra_ts(ts_t *ts) {
tipoStr = "NSEI";
break;
}
+ snprintf(deslocStr, sizeof(deslocStr), "%d", p->info.fun.desloc);
if (p->info.fun.quant > 1) {
char paramStr[150] = "";
snprintf(paramStr, sizeof(paramStr), "%d{", p->info.fun.quant);
diff --git a/ts/ts.o b/ts/ts.o
new file mode 100644
index 0000000000000000000000000000000000000000..61c2b7e1032ed2c492aacab17952e40c31f213cf
GIT binary patch
literal 10696
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
F9{|_WS84zN
literal 0
HcmV?d00001
--
GitLab