style/Style.h

   1 // Copyright (c) 1996 James Clark
   2 // See the file copying.txt for copying permission.
   3
   4 #ifndef Style_INCLUDED
   5 #define Style_INCLUDED 1
   6
   7 #include "types.h"
   8 #include "StringC.h"
   9 #include "Named.h"
  10 #include <stddef.h>
  11 #include "ELObj.h"
  12 #include "Vector.h"
  13 #include "Ptr.h"
  14 #include "Resource.h"
  15 #include "Owner.h"
  16 #include "Insn.h"
  17 #include "FOTBuilder.h"
  18 #include "Boolean.h"
  19 #include "Node.h"
  20 #include "Location.h"
  21 #include "ProcessingMode.h"
  22
  23 #ifdef DSSSL_NAMESPACE
  24 namespace DSSSL_NAMESPACE {
  25 #endif
  26
  27 class StyleStack;
  28 class Interpreter;
  29 class VarStyleObj;
  30
  31 // InheritedC represents the specification of a value
  32 // of an inherited characteristic.
  33 // It is also used as a prototype for other specifications of
  34 // values for that characteristic:
  35 // the identifier for an inherited characteristic contains the
  36 // InheritedC that specifies its initial value.
  37
  38 class InheritedC : public Resource {
  39 public:
  40   InheritedC(const Identifier *ident, unsigned index);
  41   virtual ~InheritedC();
  42   virtual void set(VM &vm, const VarStyleObj *, FOTBuilder &,
  43                    ELObj *&, Vector<size_t> &dependencies) const = 0;
  44   virtual ELObj *value(VM &, const VarStyleObj *, Vector<size_t> &) const = 0;
  45   virtual ConstPtr<InheritedC> make(ELObj *, const Location &, Interpreter &) const = 0;
  46   unsigned index() const;
  47   const Identifier *identifier() const;
  48   void setIdentifier(const Identifier *);
  49 protected:
  50   void invalidValue(const Location &, Interpreter &) const;
  51 private:
  52   const Identifier *ident_;
  53   // The index of the inherited characteristic (not the specification).
  54   unsigned index_;
  55 };
  56
  57 class VarInheritedC : public InheritedC {
  58 public:
  59   VarInheritedC(const ConstPtr<InheritedC> &, const InsnPtr &code, const Location &);
  60   void set(VM &, const VarStyleObj *, FOTBuilder &, ELObj *&value,
  61            Vector<size_t> &dependencies) const;
  62   ELObj *value(VM &, const VarStyleObj *, Vector<size_t> &) const;
  63   virtual ConstPtr<InheritedC> make(ELObj *, const Location &, Interpreter &) const;
  64 private:
  65   ConstPtr<InheritedC> inheritedC_;
  66   InsnPtr code_;
  67   Location loc_;
  68 };
  69
  70 class StyleObjIter {
  71 public:
  72   StyleObjIter();
  73   void append(const Vector<ConstPtr<InheritedC> > *, const VarStyleObj *);
  74   ConstPtr<InheritedC> next(const VarStyleObj *&);
  75 private:
  76   size_t i_;
  77   size_t vi_;
  78   Vector<const VarStyleObj *> styleVec_;
  79   Vector<const Vector<ConstPtr<InheritedC> > *> vecs_;
  80 };
  81
  82 class StyleObj : public ELObj {
  83 public:
  84   StyleObj *asStyle();
  85   virtual void appendIter(StyleObjIter &) const = 0;
  86 };
  87
  88 struct StyleSpec : public Resource {
  89   StyleSpec(Vector<ConstPtr<InheritedC> > &, Vector<ConstPtr<InheritedC> > &);
  90   Vector<ConstPtr<InheritedC> > forceSpecs;
  91   Vector<ConstPtr<InheritedC> > specs;
  92 };
  93
  94 class BasicStyleObj : public StyleObj {
  95 public:
  96   virtual void appendIterForce(StyleObjIter &) const = 0;
  97   virtual void appendIterNormal(StyleObjIter &) const = 0;
  98 };
  99
 100 class VarStyleObj : public BasicStyleObj {
 101 public:
 102   void *operator new(size_t, Collector &c) {
 103     return c.allocateObject(1);
 104   }
 105   VarStyleObj(const ConstPtr<StyleSpec> &, StyleObj *use, ELObj **display,
 106               const NodePtr &node);
 107   ~VarStyleObj();
 108   void appendIter(StyleObjIter &) const;
 109   void appendIterForce(StyleObjIter &) const;
 110   void appendIterNormal(StyleObjIter &) const;
 111   const NodePtr &node() const;
 112   ELObj **display() const;
 113   void traceSubObjects(Collector &) const;
 114 private:
 115   ConstPtr<StyleSpec> styleSpec_;
 116   StyleObj *use_;
 117   ELObj **display_;
 118   NodePtr node_;
 119 };
 120
 121 class OverriddenStyleObj : public StyleObj {
 122 public:
 123   OverriddenStyleObj(BasicStyleObj *basic, StyleObj *override);
 124   void appendIter(StyleObjIter &) const;
 125   void traceSubObjects(Collector &) const;
 126 private:
 127   BasicStyleObj *basic_;
 128   StyleObj *override_;
 129 };
 130
 131 class MergeStyleObj : public StyleObj {
 132 public:
 133   void *operator new(size_t, Collector &c) {
 134     return c.allocateObject(1);
 135   }
 136   MergeStyleObj();
 137   void append(StyleObj *);
 138   void appendIter(StyleObjIter &) const;
 139   void traceSubObjects(Collector &) const;
 140 private:
 141   Vector<StyleObj *> styles_;
 142 };
 143
 144 class ColorObj : public ELObj {
 145 public:
 146   ColorObj *asColor();
 147   virtual void set(FOTBuilder &) const = 0;
 148   virtual void setBackground(FOTBuilder &) const = 0;
 149 };
 150
 151 class DeviceRGBColorObj : public ColorObj {
 152 public:
 153   DeviceRGBColorObj(unsigned char, unsigned char, unsigned char);
 154   void set(FOTBuilder &) const;
 155   void setBackground(FOTBuilder &) const;
 156 private:
 157   FOTBuilder::DeviceRGBColor color_;
 158 };
 159
 160 class ColorSpaceObj : public ELObj {
 161 public:
 162   ColorSpaceObj *asColorSpace();
 163   virtual ELObj *makeColor(int argc, ELObj **argv, Interpreter &, const Location &) = 0;
 164 };
 165
 166 class DeviceRGBColorSpaceObj : public ColorSpaceObj {
 167 public:
 168   ELObj *makeColor(int argc, ELObj **argv, Interpreter &interp, const Location &);
 169 };
 170
 171 class DeviceGrayColorSpaceObj : public ColorSpaceObj {
 172 public:
 173   ELObj *makeColor(int argc, ELObj **argv, Interpreter &interp, const Location &);
 174 };
 175
 176 class DeviceCMYKColorSpaceObj : public ColorSpaceObj {
 177 public:
 178   ELObj *makeColor(int argc, ELObj **argv, Interpreter &interp, const Location &);
 179 };
 180
 181 class DeviceKXColorSpaceObj : public ColorSpaceObj {
 182 public:
 183   ELObj *makeColor(int argc, ELObj **argv, Interpreter &interp, const Location &);
 184 };
 185
 186 class CIEXYZColorSpaceObj : public ColorSpaceObj {
 187 public:
 188   CIEXYZColorSpaceObj(const double *, const double *);
 189   void *operator new(size_t, Collector &c) {
 190     return c.allocateObject(1);
 191   }
 192   ~CIEXYZColorSpaceObj();
 193   ELObj *makeColor(const double *, Interpreter &);
 194 protected:
 195 struct XYZData {
 196   double white_[3];
 197   double white_u;
 198   double white_v;
 199   double M_[9];
 200 };
 201  XYZData *xyzData_;
 202 };
 203
 204 class CIELUVColorSpaceObj : public CIEXYZColorSpaceObj {
 205 public:
 206   CIELUVColorSpaceObj(const double *, const double *, const double *);
 207   void *operator new(size_t, Collector &c) {
 208     return c.allocateObject(1);
 209   }
 210   ~CIELUVColorSpaceObj();
 211   ELObj *makeColor(int argc, ELObj **argv, Interpreter &interp, const Location &);
 212 private:
 213 struct LUVData {
 214   double range_[6];
 215 };
 216   LUVData *luvData_;
 217 };
 218
 219 class CIELABColorSpaceObj : public CIEXYZColorSpaceObj {
 220 public:
 221   CIELABColorSpaceObj(const double *, const double *, const double *);
 222   void *operator new(size_t, Collector &c) {
 223     return c.allocateObject(1);
 224   }
 225   ~CIELABColorSpaceObj();
 226   ELObj *makeColor(int argc, ELObj **argv, Interpreter &interp, const Location &);
 227 private:
 228 struct LABData {
 229   double range_[6];
 230 };
 231   LABData *labData_;
 232 };
 233
 234 class CIEABCColorSpaceObj : public CIEXYZColorSpaceObj {
 235 public:
 236   CIEABCColorSpaceObj(const double *, const double *, const double *,
 237                       FunctionObj **, const double *, const double *,
 238                       FunctionObj **, const double *);
 239   void *operator new(size_t, Collector &c) {
 240     return c.allocateObject(1);
 241   }
 242   ~CIEABCColorSpaceObj();
 243   void traceSubObjects(Collector &) const;
 244   ELObj *makeColor(int argc, ELObj **argv, Interpreter &interp, const Location &);
 245 private:
 246 struct ABCData {
 247   double rangeAbc_[6];
 248   FunctionObj *decodeAbc_[3];
 249   double matrixAbc_[9];
 250   double rangeLmn_[6];
 251   FunctionObj *decodeLmn_[3];
 252   double matrixLmn_[9];
 253 };
 254  ABCData *abcData_;
 255 };
 256
 257 class CIEAColorSpaceObj : public CIEXYZColorSpaceObj {
 258 public:
 259   CIEAColorSpaceObj(const double *, const double *, const double *,
 260                     FunctionObj *, const double *, const double *,
 261                     FunctionObj **, const double *);
 262   void *operator new(size_t, Collector &c) {
 263     return c.allocateObject(1);
 264   }
 265   ~CIEAColorSpaceObj();
 266   void traceSubObjects(Collector &) const;
 267   ELObj *makeColor(int argc, ELObj **argv, Interpreter &interp, const Location &);
 268 private:
 269 struct AData {
 270   double rangeA_[2];
 271   FunctionObj *decodeA_;
 272   double matrixA_[3];
 273   double rangeLmn_[6];
 274   FunctionObj *decodeLmn_[3];
 275   double matrixLmn_[9];
 276 };
 277   AData *aData_;
 278 };
 279
 280 struct InheritedCInfo : public Resource {
 281   InheritedCInfo(const ConstPtr<InheritedC> &, const VarStyleObj *,
 282                  unsigned valLevel, unsigned specLevel, const ProcessingMode::Rule *,
 283                  const Ptr<InheritedCInfo> &);
 284   ConstPtr<InheritedC> spec;
 285   Ptr<InheritedCInfo> prev;
 286   unsigned valLevel;
 287   unsigned specLevel;
 288   const ProcessingMode::Rule *rule;
 289   // If there are dependencies, then the cached value can only
 290   // be used only when the "value" flow object is at this level.
 291   ELObj *cachedValue;
 292   const VarStyleObj *style;
 293   // Includes both direct and indirect dependencies.
 294   Vector<size_t> dependencies;
 295 };
 296
 297 struct PopList : public Resource {
 298   PopList(const Ptr<PopList> &);
 299   Vector<size_t> list;
 300   // List of the indices of those ICs that have dependencies
 301   // (ie that use actual-*) directly or indirectly.
 302   Vector<size_t> dependingList;
 303   Ptr<PopList> prev;
 304 };
 305
 306 class StyleStack {
 307 public:
 308   StyleStack();
 309   // These append on to dependencies.
 310   ELObj *actual(const ConstPtr<InheritedC> &, const Location &, Interpreter &,
 311                 Vector<size_t> &dependencies);
 312   ELObj *actual(const ConstPtr<InheritedC> &, Interpreter &,
 313                 Vector<size_t> &dependencies);
 314   ELObj *inherited(const ConstPtr<InheritedC> &, unsigned specLevel, Interpreter &,
 315                    Vector<size_t> &dependencies);
 316   void push(StyleObj *, VM &, FOTBuilder &);
 317   void pushStart();
 318   void pushContinue(StyleObj *, const ProcessingMode::Rule *, const NodePtr &,
 319                     Messenger *);
 320   void pushEnd(VM &, FOTBuilder &);
 321   void pop();
 322   void pushEmpty() { level_++; }
 323   void popEmpty() { level_--; }
 324   unsigned level() const { return level_; }
 325   void trace(Collector &) const;
 326 private:
 327   Vector<Ptr<InheritedCInfo> > inheritedCInfo_;
 328   unsigned level_;
 329   Ptr<PopList> popList_;
 330 };
 331
 332 inline
 333 PopList::PopList(const Ptr<PopList> &p)
 334 : prev(p)
 335 {
 336 }
 337
 338 inline
 339 const Identifier *InheritedC::identifier() const
 340 {
 341   return ident_;
 342 }
 343
 344 inline
 345 void InheritedC::setIdentifier(const Identifier *ident)
 346 {
 347   ident_ = ident;
 348 }
 349
 350 inline
 351 unsigned InheritedC::index() const
 352 {
 353   return index_;
 354 }
 355
 356 inline
 357 ELObj **VarStyleObj::display() const
 358 {
 359   return display_;
 360 }
 361
 362 inline
 363 const NodePtr &VarStyleObj::node() const
 364 {
 365   return node_;
 366 }
 367
 368 inline
 369 void StyleStack::pushStart()
 370 {
 371   level_++;
 372   popList_ = new PopList(popList_);
 373 }
 374
 375 inline
 376 void StyleStack::push(StyleObj *style, VM &vm, FOTBuilder &fotb)
 377 {
 378   pushStart();
 379   pushContinue(style, 0, NodePtr(), 0);
 380   pushEnd(vm, fotb);
 381 }
 382
 383 inline
 384 ELObj *StyleStack::actual(const ConstPtr<InheritedC> &ic,
 385                           Interpreter &interp,
 386                           Vector<size_t> &dep)
 387 {
 388   return actual(ic, Location(), interp, dep);
 389 }
 390
 391 #ifdef DSSSL_NAMESPACE
 392 }
 393 #endif
 394
 395 #endif /* not Style_INCLUDED */