Return to pa_value.C CVS log

Up to [parser3project] / parser3 / src / types

Annotation of parser3/src/types/pa_value.C, revision 1.26

1.1       paf         1: /** @file
                      2:        Parser: Value class.
                      3: 
1.26    ! misha       4:        Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
1.1       paf         5:        Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.2       paf         6: */
1.1       paf         7: 
1.26    ! misha       8: static const char * const IDENT_VALUE_C="$Date: 2008-09-04 09:35:56 $";
1.1       paf         9: 
                     10: #include "pa_value.h"
                     11: #include "pa_vstateless_class.h"
1.4       paf        12: #include "pa_vmethod_frame.h"
1.10      paf        13: #include "pa_vdate.h"
                     14: #include "pa_vobject.h"
                     15: 
                     16: // globals
                     17: 
                     18: const String name_name(NAME_NAME);
                     19: 
                     20: const String value_name(VALUE_NAME);
1.12      paf        21: const String expires_name(EXPIRES_NAME);
1.10      paf        22: const String content_type_name(CONTENT_TYPE_NAME);
                     23: 
                     24: // methods
                     25: 
                     26: VObject* Value::set_derived(VObject* /*aderived*/) { return 0; }
                     27: 
                     28: Junction* Value::get_junction() { return 0; }
                     29: 
1.11      paf        30: Value* Value::base_object() { return bark("is '%s', it has no base object"); }
1.10      paf        31: 
                     32: Value* Value::get_element(const String& /*aname*/, Value& /*aself*/, bool /*looking_up*/) {
1.11      paf        33:        return bark("is '%s', it has no elements");
1.10      paf        34: }
                     35: 
                     36: 
                     37: VFile* Value::as_vfile(String::Language /*lang*/, const Request_charsets* /*charsets*/) { 
1.11      paf        38:        bark("is '%s', it does not have file value"); return 0;
1.10      paf        39: }
1.1       paf        40: 
                     41: /// call this before invoking to ensure proper actual numbered params count
1.10      paf        42: void Method::check_actual_numbered_params(Value& self, 
                     43:                                          MethodParams* actual_numbered_params) const {
1.1       paf        44: 
1.10      paf        45:        int actual_count=actual_numbered_params?actual_numbered_params->count():0;
1.1       paf        46:        if(actual_count<min_numbered_params_count) // not proper count? bark
1.22      misha      47:                throw Exception(PARSER_RUNTIME,
1.10      paf        48:                        0,
1.1       paf        49:                        "native method of %s (%s) accepts minimum %d parameter(s) (%d present)", 
1.8       paf        50:                                self.get_class()->name_cstr(),
                     51:                                self.type(),
1.1       paf        52:                                min_numbered_params_count,
                     53:                                actual_count);
                     54: 
                     55: }
1.4       paf        56: 
1.10      paf        57: // attributed meaning
                     58: 
                     59: static String::C date_attribute(const VDate& vdate) {
                     60:        time_t when=vdate.get_time();
                     61:        struct tm *tms=gmtime(&when);
                     62:        if(!tms)
1.25      misha      63:                throw Exception(DATE_RANGE_EXCEPTION_TYPE,
1.10      paf        64:                        0,
1.15      paf        65:                        "bad time in attribute value (seconds from epoch=%u)", when);
1.24      misha      66:        return date_gmt_string(tms);
                     67: }
1.10      paf        68: 
                     69: static void append_attribute_meaning(String& result,
                     70:                                     Value& value, String::Language lang, bool forced) {
                     71:        if(const String* string=value.get_string())
                     72:                result.append(*string, lang, forced);
                     73:        else
                     74:                if(Value* vdate=value.as(VDATE_TYPE, false)) {
                     75:                        String::C attribute=date_attribute(static_cast<VDate&>(*vdate));
                     76: 
                     77:                        result.append_help_length(attribute.str, attribute.length, String::L_CLEAN);
                     78:                } else
1.22      misha      79:                        throw Exception(PARSER_RUNTIME,
1.10      paf        80:                                &result,
                     81:                                "trying to append here neither string nor date (%s)",
                     82:                                        value.type());
                     83: }
                     84: #ifndef DOXYGEN
                     85: struct Attributed_meaning_info {
                     86:        String* header; // header line being constructed
                     87:        String::Language lang; // language in which to append to that line
                     88:        bool forced; // do they force that lang?
1.23      misha      89:        bool allow_bool; // allow bool types during print attributes
1.10      paf        90: };
                     91: #endif
                     92: static void append_attribute_subattribute(HashStringValue::key_type akey, 
                     93:                                          HashStringValue::value_type avalue, 
                     94:                                          Attributed_meaning_info *info) {
                     95:        if(akey==VALUE_NAME)
                     96:                return;
                     97: 
                     98:        // ...; charset=windows1251
                     99:        *info->header << "; ";
                    100:        info->header->append(String(akey, String::L_TAINTED), info->lang, info->forced);
1.21      misha     101:        if(!info->allow_bool || !avalue->is_bool()){
                    102:                *info->header << "=";
                    103:                append_attribute_meaning(*info->header, *avalue, info->lang, info->forced);
                    104:        }
1.10      paf       105: }
                    106: const String& attributed_meaning_to_string(Value& meaning, 
1.21      misha     107:                                           String::Language lang, bool forced, bool allow_bool) {
1.10      paf       108:        String& result=*new String;
                    109:        if(HashStringValue *hash=meaning.get_hash()) {
                    110:                // $value(value) $subattribute(subattribute value)
                    111:                if(Value* value=hash->get(value_name))
                    112:                        append_attribute_meaning(result, *value, lang, forced);
                    113: 
1.21      misha     114:                Attributed_meaning_info attributed_meaning_info={&result, lang, false, allow_bool};
1.20      paf       115:                hash->for_each<Attributed_meaning_info*>(append_attribute_subattribute, &attributed_meaning_info);
1.10      paf       116:        } else // result value
                    117:                append_attribute_meaning(result, meaning, lang, forced);
                    118: 
                    119:        return result;
                    120: }