Unclear on syntax for returning from a lisp function created in c#

[JaCAD]

So I'm trying to understand the process for creating a Lisp function in c# .net.

public class LispException : System.Exception
        {
            public LispException(string msg) : base(msg) { }
        }

        public class TooFewArgsException : LispException
        {
            public TooFewArgsException() : base("too few arguments") { }
        }

        public class TooManyArgsException : LispException
        {
            public TooManyArgsException() : base("too many arguments") { }
        }

        public class ArgumentTypeException : LispException
        {
            public ArgumentTypeException(string s, TypedValue tv)
                : base(string.Format("Bad argument type: {0} {1}", s, tv.TypeCode == (int)LispDataType.Nil ? "nil" : tv.Value)) { }
        }





        [LispFunction("DoubleValue")]
        public object DoubleValue(ResultBuffer argBuffer)
        {
            Editor ed = MgdAcApplication.DocumentManager.MdiActiveDocument.Editor;
            Object Res = new ResultBuffer();

            try
            {
                if (argBuffer == null)
                {
                    throw new TooFewArgsException();
                }
                else
                {
                    TypedValue[] argArray = argBuffer.AsArray();
                    int ArrayLen = argArray.Length;

                    if (ArrayLen > 1)
                    {
                        throw new TooManyArgsException();
                    }

                    else
                    {

                        if (argArray[0].TypeCode == (short)LispDataType.Double)
                        {
                            Res = ((double)argArray[0].Value) * 2.0;
                        }
                        else if (argArray[0].TypeCode == (short)LispDataType.Int16)
                        {
                            Res = ((Int16)argArray[0].Value) * 2;
                        }
                        else if (argArray[0].TypeCode == (short)LispDataType.Int32)
                        {
                            Res = ((Int32)argArray[0].Value) * 2;
                        }
                        else
                        {
                            throw new ArgumentTypeException("numberp", argArray[0]);
                        }
                    }
                }

                return Res;
            }//end try

            
            catch (LispException ex)
            {
                ed.WriteMessage("\n; error: {0}\n", ex.Message);
                return null;
            }

            catch (Autodesk.AutoCAD.Runtime.Exception ex)
            {
                ed.WriteMessage("\nAutoCAD error: {0}\n", ex.Message);
                return null;
            }

            catch (System.Exception ex)
            {
                ed.WriteMessage("\nSystem error: {0}\n", ex.Message);
                return null;
            }
        }

I can netload this without a problem, and it does what it's supposed to do...up to a point...

Command: (setq Num 12)
12

Command: (setq Num (DoubleValue Num))
24

Command: (setq Num (DoubleValue 12.34))
24.68

Command: (setq Num (abs))
; error: too few arguments

Command: !Num
24.68

Command: (setq Num (DoubleValue))

; error: too few arguments
nil

Command: !Num
nil

Notice that the call to (abs) with no arguments resulted in an error, but (abs) didn't return a value to the setq, so Num kept it's previous value.
How do I create a Lisp function in c# that will properly catch exceptions, but not return nil to the calling function, just like normal autolisp functions?

Thanks!

[BlackBox]

Couple of things....

So I'm trying to understand the process for creating a Lisp function in c# .net.

public class LispException : System.Exception
        {
            public LispException(string msg) : base(msg) { }
        }

        public class TooFewArgsException : LispException
        {
            public TooFewArgsException() : base("too few arguments") { }
        }

        public class TooManyArgsException : LispException
        {
            public TooManyArgsException() : base("too many arguments") { }
        }

        public class ArgumentTypeException : LispException
        {
            public ArgumentTypeException(string s, TypedValue tv)
                : base(string.Format("Bad argument type: {0} {1}", s, tv.TypeCode == (int)LispDataType.Nil ? "nil" : tv.Value)) { }
        }

Firstly, when copying someone else's code, be sure to credit them, and include a link when possible. I can recognize Gile's LispException Classes anywhere, as he shared them with me when I was first learning to work with LispFunction Methods.

I can netload this without a problem, and it does what it's supposed to do...up to a point...

Command: (setq Num 12)
12

Command: (setq Num (DoubleValue Num))
24

Command: (setq Num (DoubleValue 12.34))
24.68

