/**
 * The class GamlCompatibilityConverter. Performs a series of transformations between the EObject
 * based representation of GAML models and the representation based on SyntacticElements in GAMA.
 *
 * @author drogoul
 * @since 16 mars 2013
 */
public class GamlCompatibilityConverter {

  static final List<Integer> STATEMENTS_WITH_ATTRIBUTES =
      Arrays.asList(
          ISymbolKind.SPECIES, ISymbolKind.EXPERIMENT, ISymbolKind.OUTPUT, ISymbolKind.MODEL);

  // private static final Set<String> EXTS = GamaFileType.extensionsToFullType.keySet();

  public static SyntacticModelElement buildSyntacticContents(
      final EObject root, final Set<Diagnostic> errors) {
    if (!(root instanceof Model)) {
      return null;
    }
    ModelImpl m = (ModelImpl) root;
    Object[] imps;
    if (m.eIsSet(GamlPackage.MODEL__IMPORTS)) {
      List<Import> imports = m.getImports();
      imps = new Object[imports.size()];
      for (int i = 0; i < imps.length; i++) {
        URI uri = URI.createURI(imports.get(i).getImportURI(), false);
        imps[i] = uri;
      }
    } else {
      imps = null;
    }

    SyntacticModelElement model =
        (SyntacticModelElement) SyntacticFactory.create(MODEL, m, EGaml.hasChildren(m), imps);
    model.setFacet(NAME, convertToLabel(null, m.getName()));
    convStatements(model, EGaml.getStatementsOf(m), errors);
    return model;
  }

  private static boolean doesNotDefineAttributes(final String keyword) {
    SymbolProto p = DescriptionFactory.getProto(keyword, null);
    if (p == null) {
      return true;
    }
    int kind = p.getKind();
    return !STATEMENTS_WITH_ATTRIBUTES.contains(kind);
  }

  private static void addWarning(
      final String message, final EObject object, final Set<Diagnostic> errors) {
    if (!GamaPreferences.WARNINGS_ENABLED.getValue()) {
      return;
    }
    Diagnostic d = new EObjectDiagnosticImpl(Severity.WARNING, "", message, object, null, 0, null);
    errors.add(d);
  }

  private static void addInfo(
      final String message, final EObject object, final Set<Diagnostic> errors) {
    Diagnostic d = new EObjectDiagnosticImpl(Severity.INFO, "", message, object, null, 0, null);
    errors.add(d);
  }

