---

kygrammar.h

Go to the documentation of this file.

/***************************************************************************
    kygrammar.h  -  Definition of KYGrammar class
                             -------------------
    begin                : June 21 2002
    copyright            : (C) 2003 by Vojtìch Toman
    email                : vtoman@lit.cz
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifdef __GNUG__
# pragma interface
#endif

#ifndef KYGRAMMAR_H
#define KYGRAMMAR_H


#include "defs.h"
#include "grammarbase.h"
#include "queue.h"
#include "stack.h"
#include "kydefs.h"
#include "iodevice.h"
#include "fibonacci.h"
#include "contextbase.h"

#ifdef __WIN32__
# include <Winsock2.h>
#else
# include <sys/time.h>
#endif



#define KY_GRAMMAR_FLUSH_STACK_SIZE     8192


#define KY_GRAMMAR_RULE_STACK_SIZE      8192


#define KY_GRAMMAR_MAX_SIZE             8388608


#define KY_GRAMMAR_EATDATA_PERIODICITY  256


class KYGrammar : public GrammarBase
{
public:
  KYGrammar(void);

  virtual ~KYGrammar(void);

  virtual void purge(void);

  virtual void setAlphabetBaseSize(size_t size);

  virtual void setContext(ContextBase *ctxt, bool useForOutput = true);

  void setOutputDevice(IODevice *device);

  virtual void append(TerminalValue);

  virtual void appendToRootRule(RuleElement *);

  virtual void flush(void);

  virtual Rule *findRule(RuleId id);

  virtual void print(void);


  virtual void reconstructInput(void);


  virtual void printDigrams(void);


protected:
  ContextBase *context;

  bool useContextForOutput;

  long newSymbolToInstall;

  long lastFixedContextSymbol;


  size_t size;

  IODevice *outputDevice;

  InputItem *inputFirst;

  InputItem *inputLast;

  TestedRules *testedRules;


  RuleSet *ruleSet;

  Rule *rootRule;

  TerminalDigrams *terminalDigrams;

  VariableDigrams *variableDigrams;


  MatchingRule bestTestedRule;

  bool I;

  RuleId ruleCounter;


  Queue<RuleId> *availableRuleNumbers;


//    Stack<Rule> ruleStack;

  unsigned long runCount;


  unsigned long inputQueueLength;

  unsigned long maxInputQueueLength;


  size_t totalTime;

  size_t totalSymbols;

  size_t variablesEncoded;

  size_t terminalsEncoded;

  size_t eatDataPeriodicity;

  virtual Rule *createRootRule(void);


  virtual Rule *createRule(RuleElement *, RuleElement *);


  virtual bool ruleMatchesInput(TestedRule *testedRule, bool flush = false);

  virtual void eatData(bool = false);

  virtual void reconstructRule(Rule *rule, IODevice *outputDevice);

  virtual size_t getRuleLength(Rule *rule);

  virtual void reductionRule1(Rule *);

  virtual Rule *reductionRule2(RuleElement *, RuleElement *);

  virtual Rule *reductionRule3(Rule *, RuleElement *, RuleElement *);


  virtual void initKYGrammar(void);


  RuleElement **flushStack;

  int flushStackPos;

  Rule **ruleStack;

  int ruleStackPos;
};



#endif //KYGRAMMAR_H

---