Return to pa_request.C CVS log

Up to [parser3project] / parser3 / src / main

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

1.1       paf         1: /*
1.4     ! paf         2: $Id: pa_request.C,v 1.3 2001/03/10 11:44:42 paf Exp $
1.1       paf         3: */
                      4: 
                      5: #include "pa_request.h"
1.3       paf         6: #include "pa_wwrapper.h"
                      7: #include "pa_common.h"
                      8: #include "pa_vclass.h"
                      9: #include "classes/_root.h"
                     10: #include "classes/_env.h"
                     11: 
                     12: #include <stdio.h>
                     13: 
                     14: Request::Request(Pool& apool) : Pooled(apool),
                     15:        stack(apool),
                     16:        root_class(apool),
                     17:        env_class(apool),
                     18:        fclasses(apool),
                     19:        fclasses_array(apool),
                     20:        lang(String::Untaint_lang::HTML_TYPO)
                     21: {
                     22:        // root class
                     23:        initialize_root_class(pool(), root_class);
                     24:        // adding root superclass, 
                     25:        //   parent of all classes, 
                     26:        //   operators holder
                     27:        String ROOT(pool()); ROOT.APPEND_CONST(ROOT_NAME);
                     28:        classes().put(ROOT, &root_class);
                     29: 
                     30:        // env class
                     31:        initialize_env_class(pool(), env_class);
                     32:        String ENV(pool()); ENV.APPEND_CONST(ENV_NAME);
                     33:        classes().put(ENV, &env_class);
                     34: }
1.1       paf        35: 
                     36: void Request::core() {
1.3       paf        37:        TRY {
                     38:                char *file="Y:\\parser3\\src\\test.p";
                     39:                String RUN(pool()); RUN.APPEND_CONST(RUN_NAME);
                     40:                use(file, &RUN);
                     41: 
                     42:                char *result=execute_MAIN();
                     43:                printf("result-----------------\n%sEOF----------------\n", result);
                     44:        } 
                     45:        CATCH(e) {
                     46:                printf("\nERROR: ");
                     47:                const String *problem_source=e.problem_source();
                     48:                if(problem_source) {
                     49:                        const Origin& origin=problem_source->origin();
                     50:                        if(origin.file)
                     51:                                printf("%s(%d): ",
                     52:                                origin.file, 1+origin.line);
                     53:                        printf("'%s' ", 
                     54:                                problem_source->cstr());
                     55:                }
                     56:                printf("%s", e.comment());
1.1       paf        57:                const String *type=e.type();
                     58:                if(type) {
                     59:                        printf("  type: %s", type->cstr());
                     60:                        const String *code=e.code();
                     61:                        if(code)
                     62:                                printf(", code: %s", code->cstr());
                     63:                }
1.3       paf        64:                printf("\n");
1.1       paf        65:        }
1.3       paf        66:        END_CATCH
1.1       paf        67: }
                     68: 
1.3       paf        69: void Request::use(char *file, String *name) {
                     70:        // TODO: обнаружить|решить cyclic dependences
1.1       paf        71:        char *source=file_read(pool(), file);
1.3       paf        72:        if(!source)
                     73:                THROW(0,0,
                     74:                        0,
                     75:                        "use: can not read '%s' file", file);
                     76: 
1.4     ! paf        77:        VClass& vclass=COMPILE(source, name, file);
1.1       paf        78: 
1.4     ! paf        79:        // locate and execute possible @auto[] static method
        !            80:        String name_auto(pool());
        !            81:        name_auto.APPEND_CONST(AUTO_METHOD_NAME);
        !            82:        execute_static(vclass, name_auto, false);
1.1       paf        83: }
                     84: 
1.3       paf        85: char *Request::execute_MAIN() {
                     86:        // locate class with @main & it's code
                     87:        String name_main(pool());
1.1       paf        88:        name_main.APPEND_CONST(MAIN_METHOD_NAME);
                     89: 
1.3       paf        90:        // looking for latest known @main
                     91:        for(int i=classes_array().size(); --i>=0;) {
                     92:                VClass *vclass=static_cast<VClass *>(classes_array().get(i));
1.4     ! paf        93:                char *result=execute_static(*vclass, name_main, true);
        !            94:                if(result)
        !            95:                        return result;
1.3       paf        96:        }
                     97:        
                     98:        THROW(0,0,
                     99:                0, 
                    100:                "'"MAIN_METHOD_NAME"' method not found");
                    101:        return 0;
1.1       paf       102: }