LCOV - app.info - objdir/dist/include/nsToken.h

LCOV - code coverage report
| Current view: | directory - objdir/dist/include - nsToken.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 40 | 29 | 72.5 %
| Date: | 2012-06-02 | Functions: | 16 | 9 | 56.2 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is mozilla.org code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *
          24                 :  * Alternatively, the contents of this file may be used under the terms of
          25                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          26                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          28                 :  * of those above. If you wish to allow use of your version of this file only
          29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          30                 :  * use your version of this file under the terms of the MPL, indicate your
          31                 :  * decision by deleting the provisions above and replace them with the notice
          32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          33                 :  * the provisions above, a recipient may use your version of this file under
          34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          35                 :  *
          36                 :  * ***** END LICENSE BLOCK ***** */
          37                 :
          38                 :
          39                 : /**
          40                 :  * MODULE NOTES:
          41                 :  * @update  gess 4/1/98
          42                 :  *
          43                 :  * This class is defines the basic notion of a token
          44                 :  * within our system. All other tokens are derived from
          45                 :  * this one. It offers a few basic interfaces, but the
          46                 :  * most important is consume(). The consume() method gets
          47                 :  * called during the tokenization process when an instance
          48                 :  * of that particular token type gets detected in the
          49                 :  * input stream.
          50                 :  *
          51                 :  * CToken objects that are allocated from the heap _must_ be allocated
          52                 :  * using the nsTokenAllocator: the nsTokenAllocator object uses an
          53                 :  * arena to manage the tokens.
          54                 :  *
          55                 :  * The nsTokenAllocator object's arena implementation requires
          56                 :  * object size at destruction time to properly recycle the object;
          57                 :  * therefore, CToken::operator delete() is not public. Instead,
          58                 :  * heap-allocated tokens should be destroyed using the static
          59                 :  * Destroy() method, which accepts a token and the arena from which
          60                 :  * the token was allocated.
          61                 :  *
          62                 :  * Leaf classes (that are actually instantiated from the heap) must
          63                 :  * implement the SizeOf() method, which Destroy() uses to determine
          64                 :  * the size of the token in order to properly recycle it.
          65                 :  */
          66                 :
          67                 :
          68                 : #ifndef CTOKEN__
          69                 : #define CTOKEN__
          70                 :
          71                 : #include "prtypes.h"
          72                 : #include "nsString.h"
          73                 : #include "nsError.h"
          74                 : #include "nsFixedSizeAllocator.h"
          75                 :
          76                 : #define NS_HTMLTOKENS_NOT_AN_ENTITY \
          77                 :   NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_HTMLPARSER,2000)
          78                 :
          79                 : class nsScanner;
          80                 : class nsTokenAllocator;
          81                 :
          82                 : enum eContainerInfo {
          83                 :   eWellFormed,
          84                 :   eMalformed,
          85                 :   eFormUnknown
          86                 : };
          87                 :
          88                 : /**
          89                 :  * Implement the SizeOf() method; leaf classes derived from CToken
          90                 :  * must declare this.
          91                 :  */
          92                 : #define CTOKEN_IMPL_SIZEOF                                \
          93                 : protected:                                                \
          94                 :   virtual size_t SizeOf() const { return sizeof(*this); } \
          95                 : public:
          96                 :
          97                 : /**
          98                 :  *  Token objects represent sequences of characters as they
          99                 :  *  are consumed from the input stream (URL). While they're
         100                 :  *  pretty general in nature, we use subclasses (found in
         101                 :  *  nsHTMLTokens.h) to define <start>, </end>, <text>,
         102                 :  *  <comment>, <&entity>, <newline>, and <whitespace> tokens.
         103                 :  *
         104                 :  *  @update  gess 3/25/98
         105                 :  */
         106                 : class CToken {
         107                 :   public:
         108                 :
         109                 :     enum  eTokenOrigin {eSource,eResidualStyle};
         110                 :
         111                 :   protected:
         112                 :
         113                 :     // nsTokenAllocator should be the only class that tries to
         114                 :     // allocate tokens from the heap.
         115                 :     friend class nsTokenAllocator;
         116                 :
         117                 :     /**
         118                 :      *
         119                 :      * @update  harishd 08/01/00
         120                 :      * @param   aSize    -
         121                 :      * @param   aArena   - Allocate memory from this pool.
         122                 :      */
         123            3093 :     static void * operator new (size_t aSize,nsFixedSizeAllocator& anArena) CPP_THROW_NEW
         124                 :     {
         125            3093 :       return anArena.Alloc(aSize);
         126                 :     }
         127                 :
         128                 :     /**
         129                 :      * Hide operator delete; clients should use Destroy() instead.
         130                 :      */
         131               0 :     static void operator delete (void*,size_t) {}
         132                 :
         133                 :   protected:
         134                 :     /**
         135                 :      * destructor
         136                 :      * @update  gess5/11/98
         137                 :      */
         138                 :     virtual ~CToken();
         139                 :
         140                 :   private:
         141                 :     /**
         142                 :      * Destroy a token.
         143                 :      */
         144            3093 :     static void Destroy(CToken* aToken,nsFixedSizeAllocator& aArenaPool)
         145                 :     {
         146            3093 :       size_t sz = aToken->SizeOf();
         147            3093 :       aToken->~CToken();
         148            3093 :       aArenaPool.Free(aToken, sz);
         149            3093 :     }
         150                 :
         151                 :   public:
         152                 :     /**
         153                 :      * Make a note on number of times you have been referenced
         154                 :      * @update  harishd 08/02/00
         155                 :      */
         156            1967 :     void AddRef() {
         157            1967 :       ++mUseCount;
         158            1967 :       NS_LOG_ADDREF(this, mUseCount, "CToken", sizeof(*this));
         159            1967 :     }
         160                 :
         161                 :     /**
         162                 :      * Free yourself if no one is holding you.
         163                 :      * @update  harishd 08/02/00
         164                 :      */
         165            5060 :     void Release(nsFixedSizeAllocator& aArenaPool) {
         166            5060 :       --mUseCount;
         167            5060 :       NS_LOG_RELEASE(this, mUseCount, "CToken");
         168            5060 :       if (mUseCount==0)
         169            3093 :         Destroy(this, aArenaPool);
         170            5060 :     }
         171                 :
         172                 :     /**
         173                 :      * Default constructor
         174                 :      * @update  gess7/21/98
         175                 :      */
         176                 :     CToken(PRInt32 aTag=0);
         177                 :
         178                 :     /**
         179                 :      * Retrieve string value of the token
         180                 :      * @update  gess5/11/98
         181                 :      * @return  reference to string containing string value
         182                 :      */
         183                 :     virtual const nsSubstring& GetStringValue(void) = 0;
         184                 :
         185                 :     /**
         186                 :      * Get string of full contents, suitable for debug dump.
         187                 :      * It should look exactly like the input source.
         188                 :      * @update  gess5/11/98
         189                 :      * @return  reference to string containing string value
         190                 :      */
         191                 :     virtual void GetSource(nsString& anOutputString);
         192                 :
         193                 :     /** @update harishd 03/23/00
         194                 :      *  @return  reference to string containing string value
         195                 :      */
         196                 :     virtual void AppendSourceTo(nsAString& anOutputString);
         197                 :
         198                 :     /**
         199                 :      * Sets the ordinal value of this token (not currently used)
         200                 :      * @update  gess5/11/98
         201                 :      * @param   value is the new ord value for this token
         202                 :      */
         203               0 :     void SetTypeID(PRInt32 aValue) {
         204               0 :       mTypeID = aValue;
         205               0 :     }
         206                 :
         207                 :     /**
         208                 :      * Getter which retrieves the current ordinal value for this token
         209                 :      * @update  gess5/11/98
         210                 :      * @return  current ordinal value
         211                 :      */
         212                 :     virtual PRInt32 GetTypeID(void);
         213                 :
         214                 :     /**
         215                 :      * Getter which retrieves the current attribute count for this token
         216                 :      * @update  gess5/11/98
         217                 :      * @return  current attribute count
         218                 :      */
         219                 :     virtual PRInt16 GetAttributeCount(void);
         220                 :
         221                 :     /**
         222                 :      * Causes token to consume data from given scanner.
         223                 :      * Note that behavior varies wildly between CToken subclasses.
         224                 :      * @update  gess5/11/98
         225                 :      * @param   aChar -- most recent char consumed
         226                 :      * @param   aScanner -- input source where token should get data
         227                 :      * @return  error code (0 means ok)
         228                 :      */
         229                 :     virtual nsresult Consume(PRUnichar aChar,nsScanner& aScanner,PRInt32 aMode);
         230                 :
         231                 :     /**
         232                 :      * Getter which retrieves type of token
         233                 :      * @update  gess5/11/98
         234                 :      * @return  int containing token type
         235                 :      */
         236                 :     virtual PRInt32 GetTokenType(void);
         237                 :
         238                 :     /**
         239                 :      * For tokens who care, this can tell us whether the token is
         240                 :      * well formed or not.
         241                 :      *
         242                 :      * @update  gess 8/30/00
         243                 :      * @return  false; subclasses MUST override if they care.
         244                 :      */
         245               0 :     virtual bool IsWellFormed(void) const {return false;}
         246                 :
         247               0 :     virtual bool IsEmpty(void) { return false; }
         248                 :
         249                 :     /**
         250                 :      * If aValue is TRUE then the token represents a short-hand tag
         251                 :      */
         252               0 :     virtual void SetEmpty(bool aValue) { return ; }
         253                 :
         254            3147 :     PRInt32 GetNewlineCount()
         255                 :     {
         256            3147 :       return mNewlineCount;
         257                 :     }
         258                 :
         259              54 :     void SetNewlineCount(PRInt32 aCount)
         260                 :     {
         261              54 :       mNewlineCount = aCount;
         262              54 :     }
         263                 :
         264               0 :     PRInt32 GetLineNumber()
         265                 :     {
         266               0 :       return mLineNumber;
         267                 :     }
         268                 :
         269            2415 :     void SetLineNumber(PRInt32 aLineNumber)
         270                 :     {
         271            2415 :       mLineNumber = mLineNumber == 0 ? aLineNumber : mLineNumber;
         272            2415 :     }
         273                 :
         274              25 :     void SetInError(bool aInError)
         275                 :     {
         276              25 :       mInError = aInError;
         277              25 :     }
         278                 :
         279               0 :     bool IsInError()
         280                 :     {
         281               0 :       return mInError;
         282                 :     }
         283                 :
         284             237 :     void SetAttributeCount(PRInt16 aValue) {  mAttrCount = aValue; }
         285                 :
         286                 :     /**
         287                 :      * perform self test.
         288                 :      * @update  gess5/11/98
         289                 :      */
         290                 :     virtual void SelfTest(void);
         291                 :
         292                 :     static int GetTokenCount();
         293                 :
         294                 :
         295                 :
         296                 : protected:
         297                 :     /**
         298                 :      * Returns the size of the token object.
         299                 :      */
         300                 :     virtual size_t SizeOf() const = 0;
         301                 :
         302                 :     PRInt32 mTypeID;
         303                 :     PRInt32 mUseCount;
         304                 :     PRInt32 mNewlineCount;
         305                 :     PRUint32 mLineNumber : 31;
         306                 :     PRUint32 mInError : 1;
         307                 :     PRInt16 mAttrCount;
         308                 : };
         309                 :
         310                 :
         311                 :
         312                 : #endif
         313                 :
         314                 :

Generated by: LCOV version 1.7