/// /////////////////////////////////////////////////////////
public void AfterEval(C2iExpression formule, CResultAErreur result)
{
if (m_debugger != null)
{
m_debugger.AfterEval(formule, result);
}
}
/// //////////////////////////////////////////
private CResultAErreur GetSourceEtChampFinal(C2iExpression expression, CContexteEvaluationExpression ctx, ref object source, ref C2iExpressionChamp expressionChamp)
{
CResultAErreur result = CResultAErreur.True;
expressionChamp = expression as C2iExpressionChamp;
if (expressionChamp != null)
{
return(result);
}
C2iExpressionObjet expObjet = expression as C2iExpressionObjet;
if (expObjet == null)
{
result.EmpileErreur(I.T("Impossible to affect a value to @1|133", expression.GetString()));
}
result = expObjet.Parametres2i[0].Eval(ctx);
if (!result || result == null)
{
return(result);
}
ctx.PushObjetSource(result.Data, false);
source = result.Data;
result = GetSourceEtChampFinal(expObjet.Parametres2i[1], ctx, ref source, ref expressionChamp);
ctx.PopObjetSource(false);
return(result);
}
public static void SetInfo(C2iExpression formule, CInfo2iExpression info)
{
if (formule != null)
{
m_cache[formule.GetType()] = info;
}
}
//-----------------------------------------------
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
if (FormuleFinale == null)
{
result = RefreshFormuleFinale();
if (!result)
{
return(result);
}
}
if (FormuleFinale != null)
{
C2iExpression formuleToEval = FormuleFinale;
if (Debug)
{
formuleToEval = new C2iExpressionDebug();
formuleToEval.Parametres.Add(FormuleFinale);
}
return(formuleToEval.Eval(ctx));
}
result.EmpileErreur(I.T("Can not create formula from graphical|20086"));
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur VerifieParametres()
{
CResultAErreur result = base.VerifieParametres();
if (!result)
{
return(result);
}
if (Parametres.Count < 2)
{
result.EmpileErreur(I.T("Incorrect number of parameters|161"));
return(result);
}
C2iExpression expType = Parametres2i[1];
if (expType is C2iExpressionConstante)
{
string strType = ((C2iExpressionConstante)expType).Valeur.ToString();
if (CActivatorSurChaine.GetType(strType, true) == null)
{
result.EmpileErreur(I.T("The type @1 doesn't exist|162", strType));
}
}
if (Parametres.Count >= 3)
{
if (!(Parametres2i[2] is C2iExpressionVrai) &&
!(Parametres2i[2] is C2iExpressionFaux))
{
result.EmpileErreur(I.T("The third parameter must be 'true()' or 'false()'|163"));
}
}
return(result);
}
/// ///////////////////////////////////////////////////////////
public void SetParametre(int nParametre, C2iExpression parametre)
{
while (nParametre >= m_listeParametres.Count)
{
m_listeParametres.Add(null);
}
m_listeParametres[nParametre] = parametre;
}
/// /////////////////////////////////////////////////////////
public bool BeforeEval(C2iExpression formule)
{
if (m_debugger != null)
{
return(m_debugger.BeforeEval(formule));
}
return(false);
}
public static CInfo2iExpression GetCache(C2iExpression formule)
{
if (formule != null)
{
CInfo2iExpression info = null;
m_cache.TryGetValue(formule.GetType(), out info);
return(info);
}
return(null);
}
///////////////////////////////////////////////////
public static string GetPseudoCode(C2iExpression exp)
{
if (exp == null)
{
return("");
}
CStringSerializer ser = new CStringSerializer(ModeSerialisation.Ecriture);
exp.GetPseudoCode(ser);
string strRetour = new CStringSerializerCompresseur().Compress(ser.String);
return(strRetour);
}
/// ///////////////////////////////////////////////////////////
public static void RegisterAllInAssembly()
{
foreach (Type tp in typeof(C2iExpression).Assembly.GetTypes())
{
if (tp.IsSubclassOf(typeof(C2iExpression)) && !tp.IsAbstract)
{
#if PDA
C2iExpression exp = (C2iExpression)Activator.CreateInstance(tp);
#else
C2iExpression exp = (C2iExpression)Activator.CreateInstance(tp, new object[0]);
#endif
CAllocateur2iExpression.Register2iExpression(exp.IdExpression, tp);
}
}
}
public static CDessineurExpressionGraphique GetDessineur(CRepresentationExpressionGraphique expression)
{
C2iExpression formule = expression.Formule;
CDessineurExpressionGraphique dessineur = null;
if (formule != null)
{
Type tp = formule.GetType();
while (tp != null)
{
if (m_dicDessineurs.TryGetValue(tp, out dessineur))
return dessineur;
tp = tp.BaseType;
}
}
return DefaultInstance;
}
//-----------------------------------------------
public CRepresentationExpressionGraphique FindFormule(C2iExpression formule)
{
if (formule == null)
{
return(null);
}
string strSearch = formule.GetString().ToUpper().Trim();
foreach (CRepresentationExpressionGraphique r in m_listeRepresentations)
{
if (r.Formule != null && r.Formule.GetString().ToUpper().Trim() == strSearch)
{
return(r);
}
}
return(null);
}
//-----------------------------------------------
public CResultAErreur RefreshFormuleFinale()
{
m_formuleFinale = null;
CResultAErreur result = CResultAErreur.True;
C2iExpressionBegin formule = new C2iExpressionBegin();
foreach (CDefinitionProprieteDynamiqueVariableFormule def in m_listeVariables)
{
C2iExpressionVariable var = new C2iExpressionVariable();
C2iExpression exp = new C2iExpressionChamp();
((C2iExpressionChamp)exp).DefinitionPropriete = def;
var.Parametres.Add(exp);
exp = new C2iExpressionConstante(def.TypeDonnee.TypeDotNetNatif.ToString());
var.Parametres.Add(exp);
if (def.TypeDonnee.IsArrayOfTypeNatif)
{
exp = new C2iExpressionVrai();
var.Parametres.Add(exp);
}
formule.Parametres.Add(var);
}
CRepresentationExpressionGraphique graf = StartPoint;
if (graf == null)
{
result.EmpileErreur(I.T("No start point|20103"));
return(result);
}
while (graf != null)
{
result = graf.RefreshParametres();
if (!result)
{
return(result);
}
if (graf.Formule != null)
{
formule.Parametres.Add(graf.Formule);
}
graf = graf.Next;
}
m_formuleFinale = formule;
return(CResultAErreur.True);
}
/// /////////////////////////////////////////////////
public override CResultAErreur AnalyseChaine(string strChaine)
{
CResultAErreur result = base.AnalyseChaine(strChaine);
if (result)
{
C2iExpression expression = (C2iExpression)result.Data;
if (expression != null)
{
expression.SetTypeObjetInterroge(
m_contexteAnalyse.ObjetAnalyse,
m_contexteAnalyse);
}
//Vérifie que tous les champs ont un type de donnée connu
//(ce qui indique que les champs sont connus)
foreach (C2iExpressionChamp expChamp in expression.ExtractExpressionsType(typeof(C2iExpressionChamp)))
{
if (expChamp.DefinitionPropriete == null)
{
result.EmpileErreur(I.T("One field of formula doesn't exist|141"));
}
else if (expChamp.TypeDonnee == null)
{
if (m_contexteAnalyse != null && m_contexteAnalyse.GetVariable(expChamp.DefinitionPropriete.NomPropriete) == null)
{
result.EmpileErreur(I.T("The @1 field doesn't exist|107", expChamp.DefinitionPropriete.Nom));
}
else
{
expChamp.DefinitionPropriete = m_contexteAnalyse.GetVariable(expChamp.DefinitionPropriete.NomPropriete);
}
}
}
result = expression.VerifieParametres();
if (!result)
{
return(result);
}
result.Data = expression;
}
return(result);
}
/// ///////////////////////////////////////////////////////////
public virtual CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
int nNb = Parametres.Count;
serializer.TraiteInt(ref nNb);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (C2iExpression expression in Parametres2i)
{
expression.GetPseudoCode(serializer);
}
break;
case ModeSerialisation.Lecture:
m_listeParametres.Clear();
for (int n = 0; n < nNb; n++)
{
C2iExpression expression = FromPseudoCode(serializer);
m_listeParametres.Add(expression);
}
break;
}
if (nVersion >= 1)
{
serializer.TraiteString(ref m_strCaracteresControlesAvantString);
if (m_strCaracteresControlesAvantString.Length > 3)
{
m_strCaracteresControlesAvantString = m_strCaracteresControlesAvantString.Substring(0, 3);
}
}
return(result);
}
///////////////////////////////////////////////////
protected static C2iExpression FromPseudoCode(C2iSerializer serializer)
{
string strType = "";
try
{
serializer.TraiteString(ref strType);
C2iExpression exp = (C2iExpression) new CAllocateur2iExpression().GetExpression(strType);
if (exp == null)
{
return(null);
}
if (!exp.Serialize(serializer))
{
return(null);
}
return(exp);
}
catch
{
return(null);
}
}
/// //////////////////////////////////// /////////////////////////////////
private CResultAErreur GetValeurObjet(CContexteEvaluationExpression ctx, object source, C2iExpression expressionAEvaluer)
{
CResultAErreur result = CResultAErreur.True;
ctx.PushObjetSource(source, false);
try
{
result = expressionAEvaluer.Eval(ctx);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
ctx.PopObjetSource(false);
}
return(result);
}
public CFormuleNommee(string strLibelle, C2iExpression formule)
: this()
{
Libelle = strLibelle;
m_formule = formule;
}
//----------------------------------
public CRepresentationExpressionGraphique(C2iExpression formule)
{
Size = new Size(80, 50);
m_formule = formule;
}
/// ///////////////////////////////////////////////////////////
public override CResultAErreur VerifieParametres()
{
CResultAErreur result = CResultAErreur.True;
if (m_definitionMethode != null)
{
if (ObjetPourAnalyseSourceConnu == null)
{
return(result);
}
CInfoMethodeDynamique info = new CInfoMethodeDynamique(ObjetPourAnalyseSourceConnu.TypeResultatExpression.TypeDotNetNatif, DefinitionMethode.NomProprieteSansCleTypeChamp);
CInfoParametreMethodeDynamique[] parametres = info.InfosParametres;
if (parametres.Length != Parametres.Count)
{
result.EmpileErreur(I.T("The number parameters @1 method is incorrect|121", DefinitionMethode.NomProprieteSansCleTypeChamp));
return(result);
}
int nParam = 0;
foreach (CInfoParametreMethodeDynamique defPar in parametres)
{
C2iExpression expression = Parametres2i[nParam];
if (expression != null && expression.TypeDonnee == null)
{
result.EmpileErreur(I.T("the @1 parameter is invalide in method @2|20125",
expression.GetString(),
DefinitionMethode.NomProprieteSansCleTypeChamp));
}
else if (expression == null ||
expression.GetType() != typeof(C2iExpressionNull) &&
!expression.TypeDonnee.CanConvertTo(new CTypeResultatExpression(defPar.TypeParametre, false)))
{
result.EmpileErreur(I.T("The @1 method parameters doesn't correspond|122", DefinitionMethode.NomProprieteSansCleTypeChamp));
break;
}
nParam++;
}
}
else if (DefinitionFonction != null)
{
IEnumerable <CParametreFonctionDynamique> parametres = DefinitionFonction.ParametresDeLaFonction;
if (parametres.Count() != Parametres.Count)
{
result.EmpileErreur(I.T("The number parameters @1 method is incorrect|121", DefinitionFonction.NomProprieteSansCleTypeChamp));
return(result);
}
int nParam = 0;
foreach (CParametreFonctionDynamique defPar in parametres)
{
C2iExpression expression = Parametres2i[nParam];
if (expression != null && expression.TypeDonnee == null)
{
result.EmpileErreur(I.T("the @1 parameter is invalide in method @2|20125",
expression.GetString(),
defPar.Nom));
}
else if (expression == null ||
expression.GetType() != typeof(C2iExpressionNull) &&
!expression.TypeDonnee.CanConvertTo(defPar.TypeResultatExpression))
{
result.EmpileErreur(I.T("The @1 method parameters doesn't correspond|122", DefinitionFonction.NomProprieteSansCleTypeChamp));
break;
}
nParam++;
}
}
else if (m_strNomMethode.Length > 0)
{
result.EmpileErreur(I.T("Unknown method @1|20126", m_strNomMethode));
}
else
{
result.EmpileErreur(I.T("Unknown method @1|20126", DefinitionFonction.NomProprieteSansCleTypeChamp));
}
return(result);
}
private void ShowInterfaceLienParametre(
CRepresentationExpressionGraphique source,
CRepresentationExpressionGraphique dest)
{
Dictionary <int, CMenuNumero> dicMenus = new Dictionary <int, CMenuNumero>();
if (source == null || dest == null)
{
return;
}
if (m_menuNumeroParametre.Items.Count == 0)
{
//Création initiale des sous menus
for (int n = 0; n < 20; n++)
{
CMenuNumero menu = new CMenuNumero(n.ToString(), n);
m_menuNumeroParametre.Items.Add(menu);
menu.Click += new EventHandler(menuNumero_Click);
}
}
foreach (ToolStripMenuItem item in m_menuNumeroParametre.Items)
{
CMenuNumero num = item as CMenuNumero;
if (num != null)
{
dicMenus[num.Numero] = num;
}
}
C2iExpressionAnalysable expAn = dest.Formule == null ? null : dest.Formule as C2iExpressionAnalysable;
if (expAn != null)
{
CInfo2iExpression info = null;
info = expAn.GetInfos();
CInfo2iDefinitionParametres[] infosParams = info.InfosParametres;
for (int n = 0; n < 20; n++)
{
string strNom = info.GetNomParametre(n);
if (strNom.Trim() == "")
{
dicMenus[n].Visible = false;
}
else
{
dicMenus[n].Visible = true;
dicMenus[n].Text = strNom;
}
}
sc2i.expression.C2iExpression[] parametres = dest.Formule.Parametres2i;
foreach (ToolStripMenuItem item in m_menuNumeroParametre.Items)
{
int nPos = item.Text.IndexOf('(');
if (nPos > 0)
{
item.Text = item.Text.Substring(0, nPos).Trim();
}
CMenuNumero numero = item as CMenuNumero;
if (numero != null)
{
if (numero.Numero < parametres.Length)
{
sc2i.expression.C2iExpression exp = parametres[numero.Numero];
if (exp != null)
{
item.Text += " (" + exp.GetString() + ")";
}
}
}
}
m_sourceLienParametre = source;
m_destLienParametre = dest;
m_menuNumeroParametre.Show(Cursor.Position);
}
}
//--------------------------------------------------
/// <summary>
/// crée les éléments graphiques d'une formule
/// </summary>
/// <param name="formule"></param>
public void InitFromFormule(C2iExpression formule)
{
m_listeRepresentations.Clear();
m_listeVariables.Clear();
if (formule == null)
{
return;
}
ArrayList lst = formule.ExtractExpressionsType(typeof(C2iExpressionVariable));
foreach (C2iExpressionVariable variable in lst)
{
if (variable.Parametres.Count > 0)
{
C2iExpressionChamp champ = variable.Parametres[0] as C2iExpressionChamp;
if (champ != null)
{
CDefinitionProprieteDynamiqueVariableFormule def = champ.DefinitionPropriete as CDefinitionProprieteDynamiqueVariableFormule;
if (def != null)
{
m_listeVariables.Add(def);
}
}
}
}
C2iExpressionBegin begin = formule as C2iExpressionBegin;
m_strIdStartPoint = "";
int nX = 100;
int nY = 20;
if (begin != null)
{
CRepresentationExpressionGraphique previous = null;
foreach (C2iExpression action in begin.Parametres)
{
if (!(action is C2iExpressionVariable))
{
CRepresentationExpressionGraphique rep = new CRepresentationExpressionGraphique();
rep.Position = new Point(nX, nY);
AddChild(rep);
rep.Parent = this;
rep.Formule = action;
nY = rep.RectangleAbsolu.Bottom;
foreach (CRepresentationExpressionGraphique repTmp in m_listeRepresentations)
{
if (repTmp.RectangleAbsolu.Bottom > nY)
{
nY = rep.RectangleAbsolu.Bottom;
}
}
nY += 20;
if (previous == null)
{
StartPoint = rep;
}
else
{
previous.Next = rep;
}
previous = rep;
}
}
}
else
{
CRepresentationExpressionGraphique rep = new CRepresentationExpressionGraphique();
rep.Position = new Point(nX, nY);
AddChild(rep);
rep.Parent = this;
rep.Formule = formule;
StartPoint = rep;
}
}
