C++ WrapperStr::length方法代码示例

static WrapperStr root_relative_if_possible(WrapperStr p)
{
    unsigned rln = RootCDir.length();

    return ((p.length() >= rln) && (p.left(rln) == RootCDir))
           ? p.mid(rln)
           : p;
}

static void manage_decorators(QTextStream & f, const WrapperStr & decorators,
                              QString indent, BooL & indent_needed)
{
    if (! decorators.isEmpty()) {
        int index = 0;
        int index2;

        while ((index2 = decorators.find("\n", index)) != -1) {
            if (indent_needed)
                f << indent;
            else
                indent_needed = TRUE;

            f << decorators.mid(index, index2 + 1 - index);
            index = index2 + 1;
        }

        if (index != (int) decorators.length()) {
            if (indent_needed) {
                f << indent;
                indent_needed = FALSE;
            }

            f << decorators.mid(index);
        }
    }
}

void UmlItem::replace_alias(WrapperStr & s)
{
    int index = 0;

    while ((index = s.find("@{", index)) != -1) {
        int index2 = s.find('}', index + 2);

        if (index2 == -1)
            return;

        UmlBaseItem * obj = this;
        WrapperStr key = s.mid(index + 2, index2 - index - 2);
        WrapperStr value;

        for (;;) {
            if (obj->propertyValue(key, value)) {
                s.replace(index, index2 - index + 1, value);
                index += value.length();
                break;
            }
            else if ((obj = obj->parent()) == 0) {
                index = index2 + 1;
                break;
            }
        }
    }
}

static WrapperStr force_final_slash(WrapperStr p)
{
    int ln = p.length();

    if (ln < 2)
        return p;

    return (p[ln - 1] != '/')
           ? WrapperStr(p + '/')
           : p;
}

void UmlItem::importExtension(FileIn & in, Token & token, UmlItem * where)
{
    if (! token.closed()) {
        WrapperStr s = token.valueOf("extender");

        if (s.isNull())
            s = token.valueOf("xmi:extender");

        if (s == "Bouml") {
            WrapperStr k = token.what();
            const char * kstr = k;

            while (in.read(), !token.close(kstr)) {
                s = token.what();

                if (s == "taggedvalue")
                    // is closed
                    where->set_PropertyValue(token.valueOf("tag"), token.valueOf("value"));
                else if (s == "stereotype")
                    where->set_Stereotype(token.valueOf("name"));

                if (! token.closed())
                    in.finish(token.what());
            }
        }
        else if (s == "Visual Paradigm for UML") {
            WrapperStr k = token.what();
            const char * kstr = k;

            while (in.read(), !token.close(kstr)) {
                s = token.what();

                if (s == "appliedstereotype") {
                    s = token.valueOf("xmi:value");

                    if (s.right(3) == "_id") {
                        s = s.mid(s.find("_") + 1);
                        s = s.left(s.length() - 3).lower();
                    }

                    where->set_Stereotype(s);
                }

                if (! token.closed())
                    in.finish(token.what());
            }
        }
        else
            in.finish(token.what());
    }
}

void UmlClass::write(QTextStream & f, const UmlTypeSpec & t,
                     bool with_formals, BooL * is_template)
{
    if (t.type != 0)
        t.type->write(f, with_formals, is_template);
    else {
        WrapperStr s = CppSettings::type(t.explicit_type);

        f << s;

        if (is_template != 0)
            *is_template = (!s.isEmpty() && (s.at(s.length() - 1) == QString('>')));
    }

}

WrapperStr UmlItem::legalName(WrapperStr s)
{
    unsigned index;
    unsigned n = s.length();

    for (index = 0; index != n; index += 1) {
        char c = s.operator QString().toLocal8Bit()[index];

        if (!(((c >= 'a') && (c <= 'z')) ||
              ((c >= 'A') && (c <= 'Z')) ||
              ((c >= '0') && (c <= '9')) ||
              (c == '_')))
            s.replace(index, 1, "_");
    }

    return s;
}

WrapperStr UmlItem::legalName(WrapperStr s)
{
    unsigned index;
    unsigned n = s.length();

    for (index = 0; index != n; index += 1) {
        char c = s.at(index);

        if (!(((c >= 'a') && (c <= 'z')) ||
              ((c >= 'A') && (c <= 'Z')) ||
              ((c >= '0') && (c <= '9')) ||
              (c == '_')))
            s.replace(index, 1, "_");
    }

    return s;
}

