cpp/src/Slice/Checksum.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <Slice/Checksum.h>
  11 #include <Slice/MD5.h>
  12
  13 using namespace std;
  14 using namespace Slice;
  15
  16 namespace Slice
  17 {
  18
  19 class ChecksumVisitor : public ParserVisitor
  20 {
  21 public:
  22
  23     ChecksumVisitor(ChecksumMap&);
  24
  25     virtual bool visitClassDefStart(const ClassDefPtr&);
  26     virtual bool visitExceptionStart(const ExceptionPtr&);
  27     virtual bool visitStructStart(const StructPtr&);
  28     virtual void visitSequence(const SequencePtr&);
  29     virtual void visitDictionary(const DictionaryPtr&);
  30     virtual void visitEnum(const EnumPtr&);
  31     virtual void visitConst(const ConstPtr&);
  32
  33 private:
  34
  35     string typeToString(const TypePtr&);
  36     void updateMap(const string&, const string&);
  37
  38     ChecksumMap& _map;
  39 };
  40
  41 }
  42
  43 Slice::ChecksumVisitor::ChecksumVisitor(ChecksumMap& m) :
  44     _map(m)
  45 {
  46 }
  47
  48 bool
  49 Slice::ChecksumVisitor::visitClassDefStart(const ClassDefPtr& p)
  50 {
  51     if(p->isLocal())
  52     {
  53         return false;
  54     }
  55
  56     ClassList bases = p->bases();
  57
  58     ostringstream ostr;
  59
  60     if(p->isInterface())
  61     {
  62         ostr << "interface ";
  63     }
  64     else
  65     {
  66         ostr << "class ";
  67     }
  68     ostr << p->name();
  69
  70     if(!bases.empty())
  71     {
  72         if(!bases.front()->isInterface())
  73         {
  74             ostr << " extends " << bases.front()->scoped();
  75             bases.erase(bases.begin());
  76         }
  77         if(!bases.empty())
  78         {
  79             if(p->isInterface())
  80             {
  81                 ostr << " extends ";
  82             }
  83             else
  84             {
  85                 ostr << " implements ";
  86             }
  87             for(ClassList::iterator q = bases.begin(); q != bases.end(); ++q)
  88             {
  89                 if(q != bases.begin())
  90                 {
  91                     ostr << ", ";
  92                 }
  93                 ostr << (*q)->scoped();
  94             }
  95         }
  96     }
  97     ostr << endl;
  98
  99     if(p->hasDataMembers())
 100     {
 101         DataMemberList members = p->dataMembers();
 102         for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
 103         {
 104             ostr << typeToString((*q)->type()) << ' ' << (*q)->name() << endl;
 105         }
 106     }
 107
 108     if(p->hasOperations())
 109     {
 110         OperationList ops = p->operations();
 111         for(OperationList::iterator q = ops.begin(); q != ops.end(); ++q)
 112         {
 113             ostr << typeToString((*q)->returnType()) << ' ' << (*q)->name() << '(';
 114             ParamDeclList params = (*q)->parameters();
 115             for(ParamDeclList::iterator r = params.begin(); r != params.end(); ++r)
 116             {
 117                 if(r != params.begin())
 118                 {
 119                     ostr << ", ";
 120                 }
 121                 if((*r)->isOutParam())
 122                 {
 123                     ostr << "out ";
 124                 }
 125                 ostr << typeToString((*r)->type()) << ' ' << (*r)->name();
 126             }
 127             ostr << ')';
 128             ExceptionList ex = (*q)->throws();
 129             if(!ex.empty())
 130             {
 131                 ostr << " throws ";
 132                 for(ExceptionList::iterator s = ex.begin(); s != ex.end(); ++s)
 133                 {
 134                     if(s != ex.begin())
 135                     {
 136                         ostr << ", ";
 137                     }
 138                     ostr << (*s)->scoped();
 139                 }
 140             }
 141             ostr << endl;
 142         }
 143     }
 144
 145     updateMap(p->scoped(), ostr.str());
 146
 147     return false;
 148 }
 149
 150 bool
 151 Slice::ChecksumVisitor::visitExceptionStart(const ExceptionPtr& p)
 152 {
 153     if(p->isLocal())
 154     {
 155         return false;
 156     }
 157
 158     ExceptionPtr base = p->base();
 159
 160     ostringstream ostr;
 161
 162     ostr << "exception " << p->name();
 163     if(base)
 164     {
 165         ostr << " extends " << base->scoped();
 166     }
 167     ostr << endl;
 168
 169     DataMemberList members = p->dataMembers();
 170     for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
 171     {
 172         ostr << typeToString((*q)->type()) << ' ' << (*q)->name() << endl;
 173     }
 174
 175     updateMap(p->scoped(), ostr.str());
 176
 177     return false;
 178 }
 179
 180 bool
 181 Slice::ChecksumVisitor::visitStructStart(const StructPtr& p)
 182 {
 183     if(p->isLocal())
 184     {
 185         return false;
 186     }
 187
 188     ostringstream ostr;
 189
 190     ostr << "struct " << p->name() << endl;
 191
 192     DataMemberList members = p->dataMembers();
 193     for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q)
 194     {
 195         ostr << typeToString((*q)->type()) << ' ' << (*q)->name() << endl;
 196     }
 197
 198     updateMap(p->scoped(), ostr.str());
 199
 200     return false;
 201 }
 202
 203 void
 204 Slice::ChecksumVisitor::visitSequence(const SequencePtr& p)
 205 {
 206     if(p->isLocal())
 207     {
 208         return;
 209     }
 210
 211     ostringstream ostr;
 212     ostr << "sequence<" << typeToString(p->type()) << "> " << p->name() << endl;
 213     updateMap(p->scoped(), ostr.str());
 214 }
 215
 216 void
 217 Slice::ChecksumVisitor::visitDictionary(const DictionaryPtr& p)
 218 {
 219     if(p->isLocal())
 220     {
 221         return;
 222     }
 223
 224     ostringstream ostr;
 225     ostr << "dictionary<" << typeToString(p->keyType()) << ", " << typeToString(p->valueType()) << "> " << p->name()
 226          << endl;
 227     updateMap(p->scoped(), ostr.str());
 228 }
 229
 230 void
 231 Slice::ChecksumVisitor::visitEnum(const EnumPtr& p)
 232 {
 233     if(p->isLocal())
 234     {
 235         return;
 236     }
 237
 238     ostringstream ostr;
 239
 240     ostr << "enum " << p->name() << endl;
 241
 242     EnumeratorList enums = p->getEnumerators();
 243     for(EnumeratorList::iterator q = enums.begin(); q != enums.end(); ++q)
 244     {
 245         ostr << (*q)->name() << endl;
 246     }
 247
 248     updateMap(p->scoped(), ostr.str());
 249 }
 250
 251 void
 252 Slice::ChecksumVisitor::visitConst(const ConstPtr& p)
 253 {
 254     ostringstream ostr;
 255     ostr << "const " << typeToString(p->type()) << ' ' << p->name() << " = " << p->value() << endl;
 256     updateMap(p->scoped(), ostr.str());
 257 }
 258
 259 string
 260 Slice::ChecksumVisitor::typeToString(const TypePtr& type)
 261 {
 262     static const char* builtinTable[] =
 263     {
 264         "byte",
 265         "boolean",
 266         "short",
 267         "int",
 268         "long",
 269         "float",
 270         "double",
 271         "string",
 272         "Object",
 273         "Object*",
 274         "LocalObject"
 275     };
 276
 277     if(!type)
 278     {
 279         return "void";
 280     }
 281
 282     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
 283     if(builtin)
 284     {
 285         return builtinTable[builtin->kind()];
 286     }
 287
 288     ProxyPtr proxy = ProxyPtr::dynamicCast(type);
 289     if(proxy)
 290     {
 291         return proxy->_class()->scoped() + "*";
 292     }
 293
 294     ContainedPtr cont = ContainedPtr::dynamicCast(type);
 295     assert(cont);
 296     return cont->scoped();
 297 }
 298
 299 void
 300 Slice::ChecksumVisitor::updateMap(const string& scoped, const string& data)
 301 {
 302     MD5 md5(reinterpret_cast<const unsigned char*>(data.c_str()), static_cast<int>(data.size()));
 303     vector<unsigned char> bytes;
 304     bytes.resize(16);
 305     md5.getDigest(reinterpret_cast<unsigned char*>(&bytes[0]));
 306     _map.insert(ChecksumMap::value_type(scoped, bytes));
 307 }
 308
 309 Slice::ChecksumMap
 310 Slice::createChecksums(const UnitPtr& u)
 311 {
 312     ChecksumMap result;
 313
 314     ChecksumVisitor visitor(result);
 315     u->visit(&visitor, false);
 316
 317     return result;
 318 }