LCOV - app.info - js/src/jsstrinlines.h

LCOV - code coverage report
| Current view: | directory - js/src - jsstrinlines.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 47 | 46 | 97.9 %
| Date: | 2012-06-02 | Functions: | 12 | 12 | 100.0 %

           1                 : /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
           2                 :  *
           3                 :  * ***** BEGIN LICENSE BLOCK *****
           4                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           5                 :  *
           6                 :  * The contents of this file are subject to the Mozilla Public License Version
           7                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           8                 :  * the License. You may obtain a copy of the License at
           9                 :  * http://www.mozilla.org/MPL/
          10                 :  *
          11                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          12                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          13                 :  * for the specific language governing rights and limitations under the
          14                 :  * License.
          15                 :  *
          16                 :  * The Original Code is Mozilla Communicator client code, released
          17                 :  * March 31, 1998.
          18                 :  *
          19                 :  * The Initial Developer of the Original Code is
          20                 :  * Netscape Communications Corporation.
          21                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          22                 :  * the Initial Developer. All Rights Reserved.
          23                 :  *
          24                 :  * Contributor(s):
          25                 :  *
          26                 :  * Alternatively, the contents of this file may be used under the terms of
          27                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          28                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          30                 :  * of those above. If you wish to allow use of your version of this file only
          31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          32                 :  * use your version of this file under the terms of the MPL, indicate your
          33                 :  * decision by deleting the provisions above and replace them with the notice
          34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          35                 :  * the provisions above, a recipient may use your version of this file under
          36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          37                 :  *
          38                 :  * ***** END LICENSE BLOCK ***** */
          39                 :
          40                 : #ifndef jsstrinlines_h___
          41                 : #define jsstrinlines_h___
          42                 :
          43                 : #include "mozilla/Attributes.h"
          44                 :
          45                 : #include "jsatom.h"
          46                 : #include "jsstr.h"
          47                 :
          48                 : #include "jscntxtinlines.h"
          49                 : #include "jsgcinlines.h"
          50                 : #include "vm/String-inl.h"
          51                 :
          52                 : namespace js {
          53                 :
          54                 : class RopeBuilder {
          55                 :     JSContext *cx;
          56                 :     JSString *res;
          57                 :
          58                 :     RopeBuilder(const RopeBuilder &other) MOZ_DELETE;
          59                 :     void operator=(const RopeBuilder &other) MOZ_DELETE;
          60                 :
          61                 :   public:
          62           13398 :     RopeBuilder(JSContext *cx)
          63           13398 :       : cx(cx), res(cx->runtime->emptyString)
          64           13398 :     {}
          65                 :
          66           40194 :     inline bool append(JSString *str) {
          67           40194 :         res = js_ConcatStrings(cx, res, str);
          68           40194 :         return !!res;
          69                 :     }
          70                 :
          71           13398 :     inline JSString *result() {
          72           13398 :         return res;
          73                 :     }
          74                 : };
          75                 :
          76                 : class StringSegmentRange
          77          456567 : {
          78                 :     /*
          79                 :      * If malloc() shows up in any profiles from this vector, we can add a new
          80                 :      * StackAllocPolicy which stashes a reusable freed-at-gc buffer in the cx.
          81                 :      */
          82                 :     Vector<JSString *, 32> stack;
          83                 :     JSLinearString *cur;
          84                 :
          85        36315564 :     bool settle(JSString *str) {
          86       108523776 :         while (str->isRope()) {
          87        35892648 :             JSRope &rope = str->asRope();
          88        35892648 :             if (!stack.append(rope.rightChild()))
          89               0 :                 return false;
          90        35892648 :             str = rope.leftChild();
          91                 :         }
          92        36315564 :         cur = &str->asLinear();
          93        36315564 :         return true;
          94                 :     }
          95                 :
          96                 :   public:
          97          456567 :     StringSegmentRange(JSContext *cx)
          98          456567 :       : stack(cx), cur(NULL)
          99          456567 :     {}
         100                 :
         101          456567 :     JS_WARN_UNUSED_RESULT bool init(JSString *str) {
         102          456567 :         JS_ASSERT(stack.empty());
         103          456567 :         return settle(str);
         104                 :     }
         105                 :
         106        73041297 :     bool empty() const {
         107        73041297 :         return cur == NULL;
         108                 :     }
         109                 :
         110        36292365 :     JSLinearString *front() const {
         111        36292365 :         JS_ASSERT(!cur->isRope());
         112        36292365 :         return cur;
         113                 :     }
         114                 :
         115        36292365 :     JS_WARN_UNUSED_RESULT bool popFront() {
         116        36292365 :         JS_ASSERT(!empty());
         117        36292365 :         if (stack.empty()) {
         118          433368 :             cur = NULL;
         119          433368 :             return true;
         120                 :         }
         121        35858997 :         return settle(stack.popCopy());
         122                 :     }
         123                 : };
         124                 :
         125                 : /*
         126                 :  * Return s advanced past any Unicode white space characters.
         127                 :  */
         128                 : static inline const jschar *
         129         2013370 : SkipSpace(const jschar *s, const jschar *end)
         130                 : {
         131         2013370 :     JS_ASSERT(s <= end);
         132                 :
         133         4026884 :     while (s < end && unicode::IsSpace(*s))
         134             144 :         s++;
         135                 :
         136         2013370 :     return s;
         137                 : }
         138                 :
         139                 : /*
         140                 :  * Return less than, equal to, or greater than zero depending on whether
         141                 :  * s1 is less than, equal to, or greater than s2.
         142                 :  */
         143                 : inline bool
         144          341792 : CompareChars(const jschar *s1, size_t l1, const jschar *s2, size_t l2, int32_t *result)
         145                 : {
         146          341792 :     size_t n = JS_MIN(l1, l2);
         147          655404 :     for (size_t i = 0; i < n; i++) {
         148          644636 :         if (int32_t cmp = s1[i] - s2[i]) {
         149          331024 :             *result = cmp;
         150          331024 :             return true;
         151                 :         }
         152                 :     }
         153                 :
         154           10768 :     *result = (int32_t)(l1 - l2);
         155           10768 :     return true;
         156                 : }
         157                 :
         158                 : }  /* namespace js */
         159                 :
         160                 : #endif /* jsstrinlines_h___ */

Generated by: LCOV version 1.7