[cycript.git] / Parser.hpp

#ifndef CYPARSER_HPP
#define CYPARSER_HPP

#include <cstdlib>

class CYParser {
  public:
    void *scanner_;

  private:
    void ScannerInit();
    void ScannerDestroy();

  public:
    CYParser();
    ~CYParser();
};

struct CYSource {
    CYSource *next_;

    void SetNext(CYSource *next) {
        next_ = next;
    }
};

struct CYName {
    virtual const char *Name() const = 0;
};

struct CYToken {
    virtual const char *Text() const = 0;
};

struct CYWord :
    virtual CYToken,
    CYName
{
    const char *word_;

    CYWord(const char *word) :
        word_(word)
    {
    }

    virtual const char *Text() const {
        return word_;
    }

    virtual const char *Name() const {
        return Text();
    }
};

struct CYIdentifier :
    CYWord
{
    const char *word_;

    virtual const char *Text() const {
        return word_;
    }
};

struct CYLabel {
    CYIdentifier *identifier_;
    CYLabel *next_;

    CYLabel(CYIdentifier *identifier, CYLabel *next) :
        identifier_(identifier),
        next_(next)
    {
    }
};

struct CYStatement :
    CYSource
{
    CYLabel *label_;

    void AddLabel(CYIdentifier *identifier) {
        label_ = new CYLabel(identifier, label_);
    }
};

struct CYForInitialiser {
};

struct CYForInInitialiser {
};

struct CYExpression :
    CYStatement,
    CYForInitialiser,
    CYForInInitialiser
{
};

struct CYLiteral :
    CYExpression
{
};

struct CYString :
    CYLiteral,
    CYName
{
    const char *value_;

    CYString(const char *value) :
        value_(value)
    {
    }

    CYString(const CYIdentifier *identifier) :
        value_(identifier->Text())
    {
    }

    const char *String() const {
        return value_;
    }

    virtual const char *Name() const {
        return String();
    }
};

struct CYNumber :
    virtual CYToken,
    CYLiteral,
    CYName
{
    double Number() const {
        throw;
    }

    virtual const char *Name() const {
        throw;
    }
};

struct CYNull :
    CYWord,
    CYLiteral
{
    CYNull() :
        CYWord("null")
    {
    }
};

struct CYThis :
    CYWord,
    CYExpression
{
    CYThis() :
        CYWord("this")
    {
    }
};

struct CYBoolean :
    CYLiteral
{
};

struct CYFalse :
    CYWord,
    CYBoolean
{
    CYFalse() :
        CYWord("false")
    {
    }
};

struct CYTrue :
    CYWord,
    CYBoolean
{
    CYTrue() :
        CYWord("true")
    {
    }
};

struct CYVariable :
    CYExpression
{
    CYIdentifier *name_;

    CYVariable(CYIdentifier *name) :
        name_(name)
    {
    }
};

struct CYPrefix :
    CYExpression
{
    CYExpression *rhs_;

    CYPrefix(CYExpression *rhs) :
        rhs_(rhs)
    {
    }
};

struct CYInfix :
    CYExpression
{
    CYExpression *lhs_;
    CYExpression *rhs_;

    CYInfix(CYExpression *lhs, CYExpression *rhs) :
        lhs_(lhs),
        rhs_(rhs)
    {
    }
};

struct CYPostfix :
    CYExpression
{
    CYExpression *lhs_;

    CYPostfix(CYExpression *lhs) :
        lhs_(lhs)
    {
    }
};

struct CYAssignment :
    CYInfix
{
    CYAssignment(CYExpression *lhs, CYExpression *rhs) :
        CYInfix(lhs, rhs)
    {
    }
};

struct CYArgument {
    CYWord *name_;
    CYExpression *value_;
    CYArgument *next_;

    CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) :
        name_(name),
        value_(value),
        next_(next)
    {
    }
};

