Entry lhs = Entry.Create(TermsConverter.ToTerms("int(f,x,a,b)"));
Entry rhs = Entry.Create(TermsConverter.ToTerms("Int(f,x,a,b)")); ;
Entry def = context.AddDefinition(lhs, rhs);

Entry lhs = Entry.Create(TermsConverter.ToTerms("int(f,x,a,b)"));
Entry rhs = Entry.Create(TermsConverter.ToTerms("Int(f,x,a,b)")); ;
int index = context.Count;
Entry def = context.AddDefinition(lhs, rhs);

try
{
  // do your stuff here
}
catch
{
  // errors, they might happens
}
finally
{
  // remove the definition, even if an error occourred
  context.RemoveAt(index);
}

        public static bool MaximaTakeoverF(Term[][] args, ref Store context, ref Term[] result)
        {
            // List of available definitions
            String[] Functions = new String[]
            {
                "Diff(f__)",
                "Diff(f__,x__)",
                "Diff(f__,x__,n__)",
                "Int(f__,x__)",
                "Int(f__,x__,a__,b__)",
                "Lim(f__,x__,x0__)",
                "Sum(f__,var__,a__,b__)",
                "Det(m__)"
            };

            // Try to ensure maxima is running
            ControlObjects.CommunicationInterface.GetMaxima();
            // Check if Maxima is running and complain otherwise
            if (ControlObjects.CommunicationInterface.GetMaxima().GetState() != ControlObjects.CommunicationInterface.GetMaxima().GetMaximaStateRunning())
            {
                result = TermsConverter.ToTerms(ControlObjects.CommunicationInterface.GetMaxima().GetState());
                return true;
            }

            // Generate a string with all args concatenated
            var ArgString = ""; 
            foreach (Term[] arg in args) ArgString = ArgString + TermsConverter.ToString((Decision.Preprocessing(arg, ref context))); 

            // Loop over the available functions
            string message = "";
            foreach (String Function in Functions)
            {
                string LhsString = Function.ToLower();
                Entry lhs = Entry.Create(TermsConverter.ToTerms(LhsString));

                if (ArgString.Contains(LhsString.Substring(0, 3)) || ArgString.Contains("all"))
                {
                    // add definition
                    Entry rhs = Entry.Create(TermsConverter.ToTerms(Function));
                    Entry def = context.AddDefinition(lhs, rhs);
                    // augment message
                    string MsgPart = LhsString.Split('(')[0] + "(), ";
                    if (!message.Contains(MsgPart)) message += MsgPart;             
                }
                else
                {
                    // remove definition
                    context.Clear(lhs);
                }
            }

            // Make result string
            if (message.Length == 0) message = "All functions handled by SMath"; 
            else message = message.Substring(0, message.Length - 2) + " handled by Maxima";

            result = TermsConverter.ToTerms(Symbols.StringChar + message + Symbols.StringChar);
            return true;
        }

                    // add definition
                    Entry rhs = Entry.Create(TermsConverter.ToTerms(Function));
                    context.AddDefinition(lhs, rhs);
                    // add description
                    context[context.Count-1].Description =  "description of "+ LhsString ;

                    string name = LhsString.Split('(')[0];
                    string[] vars = Regex.Replace(LhsString, @".+\((.+)\)", "$1").Split(',');
                    Term[] Tvars = new Term[1];
                    int i = 0;
                    foreach (string v in vars)
                    {
                        Tvars[i] = new Term(v, TermType.Operand, 0); i++;
                    }
                    context.AddDefinition(new Definition(name, Tvars, rhs, "description of "+name));
                    

context[context.Count-1].Description =  "description of "+ LhsString ;