Multiple Commands in one LISP

[CSM_MAI]

I currently have 5 individual commands combined into one lisp routine.  The first command looks for an envoronment value, when it finds it, it is supposed to then activate one of the other 4 commands I have in the lisp based on what it finds. For some reason AutoCAD is returning "unknown command" on the command prompt when the first command is executed. If I type in the command it was supposed to trigger, it works fine. When doing something like this, is the use of 5 separate (defun C:xxx ( )'s appropriate, or is there an easier way to achieve this? Thanks.

[mid-awe]

Make sure that the first command is loaded last of all. It can happen that your program runs fine but subsequent programs have not loaded.

I like to use functions for what you are doing.

(defun something (args) (command "whatever" Pause))

then:

(defun c:discover (/ discovered) (if (= (getstring "\n type something") discovered) (something args)) (princ))

[Shneuph]

Without seeing any of your code... It sounds like you should have your program organized like this then with the main one being defined as a 'command' and the rest only as functions.

(Defun C:MainCommand ( / ) <--- Define Command

   (cond 

     (= envvar w)

        (funct1)

         )

     (= envvar x)

        (funct2)

         )

     (= envvar y)

        (funct3)

         )

     (= envvar z)

        (funct4)

         )

     );end cond

);end command defun

;define functions

(defun funct1 ( / )...) <--- Sub functions (no C:)

(defun funct2 ( / )...)

(defun funct3 ( / )...)

(defun funct4 ( / )...)

This organization should work.. If you have them all defined as commands (You intend to use the sub functions directly from the command line) you can call them with (C:funct1) instead of (funct1) I think.

(Defun C:MainCommand ( / ) <--- Define Command

   (cond 

     (= envvar w)

        (C:funct1)

         )

     ...

  )

 (Defun C:funct1 ( / )...) 

[CSM_MAI]

Thanks for the quick responses. I was able to get it fixed by taking out the "C:" on the other 4 commands. Essentially it looks like this:

(defun C:maincommand ()

(setq GETS TEXT STRING CODE)

(COND

 ((= XXX "XXX") (COMMAND1))

 ((= XXX "XXX") (COMMAND2))

 ((= XXX "XXX") (COMMAND3))

 ((= XXX "XXX") (COMMAND4))

)

(PRINC)

)

(DEFUN COMMAND1 ()

(CODE)

(PRINC)

)

(DEFUN COMMAND2 ()

(CODE)

(PRINC)

)

(DEFUN COMMAND3 ()

(CODE)

(PRINC)

)

(DEFUN COMMAND4 ()

(CODE)

(PRINC)

)

[scot-65]

By moving the subroutines (function) above the "c:" or
"main" body of the program, and canceling out the first
and last line, one can edit without having to load, then
command running it. It is only after debugging that you
un-cancel the two lines and now you have the command.

2) A few programming languages will fail to call a subroutine
if the subroutine is placed below the calling point. With that,
it is good practice to place above and it is also easier to hunt
down the problem sub.

[doni49 · Accepted solution]

If you DID want these "secondary" commands to remain callable (by the user), you could also leave the c colon in there -- just include it when you actually call the functions within lisp.

(defun c:sub1()
  (princ "This is Sub1")
)
(defun c:sub2()
  (princ "This is Sub2")
)
(defun c:MainCommand()
  (c:sub1)
  (c:sub2)
)

[doni49]

Also -- if you DON'T want the secondary commands to be callable (the only place they'll be called is from within your main command), then I think you'd be better off using lambdas within each one of those test conditions.  It'll make for less "overhead".

[doni49]

---

@doni49 wrote:

Also -- if you DON'T want the secondary commands to be callable (the only place they'll be called is from within your main command), then I think you'd be better off using lambdas within each one of those test conditions.  It'll make for less "overhead".

---

Forget this suggestion.  I've never tried to use lambda this way but I really thought it would work.  I just tried to write up an example -- but no good.