Return to core.C CVS log

Up to [parser3project] / parser3 / src / main

Annotation of parser3/src/main/core.C, revision 1.49

1.18      paf         1: /*
1.49    ! paf         2: $Id: core.C,v 1.48 2001/03/10 11:03:49 paf Exp $
1.18      paf         3: */
                      4: 
1.23      paf         5: #include "pa_request.h"
1.29      paf         6: #include "pa_wwrapper.h"
1.23      paf         7: #include "pa_common.h"
                      8: #include "pa_vclass.h"
                      9: 
                     10: #include <stdio.h>
1.48      paf        11: #include "classes/_root.h"
1.49    ! paf        12: #include "classes/_env.h"
1.46      paf        13: #include "classes/_string.h"
1.47      paf        14: #include "classes/_double.h"
                     15: #include "classes/_int.h"
1.23      paf        16: 
                     17: void core() {
1.25      paf        18:        Pool pool;
1.48      paf        19:        initialize_string_class(pool, *(string_class=new(pool) VClass(pool)));
                     20:        initialize_double_class(pool, *(double_class=new(pool) VClass(pool)));
                     21:        initialize_int_class(pool, *(int_class=new(pool) VClass(pool)));
1.24      paf        22:        Request request(pool);
                     23:        request.core();
1.23      paf        24: }
                     25: 
1.43      paf        26: Request::Request(Pool& apool) : Pooled(apool),
                     27:        stack(apool),
1.45      paf        28:        root_class(apool),
1.49    ! paf        29:        env_class(apool),
1.43      paf        30:        fclasses(apool),
1.48      paf        31:        fclasses_array(apool),
                     32:        lang(String::Untaint_lang::HTML_TYPO)
1.43      paf        33: {
1.49    ! paf        34:        // root class
1.48      paf        35:        initialize_root_class(pool(), root_class);
1.43      paf        36:        // adding root superclass, 
                     37:        //   parent of all classes, 
                     38:        //   operators holder
                     39:        String ROOT(pool()); ROOT.APPEND_CONST(ROOT_NAME);
1.45      paf        40:        classes().put(ROOT, &root_class);
1.49    ! paf        41: 
        !            42:        // env class
        !            43:        initialize_env_class(pool(), env_class);
        !            44:        String ENV(pool()); ENV.APPEND_CONST(ENV_NAME);
        !            45:        classes().put(ENV, &env_class);
1.43      paf        46: }
                     47: 
1.23      paf        48: void Request::core() {
1.24      paf        49:        TRY {
1.35      paf        50:                char *file="Y:\\parser3\\src\\test.p";
1.43      paf        51:                String RUN(pool()); RUN.APPEND_CONST(RUN_NAME);
1.35      paf        52:                use(file, &RUN);
                     53: 
                     54:                char *result=execute_MAIN();
1.34      paf        55:                printf("result-----------------\n%sEOF----------------\n", result);
1.24      paf        56:        } 
                     57:        CATCH(e) {
1.31      paf        58:                printf("\nERROR: ");
                     59:                const String *problem_source=e.problem_source();
                     60:                if(problem_source) {
                     61:                        const Origin& origin=problem_source->origin();
                     62:                        if(origin.file)
                     63:                                printf("%s(%d): ",
                     64:                                origin.file, 1+origin.line);
1.32      paf        65:                        printf("'%s' ", 
1.31      paf        66:                                problem_source->cstr());
                     67:                }
                     68:                printf("%s", e.comment());
1.23      paf        69:                const String *type=e.type();
                     70:                if(type) {
                     71:                        printf("  type: %s", type->cstr());
                     72:                        const String *code=e.code();
                     73:                        if(code)
                     74:                                printf(", code: %s", code->cstr());
                     75:                }
1.31      paf        76:                printf("\n");
1.23      paf        77:        }
1.24      paf        78:        END_CATCH
1.23      paf        79: }
                     80: 
1.43      paf        81: void Request::use(char *file, String *name) {
1.42      paf        82:        // TODO: обнаружить|решить cyclic dependences
1.23      paf        83:        char *source=file_read(pool(), file);
1.37      paf        84:        if(!source)
                     85:                THROW(0,0,
                     86:                        0,
                     87:                        "use: can not read '%s' file", file);
                     88: 
1.43      paf        89:        COMPILE(source, name, file);
                     90:        // TODO: запустить @STATIC[], если есть
                     91: 
                     92: //     if(alias)
                     93:                //classes().put(*alias, &vclass);
1.23      paf        94: }
                     95: 
1.35      paf        96: char *Request::execute_MAIN() {
                     97:        // locate class with @main & it's code
1.23      paf        98:        String name_main(pool());
                     99:        name_main.APPEND_CONST(MAIN_METHOD_NAME);
                    100: 
1.35      paf       101:        // looking for latest known @main
                    102:        for(int i=classes_array().size(); --i>=0;) {
                    103:                VClass *vclass=static_cast<VClass *>(classes_array().get(i));
                    104:                Value *main=vclass->get_element(name_main);
                    105:                if(main) { // found some 'main' element
                    106:                        Junction *junction=main->get_junction();
1.36      paf       107:                        if(junction) {// it even has junction!
                    108:                                const Method *method=junction->method;
                    109:                                if(method) { // and junction is method-junction! call it
                    110:                                        // initialize contexts
1.41      paf       111:                                        root=rcontext=self=vclass;
1.40      paf       112:                                        wcontext=NEW WWrapper(pool(), vclass, false /* not constructing */);
1.36      paf       113:                                        
                    114:                                        // execute!     
1.44      paf       115:                                        execute(*method->parser_code);
1.36      paf       116:                                        
                    117:                                        // return chars
                    118:                                        return wcontext->get_string()->cstr();
                    119:                                }
1.35      paf       120:                        }
                    121:                }
                    122:        }
                    123:        
                    124:        THROW(0,0,
                    125:                0, 
                    126:                "'"MAIN_METHOD_NAME"' method not found");
                    127:        return 0;
1.23      paf       128: }