~ubuntu-branches/ubuntu/quantal/aspectc++/quantal

« back to all changes in this revision

Viewing changes to AspectC++/Repository.cc

• browse files at revision 10
• compare with another revision
• download diff
• download tarball
• view history from revision 10

Show diffs side-by-side

added

removed

AspectC++/Repository.cc

25

25

#include "Repository.h"

26

26

#include "version.h"

27

27

#include "PointCut.h"

28

 

#include "JoinPointLoc.h"

29

 

#include "IntroductionInfo.h"

 

28

#include "TransformInfo.h"

30

29

#include "OrderInfo.h"

31

30

#include "AdviceInfo.h"

32

31

#include "AspectInfo.h"

105

104

  _name = (const char *)0;

106

105

}

107

106

 

 

107

const SourceLoc *Repository::source_loc (JoinPointLoc &jpl) {

 

108

  const SourceLoc *src = 0;

 

109

  set<SourceLoc> &source_locs = (jpl.type () &

 

110

    (JoinPointLoc::Method|JoinPointLoc::Construction|JoinPointLoc::Destruction)) ?

 

111

    jpl.parent ()->source_locs () : jpl.source_locs ();

 

112

  for (set<SourceLoc>::iterator i = source_locs.begin ();

 

113

    i != source_locs.end (); ++i) {

 

114

    if ((*i).kind () != SLK_DECL) {

 

115

      src = &(*i);

 

116

      break;

 

117

    }

 

118

  }

 

119

  return src;

 

120

}

 

121

 

108

122

Repository::REPO_ID Repository::consider (const Unit &unit) {

109

123

  if (!unit.isFile ())

110

124

    return -1;

111

125

 

112

126

  return _frepo.insert (unit.name (),

113

 

                        ((Token*)unit.last ())->location ().line (), _primary);

 

127

      ((Token*)unit.last ())->location ().line (), _primary);

 

128

}

 

129

 

 

130

Repository::REPO_ID Repository::consider (const File &file) {

 

131

  return _frepo.insert (file.name ().c_str (), file.len (), _primary);

114

132

}

115

133

 

116

134

Repository::REPO_ID Repository::consider (JoinPointLoc &jpl, int adv) {

117

 

  REPO_ID file_id = consider (*jpl.unit ());

118

 

  REPO_ID jp_id = _jprepo.insert (file_id, jpl.line (), jpl.signature (),

119

 

                                  jpl.type_str (), adv, jpl.lines ());

 

135

  const SourceLoc *src = source_loc (jpl);

 

136

  if (!src)

 

137

    return -1;

 

138

  REPO_ID file_id = consider (*(const File*)jpl.map (src->file_id()));

 

139

  REPO_ID jp_id   = _jprepo.insert (file_id, src->line (), jpl.signature (),

 

140

                                    jpl.type_str (), adv, src->len ());

120

141

  return jp_id;

121

142

}

122

143

 

123

 

