%{

// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). 

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

// 

// RCOMP.CPP

// Generated from RCOMP.Y

#include <assert.h>

#include <ctype.h>

#include <string.h>

#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)

#include <fstream>

#include <iostream>

using namespace std;

using std::cout;

using std::endl;

#else //!__MSVCDOTNET__

#include <fstream.h>

#endif //__MSVCDOTNET__

#ifdef __VC32__

#pragma warning( disable : 4065 ) // C4065: switch statement contains 'default' but no 'case' labels

#pragma warning( disable : 4102 ) // C4102: 'yyerrlab1' : unreferenced label

#pragma warning( disable : 4127 ) // C4127: conditional expression is constant

#pragma warning( disable : 4244 ) // C4244: '=' : conversion from 'int' to 'short', possible loss of data

#endif //__VC32__

#include "resource.h"

#include "parser.h"

int yylex();

void yyerror(const char* string, ...);

int yywrap();

#define YYDEBUG 1

extern int yylineno;

#include "rcomp.hpp"

#include "datatype.h"

#include "mem.h"

#include "rcbinstr.h"

#include "rcscan.h"

#include "errorhan.h"

#include "fileacc.h"

#include "version.h"

#include "ctable.h"

#include "localise.h"

#include "main.h"

#if defined(__VC32__) && !defined(_DEBUG)

#pragma warning( disable : 4702 )	// unreachable code

#pragma warning( disable : 4102 )	// 'yyerrlabel' : unreferenced label

#pragma warning( disable : 4244 )	// '=' : conversion from 'int' to 'short', possible loss of data

#endif

String::CharacterSet CharacterSetID( const String & character_set_name );

void asUTF8(char* aUtf8, int aUnicode);

void SetIdFromName( const String & NameStatementValue);

void CheckStructUsage();

unsigned short & d = MemCheckControl::iLogMemory;

StructHeader *		pSH;

StructHeaderArray * 	pSHA;	// Used in resource struct handling functions.

ResourceHeader *	pResourceHeader;

ResourceItemArray *	pCurrentRIA;

StringArray * pUsedLabelsArray = new StringArray();

int			verbose;

String::CharacterSet	SourceCharacterSet = String::CP1252;

String::CharacterSet	TargetCharacterSet = String::CP1252;

unsigned short		logmemorysetting;

int *			pCurrentLineNumber;

FileLineManager *	pFileLineHandler;

NameIdMap *		pResourceNameIds;

long			CurrentEnumValue;

String			CurrentEnumName;

char			TempStr[300];

rcscan * pScan;

int CurrentIdStep=1;

long CurrentId=0;

int FormatIdAsHex=0;	// defaults to decimal, changes in SetIdFromName

unsigned long Uid2=0;

unsigned long Uid3=0;

const String	Divider("*******************************************");

#define REGISTER_LINE	ErrorHandler::Register(pFileLineHandler->GetCurrentFile(), pFileLineHandler->GetErrorLine(* pCurrentLineNumber))

// Convert a string containing a character literal in aQuoted

// into a value suitable for LCHAR_LITERAL

void SetCharacterLiteral(char* aOut, const String& aQuoted)

	{

	    UTF16 first;

	    int length=1;

	    if (aQuoted.Length() < 1 ) 

	               { 

                        REGISTER_LINE;

                        ErrorHandler::OutputErrorLine("Warning: Empty Character literal");

                       }

	    if (aQuoted.Length() > 1 ) 

	 	       {

                        REGISTER_LINE;

                        ErrorHandler::OutputErrorLine("Error: String Literal length greater than 1");

			exit(1);

                       }

	    if (aQuoted.Export(&first, length, SourceCharacterSet)==0)

			{

			REGISTER_LINE;

			ErrorHandler::OutputErrorLine("Warning: Ignoring trailing characters in character literal");

			}

	    sprintf(aOut, "%d", first);

	}

%}

%union {

	char				Value[1024*8];

	TValueMaybeRls			ValueMaybeRls;

	unsigned long 			Id;

	StructItem *			pStructItem;

	SimpleStructItem *		pSimpleStructItem;

	ArrayStructItem *   	pArrayStructItem;

	StructArrayStructItem *	pStructArrayStructItem;

	StringArray *			pStringArray;

	long					NumInitialiser;

	TRlsQualifiers		RlsQualifiers;

	TRlsType			RlsType;

}

