parser3/src/main/compile_tools.h - diff

Return to compile_tools.h CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/compile_tools.h between versions 1.55 and 1.67.2.8.2.5

version 1.55, 2002/02/07 11:16:28	version 1.67.2.8.2.5, 2003/03/27 14:51:28
Line 1	Line 1
/** @file	/** @file
Parser: compiler support helper functions decls.	Parser: compiler support helper functions decls.

Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)

$Id$
*/	*/

#ifndef COMPILE_TOOLS	#ifndef COMPILE_TOOLS
#define COMPILE_TOOLS	#define COMPILE_TOOLS

	static const char* IDENT_COMPILE_TOOLS_H="$Date$";

#include "pa_opcode.h"	#include "pa_opcode.h"
#include "pa_types.h"	#include "pa_types.h"
#include "pa_vstring.h"	#include "pa_vstring.h"
Line 17	Line 17

enum lexical_state {	enum lexical_state {
LS_USER, LS_NAME_SQUARE_PART,	LS_USER, LS_NAME_SQUARE_PART,
LS_COMMENT,	LS_USER_COMMENT,
LS_DEF_NAME,	LS_DEF_NAME,
LS_DEF_PARAMS,	LS_DEF_PARAMS,
LS_DEF_LOCALS,	LS_DEF_LOCALS,
Line 26 enum lexical_state {	Line 26 enum lexical_state {
LS_EXPRESSION_STRING_QUOTED,	LS_EXPRESSION_STRING_QUOTED,
LS_EXPRESSION_STRING_APOSTROFED,	LS_EXPRESSION_STRING_APOSTROFED,
LS_EXPRESSION_VAR_NAME_WITH_COLON, LS_EXPRESSION_VAR_NAME_WITHOUT_COLON,	LS_EXPRESSION_VAR_NAME_WITH_COLON, LS_EXPRESSION_VAR_NAME_WITHOUT_COLON,
	LS_EXPRESSION_COMMENT,
LS_VAR_NAME_SIMPLE_WITH_COLON, LS_VAR_NAME_SIMPLE_WITHOUT_COLON,	LS_VAR_NAME_SIMPLE_WITH_COLON, LS_VAR_NAME_SIMPLE_WITHOUT_COLON,
LS_VAR_NAME_CURLY,	LS_VAR_NAME_CURLY,
LS_VAR_ROUND,	LS_VAR_ROUND,
Line 41 enum lexical_state {	Line 42 enum lexical_state {
struct parse_control {	struct parse_control {
//@{	//@{
/// @name input	/// @name input
Pool *pool;	Request& request;
Request *request;	VStateless_class* cclass;
VStateless_class *cclass;	const char* source;
#ifndef NO_CSTRING_ORIGIN	const char* file;
const char *source;
const char *file;
#endif
int line, col;	int line, col;
//@}	//@}
//@{	//@{
/// @name state; initially	/// @name state; initially
bool trim_bof;	bool trim_bof;
int pending_state; ///< i=0	int pending_state; ///< i=0
String *string; ///< =new(pool) String(pool)	StringBody string; ///< lexical string accumulator

#define MAX_LEXICAL_STATES 100	#define MAX_LEXICAL_STATES 100
enum lexical_state ls; ///< =LS_USER;	enum lexical_state ls; ///< =LS_USER;
Line 62 struct parse_control {	Line 60 struct parse_control {
enum lexical_state ls_stack[MAX_LEXICAL_STATES];	enum lexical_state ls_stack[MAX_LEXICAL_STATES];
int brackets_nestages[MAX_LEXICAL_STATES]; ///< brackets nestage on each state	int brackets_nestages[MAX_LEXICAL_STATES]; ///< brackets nestage on each state

bool object_constructor_allowed;	bool in_call_value;
//@}	//@}

/// output: filled input 'methods' and 'error' if any	/// output: filled input 'methods' and 'error' if any
char error[MAX_STRING];	char error[MAX_STRING];

	parse_control(Request& arequest,
	VStateless_class* aclass,
	const char* asource,
	const char* afile):
	request(arequest), // input

	// we were told the class to compile to?
	cclass(aclass), // until changed with @CLASS would consider operators loading

	source(asource),

	file(afile),
	line(0), col(0),

	// initialise state
	trim_bof(true),
	pending_state(0),
	ls(LS_USER),
	ls_sp(0),
	in_call_value(false) {
	}
};	};

/// New array // return empty array	/// New array // return empty array
inline Array/<Operation>/ *N(Pool& pool) {	inline ArrayOperation* N() {
return new(pool) Array/<Operation>/(pool);	return new ArrayOperation;
}	}

/// Assembler instruction // append ordinary instruction to ops	/// Assembler instruction // append ordinary instruction to ops
inline void O(Array/<Operation>/ *result, enum OPCODE code) {	inline void O(ArrayOperation& result, OPCODE code) {
Operation op; op.code=code;	result+=Operation(code);
*result+=op.cast;
}	}

/// aPpend 'code_array' to 'result'	/// aPpend 'code_array' to 'result'
inline void P(Array/<Operation>/ result, Array code_array) {	inline void P(ArrayOperation& result, ArrayOperation& code_array) {
result->append_array(*code_array);	result.append(code_array);
}	}
/// aPpend part of 'code_array', starting from offset, to 'result'	/// aPpend part of 'code_array', starting from offset, to 'result'
inline void P(Array/<Operation>/ result, Array code_array, int offset) {	inline void P(ArrayOperation& result, ArrayOperation& code_array, int offset) {
result->append_array(*code_array, offset);	result.append(code_array, offset);
}	}

/// aPpend 'vstring' to 'result'	/// aPpend 'vstring' to 'result'
void PV(Array/<Operation>/ result, VString vstring);	inline void PV(ArrayOperation& result, Value* value) {
/// Parameter 'simple Code_Array'	result+=Operation(OP_VALUE); // append OP_VALUE
void PCA(Array/<Operation>/ result, Array/<Operation>/ code_array);	result+=Operation(value); // append 'value'
/// Parameter 'Expression code_Array'	}
void PEA(Array/<Operation>/ result, Array/<Operation>/ code_array);
/// Construct 'simple Code_Array'	/// append cOde Array
void CCA(Array/<Operation>/ result, Array/<Operation>/ code_array);	inline void OA(ArrayOperation& result, OPCODE code, ArrayOperation* code_array) {
/// aPpend Nested Code	result+=Operation(code); // append OP_CODE
void PNC(Array/<Operation>/ result, Array/<Operation>/ code_array);	result+=Operation(code_array); // append 'code_array'
	}

/**	/**
Value Literal // returns array with	Value Literal // returns array with
- first: OP_VALUE instruction	- first: OP_VALUE instruction
- second op: string itself	- second op: string itself
*/	*/
Array VL(Value value);	inline ArrayOperation* VL(Value* value) {
	// empty ops array
	ArrayOperation* result=N();

	// append 'value' to 'result'
	PV(*result, value);

	return result;
	}

/// Literal Array to(2) Value @return Value from literal Array OP+Value	/// Literal Array to(2) Value @return Value from literal Array OP+Value
Value LA2V(Array literal_string_array, int offset=0);	Value* LA2V(ArrayOperation& literal_string_array, int offset=0);
/// Literal Array to(2) String @return String value from literal Array OP+String array	/// Literal Array to(2) String @return String value from literal Array OP+String array
inline const String LA2S(Array literal_string_array, int offset=0) {	inline const String* LA2S(ArrayOperation& literal_string_array, int offset=0) {
if(Value *value=LA2V(literal_string_array, offset))	if(Value* value=LA2V(literal_string_array, offset))
return value->get_string();	return value->get_string();
return 0;	return 0;
}	}
void change_string_literal_to_double_literal(Array *literal_string_array);
void change_string_literal_to_write_string_literal(Array *literal_string_array);	inline void change_string_literal_to_write_string_literal(ArrayOperation& literal_string_array) {
	literal_string_array.put(0, OP_STRING__WRITE);
	}


	void change_string_literal_to_double_literal(ArrayOperation& literal_string_array);

	void change_string_literal_value(ArrayOperation& literal_string_array, const String& new_value);

	void changetail_or_append(ArrayOperation& opcodes,
	OPCODE find, bool with_argument, OPCODE replace, OPCODE notfound);


void push_LS(parse_control& pc, lexical_state new_state);	void push_LS(parse_control& pc, lexical_state new_state);
void pop_LS(parse_control& pc);	void pop_LS(parse_control& pc);

E-mail:

Removed from v.1.55
changed lines
	Added in v.1.67.2.8.2.5