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.67.2.8.2.5 and 1.78

version 1.67.2.8.2.5, 2003/03/27 14:51:28	version 1.78, 2008/06/10 14:06:36
Line 1	Line 1
/** @file	/** @file
Parser: compiler support helper functions decls.	Parser: compiler support helper functions decls.

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

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

static const char* IDENT_COMPILE_TOOLS_H="$Date$";	static const char * const 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"
#include "pa_request.h"	#include "pa_request.h"

	/// used to track source column number
	#define TAB_SIZE 8

enum lexical_state {	enum lexical_state {
LS_USER, LS_NAME_SQUARE_PART,	LS_USER, LS_NAME_SQUARE_PART,
LS_USER_COMMENT,	LS_USER_COMMENT,
Line 38 enum lexical_state {	Line 41 enum lexical_state {
LS_METHOD_ROUND,	LS_METHOD_ROUND,
LS_METHOD_AFTER	LS_METHOD_AFTER
};	};

	struct Pos {
	int line;
	int col;
	Pos(int aline, int acol): line(aline), col(acol) {}
	Pos(): line(0), col(0) {}

	void clear() { line=col=0; }
	operator bool() { return col!=0; }
	};

/// compiler status	/// compiler status
struct parse_control {	class Parse_control {
	const String* main_alias;
	uint last_line_end_col;
	public:
	const String& alias_method(const String& name);
//@{	//@{
/// @name input	/// @name input
Request& request;	Request& request;
VStateless_class* cclass;	VStateless_class* cclass;
	ArrayClass* cclasses;
const char* source;	const char* source;
const char* file;	uint file_no;
int line, col;	Pos pos;
//@}	//@}
//@{	//@{
/// @name state; initially	/// @name state; initially
bool trim_bof;	bool trim_bof;
int pending_state; ///< i=0	int pending_state; ///< i=0
StringBody string; ///< lexical string accumulator	String::Body string; ///< lexical string accumulator
	Pos string_start;

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

bool in_call_value;	bool in_call_value;
	bool explicit_result;
//@}	//@}

/// 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,	Parse_control(Request& arequest,
VStateless_class* aclass,	VStateless_class* aclass,
const char* asource,	const char* asource, const String* amain_alias,
const char* afile):	uint afile_no,
	int line_no_offset):
	main_alias(amain_alias),
	last_line_end_col(0),

request(arequest), // input	request(arequest), // input

// we were told the class to compile to?	// we were told the class to compile to?
cclass(aclass), // until changed with @CLASS would consider operators loading	cclass(aclass), // until changed with @CLASS would consider operators loading
	cclasses(new ArrayClass(1)),
	source(asource),
	file_no(afile_no),
	pos(line_no_offset, 0),

source(asource),	// initialize state

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

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

	*cclasses+=aclass;
	}

	void pos_next_line() {
	pos.line++;
	last_line_end_col=pos.col;
	pos.col=0;
	}
	void pos_next_c(int c) {
	if(c=='\t')
	pos.col=(pos.col+TAB_SIZE)&~(TAB_SIZE-1);
	else
	pos.col++;
	}
	/// not precise in case of \t in the middle of the text
	void pos_prev_c() {
	if(pos.col==0) {
	--pos.line; pos.col=last_line_end_col;
	} else
	--pos.col;
	}
	void ungetc() {
	source--;
	pos_prev_c();
}	}
};	};

Line 94 inline ArrayOperation* N() {	Line 144 inline ArrayOperation* N() {
return new ArrayOperation;	return new ArrayOperation;
}	}

/// Assembler instruction // append ordinary instruction to ops	/// Assembler instruction // append ordinary instruction to ops
inline void O(ArrayOperation& result, OPCODE code) {	inline void O(ArrayOperation& result, OPCODE code) {
result+=Operation(code);	result+=Operation(code);
}	}
Line 108 inline void P(ArrayOperation& result, Ar	Line 158 inline void P(ArrayOperation& result, Ar
result.append(code_array, offset);	result.append(code_array, offset);
}	}

/// aPpend 'vstring' to 'result'
inline void PV(ArrayOperation& result, Value* value) {
result+=Operation(OP_VALUE); // append OP_VALUE
result+=Operation(value); // append 'value'
}

/// append cOde Array	/// append cOde Array
inline void OA(ArrayOperation& result, OPCODE code, ArrayOperation* code_array) {	inline void OA(ArrayOperation& result, OPCODE code, ArrayOperation* code_array) {
result+=Operation(code); // append OP_CODE	result+=Operation(code); // append OP_CODE
Line 122 inline void OA(ArrayOperation& result, O	Line 166 inline void OA(ArrayOperation& result, O

/**	/**
Value Literal // returns array with	Value Literal // returns array with
- first: OP_VALUE instruction	- first op: OP_VALUE instruction
- second op: string itself	- second op: origin (debug information)
	- third op: string itself
*/	*/
inline ArrayOperation* VL(Value* value) {	inline ArrayOperation* VL(Value* value, uint file_no, uint line, uint col) {
// empty ops array	// empty ops array
ArrayOperation* result=N();	ArrayOperation& result=*N();

// append 'value' to 'result'	// append 'value' to 'result'
PV(*result, value);	result+=Operation(OP_VALUE);
	result+=Operation(file_no, line, col); // append origin
	result+=Operation(value); // append 'value'

return result;	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+origin+Value
Value* LA2V(ArrayOperation& 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+origin+String array
inline const String* LA2S(ArrayOperation& 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();
Line 149 inline void change_string_literal_to_wri	Line 196 inline void change_string_literal_to_wri
}	}


void change_string_literal_to_double_literal(ArrayOperation& literal_string_array);	void maybe_change_string_literal_to_double_literal(ArrayOperation& literal_string_array);

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

Line 157 void changetail_or_append(ArrayOperation	Line 204 void changetail_or_append(ArrayOperation
OPCODE find, bool with_argument, OPCODE replace, OPCODE notfound);	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);

#endif	#endif

E-mail:

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