xref: /aoo4110/main/idlc/inc/idlc/astexpression.hxx (revision b1cdbd2c)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#ifndef _IDLC_ASTEXPRESSION_HXX_
#define _IDLC_ASTEXPRESSION_HXX_

#include <idlc/idlc.hxx>

// Enum to define all the different operators to combine expressions
enum ExprComb
{
	EC_add,		// '+'
	EC_minus,	// '-'
	EC_mul,		// '*'
	EC_div,		// '/'
	EC_mod,		// '%'
	EC_or,		// '|'
	EC_xor,		// '^'
	EC_and,		// '&'
	EC_left,	// '<<'
	EC_right,	// '>>'
	EC_u_plus,	// unary '+'
	EC_u_minus,	// unary '-'
	EC_bit_neg,	// '~'
	EC_none,	// No operator (missing)
	EC_symbol	// a symbol (function or constant name)
};

// Enum to define the different kinds of evaluation possible
enum EvalKind
{
	EK_const,			// Must evaluate to constant
	EK_positive_int		// Must evaluate to positive integer
};

// Enum to define expression type
enum ExprType
{
	ET_short,		// Expression value is short
	ET_ushort,		// Expression value is unsigned short
	ET_long,		// Expression value is long
	ET_ulong,		// Expression value is unsigned long
	ET_hyper,		// Expression value is hyper (64 bit)
	ET_uhyper,		// Expression value is unsigned hyper
	ET_float,		// Expression value is 32-bit float
	ET_double,		// Expression value is 64-bit float
	ET_char,		// Expression value is char
	ET_byte,		// Expression value is byte
	ET_boolean,		// Expression value is boolean
	ET_string,		// Expression value is char *
	ET_any,			// Expression value is any of above
	ET_void,		// Expression value is void (absent)
	ET_type,		// Expression value is type
	ET_none 		// Expression value is missing
};

// Structure to describe value of constant expression and its type
struct AstExprValue
{
	union
	{
		sal_uInt8		byval;		// Contains byte expression value
		sal_Int16		sval;		// Contains short expression value
		sal_uInt16		usval;		// Contains unsigned short expr value
		sal_Int32		lval;		// Contains long expression value
		sal_uInt32		ulval;		// Contains unsigned long expr value
		sal_Int64		hval;		// Contains hyper expression value
		sal_uInt64		uhval;		// Contains unsigned hyper expr value
		sal_Bool		bval;		// Contains boolean expression value
		float			fval;		// Contains 32-bit float expr value
		double			dval;		// Contains 64-bit float expr value
		sal_uInt32		eval;		// Contains enumeration value
	} u;
	ExprType et;
};

const sal_Char* SAL_CALL exprTypeToString(ExprType t);

class AstExpression
{
public:
	// Constructor(s)
	AstExpression(ExprComb c, AstExpression *pExpr1, AstExpression *pExpr2);

	AstExpression(sal_Int32			l);
	AstExpression(sal_Int32			l, ExprType et);
	AstExpression(sal_Int64			h);
	AstExpression(sal_uInt64		uh);
	AstExpression(double			d);
	AstExpression(::rtl::OString* scopedName);

	virtual ~AstExpression();

	// Data Accessors
	AstScope* getScope()
		{ return m_pScope; }
	void setScope(AstScope* pScope)
		{ m_pScope = pScope; }
	sal_Int32 getLine()
		{ return m_lineNo; }
	void setLine(sal_Int32 l)
		{ m_lineNo = l; }
	const ::rtl::OString& getFileName()
		{ return m_fileName; }
	void setFileName(const ::rtl::OString& fileName)
		{ m_fileName = fileName; }
	ExprComb getCombOperator()
		{ return m_combOperator; }
	void setCombOperator(ExprComb new_ec)
		{ m_combOperator = new_ec; }
	AstExprValue* getExprValue()
		{ return m_exprValue; }
	void setExprValue(AstExprValue *pEv)
		{ m_exprValue = pEv; }
	AstExpression* getExpr1()
		{ return m_subExpr1; }
	void setExpr1(AstExpression *pExpr)
		{ m_subExpr1 = pExpr; }
	AstExpression* getExpr2()
		{ return m_subExpr2; }
	void setExpr2(AstExpression *pExpr)
		{ m_subExpr2 = pExpr; }
	::rtl::OString* getSymbolicName()
		{ return m_pSymbolicName; }
	void setSymbolicName(::rtl::OString* pSymbolicName)
		{ m_pSymbolicName = pSymbolicName; }

	// Evaluation and value coercion
	AstExprValue* coerce(ExprType type, sal_Bool bAssign=sal_True);

	// Evaluate then store value inside this AstExpression
	void evaluate(EvalKind ek);

	// Compare to AstExpressions
	sal_Bool operator==(AstExpression *pExpr);
	sal_Bool compare(AstExpression *pExpr);

	::rtl::OString toString();
	void dump() {}
private:
	// Fill out the lineno, filename and definition scope details
	void	fillDefinitionDetails();
	// Internal evaluation
	AstExprValue* eval_internal(EvalKind ek);
	// Evaluate different sets of operators
	AstExprValue* eval_bin_op(EvalKind ek);
	AstExprValue* eval_bit_op(EvalKind ek);
	AstExprValue* eval_un_op(EvalKind ek);
	AstExprValue* eval_symbol(EvalKind ek);

	AstScope*		m_pScope;		// scope defined in
	sal_Int32		m_lineNo;		// line number defined in
	::rtl::OString	m_fileName;		// fileName	defined in

	ExprComb		m_combOperator;
	AstExpression*	m_subExpr1;
	AstExpression*	m_subExpr2;
	AstExprValue*	m_exprValue;
	::rtl::OString*	m_pSymbolicName;
};

#endif // _IDLC_ASTEXPRESSION_HXX_