  private static final ISyntacticElement convStatement(
      final ISyntacticElement upper, final Statement stm, final Set<Diagnostic> errors) {
    // We catch its keyword
    String keyword = EGaml.getKey.caseStatement(stm);
    if (keyword == null) {
      throw new NullPointerException(
          "Trying to convert a statement with a null keyword. Please debug to understand the cause.");
    } else if (keyword.equals(ENTITIES)) {
      convertBlock(stm, upper, errors);
      return null;
    } else {
      keyword = convertKeyword(keyword, upper.getKeyword());
    }
    final ISyntacticElement elt = SyntacticFactory.create(keyword, stm, EGaml.hasChildren(stm));

    if (keyword.equals(ENVIRONMENT)) {
      convertBlock(stm, upper, errors);
    } else if (stm instanceof S_Assignment) {
      keyword = convertAssignment((S_Assignment) stm, keyword, elt, stm.getExpr(), errors);
      // } else if ( stm instanceof S_Definition && !SymbolProto.nonTypeStatements.contains(keyword)
      // ) {
    } else if (stm instanceof S_Definition && !DescriptionFactory.isStatementProto(keyword)) {
      S_Definition def = (S_Definition) stm;
      // If we define a variable with this statement
      TypeRef t = (TypeRef) def.getTkey();

      // 20/01/14: The type is now passed plainly
      if (t != null) {
        addFacet(elt, TYPE, convExpr(t, errors), errors);
      }
      // convertType(elt, t, errors);
      if (t != null && doesNotDefineAttributes(upper.getKeyword())) {
        // Translation of "type var ..." to "let var type: type ..." if we are not in a
        // top-level statement (i.e. not in the declaration of a species or an experiment)
        elt.setKeyword(LET);
        // addFacet(elt, TYPE, convertToConstantString(null, keyword), errors);
        keyword = LET;
      } else {
        // Translation of "type1 ID1 (type2 ID2, type3 ID3) {...}" to
        // "action ID1 type: type1 { arg ID2 type: type2; arg ID3 type: type3; ...}"
        Block b = def.getBlock();
        if (b != null && b.getFunction() == null) {
          elt.setKeyword(ACTION);
          // addFacet(elt, TYPE, convertToConstantString(null, keyword), errors);
          keyword = ACTION;
        }
        convertArgs(def.getArgs(), elt, errors);
      }
    } else if (stm instanceof S_Do) {
      // Translation of "stm ID (ID1: V1, ID2:V2)" to "stm ID with:(ID1: V1, ID2:V2)"
      Expression e = stm.getExpr();
      addFacet(elt, ACTION, convertToLabel(e, EGaml.getKeyOf(e)), errors);
      if (e instanceof Function) {
        addFacet(elt, INTERNAL_FUNCTION, convExpr(e, errors), errors);
        Function f = (Function) e;
        Parameters p = f.getParameters();
        if (p != null) {
          addFacet(elt, WITH, convExpr(p, errors), errors);
        } else {
          ExpressionList list = f.getArgs();
          if (list != null) {
            addFacet(elt, WITH, convExpr(list, errors), errors);
          }
        }
      }
    } else if (stm instanceof S_If) {
      // If the statement is "if", we convert its potential "else" part and put it as a child
      // of the syntactic element (as GAML expects it)
      convElse((S_If) stm, elt, errors);
    } else if (stm instanceof S_Action) {
      // Conversion of "action ID (type1 ID1 <- V1, type2 ID2)" to
      // "action ID {arg ID1 type: type1 default: V1; arg ID2 type: type2}"
      convertArgs(((S_Action) stm).getArgs(), elt, errors);
    } else if (stm instanceof S_Reflex) {
      // We add the "when" facet to reflexes and inits if necessary
      S_Reflex ref = (S_Reflex) stm;
      if (ref.getExpr() != null) {
        addFacet(elt, WHEN, convExpr(ref.getExpr(), errors), errors);
      }
    } else if (stm instanceof S_Solve) {
      Expression e = stm.getExpr();
      addFacet(elt, EQUATION, convertToLabel(e, EGaml.getKeyOf(e)), errors);
    }

    // We apply some conversions to the facets expressed in the statement
    convertFacets(stm, keyword, elt, errors);

    if (stm instanceof S_Var && (keyword.equals(CONST) || keyword.equals(VAR))) {
      // We modify the "var", "const" declarations in order to replace the
      // keyword by the type
      IExpressionDescription type = elt.getExpressionAt(TYPE);
      if (type == null) {
        addWarning("Facet 'type' is missing, set by default to 'unknown'", stm, errors);
        elt.setKeyword(UNKNOWN);
      } else {

        // WARNING FALSE (type is now more TypeRef)
        elt.setKeyword(type.toString());
      }
      if (keyword.equals(CONST)) {
        IExpressionDescription constant = elt.getExpressionAt(CONST);
        if (constant != null && constant.toString().equals(FALSE)) {
          addWarning("Is this variable constant or not ?", stm, errors);
        }
        elt.setFacet(CONST, ConstantExpressionDescription.create(true));
      }
    } else if (stm instanceof S_Experiment) {
      // We do it also for experiments, and change their name
      IExpressionDescription type = elt.getExpressionAt(TYPE);
      if (type == null) {
        addInfo("Facet 'type' is missing, set by default to 'gui'", stm, errors);
        elt.setFacet(TYPE, ConstantExpressionDescription.create(GUI_));
      }
      // if ( type == null ) {
      // addWarning("Facet 'type' is missing, set by default to 'gui'", stm, errors);
      // elt.setFacet(TYPE, ConstantExpressionDescription.create(GUI_));
      // elt.setKeyword(GUI_);
      // } else {
      // elt.setKeyword(type);
      // }
      // We modify the names of experiments so as not to confuse them with species
      String name = elt.getName();
      elt.setFacet(TITLE, convertToLabel(null, "Experiment " + name));
      elt.setFacet(NAME, convertToLabel(null, name));
    } else // TODO Change this by implementing only one class of methods (that delegates to
    // others)
    if (keyword.equals(METHOD)) {
      // We apply some conversion for methods (to get the name instead of the "method"
      // keyword)
      String type = elt.getName();
      if (type != null) {
        elt.setKeyword(type);
      }
    } else if (stm instanceof S_Equations) {
      convStatements(elt, EGaml.getEquationsOf((S_Equations) stm), errors);
    }
    // We add the dependencies (only for variable declarations)
    assignDependencies(stm, keyword, elt, errors);
    // We convert the block of statements (if any)
    convertBlock(stm, elt, errors);

    return elt;
  }