struct CYBlank :
    public CYWord
{
    CYBlank() :
        CYWord("")
    {
    }
};

struct CYClause {
    CYExpression *case_;
    CYStatement *code_;
    CYClause *next_;

    CYClause(CYExpression *_case, CYStatement *code) :
        case_(_case),
        code_(code)
    {
    }

    void SetNext(CYClause *next) {
        next_ = next;
    }
};

struct CYElement :
    CYLiteral
{
    CYExpression *value_;
    CYElement *next_;

    CYElement(CYExpression *value, CYElement *next) :
        value_(value),
        next_(next)
    {
    }
};

struct CYDeclaration :
    CYForInInitialiser
{
    CYIdentifier *identifier_;
    CYExpression *initialiser_;

    CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser) :
        identifier_(identifier),
        initialiser_(initialiser)
    {
    }
};

struct CYDeclarations :
    CYStatement,
    CYForInitialiser
{
    CYDeclaration *declaration_;
    CYDeclarations *next_;

    CYDeclarations(CYDeclaration *declaration, CYDeclarations *next) :
        declaration_(declaration),
        next_(next)
    {
    }
};

struct CYParameter {
    CYIdentifier *name_;
    CYParameter *next_;

    CYParameter(CYIdentifier *name, CYParameter *next) :
        name_(name),
        next_(next)
    {
    }
};

struct CYFor :
    CYStatement
{
    CYForInitialiser *initialiser_;
    CYExpression *test_;
    CYExpression *increment_;
    CYStatement *code_;

    CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) :
        initialiser_(initialiser),
        test_(test),
        increment_(increment),
        code_(code)
    {
    }
};

struct CYForIn :
    CYStatement
{
    CYForInInitialiser *initialiser_;
    CYExpression *set_;
    CYStatement *code_;

    CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
        initialiser_(initialiser),
        set_(set),
        code_(code)
    {
    }
};

struct CYProperty :
    CYLiteral
{
    CYName *name_;
    CYExpression *value_;
    CYProperty *next_;

    CYProperty(CYName *name, CYExpression *value, CYProperty *next) :
        name_(name),
        value_(value),
        next_(next)
    {
    }
};

struct CYCatch {
    CYIdentifier *name_;
    CYStatement *code_;

    CYCatch(CYIdentifier *name, CYStatement *code) :
        name_(name),
        code_(code)
    {
    }
};

struct CYMessage :
    CYExpression
{
    CYExpression *self_;
    CYArgument *arguments_;

    CYMessage(CYExpression *self, CYArgument *arguments) :
        self_(self),
        arguments_(arguments)
    {
    }
};

struct CYMember :
    CYExpression
{
    CYExpression *object_;
    CYExpression *property_;

    CYMember(CYExpression *object, CYExpression *property) :
        object_(object),
        property_(property)
    {
    }
};

struct CYNew :
    CYExpression
{
    CYExpression *constructor_;
    CYArgument *arguments_;

    CYNew(CYExpression *constructor, CYArgument *arguments) :
        constructor_(constructor),
        arguments_(arguments)
    {
    }
};

struct CYCall :
    CYExpression
{
    CYExpression *function_;
    CYArgument *arguments_;

    CYCall(CYExpression *function, CYArgument *arguments) :
        function_(function),
        arguments_(arguments)
    {
    }
};

struct CYIf :
    CYStatement
{
    CYExpression *test_;
    CYStatement *true_;
    CYStatement *false_;

    CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false) :
        test_(test),
        true_(_true),
        false_(_false)
    {
    }
};

struct CYDoWhile :
    CYStatement
{
    CYExpression *test_;
    CYStatement *code_;

    CYDoWhile(CYExpression *test, CYStatement *code) :
        test_(test),
        code_(code)
    {
    }
};

struct CYWhile :
    CYStatement
{
    CYExpression *test_;
    CYStatement *code_;

    CYWhile(CYExpression *test, CYStatement *code) :
        test_(test),
        code_(code)
    {
    }
};