%token <Id> L_STRUCT L_RESOURCE L_NAME L_OFFSET L_SYSTEM L_GLOBAL L_LOCAL L_CHARACTER_SET 

%token <Id> L_BUF L_WORD L_BYTE L_LONG L_DOUBLE L_TEXT L_LTEXT L_LINK L_LLINK L_SRLINK

%token <Id> L_BUF8 L_TEXT8 L_LTEXT8 L_BUF16 L_TEXT16 L_LTEXT16 L_UID_TWO L_UID_THREE

%token <Id> L_RLS_STRING L_RLS_STRING8 L_RLS_DOUBLE

%token <Id> L_RLS_BYTE L_RLS_WORD L_RLS_LONG

%token <Id> L_MULTI

%token <Id> L_TAG_START L_TAG_END 

%token <Value> L_TAG_COMMAND L_TAG_WORD L_TAG_NEW_LINE

%token <Value> L_LABEL L_NUM_NATURAL L_NUM_FLOAT L_NATURAL_EXPR L_ENUM

%token <Value> L_LEN

%token <Value> L_CHAR_LITERAL L_STRING_LITERAL

%type <Id>			data_type len_declaration

%type <pStructItem>		struct_item array_struct_item simple_struct_item

%type <pSimpleStructItem>	simple_struct_item_start

%type <pStructItem>		struct_type_struct_item  struct_array_struct_item

%type <pArrayStructItem>	array_struct_item_start array_struct_item_base

%type <pStructArrayStructItem>	struct_array_struct_item_base

%type <Value>			simple_initialiser natural_expression

%type <Value>			character_code_expression string_expression string_expression_item

%type <pStringArray>		simple_initialiser_list

%type <NumInitialiser>		natural_expression_numeric

%type <RlsQualifiers>		rls_qualifiers rls_cardinality

%type <Value>		rls_label

%type <RlsType>		rls_string_item rls_num_item rls_float_item

%left	'+' '-'

%left	'*' '/'

%left	'|'

%left	UMINUS

%%

/*****************************************************************/

/* TOP-MOST RULE                                                 */

/*****************************************************************/

source :	statement_list				{	if(verbose)	{	MOFF; cout << Divider << "\n" << Divider << endl; MON; }

										}

;

/*****************************************************************/

/* statement-list and statement                                  */

/*****************************************************************/

statement_list:

	statement_list statement

|	statement_list comment_tag

|	/* Nothing */

;

statement:

	struct_statement maybe_semicolon

|	resource_statement maybe_semicolon

|   character_set_statement maybe_semicolon

|	name_statement maybe_semicolon

|	offset_statement maybe_semicolon

|	system_statement maybe_semicolon

|   enum_statement

|	uidX_statement maybe_semicolon

|	rls_item_statement maybe_semicolon

;

maybe_semicolon:

		';'

		{

		// This is my gift to the world: no more "syntax error" for adding

		// an extra semicolon at the end of a struct or resource.

	    REGISTER_LINE;

	    ErrorHandler::OutputErrorLine("Warning: unnecessary semicolon");

		}

|

;

/******************************************************************/

/* STRUCT statement                                               */

/******************************************************************/

struct_statement:

	struct_statement_start struct_item_list '}'

										{	if(verbose) { MOFF; cout << Divider << "\n" << * pSH << Divider << endl; MON;}	}

;

struct_statement_start:

	L_STRUCT L_LABEL maybe_comment_tag '{'

										{	if(verbose) {	MOFF;cout << "struct_statement_start                     " << $2 << endl; MON;}

											pSH = new StructHeader($2);

											REGISTER_LINE;

											pG->SHA.Add(pSH);

										}

|	L_STRUCT L_LABEL len_declaration maybe_comment_tag '{'

										{	if(verbose) {	RCTypeArray Types; MOFF;cout << "struct_statement_start                     " << $2 << " " << Types.GetName($3) << endl; MON;}

											pSH = new StructHeader($2, $3);

											REGISTER_LINE;

											pG->SHA.Add(pSH);

										}

