← Back to branch summary

~ubuntu-branches/ubuntu/trusty/openjade1.3/trusty

« back to all changes in this revision

Viewing changes to spam/spam.cxx

  • Committer: Bazaar Package Importer
  • Author(s): Yann Dirson
  • Date: 2002-04-09 00:01:50 UTC
  • Revision ID: james.westby@ubuntu.com-20020409000150-r9rkyalxlhvf9ba3
Tags: upstream-1.3.1
Import upstream version 1.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
spam/spam.cxx
 
1
// Copyright (c) 1995, 1996 James Clark
 
2
// See the file COPYING for copying permission.
 
3
 
 
4
// FIXME usage message for bad -m option.
 
5
 
 
6
#include "config.h"
 
7
#include "SgmlParser.h"
 
8
#include "Event.h"
 
9
#include "OutputCharStream.h"
 
10
#include "ParserApp.h"
 
11
#include "Boolean.h"
 
12
#include "macros.h"
 
13
#include "SpamMessages.h"
 
14
#include "CopyEventHandler.h"
 
15
#include "InputSource.h"
 
16
 
 
17
#include "sptchar.h"
 
18
 
 
19
#include <stdlib.h>
 
20
 
 
21
#ifdef SP_NAMESPACE
 
22
using namespace SP_NAMESPACE;
 
23
#endif
 
24
 
 
25
class XCopyEventHandler : public CopyEventHandler {
 
26
public:
 
27
  XCopyEventHandler(OutputCharStream *os, unsigned normalizeFlags,
 
28
                    const StringC &outputEntity, Messenger *);
 
29
  void message(MessageEvent *);
 
30
private:
 
31
  void reportTagInSpecialMarkedSection(const Location &);
 
32
  Messenger *messenger_;
 
33
  OutputCharStream *os_;
 
34
};
 
35
 
 
36
static
 
37
struct {
 
38
  const ParserApp::AppChar *name;
 
39
  unsigned flag;
 
40
} normalizeTable[] = {
 
41
  { SP_T("omittag"), CopyEventHandler::normalizeOmittag },
 
42
  { SP_T("shortref"), CopyEventHandler::normalizeShortref },
 
43
  { SP_T("net"), CopyEventHandler::normalizeNet },
 
44
  { SP_T("emptytag"), CopyEventHandler::normalizeEmptytag },
 
45
  { SP_T("unclosed"), CopyEventHandler::normalizeUnclosed },
 
46
  { SP_T("attname"), CopyEventHandler::normalizeAttname },
 
47
  { SP_T("attvalue"), CopyEventHandler::normalizeAttvalue },
 
48
  { SP_T("attspec"), CopyEventHandler::normalizeAttspec },
 
49
  { SP_T("current"), CopyEventHandler::normalizeCurrent },
 
50
  { SP_T("shorttag"), CopyEventHandler::normalizeShorttag },
 
51
  { SP_T("rank"), CopyEventHandler::normalizeRank },
 
52
  { SP_T("reserved"), CopyEventHandler::normalizeReserved },
 
53
  { SP_T("ms"), CopyEventHandler::normalizeMarkedSection },
 
54
};
 
55
 
 
56
class SpamApp : public ParserApp {
 
57
public:
 
58
  SpamApp();
 
59
  ErrorCountEventHandler *makeEventHandler();
 
60
  void processOption(AppChar opt, const AppChar *arg);
 
61
private:
 
62
  unsigned normalizeFlags_;
 
63
  StringC outputEntity_;
 
64
  Boolean rawOutput_;
 
65
};
 
66
 
 
67
SP_DEFINE_APP(SpamApp)
 
68
 
 
69
SpamApp::SpamApp()
 
70
: rawOutput_(0), normalizeFlags_(0)
 
71
{
 
72
  options_.eventsWanted.addInstanceMarkup();
 
73
  options_.eventsWanted.addPrologMarkup();
 
74
  registerOption('h');
 
75
  registerOption('l');
 
76
  registerOption('m', SP_T("omittag|shortref|net|emptytag|unclosed|attname|attvalue|attspec|current|shorttag|rank|reserved"));
 
77
  registerOption('o', SP_T("entity_name"));
 
78
  registerOption('p');
 
79
  registerOption('r');
 
80
  registerOption('x');
 
81
}
 
82
 
 
83
void SpamApp::processOption(AppChar opt, const AppChar *arg)
 
84
{
 
85
  switch (opt) {
 
86
  case 'h':
 
87
    // hoist omitted tags out of entities
 
88
    normalizeFlags_ |= CopyEventHandler::normalizeOmittagHoist;
 
89
    break;
 
90
  case 'l':                     // prefer lowercase
 
91
    normalizeFlags_ |= CopyEventHandler::normalizeLower;
 
92
    break;
 
93
  case 'm':
 
94
    {
 
95
      Boolean found = 0;
 
96
      for (size_t i = 0; i < SIZEOF(normalizeTable); i++)
 
97
        if (tcscmp(normalizeTable[i].name, arg) == 0) {
 
98
          found = 1;
 
99
          normalizeFlags_ |= normalizeTable[i].flag;
 
100
          break;
 
101
        }
 
102
      if (!found) {
 
103
        message(SpamMessages::invalidMarkupArgument,
 
104
                StringMessageArg(convertInput(arg)));
 
105
        // usage(kit);
 
106
      }
 
107
    }
 
108
    break;
 
109
  case 'o':
 
110
    outputEntity_ = convertInput(arg);
 
111
    break;
 
112
  case 'p':
 
113
    if (normalizeFlags_ & CopyEventHandler::normalizeIncludeProlog)
 
114
      normalizeFlags_ |= CopyEventHandler::normalizeExpandProlog;
 
115
    else
 
116
      normalizeFlags_ |= CopyEventHandler::normalizeIncludeProlog;
 
117
    break;
 
118
  case 'r':
 
119
    rawOutput_ = 1;
 
120
    break;
 
121
  case 'x':
 
122
    if (normalizeFlags_ & CopyEventHandler::normalizeExpand)
 
123
      normalizeFlags_ |= CopyEventHandler::normalizeExpandAll;
 
124
    else
 
125
      normalizeFlags_ |= CopyEventHandler::normalizeExpand;
 
126
    break;
 
127
  default:
 
128
    ParserApp::processOption(opt, arg);
 
129
    break;
 
130
  }
 
131
}
 
132
 
 
133
ErrorCountEventHandler *SpamApp::makeEventHandler()
 
134
{
 
135
  OutputCharStream *os = makeStdOut();
 
136
  if (!rawOutput_)
 
137
    os = new RecordOutputCharStream(os);
 
138
  return new XCopyEventHandler(os, normalizeFlags_, outputEntity_, this);
 
139
}
 
140
 
 
141
XCopyEventHandler::XCopyEventHandler(OutputCharStream *os,
 
142
                                     unsigned normalizeFlags,
 
143
                                     const StringC &outputEntity,
 
144
                                     Messenger *messenger)
 
145
: messenger_(messenger), os_(os),
 
146
  CopyEventHandler(os, normalizeFlags, outputEntity)
 
147
{
 
148
}
 
149
 
 
150
void XCopyEventHandler::message(MessageEvent *event)
 
151
{
 
152
  messenger_->dispatchMessage(event->message());
 
153
  CopyEventHandler::message(event);
 
154
}
 
155
 
 
156
void XCopyEventHandler::reportTagInSpecialMarkedSection(const Location &loc)
 
157
{
 
158
  messenger_->setNextLocation(loc);
 
159
  messenger_->message(SpamMessages::tagInSpecialMarkedSection);
 
160
}