struct CYLambda :
    CYExpression
{
    CYIdentifier *name_;
    CYParameter *parameters_;
    CYSource *body_;

    CYLambda(CYIdentifier *name, CYParameter *parameters, CYSource *body) :
        name_(name),
        parameters_(parameters),
        body_(body)
    {
    }
};

struct CYFunction :
    CYLambda
{
    CYFunction(CYIdentifier *name, CYParameter *parameters, CYSource *body) :
        CYLambda(name, parameters, body)
    {
    }
};

struct CYContinue :
    CYStatement
{
    CYIdentifier *label_;

    CYContinue(CYIdentifier *label) :
        label_(label)
    {
    }
};

struct CYBreak :
    CYStatement
{
    CYIdentifier *label_;

    CYBreak(CYIdentifier *label) :
        label_(label)
    {
    }
};

struct CYReturn :
    CYStatement
{
    CYExpression *value_;

    CYReturn(CYExpression *value) :
        value_(value)
    {
    }
};

struct CYEmpty :
    CYStatement
{
};

struct CYTry :
    CYStatement
{
    CYStatement *try_;
    CYCatch *catch_;
    CYStatement *finally_;

    CYTry(CYStatement *_try, CYCatch *_catch, CYStatement *finally) :
        try_(_try),
        catch_(_catch),
        finally_(finally)
    {
    }
};

struct CYThrow :
    CYStatement
{
    CYExpression *value_;

    CYThrow(CYExpression *value) :
        value_(value)
    {
    }
};

struct CYWith :
    CYStatement
{
    CYExpression *scope_;
    CYStatement *code_;

    CYWith(CYExpression *scope, CYStatement *code) :
        scope_(scope),
        code_(code)
    {
    }
};

struct CYSwitch :
    CYStatement
{
    CYExpression *value_;
    CYClause *clauses_;

    CYSwitch(CYExpression *value, CYClause *clauses) :
        value_(value),
        clauses_(clauses)
    {
    }
};

struct CYCondition :
    CYExpression
{
    CYExpression *test_;
    CYExpression *true_;
    CYExpression *false_;

    CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) :
        true_(_true),
        false_(_false)
    {
    }
};

#define CYPostfix_(op, name) \
    struct CY ## name : \
        CYPostfix \
    { \
        CY ## name(CYExpression *lhs) : \
            CYPostfix(lhs) \
        { \
        } \
    };

#define CYPrefix_(op, name) \
    struct CY ## name : \
        CYPrefix \
    { \
        CY ## name(CYExpression *rhs) : \
            CYPrefix(rhs) \
        { \
        } \
    };

#define CYInfix_(op, name) \
    struct CY ## name : \
        CYInfix \
    { \
        CY ## name(CYExpression *lhs, CYExpression *rhs) : \
            CYInfix(lhs, rhs) \
        { \
        } \
    };

#define CYAssignment_(op, name) \
    struct CY ## name ## Assign : \
        CYAssignment \
    { \
        CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \
            CYAssignment(lhs, rhs) \
        { \
        } \
    };

CYPostfix_("++", PostIncrement)
CYPostfix_("--", PostDecrement)

CYPrefix_("delete", Delete)
CYPrefix_("void", Void)
CYPrefix_("typeof", TypeOf)
CYPrefix_("++", PreIncrement)
CYPrefix_("--", PreDecrement)
CYPrefix_("-", Negate)
CYPrefix_("~", BitwiseNot)
CYPrefix_("!", LogicalNot)
CYPrefix_("*", Indirect)
CYPrefix_("&", AddressOf)

