q3aql/Serious-Engine
q3aql/Serious-Engine
1
0
Fork 0
mirror of https://github.com/ptitSeb/Serious-Engine synced 2024-11-22 10:20:26 +01:00
Code Issues Packages Projects Releases Wiki Activity
pandora
Serious-Engine/Sources/SeriousSkaStudio/Parser.cpp
SLAwww 9d8b787be2 Uploading full engine sources
2016-03-11 15:57:17 +02:00

2333 lines
75 KiB
C++
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* A Bison parser, made from seriousskastudio/parser.y with Bison version GNU Bison version 1.24
*/
#define YYBISON 1 /* Identify Bison output. */
#define c_float 258
#define c_int 259
#define c_string 260
#define k_SE_MESH 261
#define k_SE_SKELETON 262
#define k_PARENT 263
#define k_BONES 264
#define k_VERTICES 265
#define k_NORMALS 266
#define k_UVMAPS 267
#define k_NAME 268
#define k_TEXCOORDS 269
#define k_SURFACES 270
#define k_TRIANGLE_SET 271
#define k_WEIGHTS 272
#define k_WEIGHT_SET 273
#define k_MORPHS 274
#define k_RELATIVE 275
#define k_TRUE 276
#define k_FALSE 277
#define k_MORPH_SET 278
#define k_SE_MESH_END 279
#define k_SE_SKELETON_END 280
#define k_SE_ANIM 281
#define k_SEC_PER_FRAME 282
#define k_FRAMES 283
#define k_BONEENVELOPES 284
#define k_MORPHENVELOPES 285
#define k_DEFAULT_POSE 286
#define k_SE_ANIM_END 287
#define k_ANIM_SET_LIST 288
#define k_ANIM_ID 289
#define k_MAX_DISTANCE 290
#define k_MESHLODLIST 291
#define k_SKELETONLODLIST 292
#define k_TRESHOLD 293
#define k_COMPRESION 294
#define k_LENGTH 295
#define k_ANIMSPEED 296
#define k_SHADER_PARAMS 297
#define k_SHADER_PARAMS_END 298
#define k_SHADER_SURFACES 299
#define k_SHADER_SURFACE 300
#define k_SHADER_NAME 301
#define k_SHADER_TEXTURES 302
#define k_SHADER_UVMAPS 303
#define k_SHADER_COLORS 304
#define k_SHADER_FLOATS 305
#define k_SHADER_FLAGS 306
#define k_FULL_FACE_FORWARD 307
#define k_HALF_FACE_FORWARD 308
#line 1 "seriousskastudio/parser.y"
#include "StdAfx.h"
#include "ParsingSymbols.h"
#include <Engine/Templates/DynamicStackArray.cpp>
#include <Engine/Ska/StringTable.h>
#include <Engine/Ska/Render.h>
extern CTFileName strCurentFileName;
MeshLOD *pMeshLOD;
SkeletonLOD *pSkeletonLOD;
static INDEX _ctVertices = 0;
static INDEX _ctNormals = 0;
static INDEX _ctUVMaps = 0;
static INDEX _ctTexCoords = 0;
static INDEX _ctSurfaces = 0;
static INDEX _ctTriangles = 0;
static INDEX _ctWeights = 0;
static INDEX _ctVertexWeights = 0;
static INDEX _ctMorphs = 0;
static INDEX _ctVertexMorphs = 0;
static INDEX _ctBones = 0;
static INDEX _ctBoneEnvelopes = 0;
static INDEX _ctMorphEnvelopes = 0;
static INDEX _ctFrames = 0;
static INDEX _iBone = 0;
static INDEX _iVertex = 0;
static INDEX _iNormal = 0;
static INDEX _iUVMap = 0;
static INDEX _iTexCoord = 0;
static INDEX _iSurface = 0;
static INDEX _iTriangle = 0;
static INDEX _iWeight = 0;
static INDEX _iVertexWeight = 0;
static INDEX _iMorph = 0;
static INDEX _iVertexMorph = 0;
static INDEX _iBoneEnvelope = 0;
static INDEX _iMorphEnvelope = 0;
static INDEX _iFrame = 0;
/*
** Shader
*/
struct SurfaceShader
{
CTString fnShaderName;
INDEX ss_iSurfaceID;
ShaderParams ss_spShaderParams;
};
INDEX _ishParamIndex; // current index of shader param
INDEX _ctshParamsMax; // size of array allocated for shader params
CStaticArray<struct SurfaceShader> _assSurfaceShaders;
INDEX _iShaderSurfIndex = 0;
INDEX _ctShaderSurfaces = 0;
/*
**
*/
float _fCurentMaxDistance;// max distance for next lod
float _fTreshold = 0;// treshold for next animation
float _fAnimSpeed = -1;
BOOL bCompresion = FALSE;// is animation is using compresions
#line 67 "seriousskastudio/parser.y"
#define YYERROR_VERBOSE 1
// if error occurs in parsing
void yyerror(const char *strFormat, ...)
{
va_list arg;
va_start(arg, strFormat);
CTString strError;
strError.VPrintF(strFormat, arg);
// throw the string
ThrowF_t("File '%s' (line %d)\n%s",(const char*)strCurentFileName, _yy_iLine, (const char*)strError);
};
#line 85 "seriousskastudio/parser.y"
typedef union {
INDEX i;
float f;
const char *str;
float v2[2];
float v3[3];
int i3[3];
float f12[12];
} YYSTYPE;
#ifndef YYLTYPE
typedef
struct yyltype
{
int timestamp;
int first_line;
int first_column;
int last_line;
int last_column;
char *text;
}
yyltype;
#define YYLTYPE yyltype
#endif
#include <stdio.h>
#ifndef __cplusplus
#ifndef __STDC__
#define const
#endif
#endif
#define YYFINAL 427
#define YYFLAG -32768
#define YYNTBASE 58
#define YYTRANSLATE(x) ((unsigned)(x) <= 308 ? yytranslate[x] : 184)
static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 57, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 56, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 54, 2, 55, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 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, 43, 44, 45,
46, 47, 48, 49, 50, 51, 52, 53
};
#if YYDEBUG != 0
static const short yyprhs[] = { 0,
0, 2, 4, 6, 8, 10, 15, 16, 18, 20,
23, 24, 28, 41, 46, 47, 49, 51, 54, 63,
64, 67, 68, 72, 73, 77, 81, 91, 92, 99,
100, 102, 104, 107, 108, 120, 122, 125, 128, 129,
136, 137, 139, 141, 144, 145, 152, 154, 157, 160,
163, 166, 171, 172, 174, 176, 179, 184, 188, 189,
196, 197, 199, 201, 204, 205, 217, 222, 225, 226,
228, 229, 230, 243, 244, 246, 248, 251, 260, 268,
269, 277, 278, 280, 282, 285, 288, 289, 297, 298,
300, 302, 305, 308, 309, 317, 318, 320, 322, 325,
328, 329, 337, 338, 340, 342, 345, 348, 349, 351,
355, 359, 360, 363, 364, 367, 368, 375, 377, 380,
383, 384, 391, 393, 396, 399, 400, 407, 408, 410,
412, 415, 416, 428, 430, 433, 436, 437, 444, 446,
449, 450, 462, 464, 467, 470, 471, 478, 479, 481,
483, 486, 487, 499, 501, 504, 511, 512, 519, 520,
522, 524, 527, 528, 542, 544, 547, 564, 567, 569,
571, 573, 577, 583, 589, 595, 619, 622
};
static const short yyrhs[] = { 63,
0, 90, 0, 66, 0, 64, 0, 59, 0, 36,
54, 60, 55, 0, 0, 61, 0, 63, 0, 61,
63, 0, 0, 35, 176, 56, 0, 62, 103, 133,
134, 135, 136, 140, 144, 152, 159, 167, 175, 0,
33, 54, 65, 55, 0, 0, 66, 0, 67, 0,
66, 67, 0, 69, 68, 70, 71, 72, 73, 81,
89, 0, 0, 39, 183, 0, 0, 38, 176, 56,
0, 0, 41, 176, 56, 0, 26, 3, 56, 0,
27, 3, 56, 28, 4, 56, 34, 5, 56, 0,
0, 29, 4, 74, 54, 75, 55, 0, 0, 76,
0, 77, 0, 75, 77, 0, 0, 13, 5, 31,
54, 182, 56, 78, 55, 54, 79, 55, 0, 80,
0, 79, 80, 0, 182, 56, 0, 0, 30, 4,
82, 54, 83, 55, 0, 0, 84, 0, 85, 0,
83, 85, 0, 0, 13, 5, 86, 54, 87, 55,
0, 88, 0, 87, 88, 0, 3, 56, 0, 4,
56, 0, 32, 56, 0, 37, 54, 91, 55, 0,
0, 92, 0, 93, 0, 92, 93, 0, 62, 94,
95, 102, 0, 7, 3, 56, 0, 0, 9, 4,
54, 96, 97, 55, 0, 0, 98, 0, 99, 0,
97, 99, 0, 0, 13, 5, 56, 8, 5, 56,
40, 176, 100, 56, 101, 0, 54, 182, 56, 55,
0, 25, 56, 0, 0, 104, 0, 0, 0, 42,
176, 56, 44, 4, 54, 105, 107, 55, 56, 106,
43, 0, 0, 108, 0, 109, 0, 108, 109, 0,
110, 111, 116, 121, 126, 131, 55, 56, 0, 45,
5, 56, 54, 46, 5, 56, 0, 0, 47, 4,
112, 54, 113, 55, 56, 0, 0, 114, 0, 115,
0, 114, 115, 0, 5, 56, 0, 0, 48, 4,
117, 54, 118, 55, 56, 0, 0, 119, 0, 120,
0, 119, 120, 0, 4, 56, 0, 0, 49, 4,
122, 54, 123, 55, 56, 0, 0, 124, 0, 125,
0, 124, 125, 0, 4, 56, 0, 0, 50, 4,
127, 54, 128, 55, 56, 0, 0, 129, 0, 130,
0, 129, 130, 0, 176, 56, 0, 0, 132, 0,
51, 4, 56, 0, 6, 3, 56, 0, 0, 52,
183, 0, 0, 53, 183, 0, 0, 10, 4, 54,
137, 138, 55, 0, 139, 0, 138, 139, 0, 179,
56, 0, 0, 11, 4, 54, 141, 142, 55, 0,
143, 0, 142, 143, 0, 180, 56, 0, 0, 12,
4, 54, 145, 146, 55, 0, 0, 147, 0, 148,
0, 147, 148, 0, 0, 54, 13, 5, 56, 14,
4, 54, 149, 150, 55, 55, 0, 151, 0, 150,
151, 0, 178, 56, 0, 0, 15, 4, 54, 153,
154, 55, 0, 155, 0, 154, 155, 0, 0, 54,
13, 5, 56, 16, 4, 54, 156, 157, 55, 55,
0, 158, 0, 157, 158, 0, 181, 56, 0, 0,
17, 4, 54, 160, 161, 55, 0, 0, 162, 0,
163, 0, 161, 163, 0, 0, 54, 13, 5, 56,
18, 4, 54, 164, 165, 55, 55, 0, 166, 0,
165, 166, 0, 54, 4, 56, 176, 56, 55, 0,
0, 19, 4, 54, 168, 169, 55, 0, 0, 170,
0, 171, 0, 169, 171, 0, 0, 54, 13, 5,
56, 20, 183, 23, 4, 172, 54, 173, 55, 55,
0, 174, 0, 173, 174, 0, 54, 4, 56, 176,
57, 176, 57, 176, 56, 176, 57, 176, 57, 176,
56, 55, 0, 24, 56, 0, 3, 0, 4, 0,
4, 0, 176, 57, 176, 0, 176, 57, 176, 57,
176, 0, 176, 57, 176, 57, 176, 0, 177, 57,
177, 57, 177, 0, 176, 57, 176, 57, 176, 57,
176, 57, 176, 57, 176, 57, 176, 57, 176, 57,
176, 57, 176, 57, 176, 57, 176, 0, 21, 56,
0, 22, 56, 0
};
#endif
#if YYDEBUG != 0
static const short yyrline[] = { 0,
168, 169, 170, 171, 172, 180, 184, 185, 189, 190,
194, 198, 205, 214, 218, 219, 223, 224, 228, 232,
234, 238, 240, 245, 249, 256, 272, 302, 319, 328,
329, 333, 334, 338, 366, 383, 384, 388, 407, 420,
429, 430, 434, 435, 439, 453, 469, 470, 474, 487,
503, 512, 516, 517, 521, 522, 526, 530, 537, 559,
568, 569, 573, 574, 578, 592, 596, 612, 621, 628,
632, 640, 644, 647, 648, 652, 653, 656, 663, 673,
679, 690, 691, 694, 695, 699, 714, 720, 731, 732,
735, 736, 739, 754, 760, 771, 772, 775, 776, 779,
794, 801, 812, 813, 816, 817, 820, 835, 836, 839,
847, 861, 865, 875, 879, 890, 899, 908, 909, 913,
927, 940, 949, 950, 954, 968, 978, 987, 988, 992,
993, 997, 1016, 1026, 1027, 1031, 1047, 1064, 1073, 1074,
1078, 1120, 1130, 1131, 1135, 1152, 1162, 1171, 1172, 1176,
1177, 1181, 1198, 1208, 1209, 1213, 1235, 1246, 1255, 1256,
1259, 1260, 1264, 1282, 1292, 1293, 1297, 1320, 1325, 1329,
1335, 1341, 1348, 1356, 1364, 1372, 1389, 1393
};
static const char * const yytname[] = { "$","error","$undefined.","c_float",
"c_int","c_string","k_SE_MESH","k_SE_SKELETON","k_PARENT","k_BONES","k_VERTICES",
"k_NORMALS","k_UVMAPS","k_NAME","k_TEXCOORDS","k_SURFACES","k_TRIANGLE_SET",
"k_WEIGHTS","k_WEIGHT_SET","k_MORPHS","k_RELATIVE","k_TRUE","k_FALSE","k_MORPH_SET",
"k_SE_MESH_END","k_SE_SKELETON_END","k_SE_ANIM","k_SEC_PER_FRAME","k_FRAMES",
"k_BONEENVELOPES","k_MORPHENVELOPES","k_DEFAULT_POSE","k_SE_ANIM_END","k_ANIM_SET_LIST",
"k_ANIM_ID","k_MAX_DISTANCE","k_MESHLODLIST","k_SKELETONLODLIST","k_TRESHOLD",
"k_COMPRESION","k_LENGTH","k_ANIMSPEED","k_SHADER_PARAMS","k_SHADER_PARAMS_END",
"k_SHADER_SURFACES","k_SHADER_SURFACE","k_SHADER_NAME","k_SHADER_TEXTURES","k_SHADER_UVMAPS",
"k_SHADER_COLORS","k_SHADER_FLOATS","k_SHADER_FLAGS","k_FULL_FACE_FORWARD","k_HALF_FACE_FORWARD",
"'{'","'}'","';'","','","program","meshlod_list","meshlod_array_opt","meshlod_array",
"max_distance","meshlod","animset_list","animset_array_opt","animset_array",
"animset","compresion_opt","treshold_opt","animspeed_opt","animset_begin","animation_header",
"bone_envelopes","@1","bone_env_header_opt","bone_env_header","bone_envelope",
"@2","bone_env_array","bone_env_m","morph_envelopes","@3","morph_env_header",
"morph_env_header_notnull","morph_env","@4","morph_env_array","morph_env_i",
"animset_end","skeletonlod_list","opt_skeletonlod_array","skeletonlod_array",
"skeletonlod","skeleton_begin","bones","@5","bone_headers","bone_headers_notnull",
"bone_header","@6","bone","skeleton_end","shader_params_opt","shader_params",
"@7","@8","surface_shader_params_array_opt","surface_shader_params_array","surface_shader_params",
"shader_name","shader_textures","@9","shader_texture_array_opt","shader_texture_array",
"shader_texture","shader_uvmaps","@10","shader_uvmaps_array_opt","shader_uvmaps_array",
"shader_uvmap","shader_colors","@11","shader_colors_array_opt","shader_colors_array",
"shader_color","shader_floats","@12","shader_floats_array_opt","shader_floats_array",
"shader_float","shader_flag_opt","shader_flags","mesh_begin","is_full_faceforward_opt",
"is_half_faceforward_opt","vertices","@13","vert3_array","vert3_array_value",
"normals","@14","norm3_array","norm3_array_value","uvmaps","@15","uvmaps_opt_array",
"uvmaps_array","uvmap","@16","uv2_array","uv2_array_value","surfaces","@17",
"surfaces_array","triangleset","@18","triangle_array","triangle_array_value",
"weights","@19","weights_array","weights_array_notnull","weightset","@20","weight_map_array",
"weight_map_array_value","morphs","@21","morphs_array","morphs_array_notnull",
"morphset","@22","morph_set_array","morph_set_array_value","mesh_end","float_const",
"int_const","uv2","vert3","norm3","triangle","matrix","boolean",""
};
#endif
static const short yyr1[] = { 0,
58, 58, 58, 58, 58, 59, 60, 60, 61, 61,
62, 62, 63, 64, 65, 65, 66, 66, 67, 68,
68, 69, 69, 70, 70, 71, 72, 74, 73, 75,
75, 76, 76, 78, 77, 79, 79, 80, 82, 81,
83, 83, 84, 84, 86, 85, 87, 87, 88, 88,
89, 90, 91, 91, 92, 92, 93, 94, 96, 95,
97, 97, 98, 98, 100, 99, 101, 102, 103, 103,
105, 106, 104, 107, 107, 108, 108, 109, 110, 112,
111, 113, 113, 114, 114, 115, 117, 116, 118, 118,
119, 119, 120, 122, 121, 123, 123, 124, 124, 125,
127, 126, 128, 128, 129, 129, 130, 131, 131, 132,
133, 134, 134, 135, 135, 137, 136, 138, 138, 139,
141, 140, 142, 142, 143, 145, 144, 146, 146, 147,
147, 149, 148, 150, 150, 151, 153, 152, 154, 154,
156, 155, 157, 157, 158, 160, 159, 161, 161, 162,
162, 164, 163, 165, 165, 166, 168, 167, 169, 169,
170, 170, 172, 171, 173, 173, 174, 175, 176, 176,
177, 178, 179, 180, 181, 182, 183, 183
};
static const short yyr2[] = { 0,
1, 1, 1, 1, 1, 4, 0, 1, 1, 2,
0, 3, 12, 4, 0, 1, 1, 2, 8, 0,
2, 0, 3, 0, 3, 3, 9, 0, 6, 0,
1, 1, 2, 0, 11, 1, 2, 2, 0, 6,
0, 1, 1, 2, 0, 6, 1, 2, 2, 2,
2, 4, 0, 1, 1, 2, 4, 3, 0, 6,
0, 1, 1, 2, 0, 11, 4, 2, 0, 1,
0, 0, 12, 0, 1, 1, 2, 8, 7, 0,
7, 0, 1, 1, 2, 2, 0, 7, 0, 1,
1, 2, 2, 0, 7, 0, 1, 1, 2, 2,
0, 7, 0, 1, 1, 2, 2, 0, 1, 3,
3, 0, 2, 0, 2, 0, 6, 1, 2, 2,
0, 6, 1, 2, 2, 0, 6, 0, 1, 1,
2, 0, 11, 1, 2, 2, 0, 6, 1, 2,
0, 11, 1, 2, 2, 0, 6, 0, 1, 1,
2, 0, 11, 1, 2, 6, 0, 6, 0, 1,
1, 2, 0, 13, 1, 2, 16, 2, 1, 1,
1, 3, 5, 5, 5, 23, 2, 2
};
static const short yydefact[] = { 22,
0, 0, 0, 0, 0, 5, 69, 1, 4, 22,
17, 20, 2, 22, 169, 170, 0, 11, 11, 0,
0, 0, 70, 18, 0, 24, 0, 22, 12, 0,
11, 9, 0, 0, 11, 55, 23, 0, 0, 112,
0, 0, 21, 0, 0, 14, 6, 10, 0, 0,
52, 56, 0, 0, 0, 114, 177, 178, 0, 0,
0, 0, 0, 0, 0, 111, 113, 0, 0, 25,
0, 0, 0, 58, 0, 0, 57, 0, 115, 0,
0, 26, 0, 0, 0, 59, 68, 71, 0, 0,
0, 0, 28, 0, 0, 61, 74, 116, 0, 0,
0, 0, 0, 39, 0, 19, 0, 0, 62, 63,
0, 0, 75, 76, 0, 0, 121, 0, 0, 0,
0, 30, 0, 51, 0, 60, 64, 0, 0, 77,
0, 0, 0, 118, 0, 0, 0, 126, 0, 0,
0, 0, 0, 0, 31, 32, 41, 0, 0, 72,
80, 0, 0, 117, 119, 0, 120, 0, 123, 0,
0, 128, 137, 0, 0, 0, 0, 0, 29, 33,
0, 0, 42, 43, 0, 0, 0, 0, 87, 0,
0, 0, 122, 124, 0, 125, 0, 0, 129, 130,
0, 146, 0, 0, 13, 0, 0, 45, 40, 44,
0, 0, 73, 82, 0, 94, 0, 108, 0, 0,
0, 127, 131, 0, 0, 139, 148, 157, 168, 27,
0, 0, 0, 0, 0, 0, 83, 84, 89, 0,
101, 0, 0, 109, 173, 0, 0, 0, 138, 140,
0, 0, 149, 150, 159, 0, 0, 0, 0, 79,
86, 0, 85, 0, 0, 90, 91, 96, 0, 0,
0, 174, 0, 0, 0, 147, 151, 0, 0, 160,
161, 0, 34, 0, 0, 0, 47, 65, 81, 93,
0, 92, 0, 0, 97, 98, 103, 110, 78, 0,
0, 0, 0, 158, 162, 0, 0, 49, 50, 46,
48, 0, 88, 100, 0, 99, 0, 104, 105, 0,
0, 0, 0, 0, 0, 0, 0, 95, 0, 106,
107, 132, 0, 0, 0, 0, 0, 0, 66, 102,
0, 141, 0, 0, 0, 0, 36, 0, 0, 0,
134, 0, 0, 0, 152, 0, 0, 35, 37, 38,
0, 0, 135, 0, 136, 171, 0, 143, 0, 0,
0, 0, 0, 67, 133, 172, 0, 144, 0, 145,
0, 0, 154, 163, 0, 142, 0, 0, 0, 155,
0, 0, 0, 0, 153, 0, 0, 175, 0, 0,
0, 165, 0, 0, 0, 0, 166, 0, 156, 0,
164, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 176,
0, 0, 0, 167, 0, 0, 0
};
static const short yydefgoto[] = { 425,
6, 30, 31, 7, 8, 9, 27, 10, 11, 26,
12, 45, 61, 73, 85, 103, 144, 145, 146, 297,
336, 337, 95, 123, 172, 173, 174, 222, 276, 277,
106, 13, 34, 35, 36, 50, 64, 96, 108, 109,
110, 302, 329, 77, 22, 23, 97, 177, 112, 113,
114, 115, 132, 178, 226, 227, 228, 153, 205, 255,
256, 257, 181, 230, 284, 285, 286, 208, 259, 307,
308, 309, 233, 234, 40, 56, 69, 81, 116, 133,
134, 91, 137, 158, 159, 101, 162, 188, 189, 190,
331, 340, 341, 120, 191, 215, 216, 344, 357, 358,
141, 217, 242, 243, 244, 361, 372, 373, 166, 245,
269, 270, 271, 381, 391, 392, 195, 246, 359, 343,
136, 161, 360, 338, 43
};
static const short yypact[] = { 34,
-26, 30, -23, -1, 30,-32768, 15,-32768,-32768, 16,
-32768, 22,-32768, -18,-32768,-32768, 28, -17, -11, 29,
30, 49,-32768,-32768, 14, 42, 20, -16,-32768, 31,
-10,-32768, 61, 32, -9,-32768,-32768, 33, 85, 38,
35, 36,-32768, 30, 67,-32768,-32768,-32768, 91, 86,
-32768,-32768, 52, 41, 14, 45,-32768,-32768, 43, 97,
74, 46, 99, 79, 101,-32768,-32768, 14, 96,-32768,
51, 105, 81,-32768, 57, 56,-32768, 59,-32768, 111,
106,-32768, 60, 114, 89,-32768,-32768,-32768, 66, 117,
110, 95,-32768, 120, 93, 113, 82,-32768, 75, 124,
115, 128, 80,-32768, 77,-32768, 131, 4,-32768,-32768,
132, 83, 82,-32768, 92, 30,-32768, 87, 136, 125,
88, 130, 94,-32768, 90,-32768,-32768, 102, 103,-32768,
141, 104, 1,-32768, 98, 107, 30,-32768, 108, 143,
134, 116, 144, 8,-32768,-32768, 138, 149, 112,-32768,
-32768, 156, 118,-32768,-32768, 30,-32768, 3,-32768, 119,
109, 121,-32768, 123, 157, 140, 163, 139,-32768,-32768,
164, 10,-32768,-32768, 166, 126, 135, 127,-32768, 169,
129, 133,-32768,-32768, 30,-32768, 161, 137, 121,-32768,
142,-32768, 145, 146,-32768, 147, 150,-32768,-32768,-32768,
152, 175,-32768, 177, 151,-32768, 180, 155, 30, 153,
181,-32768,-32768, 172, -5,-32768, 158,-32768,-32768,-32768,
30, 159, 148, 160, 162, 154, 177,-32768, 183, 165,
-32768, 185, 167,-32768,-32768, 30, 168, 186,-32768,-32768,
182, -3,-32768,-32768, 171, 170, 173, 70, 30,-32768,
-32768, 174,-32768, 176, 178, 183,-32768, 189, 184, 179,
187,-32768, 197, 188, 192,-32768,-32768, 201, 23,-32768,
-32768, 30,-32768, 190, 193, 5,-32768,-32768,-32768,-32768,
194,-32768, 195, 198, 189,-32768, 30,-32768,-32768, 196,
199, 200, 212,-32768,-32768, 191, 202,-32768,-32768,-32768,
-32768, 203,-32768,-32768, 204,-32768, 206, 30,-32768, 207,
208, 216, 205, 209, 30, 210, 213,-32768, 215,-32768,
-32768,-32768, 214, 217, 211, 218, 30, 30,-32768,-32768,
30,-32768, 219, 14, 30, 7,-32768, 220, 221, 9,
-32768, 222, 225, 224,-32768, 229, 226,-32768,-32768,-32768,
223, 227,-32768, 30,-32768,-32768, 11,-32768, 230, 228,
232, 233, 30,-32768,-32768,-32768, 234,-32768, 224,-32768,
235, 25,-32768,-32768, 231,-32768, 236, 238, 237,-32768,
241, 30, 224, 30,-32768, 242, 240,-32768, 243, 250,
27,-32768, 30, 245, 246, 248,-32768, 244,-32768, 30,
-32768, 30, 247, 251, 30, 30, 252, 253, 30, 30,
249, 254, 30, 30, 255, 257, 30, 30, 258,-32768,
30, 260, 262,-32768, 266, 269,-32768
};
static const short yypgoto[] = {-32768,
-32768,-32768,-32768, 13, 12,-32768,-32768, 276, 19,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 50,-32768,
-32768, -138,-32768,-32768,-32768,-32768, 54,-32768,-32768, -75,
-32768,-32768,-32768,-32768, 239,-32768,-32768,-32768,-32768,-32768,
256,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
259,-32768,-32768,-32768,-32768,-32768, 18,-32768,-32768,-32768,
-32768, -20,-32768,-32768,-32768,-32768, -45,-32768,-32768,-32768,
-32768, -67,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
122,-32768,-32768,-32768, 84,-32768,-32768,-32768,-32768, 69,
-32768,-32768, -68,-32768,-32768,-32768, 76,-32768,-32768, -59,
-32768,-32768,-32768,-32768, 65,-32768,-32768, -53,-32768,-32768,
-32768,-32768, 53,-32768,-32768, -73,-32768, -2, -342,-32768,
-32768,-32768,-32768, -219, -54
};
#define YYLAST 419
static const short yytable[] = { 17,
67, 247, 20, 15, 16, 15, 16, 274, 275, 15,
16, 15, 16, 79, 356, -3, 107, 2, 38, 5,
143, 5, 171, 2, 2, 2, 377, 14, 24, 32,
18, 33, 15, 16, 41, 42, -15, -7, -16, -11,
388, 59, 48, -53, -8, -54, 24, 33, 214, 239,
241, 266, 19, 5, 39, 154, 21, 183, 126, 300,
25, 348, 169, 352, 199, 367, 1, 49, 2, 3,
4, 5, 274, 275, 46, -11, 268, 294, 371, 379,
390, 396, 44, 29, 37, 47, 51, 54, 53, 55,
57, 58, 60, 62, 63, 65, 66, 68, 70, 71,
72, 74, 75, 76, 78, 80, 82, 83, 339, 84,
86, 87, 88, 135, 89, 92, 90, 93, 94, 98,
99, 100, 102, 104, 105, 107, 111, 118, 117, 119,
135, 121, 124, 122, 160, 125, 128, 129, 131, 139,
138, 140, 143, 142, 151, 148, 164, 147, 168, 167,
171, 152, 165, 182, 156, 160, 175, 149, 150, 179,
193, 163, 157, 194, 186, 176, 180, 196, 198, 197,
201, 202, 206, 211, 187, 185, 192, 203, 207, 224,
204, 225, 210, 231, 238, 237, 254, 249, 260, 209,
264, 212, 283, 170, 265, 214, 292, 349, 218, 311,
301, 219, 220, 221, 229, 232, 235, 223, 252, 236,
290, 241, 248, 293, 312, 250, 314, 251, 258, 323,
333, 261, 324, 263, 268, 200, 272, 356, 273, 279,
334, 280, 281, 262, 288, 282, 374, 287, 378, 306,
320, 184, 289, 291, 253, 298, 278, 315, 299, 303,
304, 362, 305, 395, 155, 313, 316, 213, 317, 318,
319, 322, 321, 327, 325, 426, 328, 332, 427, 296,
330, 353, 345, 52, 335, 350, 351, 364, 354, 346,
355, 365, 363, 370, 310, 371, 369, 382, 376, 28,
240, 385, 383, 384, 386, 390, 393, 368, 394, 399,
402, 400, 401, 405, 413, 310, 267, 406, 409, 410,
414, 417, 326, 418, 421, 423, 424, 397, 380, 0,
0, 295, 0, 0, 0, 0, 0, 0, 342, 0,
0, 0, 347, 0, 0, 0, 0, 342, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 366, 0, 0, 0, 0, 0, 0, 0, 0,
375, 0, 0, 127, 0, 0, 0, 0, 0, 0,
0, 130, 0, 0, 0, 0, 0, 0, 0, 387,
0, 389, 0, 0, 0, 0, 0, 0, 0, 0,
398, 0, 0, 0, 0, 0, 0, 403, 0, 404,
0, 0, 407, 408, 0, 0, 411, 412, 0, 0,
415, 416, 0, 0, 419, 420, 0, 0, 422
};
static const short yycheck[] = { 2,
55, 221, 5, 3, 4, 3, 4, 3, 4, 3,
4, 3, 4, 68, 4, 0, 13, 35, 21, 38,
13, 38, 13, 35, 35, 35, 369, 54, 10, 18,
54, 19, 3, 4, 21, 22, 55, 55, 55, 6,
383, 44, 31, 55, 55, 55, 28, 35, 54, 55,
54, 55, 54, 38, 6, 55, 42, 55, 55, 55,
39, 55, 55, 55, 55, 55, 33, 7, 35, 36,
37, 38, 3, 4, 55, 42, 54, 55, 54, 55,
54, 55, 41, 56, 56, 55, 55, 3, 56, 52,
56, 56, 26, 3, 9, 44, 56, 53, 56, 3,
27, 56, 4, 25, 4, 10, 56, 3, 328, 29,
54, 56, 54, 116, 4, 56, 11, 4, 30, 54,
4, 12, 28, 4, 32, 13, 45, 4, 54, 15,
133, 4, 56, 54, 137, 5, 5, 55, 47, 4,
54, 17, 13, 56, 4, 56, 4, 54, 5, 34,
13, 48, 19, 156, 57, 158, 8, 56, 56, 4,
4, 54, 56, 24, 56, 54, 49, 5, 5, 31,
5, 46, 4, 13, 54, 57, 54, 43, 50, 5,
54, 5, 185, 4, 13, 5, 4, 40, 4, 57,
5, 55, 4, 144, 13, 54, 5, 336, 54, 4,
276, 56, 56, 54, 54, 51, 209, 56, 55, 57,
14, 54, 54, 13, 16, 56, 5, 56, 54, 4,
4, 55, 18, 56, 54, 172, 57, 4, 56, 56,
20, 56, 55, 236, 56, 256, 4, 54, 4, 285,
308, 158, 56, 56, 227, 56, 249, 57, 56, 56,
56, 23, 55, 4, 133, 56, 55, 189, 56, 56,
55, 54, 56, 54, 56, 0, 54, 54, 0, 272,
56, 340, 54, 35, 57, 56, 56, 55, 57, 334,
56, 55, 57, 56, 287, 54, 57, 57, 55, 14,
215, 55, 57, 56, 54, 54, 57, 357, 56, 55,
57, 56, 55, 57, 56, 308, 242, 57, 57, 57,
57, 57, 315, 57, 57, 56, 55, 391, 372, -1,
-1, 269, -1, -1, -1, -1, -1, -1, 331, -1,
-1, -1, 335, -1, -1, -1, -1, 340, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 354, -1, -1, -1, -1, -1, -1, -1, -1,
363, -1, -1, 108, -1, -1, -1, -1, -1, -1,
-1, 113, -1, -1, -1, -1, -1, -1, -1, 382,
-1, 384, -1, -1, -1, -1, -1, -1, -1, -1,
393, -1, -1, -1, -1, -1, -1, 400, -1, 402,
-1, -1, 405, 406, -1, -1, 409, 410, -1, -1,
413, 414, -1, -1, 417, 418, -1, -1, 421
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
#line 3 "bison.simple"
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
#undef YYERROR_VERBOSE
#ifndef alloca
#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not GNU C. */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
#include <alloca.h>
#else /* not sparc */
#if defined (MSDOS) && !defined (__TURBOC__)
#include <malloc.h>
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
#include <malloc.h>
#pragma alloca
#else /* not MSDOS, __TURBOC__, or _AIX */
#ifdef __hpux
#ifdef __cplusplus
extern "C" {
void *alloca (unsigned int);
};
#else /* not __cplusplus */
void *alloca ();
#endif /* not __cplusplus */
#endif /* __hpux */
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc. */
#endif /* not GNU C. */
#endif /* alloca not defined. */
/* This is the parser code that is written into each bison parser
when the %semantic_parser declaration is not specified in the grammar.
It was written by Richard Stallman by simplifying the hairy parser
used when %semantic_parser is specified. */
/* Note: there must be only one dollar sign in this file.
It is replaced by the list of actions, each action
as one case of the switch. */
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY -2
#define YYEOF 0
#define YYACCEPT return(0)
#define YYABORT return(1)
#define YYERROR goto yyerrlab1
/* Like YYERROR except do call yyerror.
This remains here temporarily to ease the
transition to the new meaning of YYERROR, for GCC.
Once GCC version 2 has supplanted version 1, this can go. */
#define YYFAIL goto yyerrlab
#define YYRECOVERING() (!!yyerrstatus)
#define YYBACKUP(token, value) \
do \
if (yychar == YYEMPTY && yylen == 1) \
{ yychar = (token), yylval = (value); \
yychar1 = YYTRANSLATE (yychar); \
YYPOPSTACK; \
goto yybackup; \
} \
else \
{ yyerror ("syntax error: cannot back up"); YYERROR; } \
while (0)
#define YYTERROR 1
#define YYERRCODE 256
#ifndef YYPURE
#define YYLEX yylex()
#endif
#ifdef YYPURE
#ifdef YYLSP_NEEDED
#ifdef YYLEX_PARAM
#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
#else
#define YYLEX yylex(&yylval, &yylloc)
#endif
#else /* not YYLSP_NEEDED */
#ifdef YYLEX_PARAM
#define YYLEX yylex(&yylval, YYLEX_PARAM)
#else
#define YYLEX yylex(&yylval)
#endif
#endif /* not YYLSP_NEEDED */
#endif
/* If nonreentrant, generate the variables here */
#ifndef YYPURE
int yychar; /* the lookahead symbol */
YYSTYPE yylval; /* the semantic value of the */
/* lookahead symbol */
#ifdef YYLSP_NEEDED
YYLTYPE yylloc; /* location data for the lookahead */
/* symbol */
#endif
int yynerrs; /* number of parse errors so far */
#endif /* not YYPURE */
#if YYDEBUG != 0
int yydebug; /* nonzero means print parse trace */
/* Since this is uninitialized, it does not stop multiple parsers
from coexisting. */
#endif
/* YYINITDEPTH indicates the initial size of the parser's stacks */
#ifndef YYINITDEPTH
#define YYINITDEPTH 200
#endif
/* YYMAXDEPTH is the maximum size the stacks can grow to
(effective only if the built-in stack extension method is used). */
#if YYMAXDEPTH == 0
#undef YYMAXDEPTH
#endif
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif
/* Prevent warning if -Wstrict-prototypes. */
#ifdef __GNUC__
int yyparse (void);
#endif
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
#define __yy_memcpy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT)
#else /* not GNU C or C++ */
#ifndef __cplusplus
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__yy_memcpy (from, to, count)
char *from;
char *to;
int count;
{
register char *f = from;
register char *t = to;
register int i = count;
while (i-- > 0)
*t++ = *f++;
}
#else /* __cplusplus */
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__yy_memcpy (char *from, char *to, int count)
{
register char *f = from;
register char *t = to;
register int i = count;
while (i-- > 0)
*t++ = *f++;
}
#endif
#endif
#line 192 "bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
It should actually point to an object.
Grammar actions can access the variable by casting it
to the proper pointer type. */
#ifdef YYPARSE_PARAM
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
#else
#define YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#endif
int
yyparse(YYPARSE_PARAM)
YYPARSE_PARAM_DECL
{
register int yystate;
register int yyn;
register short *yyssp;
register YYSTYPE *yyvsp;
int yyerrstatus; /* number of tokens to shift before error messages enabled */
int yychar1 = 0; /* lookahead token as an internal (translated) token number */
short yyssa[YYINITDEPTH]; /* the state stack */
YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
short *yyss = yyssa; /* refer to the stacks thru separate pointers */
YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
#ifdef YYLSP_NEEDED
YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
YYLTYPE *yyls = yylsa;
YYLTYPE *yylsp;
#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
#else
#define YYPOPSTACK (yyvsp--, yyssp--)
#endif
int yystacksize = YYINITDEPTH;
#ifdef YYPURE
int yychar;
YYSTYPE yylval;
int yynerrs;
#ifdef YYLSP_NEEDED
YYLTYPE yylloc;
#endif
#endif
YYSTYPE yyval; /* the variable used to return */
/* semantic values from the action */
/* routines */
int yylen;
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Starting parse\n");
#endif
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
yyssp = yyss - 1;
yyvsp = yyvs;
#ifdef YYLSP_NEEDED
yylsp = yyls;
#endif
/* Push a new state, which is found in yystate . */
/* In all cases, when you get here, the value and location stacks
have just been pushed. so pushing a state here evens the stacks. */
yynewstate:
*++yyssp = yystate;
if (yyssp >= yyss + yystacksize - 1)
{
/* Give user a chance to reallocate the stack */
/* Use copies of these so that the &'s don't force the real ones into memory. */
YYSTYPE *yyvs1 = yyvs;
short *yyss1 = yyss;
#ifdef YYLSP_NEEDED
YYLTYPE *yyls1 = yyls;
#endif
/* Get the current used size of the three stacks, in elements. */
int size = yyssp - yyss + 1;
#ifdef yyoverflow
/* Each stack pointer address is followed by the size of
the data in use in that stack, in bytes. */
#ifdef YYLSP_NEEDED
/* This used to be a conditional around just the two extra args,
but that might be undefined if yyoverflow is a macro. */
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
&yyls1, size * sizeof (*yylsp),
&yystacksize);
#else
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
&yystacksize);
#endif
yyss = yyss1; yyvs = yyvs1;
#ifdef YYLSP_NEEDED
yyls = yyls1;
#endif
#else /* no yyoverflow */
/* Extend the stack our own way. */
if (yystacksize >= YYMAXDEPTH)
{
yyerror("parser stack overflow");
return 2;
}
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
__yy_memcpy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
__yy_memcpy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
#ifdef YYLSP_NEEDED
yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
__yy_memcpy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
#endif
#endif /* no yyoverflow */
yyssp = yyss + size - 1;
yyvsp = yyvs + size - 1;
#ifdef YYLSP_NEEDED
yylsp = yyls + size - 1;
#endif
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Stack size increased to %d\n", yystacksize);
#endif
if (yyssp >= yyss + yystacksize - 1)
YYABORT;
}
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Entering state %d\n", yystate);
#endif
goto yybackup;
yybackup:
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* yyresume: */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
/* yychar is either YYEMPTY or YYEOF
or a valid token in external form. */
if (yychar == YYEMPTY)
{
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Reading a token: ");
#endif
yychar = YYLEX;
}
/* Convert token to internal form (in yychar1) for indexing tables with */
if (yychar <= 0) /* This means end of input. */
{
yychar1 = 0;
yychar = YYEOF; /* Don't call YYLEX any more */
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Now at end of input.\n");
#endif
}
else
{
yychar1 = YYTRANSLATE(yychar);
#if YYDEBUG != 0
if (yydebug)
{
fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
/* Give the individual parser a way to print the precise meaning
of a token, for further debugging info. */
#ifdef YYPRINT
YYPRINT (stderr, yychar, yylval);
#endif
fprintf (stderr, ")\n");
}
#endif
}
yyn += yychar1;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
goto yydefault;
yyn = yytable[yyn];
/* yyn is what to do for this token type in this state.
Negative => reduce, -yyn is rule number.
Positive => shift, yyn is new state.
New state is final state => don't bother to shift,
just return success.
0, or most negative number => error. */
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrlab;
if (yyn == YYFINAL)
YYACCEPT;
/* Shift the lookahead token. */
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
#endif
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif
/* count tokens shifted since error; after three, turn off error status. */
if (yyerrstatus) yyerrstatus--;
yystate = yyn;
goto yynewstate;
/* Do the default action for the current state. */
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
/* Do a reduction. yyn is the number of a rule to reduce with. */
yyreduce:
yylen = yyr2[yyn];
if (yylen > 0)
yyval = yyvsp[1-yylen]; /* implement default value of the action */
#if YYDEBUG != 0
if (yydebug)
{
int i;
fprintf (stderr, "Reducing via rule %d (line %d), ",
yyn, yyrline[yyn]);
/* Print the symbols being reduced, and their result. */
for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
fprintf (stderr, "%s ", yytname[yyrhs[i]]);
fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
}
#endif
switch (yyn) {
case 11:
#line 195 "seriousskastudio/parser.y"
{
// fill with default values
;
break;}
case 12:
#line 199 "seriousskastudio/parser.y"
{
_fCurentMaxDistance = yyvsp[-1].f;
;
break;}
case 20:
#line 233 "seriousskastudio/parser.y"
{ bCompresion = FALSE; ;
break;}
case 21:
#line 235 "seriousskastudio/parser.y"
{ bCompresion = yyvsp[0].i; ;
break;}
case 22:
#line 239 "seriousskastudio/parser.y"
{ _fTreshold = 0.0f; ;
break;}
case 23:
#line 241 "seriousskastudio/parser.y"
{ _fTreshold = yyvsp[-1].f; ;
break;}
case 24:
#line 246 "seriousskastudio/parser.y"
{
_fAnimSpeed = -1;
;
break;}
case 25:
#line 250 "seriousskastudio/parser.y"
{
_fAnimSpeed = yyvsp[-1].f;
;
break;}
case 26:
#line 257 "seriousskastudio/parser.y"
{
// get curent animation count
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
// increase curent animation count
_yy_pAnimSet->as_Anims.Expand(ctan+1);
// get ref to new created animation
Animation &an = _yy_pAnimSet->as_Anims[ctan];
// set animation allready read treshold
an.an_fTreshold = _fTreshold;
// set animation allready read compresion flag
an.an_bCompresed = bCompresion;
;
break;}
case 27:
#line 273 "seriousskastudio/parser.y"
{
_ctFrames = yyvsp[-4].i;
if(_ctFrames<0) {
yyerror("Negative frame count found %d",_ctFrames);
}
// get current animset count
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
// get ref to last animation
Animation &an = _yy_pAnimSet->as_Anims[ctan-1];
// set animations seconds per frame
an.an_fSecPerFrame = yyvsp[-7].f;
// set animation frame count
an.an_iFrames = _ctFrames;
// set animation ID
an.an_iID = ska_GetIDFromStringTable(yyvsp[-1].str);
// set animation source file (current file)
an.an_fnSourceFile = strCurentFileName;
// set animation custom speed (if any)
an.an_bCustomSpeed = FALSE;
if(_fAnimSpeed>=0)
{
an.an_bCustomSpeed = TRUE;
an.an_fSecPerFrame = _fAnimSpeed;
}
;
break;}
case 28:
#line 303 "seriousskastudio/parser.y"
{
// set bone envelopes count
_ctBoneEnvelopes = yyvsp[0].i;
if(_ctBoneEnvelopes<0) {
yyerror("Negative bone envelope count found %d",_ctBoneEnvelopes);
}
// count animations
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
Animation &an = _yy_pAnimSet->as_Anims[ctan-1];
// add new bone envelope array
an.an_abeBones.New(_ctBoneEnvelopes);
// set current bone envelope index
_iBoneEnvelope = 0;
;
break;}
case 29:
#line 320 "seriousskastudio/parser.y"
{
if(_iBoneEnvelope!=_ctBoneEnvelopes) {
yyerror("Incorect number of bone envelopes.\nExpecting %d but found only %d",_ctBoneEnvelopes,_iBoneEnvelope);
}
;
break;}
case 34:
#line 339 "seriousskastudio/parser.y"
{
if(_iBoneEnvelope>=_ctBoneEnvelopes) {
yyerror("Incorect number of bone envelopes - %d",_ctBoneEnvelopes);
}
// get last animation
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
Animation &an = _yy_pAnimSet->as_Anims[ctan-1];
BoneEnvelope &be = an.an_abeBones[_iBoneEnvelope];
// create array of bone posiotions and rotations
be.be_apPos.New(_ctFrames);
be.be_arRot.New(_ctFrames);
// for each frame
for(INDEX ifn=0;ifn<_ctFrames;ifn++)
{
// set bone position and rotation frame number
be.be_apPos[ifn].ap_iFrameNum = ifn;
be.be_arRot[ifn].ar_iFrameNum = ifn;
}
// get id of this bone envelope
be.be_iBoneID = ska_GetIDFromStringTable(yyvsp[-4].str);
// fill default pos matrix
memcpy(&be.be_mDefaultPos,yyvsp[-1].f12,sizeof(float)*12);
_iFrame = 0;
;
break;}
case 35:
#line 367 "seriousskastudio/parser.y"
{
_iBoneEnvelope++;
if(_iFrame!=_ctFrames) {
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
Animation &an = _yy_pAnimSet->as_Anims[ctan-1];
BoneEnvelope &be = an.an_abeBones[_iBoneEnvelope-1];
CTString strBoneEnvelope = ska_GetStringFromTable(be.be_iBoneID);
yyerror("Incorect number of bone envelope frames count for bone envelope '%s'.\nExpecting %d but found only %d",
(const char*)strBoneEnvelope,_ctFrames,_iFrame);
}
;
break;}
case 38:
#line 389 "seriousskastudio/parser.y"
{
if(_iFrame>=_ctFrames) {
yyerror("Incorect number of bone envelope frames - %d",_ctFrames);
}
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
QVect qvPlacement;
Matrix12ToQVect(qvPlacement,yyvsp[-1].f12);
Animation &an = _yy_pAnimSet->as_Anims[ctan-1];
BoneEnvelope &be = an.an_abeBones[_iBoneEnvelope];
be.be_apPos[_iFrame].ap_vPos = qvPlacement.vPos;
be.be_arRot[_iFrame].ar_qRot = qvPlacement.qRot;
_iFrame++;
;
break;}
case 39:
#line 408 "seriousskastudio/parser.y"
{
// set morph envelopes count
_ctMorphEnvelopes = yyvsp[0].i;
if(_ctMorphEnvelopes<0) {
yyerror("Negative morph envelope count found %d",_ctMorphEnvelopes);
}
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
_yy_pAnimSet->as_Anims[ctan-1].an_ameMorphs.New(_ctMorphEnvelopes);
_iMorphEnvelope = 0;
;
break;}
case 40:
#line 421 "seriousskastudio/parser.y"
{
if(_iMorphEnvelope!=_ctMorphEnvelopes) {
yyerror("Incorect number of morph envelopes.\nExpecting %d but found only %d",_ctMorphEnvelopes,_iMorphEnvelope);
}
;
break;}
case 45:
#line 440 "seriousskastudio/parser.y"
{
if(_iMorphEnvelope>=_ctMorphEnvelopes) {
yyerror("Incorect number of morph envelopes - %d",_ctMorphEnvelopes);
}
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
// get ref to animation and morph envelope
Animation &an = _yy_pAnimSet->as_Anims[ctan-1];
MorphEnvelope &me = an.an_ameMorphs[_iMorphEnvelope];
// create array for morphs factors
me.me_aFactors.New(_ctFrames);
me.me_iMorphMapID = ska_GetIDFromStringTable(yyvsp[0].str);
_iFrame = 0;
;
break;}
case 46:
#line 454 "seriousskastudio/parser.y"
{
_iMorphEnvelope++;
if(_iFrame!=_ctFrames) {
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
Animation &an = _yy_pAnimSet->as_Anims[ctan-1];
MorphEnvelope &me = an.an_ameMorphs[_iMorphEnvelope-1];
CTString strMorphEnvelope = ska_GetStringFromTable(me.me_iMorphMapID);
yyerror("Incorect number of morph envelope frames count for morph envelope '%s'.\nExpecting %d but found only %d",
(const char*)strMorphEnvelope,_ctFrames,_iFrame);
}
;
break;}
case 49:
#line 475 "seriousskastudio/parser.y"
{
if(_iFrame>=_ctFrames) {
yyerror("Incorect number of morph envelope frames - %d",_ctFrames);
}
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
Animation &an = _yy_pAnimSet->as_Anims[ctan-1];
MorphEnvelope &me = an.an_ameMorphs[_iMorphEnvelope];
me.me_aFactors[_iFrame] = yyvsp[-1].f;
_iFrame++;
;
break;}
case 50:
#line 488 "seriousskastudio/parser.y"
{
if(_iFrame>=_ctFrames) {
yyerror("Incorect number of morph envelope frames - %d",_ctFrames);
}
INDEX ctan = _yy_pAnimSet->as_Anims.Count();
Animation &an = _yy_pAnimSet->as_Anims[ctan-1];
MorphEnvelope &me = an.an_ameMorphs[_iMorphEnvelope];
me.me_aFactors[_iFrame] = yyvsp[-1].i;
_iFrame++;
;
break;}
case 58:
#line 531 "seriousskastudio/parser.y"
{
// check for version of skeleton ascii file
;
break;}
case 59:
#line 538 "seriousskastudio/parser.y"
{
_ctBones = yyvsp[-1].i;
if(_ctBones<0) {
yyerror("Negative bone count found %d",_ctBones);
}
// set bone index to 0
_iBone = 0;
// get skeleton lods count
INDEX ctskllod = _yy_pSkeleton->skl_aSkeletonLODs.Count();
// increase skeleton lods count
_yy_pSkeleton->skl_aSkeletonLODs.Expand(ctskllod+1);
// get ref to new skeleton created
pSkeletonLOD = &_yy_pSkeleton->skl_aSkeletonLODs[ctskllod];
// read source file name of skeleton ascii file
pSkeletonLOD->slod_fnSourceFile = strCurentFileName;
// get allready remembered max distance
pSkeletonLOD->slod_fMaxDistance = _fCurentMaxDistance;
// create new array for bones
pSkeletonLOD->slod_aBones.New(_ctBones);
;
break;}
case 60:
#line 560 "seriousskastudio/parser.y"
{
if(_iBone!=_ctBones) {
yyerror("Incorect number of bones.\nExpecting %d but found only %d",_ctBones,_iBone);
}
;
break;}
case 65:
#line 579 "seriousskastudio/parser.y"
{
if(_iBone>=_ctBones) {
yyerror("Incorect number of bones - %d",_ctBones);
}
SkeletonBone &sb = pSkeletonLOD->slod_aBones[_iBone];
// get bone ID
sb.sb_iID = ska_GetIDFromStringTable(yyvsp[-6].str);
// get parent bone ID
sb.sb_iParentID = ska_GetIDFromStringTable(yyvsp[-3].str);
// get bone length
sb.sb_fBoneLength = yyvsp[0].f;
;
break;}
case 67:
#line 597 "seriousskastudio/parser.y"
{
SkeletonBone &sb = pSkeletonLOD->slod_aBones[_iBone];
// convert matrix to qvect struct
Matrix12ToQVect(sb.sb_qvRelPlacement,yyvsp[-2].f12);
// copy matrix to bone as its absolute placement
memcpy(&sb.sb_mAbsPlacement,yyvsp[-2].f12,sizeof(float)*12);
// calculate bone offset length
FLOAT3D vOffset = FLOAT3D(yyvsp[-2].f12[3],yyvsp[-2].f12[7],yyvsp[-2].f12[11]);
sb.sb_fOffSetLen = vOffset.Length();
// increase bone count
_iBone++;
;
break;}
case 68:
#line 613 "seriousskastudio/parser.y"
{
// end of skeleton parsing
;
break;}
case 69:
#line 622 "seriousskastudio/parser.y"
{
// no shader for next surface
_assSurfaceShaders.Clear();
_ctShaderSurfaces=0;
_iShaderSurfIndex=0;
;
break;}
case 71:
#line 633 "seriousskastudio/parser.y"
{
_assSurfaceShaders.Clear();
_ctShaderSurfaces = yyvsp[-1].i;
// create array of shader params for each surface in mesh file
_assSurfaceShaders.New(_ctShaderSurfaces);
// reset surface index
_iShaderSurfIndex=0;
;
break;}
case 72:
#line 641 "seriousskastudio/parser.y"
{
// check if surfaces count match count of read surfaces
if(_iShaderSurfIndex!=_ctShaderSurfaces) yyerror("Incorect number of surfaces");
;
break;}
case 78:
#line 657 "seriousskastudio/parser.y"
{
_iShaderSurfIndex++;
;
break;}
case 79:
#line 664 "seriousskastudio/parser.y"
{
if(_iShaderSurfIndex>=_ctShaderSurfaces) yyerror("Incorect number of surfaces");
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
SurfShader.ss_iSurfaceID = ska_GetIDFromStringTable(yyvsp[-5].str);
// set shader fn
SurfShader.fnShaderName = (CTString)yyvsp[-1].str
;
break;}
case 80:
#line 674 "seriousskastudio/parser.y"
{
_ctshParamsMax = yyvsp[0].i;
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
SurfShader.ss_spShaderParams.sp_aiTextureIDs.New(_ctshParamsMax);
_ishParamIndex = 0;
;
break;}
case 81:
#line 680 "seriousskastudio/parser.y"
{
// incorect params count
if(_ishParamIndex!=_ctshParamsMax)
{
CTString strErr = CTString(0,"Incorect texture params count\nExpecting %d but found %d",_ctshParamsMax,_ishParamIndex);
yyerror((char*)(const char*)strErr);
}
;
break;}
case 86:
#line 700 "seriousskastudio/parser.y"
{
if(_ishParamIndex>=_ctshParamsMax)
{
CTString strErr = CTString(0,"Incorect texture params count %d",_ctshParamsMax);
yyerror((char*)(const char*)strErr);
}
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
// set ID of current texture name
SurfShader.ss_spShaderParams.sp_aiTextureIDs[_ishParamIndex] = ska_GetIDFromStringTable(yyvsp[-1].str);
// increase shading parametar index
_ishParamIndex++;
;
break;}
case 87:
#line 715 "seriousskastudio/parser.y"
{
_ctshParamsMax = yyvsp[0].i;
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
SurfShader.ss_spShaderParams.sp_aiTexCoordsIndex.New(_ctshParamsMax);
_ishParamIndex = 0;
;
break;}
case 88:
#line 721 "seriousskastudio/parser.y"
{
// incorect params count
if(_ishParamIndex!=_ctshParamsMax)
{
CTString strErr = CTString(0,"Incorect uvmap params count\nExpecting %d but found %d",_ctshParamsMax,_ishParamIndex);
yyerror((char*)(const char*)strErr);
}
;
break;}
case 93:
#line 740 "seriousskastudio/parser.y"
{
if(_ishParamIndex>=_ctshParamsMax)
{
CTString strErr = CTString(0,"Incorect uvmap params count %d",_ctshParamsMax);
yyerror((char*)(const char*)strErr);
}
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
// set index of current uvmap name
SurfShader.ss_spShaderParams.sp_aiTexCoordsIndex[_ishParamIndex] = yyvsp[-1].i;
// increase shading parametar index
_ishParamIndex++;
;
break;}
case 94:
#line 755 "seriousskastudio/parser.y"
{
_ctshParamsMax = yyvsp[0].i;
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
SurfShader.ss_spShaderParams.sp_acolColors.New(_ctshParamsMax);
_ishParamIndex = 0;
;
break;}
case 95:
#line 761 "seriousskastudio/parser.y"
{
// incorect params count
if(_ishParamIndex!=_ctshParamsMax)
{
CTString strErr = CTString(0,"Incorect color params count\nExpecting %d but found %d",_ctshParamsMax,_ishParamIndex);
yyerror((char*)(const char*)strErr);
}
;
break;}
case 100:
#line 780 "seriousskastudio/parser.y"
{
if(_ishParamIndex>=_ctshParamsMax)
{
CTString strErr = CTString(0,"Incorect colors params count %d",_ctshParamsMax);
yyerror((char*)(const char*)strErr);
}
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
// set color
SurfShader.ss_spShaderParams.sp_acolColors[_ishParamIndex] = yyvsp[-1].i;
// increase color parametar index
_ishParamIndex++;
;
break;}
case 101:
#line 795 "seriousskastudio/parser.y"
{
_ctshParamsMax = yyvsp[0].i;
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
SurfShader.ss_spShaderParams.sp_afFloats.New(_ctshParamsMax);
_ishParamIndex = 0;
;
break;}
case 102:
#line 802 "seriousskastudio/parser.y"
{
// incorect params count
if(_ishParamIndex!=_ctshParamsMax)
{
CTString strErr = CTString(0,"Incorect floats params count\nExpecting %d but found %d",_ctshParamsMax,_ishParamIndex);
yyerror((char*)(const char*)strErr);
}
;
break;}
case 107:
#line 821 "seriousskastudio/parser.y"
{
if(_ishParamIndex>=_ctshParamsMax)
{
CTString strErr = CTString(0,"Incorect floats params count %d",_ctshParamsMax);
yyerror((char*)(const char*)strErr);
}
// set color
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
SurfShader.ss_spShaderParams.sp_afFloats[_ishParamIndex] = yyvsp[-1].f;
// increase floats parametar index
_ishParamIndex++;
;
break;}
case 110:
#line 840 "seriousskastudio/parser.y"
{
SurfaceShader &SurfShader = _assSurfaceShaders[_iShaderSurfIndex];
SurfShader.ss_spShaderParams.sp_ulFlags = yyvsp[-1].i;
;
break;}
case 111:
#line 848 "seriousskastudio/parser.y"
{
if (yyvsp[-1].f!=0.1) NOTHING; //parseMesh->error
INDEX ctmshlod = _yy_pMesh->msh_aMeshLODs.Count();
_yy_pMesh->msh_aMeshLODs.Expand(ctmshlod+1);
pMeshLOD = &_yy_pMesh->msh_aMeshLODs[ctmshlod];
pMeshLOD->mlod_fnSourceFile = strCurentFileName;
pMeshLOD->mlod_fMaxDistance = _fCurentMaxDistance;
_yy_iWIndex=0;
_yy_iMIndex=0;
;
break;}
case 112:
#line 862 "seriousskastudio/parser.y"
{
pMeshLOD->mlod_ulFlags &= ~ML_FULL_FACE_FORWARD;
;
break;}
case 113:
#line 866 "seriousskastudio/parser.y"
{
if(yyvsp[0].i == TRUE) {
pMeshLOD->mlod_ulFlags|=ML_FULL_FACE_FORWARD;
} else {
pMeshLOD->mlod_ulFlags &=~ML_FULL_FACE_FORWARD;
}
;
break;}
case 114:
#line 876 "seriousskastudio/parser.y"
{
pMeshLOD->mlod_ulFlags &= ~ML_HALF_FACE_FORWARD;
;
break;}
case 115:
#line 880 "seriousskastudio/parser.y"
{
if(yyvsp[0].i == TRUE) {
pMeshLOD->mlod_ulFlags|=ML_HALF_FACE_FORWARD;
} else {
pMeshLOD->mlod_ulFlags &=~ML_HALF_FACE_FORWARD;
}
;
break;}
case 116:
#line 890 "seriousskastudio/parser.y"
{
_ctVertices = yyvsp[-1].i;
if(_ctVertices<0) {
yyerror("Negative vertex count found %d",_ctVertices);
}
pMeshLOD->mlod_aVertices.New(_ctVertices);
_iVertex = 0;
;
break;}
case 117:
#line 900 "seriousskastudio/parser.y"
{
if(_iVertex!=_ctVertices) {
yyerror("Incorect number of vertices.\nExpecting %d but found only %d",_ctVertices,_iVertex);
}
;
break;}
case 120:
#line 913 "seriousskastudio/parser.y"
{
if(_iVertex>=_ctVertices) {
yyerror("Incorect number of vertices - %d",_ctVertices);
}
pMeshLOD->mlod_aVertices[_iVertex].x = yyvsp[-1].v3[0];
pMeshLOD->mlod_aVertices[_iVertex].y = yyvsp[-1].v3[1];
pMeshLOD->mlod_aVertices[_iVertex].z = yyvsp[-1].v3[2];
_iVertex++;
;
break;}
case 121:
#line 927 "seriousskastudio/parser.y"
{
_ctNormals = yyvsp[-1].i;
if(_ctNormals != _ctVertices) {
yyerror("Number of normals differs from the number of vertices!");
}
if(_ctNormals <0) {
yyerror("Negative normal count found %d",_ctNormals);
}
_iNormal = 0;
pMeshLOD->mlod_aNormals.New(_ctNormals);
;
break;}
case 122:
#line 941 "seriousskastudio/parser.y"
{
if(_iNormal!=_ctNormals) {
yyerror("Incorect number of normals.\nExpecting %d but found only %d",_ctNormals,_iNormal);
}
;
break;}
case 125:
#line 955 "seriousskastudio/parser.y"
{
if(_iNormal>=_ctNormals) {
yyerror("Incorect number of normals - %d",_ctNormals);
}
pMeshLOD->mlod_aNormals[_iNormal].nx = yyvsp[-1].v3[0];
pMeshLOD->mlod_aNormals[_iNormal].ny = yyvsp[-1].v3[1];
pMeshLOD->mlod_aNormals[_iNormal].nz = yyvsp[-1].v3[2];
_iNormal++;
;
break;}
case 126:
#line 968 "seriousskastudio/parser.y"
{
_ctUVMaps = yyvsp[-1].i;
if(_ctUVMaps <0) {
yyerror("Negative UVMaps count found %d",_ctUVMaps);
}
_iUVMap = 0;
pMeshLOD->mlod_aUVMaps.New(_ctUVMaps);
;
break;}
case 127:
#line 979 "seriousskastudio/parser.y"
{
if(_iUVMap!=_ctUVMaps) {
yyerror("Incorect number of UVMaps.\nExpecting %d but found only %d",_ctUVMaps,_iUVMap);
}
;
break;}
case 132:
#line 998 "seriousskastudio/parser.y"
{
if(_iUVMap>=_ctUVMaps) {
yyerror("Incorect number of UVMaps - %d",_ctUVMaps);
}
_ctTexCoords = yyvsp[-1].i;
if(_ctTexCoords != _ctVertices) {
yyerror("Number of texcords differs from the number of vertices!");
}
if(_ctTexCoords <0) {
yyerror("Negative texcoords count found %d",_ctTexCoords);
}
_iTexCoord = 0;
MeshUVMap &uvmap = pMeshLOD->mlod_aUVMaps[_iUVMap];
uvmap.muv_aTexCoords.New(_ctTexCoords);
uvmap.muv_iID = ska_GetIDFromStringTable(yyvsp[-4].str);
;
break;}
case 133:
#line 1017 "seriousskastudio/parser.y"
{
_iUVMap++;
if(_iTexCoord!=_ctTexCoords) {
yyerror("Incorect number of TexCoords for UVMap %d.\nExpecting %d but found only %d",_iUVMap,_ctTexCoords,_iTexCoord);
}
;
break;}
case 136:
#line 1032 "seriousskastudio/parser.y"
{
if(_iTexCoord>=_ctTexCoords) {
yyerror("Incorect number of TexCoords - %d",_ctTexCoords);
}
MeshUVMap &uvmap = pMeshLOD->mlod_aUVMaps[_iUVMap];
MeshTexCoord &mtc = uvmap.muv_aTexCoords[_iTexCoord];
mtc.u = yyvsp[-1].v2[0];
mtc.v = yyvsp[-1].v2[1];
_iTexCoord++;
;
break;}
case 137:
#line 1048 "seriousskastudio/parser.y"
{
_ctSurfaces = yyvsp[-1].i;
if(_ctSurfaces <0) {
yyerror("Negative surface count found %d",_ctSurfaces);
}
_iSurface = 0;
pMeshLOD->mlod_aSurfaces.New(_ctSurfaces);
// reset shader for each surface
for(INDEX isrf=0;isrf<_ctSurfaces;isrf++) {
MeshSurface &msrf = pMeshLOD->mlod_aSurfaces[isrf];
msrf.msrf_pShader = NULL;
}
;
break;}
case 138:
#line 1065 "seriousskastudio/parser.y"
{
if(_iSurface!=_ctSurfaces) {
yyerror("Incorect number of surfaces.\nExpecting %d but found only %d",_ctSurfaces,_iSurface);
}
;
break;}
case 141:
#line 1079 "seriousskastudio/parser.y"
{
_ctTriangles = yyvsp[-1].i;
if(_ctTriangles <0) {
yyerror("Negative triangle count found %d",_ctTriangles);
}
if(_iSurface>=_ctSurfaces) {
yyerror("Incorect number of surfaces - %d",_ctSurfaces);
}
MeshSurface &msrf = pMeshLOD->mlod_aSurfaces[_iSurface];
msrf.msrf_aTriangles.New(_ctTriangles);
msrf.msrf_iSurfaceID = ska_GetIDFromStringTable(yyvsp[-4].str);
msrf.msrf_pShader = NULL;
_iTriangle = 0;
INDEX ctSrfSha = _assSurfaceShaders.Count();
// find this surface in array of shader surfaces that was parsed before mesh
for(INDEX iSrfSha=0;iSrfSha<ctSrfSha;iSrfSha++)
{
// reset shader
SurfaceShader &ssSurfShader = _assSurfaceShaders[iSrfSha];
if(ssSurfShader.ss_iSurfaceID == msrf.msrf_iSurfaceID)
{
// copy shader texture ID's to mesh
msrf.msrf_ShadingParams.sp_aiTextureIDs = ssSurfShader.ss_spShaderParams.sp_aiTextureIDs;
msrf.msrf_ShadingParams.sp_aiTexCoordsIndex = ssSurfShader.ss_spShaderParams.sp_aiTexCoordsIndex;
msrf.msrf_ShadingParams.sp_acolColors = ssSurfShader.ss_spShaderParams.sp_acolColors;
msrf.msrf_ShadingParams.sp_afFloats = ssSurfShader.ss_spShaderParams.sp_afFloats;
msrf.msrf_ShadingParams.sp_ulFlags = ssSurfShader.ss_spShaderParams.sp_ulFlags;
// set shader for this surface
if(ssSurfShader.fnShaderName.Length()>0) {
ChangeSurfaceShader_t(msrf,ssSurfShader.fnShaderName);
} else {
msrf.msrf_pShader=NULL;
}
break;
}
}
;
break;}
case 142:
#line 1121 "seriousskastudio/parser.y"
{
_iSurface++;
if(_iTriangle!=_ctTriangles) {
yyerror("Incorect number of triangles for surface %d.\nExpecting %d but found only %d",_iSurface,_ctTriangles,_iTriangle);
}
;
break;}
case 145:
#line 1136 "seriousskastudio/parser.y"
{
if(_iTriangle>=_ctTriangles) {
yyerror("Incorect number of triangles - %d",_ctTriangles);
}
MeshSurface &msrf = pMeshLOD->mlod_aSurfaces[_iSurface];
MeshTriangle &mt = msrf.msrf_aTriangles[_iTriangle];
mt.iVertex[0]=yyvsp[-1].i3[0];
mt.iVertex[1]=yyvsp[-1].i3[1];
mt.iVertex[2]=yyvsp[-1].i3[2];
_iTriangle++;
;
break;}
case 146:
#line 1153 "seriousskastudio/parser.y"
{
_ctWeights = yyvsp[-1].i;
if(_ctWeights <0) {
yyerror("Negative weights count found %d",_ctWeights);
}
_iWeight = 0;
pMeshLOD->mlod_aWeightMaps.New(_ctWeights);
;
break;}
case 147:
#line 1163 "seriousskastudio/parser.y"
{
if(_iWeight!=_ctWeights) {
yyerror("Incorect number of weights.\nExpecting %d but found only %d",_ctWeights,_iWeight);
}
;
break;}
case 152:
#line 1182 "seriousskastudio/parser.y"
{
_ctVertexWeights = yyvsp[-1].i;
if(_ctVertexWeights <0) {
yyerror("Negative vertex weights count found %d",_ctVertexWeights);
}
if(_iWeight>=_ctWeights) {
yyerror("Incorect number of weights - %d",_ctWeights);
}
MeshWeightMap &mwm = pMeshLOD->mlod_aWeightMaps[_iWeight];
mwm.mwm_iID = ska_GetIDFromStringTable(yyvsp[-4].str);
mwm.mwm_aVertexWeight.New(_ctVertexWeights);
_iVertexWeight = 0;
;
break;}
case 153:
#line 1199 "seriousskastudio/parser.y"
{
_iWeight++;
if(_iVertexWeight!=_ctVertexWeights) {
yyerror("Incorect number of vertex weights.\nExpecting %d but found only %d",_ctVertexWeights,_iVertexWeight);
}
;
break;}
case 156:
#line 1214 "seriousskastudio/parser.y"
{
if(_iVertexWeight>=_ctVertexWeights) {
yyerror("Incorect number of vertex weights - %d",_ctVertexWeights);
}
MeshWeightMap &mwm = pMeshLOD->mlod_aWeightMaps[_iWeight];
MeshVertexWeight &mvw = mwm.mwm_aVertexWeight[_iVertexWeight];
FLOAT fWeight = yyvsp[-2].f;
if(fWeight<0) {
yyerror("Weight value is negative");
}
mvw.mww_iVertex = yyvsp[-4].i;
mvw.mww_fWeight = fWeight;
_iVertexWeight++;
;
break;}
case 157:
#line 1236 "seriousskastudio/parser.y"
{
_ctMorphs = yyvsp[-1].i;
if(_ctMorphs<0) {
yyerror("Negative morph count found %d",_ctMorphs);
}
pMeshLOD->mlod_aMorphMaps.New(yyvsp[-1].i);
_iMorph = 0;
;
break;}
case 158:
#line 1247 "seriousskastudio/parser.y"
{
if(_iMorph!=_ctMorphs) {
yyerror("Incorect number of morphs.\nExpecting %d but found only %d",_ctMorphs,_iMorph);
}
;
break;}
case 163:
#line 1265 "seriousskastudio/parser.y"
{
_ctVertexMorphs = yyvsp[0].i;
if(_ctVertexMorphs <0) {
yyerror("Negative vertex morphs count found %d",_ctVertexMorphs);
}
if(_iMorph>=_ctMorphs) {
yyerror("Incorect number of morphs - %d",_ctMorphs);
}
MeshMorphMap &mmm = pMeshLOD->mlod_aMorphMaps[_iMorph];
mmm.mmp_aMorphMap.New(yyvsp[0].i);
mmm.mmp_iID = ska_GetIDFromStringTable(yyvsp[-5].str);
mmm.mmp_bRelative = yyvsp[-2].i;
_iVertexMorph = 0;
;
break;}
case 164:
#line 1283 "seriousskastudio/parser.y"
{
_iMorph++;
if(_iVertexMorph!=_ctVertexMorphs) {
yyerror("Incorect number of vertex morphs.\nExpecting %d but found only %d",_ctVertexMorphs,_iVertexMorph);
}
;
break;}
case 167:
#line 1299 "seriousskastudio/parser.y"
{
if(_iVertexMorph>=_ctVertexMorphs) {
yyerror("Incorect number of vertex morphs - %d",_ctVertexMorphs);
}
// add mesh vertex morph to morph array
MeshMorphMap &mmm = pMeshLOD->mlod_aMorphMaps[_iMorph];
MeshVertexMorph &mwm = mmm.mmp_aMorphMap[_iVertexMorph];
mwm.mwm_iVxIndex = yyvsp[-14].i;
mwm.mwm_x = yyvsp[-12].f;
mwm.mwm_y = yyvsp[-10].f;
mwm.mwm_z = yyvsp[-8].f;
mwm.mwm_nx = yyvsp[-6].f;
mwm.mwm_ny = yyvsp[-4].f;
mwm.mwm_nz = yyvsp[-2].f;
_iVertexMorph++;
;
break;}
case 169:
#line 1326 "seriousskastudio/parser.y"
{
yyval.f = yyvsp[0].f;
;
break;}
case 170:
#line 1329 "seriousskastudio/parser.y"
{
yyval.f = (float)yyvsp[0].i;
;
break;}
case 171:
#line 1335 "seriousskastudio/parser.y"
{
yyval.i = yyvsp[0].i;
;
break;}
case 172:
#line 1341 "seriousskastudio/parser.y"
{
yyval.v2[0] = yyvsp[-2].f;
yyval.v2[1] = yyvsp[0].f;
;
break;}
case 173:
#line 1348 "seriousskastudio/parser.y"
{
yyval.v3[0] = yyvsp[-4].f;
yyval.v3[1] = yyvsp[-2].f;
yyval.v3[2] = yyvsp[0].f;
;
break;}
case 174:
#line 1356 "seriousskastudio/parser.y"
{
yyval.v3[0] = yyvsp[-4].f;
yyval.v3[1] = yyvsp[-2].f;
yyval.v3[2] = yyvsp[0].f;
;
break;}
case 175:
#line 1364 "seriousskastudio/parser.y"
{
yyval.i3[0] = yyvsp[-4].i;
yyval.i3[1] = yyvsp[-2].i;
yyval.i3[2] = yyvsp[0].i;
;
break;}
case 176:
#line 1372 "seriousskastudio/parser.y"
{
yyval.f12[0] = yyvsp[-22].f;
yyval.f12[1] = yyvsp[-20].f;
yyval.f12[2] = yyvsp[-18].f;
yyval.f12[3] = yyvsp[-16].f;
yyval.f12[4] = yyvsp[-14].f;
yyval.f12[5] = yyvsp[-12].f;
yyval.f12[6] = yyvsp[-10].f;
yyval.f12[7] = yyvsp[-8].f;
yyval.f12[8] = yyvsp[-6].f;
yyval.f12[9] = yyvsp[-4].f;
yyval.f12[10] = yyvsp[-2].f;
yyval.f12[11] = yyvsp[0].f;
;
break;}
case 177:
#line 1390 "seriousskastudio/parser.y"
{
yyval.i = TRUE;
;
break;}
case 178:
#line 1394 "seriousskastudio/parser.y"
{
yyval.i = FALSE;
;
break;}
}
/* the action file gets copied in in place of this dollarsign */
#line 487 "bison.simple"
yyvsp -= yylen;
yyssp -= yylen;
#ifdef YYLSP_NEEDED
yylsp -= yylen;
#endif
#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
*++yyvsp = yyval;
#ifdef YYLSP_NEEDED
yylsp++;
if (yylen == 0)
{
yylsp->first_line = yylloc.first_line;
yylsp->first_column = yylloc.first_column;
yylsp->last_line = (yylsp-1)->last_line;
yylsp->last_column = (yylsp-1)->last_column;
yylsp->text = 0;
}
else
{
yylsp->last_line = (yylsp+yylen-1)->last_line;
yylsp->last_column = (yylsp+yylen-1)->last_column;
}
#endif
/* 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. */
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTBASE];
goto yynewstate;
yyerrlab: /* here on detecting error */
if (! yyerrstatus)
/* If not already recovering from an error, report this error. */
{
++yynerrs;
#ifdef YYERROR_VERBOSE
yyn = yypact[yystate];
if (yyn > YYFLAG && yyn < YYLAST)
{
int size = 0;
char *msg;
int x, count;
count = 0;
/* Start X at -yyn if nec to avoid negative indexes in yycheck. */
for (x = (yyn < 0 ? -yyn : 0);
x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
size += strlen(yytname[x]) + 15, count++;
msg = (char *) malloc(size + 15);
if (msg != 0)
{
strcpy(msg, "parse error");
if (count < 5)
{
count = 0;
for (x = (yyn < 0 ? -yyn : 0);
x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
{
strcat(msg, count == 0 ? ", expecting `" : " or `");
strcat(msg, yytname[x]);
strcat(msg, "'");
count++;
}
}
yyerror(msg);
free(msg);
}
else
yyerror ("parse error; also virtual memory exceeded");
}
else
#endif /* YYERROR_VERBOSE */
yyerror("parse error");
}
goto yyerrlab1;
yyerrlab1: /* here on error raised explicitly by an action */
if (yyerrstatus == 3)
{
/* if just tried and failed to reuse lookahead token after an error, discard it. */
/* return failure if at end of input */
if (yychar == YYEOF)
YYABORT;
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif
yychar = YYEMPTY;
}
/* Else will try to reuse lookahead token
after shifting the error token. */
yyerrstatus = 3; /* Each real token shifted decrements this */
goto yyerrhandle;
yyerrdefault: /* current state does not do anything special for the error token. */
#if 0
/* This is wrong; only states that explicitly want error tokens
should shift them. */
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
if (yyn) goto yydefault;
#endif
yyerrpop: /* pop the current state because it cannot handle the error token */
if (yyssp == yyss) YYABORT;
yyvsp--;
yystate = *--yyssp;
#ifdef YYLSP_NEEDED
yylsp--;
#endif
#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "Error: state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
yyerrhandle:
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yyerrdefault;
yyn += YYTERROR;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
goto yyerrdefault;
yyn = yytable[yyn];
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrpop;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrpop;
if (yyn == YYFINAL)
YYACCEPT;
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting error token, ");
#endif
*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif
yystate = yyn;
goto yynewstate;
}
#line 1398 "seriousskastudio/parser.y"
Reference in New Issue View Git Blame Copy Permalink