  private static void convertBlock(
      final Statement stm, final ISyntacticElement elt, final Set<Diagnostic> errors) {
    Block block = stm.getBlock();
    if (block != null) {
      Expression function = block.getFunction();
      if (function != null) {
        // If it is a function (and not a regular block), we add it as a facet
        addFacet(elt, FUNCTION, convExpr(function, errors), errors);
      } else {
        convStatements(elt, EGaml.getStatementsOf(block), errors);
      }
    }
  }

  private static void addFacet(
      final ISyntacticElement e,
      final String key,
      final IExpressionDescription expr,
      final Set<Diagnostic> errors) {
    if (e.hasFacet(key)) {
      // if ( key.equals(TYPE) ) {
      // GuiUtils.debug("GamlCompatibilityConverter.addFacet:");
      // }
      addWarning(
          "Double definition of facet " + key + ". Only the last one will be considered",
          e.getElement(),
          errors);
    }
    e.setFacet(key, expr);
  }

  private static void assignDependencies(
      final Statement stm,
      final String keyword,
      final ISyntacticElement elt,
      final Set<Diagnostic> errors) {
    // COMPATIBILITY with the definition of environment
    // if ( !SymbolProto.nonTypeStatements.contains(keyword) ) {
    if (!DescriptionFactory.isStatementProto(keyword)) {
      Set<String> s = varDependenciesOf(stm);
      if (s != null && !s.isEmpty()) {
        elt.setFacet(DEPENDS_ON, new StringListExpressionDescription(s));
      }
      // 25/01/14: this test is cancelled for the moment, as the facet type is now defined earlier
      // when dealing
      // with type var_name;
      // if ( !(stm instanceof S_Var) ) {
      // IExpressionDescription type = elt.getExpressionAt(TYPE);
      // if ( type != null ) {
      // if ( type.toString().equals(keyword) ) {
      // addWarning("Duplicate declaration of type", stm, errors);
      // } else {
      // addWarning("Conflicting declaration of type (" + type + " and " + keyword +
      // "), only the last one will be considered", stm, errors);
      // }
      // }
      // }
    }
  }

  private static void convElse(
      final S_If stm, final ISyntacticElement elt, final Set<Diagnostic> errors) {
    EObject elseBlock = stm.getElse();
    if (elseBlock != null) {
      ISyntacticElement elseElt =
          SyntacticFactory.create(ELSE, elseBlock, EGaml.hasChildren(elseBlock));
      if (elseBlock instanceof Statement) {
        elseElt.addChild(convStatement(elt, (Statement) elseBlock, errors));
      } else {
        convStatements(elseElt, EGaml.getStatementsOf((Block) elseBlock), errors);
      }
      elt.addChild(elseElt);
    }
  }

  private static void convertArgs(
      final ActionArguments args, final ISyntacticElement elt, final Set<Diagnostic> errors) {
    if (args != null) {
      for (ArgumentDefinition def : EGaml.getArgsOf(args)) {
        ISyntacticElement arg = SyntacticFactory.create(ARG, def, false);
        addFacet(arg, NAME, convertToLabel(null, def.getName()), errors);
        EObject type = def.getType();
        addFacet(arg, TYPE, convExpr(type, errors), errors);
        // addFacet(arg, TYPE, convertToConstantString(null, EGaml.getKey.caseTypeRef(type)),
        // errors);
        // convertType(arg, type, errors);
        Expression e = def.getDefault();
        if (e != null) {
          addFacet(arg, DEFAULT, convExpr(e, errors), errors);
        }
        elt.addChild(arg);
      }
    }
  }

