private List<Declaration> getInheritedMembers(String name, List<TypeDeclaration> visited) {
List<Declaration> members = new ArrayList<Declaration>();
for (TypeDeclaration t : getSatisfiedTypeDeclarations()) {
// if ( !(t instanceof TypeParameter) ) { //don't look for members in a type parameter with a
// self-referential lower bound
for (Declaration d : t.getMembers(name, visited)) {
if (d.isShared() && isResolvable(d)) {
if (!contains(members, d)) {
members.add(d);
}
}
}
// }
}
TypeDeclaration et = getExtendedTypeDeclaration();
if (et != null) {
for (Declaration d : et.getMembers(name, visited)) {
if (d.isShared() && isResolvable(d)) {
if (!contains(members, d)) {
members.add(d);
}
}
}
}
return members;
}
public int compare(Declaration d1, Declaration d2) {
if (equals(d1, d2)) return 0;
SourcePosition p1 = d1.getPosition();
SourcePosition p2 = d2.getPosition();
if (p1 == null && p2 != null) return 1;
else if (p1 != null && p2 == null) return -1;
else if (p1 == null && p2 == null) return compareEqualPosition(d1, d2);
else {
assert p1 != null && p2 != null;
int fileComp = p1.file().compareTo(p2.file());
if (fileComp == 0) {
long diff = (long) p1.line() - (long) p2.line();
if (diff == 0) {
diff = Long.signum((long) p1.column() - (long) p2.column());
if (diff != 0) return (int) diff;
else {
// declarations may be two
// compiler-generated members with the
// same source position
return compareEqualPosition(d1, d2);
}
} else return (diff < 0) ? -1 : 1;
} else return fileComp;
}
}
protected void findConstructor(Declaration[] declarations) throws NoSuchMethodException {
int N = this.abducibleArgs.length;
cachedConstructor = null;
List<Class> availableArgs = N > 0 ? new ArrayList<Class>(N) : Collections.<Class>emptyList();
for (int j = 0; j < N; j++) {
// during the initial build (KieBuilder), the declarations are provided on the fly and use for
// type checking
// when building the KieBase, the internal declarations are set and can be used
Declaration decl =
declarations != null ? declarations[mapArgToParam(j)] : getDeclaration(abducibleArgs[j]);
if (decl != null) {
availableArgs.add(decl.getExtractor().getExtractToClass());
}
}
Class klass = returnType.getClassType();
while (cachedConstructor == null) {
try {
cachedConstructor =
klass.getConstructor(availableArgs.toArray(new Class[availableArgs.size()]));
} catch (NoSuchMethodException nsme) {
if (klass == Object.class) {
throw nsme;
} else {
klass = klass.getSuperclass();
}
}
}
}
private SupertypeDeclaration getMemberInternal(
String name, List<ProducedType> signature, boolean variadic) {
// first search for the member in the local
// scope, including non-shared declarations
Declaration d = getDirectMember(name, signature, variadic);
if (d != null && d.isShared()) {
// if it's shared, it's what we're
// looking for, return it
// TODO: should also return it if we're
// calling from local scope!
if (signature != null && isAbstraction(d)) {
// look for a supertype decl that matches the signature better
SupertypeDeclaration sd = getSupertypeDeclaration(name, signature, variadic);
Declaration sm = sd.getMember();
if (sm != null && !isAbstraction(sm)) {
return sd;
}
}
return new SupertypeDeclaration(d, false);
} else {
// now look for inherited shared declarations
SupertypeDeclaration sd = getSupertypeDeclaration(name, signature, variadic);
if (sd.getMember() != null || sd.isAmbiguous()) {
return sd;
}
}
// finally return the non-shared member we
// found earlier, so that the caller can give
// a nice error message
return new SupertypeDeclaration(d, false);
}
private void replaceDeclarations(
DeclarationScopeResolver resolver, Pattern pattern, Constraint constraint) {
Declaration[] decl = constraint.getRequiredDeclarations();
for (Declaration aDecl : decl) {
Declaration resolved = resolver.getDeclaration(null, aDecl.getIdentifier());
if (constraint instanceof MvelConstraint && ((MvelConstraint) constraint).isUnification()) {
if (ClassObjectType.DroolsQuery_ObjectType.isAssignableFrom(
resolved.getPattern().getObjectType())) {
Declaration redeclaredDeclr =
new Declaration(
resolved.getIdentifier(),
((MvelConstraint) constraint).getFieldExtractor(),
pattern,
false);
pattern.addDeclaration(redeclaredDeclr);
} else if (resolved.getPattern() != pattern) {
((MvelConstraint) constraint).unsetUnification();
}
}
if (resolved != null && resolved != aDecl && resolved.getPattern() != pattern) {
constraint.replaceDeclaration(aDecl, resolved);
} else if (resolved == null) {
// it is probably an implicit declaration, so find the corresponding pattern
Pattern old = aDecl.getPattern();
Pattern current = resolver.findPatternByIndex(old.getIndex());
if (current != null && old != current) {
resolved = new Declaration(aDecl.getIdentifier(), aDecl.getExtractor(), current);
constraint.replaceDeclaration(aDecl, resolved);
}
}
}
}
/**
* Visits a class declaration.
*
* @param d the declaration to visit
*/
public void visitClassDeclaration(ClassDeclaration d) {
d.accept(pre);
SortedSet<Declaration> decls = new TreeSet<Declaration>(SourceOrderDeclScanner.comparator);
for (TypeParameterDeclaration tpDecl : d.getFormalTypeParameters()) {
decls.add(tpDecl);
}
for (FieldDeclaration fieldDecl : d.getFields()) {
decls.add(fieldDecl);
}
for (MethodDeclaration methodDecl : d.getMethods()) {
decls.add(methodDecl);
}
for (TypeDeclaration typeDecl : d.getNestedTypes()) {
decls.add(typeDecl);
}
for (ConstructorDeclaration ctorDecl : d.getConstructors()) {
decls.add(ctorDecl);
}
for (Declaration decl : decls) decl.accept(this);
d.accept(post);
}
@Override
public void typeCheck() {
for (String type : mExtensions.keySet()) {
int lineNum = mExtensions.get(type);
Declaration d = mCompiler.getDeclaration(type);
if (!(d instanceof ProtocolDeclaration)) {
Compiler.typeError(fullName(), lineNum, type + " is not a Protocol");
}
if (type.equals(fullName())) {
Compiler.typeError(fullName(), lineNum, fullName() + " cannot extend itself");
}
for (String f : ((ProtocolDeclaration) d).mOffsets.keySet()) {
addFunction(f, lineNum);
}
}
for (Declaration declaration : mImplementers.values()) {
// TODO must not include static functions
for (String f : mOffsets.keySet()) {
if (!declaration.hasFunction(f)) {
Compiler.typeError(
declaration.fullName(),
0,
declaration.fullName() + " does not implement " + fullName() + ", missing " + f);
}
}
}
}
static Expression derefFunc(Expression afunc) {
if (afunc instanceof ReferenceExp) {
Declaration func_decl = ((ReferenceExp) afunc).binding;
func_decl = Declaration.followAliases(func_decl);
if (func_decl != null && !func_decl.getFlag(Declaration.IS_UNKNOWN))
afunc = func_decl.getValue();
}
return afunc;
}
@Override
public boolean satisfies(TypeDeclaration type) {
if (type.equals(TypeDeclaration.this)) {
return false;
} else {
Declaration dm = type.getDirectMember(member.getName(), signature, false);
return dm != null && dm.equals(member);
}
}
private void processEvalCondition(DeclarationScopeResolver resolver, EvalCondition element) {
Declaration[] decl = element.getRequiredDeclarations();
for (Declaration aDecl : decl) {
Declaration resolved = resolver.getDeclaration(null, aDecl.getIdentifier());
if (resolved != null && resolved != aDecl) {
element.replaceDeclaration(aDecl, resolved);
}
}
}
/* some straightforward attribute - accessor/mutator checks */
public void testAccessors() {
testSetValidDefinitions();
assertTrue(!dvar.isScopeHolder());
assertTrue(dfn.isScopeHolder());
// assert (dvar.isDefining ());
assertTrue(dvar.getUnqualifiedName().equals(VARID));
}
public static void ajouterDeclaratioInvalide(Declaration declaration) {
if (declaration != null
&& regle.Declaration.estOrdreValide(declaration.getOrdre())
&& !regle.Declaration.getRegle(declaration.getOrdre())
.possedeNumeroDePermisValide(declaration)) {
STATISTIQUE.nbDeclarationsNumeroInvalide++;
}
STATISTIQUE.nbDeclarationsIncompletesOuInvalide++;
}
private JSType lookupTypeByName(
String name, Node n, DeclaredTypeRegistry registry, ImmutableList<String> outerTypeParameters)
throws UnknownTypeException {
String tvar = UniqueNameGenerator.findGeneratedName(name, outerTypeParameters);
if (tvar != null) {
return JSType.fromTypeVar(tvar);
}
Declaration decl = registry.getDeclaration(QualifiedName.fromQualifiedString(name), true);
if (decl == null) {
unknownTypeNames.put(n, name);
throw new UnknownTypeException("Unhandled type: " + name);
}
// It's either a typedef, an enum, a type variable or a nominal type
if (decl.getTypedef() != null) {
return getTypedefType(decl.getTypedef(), registry);
}
if (decl.getEnum() != null) {
return getEnumPropType(decl.getEnum(), registry);
}
if (decl.isTypeVar()) {
howmanyTypeVars++;
return decl.getTypeOfSimpleDecl();
}
if (decl.getNominal() != null) {
return getNominalTypeHelper(decl.getNominal(), n, registry, outerTypeParameters);
}
return JSType.UNKNOWN;
}
@SuppressWarnings("unchecked")
static <E extends Element> E cleanClone(E e) {
E c = (E) e.clone();
c.setCommentBefore(null);
c.setCommentAfter(null);
if (c instanceof Declaration) {
Declaration d = (Declaration) c;
d.setAnnotations(null);
}
return c;
}
@Override
public boolean satisfies(TypeDeclaration type) {
// do not look in ourselves
if (type == TypeDeclaration.this) return false;
Declaration d = type.getDirectMember(name, null, false);
if (d != null && d.isShared() && isResolvable(d)) {
// only accept abstractions
return isAbstraction(d);
} else {
return false;
}
}
@Override
public boolean satisfies(TypeDeclaration type) {
// do not look in ourselves
if (type == TypeDeclaration.this) return false;
Declaration d = type.getDirectMember(name, signature, variadic);
if (d != null && d.isShared() && isResolvable(d)) {
// only accept abstractions if we don't have a signature
return !isAbstraction(d) || signature == null;
} else {
return false;
}
}
@Override
public void visit(Param visitor) {
SymTab symtab = new SymTab();
Declaration dec = new Declaration();
dec.id = visitor.getIdent();
dec.type = visitor.getTipo();
dec.fila = visitor.fila;
st.set(dec);
for (int i = 0; i < st.scopes.size(); i++) {
symtab.scopes.add(i, st.scopes.get(i));
}
visitor.alcance = symtab.scopes;
}
/** Only used for inline- and tail-calls. */
private static void pushArgs(
LambdaExp lexp, Expression[] args, int[] incValues, Compilation comp) {
Declaration param = lexp.firstDecl();
int args_length = args.length;
for (int i = 0; i < args_length; ++i) {
Expression arg = args[i];
if (param.ignorable()) arg.compile(comp, Target.Ignore);
else if (incValues != null
&& (incValues[i] = SetExp.canUseInc(arg, param)) != SetExp.BAD_SHORT) ;
else arg.compileWithPosition(comp, StackTarget.getInstance(param.getType()));
param = param.nextDecl();
}
}
public void visitExecutableDeclaration(ExecutableDeclaration d) {
d.accept(pre);
SortedSet<Declaration> decls = new TreeSet<Declaration>(SourceOrderDeclScanner.comparator);
for (TypeParameterDeclaration tpDecl : d.getFormalTypeParameters()) decls.add(tpDecl);
for (ParameterDeclaration pDecl : d.getParameters()) decls.add(pDecl);
for (Declaration decl : decls) decl.accept(this);
d.accept(post);
}
@RequestMapping(value = "Declaration", method = RequestMethod.POST)
public ModelAndView declaration(Declaration declaration) {
ModelAndView mv = new ModelAndView("jsp/printPage");
declaration = this.declarationService.create(declaration);
for (int i = 0; i < this.instructorList.size(); i++)
instructorList.get(i).setId(declaration.getId());
this.instructorService.create(this.instructorList);
for (int i = 0; i < this.scheduleList.size(); i++)
scheduleList.get(i).setId(declaration.getId());
this.scheduleService.create(this.scheduleList);
for (int i = 0; i < this.budgetList.size(); i++) budgetList.get(i).setId(declaration.getId());
this.budgetService.create(this.budgetList);
for (int i = 0; i < this.hoursList.size(); i++) hoursList.get(i).setId(declaration.getId());
this.hoursService.create(this.hoursList);
mv.addObject("Declaration", declaration);
List<Instructor> getI = this.instructorService.selectById(declaration.getId());
List<Teacher> getT = this.teacherService.selectByInstructorList(getI);
mv.addObject("Instructor", getT);
mv.addObject("InstructorLength", getT.size() + 1);
List<Schedule> getS = this.scheduleService.selectById(declaration.getId());
mv.addObject("Schedule", getS);
List<Budget> getB = this.budgetService.selectById(declaration.getId());
mv.addObject("Budget", getB);
mv.addObject("BudgetLength", getB.size() + 1);
List<Hours> getH = this.hoursService.selectById(declaration.getId());
mv.addObject("Hours", getH);
mv.addObject("HoursLength", getH.size() + 1);
return mv;
}
// TODO Revisar las variables solo dentro del alcance
@Override
public void visit(ExprVar visitor) {
Declaration decl = new Declaration();
decl.id = visitor.getIdent();
decl.fila = visitor.fila;
int scope = st.searchDeclaration(decl.id);
if (scope == SymTab.INVALID_SCOPE) {
System.out.println(
"Error Semantico en fila "
+ decl.fila
+ ", la variable "
+ decl.id
+ " no ha sido declarada");
}
}
@Override
public Map<String, DeclarationWithProximity> getMatchingDeclarations(
Unit unit, String startingWith, int proximity) {
Map<String, DeclarationWithProximity> result =
super.getMatchingDeclarations(unit, startingWith, proximity);
// Inherited declarations hide outer and imported declarations
result.putAll(getMatchingMemberDeclarations(null, startingWith, proximity));
// Local declarations always hide inherited declarations, even if non-shared
for (Declaration d : getMembers()) {
if (isResolvable(d) && !isOverloadedVersion(d) && isNameMatching(startingWith, d)) {
result.put(d.getName(), new DeclarationWithProximity(d, proximity));
}
}
return result;
}
public void testGetFieldValue() throws IntrospectionException {
final FieldExtractor extractor =
cache.getExtractor(Cheese.class, "type", getClass().getClassLoader());
final Pattern pattern = new Pattern(5, new ClassObjectType(Cheese.class));
// Bind the extractor to a decleration
// Declarations know the pattern they derive their value from
final Declaration declaration = new Declaration("typeOfCheese", extractor, pattern);
// Create some facts
final Cheese cheddar = new Cheese("cheddar", 5);
// Check we can extract Declarations correctly
assertEquals("cheddar", declaration.getValue(null, cheddar));
}
/**
* Constructs flow graphs for {@code ast}. It also prints warnings if there are syntactically
* unreachable blocks.
*
* @param ast the AST for which to build flow graphs
* @return whether there were missing blocks
*/
public boolean process(Declaration ast) {
currentBlock = null;
errors = false;
flowGraphs = new HashMap<Implementation, SimpleGraph<Block>>();
ast.eval(this);
return errors;
}
public HashMap<String, SecLevel> getSecurityLevel() {
HashMap<String, SecLevel> secLevel = new HashMap<String, SecLevel>();
if (declaration != null) {
return declaration.getSecurityLevel();
}
return secLevel;
}
public String toString() {
if (declaration != null) {
return declaration.toString() + "\n" + statement.toString();
} else {
return statement.toString();
}
}
@Override
public void see(Implementation implementation, Signature sig, Body body, Declaration tail) {
// initialize graph
currentFlowGraph = new SimpleGraph<Block>();
flowGraphs.put(implementation, currentFlowGraph);
// get blocks by name
blocksByName = new HashMap<String, Block>();
Block b = body.getBlocks();
while (b != null) {
blocksByName.put(b.getName(), b);
currentFlowGraph.node(b);
b = b.getTail();
}
// build graph
body.eval(this);
// check for reachability
seenBlocks = new HashSet<Block>();
b = body.getBlocks();
if (b == null) return;
dfs(b);
while (b != null) {
if (!seenBlocks.contains(b))
Err.warning("" + b.loc() + ": Block " + b.getName() + " is unreachable.");
b = b.getTail();
}
if (tail != null) tail.eval(this);
}
/** @apilevel low-level */
public void flushCache() {
super.flushCache();
getModule_visited = false;
lookupFunction_String_visited = null;
lookupVar_String_visited = null;
lookupVar_String_values = null;
}
public void setPackage(String s) {
s = parser.pack_replace(s);
super.setPackage(s);
const_type.setPackage(s);
const_expr.setPackage(s);
t.typeName = name;
t.setPackage(s);
}
private List<Declaration> getMembers(String name, List<TypeDeclaration> visited) {
if (visited.contains(this)) {
return Collections.emptyList();
} else {
visited.add(this);
List<Declaration> members = new ArrayList<Declaration>();
for (Declaration d : getMembers()) {
if (d.getName() != null && d.getName().equals(name)) {
members.add(d);
}
}
if (members.isEmpty()) {
members.addAll(getInheritedMembers(name));
}
return members;
}
}