CYInfix_("*", Multiply)
CYInfix_("/", Divide)
CYInfix_("%", Modulus)
CYInfix_("+", Add)
CYInfix_("-", Subtract)
CYInfix_("<<", ShiftLeft)
CYInfix_(">>", ShiftRightSigned)
CYInfix_(">>>", ShiftRightUnsigned)
CYInfix_("<", Less)
CYInfix_(">", Greater)
CYInfix_("<=", LessOrEqual)
CYInfix_(">=", GreaterOrEqual)
CYInfix_("instanceof", InstanceOf)
CYInfix_("in", In)
CYInfix_("==", Equal)
CYInfix_("!=", NotEqual)
CYInfix_("===", Identical)
CYInfix_("!==", NotIdentical)
CYInfix_("&", BitwiseAnd)
CYInfix_("^", BitwiseXOr)
CYInfix_("|", BitwiseOr)
CYInfix_("&&", LogicalAnd)
CYInfix_("||", LogicalOr)

CYAssignment_("=", )
CYAssignment_("*=", Multiply)
CYAssignment_("/=", Divide)
CYAssignment_("%=", Modulus)
CYAssignment_("+=", Add)
CYAssignment_("-=", Subtract)
CYAssignment_("<<=", ShiftLeft)
CYAssignment_(">>=", ShiftRightSigned)
CYAssignment_(">>>=", ShiftRightUnsigned)
CYAssignment_("&=", BitwiseAnd)
CYAssignment_("^=", BitwiseXOr)
CYAssignment_("|=", BitwiseOr)

#endif/*CYPARSER_HPP*/
Commit	Line	Data
63b4c5a8 JF	1	#ifndef CYPARSER_HPP
	2	#define CYPARSER_HPP
	3
cf7d4c69 JF	4	#include <cstdlib>
cf7d4c69 JF	5
e5332278	6	class CYParser {
924f67b2 JF	7	public:
	8	void *scanner_;
	9
	10	private:
	11	void ScannerInit();
	12	void ScannerDestroy();
	13
	14	public:
	15	CYParser();
	16	~CYParser();
e5332278	17	};
63b4c5a8	18
cf7d4c69 JF	19	struct CYSource {
	20	CYSource *next_;
	21
	22	void SetNext(CYSource *next) {
	23	next_ = next;
	24	}
	25	};
	26
	27	struct CYName {
	28	virtual const char *Name() const = 0;
63b4c5a8 JF	29	};
	30
	31	struct CYToken {
	32	virtual const char *Text() const = 0;
	33	};
	34
cf7d4c69 JF	35	struct CYWord :
	36	virtual CYToken,
	37	CYName
63b4c5a8	38	{
cf7d4c69 JF	39	const char *word_;
	40
	41	CYWord(const char *word) :
	42	word_(word)
	43	{
	44	}
	45
	46	virtual const char *Text() const {
	47	return word_;
	48	}
	49
	50	virtual const char *Name() const {
	51	return Text();
	52	}
63b4c5a8 JF	53	};
63b4c5a8 JF	54
cf7d4c69 JF	55	struct CYIdentifier :
cf7d4c69 JF	56	CYWord
63b4c5a8	57	{
cf7d4c69 JF	58	const char *word_;
	59
	60	virtual const char *Text() const {
	61	return word_;
	62	}
63b4c5a8 JF	63	};
63b4c5a8 JF	64
cf7d4c69 JF	65	struct CYLabel {
	66	CYIdentifier *identifier_;
	67	CYLabel *next_;
	68
	69	CYLabel(CYIdentifier identifier, CYLabel next) :
	70	identifier_(identifier),
	71	next_(next)
	72	{
	73	}
	74	};
	75
	76	struct CYStatement :
	77	CYSource
63b4c5a8	78	{
cf7d4c69 JF	79	CYLabel *label_;
	80
	81	void AddLabel(CYIdentifier *identifier) {
	82	label_ = new CYLabel(identifier, label_);
	83	}
	84	};
	85
	86	struct CYForInitialiser {
	87	};
	88
	89	struct CYForInInitialiser {
63b4c5a8 JF	90	};
63b4c5a8 JF	91
cf7d4c69 JF	92	struct CYExpression :
	93	CYStatement,
	94	CYForInitialiser,
	95	CYForInInitialiser