  private static String convertAssignment(
      final S_Assignment stm,
      String keyword,
      final ISyntacticElement elt,
      final Expression expr,
      final Set<Diagnostic> errors) {
    IExpressionDescription value = convExpr(stm.getValue(), errors);
    if (keyword.endsWith("<-") || keyword.equals(SET)) {
      // Translation of "container[index] <- value" to
      // "put item: value in: container at: index"
      // 20/1/14: Translation of container[index] +<- value" to
      // "add item: value in: container at: index"
      if (expr instanceof Access && expr.getOp().equals("[")) {
        String kw = keyword.equals("+<-") ? ADD : PUT;
        String to = keyword.equals("+<-") ? TO : IN;
        elt.setKeyword(kw);
        addFacet(elt, ITEM, value, errors);
        addFacet(elt, to, convExpr(expr.getLeft(), errors), errors);
        List<Expression> args = EGaml.getExprsOf(((Access) expr).getArgs());
        if (args.size() == 0) {
          // Add facet all: true when no index is provided
          addFacet(elt, ALL, ConstantExpressionDescription.create(true), errors);
        } else {
          if (args.size() == 1) { // Integer index
            addFacet(elt, AT, convExpr(args.get(0), errors), errors);
          } else { // Point index
            IExpressionDescription p =
                new OperatorExpressionDescription(
                    POINT, convExpr(args.get(0), errors), convExpr(args.get(1), errors));
            addFacet(elt, AT, p, errors);
          }
        }
        keyword = kw;
      } else {
        // Translation of "var <- value" to "set var value: value"
        elt.setKeyword(SET);
        addFacet(elt, VALUE, value, errors);
        keyword = SET;
      }
    } else if (keyword.startsWith("<<") || keyword.equals("<+")) {
      // Translation of "container <+ item" or "container << item" to "add item: item to: container"
      // 08/01/14: Addition of the "<<+" (add all)
      elt.setKeyword(ADD);
      addFacet(elt, TO, convExpr(expr, errors), errors);
      addFacet(elt, ITEM, value, errors);
      if (keyword.equals("<<+")) {
        addFacet(elt, ALL, ConstantExpressionDescription.create(true), errors);
      }
      keyword = ADD;
    } else if (keyword.startsWith(">>") || keyword.equals(">-")) {
      // Translation of "container >> item" or "container >- item" to
      // "remove item: item from: container"
      // 08/01/14: Addition of the ">>-" keyword (remove all)
      elt.setKeyword(REMOVE);
      // 20/01/14: Addition of the access [] to remove from the index
      if (expr instanceof Access
          && expr.getOp().equals("[")
          && EGaml.getExprsOf(((Access) expr).getArgs()).size() == 0) {
        addFacet(elt, FROM, convExpr(expr.getLeft(), errors), errors);
        addFacet(elt, INDEX, value, errors);
      } else {
        addFacet(elt, FROM, convExpr(expr, errors), errors);
        addFacet(elt, ITEM, value, errors);
      }
      if (keyword.equals(">>-")) {
        addFacet(elt, ALL, ConstantExpressionDescription.create(true), errors);
      }
      keyword = REMOVE;
    } else if (keyword.equals(EQUATION_OP)) {
      // conversion of left member (either a var or a function)
      IExpressionDescription left = null;
      if (expr instanceof VariableRef) {
        left = new OperatorExpressionDescription(ZERO, convExpr(expr, errors));
      } else {
        left = convExpr(expr, errors);
      }
      addFacet(elt, EQUATION_LEFT, left, errors);
      // Translation of right member
      addFacet(elt, EQUATION_RIGHT, value, errors);
    }
    return keyword;
  }

  private static void convertFacets(
      final Statement stm,
      final String keyword,
      final ISyntacticElement elt,
      final Set<Diagnostic> errors) {
    SymbolProto p = DescriptionFactory.getProto(keyword, null);
    for (Facet f : EGaml.getFacetsOf(stm)) {
      String fname = EGaml.getKey.caseFacet(f);

      // We change the "<-" and "->" symbols into full names
      if (fname.equals("<-")) {
        fname = keyword.equals(LET) || keyword.equals(SET) ? VALUE : INIT;
      } else if (fname.equals("->")) {
        fname = FUNCTION;
      }

      // We compute (and convert) the expression attached to the facet
      boolean label = p == null ? false : p.isLabel(fname);
      IExpressionDescription fexpr = convExpr(f, label, errors);
      addFacet(elt, fname, fexpr, errors);
    }

    // We add the "default" (or omissible) facet to the syntactic element
    String def = stm.getFirstFacet();
    if (def != null) {
      if (def.endsWith(":")) {
        def = def.substring(0, def.length() - 1);
      }
    } else {
      def = DescriptionFactory.getOmissibleFacetForSymbol(keyword);
    }
    if (def != null && !def.isEmpty() && !elt.hasFacet(def)) {
      IExpressionDescription ed = findExpr(stm, errors);
      if (ed != null) {
        elt.setFacet(def, ed);
      }
    }
  }

