Return to pa_request.C CVS log

Up to [parser3project] / parser3 / src / main

Annotation of parser3/src/main/pa_request.C, revision 1.10

1.1       paf         1: /*
1.9       paf         2:        Parser
                      3:        Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
                      4:        Author: Alexander Petrosyan <paf@design.ru>
                      5: 
1.10    ! paf         6:        $Id: pa_request.C,v 1.9 2001/03/10 16:34:39 paf Exp $
1.1       paf         7: */
                      8: 
                      9: #include "pa_request.h"
1.3       paf        10: #include "pa_wwrapper.h"
                     11: #include "pa_common.h"
                     12: #include "pa_vclass.h"
                     13: #include "classes/_root.h"
                     14: #include "classes/_env.h"
1.6       paf        15: #include "core.h"
1.3       paf        16: 
                     17: #include <stdio.h>
                     18: 
                     19: Request::Request(Pool& apool) : Pooled(apool),
                     20:        stack(apool),
                     21:        root_class(apool),
                     22:        env_class(apool),
                     23:        fclasses(apool),
                     24:        fclasses_array(apool),
                     25:        lang(String::Untaint_lang::HTML_TYPO)
                     26: {
                     27:        // root class
                     28:        initialize_root_class(pool(), root_class);
                     29:        // adding root superclass, 
                     30:        //   parent of all classes, 
                     31:        //   operators holder
1.6       paf        32:        classes().put(*root_class_name, &root_class);
1.3       paf        33: 
                     34:        // env class
                     35:        initialize_env_class(pool(), env_class);
1.6       paf        36:        classes().put(*env_class_name, &env_class);
1.3       paf        37: }
1.1       paf        38: 
                     39: void Request::core() {
1.3       paf        40:        TRY {
1.7       paf        41:                // loading system auto.p
                     42:                char *sys_auto_file="C:\\temp\\auto.p";
1.10    ! paf        43:                VClass *auto_class=use(
1.7       paf        44:                        sys_auto_file, 
1.10    ! paf        45:                        run_class_name, 0, 
1.7       paf        46:                        false/*ignore possible error*/);
1.8       paf        47: 
                     48:                // TODO: использовать AUTO:limits здесь, пока их не сломали враги
1.7       paf        49: 
                     50:                // TODO: load site auto.p files, all assigned bases from upper dir
                     51:                char *site_auto_file="Y:\\parser3\\src\\auto.p";
1.10    ! paf        52:                auto_class=use(
1.7       paf        53:                        site_auto_file, 
1.10    ! paf        54:                        run_class_name, auto_class, 
1.7       paf        55:                        false/*ignore possible error*/);
                     56: 
                     57:                // there must be some auto.p
1.10    ! paf        58:                if(!auto_class)
1.7       paf        59:                        THROW(0,0,
                     60:                                0,
                     61:                                "'auto.p' not found");
1.5       paf        62: 
1.7       paf        63:                // compiling requested file
1.5       paf        64:                char *test_file="Y:\\parser3\\src\\test.p";
1.10    ! paf        65:                use(test_file, run_class_name, auto_class);
1.3       paf        66: 
1.7       paf        67:                // executing some @main[]
1.3       paf        68:                char *result=execute_MAIN();
                     69:                printf("result-----------------\n%sEOF----------------\n", result);
                     70:        } 
                     71:        CATCH(e) {
                     72:                printf("\nERROR: ");
                     73:                const String *problem_source=e.problem_source();
                     74:                if(problem_source) {
                     75:                        const Origin& origin=problem_source->origin();
                     76:                        if(origin.file)
                     77:                                printf("%s(%d): ",
                     78:                                origin.file, 1+origin.line);
                     79:                        printf("'%s' ", 
                     80:                                problem_source->cstr());
                     81:                }
                     82:                printf("%s", e.comment());
1.1       paf        83:                const String *type=e.type();
                     84:                if(type) {
                     85:                        printf("  type: %s", type->cstr());
                     86:                        const String *code=e.code();
                     87:                        if(code)
                     88:                                printf(", code: %s", code->cstr());
                     89:                }
1.3       paf        90:                printf("\n");
1.1       paf        91:        }
1.3       paf        92:        END_CATCH
1.1       paf        93: }
                     94: 
1.7       paf        95: VClass *Request::use(char *file, String *name, VClass *base_class, bool fail_on_read_problem) {
1.3       paf        96:        // TODO: обнаружить|решить cyclic dependences
1.5       paf        97:        char *source=file_read(pool(), file, fail_on_read_problem);
1.3       paf        98:        if(!source)
1.5       paf        99:                return 0;
1.3       paf       100: 
1.5       paf       101:        // compile loaded class
1.7       paf       102:        VClass& vclass=COMPILE(source, name, base_class, file);
1.1       paf       103: 
1.4       paf       104:        // locate and execute possible @auto[] static method
1.5       paf       105:        execute_static_method(vclass, *auto_method_name, false /*no result needed*/);
                    106:        return &vclass;
1.1       paf       107: }
                    108: 
1.3       paf       109: char *Request::execute_MAIN() {
1.5       paf       110:        // locate class with @main[] & execute it
1.3       paf       111:        for(int i=classes_array().size(); --i>=0;) {
                    112:                VClass *vclass=static_cast<VClass *>(classes_array().get(i));
1.5       paf       113:                char *result=execute_static_method(*vclass, *main_method_name, true /*result needed*/);
1.4       paf       114:                if(result)
                    115:                        return result;
1.3       paf       116:        }
                    117:        
                    118:        THROW(0,0,
                    119:                0, 
                    120:                "'"MAIN_METHOD_NAME"' method not found");
                    121:        return 0;
1.1       paf       122: }