63b4c5a8 JF	96	{
	97	};
	98
cf7d4c69 JF	99	struct CYLiteral :
cf7d4c69 JF	100	CYExpression
63b4c5a8	101	{
cf7d4c69	102	};
63b4c5a8	103
cf7d4c69 JF	104	struct CYString :
	105	CYLiteral,
	106	CYName
	107	{
	108	const char *value_;
	109
	110	CYString(const char *value) :
	111	value_(value)
	112	{
	113	}
	114
	115	CYString(const CYIdentifier *identifier) :
	116	value_(identifier->Text())
	117	{
	118	}
	119
	120	const char *String() const {
	121	return value_;
	122	}
	123
	124	virtual const char *Name() const {
	125	return String();
63b4c5a8 JF	126	}
	127	};
	128
cf7d4c69 JF	129	struct CYNumber :
	130	virtual CYToken,
	131	CYLiteral,
	132	CYName
	133	{
	134	double Number() const {
	135	throw;
	136	}
	137
	138	virtual const char *Name() const {
	139	throw;
	140	}
	141	};
	142
	143	struct CYNull :
	144	CYWord,
	145	CYLiteral
	146	{
	147	CYNull() :
	148	CYWord("null")
	149	{
	150	}
	151	};
	152
	153	struct CYThis :
	154	CYWord,
	155	CYExpression
	156	{
	157	CYThis() :
	158	CYWord("this")
	159	{
	160	}
	161	};
	162
	163	struct CYBoolean :
	164	CYLiteral
	165	{
	166	};
	167
	168	struct CYFalse :
	169	CYWord,
	170	CYBoolean
	171	{
	172	CYFalse() :
	173	CYWord("false")
	174	{
	175	}
	176	};
	177
	178	struct CYTrue :
	179	CYWord,
	180	CYBoolean
	181	{
	182	CYTrue() :
	183	CYWord("true")
	184	{
	185	}
	186	};
	187
	188	struct CYVariable :
	189	CYExpression
	190	{
	191	CYIdentifier *name_;
	192
193	CYVariable(CYIdentifier *name) :
194	name_(name)
195	{
196	}
197	};
198
199	struct CYPrefix :
63b4c5a8 JF	200	CYExpression
	201	{
	202	CYExpression *rhs_;
	203
cf7d4c69	204	CYPrefix(CYExpression *rhs) :
63b4c5a8 JF	205	rhs_(rhs)
	206	{
	207	}
	208	};
	209
cf7d4c69	210	struct CYInfix :
63b4c5a8 JF	211	CYExpression
	212	{
	213	CYExpression *lhs_;
	214	CYExpression *rhs_;
	215
cf7d4c69	216	CYInfix(CYExpression lhs, CYExpression rhs) :
63b4c5a8 JF	217	lhs_(lhs),
	218	rhs_(rhs)
	219	{
	220	}
	221	};
	222
cf7d4c69	223	struct CYPostfix :
63b4c5a8 JF	224	CYExpression
	225	{
	226	CYExpression *lhs_;
	227
cf7d4c69	228	CYPostfix(CYExpression *lhs) :
63b4c5a8 JF	229	lhs_(lhs)
	230	{
	231	}
	232	};
	233