  private static String convertKeyword(final String k, final String upper) {
    String keyword = k;
    if ((upper.equals(BATCH) || upper.equals(EXPERIMENT)) && keyword.equals(SAVE)) {
      keyword = SAVE_BATCH;
    } else if (upper.equals(OUTPUT) && keyword.equals(FILE)) {
      keyword = OUTPUT_FILE;
    } else if (upper.equals(DISPLAY) || upper.equals(POPULATION)) {
      if (keyword.equals(SPECIES)) {
        keyword = POPULATION;
      } else if (keyword.equals(GRID)) {
        keyword = GRID_POPULATION;
      }
    }
    return keyword;
  }

  private static final IExpressionDescription convExpr(
      final EObject expr, final Set<Diagnostic> errors) {
    if (expr == null) {
      return null;
    }
    IExpressionDescription result = EcoreBasedExpressionDescription.create(expr, errors);
    return result;
  }

  private static final IExpressionDescription convExpr(
      final Facet facet, final boolean label, final Set<Diagnostic> errors) {
    if (facet != null) {
      Expression expr = facet.getExpr();
      if (expr != null) {
        return label ? convertToLabel(expr, EGaml.getKeyOf(expr)) : convExpr(expr, errors);
      }
      String name = facet.getName();
      // TODO Verify the use of "facet"
      if (name != null) {
        return convertToLabel(null, name);
      }
    }
    return null;
  }

  static final IExpressionDescription convertToLabel(final EObject target, final String string) {
    IExpressionDescription ed = LabelExpressionDescription.create(string);
    ed.setTarget(target);
    if (target != null) {
      DescriptionFactory.setGamlDocumentation(target, ed.getExpression());
    }
    return ed;
  }

  static final void convStatements(
      final ISyntacticElement elt,
      final List<? extends Statement> ss,
      final Set<Diagnostic> errors) {
    for (final Statement stm : ss) {
      ISyntacticElement child = convStatement(elt, stm, errors);
      if (child != null) {
        elt.addChild(child);
      }
    }
  }

  private static final IExpressionDescription findExpr(
      final Statement stm, final Set<Diagnostic> errors) {
    if (stm == null) {
      return null;
    }
    // The order below should be important
    String name = EGaml.getNameOf(stm);
    if (name != null) {
      return convertToLabel(stm, name);
    }
    Expression expr = stm.getExpr();
    if (expr != null) {
      return convExpr(expr, errors);
    }
    return null;
  }

  private static final Set<String> varDependenciesOf(final Statement s) {
    Set<String> list = new HashSet();
    for (Facet facet : EGaml.getFacetsOf(s)) {
      Expression expr = facet.getExpr();
      if (expr != null) {
        if (expr instanceof VariableRef) {
          list.add(EGaml.getKey.caseVariableRef((VariableRef) expr));
        } else {
          for (TreeIterator<EObject> tree = expr.eAllContents(); tree.hasNext(); ) {
            EObject obj = tree.next();
            if (obj instanceof VariableRef) {
              list.add(EGaml.getKey.caseVariableRef((VariableRef) obj));
            }
          }
        }
      }
    }
    if (list.isEmpty()) {
      return null;
    }
    return list;
  }
}
예제 #2
0
/**
 * The Class FsmStateStatement.
 *
 * @author drogoul
 */
@symbol(
    name = FsmStateStatement.STATE,
    kind = ISymbolKind.BEHAVIOR,
    with_sequence = true,
    unique_name = true)
@inside(
    symbols = IKeyword.FSM,
    kinds = {ISymbolKind.SPECIES, ISymbolKind.EXPERIMENT, ISymbolKind.MODEL})
@facets(
    value = {
      @facet(
          name = FsmStateStatement.INITIAL,
          type = IType.BOOL,
          optional = true,
          doc = @doc("specifies whether the state is the initial one (default value = false)")),
      @facet(
          name = FsmStateStatement.FINAL,
          type = IType.BOOL,
          optional = true,
          doc =
              @doc(
                  "specifies whether the state is a final one (i.e. there is no transition from this state to another state) (default value= false)")),
      @facet(
          name = IKeyword.NAME,
          type = IType.ID,
          optional = false,
          doc = @doc("the identifier of the state"))
    },
    omissible = IKeyword.NAME)