Command: (setq Num (abs))
; error: too few arguments

Command: !Num
24.68

Command: (setq Num (DoubleValue))

; error: too few arguments
nil

Command: !Num
nil

Notice that the call to (abs) with no arguments resulted in an error, but (abs) didn't return a value to the setq, so Num kept it's previous value.
How do I create a Lisp function in c# that will properly catch exceptions, but not return nil to the calling function, just like normal autolisp functions?

Simple, either return false, or a ResultBuffer with a Nil LispDataType... Just be sure to handle any Exception(s), as not every LispFunction Method will do simple Math calculations.

[BlackBox]

Consider this adaptation:

using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;

using System;

[assembly: CommandClass(typeof(AUGI.Sample.LispFunctions.Commands))]

namespace AUGI.Sample.LispFunctions
{
    public class Commands
    {
        [LispFunction("2X")]
        public object Double(ResultBuffer resbuf)
        {
            if (resbuf == null)
                return false;

            TypedValue[] args = resbuf.AsArray();

            if (args.Length != 1)
                return false;

            TypedValue arg = args[0];
            short type = arg.TypeCode;

            if (type == (short)LispDataType.Double)
                return ((double)arg.Value) * 2.0;

            if (type == (short)LispDataType.Int16)
                return ((Int16)arg.Value) * 2;

            if (type == (short)LispDataType.Int32)
                return ((Int32)arg.Value) * 2;

            return false;
        }
    }
}

[_gile]

Hi,

How do I create a Lisp function in c# that will properly catch exceptions, but not return nil to the calling function, just like normal autolisp functions?

It returns nil because your error handlers ends with: "return null;".
To avoid this, you can re-throw the exception after having displayed the error message:

catch (LispException ex)
            {
                MgdAcApplication.ShowAlertDialog(ex.Message);
                throw;
            }

            catch (Autodesk.AutoCAD.Runtime.Exception ex)
            {
                MgdAcApplication.ShowAlertDialog(ex.Message);
                throw;
            }

            catch (System.Exception ex)
            {
                MgdAcApplication.ShowAlertDialog(ex.Message);
                throw;
            }

PS: BlackBox, your adaptation should always return nil in case an exception is raised (nil stands for false too).

[BlackBox]

PS: BlackBox, your adaptation should always return nil in case an exception is raised (nil stands for false too).

It (my code) does always return Nil (false) in place of an Exception... However, unless I've overlooked something, Exception handling is only necessary when you've not accounted for a possible Exception through code logic... As I am using logical tests for each step, this is not necessary, as there are no Exceptions thrown.

[_gile]

It (my code) does always return Nil (false) in place of an Exception... However, unless I've overlooked something, Exception handling is only necessary when you've not accounted for a possible Exception through code logic... As I am using logical tests for each step, this is not necessary, as there are no Exceptions thrown.

I do not think so. An invalid input (as an invalid number or type of argument) have to throw an exception instead of returning a valid LISP value: nil.
Your code hides the exception and may cause an exception later in the calling function:

(setq a (2x))
;; ...
(princ (itoa a))

; error: Bad argument type: fixnump: nil

[JaCAD]

Hi,


It returns nil because your error handlers ends with: "return null;".
To avoid this, you can re-throw the exception after having displayed the error message:

catch (LispException ex)
            {
                MgdAcApplication.ShowAlertDialog(ex.Message);
                throw;
            }

            catch (Autodesk.AutoCAD.Runtime.Exception ex)
            {
                MgdAcApplication.ShowAlertDialog(ex.Message);
                throw;
            }

            catch (System.Exception ex)
            {
                MgdAcApplication.ShowAlertDialog(ex.Message);
                throw;
            }

PS: BlackBox, your adaptation should always return nil in case an exception is raised (nil stands for false too).

Thanks Gile, this is the functionality I was looking for. Thanks also for your LispException classes.

Is there a way to suppress the error stack which dumps to the command prompt in the instance of an exception?

Thanks!

[_gile]

Is there a way to suppress the error stack which dumps to the command prompt in the instance of an exception?

Maybe, but I don't know which. That's why I use the Application.ShowAlertDialog() method to prevent the user/coder that an error occured.