|	L_STRUCT L_LABEL L_LEN maybe_comment_tag '{'

										{	if(verbose) {	MOFF;cout << "struct_statement_start                     " << $2 << " (WORD)" << endl; MON;}

											pSH = new StructHeader($2, L_WORD);

											REGISTER_LINE;

											pG->SHA.Add(pSH);

										}

;

struct_item_list:

	struct_item_list struct_item ';'	{	if(verbose) {	MOFF;cout << "struct_item_list                           Adding struct_item." << endl; MON;}

											REGISTER_LINE;

											pSH->iSIA.Add($2);

										}

|	struct_item_list comment_tag struct_item ';'	{	if(verbose) {	MOFF;cout << "tagged struct_item_list                    Adding struct_item." << endl; MON;}

											REGISTER_LINE;

											pSH->iSIA.Add($3);

										}

|	/* Nothing */

;

struct_item:

	simple_struct_item

|	array_struct_item

|	struct_type_struct_item

|	struct_array_struct_item

;

simple_struct_item:

	simple_struct_item_start			{	$$ = $1;}

|	simple_struct_item_start '(' natural_expression ')'

										{	if(verbose) { MOFF;cout << "    Limit: " << $3 << endl; MON;}

											$1->iLengthLimit = $3;

											$$ = $1;

										}

|	simple_struct_item_start '=' simple_initialiser	/****************************************************************/

										{	if(verbose) { MOFF;cout << "    Default: " << $3 << endl; MON;}

											$1->iDefault = $3;

											$$ = $1;

										}

|	simple_struct_item_start '(' natural_expression ')' '=' string_expression /****************************************************************/

										{	if(verbose) { MOFF;cout << "    Limit: " << $3 << ", Default: " << $6 << endl; MON;}

											NumericValue Limit($3, L_LONG);

											if(String($6).ExportLength(TargetCharacterSet,SourceCharacterSet) > Limit.GetULong() )

											{

												REGISTER_LINE;

												ErrorHandler::OutputErrorLine("Text length exceeds specified limit");

												exit(1);

											}

											$1->iLengthLimit = $3;

											$1->iDefault = $6;

											$$ = $1;

										}

;

simple_struct_item_start:

	data_type L_LABEL					{	if(verbose) 

											{		

												   RCTypeArray Types;

														   MOFF;cout << "simple_struct_item                         " << Types.GetName($1) << " " << $2 << endl; MON;

											}

											$$ = new SimpleStructItem($1,$2); 

											assert($$ != NULL);

										}

|	data_type '<' natural_expression_numeric '>' L_LABEL

										{	if(verbose) 

											{			   RCTypeArray Types;

														   MOFF;cout << "simple_struct_item                         " << Types.GetName($1) << " " << $5 << endl; MON;

											}

											String s(NumericValue::ltoa($3));

											$$ = new SimpleStructItem($1,$5,s);

											assert($$ != NULL);

										}

;

/* Note that generic text identifiers are converted to their explicit

   8 or 16-bit forms at this point, depending on the target character set.

*/

data_type:

	L_BYTE								{	$$ = L_BYTE;}

|	L_WORD								{	$$ = L_WORD;}

|	L_LONG								{	$$ = L_LONG;}

|	L_DOUBLE							{	$$ = L_DOUBLE;}

|	L_TEXT	

	    { 

	    $$ = ( TargetCharacterSet == String::Unicode ) ? L_TEXT16: L_TEXT8;

	    REGISTER_LINE;

	    ErrorHandler::OutputErrorLine("Warning: Deprecated use of zero-terminated TEXT - use LTEXT instead");

	    }

|	L_LTEXT	

	    {

	    $$ = ( TargetCharacterSet == String::Unicode ) ? L_LTEXT16: L_LTEXT8;

	    }

|	L_BUF	

	    { 

	    $$ = ( TargetCharacterSet == String::Unicode ) ? L_BUF16: L_BUF8;

	    }

|	L_TEXT8								{	$$ = L_TEXT8;

											REGISTER_LINE;

											ErrorHandler::OutputErrorLine("Warning: Deprecated use of zero-terminated TEXT8 - use LTEXT8 instead");

										}

|	L_TEXT16							{	$$ = L_TEXT16;

											REGISTER_LINE;

											ErrorHandler::OutputErrorLine("Warning: Deprecated use of zero-terminated TEXT16 - use LTEXT16 instead");

										}

