Return to pa_request.C CVS log

Up to [parser3project] / parser3 / src / main

$ENV: re 0, stateless classes

/*
	Parser
	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)

	$Id: pa_request.C,v 1.26 2001/03/13 13:43:30 paf Exp $
*/

#include <string.h>

#include "pa_request.h"
#include "pa_wwrapper.h"
#include "pa_common.h"
#include "pa_vclass.h"
#include "_root.h"
#include "_env.h"
#include "_table.h"
#include "core.h"

#include <stdio.h>

Request::Request(Pool& apool) : Pooled(apool),
	stack(apool),
	root_class(apool),
	env_class(apool),
	fclasses(apool),
	fclasses_array(apool),
	flang(String::Untaint_lang::HTML_TYPO)
{
	// root class
	initialize_root_class(pool(), root_class);
	// adding root superclass, 
	//   parent of all classes, 
	//   operators holder
	classes().put(*root_class_name, &root_class);
	//root_class.set_name(*root_class_name);

	// env class
	initialize_env_class(pool(), env_class);
	classes().put(*env_class_name, &env_class);

	// table class
	classes().put(*table_class_name, table_class);	
	table_class->set_name(*table_class_name);


	// web
	// TODO: ifdef WIN32 flip \\ to /
	document_root="Y:/parser3/src/";
	page_filespec="Y:/parser3/src/test.p";
}

void Request::core() {
	TRY {
		// loading system auto.p
		char *sys_auto_file="C:\\temp\\auto.p";
		VStateless_class *main_class=use_file(
			sys_auto_file, false/*ignore possible read problem*/,
			main_class_name);

		// TODO: использовать $MAIN:limits здесь, пока их не сломали враги

		// TODO: load site auto.p files, all assigned bases from upper dir
		char *site_auto_file="Y:\\parser3\\src\\auto.p";
		main_class=use_file(
			site_auto_file, false/*ignore possible read problem*/,
			main_class_name, main_class);

		// there must be some auto.p
		if(!main_class)
			THROW(0,0,
				0,
				"no 'auto.p' found (nither system nor any site's)");

		// compiling requested file
		main_class=use_file(page_filespec, true/*don't ignore read problem*/,
			main_class_name, main_class);

		// execute @main[]
		char *result=execute_method(*main_class, *main_method_name, 
			true /*result needed*/);
		if(!result)
			THROW(0,0,
			0, 
			"'"MAIN_METHOD_NAME"' method not found");

		printf("result-----------------\n%sEOF----------------\n", result);
	} 
	CATCH(e) {
		printf("\nERROR: ");
		const String *problem_source=e.problem_source();
#ifndef NO_STRING_ORIGIN
		if(problem_source) {
			const Origin& origin=problem_source->origin();
			if(origin.file)
				printf("%s(%d): ",
				origin.file, 1+origin.line);
			printf("'%s' ", 
				problem_source->cstr());
		}
#endif
		printf("%s", e.comment());
		const String *type=e.type();
		if(type) {
			printf("  type: %s", type->cstr());
			const String *code=e.code();
			if(code)
				printf(", code: %s", code->cstr());
		}
		printf("\n");
	}
	END_CATCH
}

VStateless_class *Request::use_file(
									const char *file, bool fail_on_read_problem,
									const String *name, 
									VStateless_class *base_class) {
	// TODO: обнаружить|решить cyclic dependences
	char *source=file_read(pool(), file, fail_on_read_problem);
	if(!source)
		return base_class;

	return use_buf(source, file, 0/*new class*/, name, base_class);
}

VStateless_class *Request::use_buf(
								   const char *source, const char *file,
								   VStateless_class *aclass, const String *name, 
								   VStateless_class *base_class) {
	// compile loaded class
	VStateless_class& cclass=COMPILE(source, aclass, name, base_class, file);

	// locate and execute possible @auto[] static method
	execute_method(cclass, *auto_method_name, false /*no result needed*/);
	return &cclass;
}

void Request::fail_if_junction_(bool is, 
								Value& value, const String& method_name, char *msg) {

	// fail_if_junction(true, junction = fail
	// fail_if_junction(false, not junction = fail
	if((value.get_junction()!=0) ^ !is)
		THROW(0, 0,
			&method_name,
			msg);
}

char *Request::relative(const char *path, const char *file) {
    char *result=(char *)malloc(strlen(path)+strlen(file)+1);
	strcpy(result, path);
    rsplit(result,'/');
    strcat(result, "/");
    strcat(result, file);
    return result;
}

char *Request::absolute(const char *name) {
	if(name[0]=='/') {
		char *result=(char *)malloc(strlen(document_root)+strlen(name)+1);
		strcpy(result, document_root);
		strcat(result, name);
		return result;
	} else 
		return relative(page_filespec, name);
}