//

//  rbbirb.h

//

//  Copyright (C) 2002-2004, International Business Machines Corporation and others.

//  All Rights Reserved.

//

//  This file contains declarations for several classes from the

//    Rule Based Break Iterator rule builder.

//

#ifndef RBBIRB_H

#define RBBIRB_H

#include "unicode/utypes.h"

#include "unicode/uobject.h"

#include "unicode/rbbi.h"

#include "unicode/uniset.h"

#include "unicode/parseerr.h"

#include "uhash.h"

#include "uvector.h"

#include "unicode/symtable.h"// For UnicodeSet parsing, is the interface that

                          //    looks up references to $variables within a set.

U_NAMESPACE_BEGIN

class               RBBIRuleScanner;

struct              RBBIRuleTableEl;

class               RBBISetBuilder;

class               RBBINode;

class               RBBITableBuilder;

//--------------------------------------------------------------------------------

//

//   RBBISymbolTable.    Implements SymbolTable interface that is used by the

//                       UnicodeSet parser to resolve references to $variables.

//

//--------------------------------------------------------------------------------

class RBBISymbolTableEntry : public UMemory { // The symbol table hash table contains one

public:                                       //   of these structs for each entry.

    RBBISymbolTableEntry();

    UnicodeString          key;

    RBBINode               *val;

    ~RBBISymbolTableEntry();

private:

    RBBISymbolTableEntry(const RBBISymbolTableEntry &other); // forbid copying of this class

    RBBISymbolTableEntry &operator=(const RBBISymbolTableEntry &other); // forbid copying of this class

};

class RBBISymbolTable : public UMemory, public SymbolTable {

private:

    const UnicodeString      &fRules;

    UHashtable               *fHashTable;

    RBBIRuleScanner          *fRuleScanner;

    // These next two fields are part of the mechanism for passing references to

    //   already-constructed UnicodeSets back to the UnicodeSet constructor

    //   when the pattern includes $variable references.

    const UnicodeString      ffffString;      // = "/uffff"

    UnicodeSet              *fCachedSetLookup;

public:

    //  API inherited from class SymbolTable

    virtual const UnicodeString*  lookup(const UnicodeString& s) const;

    virtual const UnicodeFunctor* lookupMatcher(UChar32 ch) const;

    virtual UnicodeString parseReference(const UnicodeString& text,

                                         ParsePosition& pos, int32_t limit) const;

    //  Additional Functions

    RBBISymbolTable(RBBIRuleScanner *, const UnicodeString &fRules, UErrorCode &status);

    virtual ~RBBISymbolTable();

    virtual RBBINode *lookupNode(const UnicodeString &key) const;

    virtual void      addEntry  (const UnicodeString &key, RBBINode *val, UErrorCode &err);

#ifdef RBBI_DEBUG

    virtual void      rbbiSymtablePrint() const;

#else

    // A do-nothing inline function for non-debug builds.  Member funcs can't be empty

    //  or the call sites won't compile.

    int  fFakeField;

    #define rbbiSymtablePrint() fFakeField=0; 

#endif

private:

    RBBISymbolTable(const RBBISymbolTable &other); // forbid copying of this class

    RBBISymbolTable &operator=(const RBBISymbolTable &other); // forbid copying of this class

};

//--------------------------------------------------------------------------------

//

//  class RBBIRuleBuilder       The top-level class handling RBBI rule compiling.

//

//--------------------------------------------------------------------------------

class RBBIRuleBuilder : public UMemory {

public:

    //  Create a rule based break iterator from a set of rules.

    //  This function is the main entry point into the rule builder.  The

    //   public ICU API for creating RBBIs uses this function to do the actual work.

    //

    static BreakIterator * createRuleBasedBreakIterator( const UnicodeString    &rules,

                                    UParseError      &parseError,

                                    UErrorCode       &status);

public:

    // The "public" functions and data members that appear below are accessed

    //  (and shared) by the various parts that make up the rule builder.  They

    //  are NOT intended to be accessed by anything outside of the

    //  rule builder implementation.

    RBBIRuleBuilder(const UnicodeString  &rules,

                    UParseError          &parseErr,

                    UErrorCode           &status

        );

    virtual    ~RBBIRuleBuilder();

    char                          *fDebugEnv;        // controls debug trace output

    UErrorCode                    *fStatus;          // Error reporting.  Keeping status

    UParseError                   *fParseError;      //   here avoids passing it everywhere.

    const UnicodeString           &fRules;           // The rule string that we are compiling

    RBBIRuleScanner               *fScanner;         // The scanner.

    RBBINode                      *fForwardTree;     // The parse trees, generated by the scanner,

    RBBINode                      *fReverseTree;     //   then manipulated by subsequent steps.

    RBBINode                      *fSafeFwdTree;

    RBBINode                      *fSafeRevTree;

    RBBINode                      **fDefaultTree;    // For rules not qualified with a !

                                                     //   the tree to which they belong to.

    UBool                         fChainRules;       // True for chained Unicode TR style rules.

                                                     // False for traditional regexp rules.

    UBool                         fLBCMNoChain;      // True:  suppress chaining of rules on

                                                     //   chars with LineBreak property == CM.

    UBool                         fLookAheadHardBreak;  // True:  Look ahead matches cause an

                                                     // immediate break, no continuing for the

                                                     // longest match.

    RBBISetBuilder                *fSetBuilder;      // Set and Character Category builder.

    UVector                       *fUSetNodes;       // Vector of all uset nodes.

    RBBITableBuilder              *fForwardTables;   // State transition tables

    RBBITableBuilder              *fReverseTables;

    RBBITableBuilder              *fSafeFwdTables;

    RBBITableBuilder              *fSafeRevTables;

    UVector                       *fRuleStatusVals;  // The values that can be returned

                                                     //   from getRuleStatus().

    RBBIDataHeader                *flattenData();    // Create the flattened (runtime format)

                                                     // data tables..

private:

    RBBIRuleBuilder(const RBBIRuleBuilder &other); // forbid copying of this class

    RBBIRuleBuilder &operator=(const RBBIRuleBuilder &other); // forbid copying of this class

};

//----------------------------------------------------------------------------

//

//   RBBISetTableEl   is an entry in the hash table of UnicodeSets that have

//                    been encountered.  The val Node will be of nodetype uset

//                    and contain pointers to the actual UnicodeSets.

//                    The Key is the source string for initializing the set.

//

//                    The hash table is used to avoid creating duplicate

//                    unnamed (not $var references) UnicodeSets.

//

//                    Memory Management:

//                       The Hash Table owns these RBBISetTableEl structs and

//                            the key strings.  It does NOT own the val nodes.

//

//----------------------------------------------------------------------------

struct RBBISetTableEl {

    UnicodeString *key;

    RBBINode      *val;

};

//----------------------------------------------------------------------------

//

//   RBBIDebugPrintf    Printf equivalent, for debugging output.

//                      Conditional compilation of the implementation lets us

//                      get rid of the stdio dependency in environments where it

//                      is unavailable.

//

//----------------------------------------------------------------------------

#ifdef RBBI_DEBUG

#include <stdio.h>

#define RBBIDebugPrintf printf

#define RBBIDebugPuts puts

#else

#undef RBBIDebugPrintf 

#define RBBIDebugPuts(arg)

#endif

U_NAMESPACE_END

#endif