cf7d4c69 JF	234	struct CYAssignment :
	235	CYInfix
	236	{
	237	CYAssignment(CYExpression lhs, CYExpression rhs) :
	238	CYInfix(lhs, rhs)
	239	{
	240	}
	241	};
	242
	243	struct CYArgument {
	244	CYWord *name_;
	245	CYExpression *value_;
	246	CYArgument *next_;
	247
	248	CYArgument(CYWord name, CYExpression value, CYArgument *next = NULL) :
	249	name_(name),
	250	value_(value),
	251	next_(next)
	252	{
	253	}
	254	};
	255
	256	struct CYBlank :
	257	public CYWord
	258	{
	259	CYBlank() :
	260	CYWord("")
	261	{
	262	}
	263	};
	264
	265	struct CYClause {
	266	CYExpression *case_;
	267	CYStatement *code_;
	268	CYClause *next_;
	269
	270	CYClause(CYExpression _case, CYStatement code) :
	271	case_(_case),
	272	code_(code)
	273	{
	274	}
	275
	276	void SetNext(CYClause *next) {
	277	next_ = next;
	278	}
	279	};
	280
	281	struct CYElement :
	282	CYLiteral
	283	{
	284	CYExpression *value_;
	285	CYElement *next_;
	286
	287	CYElement(CYExpression value, CYElement next) :
	288	value_(value),
	289	next_(next)
	290	{
	291	}
	292	};
	293
	294	struct CYDeclaration :
	295	CYForInInitialiser
	296	{
	297	CYIdentifier *identifier_;
298	CYExpression *initialiser_;
299
300	CYDeclaration(CYIdentifier identifier, CYExpression initialiser) :
301	identifier_(identifier),
302	initialiser_(initialiser)
303	{
304	}
305	};
306
307	struct CYDeclarations :
308	CYStatement,
309	CYForInitialiser
310	{
311	CYDeclaration *declaration_;
312	CYDeclarations *next_;
313
314	CYDeclarations(CYDeclaration declaration, CYDeclarations next) :
315	declaration_(declaration),
316	next_(next)
317	{
318	}
319	};
320
321	struct CYParameter {
322	CYIdentifier *name_;
323	CYParameter *next_;
324
325	CYParameter(CYIdentifier name, CYParameter next) :
326	name_(name),
327	next_(next)
328	{
329	}
330	};
331
332	struct CYFor :
333	CYStatement
334	{
335	CYForInitialiser *initialiser_;
336	CYExpression *test_;
337	CYExpression *increment_;
338	CYStatement *code_;
339
340	CYFor(CYForInitialiser initialiser, CYExpression test, CYExpression increment, CYStatement code) :
341	initialiser_(initialiser),
342	test_(test),
343	increment_(increment),
344	code_(code)
345	{
346	}
347	};
348
349	struct CYForIn :
350	CYStatement
351	{
352	CYForInInitialiser *initialiser_;
353	CYExpression *set_;
354	CYStatement *code_;
355
356	CYForIn(CYForInInitialiser initialiser, CYExpression set, CYStatement *code) :
357	initialiser_(initialiser),
358	set_(set),
359	code_(code)
360	{
361	}
362	};
363
364	struct CYProperty :
365	CYLiteral
366	{
367	CYName *name_;
368	CYExpression *value_;
369	CYProperty *next_;
370
371	CYProperty(CYName name, CYExpression value, CYProperty *next) :
372	name_(name),
373	value_(value),
374	next_(next)
375	{
376	}
377	};
378
379	struct CYCatch {
380	CYIdentifier *name_;
381	CYStatement *code_;
382
383	CYCatch(CYIdentifier name, CYStatement code) :
384	name_(name),
385	code_(code)
386	{
387	}
388	};
389
390	struct CYMessage :
63b4c5a8 JF	391	CYExpression
63b4c5a8 JF	392	{
cf7d4c69 JF	393	CYExpression *self_;
cf7d4c69 JF	394	CYArgument *arguments_;
63b4c5a8	395
cf7d4c69 JF	396	CYMessage(CYExpression self, CYArgument arguments) :
	397	self_(self),
	398	arguments_(arguments)
63b4c5a8 JF	399	{
	400	}
	401	};
	402