|	L_LTEXT8							{	$$ = L_LTEXT8;}

|	L_LTEXT16							{	$$ = L_LTEXT16;}

|	L_BUF8								{	$$ = L_BUF8;}

|	L_BUF16								{	$$ = L_BUF16;}

|	L_LINK								{	$$ = L_LINK;}

|	L_LLINK								{	$$ = L_LLINK;}

|	L_SRLINK							{	$$ = L_SRLINK;}

;

array_struct_item:

	array_struct_item_base				{	$$ = $1;}

|	array_struct_item_base '=' '{' simple_initialiser_list '}'

										{	if(verbose) {	MOFF;cout << "array_struct_item                          with simple_initialiser_list" << endl;MON;}

											$1->iDefaults = * $4;

											if($1->iSize.Length() > 0)

											{

												NumericValue v($1->iSize, L_LONG);

												REGISTER_LINE;

												if($4->Size()!=long(v.GetULong()))

												{

													ErrorHandler::OutputErrorLine("Size does not match number of initialisers");

													exit(1);

												}

											}

											$$ = $1;

											delete $4;

										}

;

array_struct_item_base:

	array_struct_item_start ']'			{	if(verbose) {	MOFF;cout << "array_struct_item_base                     with no size" << endl;MON;}

											$$ =$1;

										}

|	array_struct_item_start natural_expression ']'

										{	if(verbose) {	MOFF;cout << "array_struct_item_base                     with size " << $2 << endl;MON;}

											$1->iSize = $2;

											$$ = $1;

										}

|	L_LEN len_declaration array_struct_item_start ']'

										{	if(verbose) 

												{		 	RCTypeArray Types;

														 	MOFF;cout << "array_struct_item_base                     with LenType " << Types.GetName($2) << endl;MON;

												}

											$3->iLenType = $2;

											$$ = $3;

										}

|	L_LEN len_declaration array_struct_item_start natural_expression ']'

										{	if(verbose) 

												{		 	RCTypeArray Types;

														 	MOFF;cout << "array_struct_item_base                     with size " << $4 << " and LenType " << Types.GetName($2) << endl;MON;

												}

											$3->iLenType = $2;

											$3->iSize = $4; 

											$$ = $3; 

										}

;

array_struct_item_start:

	data_type L_LABEL '['				{	if(verbose) 

												{		 	RCTypeArray Types; 

														 	MOFF;cout << "array_struct_item_start                    " << Types.GetName($1) << " " << $2 << endl;MON;

												}

											$$ = new ArrayStructItem($1, $2);

										}

;

len_declaration:

	L_BYTE								{	$$ = L_BYTE;}

|	L_WORD								{	$$ = L_WORD;}

;

struct_type_struct_item:

	L_STRUCT L_LABEL					{	if(verbose) {	MOFF;cout << "struct_type_struct_item                    " << $2 << endl;MON;}

											$$ = new StructTypeStructItem($2);

										}

;

struct_array_struct_item:

	struct_array_struct_item_base		{	$$ = $1;}

|	L_LEN len_declaration struct_array_struct_item_base

										{	if(verbose) {	RCTypeArray Types; MOFF;cout << "struct_array_struct_item                   - Setting Size to " << Types.GetName($2) << endl;MON;}

											$3->iLenType = $2; $$ = $3;

										}

;

struct_array_struct_item_base:

	L_STRUCT L_LABEL '[' ']'			{	if(verbose) {	MOFF;cout << "struct_array_struct_item_base              " << $2 << endl;MON;}

											$$ = new StructArrayStructItem($2);

										}

|	L_STRUCT L_LABEL '[' natural_expression ']'

										{	if(verbose) {	MOFF;cout << "struct_array_struct_item_base              " << $2 << " " << $4 << endl;MON;}

											$$ = new StructArrayStructItem($2, $4);

										}

;

/*********************************************************************/

/* RESOURCE statement                                                */

/*********************************************************************/