@validator(StateValidator.class)
@doc(
    value =
        "A state, like a reflex, can contains several statements that can be executed at each time step by the agent.",
    usages = {
      @usage(
          value =
              "Here is an exemple integrating 2 states and the statements in the FSM architecture:",
          examples = {
            @example(value = "	state s_init initial: true {", isExecutable = false),
            @example(value = "		enter { write \"Enter in\" + state; }", isExecutable = false),
            @example(value = "			write \"Enter in\" + state;", isExecutable = false),
            @example(value = "		}", isExecutable = false),
            @example(value = "", isExecutable = false),
            @example(value = "		write state;", isExecutable = false),
            @example(value = "", isExecutable = false),
            @example(value = "		transition to: s1 when: (cycle > 2) {", isExecutable = false),
            @example(value = "			write \"transition s_init -> s1\";", isExecutable = false),
            @example(value = "		}", isExecutable = false),
            @example(value = "", isExecutable = false),
            @example(value = "		exit {", isExecutable = false),
            @example(value = "			write \"EXIT from \"+state;", isExecutable = false),
            @example(value = "		}", isExecutable = false),
            @example(value = "	}", isExecutable = false),
            @example(value = "	state s1 {", isExecutable = false),
            @example(value = "", isExecutable = false),
            @example(value = "	enter {write 'Enter in '+state;}", isExecutable = false),
            @example(value = "", isExecutable = false),
            @example(value = "	write state;", isExecutable = false),
            @example(value = "", isExecutable = false),
            @example(value = "	exit {write 'EXIT from '+state;}", isExecutable = false),
            @example(value = "}", isExecutable = false)
          })
    },
    see = {FsmStateStatement.ENTER, FsmStateStatement.EXIT, FsmTransitionStatement.TRANSITION})
public class FsmStateStatement extends AbstractStatementSequence {

  static List<String> AllowedArchitectures =
      Arrays.asList(
          IKeyword.USER_CONTROLLED,
          IKeyword.USER_FIRST,
          IKeyword.USER_INIT,
          IKeyword.USER_LAST,
          IKeyword.USER_ONLY);

  public static class StateValidator implements IDescriptionValidator {

    /**
     * Method validate()
     *
     * @see msi.gaml.compilation.IDescriptionValidator#validate(msi.gaml.descriptions.IDescription)
     */
    @Override
    public void validate(final IDescription description) {
      // Verify that the state is inside a species with fsm control
      SpeciesDescription species = description.getSpeciesContext();
      String keyword = description.getKeyword();
      IArchitecture control = species.getControl();
      // String control = species.getControlName();
      if (!(control instanceof FsmArchitecture)) {
        if (keyword.equals(STATE)) {
          description.error(
              "A state can only be defined in an fsm-controlled or user-controlled species",
              IGamlIssue.WRONG_CONTEXT);
          return;
        } else if (control.getClass() == FsmArchitecture.class) {
          description.error(
              "A "
                  + description.getKeyword()
                  + " can only be defined in a user-controlled species (one of"
                  + AllowedArchitectures
                  + ")",
              IGamlIssue.WRONG_CONTEXT);
          return;
        }
      }
      if (!Assert.nameIsValid(description)) {
        return;
      }
      Facets ff = description.getFacets();
      IExpression expr = ff.getExpr(INITIAL);
      if (IExpressionFactory.TRUE_EXPR.equals(expr)) {
        assertNoOther(description, INITIAL);
      } else {
        expr = ff.getExpr(FINAL);
        if (IExpressionFactory.TRUE_EXPR.equals(expr)) {
          assertNoOther(description, FINAL);
        } else {
          assertAtLeastOne(description, INITIAL);
        }
      }
    }

    private void assertNoOther(final IDescription desc, final String facet) {
      final IDescription sd = desc.getEnclosingDescription();
      if (!(sd instanceof SpeciesDescription)) {
        return;
      }
      for (final IDescription child : ((SpeciesDescription) sd).getBehaviors()) {
        if (child.equals(desc) || !child.getKeyword().equals(STATE)) {
          continue;
        }
        IExpression expr = child.getFacets().getExpr(facet);
        if (IExpressionFactory.TRUE_EXPR.equals(expr)) {
          final String error = "Only one " + facet + " state is allowed.";
          child.error(error, IGamlIssue.DUPLICATE_DEFINITION, facet, TRUE);
        }
      }
    }