Repository::REPO_ID Repository::consider (AspectInfo &ai) {

124

 

  REPO_ID file_id = consider (ai.unit ());

125

 

  return _asprepo.insert (file_id, ai.line (), ai.name ());

 

144

Repository::REPO_ID Repository::consider (JPL_Aspect &jpl) {

 

145

  const SourceLoc *src = source_loc (jpl);

 

146

  if (!src)

 

147

    return -1;

 

148

  REPO_ID file_id = consider (*(const File*)jpl.map (src->file_id()));

 

149

  return _asprepo.insert (file_id, src->line (), jpl.signature ());

 

150

}

 

151

 

 

152

Repository::REPO_ID Repository::consider (JPL_Introduction &intro) {

 

153

  const SourceLoc *src = source_loc (intro);

 

154

  if (!src)

 

155

    return -1;

 

156

  // remember aspect and advice information in the project repository

 

157

  REPO_ID aspect_id = consider (*(JPL_Aspect*)intro.parent ());

 

158

  REPO_ID file_id   = consider (*(const File*)intro.map (src->file_id()));

 

159

  REPO_ID advice_id = _advrepo.insert (file_id, src->line (),

 

160

    intro.type_str (), aspect_id, src->len ());

 

161

  return advice_id;

126

162

}

127

163

 

128

164

void Repository::setup (Unit* prim_unit) {

143

179

  _frepo.cleanup (_primary);

144

180

}

145

181

 

146

 

void Repository::update (IntroductionInfo &ii, PointCut &target) {

147

 

  // remember aspect information in the project repository

148

 

  REPO_ID aspect_id = consider (*ii.aspect ());

149

 

  REPO_ID file_id   = consider (ii.unit ());

150

 

  REPO_ID advice_id = _advrepo.insert (file_id, ii.line (), ii.type_str (), 

151

 

                                       aspect_id, ii.lines ());

 

182

void Repository::update (JPL_Introduction &intro, JPL_Class &cls) {

 

183

  // remember aspect information in the project repository

 

184

  REPO_ID advice_id = consider (intro);

 

185

  REPO_ID jp_id = consider (cls, advice_id);

 

186

  cls.assigned_id (jp_id);

 

187

}

 

188

 

 

189

void Repository::update (AdviceInfo &ai, PointCut &target) {

 

190

  // remember aspect information in the project repository

 

191

  REPO_ID aspect_id = consider (ai.aspect ());

 

192

  const SourceLoc *src = source_loc (ai.code ());

 

193

  if (!src)

 

194

    return;

 

195

  REPO_ID file_id   = consider (*(const File*)ai.code ().map (src->file_id()));

 

196

  REPO_ID advice_id = _advrepo.insert (file_id, src->line (),

 

197

    ai.code ().type_str (), aspect_id, src->len ());

 

198

  

152

199

  for (PointCut::iterator iter = target.begin ();

153

200

       iter != target.end (); ++iter) {

154

201

    JoinPointLoc &jpl = *((*iter).location ());

 

202

    const SourceLoc *src = source_loc (jpl);

 

203

    if (!src)

 

204

      continue;

155

205

    REPO_ID jp_id = consider (jpl, advice_id);

156

 

    jpl.id (jp_id);

157

 

  }

158

 

}

159

 

 

160

 

void Repository::update (AdviceInfo &ai, PointCut &target) {

161

 

  // remember aspect information in the project repository

162

 

  REPO_ID aspect_id = consider (*ai.aspect ());

163

 

  REPO_ID file_id   = consider (ai.code ().unit ());

164

 

  REPO_ID advice_id = _advrepo.insert (file_id, ai.code ().line (),

165

 

    ai.code ().type_str (), aspect_id, ai.code ().lines ());

166

 

  

167

 

  for (PointCut::iterator iter = target.begin ();

168

 

       iter != target.end (); ++iter) {

169

 

    JoinPointLoc &jpl = *((*iter).location ());

170

 

    if (!(jpl.type () == JoinPointLoc::Method &&

171

 

          !((JPL_Method&)jpl).func_info ()->isDefined ()) &&

172

 

        !(jpl.type () == JoinPointLoc::MethodCall &&

173

 

          ((JPL_Code&)jpl).is_pseudo ())) {

174

 

      REPO_ID jp_id = consider (jpl, advice_id);

175

 

      jpl.id (jp_id);

176

 

    }

 

206

    jpl.assigned_id (jp_id);

177

207

  }

178

208

}

179

209

 

180

210

void Repository::update (OrderInfo &oi) {

181

211

  // remember order advice information in the project repository

182

 

  REPO_ID aspect_id = consider (*oi.aspect ());

183

 

  REPO_ID file_id   = consider (oi.unit ());

184

 

  /* REPO_ID advice_id = */ _advrepo.insert (file_id, oi.line (),

185

 

    "order", aspect_id, oi.lines ());

 

212

  REPO_ID aspect_id = consider (oi.aspect ());

 

213

  const SourceLoc *src = source_loc (oi.order ());

 

214

  if (!src)

 

215

    return;

 

216

  REPO_ID file_id   = consider (*(const File*)oi.order ().map (src->file_id()));

 

217

  /* REPO_ID advice_id = */ _advrepo.insert (file_id, src->line (),

 

218

    "order", aspect_id, src->len ());

186

219

}

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1