resource_statement:

	resource_statement_start '{' resource_item_list '}'

	    {	

	    pResourceHeader->AddDefault();

	    CurrentId+=CurrentIdStep;

	    if(verbose) { MOFF;cout << "Resource ID "<< CurrentId << endl << Divider << "\n" << * pResourceHeader << Divider << endl;MON;}

	    pResourceHeader->SetResourceId(*pResourceNameIds,CurrentId,FormatIdAsHex);

	    pG->Index.Add(pResourceHeader);

		CheckStructUsage();

		pUsedLabelsArray->Empty();

	    pResourceHeader = NULL;

	    }

;

resource_statement_start:

	L_GLOBAL resource_statement_start_names {}	/* Ignore GLOBAL (obsolete feature).*/

|	L_LOCAL  resource_statement_start_names

	    {	

	    if(verbose) { MOFF;cout << "resource_statement_start                   LOCAL" << endl;MON;}

		    assert(pResourceHeader != NULL);

		    pResourceHeader->iLocal = 1;

	    }

|	resource_statement_start_names {}

;

resource_statement_start_names:

	L_RESOURCE L_LABEL L_LABEL			{	if(verbose) {	MOFF;cout << "resource_statement_start_names             " << $2 << " " << $3 << endl;MON;}

											assert(pResourceHeader == NULL);

											pResourceHeader = new ResourceHeader($3);

											pCurrentRIA = & (pResourceHeader->iRIA);

											REGISTER_LINE;

											if(pResourceNameIds->IsStored($3))

											{

												ErrorHandler::OutputErrorLine("Resource with this name encountered already");

												exit(1);

											}

											pCurrentRIA->FillFromStruct($2);

											pG->AllIdentifiers.Add(new String($3)); // Add label to store

										}

|	L_RESOURCE L_LABEL					{	if(verbose) {	MOFF;cout << "resource_statement_start_names             " << $2 << " <Resource not named>" << endl;MON;}

											assert(pResourceHeader == NULL);

											pResourceHeader = new ResourceHeader;

											pCurrentRIA = & (pResourceHeader->iRIA);

											REGISTER_LINE;

											pCurrentRIA->FillFromStruct($2);

										}

;

resource_item_list:

	resource_item_list resource_item ';'{	if(verbose) {	MOFF;cout << "resource_item_list" << endl;MON;}}

|	resource_item_list comment_tag resource_item ';'{	if(verbose) {	MOFF;cout << "tagged resource_item_list" << endl;MON;}}

|	resource_item_list error ';'		{	yyerrok; yyclearin; }

|	/* Nothing */

;

resource_item:

	L_LABEL '=' simple_initialiser		{	if(verbose) {	MOFF;cout << "resource_item                              " << $1 << " " << $3 << endl;MON;}

											REGISTER_LINE;/****************************************************************/

											pCurrentRIA->Set($1, $3);

										}

|	resource_simple_array_item

|	struct_resource_item

|	struct_array_resource_item

;

resource_simple_array_item:

	L_LABEL '=' '{' '}'                 

	    {	

	    if (verbose) 

		{ MOFF;cout << "resource_simple_array_item                 " << $1 << endl;MON;} 

	    }

|	L_LABEL '=' '{' simple_initialiser_list '}'

	    {	

	    if (verbose) 

		{ MOFF;cout << "resource_simple_array_item                 " << $1 << " with simple_initialiser_list" << endl;MON;}

	    REGISTER_LINE;

	    pCurrentRIA->Set($1, * $4);

	    delete $4;

	    }

;

/*---------------------------------------------------------------------------*/

/* A note about RIAStack, SRIStack and pCurrentRIA.                          */

/*                                                                           */

/*  RIA stands for Resource Item Array.                                      */

/*  SRI stands for Struct Array Resource Item.                               */

/*                                                                           */

/*  A push to RIAStack is made when dropping inside a STRUCT or STRUCT[] in  */

/*  order to set values for the components. When this happens pCurrentRIA is */

/*  set to the RIA for the STRUCT or last item of the STRUCT[].              */

/*                                                                           */

/*  pCurrentRIA is set to the result of popping from RIAStack when a closing */

/*  brace is reached.                                                        */

/*                                                                           */

/*  A push is made to SRIStack when going into an item for a STRUCT[]. On    */

/*  reaching a closing brace the STRUCT[] is popped off the SRIStack. An new */

/*  item may then be added to this array.                                    */