cf7d4c69 JF	403	struct CYMember :
	404	CYExpression
	405	{
	406	CYExpression *object_;
	407	CYExpression *property_;
	408
	409	CYMember(CYExpression object, CYExpression property) :
	410	object_(object),
	411	property_(property)
	412	{
	413	}
	414	};
	415
	416	struct CYNew :
	417	CYExpression
	418	{
	419	CYExpression *constructor_;
	420	CYArgument *arguments_;
	421
	422	CYNew(CYExpression constructor, CYArgument arguments) :
	423	constructor_(constructor),
	424	arguments_(arguments)
	425	{
	426	}
	427	};
	428
	429	struct CYCall :
	430	CYExpression
	431	{
	432	CYExpression *function_;
	433	CYArgument *arguments_;
	434
	435	CYCall(CYExpression function, CYArgument arguments) :
	436	function_(function),
	437	arguments_(arguments)
	438	{
	439	}
	440	};
	441
	442	struct CYIf :
	443	CYStatement
	444	{
	445	CYExpression *test_;
	446	CYStatement *true_;
	447	CYStatement *false_;
	448
	449	CYIf(CYExpression test, CYStatement _true, CYStatement *_false) :
	450	test_(test),
	451	true_(_true),
	452	false_(_false)
	453	{
	454	}
	455	};
	456
	457	struct CYDoWhile :
	458	CYStatement
	459	{
	460	CYExpression *test_;
	461	CYStatement *code_;
	462
	463	CYDoWhile(CYExpression test, CYStatement code) :
	464	test_(test),
	465	code_(code)
	466	{
467	}
468	};
469
470	struct CYWhile :
471	CYStatement
472	{
473	CYExpression *test_;
474	CYStatement *code_;
475
476	CYWhile(CYExpression test, CYStatement code) :
477	test_(test),
478	code_(code)
479	{
480	}
481	};
482
483	struct CYLambda :
484	CYExpression
485	{
486	CYIdentifier *name_;
487	CYParameter *parameters_;
488	CYSource *body_;
489
490	CYLambda(CYIdentifier name, CYParameter parameters, CYSource *body) :
491	name_(name),
492	parameters_(parameters),
493	body_(body)
494	{
495	}
496	};
497
498	struct CYFunction :
499	CYLambda
500	{
501	CYFunction(CYIdentifier name, CYParameter parameters, CYSource *body) :
502	CYLambda(name, parameters, body)
503	{
504	}
505	};
506
507	struct CYContinue :
508	CYStatement
509	{
510	CYIdentifier *label_;
511
512	CYContinue(CYIdentifier *label) :
513	label_(label)
514	{
515	}
516	};
517
518	struct CYBreak :
519	CYStatement
520	{
521	CYIdentifier *label_;
522
523	CYBreak(CYIdentifier *label) :
524	label_(label)
525	{
526	}
527	};
528
529	struct CYReturn :
530	CYStatement
531	{
532	CYExpression *value_;
533
534	CYReturn(CYExpression *value) :
535	value_(value)
536	{
537	}
538	};
539
540	struct CYEmpty :
541	CYStatement
542	{
543	};
544
545	struct CYTry :
546	CYStatement
547	{
548	CYStatement *try_;
549	CYCatch *catch_;
550	CYStatement *finally_;
551
552	CYTry(CYStatement _try, CYCatch _catch, CYStatement *finally) :
553	try_(_try),
554	catch_(_catch),
555	finally_(finally)
556	{
557	}
558	};
559
560	struct CYThrow :
561	CYStatement
562	{
563	CYExpression *value_;
564
565	CYThrow(CYExpression *value) :
566	value_(value)
567	{
568	}
569	};
570
571	struct CYWith :
572	CYStatement
573	{
574	CYExpression *scope_;
575	CYStatement *code_;
576
577	CYWith(CYExpression scope, CYStatement code) :
578	scope_(scope),
579	code_(code)
580	{
581	}
582	};
583
584	struct CYSwitch :
585	CYStatement
586	{
587	CYExpression *value_;
588	CYClause *clauses_;
589
590	CYSwitch(CYExpression value, CYClause clauses) :
591	value_(value),
592	clauses_(clauses)
593	{
594	}
595	};
596
597	struct CYCondition :
598	CYExpression
599	{
600	CYExpression *test_;
601	CYExpression *true_;
602	CYExpression *false_;
603
604	CYCondition(CYExpression test, CYExpression _true, CYExpression *_false) :
605	true_(_true),
606	false_(_false)
607	{
608	}
609	};
610
611	#define CYPostfix_(op, name) \
612	struct CY ## name : \
613	CYPostfix \
614	{ \
615	CY ## name(CYExpression *lhs) : \
616	CYPostfix(lhs) \
617	{ \
618	} \
619	};
620
621	#define CYPrefix_(op, name) \
622	struct CY ## name : \
623	CYPrefix \
624	{ \
625	CY ## name(CYExpression *rhs) : \
626	CYPrefix(rhs) \
627	{ \
628	} \
629	};
630
631	#define CYInfix_(op, name) \
632	struct CY ## name : \
633	CYInfix \
634	{ \
635	CY ## name(CYExpression lhs, CYExpression rhs) : \
636	CYInfix(lhs, rhs) \
637	{ \
638	} \
639	};
640
641	#define CYAssignment_(op, name) \
642	struct CY ## name ## Assign : \
643	CYAssignment \
644	{ \
645	CY ## name ## Assign(CYExpression lhs, CYExpression rhs) : \
646	CYAssignment(lhs, rhs) \
647	{ \
648	} \
649	};
650
651	CYPostfix_("++", PostIncrement)
652	CYPostfix_("--", PostDecrement)
653
654	CYPrefix_("delete", Delete)
655	CYPrefix_("void", Void)
656	CYPrefix_("typeof", TypeOf)
657	CYPrefix_("++", PreIncrement)
658	CYPrefix_("--", PreDecrement)
659	CYPrefix_("-", Negate)
660	CYPrefix_("~", BitwiseNot)
661	CYPrefix_("!", LogicalNot)
662	CYPrefix_("*", Indirect)
663	CYPrefix_("&", AddressOf)
664
665	CYInfix_("*", Multiply)
666	CYInfix_("/", Divide)
667	CYInfix_("%", Modulus)
668	CYInfix_("+", Add)
669	CYInfix_("-", Subtract)
670	CYInfix_("<<", ShiftLeft)
671	CYInfix_(">>", ShiftRightSigned)
672	CYInfix_(">>>", ShiftRightUnsigned)
673	CYInfix_("<", Less)
674	CYInfix_(">", Greater)
675	CYInfix_("<=", LessOrEqual)
676	CYInfix_(">=", GreaterOrEqual)
677	CYInfix_("instanceof", InstanceOf)
678	CYInfix_("in", In)
679	CYInfix_("==", Equal)
680	CYInfix_("!=", NotEqual)
681	CYInfix_("===", Identical)
682	CYInfix_("!==", NotIdentical)
683	CYInfix_("&", BitwiseAnd)
684	CYInfix_("^", BitwiseXOr)
685	CYInfix_("\|", BitwiseOr)
686	CYInfix_("&&", LogicalAnd)
687	CYInfix_("\|\|", LogicalOr)
688
689	CYAssignment_("=", )
690	CYAssignment_("*=", Multiply)
691	CYAssignment_("/=", Divide)
692	CYAssignment_("%=", Modulus)
693	CYAssignment_("+=", Add)
694	CYAssignment_("-=", Subtract)
695	CYAssignment_("<<=", ShiftLeft)
696	CYAssignment_(">>=", ShiftRightSigned)
697	CYAssignment_(">>>=", ShiftRightUnsigned)
698	CYAssignment_("&=", BitwiseAnd)
699	CYAssignment_("^=", BitwiseXOr)
700	CYAssignment_("\|=", BitwiseOr)
701
63b4c5a8	702	#endif/CYPARSER_HPP/