bool UmlClass::is_itself(WrapperStr t)
{
    // class is a template class and t is x<...> where x is the class,
    // t is normalized
    // return true if t is the class with its formals
    int index = t.find('<');

    t = t.mid(index + 1, t.length() - index - 2);

    QList<UmlFormalParameter> l = formals();
    QList<UmlFormalParameter>::ConstIterator it = l.begin();
    WrapperStr t2 = (*it).name();

    while ((++it) != l.end())
        t2 += ',' + (*it).name();

    return (t == t2);
}

// Between template < and > I suppose that a type is not included
// because I cannot know how the type is used and I do not want to
// produce circular #include
bool UmlClassMember::compute_dependency(Q3PtrList<CppRefType> & dependencies,
                                        WrapperStr decl, const UmlTypeSpec & t,
                                        bool force_incl)
{
    remove_comments(decl);
    remove_preprocessor(decl);
    remove_arrays(decl);

    int template_level = 0;
    bool have_type = FALSE;
    const char * p = decl;
    const char * dontsubstituteuntil = 0;

    for (;;) {
        UmlTypeSpec ts;
        char c;
        bool dontsearchend = FALSE;

        // search word beginning
        while ((c = *p) != 0) {
            if ((c == '_') ||
                ((c >= 'a') && (c <= 'z')) ||
                ((c >= 'A') && (c <= 'Z')))
                break;
            else if (dontsubstituteuntil != 0) {
                if (p >= dontsubstituteuntil)
                    dontsubstituteuntil = 0;
                else
                    p += 1;
            }
            else if (c == '=')
                // init, all is done
                return have_type;
            else if (!strncmp(p, "${type}", 7)) {
                p += 7;
                ts = t;

                if (ts.type != 0) {
                    dontsearchend = TRUE;
                    break;
                }
                else {
                    decl = ts.explicit_type + p;
                    p = decl;
                }
            }
            else {
                switch (c) {
                case '<':
                    template_level += 1;
                    break;

                case '>':
                    template_level -= 1;
                }

                p += 1;
            }
        }

        if (c == 0)
            return have_type;

        if (!dontsearchend) {
            // search word end
            const char * p2 = p;

            ts.type = 0;
            ts.explicit_type = p2;
            p += 1;

            while ((c = *p) != 0) {
                if ((c == '_') ||
                    (c == ':') ||
                    ((c >= 'a') && (c <= 'z')) ||
                    ((c >= 'A') && (c <= 'Z')) ||
                    ((c >= '0') && (c <= '9')))
                    p += 1;
                else {
                    ts.explicit_type.truncate(p - p2);
                    break;
                }
            }

//#warning NAMESPACE

            if (dontsubstituteuntil == 0) {
                WrapperStr subst = CppSettings::type(ts.explicit_type);

                if (subst != ts.explicit_type) {
                    decl = subst + ' ' + p;
                    p = decl;
                    dontsubstituteuntil = p + subst.length();
                    continue;
                }
            }
        }
//.........这里部分代码省略.........

bool Class::manage_member(WrapperStr s)
{
    WrapperStr comment = Lex::get_comments();
    WrapperStr description = Lex::get_description();
    int index;
    WrapperStr access = value_of(description, "@access", index);
    aVisibility visibility;

    if (access == "public")
        visibility = PublicVisibility;
    else if (access == "protected")
        visibility = ProtectedVisibility;
    else if (access == "private")
        visibility = PrivateVisibility;
    else
        visibility = PackageVisibility;

    if (visibility != PackageVisibility) {
        description.replace(index, access.length(), "${visibility}");

        access = value_of(comment, "@access", index);
        comment.replace(index, access.length(), "${visibility}");
    }

    bool m_staticp = FALSE;
    bool m_constp = FALSE;
    bool m_abstractp = FALSE;
    bool m_finalp = FALSE;

#ifdef TRACE
    QLOG_INFO() << "Class::manage_member(" << s << ")\n";
#endif

    for (;;) {
        if (s == "public")
            visibility = PublicVisibility;
        else if (s == "protected")
            visibility = ProtectedVisibility;
        else if (s == "private")
            visibility = PrivateVisibility;
        else if (s == "static")
            m_staticp = TRUE;
        else if (s == "const")
            m_constp = TRUE;
        else if (s == "final")
            m_finalp = TRUE;
        else if (s == "abstract")
            m_abstractp = TRUE;
        else if (s != "var")
            break;

        s = Lex::read_word();
    }

    if (s == "function") {
        // an operation
        return UmlOperation::new_one(this, visibility, m_finalp, m_abstractp,
                                     m_staticp, comment, description);
    }

    for (;;) {
        WrapperStr name = s;
        WrapperStr value;

        s = Lex::read_word();

#ifdef TRACE
        QLOG_INFO() << "define var '" << ((const char *) name) << "' followed by '" << ((const char *) s) << "'\n";
#endif

        if (s == "=") {
            // initialized variable, by pass value
            Lex::mark();
            UmlOperation::skip_expr(0);

            value = Lex::region();

#ifdef TRACE
            QLOG_INFO() << "value form is '" << ((const char *) value) << "'\n";
#endif
            char c = ((const char *) value)[value.length() - 1];

            if ((c == ';') || (c == ',')) {
                value.truncate(value.length() - 1); // remove ';' or ','
                s = (c == ';') ? ";" : ",";
            }
            else
                s = Lex::read_word();
        }

        if ((s != ";") && (s != ",")) {
            Lex::error_near(s);
            return FALSE;
        }

        if (!UmlAttribute::new_one(this, name, visibility, m_constp, m_staticp,
                                   value, comment, description))
            return FALSE;

        if (s == ";")
//.........这里部分代码省略.........

//.........这里部分代码省略.........
            typespec.explicit_type = type.simplifyWhiteSpace();

            int index = typespec.explicit_type.find("${name}");

            if (index != -1)
                typespec.explicit_type.remove(index, 7);
        }

        WrapperStr decl = CppSettings::attributeDecl("");
        int index = decl.find("${type}");

        if ((index == -1) ||
            (decl.find("${const}") == -1) ||
            (decl.find("${name}") == -1) ||
            (decl.find("${mutable}") == -1) ||
            (decl.find("${volatile}") == -1) ||
            (decl.find(';') == -1)) {
            decl = "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};";
            index = decl.find("${type}");
        }

        if (pfunc)
            decl.replace(index, decl.find("${name}") + 7 - index, type);
        else {
            if (!modifier.isEmpty())
                decl.insert(index + 7, (const char *)(WrapperStr(" ") + modifier));

            if (typeform != "${type}")
                decl.replace(index, 7, typeform);
            else if (typespec.type == 0) {
                WrapperStr t = typespec.explicit_type;
                int index2 = 0;

                if (!t.isEmpty() && (t.at(t.length() - 1) == ">") && ((index2 = t.find('<')) > 0))
                {
                    stereotype = t.left(index2);
                    typespec.explicit_type =
                        // may be a,b ...
                        t.mid(index2 + 1, t.length() - 2 - index2);
                    decl.replace(index, 7, "${stereotype}<${type}>");
                }
            }

            if (!array.isEmpty())
                decl.insert(decl.find("${name}") + 7, "${multiplicity}");

            if (!bitfield.isEmpty())
                decl.insert(decl.find(';'), (const char *)(WrapperStr(" : ") + bitfield));
        }

        if (typenamep) {
            int index = decl.find("${const}") + 8; // find cannot return -1
            int index2 = decl.find("${mutable}") + 10; // find cannot return -1
            int index3 = decl.find("${volatile}") + 11; // find cannot return -1

            if (index2 > index) index = index2;

            if (index3 > index) index = index3;

            decl.insert(index, "typename ");
        }

        if (!value.isEmpty() && ((index = decl.find("${value}")) != -1))
            decl.insert(index + 2,  "h_");

#ifdef ROUNDTRIP

// from a form 'generic<...C...> var' where C is a class
    bool UmlRelation::new_one(Class * container, const WrapperStr & name,
                              UmlClass * type, WrapperStr type_def,
                              WrapperStr genericname,
                              aVisibility visibility, bool staticp,
                              bool constp, bool transientp, bool volatilep,
                              const WrapperStr & array, const WrapperStr & value,
                              WrapperStr comment, WrapperStr description,
                              WrapperStr annotation
#ifdef ROUNDTRIP
                              , bool roundtrip, QList<UmlItem *> & expected_order
#endif
                             )
    {
#ifdef TRACE
        QLOG_INFO() << "RELATION '" << name << "' from '" << cl->Name() << "' to '" << type->Name()
                    << "' array '" << array << "'\n";
#endif

        if (
#ifdef REVERSE
            container->from_libp() &&
#endif
            (visibility == PrivateVisibility)) {
            Lex::finish_line();
            Lex::clear_comments();
            return TRUE;
        }

        WrapperStr st = JavaSettings::umlType(genericname);

        if (st.isEmpty())
            st = genericname;

        UmlClass * cl = container->get_uml();
        UmlRelation * rel;

#ifdef ROUNDTRIP
        bool created;

        if (!roundtrip ||
            ((rel = search_rel(container, name, type, st)) == 0)) {
#endif
            rel = UmlBaseRelation::create(aDirectionalAssociation, cl, type);

            if (rel == 0) {
                JavaCatWindow::trace(WrapperStr("<font face=helvetica><b>cannot add relation <i>")
                                     + name + "</i> in <i>" + cl->name() + "</i> to <i>"
                                     + type->name() + "</i></b></font><br>");
                return FALSE;
            }

#ifdef REVERSE
# ifndef ROUNDTRIP
            Statistic::one_relation_more();
# else

            if (roundtrip)
                container->set_updated();

            created = TRUE;
        }
        else
            created = FALSE;

# endif
#endif

            Lex::finish_line();

            comment = Lex::get_comments(comment);
            description = Lex::get_description(description);

            WrapperStr decl = JavaSettings::relationDecl(array);

            type_def.replace(0, genericname.length(), "${stereotype}");
            decl.replace(decl.find("${type}"), 7, type_def);


#ifdef ROUNDTRIP

            if (roundtrip && !created) {
                if (rel->visibility() != visibility) {
                    rel->set_Visibility(visibility);
                    container->set_updated();
                }

                if (decl.find("${description}") != -1) {
                    if (nequal(rel->description(), description)) {
                        rel->set_Description(description);
                        container->set_updated();
                    }
                }
                else if (nequal(rel->description(), Lex::simplify_comment(comment))) {
                    rel->set_Description(comment); // comment was set
                    container->set_updated();
                }

                if (rel->isReadOnly() != constp) {
                    rel->set_isReadOnly(constp);
//.........这里部分代码省略.........

WrapperStr UmlPackage::text_path(const WrapperStr & f)
{
    WrapperStr r = file_path(f);

    return r.left(r.length() - 1 - PythonSettings::sourceExtension().length());
}

//.........这里部分代码省略.........

            if (neq(at->multiplicity(), array)) {
                at->set_Multiplicity(array);
                container->set_updated();
            }

            WrapperStr v = at->defaultValue();

            if (!v.isEmpty() && (((const char *) v)[0] == '='))
                v = v.mid(1);

            if (nequal(v, value)) {
                at->set_DefaultValue(value);
                container->set_updated();
            }

            if (nequal(at->javaAnnotations(), annotation)) {
                at->set_JavaAnnotations(annotation);
                container->set_updated();
            }

            WrapperStr stereotype;
            bool force_ste = FALSE;

            if (cl->stereotype() == "enum") {
                stereotype = "attribute";
                force_ste = TRUE;
            }
            else if (typespec.type == 0) {
                WrapperStr t = typespec.explicit_type;
                int index2;

                if (!t.isEmpty() &&
                    (t.at(t.length() - 1) == ">") &&
                    ((index2 = t.find('<')) > 0)) {
                    stereotype = t.left(index2);
                    typespec.explicit_type =
                        // may be a,b ...
                        t.mid(index2 + 1, t.length() - 2 - index2);
                    decl.replace(index, 7, "${stereotype}<${type}>");
                    force_ste = TRUE;
                }
            }

            if (at->visibility() != visibility) {
                at->set_Visibility(visibility);
                container->set_updated();
            }

            if (neq(at->stereotype(), stereotype)) {
                WrapperStr jst;

                if (! at->stereotype().isEmpty())
                    jst = JavaSettings::relationAttributeStereotype(at->stereotype());

                if ((force_ste) ? (jst != stereotype) : (jst == "attribute")) {
                    at->set_Stereotype(stereotype);
                    container->set_updated();
                }
            }

            if (neq(at->javaDecl(), decl)) {
                at->set_JavaDecl(decl);
                container->set_updated();
            }