    private void assertAtLeastOne(final IDescription desc, final String facet) {
      final IDescription sd = desc.getEnclosingDescription();
      if (!(sd instanceof SpeciesDescription)) {
        return;
      }
      for (final IDescription child : ((SpeciesDescription) sd).getBehaviors()) {
        String s = child.getKeyword();
        if (s.equals(STATE) || s.equals(USER_PANEL)) {
          final IExpression expr = child.getFacets().getExpr(facet);
          if (expr == null) {
            continue;
          }
          if (IExpressionFactory.TRUE_EXPR.equals(expr)) {
            return;
          }
        }
      }
      final String error = "No " + facet + " state defined";
      sd.error(
          error,
          IGamlIssue.MISSING_DEFINITION,
          sd.getUnderlyingElement(null),
          desc.getKeyword(),
          facet,
          TRUE);
    }
  }

  public static final String STATE_MEMORY = "state_memory";

  public static final String INITIAL = "initial";
  public static final String FINAL = "final";
  protected static final String STATE = "state";
  public static final String ENTER = "enter";
  public static final String EXIT = "exit";
  private FsmEnterStatement enterActions = null;
  private FsmExitStatement exitActions = null;
  List<FsmTransitionStatement> transitions = new ArrayList();
  private int transitionsSize;
  boolean isInitial;
  boolean isFinal;

  public FsmStateStatement(final IDescription desc) {
    super(desc);
    setName(getLiteral(IKeyword.NAME)); // A VOIR
    isInitial = Cast.asBool(null, getLiteral(FsmStateStatement.INITIAL));
    isFinal = Cast.asBool(null, getLiteral(FsmStateStatement.FINAL));
  }

  @Override
  public void setChildren(final List<? extends ISymbol> children) {
    for (final ISymbol c : children) {
      if (c instanceof FsmEnterStatement) {
        enterActions = (FsmEnterStatement) c;
      } else if (c instanceof FsmExitStatement) {
        exitActions = (FsmExitStatement) c;
      } else if (c instanceof FsmTransitionStatement) {
        transitions.add((FsmTransitionStatement) c);
      }
    }
    children.remove(enterActions);
    children.remove(exitActions);
    children.removeAll(transitions);
    transitionsSize = transitions.size();
    super.setChildren(children);
  }

  protected boolean beginExecution(final IScope scope) throws GamaRuntimeException {
    final IAgent agent = scope.getAgentScope();
    if (scope.interrupted()) {
      return false;
    }
    final Boolean enter = (Boolean) agent.getAttribute(ENTER);
    Map<String, Object> memory = (Map) agent.getAttribute(STATE_MEMORY);
    if (enter || memory == null) {
      memory = new THashMap();
      agent.setAttribute(STATE_MEMORY, memory);
    } else {
      for (final Map.Entry<String, Object> entry : memory.entrySet()) {
        scope.addVarWithValue(entry.getKey(), entry.getValue());
      }
    }
    if (enter) {
      if (enterActions != null) {
        enterActions.executeOn(scope);
      }
      if (agent.dead()) {
        return false;
      }
      agent.setAttribute(ENTER, false);
    }
    return true;
  }

  protected Object bodyExecution(final IScope scope) throws GamaRuntimeException {
    return super.privateExecuteIn(scope);
  }

  protected String evaluateTransitions(final IScope scope) throws GamaRuntimeException {
    final IAgent agent = scope.getAgentScope();
    for (int i = 0; i < transitionsSize; i++) {
      final FsmTransitionStatement transition = transitions.get(i);

      if (transition.evaluatesTrueOn(scope)) {
        final String futureState = transition.getName();
        haltOn(scope);
        transition.executeOn(scope);
        scope.setAgentVarValue(agent, STATE, futureState);
        return futureState;
      }
    }
    if (!agent.dead()) {
      scope.saveAllVarValuesIn((Map) agent.getAttribute(STATE_MEMORY));
    }
    return name;
  }

  @Override
  public Object privateExecuteIn(final IScope scope) throws GamaRuntimeException {
    if (!beginExecution(scope)) {
      return null;
    }
    bodyExecution(scope);
    return evaluateTransitions(scope);
  }

  public void haltOn(final IScope scope) throws GamaRuntimeException {
    if (exitActions != null) {
      exitActions.executeOn(scope);
    }
  }

  public FsmExitStatement getExitStatement() {
    return exitActions;
  }

  public boolean hasExitActions() {
    return exitActions != null;
  }

  public boolean isInitial() {
    return isInitial;
  }

  public boolean isFinal() {
    return isFinal;
  }
}