[BACK]Return to pa_request.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_request.C between versions 1.4 and 1.20

version 1.4, 2001/03/10 14:05:36 version 1.20, 2001/03/12 17:16:50
Line 1 Line 1
 /*  /*
 $Id$          Parser
           Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
           Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
   
           $Id$
 */  */
   
   #include <string.h>
   
 #include "pa_request.h"  #include "pa_request.h"
 #include "pa_wwrapper.h"  #include "pa_wwrapper.h"
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_vclass.h"  #include "pa_vclass.h"
 #include "classes/_root.h"  #include "_root.h"
 #include "classes/_env.h"  #include "_env.h"
   #include "_table.h"
   #include "core.h"
   
 #include <stdio.h>  #include <stdio.h>
   
Line 17  Request::Request(Pool& apool) : Pooled(a Line 25  Request::Request(Pool& apool) : Pooled(a
         env_class(apool),          env_class(apool),
         fclasses(apool),          fclasses(apool),
         fclasses_array(apool),          fclasses_array(apool),
         lang(String::Untaint_lang::HTML_TYPO)          flang(String::Untaint_lang::HTML_TYPO)
 {  {
         // root class          // root class
         initialize_root_class(pool(), root_class);          initialize_root_class(pool(), root_class);
         // adding root superclass,           // adding root superclass, 
         //   parent of all classes,           //   parent of all classes, 
         //   operators holder          //   operators holder
         String ROOT(pool()); ROOT.APPEND_CONST(ROOT_NAME);          classes().put(*root_class_name, &root_class);
         classes().put(ROOT, &root_class);          //root_class.set_name(*root_class_name);
   
         // env class          // env class
         initialize_env_class(pool(), env_class);          initialize_env_class(pool(), env_class);
         String ENV(pool()); ENV.APPEND_CONST(ENV_NAME);          classes().put(*env_class_name, &env_class);
         classes().put(ENV, &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() {  void Request::core() {
         TRY {          TRY {
                 char *file="Y:\\parser3\\src\\test.p";                  // loading system auto.p
                 String RUN(pool()); RUN.APPEND_CONST(RUN_NAME);                  char *sys_auto_file="C:\\temp\\auto.p";
                 use(file, &RUN);                  VClass *main_class=use_file(
                           sys_auto_file, false/*ignore possible read problem*/,
                           0/*new class*/, 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*/,
                           0/*new class*/, main_class_name, main_class);
   
                   // there must be some auto.p
                   if(!main_class)
                           THROW(0,0,
                                   0,
                                   "'auto.p' not found");
   
                   // compiling requested file
                   use_file(page_filespec, true/*don't ignore read problem*/,
                           0/*new class*/, main_class_name, main_class);
   
                   // executing some @main[]
                 char *result=execute_MAIN();                  char *result=execute_MAIN();
                 printf("result-----------------\n%sEOF----------------\n", result);                  printf("result-----------------\n%sEOF----------------\n", result);
         }           } 
         CATCH(e) {          CATCH(e) {
                 printf("\nERROR: ");                  printf("\nERROR: ");
                 const String *problem_source=e.problem_source();                  const String *problem_source=e.problem_source();
   #ifndef NO_STRING_ORIGIN
                 if(problem_source) {                  if(problem_source) {
                         const Origin& origin=problem_source->origin();                          const Origin& origin=problem_source->origin();
                         if(origin.file)                          if(origin.file)
Line 53  void Request::core() { Line 92  void Request::core() {
                         printf("'%s' ",                           printf("'%s' ", 
                                 problem_source->cstr());                                  problem_source->cstr());
                 }                  }
   #endif
                 printf("%s", e.comment());                  printf("%s", e.comment());
                 const String *type=e.type();                  const String *type=e.type();
                 if(type) {                  if(type) {
Line 66  void Request::core() { Line 106  void Request::core() {
         END_CATCH          END_CATCH
 }  }
   
 void Request::use(char *file, String *name) {  VClass *Request::use_file(
                                                     const char *file, bool fail_on_read_problem,
                                                     VClass *aclass, const String *name, 
                                                     VClass *base_class) {
         // TODO: обнаружить|решить cyclic dependences          // TODO: обнаружить|решить cyclic dependences
         char *source=file_read(pool(), file);          char *source=file_read(pool(), file, fail_on_read_problem);
         if(!source)          if(!source)
                 THROW(0,0,                  return base_class;
                         0,  
                         "use: can not read '%s' file", file);          return use_buf(source, file, aclass, name, base_class);
   }
   
         VClass& vclass=COMPILE(source, name, file);  VClass *Request::use_buf(
                                                     const char *source, const char *file,
                                                     VClass *aclass, const String *name, 
                                                     VClass *base_class) {
           // compile loaded class
           VClass& cclass=COMPILE(source, aclass, name, base_class, file);
   
         // locate and execute possible @auto[] static method          // locate and execute possible @auto[] static method
         String name_auto(pool());          execute_static_method(cclass, *auto_method_name, false /*no result needed*/);
         name_auto.APPEND_CONST(AUTO_METHOD_NAME);          return &cclass;
         execute_static(vclass, name_auto, false);  
 }  }
   
 char *Request::execute_MAIN() {  char *Request::execute_MAIN() {
         // locate class with @main & it's code          // locate class with @main[] & execute it
         String name_main(pool());  
         name_main.APPEND_CONST(MAIN_METHOD_NAME);  
   
         // looking for latest known @main  
         for(int i=classes_array().size(); --i>=0;) {          for(int i=classes_array().size(); --i>=0;) {
                 VClass *vclass=static_cast<VClass *>(classes_array().get(i));                  VClass *vclass=static_cast<VClass *>(classes_array().get(i));
                 char *result=execute_static(*vclass, name_main, true);                  char *result=execute_static_method(*vclass, *main_method_name, true /*result needed*/);
                 if(result)                  if(result)
                         return result;                          return result;
         }          }
Line 100  char *Request::execute_MAIN() { Line 144  char *Request::execute_MAIN() {
                 "'"MAIN_METHOD_NAME"' method not found");                  "'"MAIN_METHOD_NAME"' method not found");
         return 0;          return 0;
 }  }
   
   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=static_cast<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=static_cast<char *>(malloc(strlen(document_root)+strlen(name)+1));
                   strcpy(result, document_root);
                   strcat(result, name);
                   return result;
           } else 
                   return relative(page_filespec, name);
   }
Removed from v.1.4  
changed lines
  Added in v.1.20

E-mail: