Return to core.C CVS log

Up to [parser3project] / parser3 / src / main

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

1.18      paf         1: /*
1.34    ! paf         2: $Id: core.C,v 1.33 2001/02/24 13:21:59 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>
                     11: 
                     12: void core() {
1.25      paf        13:        Pool pool;
1.24      paf        14:        Request request(pool);
                     15:        request.core();
1.23      paf        16: }
                     17: 
                     18: void Request::core() {
1.24      paf        19:        TRY {
1.23      paf        20:                String name_RUN(pool()); name_RUN.APPEND_CONST("RUN");
                     21:                char *result=execute_MAIN(construct_class(name_RUN, load_and_compile_RUN()));
1.34    ! paf        22:                printf("result-----------------\n%sEOF----------------\n", result);
1.24      paf        23:        } 
                     24:        CATCH(e) {
1.31      paf        25:                printf("\nERROR: ");
                     26:                const String *problem_source=e.problem_source();
                     27:                if(problem_source) {
                     28:                        const Origin& origin=problem_source->origin();
                     29:                        if(origin.file)
                     30:                                printf("%s(%d): ",
                     31:                                origin.file, 1+origin.line);
1.32      paf        32:                        printf("'%s' ", 
1.31      paf        33:                                problem_source->cstr());
                     34:                }
                     35:                printf("%s", e.comment());
1.23      paf        36:                const String *type=e.type();
                     37:                if(type) {
                     38:                        printf("  type: %s", type->cstr());
                     39:                        const String *code=e.code();
                     40:                        if(code)
                     41:                                printf(", code: %s", code->cstr());
                     42:                }
1.31      paf        43:                printf("\n");
1.23      paf        44:        }
1.24      paf        45:        END_CATCH
1.23      paf        46: }
                     47: 
                     48: Array& Request::load_and_compile_RUN() {
                     49:        char *file="Y:\\parser3\\src\\test.p";
                     50:        char *source=file_read(pool(), file);
                     51:        Array& compiled_methods=COMPILE(source, file);
                     52:        return compiled_methods;
                     53: }
                     54: 
                     55: VClass *Request::construct_class(String& name, Array& compiled_methods) {
                     56:        // create new 'name' vclass, add it to request's classes
                     57:        Array immediate_parents(pool());
                     58:        // TODO: immediate_parents=@PARENTS
                     59: 
1.33      paf        60:        VClass *result=NEW VClass(pool(), immediate_parents);
1.28      paf        61:        result->set_name(name);
1.23      paf        62:        classes().put(name, result);
                     63:                
                     64:        for(int i=0; i<compiled_methods.size(); i++) {
1.26      paf        65:                // TODO: filter out @PARENTS & @CLASS & ?co?
1.23      paf        66:                Method &method=*static_cast<Method *>(compiled_methods.quick_get(i));
                     67:                result->add_method(method.name, method);
                     68:        }
                     69: 
                     70:        return result;
                     71: }
                     72: 
                     73: char *Request::execute_MAIN(VClass *class_RUN) {
                     74:        // initialize contexts
1.32      paf        75:        self=root=rcontext=class_RUN;
1.29      paf        76:        wcontext=NEW WWrapper(pool(), class_RUN);
1.23      paf        77: 
                     78:        // locate @main code
                     79:        String name_main(pool());
                     80:        name_main.APPEND_CONST(MAIN_METHOD_NAME);
                     81: 
1.30      paf        82:        Value *value_main=class_RUN->get_element(name_main);
                     83:        if(!value_main)
                     84:                THROW(0,0,
1.33      paf        85:                        class_RUN->name(), "class does not contain method '"MAIN_METHOD_NAME"'");
1.30      paf        86: 
                     87:        Junction *junction_main=value_main->get_junction();
                     88:        const Method *method_main=junction_main->method;
                     89: 
1.23      paf        90:        if(!method_main)
1.24      paf        91:                THROW(0,0,
1.33      paf        92:                        class_RUN->name(), 
                     93:                        "class does contain '"MAIN_METHOD_NAME"' but it is not a method");
1.23      paf        94: 
                     95:        // execute!     
                     96:        execute(method_main->code);
                     97: 
                     98:        // return chars
                     99:        return wcontext->get_string()->cstr();
                    100: }