From 606af4570147c864c5df08d7a225085e61aa9ada Mon Sep 17 00:00:00 2001
From: hm19 <hm19@inf.ufpr.br>
Date: Tue, 3 Dec 2024 16:13:06 -0300
Subject: [PATCH] limpo e rodando
---
MEPA | 2 -
compilador | Bin 54640 -> 0 bytes
compilador.o | Bin 2736 -> 0 bytes
compilador.tab.c | 2445 ----------------------------------------------
compilador.tab.h | 107 --
lex.yy.c | 2196 -----------------------------------------
stack/stack.o | Bin 3200 -> 0 bytes
teste11.pas | 3 +-
ts/ts.o | Bin 11840 -> 0 bytes
9 files changed, 2 insertions(+), 4751 deletions(-)
delete mode 100755 compilador
delete mode 100644 compilador.o
delete mode 100644 compilador.tab.c
delete mode 100644 compilador.tab.h
delete mode 100644 lex.yy.c
delete mode 100644 stack/stack.o
delete mode 100644 ts/ts.o
diff --git a/MEPA b/MEPA
index a4b0bcc..e458c01 100644
--- a/MEPA
+++ b/MEPA
@@ -50,5 +50,3 @@ R00: NADA
IMPR
CRVL 0,0
IMPR
- DMEM 1
- PARA
diff --git a/compilador b/compilador
deleted file mode 100755
index f090175ca12229a9f2b1f8142bdc6ba62b819eb7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 54640
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
diff --git a/compilador.o b/compilador.o
deleted file mode 100644
index 5d54ba2ec447c88f824aa9d112807c77cff6b70d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
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?^!
diff --git a/compilador.tab.c b/compilador.tab.c
deleted file mode 100644
index 69108ff..0000000
--- a/compilador.tab.c
+++ /dev/null
@@ -1,2445 +0,0 @@
-/* A Bison parser, made by GNU Bison 3.5.1. */
-
-/* Bison implementation for Yacc-like parsers in C
-
- Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
- Inc.
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-/* As a special exception, you may create a larger work that contains
- part or all of the Bison parser skeleton and distribute that work
- under terms of your choice, so long as that work isn't itself a
- parser generator using the skeleton or a modified version thereof
- as a parser skeleton. Alternatively, if you modify or redistribute
- the parser skeleton itself, you may (at your option) remove this
- special exception, which will cause the skeleton and the resulting
- Bison output files to be licensed under the GNU General Public
- License without this special exception.
-
- This special exception was added by the Free Software Foundation in
- version 2.2 of Bison. */
-
-/* C LALR(1) parser skeleton written by Richard Stallman, by
- simplifying the original so-called "semantic" parser. */
-
-/* All symbols defined below should begin with yy or YY, to avoid
- infringing on user name space. This should be done even for local
- variables, as they might otherwise be expanded by user macros.
- There are some unavoidable exceptions within include files to
- define necessary library symbols; they are noted "INFRINGES ON
- USER NAME SPACE" below. */
-
-/* Undocumented macros, especially those whose name start with YY_,
- are private implementation details. Do not rely on them. */
-
-/* Identify Bison output. */
-#define YYBISON 1
-
-/* Bison version. */
-#define YYBISON_VERSION "3.5.1"
-
-/* Skeleton name. */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers. */
-#define YYPURE 0
-
-/* Push parsers. */
-#define YYPUSH 0
-
-/* Pull parsers. */
-#define YYPULL 1
-
-
-
-
-/* First part of user prologue. */
-#line 6 "compilador.y"
-
-#include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <string.h>
-#include "compilador.h"
-#include "ts/ts.h"
-#include "stack/stack.h"
-
-int num_vars;
-int num_param;
-ts_t *ts;
-int nivel_lexico;
-int desloc;
-int destino_nivel;
-int destino_desloc;
-simb_t *l_elem;
-int rot_id;
-custom_stack_t *rot;
-custom_stack_t *proc;
-
-int val_ou_ref;
-int atr_indireto;
-
-
-#line 96 "compilador.tab.c"
-
-# ifndef YY_CAST
-# ifdef __cplusplus
-# define YY_CAST(Type, Val) static_cast<Type> (Val)
-# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
-# else
-# define YY_CAST(Type, Val) ((Type) (Val))
-# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
-# endif
-# endif
-# ifndef YY_NULLPTR
-# if defined __cplusplus
-# if 201103L <= __cplusplus
-# define YY_NULLPTR nullptr
-# else
-# define YY_NULLPTR 0
-# endif
-# else
-# define YY_NULLPTR ((void*)0)
-# endif
-# endif
-
-/* Enabling verbose error messages. */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 0
-#endif
-
-/* Use api.header.include to #include this header
- instead of duplicating it here. */
-#ifndef YY_YY_COMPILADOR_TAB_H_INCLUDED
-# define YY_YY_COMPILADOR_TAB_H_INCLUDED
-/* Debug traces. */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
-/* Token type. */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
- enum yytokentype
- {
- PROGRAM = 258,
- ABRE_PARENTESES = 259,
- FECHA_PARENTESES = 260,
- VIRGULA = 261,
- PONTO_E_VIRGULA = 262,
- DOIS_PONTOS = 263,
- PONTO = 264,
- T_BEGIN = 265,
- T_END = 266,
- VAR = 267,
- IDENT = 268,
- ATRIBUICAO = 269,
- LABEL = 270,
- TYPE = 271,
- ARRAY = 272,
- PROCEDURE = 273,
- FUNCTION = 274,
- GOTO = 275,
- IF = 276,
- THEN = 277,
- ELSE = 278,
- WHILE = 279,
- DO = 280,
- OR = 281,
- DIV = 282,
- AND = 283,
- NOT = 284,
- IGUAL = 285,
- DIFERENTE = 286,
- MENOR_IGUAL = 287,
- MAIOR_IGUAL = 288,
- MENOR = 289,
- MAIOR = 290,
- MAIS = 291,
- MENOS = 292,
- ASTERISCO = 293,
- NUMERO = 294,
- READ = 295,
- WRITE = 296,
- LOWER_THAN_ELSE = 297
- };
-#endif
-
-/* Value type. */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef int YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-extern YYSTYPE yylval;
-
-int yyparse (void);
-
-#endif /* !YY_YY_COMPILADOR_TAB_H_INCLUDED */
-
-
-
-#ifdef short
-# undef short
-#endif
-
-/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
- <limits.h> and (if available) <stdint.h> are included
- so that the code can choose integer types of a good width. */
-
-#ifndef __PTRDIFF_MAX__
-# include <limits.h> /* INFRINGES ON USER NAME SPACE */
-# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
-# define YY_STDINT_H
-# endif
-#endif
-
-/* Narrow types that promote to a signed type and that can represent a
- signed or unsigned integer of at least N bits. In tables they can
- save space and decrease cache pressure. Promoting to a signed type
- helps avoid bugs in integer arithmetic. */
-
-#ifdef __INT_LEAST8_MAX__
-typedef __INT_LEAST8_TYPE__ yytype_int8;
-#elif defined YY_STDINT_H
-typedef int_least8_t yytype_int8;
-#else
-typedef signed char yytype_int8;
-#endif
-
-#ifdef __INT_LEAST16_MAX__
-typedef __INT_LEAST16_TYPE__ yytype_int16;
-#elif defined YY_STDINT_H
-typedef int_least16_t yytype_int16;
-#else
-typedef short yytype_int16;
-#endif
-
-#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
-typedef __UINT_LEAST8_TYPE__ yytype_uint8;
-#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
- && UINT_LEAST8_MAX <= INT_MAX)
-typedef uint_least8_t yytype_uint8;
-#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
-typedef unsigned char yytype_uint8;
-#else
-typedef short yytype_uint8;
-#endif
-
-#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
-typedef __UINT_LEAST16_TYPE__ yytype_uint16;
-#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
- && UINT_LEAST16_MAX <= INT_MAX)
-typedef uint_least16_t yytype_uint16;
-#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
-typedef unsigned short yytype_uint16;
-#else
-typedef int yytype_uint16;
-#endif
-
-#ifndef YYPTRDIFF_T
-# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
-# define YYPTRDIFF_T __PTRDIFF_TYPE__
-# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
-# elif defined PTRDIFF_MAX
-# ifndef ptrdiff_t
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# endif
-# define YYPTRDIFF_T ptrdiff_t
-# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
-# else
-# define YYPTRDIFF_T long
-# define YYPTRDIFF_MAXIMUM LONG_MAX
-# endif
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-# define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-# define YYSIZE_T size_t
-# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T size_t
-# else
-# define YYSIZE_T unsigned
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM \
- YY_CAST (YYPTRDIFF_T, \
- (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
- ? YYPTRDIFF_MAXIMUM \
- : YY_CAST (YYSIZE_T, -1)))
-
-#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
-
-/* Stored state numbers (used for stacks). */
-typedef yytype_uint8 yy_state_t;
-
-/* State numbers in computations. */
-typedef int yy_state_fast_t;
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-# if ENABLE_NLS
-# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
-# endif
-# endif
-# ifndef YY_
-# define YY_(Msgid) Msgid
-# endif
-#endif
-
-#ifndef YY_ATTRIBUTE_PURE
-# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
-# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
-# else
-# define YY_ATTRIBUTE_PURE
-# endif
-#endif
-
-#ifndef YY_ATTRIBUTE_UNUSED
-# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
-# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
-# else
-# define YY_ATTRIBUTE_UNUSED
-# endif
-#endif
-
-/* Suppress unused-variable warnings by "using" E. */
-#if ! defined lint || defined __GNUC__
-# define YYUSE(E) ((void) (E))
-#else
-# define YYUSE(E) /* empty */
-#endif
-
-#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
-/* Suppress an incorrect diagnostic about yylval being uninitialized. */
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
- _Pragma ("GCC diagnostic push") \
- _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
- _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
- _Pragma ("GCC diagnostic pop")
-#else
-# define YY_INITIAL_VALUE(Value) Value
-#endif
-#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END
-#endif
-#ifndef YY_INITIAL_VALUE
-# define YY_INITIAL_VALUE(Value) /* Nothing. */
-#endif
-
-#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
-# define YY_IGNORE_USELESS_CAST_BEGIN \
- _Pragma ("GCC diagnostic push") \
- _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
-# define YY_IGNORE_USELESS_CAST_END \
- _Pragma ("GCC diagnostic pop")
-#endif
-#ifndef YY_IGNORE_USELESS_CAST_BEGIN
-# define YY_IGNORE_USELESS_CAST_BEGIN
-# define YY_IGNORE_USELESS_CAST_END
-#endif
-
-
-#define YY_ASSERT(E) ((void) (0 && (E)))
-
-#if ! defined yyoverflow || YYERROR_VERBOSE
-
-/* The parser invokes alloca or malloc; define the necessary symbols. */
-
-# ifdef YYSTACK_USE_ALLOCA
-# if YYSTACK_USE_ALLOCA
-# ifdef __GNUC__
-# define YYSTACK_ALLOC __builtin_alloca
-# elif defined __BUILTIN_VA_ARG_INCR
-# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-# elif defined _AIX
-# define YYSTACK_ALLOC __alloca
-# elif defined _MSC_VER
-# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-# define alloca _alloca
-# else
-# define YYSTACK_ALLOC alloca
-# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
- /* Use EXIT_SUCCESS as a witness for stdlib.h. */
-# ifndef EXIT_SUCCESS
-# define EXIT_SUCCESS 0
-# endif
-# endif
-# endif
-# endif
-# endif
-
-# ifdef YYSTACK_ALLOC
- /* Pacify GCC's 'empty if-body' warning. */
-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
-# ifndef YYSTACK_ALLOC_MAXIMUM
- /* The OS might guarantee only one guard page at the bottom of the stack,
- and a page size can be as small as 4096 bytes. So we cannot safely
- invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
- to allow for a few compiler-allocated temporary stack slots. */
-# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-# endif
-# else
-# define YYSTACK_ALLOC YYMALLOC
-# define YYSTACK_FREE YYFREE
-# ifndef YYSTACK_ALLOC_MAXIMUM
-# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-# endif
-# if (defined __cplusplus && ! defined EXIT_SUCCESS \
- && ! ((defined YYMALLOC || defined malloc) \
- && (defined YYFREE || defined free)))
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-# ifndef EXIT_SUCCESS
-# define EXIT_SUCCESS 0
-# endif
-# endif
-# ifndef YYMALLOC
-# define YYMALLOC malloc
-# if ! defined malloc && ! defined EXIT_SUCCESS
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-# endif
-# endif
-# ifndef YYFREE
-# define YYFREE free
-# if ! defined free && ! defined EXIT_SUCCESS
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-# endif
-# endif
-# endif
-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-
-
-#if (! defined yyoverflow \
- && (! defined __cplusplus \
- || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member. */
-union yyalloc
-{
- yy_state_t yyss_alloc;
- YYSTYPE yyvs_alloc;
-};
-
-/* The size of the maximum gap between one aligned stack and the next. */
-# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
- N elements. */
-# define YYSTACK_BYTES(N) \
- ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
- + YYSTACK_GAP_MAXIMUM)
-
-# define YYCOPY_NEEDED 1
-
-/* Relocate STACK from its old location to the new one. The
- local variables YYSIZE and YYSTACKSIZE give the old and new number of
- elements in the stack, and YYPTR gives the new location of the
- stack. Advance YYPTR to a properly aligned location for the next
- stack. */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
- do \
- { \
- YYPTRDIFF_T yynewbytes; \
- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
- Stack = &yyptr->Stack_alloc; \
- yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
- yyptr += yynewbytes / YYSIZEOF (*yyptr); \
- } \
- while (0)
-
-#endif
-
-#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from SRC to DST. The source and destination do
- not overlap. */
-# ifndef YYCOPY
-# if defined __GNUC__ && 1 < __GNUC__
-# define YYCOPY(Dst, Src, Count) \
- __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
-# else
-# define YYCOPY(Dst, Src, Count) \
- do \
- { \
- YYPTRDIFF_T yyi; \
- for (yyi = 0; yyi < (Count); yyi++) \
- (Dst)[yyi] = (Src)[yyi]; \
- } \
- while (0)
-# endif
-# endif
-#endif /* !YYCOPY_NEEDED */
-
-/* YYFINAL -- State number of the termination state. */
-#define YYFINAL 3
-/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 128
-
-/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS 43
-/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS 67
-/* YYNRULES -- Number of rules. */
-#define YYNRULES 103
-/* YYNSTATES -- Number of states. */
-#define YYNSTATES 173
-
-#define YYUNDEFTOK 2
-#define YYMAXUTOK 297
-
-
-/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
- as returned by yylex, with out-of-bounds checking. */
-#define YYTRANSLATE(YYX) \
- (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-
-/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
- as returned by yylex. */
-static const yytype_int8 yytranslate[] =
-{
- 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
- 35, 36, 37, 38, 39, 40, 41, 42
-};
-
-#if YYDEBUG
- /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
-static const yytype_int16 yyrline[] =
-{
- 0, 47, 47, 47, 63, 74, 60, 93, 94, 97,
- 101, 101, 102, 105, 106, 110, 113, 110, 121, 134,
- 143, 154, 155, 159, 161, 162, 167, 191, 167, 205,
- 229, 233, 205, 246, 247, 245, 255, 258, 259, 263,
- 262, 272, 272, 280, 281, 284, 294, 297, 298, 299,
- 302, 303, 306, 307, 308, 309, 310, 311, 314, 314,
- 318, 319, 322, 322, 353, 353, 395, 398, 402, 401,
- 414, 414, 428, 431, 432, 435, 444, 447, 450, 455,
- 458, 461, 464, 467, 470, 473, 476, 482, 488, 491,
- 494, 497, 500, 500, 542, 553, 555, 562, 555, 588,
- 595, 597, 600, 600
-};
-#endif
-
-#if YYDEBUG || YYERROR_VERBOSE || 0
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
- First, the terminals, then, starting at YYNTOKENS, nonterminals. */
-static const char *const yytname[] =
-{
- "$end", "error", "$undefined", "PROGRAM", "ABRE_PARENTESES",
- "FECHA_PARENTESES", "VIRGULA", "PONTO_E_VIRGULA", "DOIS_PONTOS", "PONTO",
- "T_BEGIN", "T_END", "VAR", "IDENT", "ATRIBUICAO", "LABEL", "TYPE",
- "ARRAY", "PROCEDURE", "FUNCTION", "GOTO", "IF", "THEN", "ELSE", "WHILE",
- "DO", "OR", "DIV", "AND", "NOT", "IGUAL", "DIFERENTE", "MENOR_IGUAL",
- "MAIOR_IGUAL", "MENOR", "MAIOR", "MAIS", "MENOS", "ASTERISCO", "NUMERO",
- "READ", "WRITE", "LOWER_THAN_ELSE", "$accept", "programa", "$@1",
- "bloco", "$@2", "$@3", "parte_declara_rotulos", "parte_declara_vars",
- "var", "$@4", "declara_vars", "declara_var", "$@5", "$@6", "tipo",
- "lista_id_var", "lista_idents", "parte_declara_subrotinas",
- "declaracao_procedimento", "$@7", "$@8", "declaracao_funcao", "$@9",
- "$@10", "$@11", "parametros_ou_nada", "$@12", "$@13",
- "paramentros_formais", "secao_pfs", "$@14", "$@15", "lista_id_pf",
- "parametro", "comando_composto", "comandos", "comando",
- "comando_sem_rotulo", "atribuicao_ou_procedimento", "$@16",
- "atribuicao_ou_procedimento_token", "atribuicao", "$@17",
- "chamada_procedimento", "$@18", "lista_parametros",
- "lista_parametros_parenteses", "$@19", "$@20", "leitura",
- "lista_leituras", "simb_leitura", "escrita", "lista_escritas",
- "expressao", "expressao_simples", "termo", "fator", "$@21", "numero",
- "comando_repetitivo", "$@22", "$@23", "comando_condicional", "cond_else",
- "if_then", "$@24", YY_NULLPTR
-};
-#endif
-
-# ifdef YYPRINT
-/* YYTOKNUM[NUM] -- (External) token number corresponding to the
- (internal) symbol number NUM (which must be that of a token). */
-static const yytype_int16 yytoknum[] =
-{
- 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
- 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
- 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
- 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
- 295, 296, 297
-};
-# endif
-
-#define YYPACT_NINF (-113)
-
-#define yypact_value_is_default(Yyn) \
- ((Yyn) == YYPACT_NINF)
-
-#define YYTABLE_NINF (-97)
-
-#define yytable_value_is_error(Yyn) \
- 0
-
- /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- STATE-NUM. */
-static const yytype_int8 yypact[] =
-{
- -113, 10, 11, -113, 4, 24, 43, -113, 7, 52,
- 45, 46, -113, 54, 55, 56, -113, -113, -113, -113,
- 57, 44, -113, 53, 59, -113, 58, -113, 61, -113,
- 62, 60, -113, -113, -113, 1, 68, -113, 5, -113,
- 66, 74, -113, 80, 68, -113, -7, -113, 85, 86,
- -113, 81, 84, -113, -113, -113, -113, 87, -113, 69,
- -113, 73, -113, -113, -113, 88, -113, 90, 89, -113,
- -113, 20, -6, -11, -113, 91, -7, -113, 5, -2,
- -7, -2, -113, 92, -113, 94, -113, 93, 74, 46,
- -113, -113, 95, -113, 98, -113, -7, -7, -7, -7,
- -7, -7, 76, -7, -7, -7, -7, -113, 28, -113,
- 30, -6, -113, -113, 51, -113, -113, 93, 88, 100,
- -113, 99, 102, 103, -113, -7, -113, -113, -113, -6,
- -6, -6, -6, -6, -6, -2, -11, -11, -113, -113,
- -113, 91, -113, -7, -113, 104, -113, -113, 74, 93,
- 46, 106, -6, 35, -7, -113, -113, -6, -2, 74,
- -113, -113, -113, -113, -113, -113, -6, -113, -113, 107,
- -7, -113, -6
-};
-
- /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
- Performed when YYTABLE does not specify something else to do. Zero
- means the default is an error. */
-static const yytype_int8 yydefact[] =
-{
- 2, 0, 0, 1, 0, 0, 0, 22, 0, 0,
- 0, 8, 21, 0, 0, 12, 7, 3, 4, 9,
- 0, 25, 15, 0, 5, 24, 11, 14, 0, 29,
- 0, 0, 23, 13, 20, 0, 36, 26, 49, 6,
- 0, 0, 33, 0, 36, 58, 0, 95, 0, 0,
- 53, 0, 0, 51, 52, 56, 57, 0, 55, 0,
- 54, 101, 19, 18, 16, 41, 30, 0, 64, 92,
- 94, 102, 85, 88, 91, 0, 0, 46, 48, 96,
- 0, 96, 99, 0, 39, 34, 37, 0, 0, 8,
- 59, 60, 0, 61, 67, 64, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 75, 0, 74,
- 0, 78, 47, 50, 0, 100, 17, 0, 41, 0,
- 45, 0, 44, 0, 27, 0, 70, 65, 93, 79,
- 80, 82, 84, 81, 83, 96, 86, 87, 90, 89,
- 72, 0, 76, 0, 97, 0, 38, 35, 0, 0,
- 8, 0, 63, 0, 0, 103, 73, 77, 96, 0,
- 42, 43, 31, 28, 66, 68, 71, 98, 40, 0,
- 0, 32, 69
-};
-
- /* YYPGOTO[NTERM-NUM]. */
-static const yytype_int8 yypgoto[] =
-{
- -113, -113, -113, -85, -113, -113, -113, -113, -113, -113,
- -113, 96, -113, -113, -86, -113, -113, -113, -113, -113,
- -113, -113, -113, -113, -113, 67, -113, -113, -113, -3,
- -113, -113, -112, -113, 97, 38, -113, -78, -113, -113,
- -113, -113, -113, 22, -113, -113, -113, -113, -113, -113,
- -113, -23, -113, -113, 39, -76, -61, -58, -113, -113,
- -113, -113, -113, -113, -113, -113, -113
-};
-
- /* YYDEFGOTO[NTERM-NUM]. */
-static const yytype_int16 yydefgoto[] =
-{
- -1, 1, 2, 14, 21, 31, 15, 18, 19, 20,
- 26, 27, 28, 83, 64, 35, 8, 24, 32, 44,
- 151, 25, 36, 88, 169, 43, 65, 119, 85, 86,
- 117, 87, 121, 122, 50, 51, 52, 53, 54, 68,
- 90, 91, 92, 93, 94, 127, 153, 170, 154, 55,
- 108, 109, 56, 110, 71, 72, 73, 74, 95, 57,
- 58, 59, 158, 60, 82, 61, 102
-};
-
- /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
- positive, shift that token. If negative, reduce the rule whose
- number is the opposite. If YYTABLE_NINF, syntax error. */
-static const yytype_int16 yytable[] =
-{
- 111, 113, 123, 115, 124, 145, 69, 40, 38, 41,
- 3, 45, 9, 10, 4, 38, 105, 5, 45, 46,
- 129, 130, 131, 132, 133, 134, 46, 106, 6, -96,
- 103, 104, 70, 140, 141, 142, 143, 161, 48, 49,
- 164, 165, 136, 137, 47, 48, 49, 138, 139, 152,
- 96, 97, 98, 99, 100, 101, 7, 155, 12, 11,
- 16, 13, 160, 23, 17, 162, 29, 157, -10, 22,
- 38, -15, 42, 168, 34, 37, 144, 30, 166, 62,
- 167, 96, 97, 98, 99, 100, 101, 63, 66, 75,
- 76, 78, 77, 80, 172, 79, 81, 89, 135, 116,
- 84, 118, 126, -62, 107, 147, 120, 148, 149, 125,
- 150, 67, 159, 163, 171, 146, 112, 128, 156, 114,
- 0, 0, 33, 0, 0, 0, 0, 0, 39
-};
-
-static const yytype_int16 yycheck[] =
-{
- 76, 79, 88, 81, 89, 117, 13, 6, 10, 8,
- 0, 13, 5, 6, 3, 10, 27, 13, 13, 21,
- 96, 97, 98, 99, 100, 101, 21, 38, 4, 24,
- 36, 37, 39, 5, 6, 5, 6, 149, 40, 41,
- 5, 6, 103, 104, 39, 40, 41, 105, 106, 125,
- 30, 31, 32, 33, 34, 35, 13, 135, 13, 7,
- 6, 15, 148, 19, 9, 150, 13, 143, 12, 12,
- 10, 13, 4, 159, 13, 13, 25, 18, 154, 13,
- 158, 30, 31, 32, 33, 34, 35, 13, 8, 4,
- 4, 7, 11, 24, 170, 8, 23, 7, 22, 7,
- 12, 7, 4, 14, 13, 5, 13, 8, 6, 14,
- 7, 44, 8, 7, 7, 118, 78, 95, 141, 80,
- -1, -1, 26, -1, -1, -1, -1, -1, 31
-};
-
- /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
- symbol of state STATE-NUM. */
-static const yytype_int8 yystos[] =
-{
- 0, 44, 45, 0, 3, 13, 4, 13, 59, 5,
- 6, 7, 13, 15, 46, 49, 6, 9, 50, 51,
- 52, 47, 12, 19, 60, 64, 53, 54, 55, 13,
- 18, 48, 61, 54, 13, 58, 65, 13, 10, 77,
- 6, 8, 4, 68, 62, 13, 21, 39, 40, 41,
- 77, 78, 79, 80, 81, 92, 95, 102, 103, 104,
- 106, 108, 13, 13, 57, 69, 8, 68, 82, 13,
- 39, 97, 98, 99, 100, 4, 4, 11, 7, 8,
- 24, 23, 107, 56, 12, 71, 72, 74, 66, 7,
- 83, 84, 85, 86, 87, 101, 30, 31, 32, 33,
- 34, 35, 109, 36, 37, 27, 38, 13, 93, 94,
- 96, 98, 78, 80, 97, 80, 7, 73, 7, 70,
- 13, 75, 76, 57, 46, 14, 4, 88, 86, 98,
- 98, 98, 98, 98, 98, 22, 99, 99, 100, 100,
- 5, 6, 5, 6, 25, 75, 72, 5, 8, 6,
- 7, 63, 98, 89, 91, 80, 94, 98, 105, 8,
- 57, 75, 46, 7, 5, 6, 98, 80, 57, 67,
- 90, 7, 98
-};
-
- /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
-static const yytype_int8 yyr1[] =
-{
- 0, 43, 45, 44, 47, 48, 46, 49, 49, 50,
- 52, 51, 51, 53, 53, 55, 56, 54, 57, 58,
- 58, 59, 59, 60, 60, 60, 62, 63, 61, 65,
- 66, 67, 64, 69, 70, 68, 68, 71, 71, 73,
- 72, 74, 72, 75, 75, 76, 77, 78, 78, 78,
- 79, 79, 80, 80, 80, 80, 80, 80, 82, 81,
- 83, 83, 85, 84, 87, 86, 88, 88, 90, 89,
- 91, 89, 92, 93, 93, 94, 95, 96, 96, 97,
- 97, 97, 97, 97, 97, 97, 98, 98, 98, 99,
- 99, 99, 101, 100, 100, 102, 104, 105, 103, 106,
- 107, 107, 109, 108
-};
-
- /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
-static const yytype_int8 yyr2[] =
-{
- 0, 2, 0, 9, 0, 0, 6, 2, 0, 1,
- 0, 3, 0, 2, 1, 0, 0, 6, 1, 3,
- 1, 3, 1, 2, 1, 0, 0, 0, 8, 0,
- 0, 0, 11, 0, 0, 5, 0, 1, 3, 0,
- 5, 0, 4, 3, 1, 1, 3, 3, 2, 0,
- 3, 1, 1, 1, 1, 1, 1, 1, 0, 3,
- 1, 1, 0, 3, 0, 2, 3, 0, 0, 4,
- 0, 2, 4, 3, 1, 1, 4, 3, 1, 3,
- 3, 3, 3, 3, 3, 1, 3, 3, 1, 3,
- 3, 1, 0, 3, 1, 1, 0, 0, 6, 2,
- 2, 0, 0, 5
-};
-
-
-#define yyerrok (yyerrstatus = 0)
-#define yyclearin (yychar = YYEMPTY)
-#define YYEMPTY (-2)
-#define YYEOF 0
-
-#define YYACCEPT goto yyacceptlab
-#define YYABORT goto yyabortlab
-#define YYERROR goto yyerrorlab
-
-
-#define YYRECOVERING() (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value) \
- do \
- if (yychar == YYEMPTY) \
- { \
- yychar = (Token); \
- yylval = (Value); \
- YYPOPSTACK (yylen); \
- yystate = *yyssp; \
- goto yybackup; \
- } \
- else \
- { \
- yyerror (YY_("syntax error: cannot back up")); \
- YYERROR; \
- } \
- while (0)
-
-/* Error token number */
-#define YYTERROR 1
-#define YYERRCODE 256
-
-
-
-/* Enable debugging if requested. */
-#if YYDEBUG
-
-# ifndef YYFPRINTF
-# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-# define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args) \
-do { \
- if (yydebug) \
- YYFPRINTF Args; \
-} while (0)
-
-/* This macro is provided for backward compatibility. */
-#ifndef YY_LOCATION_PRINT
-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-#endif
-
-
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
-do { \
- if (yydebug) \
- { \
- YYFPRINTF (stderr, "%s ", Title); \
- yy_symbol_print (stderr, \
- Type, Value); \
- YYFPRINTF (stderr, "\n"); \
- } \
-} while (0)
-
-
-/*-----------------------------------.
-| Print this symbol's value on YYO. |
-`-----------------------------------*/
-
-static void
-yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
-{
- FILE *yyoutput = yyo;
- YYUSE (yyoutput);
- if (!yyvaluep)
- return;
-# ifdef YYPRINT
- if (yytype < YYNTOKENS)
- YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
-# endif
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- YYUSE (yytype);
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-}
-
-
-/*---------------------------.
-| Print this symbol on YYO. |
-`---------------------------*/
-
-static void
-yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
-{
- YYFPRINTF (yyo, "%s %s (",
- yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
-
- yy_symbol_value_print (yyo, yytype, yyvaluep);
- YYFPRINTF (yyo, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included). |
-`------------------------------------------------------------------*/
-
-static void
-yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
-{
- YYFPRINTF (stderr, "Stack now");
- for (; yybottom <= yytop; yybottom++)
- {
- int yybot = *yybottom;
- YYFPRINTF (stderr, " %d", yybot);
- }
- YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top) \
-do { \
- if (yydebug) \
- yy_stack_print ((Bottom), (Top)); \
-} while (0)
-
-
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced. |
-`------------------------------------------------*/
-
-static void
-yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
-{
- int yylno = yyrline[yyrule];
- int yynrhs = yyr2[yyrule];
- int yyi;
- YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
- yyrule - 1, yylno);
- /* The symbols being reduced. */
- for (yyi = 0; yyi < yynrhs; yyi++)
- {
- YYFPRINTF (stderr, " $%d = ", yyi + 1);
- yy_symbol_print (stderr,
- yystos[+yyssp[yyi + 1 - yynrhs]],
- &yyvsp[(yyi + 1) - (yynrhs)]
- );
- YYFPRINTF (stderr, "\n");
- }
-}
-
-# define YY_REDUCE_PRINT(Rule) \
-do { \
- if (yydebug) \
- yy_reduce_print (yyssp, yyvsp, Rule); \
-} while (0)
-
-/* Nonzero means print parse trace. It is left uninitialized so that
- multiple parsers can coexist. */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args)
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks. */
-#ifndef YYINITDEPTH
-# define YYINITDEPTH 200
-#endif
-
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
- if the built-in stack extension method is used).
-
- Do not make this value too large; the results are undefined if
- YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
- evaluated with infinite-precision integer arithmetic. */
-
-#ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
-#endif
-
-
-#if YYERROR_VERBOSE
-
-# ifndef yystrlen
-# if defined __GLIBC__ && defined _STRING_H
-# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
-# else
-/* Return the length of YYSTR. */
-static YYPTRDIFF_T
-yystrlen (const char *yystr)
-{
- YYPTRDIFF_T yylen;
- for (yylen = 0; yystr[yylen]; yylen++)
- continue;
- return yylen;
-}
-# endif
-# endif
-
-# ifndef yystpcpy
-# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
-# define yystpcpy stpcpy
-# else
-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
- YYDEST. */
-static char *
-yystpcpy (char *yydest, const char *yysrc)
-{
- char *yyd = yydest;
- const char *yys = yysrc;
-
- while ((*yyd++ = *yys++) != '\0')
- continue;
-
- return yyd - 1;
-}
-# endif
-# endif
-
-# ifndef yytnamerr
-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
- quotes and backslashes, so that it's suitable for yyerror. The
- heuristic is that double-quoting is unnecessary unless the string
- contains an apostrophe, a comma, or backslash (other than
- backslash-backslash). YYSTR is taken from yytname. If YYRES is
- null, do not copy; instead, return the length of what the result
- would have been. */
-static YYPTRDIFF_T
-yytnamerr (char *yyres, const char *yystr)
-{
- if (*yystr == '"')
- {
- YYPTRDIFF_T yyn = 0;
- char const *yyp = yystr;
-
- for (;;)
- switch (*++yyp)
- {
- case '\'':
- case ',':
- goto do_not_strip_quotes;
-
- case '\\':
- if (*++yyp != '\\')
- goto do_not_strip_quotes;
- else
- goto append;
-
- append:
- default:
- if (yyres)
- yyres[yyn] = *yyp;
- yyn++;
- break;
-
- case '"':
- if (yyres)
- yyres[yyn] = '\0';
- return yyn;
- }
- do_not_strip_quotes: ;
- }
-
- if (yyres)
- return yystpcpy (yyres, yystr) - yyres;
- else
- return yystrlen (yystr);
-}
-# endif
-
-/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
- about the unexpected token YYTOKEN for the state stack whose top is
- YYSSP.
-
- Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
- not large enough to hold the message. In that case, also set
- *YYMSG_ALLOC to the required number of bytes. Return 2 if the
- required number of bytes is too large to store. */
-static int
-yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
- yy_state_t *yyssp, int yytoken)
-{
- enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
- /* Internationalized format string. */
- const char *yyformat = YY_NULLPTR;
- /* Arguments of yyformat: reported tokens (one for the "unexpected",
- one per "expected"). */
- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
- /* Actual size of YYARG. */
- int yycount = 0;
- /* Cumulated lengths of YYARG. */
- YYPTRDIFF_T yysize = 0;
-
- /* There are many possibilities here to consider:
- - If this state is a consistent state with a default action, then
- the only way this function was invoked is if the default action
- is an error action. In that case, don't check for expected
- tokens because there are none.
- - The only way there can be no lookahead present (in yychar) is if
- this state is a consistent state with a default action. Thus,
- detecting the absence of a lookahead is sufficient to determine
- that there is no unexpected or expected token to report. In that
- case, just report a simple "syntax error".
- - Don't assume there isn't a lookahead just because this state is a
- consistent state with a default action. There might have been a
- previous inconsistent state, consistent state with a non-default
- action, or user semantic action that manipulated yychar.
- - Of course, the expected token list depends on states to have
- correct lookahead information, and it depends on the parser not
- to perform extra reductions after fetching a lookahead from the
- scanner and before detecting a syntax error. Thus, state merging
- (from LALR or IELR) and default reductions corrupt the expected
- token list. However, the list is correct for canonical LR with
- one exception: it will still contain any token that will not be
- accepted due to an error action in a later state.
- */
- if (yytoken != YYEMPTY)
- {
- int yyn = yypact[+*yyssp];
- YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
- yysize = yysize0;
- yyarg[yycount++] = yytname[yytoken];
- if (!yypact_value_is_default (yyn))
- {
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. In other words, skip the first -YYN actions for
- this state because they are default actions. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn + 1;
- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
- int yyx;
-
- for (yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
- && !yytable_value_is_error (yytable[yyx + yyn]))
- {
- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
- {
- yycount = 1;
- yysize = yysize0;
- break;
- }
- yyarg[yycount++] = yytname[yyx];
- {
- YYPTRDIFF_T yysize1
- = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
- if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
- yysize = yysize1;
- else
- return 2;
- }
- }
- }
- }
-
- switch (yycount)
- {
-# define YYCASE_(N, S) \
- case N: \
- yyformat = S; \
- break
- default: /* Avoid compiler warnings. */
- YYCASE_(0, YY_("syntax error"));
- YYCASE_(1, YY_("syntax error, unexpected %s"));
- YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
- YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
- YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
- YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
-# undef YYCASE_
- }
-
- {
- /* Don't count the "%s"s in the final size, but reserve room for
- the terminator. */
- YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
- if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
- yysize = yysize1;
- else
- return 2;
- }
-
- if (*yymsg_alloc < yysize)
- {
- *yymsg_alloc = 2 * yysize;
- if (! (yysize <= *yymsg_alloc
- && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
- *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
- return 1;
- }
-
- /* Avoid sprintf, as that infringes on the user's name space.
- Don't have undefined behavior even if the translation
- produced a string with the wrong number of "%s"s. */
- {
- char *yyp = *yymsg;
- int yyi = 0;
- while ((*yyp = *yyformat) != '\0')
- if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
- {
- yyp += yytnamerr (yyp, yyarg[yyi++]);
- yyformat += 2;
- }
- else
- {
- ++yyp;
- ++yyformat;
- }
- }
- return 0;
-}
-#endif /* YYERROR_VERBOSE */
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol. |
-`-----------------------------------------------*/
-
-static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
-{
- YYUSE (yyvaluep);
- if (!yymsg)
- yymsg = "Deleting";
- YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
-
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- YYUSE (yytype);
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-}
-
-
-
-
-/* The lookahead symbol. */
-int yychar;
-
-/* The semantic value of the lookahead symbol. */
-YYSTYPE yylval;
-/* Number of syntax errors so far. */
-int yynerrs;
-
-
-/*----------.
-| yyparse. |
-`----------*/
-
-int
-yyparse (void)
-{
- yy_state_fast_t yystate;
- /* Number of tokens to shift before error messages enabled. */
- int yyerrstatus;
-
- /* The stacks and their tools:
- 'yyss': related to states.
- 'yyvs': related to semantic values.
-
- Refer to the stacks through separate pointers, to allow yyoverflow
- to reallocate them elsewhere. */
-
- /* The state stack. */
- yy_state_t yyssa[YYINITDEPTH];
- yy_state_t *yyss;
- yy_state_t *yyssp;
-
- /* The semantic value stack. */
- YYSTYPE yyvsa[YYINITDEPTH];
- YYSTYPE *yyvs;
- YYSTYPE *yyvsp;
-
- YYPTRDIFF_T yystacksize;
-
- int yyn;
- int yyresult;
- /* Lookahead token as an internal (translated) token number. */
- int yytoken = 0;
- /* The variables used to return semantic value and location from the
- action routines. */
- YYSTYPE yyval;
-
-#if YYERROR_VERBOSE
- /* Buffer for error messages, and its allocated size. */
- char yymsgbuf[128];
- char *yymsg = yymsgbuf;
- YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
-#endif
-
-#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
-
- /* The number of symbols on the RHS of the reduced rule.
- Keep to zero when no symbol should be popped. */
- int yylen = 0;
-
- yyssp = yyss = yyssa;
- yyvsp = yyvs = yyvsa;
- yystacksize = YYINITDEPTH;
-
- YYDPRINTF ((stderr, "Starting parse\n"));
-
- yystate = 0;
- yyerrstatus = 0;
- yynerrs = 0;
- yychar = YYEMPTY; /* Cause a token to be read. */
- goto yysetstate;
-
-
-/*------------------------------------------------------------.
-| yynewstate -- push a new state, which is found in yystate. |
-`------------------------------------------------------------*/
-yynewstate:
- /* In all cases, when you get here, the value and location stacks
- have just been pushed. So pushing a state here evens the stacks. */
- yyssp++;
-
-
-/*--------------------------------------------------------------------.
-| yysetstate -- set current state (the top of the stack) to yystate. |
-`--------------------------------------------------------------------*/
-yysetstate:
- YYDPRINTF ((stderr, "Entering state %d\n", yystate));
- YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
- YY_IGNORE_USELESS_CAST_BEGIN
- *yyssp = YY_CAST (yy_state_t, yystate);
- YY_IGNORE_USELESS_CAST_END
-
- if (yyss + yystacksize - 1 <= yyssp)
-#if !defined yyoverflow && !defined YYSTACK_RELOCATE
- goto yyexhaustedlab;
-#else
- {
- /* Get the current used size of the three stacks, in elements. */
- YYPTRDIFF_T yysize = yyssp - yyss + 1;
-
-# if defined yyoverflow
- {
- /* Give user a chance to reallocate the stack. Use copies of
- these so that the &'s don't force the real ones into
- memory. */
- yy_state_t *yyss1 = yyss;
- YYSTYPE *yyvs1 = yyvs;
-
- /* Each stack pointer address is followed by the size of the
- data in use in that stack, in bytes. This used to be a
- conditional around just the two extra args, but that might
- be undefined if yyoverflow is a macro. */
- yyoverflow (YY_("memory exhausted"),
- &yyss1, yysize * YYSIZEOF (*yyssp),
- &yyvs1, yysize * YYSIZEOF (*yyvsp),
- &yystacksize);
- yyss = yyss1;
- yyvs = yyvs1;
- }
-# else /* defined YYSTACK_RELOCATE */
- /* Extend the stack our own way. */
- if (YYMAXDEPTH <= yystacksize)
- goto yyexhaustedlab;
- yystacksize *= 2;
- if (YYMAXDEPTH < yystacksize)
- yystacksize = YYMAXDEPTH;
-
- {
- yy_state_t *yyss1 = yyss;
- union yyalloc *yyptr =
- YY_CAST (union yyalloc *,
- YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
- if (! yyptr)
- goto yyexhaustedlab;
- YYSTACK_RELOCATE (yyss_alloc, yyss);
- YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-# undef YYSTACK_RELOCATE
- if (yyss1 != yyssa)
- YYSTACK_FREE (yyss1);
- }
-# endif
-
- yyssp = yyss + yysize - 1;
- yyvsp = yyvs + yysize - 1;
-
- YY_IGNORE_USELESS_CAST_BEGIN
- YYDPRINTF ((stderr, "Stack size increased to %ld\n",
- YY_CAST (long, yystacksize)));
- YY_IGNORE_USELESS_CAST_END
-
- if (yyss + yystacksize - 1 <= yyssp)
- YYABORT;
- }
-#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
-
- if (yystate == YYFINAL)
- YYACCEPT;
-
- goto yybackup;
-
-
-/*-----------.
-| yybackup. |
-`-----------*/
-yybackup:
- /* Do appropriate processing given the current state. Read a
- lookahead token if we need one and don't already have one. */
-
- /* First try to decide what to do without reference to lookahead token. */
- yyn = yypact[yystate];
- if (yypact_value_is_default (yyn))
- goto yydefault;
-
- /* Not known => get a lookahead token if don't already have one. */
-
- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
- if (yychar == YYEMPTY)
- {
- YYDPRINTF ((stderr, "Reading a token: "));
- yychar = yylex ();
- }
-
- if (yychar <= YYEOF)
- {
- yychar = yytoken = YYEOF;
- YYDPRINTF ((stderr, "Now at end of input.\n"));
- }
- else
- {
- yytoken = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
- }
-
- /* If the proper action on seeing token YYTOKEN is to reduce or to
- detect an error, take that action. */
- yyn += yytoken;
- if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
- goto yydefault;
- yyn = yytable[yyn];
- if (yyn <= 0)
- {
- if (yytable_value_is_error (yyn))
- goto yyerrlab;
- yyn = -yyn;
- goto yyreduce;
- }
-
- /* Count tokens shifted since error; after three, turn off error
- status. */
- if (yyerrstatus)
- yyerrstatus--;
-
- /* Shift the lookahead token. */
- YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- yystate = yyn;
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- *++yyvsp = yylval;
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-
- /* Discard the shifted token. */
- yychar = YYEMPTY;
- goto yynewstate;
-
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state. |
-`-----------------------------------------------------------*/
-yydefault:
- yyn = yydefact[yystate];
- if (yyn == 0)
- goto yyerrlab;
- goto yyreduce;
-
-
-/*-----------------------------.
-| yyreduce -- do a reduction. |
-`-----------------------------*/
-yyreduce:
- /* yyn is the number of a rule to reduce with. */
- yylen = yyr2[yyn];
-
- /* If YYLEN is nonzero, implement the default value of the action:
- '$$ = $1'.
-
- Otherwise, the following line sets YYVAL to garbage.
- This behavior is undocumented and Bison
- users should not rely upon it. Assigning to YYVAL
- unconditionally makes the parser a bit smaller, and it avoids a
- GCC warning that YYVAL may be used uninitialized. */
- yyval = yyvsp[1-yylen];
-
-
- YY_REDUCE_PRINT (yyn);
- switch (yyn)
- {
- case 2:
-#line 47 "compilador.y"
- {
- geraCodigo (NULL, "INPP");
- }
-#line 1495 "compilador.tab.c"
- break;
-
- case 3:
-#line 53 "compilador.y"
- {
- geraCodigo (NULL, "PARA");
- }
-#line 1503 "compilador.tab.c"
- break;
-
- case 4:
-#line 63 "compilador.y"
- {
- char r_main[4];
- sprintf(r_main, "R%02d", rot_id);
- empilha(r_main, rot);
- rot_id += 1;
- char buffer[50];
- strcpy(buffer,"DSVS ");
- strcat(buffer,r_main);
- geraCodigo(NULL,buffer);
- }
-#line 1518 "compilador.tab.c"
- break;
-
- case 5:
-#line 74 "compilador.y"
- {
- char r_main[4];
- desempilha(r_main,rot);
- geraCodigo(r_main,"NADA");
- }
-#line 1528 "compilador.tab.c"
- break;
-
- case 6:
-#line 80 "compilador.y"
- {
- char buffer[50];
- sprintf(buffer,"DMEM %d",desloc);
- desloc = retira_pr_fun(ts);
- desloc = retira_vs_pf(ts);
- geraCodigo(NULL,buffer);
- if (nivel_lexico > 0)
- nivel_lexico -= 1;
- mostra_ts(ts);
- }
-#line 1543 "compilador.tab.c"
- break;
-
- case 10:
-#line 101 "compilador.y"
- { }
-#line 1549 "compilador.tab.c"
- break;
-
- case 15:
-#line 110 "compilador.y"
- { num_vars = 0; }
-#line 1555 "compilador.tab.c"
- break;
-
- case 16:
-#line 113 "compilador.y"
- {
- char buffer[50];
- sprintf(buffer, "AMEM %d", num_vars);
- geraCodigo(NULL, buffer);
- }
-#line 1565 "compilador.tab.c"
- break;
-
- case 18:
-#line 122 "compilador.y"
- {
- if (strcmp(token, "integer") == 0) {
- atualiza_tipo(num_vars, INTEIRO, ts);
- } else if (strcmp(token, "boolean") == 0) {
- atualiza_tipo(num_vars, BOOLEAN, ts);
- } else {
- yyerror("Tipo não reconhecido. Somente 'integer' ou 'boolean' são permitidos.");
- }
- mostra_ts(ts); // Mostra a tabela após a inserção
- }
-#line 1580 "compilador.tab.c"
- break;
-
- case 19:
-#line 135 "compilador.y"
- { /* insere �ltima vars na tabela de s�mbolos */
- num_vars += 1;
- info_t info;
- info.vs.tipo = NSEI;
- info.vs.desloc = desloc;
- insere_ts(token,VS,nivel_lexico,info,ts);
- desloc += 1;
- }
-#line 1593 "compilador.tab.c"
- break;
-
- case 20:
-#line 143 "compilador.y"
- {
- num_vars += 1;
- info_t info;
- info.vs.tipo = NSEI;
- info.vs.desloc = desloc;
- insere_ts(token,VS,nivel_lexico,info,ts);
- desloc += 1;
- /* insere vars na tabela de s�mbolos */
- }
-#line 1607 "compilador.tab.c"
- break;
-
- case 26:
-#line 167 "compilador.y"
- {
- // Insere o procedimento na tabela de símbolos
- info_t info;
- char r_proc[4];
- sprintf(r_proc, "R%02d", rot_id);
- rot_id += 1;
- strcpy(info.pr.rot,r_proc);
- info.pr.quant = 0;
- info.pr.param = NULL;
-
- // Incrementa o nível léxico
- nivel_lexico += 1;
- desloc = 0; // Reinicia deslocamento para variáveis locais do novo nível
-
- insere_ts(token, PR, nivel_lexico, info, ts);
- empilha(token,proc);
-
- char buffer[50];
- sprintf(buffer,"ENPR %d",nivel_lexico);
- geraCodigo(r_proc,buffer);
- mostra_ts(ts);
- }
-#line 1634 "compilador.tab.c"
- break;
-
- case 27:
-#line 191 "compilador.y"
- {
- char buffer[50];
- desempilha(buffer,proc);
- l_elem = busca(buffer,ts);
- sprintf(buffer,"RTPR %d,%d",l_elem->nivel,l_elem->info.pr.quant);
- geraCodigo(NULL,buffer);
- desloc = retira_vs_pf(ts);
- mostra_ts(ts);
- }
-#line 1648 "compilador.tab.c"
- break;
-
- case 29:
-#line 205 "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 1676 "compilador.tab.c"
- break;
-
- case 30:
-#line 229 "compilador.y"
- {
- num_vars = 1;
- }
-#line 1684 "compilador.tab.c"
- break;
-
- case 31:
-#line 233 "compilador.y"
- {
- char buffer[50];
- desempilha(buffer,proc);
- l_elem = busca(buffer,ts);
- sprintf(buffer,"RTPR %d,%d",l_elem->nivel,l_elem->info.fun.quant);
- geraCodigo(NULL,buffer);
- desloc = retira_vs_pf(ts);
- mostra_ts(ts);
- }
-#line 1698 "compilador.tab.c"
- break;
-
- case 33:
-#line 246 "compilador.y"
- {num_param = 0;}
-#line 1704 "compilador.tab.c"
- break;
-
- case 34:
-#line 247 "compilador.y"
- {
- char proc_ident[50];
- desempilha(proc_ident,proc);
- adiciona_param(proc_ident,num_param,ts);
- empilha(proc_ident,proc);
- mostra_ts(ts);
- }
-#line 1716 "compilador.tab.c"
- break;
-
- case 39:
-#line 263 "compilador.y"
- {
- num_vars = 0;
- val_ou_ref = REF;
- }
-#line 1725 "compilador.tab.c"
- break;
-
- case 40:
-#line 268 "compilador.y"
- {
- num_param += num_vars;
- val_ou_ref = VLR;
- }
-#line 1734 "compilador.tab.c"
- break;
-
- case 41:
-#line 272 "compilador.y"
- {
- num_vars = 0;
- val_ou_ref = VLR;
- }
-#line 1743 "compilador.tab.c"
- break;
-
- case 42:
-#line 277 "compilador.y"
- {num_param += num_vars;}
-#line 1749 "compilador.tab.c"
- break;
-
- case 45:
-#line 284 "compilador.y"
- {
- num_vars += 1;
- info_t info;
- info.pf.tipo = NSEI;
- info.pf.desloc = NSEI;
- info.pf.passagem = val_ou_ref;
- insere_ts(token,PF,nivel_lexico,info,ts);
- }
-#line 1762 "compilador.tab.c"
- break;
-
- case 58:
-#line 314 "compilador.y"
- {l_elem = busca(token, ts);}
-#line 1768 "compilador.tab.c"
- break;
-
- case 62:
-#line 322 "compilador.y"
- {
- if (l_elem == NULL) {
- yyerror("Variável de destino não declarada");
- } else {
- if (l_elem->categ == PF && l_elem->info.pf.passagem == REF)
- atr_indireto = REF;
- else atr_indireto = VLR;
- destino_nivel = l_elem->nivel;
- if(l_elem->categ == VS)
- destino_desloc = l_elem->info.vs.desloc;
- else if(l_elem->categ == PF)
- destino_desloc = l_elem->info.pf.desloc;
- else if(l_elem->categ == FUN)
- destino_desloc = l_elem->info.fun.desloc;
- else
- yyerror("Tentativa de atribuir em procedimento");
-
- }
-}
-#line 1792 "compilador.tab.c"
- break;
-
- case 63:
-#line 340 "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 1807 "compilador.tab.c"
- break;
-
- case 64:
-#line 353 "compilador.y"
- {
- if (l_elem == NULL){
- yyerror("Procedimento não declarado");
- } else{
- // Gera código para chamar o procedimento
- empilha(l_elem->ident, proc);
- }
- if (l_elem->categ == FUN)
- geraCodigo(NULL, "AMEM 1");
- if (l_elem->categ == PR || l_elem->categ == FUN)
- num_param = 0; // Reinicia a contagem de parâmetros reais
- }
-#line 1824 "compilador.tab.c"
- break;
-
- case 65:
-#line 368 "compilador.y"
- {
- char buffer[50];
- mostra_ts(ts);
- desempilha(buffer, proc);
- l_elem = busca(buffer, ts);
-
- if (l_elem->categ == PR || l_elem->categ ==FUN) {
- // Verifica se o número de parâmetros reais bate com os formais
- char error_msg[100];
- if (l_elem->categ == PR && num_param != l_elem->info.pr.quant) {
- 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 && num_param != l_elem->info.fun.quant){
- 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 1854 "compilador.tab.c"
- break;
-
- case 68:
-#line 402 "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 1866 "compilador.tab.c"
- break;
-
- case 69:
-#line 410 "compilador.y"
- {
- num_param++; // Incrementa para cada parâmetro real
- val_ou_ref = VLR;
- }
-#line 1875 "compilador.tab.c"
- break;
-
- case 70:
-#line 414 "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 1887 "compilador.tab.c"
- break;
-
- case 71:
-#line 422 "compilador.y"
- {
- num_param++; // Conta o primeiro parâmetro real
- val_ou_ref = VLR;
- }
-#line 1896 "compilador.tab.c"
- break;
-
- case 75:
-#line 435 "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 1908 "compilador.tab.c"
- break;
-
- case 77:
-#line 447 "compilador.y"
- {
- geraCodigo(NULL,"IMPR");
- }
-#line 1916 "compilador.tab.c"
- break;
-
- case 78:
-#line 450 "compilador.y"
- {
- geraCodigo(NULL,"IMPR");
- }
-#line 1924 "compilador.tab.c"
- break;
-
- case 79:
-#line 455 "compilador.y"
- {
- geraCodigo(NULL, "CMIG"); // Adiciona operação de cmig
- }
-#line 1932 "compilador.tab.c"
- break;
-
- case 80:
-#line 458 "compilador.y"
- {
- geraCodigo(NULL, "CMDG"); // Adiciona operação de cmdg
- }
-#line 1940 "compilador.tab.c"
- break;
-
- case 81:
-#line 461 "compilador.y"
- {
- geraCodigo(NULL, "CMME"); // Adiciona operação de cmme
- }
-#line 1948 "compilador.tab.c"
- break;
-
- case 82:
-#line 464 "compilador.y"
- {
- geraCodigo(NULL, "CMEG"); // Adiciona operação de cmeg
- }
-#line 1956 "compilador.tab.c"
- break;
-
- case 83:
-#line 467 "compilador.y"
- {
- geraCodigo(NULL, "CMMA"); // Adiciona operação de cmma
- }
-#line 1964 "compilador.tab.c"
- break;
-
- case 84:
-#line 470 "compilador.y"
- {
- geraCodigo(NULL, "CMAG"); // Adiciona operação de cmag
- }
-#line 1972 "compilador.tab.c"
- break;
-
- case 86:
-#line 476 "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 1983 "compilador.tab.c"
- break;
-
- case 87:
-#line 482 "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 1994 "compilador.tab.c"
- break;
-
- case 89:
-#line 491 "compilador.y"
- {
- geraCodigo(NULL, "MULT"); // Adiciona operação de mult
- }
-#line 2002 "compilador.tab.c"
- break;
-
- case 90:
-#line 494 "compilador.y"
- {
- geraCodigo(NULL, "DIVI"); // Adiciona operação de divi
- }
-#line 2010 "compilador.tab.c"
- break;
-
- case 92:
-#line 500 "compilador.y"
- {
- // Carrega variável
- l_elem = busca(token, ts);
- empilha(token, proc);
- }
-#line 2020 "compilador.tab.c"
- break;
-
- case 93:
-#line 506 "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);
- geraCodigo(NULL, buffer);
- }
- else if (l_elem->categ == PF){
- sprintf(buffer, "CREN %d,%d", l_elem->nivel, l_elem->info.pf.desloc);
- geraCodigo(NULL, buffer);
- }
- else
- yyerror("Tentativa de passagem de referencia de procedimento ou funcao");
-
- }
- 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);
- geraCodigo(NULL, buffer);
- }
- else {
- if (l_elem->categ == VS) {
- sprintf(buffer, "CRVL %d,%d", l_elem->nivel, l_elem->info.vs.desloc);
- geraCodigo(NULL, buffer);
- }
- else if (l_elem->categ == PF){
- sprintf(buffer, "CRVL %d,%d", l_elem->nivel, l_elem->info.pf.desloc);
- geraCodigo(NULL, buffer);
- }
- }
- }
- }
-#line 2061 "compilador.tab.c"
- break;
-
- case 94:
-#line 542 "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 2076 "compilador.tab.c"
- break;
-
- case 96:
-#line 555 "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 2088 "compilador.tab.c"
- break;
-
- case 97:
-#line 562 "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 2103 "compilador.tab.c"
- break;
-
- case 98:
-#line 572 "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 2122 "compilador.tab.c"
- break;
-
- case 99:
-#line 588 "compilador.y"
- {
- char r_fim[4];
- desempilha(r_fim,rot);
- geraCodigo(r_fim,"NADA");
- }
-#line 2132 "compilador.tab.c"
- break;
-
- case 102:
-#line 600 "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 2152 "compilador.tab.c"
- break;
-
- case 103:
-#line 615 "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 2171 "compilador.tab.c"
- break;
-
-
-#line 2175 "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 632 "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
deleted file mode 100644
index 2be6c98..0000000
--- a/compilador.tab.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/* 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
deleted file mode 100644
index ef6ad0e..0000000
--- a/lex.yy.c
+++ /dev/null
@@ -1,2196 +0,0 @@
-
-#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
deleted file mode 100644
index 5aa85557f8e7200312cb4b8bf4bffa3dbbe4b327..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
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
diff --git a/teste11.pas b/teste11.pas
index a0e801c..7d67e62 100644
--- a/teste11.pas
+++ b/teste11.pas
@@ -15,7 +15,8 @@ begin
write(n,k);
end;
begin
- write(f(3,m),m);
+ write(f(3,m),m);
+ v = m;
end.
diff --git a/ts/ts.o b/ts/ts.o
deleted file mode 100644
index babaf3b5062470db8121b6d0b67998e38bbdd582..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 11840
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%0AUW2
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
Z1&{y~qj`q`RDEOB4_)sKA8^K@9{>&1@$vuw
--
GitLab