CoCreate Modeling FAQ: Lisp programming in CoCreate Modeling

topic end
<!--
   * Set TOPICTITLE = <nop>CoCreate Modeling FAQ: Lisp programming in <nop>CoCreate Modeling
-->

---++!! CoCreate Modeling FAQ: Lisp programming in <nop>CoCreate Modeling
%TOC%

<style type="text/css">
pre { background-color:#FFEECC; }
</style>

---
#EditLispFiles
#LispEditor
---+++ %ENGLISH% How to edit Lisp files?

There are a couple of editors which support syntax highlighting for Lisp.
Some of them also can highlight / find / jump to opening and closing brackets which 
is one of the problems in Lisp for beginners (well not only for them ;-) ).

Here is a tiny list:
   * Crimson ( http://www.crimsoneditor.com/ )
   * <nop>ConTEXT ( http://www.context.cx/ )
   * vim ( http://www.vim.org/ )
   * Emacs ( http://www.gnu.org )
   * XEmacs ( http://www.xemacs.org )
   * <nop>SciTE ( http://www.scintilla.org/ )
   * <nop>UltraEdit ( http://www.ultraedit.com/ )
   * <nop>PSPad ( http://www.pspad.com/en/ )
   * Notepad++ ( http://notepad-plus.sourceforge.net/ )

There are syntax highlighting files for <nop>ConTEXT ([[http://context.cx/highlighters.php?filter=A-D]]),
<nop>UltraEdit and Notepad++. Notepad++ ships with <nop>CoCreate
Modeling 2007 and later.

---++++ %GERMAN% Wie schreibt man am besten Lisp-Dateien?

Es gibt eine Reihe von Editoren (Text-Bearbeitungs-Programmen), die auch die Programmiersprache Lisp
unterst&uuml;tzen. Einige k&ouml;nnen auch das Auffinden von schliessenden und &ouml;ffnenden Klammern erleichtern.

Eine kleine Liste von solchen Programmen findet sich hier:
   * Crimson ( http://www.crimsoneditor.com/ )
   * <nop>ConTEXT ( http://www.context.cx/ )
   * vim ( http://www.vim.org/ )
   * Emacs ( http://www.gnu.org )
   * XEmacs ( http://www.xemacs.org )
   * <nop>SciTE ( http://www.scintilla.org/ )
   * <nop>UltraEdit ( http://www.ultraedit.com/ )
   * <nop>PSPad ( http://www.pspad.com/en/ )
   * Notepad++ ( http://notepad-plus.sourceforge.net/ )

Einige Editoren beherrschen automatische Syntaxhervorhebung, wie zum
Beispiel <nop>ConTEXT ([[http://context.cx/highlighters.php?filter=A-D]]),
<nop>UltraEdit and Notepad++. Notepad++ wird mit <nop>CoCreate
Modeling 2007 und sp&auml;teren Versionen ausgeliefert.

-- Main.DerWolfgang, last updated 2007/04/05

---
#LoadLisp
---+++ %ENGLISH% How do I load a Lisp file into <nop>CoCreate Modeling?

There are several ways to do this:
   * By using the Common Lisp [[http://www.lisp.org/HyperSpec/Body/fun_load.html][load]] 
     command in the user input line:
     <tt>(load "c:/there/is/no/place/like/foo.lsp")</tt>.
   * Via the file browser - click File/Open, change the file type to Lisp (=*.lsp=),
     then navigate to the file and open it.
   * By dragging the Lisp file from an Explorer window and dropping it over
     <nop>CoCreate Modeling.

If you have some Lisp code which you want <nop>CoCreate Modeling to load automatically during startup,
you should place your Lisp code in one of the customization directories which <nop>CoCreate Modeling
visits during startup. The choice of customization directory depends on whether
you want the code to be loaded just for you, for your team, a site, or the whole
company. For more details, start with the [[OsdmFaqCustomization#AutomaticLoad][FAQ entry on automatic loading]].

---++++ %GERMAN% Wie lade ich eine Lisp-Datei in <nop>CoCreate Modeling?

Da gibt es viele Wege:
   * Indem man in der <nop>CoCreate Modeling-Eingabezeile das Common-Lisp-Kommando
     Lisp [[http://www.lisp.org/HyperSpec/Body/fun_load.html][load]] benutzt:
     <tt>(load "c:/wo/auch/immer/foo.lsp")</tt>.
   * &Uuml;ber den Dateibrowser - auf Datei/&Ouml;ffnen klicken, den Dateityp auf
     Lisp (=*.lsp=) &auml;ndern, die Datei suchen und ausw&auml;hlen.
   * Indem man sich die Lisp-Datei in einem Explorer-Fenster greift und &uuml;ber
     <nop>CoCreate Modeling fallen l&auml;&szlig;t (drag&amp;drop).

Hat man ein St&uuml;ckchen Lisp-Code, das bei jedem Start automatisch von <nop>CoCreate Modeling
geladen werden soll, kann man die Datei in einem der Anpassungsverzeichnisse
ablegen, die <nop>CoCreate Modeling beim Start durchsucht. Welches Anpassungsverzeichnis man
ausw&auml;hlt, h&auml;ngt davon ab, ob der Code nur f&uuml;r einen einzelnen
Anwender, eine Arbeitsgruppe, eine Firmenniederlassung oder f&uuml;r die ganze
Firma geladen werden soll. Mehr dazu im  [[OsdmFaqCustomization#AutomaticLoad][FAQ-Eintrag zum automatischen Laden]].

-- Main.ClausBrod - 19 Nov 2006

---

#RoundingErrors
---+++ %ENGLISH% <tt>(setf foo (- 1 0.01))</tt> - Lisp says that <tt>foo</tt> is 0.010000000000000009. Is subtraction in Lisp buggy?
---+++ %ENGLISH% I've written a macro which produces a profile, but sometimes, depending on the input, the profile is reported as not closed.

Chances are that you are using floating-point calculations in your profile
macro, and that you are running into inaccuracies which is
a problem that every programmer encounters when calculating
with floating-point values.

This kind of problem can be easily demonstrated by running the following two
Lisp commands:
<pre>
   (setf foo (-1 0.01))
   (display foo)
</pre>

=foo= will displays its value as =0.010000000000000009= in the output box - but
shouldn't that read =0.01=? How can a simple subtraction like this fail?

In fact, this is not even a <nop>CoCreate Modeling or Lisp problem. A similar subtraction will
fail in CoCreate Drafting as well:

<pre>
  LET FOO ( 1 - (VAL '0.99'))
  DISPLAY (FOO > 0.01) {Result = 1}
</pre>

So if both CoCreate Modeling and CoCreate Drafting fail in such
a simple subtraction, maybe it's a CoCreate problem? Are their programmers too
dumb to even get this right?

No. Similar code fails in other languages as well. Here's an example using
<nop>VBscript (execute the script using =wscript= or =cscript=):
<pre>
  Foo = 1 - 0.99
  If Foo > 0.01 Then
    WScript.Echo("Foo is larger than 0.01")
  Else
    WScript.Echo("Foo is equal to or smaller than 0.01")
  End if
</pre>

The truth is that surprises like this can happen to you
in _any_ language and in _any_ application. The reason is that
the way in which CPUs represent floating-point
values is imprecise by definition - there are only a
limited number of bits available to store floating-point
values. A good backgrounder on this is the famous white
paper <a href="http://docs-pdf.sun.com/800-7895/800-7895.pdf">What Every
Computer Scientist Should Know About Floating-Point Arithmetic</a>.
Alternatively, check out the (German)
article at http://www.aboutwebdesign.de/awd/content/1014916256.shtml
which is less formal and good enough as an introduction for
most people.
   
Bottom line of those articles: Calculations with floating-point values are
subject to inaccuracies because their representation in computer memory
has only a finite number of "digits", and sometimes you simply cannot
completely avoid floating-point errors. There are, however, techniques
which reduce and control the error:
    
   * Work with tolerances: When comparing floating-point
     values, allow a certain margin of error, i.e. consider
     two floating-point values as equal if they differ by a
     certain epsilon value at most. (This is why we call this
     technique "Epsilontik", at least in German.)
   * Work with precise data types: Most programming languages
     provide two floating-point data types, i.e. single
     precision (C/C++: float, Lisp: short float) and double
     precision (C/C++: double). When in doubt, choose the more
     precise data type.
   * Avoid floating-point calculations wherever you can.
     Sometimes it is possible to do part of the calculations
     using integer arithmetic.
   * Avoid combining floating-point values in the same term if
     they are of completely different magnitudes. In a
     sequence of calculations, first add/subtract/whatever
     those floating-point pairs which are roughly in the same
     magnitude range.
   * Use algorithms which try to detect when two
     floating-point values really should be 100% identical,
     and which can "fix" the values on the fly.
   * Avoid algorithms which accumulate inaccuracies. For
     example, to rotate a transformation by 170 degrees, apply
     one 170 degress rotation rather than iteratively applying
     17 rotations of 10 degrees.

-- Main.ClausBrod

---
#DoubleQuotes
#EscapeCharacter
---+++ %ENGLISH% How can I use double-quotes in a literal Lisp string?

Imagine you want to replace all double-quote characters in a Lisp string
using the Integration Kit function =sd-string-replace=. Seems we have a
problem here: Literal strings in Lisp start with a double-quote character,
and the next double-quote character in the string ends it. Hmmm...

The solution for this is to use so-called _escape characters_. In Lisp
strings, backslashes are used as escape characters. (There are
similar mechanisms in many programming languages, and the backslash
character is used suspicously often for this purpose. Is there a
secret <i>backslash conspiracy</i> going on here? :D ) Example:

<pre>
  (oli:sd-string-replace string "\"" "!")
</pre>

This replaces all double-quote characters in =string= with exclamation
marks. Note that two double-quote characters follow after the backslash.
The special meaning of the first double-quote character ("end the current
literal string") is ignored by the Lisp reader in this case because it
is preceded by an escape character.

See also the section on the 
[[http://www.lispworks.com/reference/HyperSpec/Body/02_adf.htm][Single Escape Character]] 
in the Common Lisp HyperSpec.

---++++ %GERMAN% Wie gebe ich in einem Lisp-String doppelte Anf&uuml;hrungszeichen an?

Nehmen wir mal an, wir wollten in einem Lisp-String alle doppelten Anf&uuml;hrungszeichen
durch ein anderes Zeichen ersetzen, und zwar mit der Funktion =sd-string-replace=
aus dem Integration Kit. Das k&ouml;nnte problematisch werden, denn ein
Zeichenkettenliteral in Lisp beginnt mit einem doppelten Anf&uuml;hrungszeichen,
und das n&auml;chste Anf&uuml;hrungszeichen beendet es. Hmmm...

Die L&ouml;sung sind die sogenannten _ESCAPE- oder Abdeckzeichen_. In Lisp-Zeichenketten
wird der R&uuml;ckstrich (Backslash) als solches Umschaltzeichen verwendet.
(In anderen Programmiersprachen gibt es &auml;hnliche Mechanismen, und das
Backslash-Zeichen wird verd&auml;chtig oft f&uuml;r diesen Zweck eingesetzt -
eine Backslash-Verschw&ouml;rung? :D ) Beispiel:

<pre>
  (oli:sd-string-replace string "\"" "!")
</pre>

Das Kommando ersetzt alle doppelten Anf&uuml;hrungszeichen durch
Ausrufezeichen. Man beachte, da&szlig; nach dem Backslash-Zeichen
_zwei_ doppelte Anf&uuml;hrungszeichen folgen. Die besondere Bedeutung
des ersten Anf&uuml;hrungszeichen ("beende die aktuelle literale
Zeichenkette") wird von Lisp in diesem Fall ignoriert, weil ein
Backslash-Zeichen vorangeht.

Siehe auch den Abschnitt 
[[http://www.lispworks.com/reference/HyperSpec/Body/02_adf.htm][Single Escape Character]] 
in der HyperSpec-Dokumentation zu Common Lisp.

-- Main.ClausBrod

---

#SearchBackslash
---+++ %ENGLISH% How do I search for a backslash character in a string?

See the explanations [[#EscapeCharacter][above]] on escape characters to understand
why the following would work:
<pre>
  (oli:sd-string-match-pattern-p "*\\\\*" somestring)
</pre>

Hint: Four backslashes are required in the pattern string because the pattern
uses a special regular expression syntax in which the backslash has a special
meaning, just like in Lisp. So you need to "escape" once because of the
pattern language, and then another time because of Lisp.

---++++ %GERMAN% Wie suche ich einen R&uuml;ckstrich in einer Zeichenkette?

Siehe die Erl&auml;uterungen zum Thema Escape-Zeichen [[#EscapeCharacter][weiter oben]];
damit versteht man (hoffentlich), warum das folgende funktioniert:

<pre>
  (oli:sd-string-match-pattern-p "*\\\\*" somestring)
</pre>

Hinweis: Vier R&uuml;ckstriche braucht man deswegen im Muster-String, weil
das Muster in einer speziellen Syntax f&uuml;r regul&auml;re Ausdr&uuml;cke
angegeben wird, in der der R&uuml;ckstrich ebenso wie in Lisp eine spezielle 
Bedeutung hat. Man mu&szlig; also einmal wegen der regul&auml;ren Ausdr&uuml;cke
und dann noch einmal wegen Lisp die erforderlichen R&uuml;ckstriche
hinzuf&uuml;gen.

-- Main.ClausBrod - 13 Jan 2005

---

#SetfVsSetq
---+++ %ENGLISH% What's the difference between =setf= and =setq=?

=setf= is a macro which builds on =setq=, but also allows to do funky stuff like this:

<pre>
  (setf (fifth somelist) 42)
</pre>

Note that the first argument isn't really an ordinary variable, but rather the
description (as a Lisp form) of a place where the value is to be written to. http://www.supelec.fr/docs/cltl/clm/node80.html lists which kind of forms
can be used with =setf=.

In the majority of cases, this special evaluation isn't needed, so you're
probably slightly better off (in terms of performance) by using =setq=.
If you get it wrong, Lisp will kindly remind you with an error message, and then
you can then still use =setf= instead when required.

Historically, =setf= is the abbreviation for =setfq=, which,
according to
[[http://www.cs.umbc.edu/331/resources/papers/Evolution-of-Lisp.pdf][Evolution of Lisp]],
stood for "quote the function and evaluate everything else".

---++++ %GERMAN% Was ist der Unterschied zwischen =setf= und =setq=?

=setf= ist ein Makro, das auf =setq= aufbaut, zus&auml;tzlich aber ulkige Dinge wie dies hier
erlaubt:

<pre>
  (setf (fifth somelist) 42)
</pre>

Das erste Argument von =setf= ist keine normale Variable, sondern eher die Beschreibung
(als Lisp-Form) eines Platzes, an den der Wert geschrieben werden soll.
http://www.supelec.fr/docs/cltl/clm/node80.html listet auf, welche Arten von Lisp-Formen
bei =setf= erlaubt sind.

In der Mehrzahl der F&auml;lle braucht man solche speziellen Erweiterungen nicht,
f&auml;hrt also mit =setq= etwas besser (zumindest in Sachen Geschwindigkeit).
Macht man's falsch, erinnert Lisp einen ohnehin freundlicherweise in Form von
Fehlermeldungen daran, und dann kann man immer noch auf =setf= umsteigen.

Aus historischer Sicht ist =setf= eine Abk&uuml;rzung f&uuml;r =setfq=, was
laut [[http://www.cs.umbc.edu/331/resources/papers/Evolution-of-Lisp.pdf][Evolution of Lisp]]
f&uuml;r "quote the function and evaluate everything else" steht.

-- Main.ClausBrod


#UnexpectedEnd
---+++ %ENGLISH% When I load my Lisp code, I get an "Unexpected end of input stream" error.

When the Lisp interpreter loads a file, it parses and checks it for syntax problems. One 
such syntax problem is when you open parentheses, but forget to close then. Example:
<pre>
  (display "This will not work"
</pre>

When saving this to a file called =foo.lsp= and loading it into <nop>CoCreate Modeling, 
you'll get an error message which reads like:
<pre>
LISP error: Unexpected end of #&lt;input stream "foo.lsp"&gt;.
</pre>

What the Lisp interpreter is trying to say is that it arrived at the end of the file 
before all forms were closed properly, i.e. the number of opening parentheses does 
not match the number of closing parentheses. You can also run into this issue if you 
do not properly terminate a literal string, i.e. you forget the closing double-quote. 
So when you get this error message, open the Lisp file in an editor and look for 
missing parentheses and quotes.

A [[#EditLispFiles][good Lisp editor]] will highlight matching parentheses, and also 
indent your code automatically so that any imbalances become readily apparent.

This error message also used to occur if the Lisp file contains
a comment in the last line, and that last line does not end with a newline character.
This has been fixed in <nop>CoCreate Modeling 2007.

---++++ %GERMAN% Wenn ich meinen Lisp-Code lade, bekomme ich eine Fehlermeldung "Unexpected end of input stream"

Wenn der Lisp-Interpreter eine Datei l&auml;dt, pr&uuml;ft er sie auch auf Syntaxfehler. 
Ein solcher Syntaxfehler ist es, wenn man eine Klammer &ouml;ffnet, aber sie zu schlie&szlig;en vergi&szlig;t. Beispiel:

<pre>
  (display "Das klappt nicht"
</pre>

Speichert man das in eine Datei namens =foo.lsp= und l&auml;dt diese dann in <nop>CoCreate Modeling,
bekommt man eine Fehlermeldung wie diese:

<pre>
LISP error: Unexpected end of #&lt;input stream "foo.lsp"&gt;.
</pre>

Der Lisp-Interpreter versucht hier zu sagen, da&szlig; er am Ende der Datei angekommen ist, bevor 
alle Lisp-Formen ordentlich geschlossen wurden, da&szlig; also die Anzahl der &ouml;ffnenden Klammern 
nicht der Anzahl der schlie&szlig;enden Klammern entspricht. Das Problem kann auch auftreten, 
wenn man eine literale Zeichenkette nicht ordentlich abschlie&szlig;t, also die 
G&auml;nsef&uuml;&szlig;chen am Ende vergi&szlig;t. Wenn man diese Meldung bekommt, 
&ouml;ffnet man also einfach die betreffende Datei in einem Editor und sucht nach fehlenden 
Klammern oder G&auml;nsef&uuml;&szlig;chen.

Ein [[#EditLispFiles][guter Lisp-Editor]] hebt automatisch zugeh&ouml;rige Klammernpaare hervor 
und r&uuml;ckt auch automatisch den Code ein, so da&szlig; solche Strukturfehler sofort auffallen.

Die Fehlermeldung wurde bisher auch dann angezeigt, wenn die Lisp-Datei
einen Kommentar in der letzten Zeile beinhaltet und diese letzte Zeile nicht mit einem
Zeilenvorschub abgeschlossen ist. Dieses Problem ist in <nop>CoCreate Modeling 2007
behoben.

-- Main.ClausBrod - 20 April 2005, last updated 21 December 2005

---
#PackageNames
---+++ %ENGLISH% When I try to call an Integration Kit function =SD-XXX=, I get an error message: "The function SD-XXX is undefined"

First, check the spelling.

Second, all Integration Kit APIs are in the =OLI= LISP package. A Lisp package is
the equivalent of a _namespace_ in other languages. To specify the package, preprend
the function name with =OLI:=, or add a =use-package :oli= statement at the
beginning of your Lisp file.

<pre>
   (SD-XXX param1 param2)      ;; package not specified, call might fail

   (OLI:SD-XXX param1 param2)  ;; MUCH better!

   (use-package :OLI)          ;; alternative method
   (SD-XXX param1 param2)
</pre>

See the [[http://www.lispworks.com/reference/HyperSpec/Body/c_packag.htm][section on packages]]
in the Lisp HyperSpec for more details. The [[http://www.psg.com/~dlamkins/sl/chapter03-10.html][introduction on packages]] 
in David Lamkins'
[[http://www.psg.com/~dlamkins/sl/contents.html][Successful Lisp]] is also a good start
to learn more about this topic.

Actually, in older versions of <nop>CoCreate Modeling it was sometimes to use IKIT APIs without
specifying the =OLI= package. This was an undocumented side effect of our
internal code structure; it just so happened that some code
executed the required =use-package= call, or at least most of the time.
Recent versions of <nop>CoCreate Modeling are less forgiving; to reduce the likelihood of
name clashes, we now enforce proper specification
of the =OLI= package.

---++++ %GERMAN% Wenn ich die Integration-Kit-Funktion =SD-XXX= aufrufe, bekomme ich eine Fehlermeldung "The function SD-XXX is undefined"

Zuallererst: Korrekte Schreibweise des Kommandos &uuml;berpr&uuml;fen.

Zum zweiten: Alle APIs des Integration Kit befinden sich im Lisp-Package =OLI=. Ein
Lisp-Package ist die Entsprechung zu _Namensr&auml;umen_ in anderen Programmiersprachen.
Um das Package anzugeben, h&auml;ngt man vor den aufzurufenden Funktionsnamen einfach
=OLI:=, oder aber man benutzt das Kommando =use-package :oli= am Anfang der Lisp-Datei.

<pre>
   (SD-XXX param1 param2)      ;; Package nicht angegeben; das wird schiefgehen

   (OLI:SD-XXX param1 param2)  ;; Viel besser!

   (use-package :OLI)          ;; Alternative Methode
   (SD-XXX param1 param2)
</pre>

Siehe auch den [[http://www.lispworks.com/reference/HyperSpec/Body/c_packag.htm][Abschnitt zu Packages]]
in der Lisp-HyperSpec f&uuml;r detailliertere Erl&auml;uterungen. Die 
[[http://www.psg.com/~dlamkins/sl/chapter03-10.html][Einf&uuml;hrung zu Packages]] im Buch
[[http://www.psg.com/~dlamkins/sl/contents.html][Successful Lisp]] von David Lamkins ist auch
ein guter Startpunkt, um mehr zu diesem Thema zu lernen.

In &auml;lteren Versionen von <nop>CoCreate Modeling konnte man &uuml;brigens manchmal straflos
IKIT-APIs ohne Angabe des Packagenamens (=OLI=) aufrufen. Das war ein undokumentierter
Seiteneffekt der internen Codestruktur; zuf&auml;lligerweise benutzte interner Code
den passenden Aufruf von =use-package= und nahm diese Anmeldung nicht zur&uuml;ck.
Neuere Versionen von <nop>CoCreate Modeling sind weniger nachsichtig in diesem Punkt. Um die
Wahrscheinlichkeit von Namenskollisionen zu reduzieren, erzwingt <nop>CoCreate Modeling seit einiger
Zeit die korrekte Angabe des Packagenamens.

-- Main.ClausBrod

---
#CoerceValue

---+++ %ENGLISH% When running my macro X, I get an error message reporting that "XXX cannot be coerced to YYY".

<img src="%ATTACHURL%/coerce.jpg" align="right" />
In the example displayed here, a function is called which expects a parameter of type
=double=, but instead is passed a structure of type =GPNTDOCU=. So this type of error
message usually indicates a programming error (incorrect parameter passing)
in the Lisp code which has been executed.

As you can see from the screenshot, the error message itself is slightly buggy, too .-)

---++++ %GERMAN% Wenn ich das Makro X ausf&uuml;hre, bekomme ich eine Fehlermeldung "XXX cannot be coerced to YYY".

Im Beispiel wird eine Funktion aufgerufen, die einen Parameter vom Typ =double= erwartet,
stattdessen aber vom Aufrufer eine Struktur vom Typ =GPNTDOCU= erh&auml;lt. Diese Art von
Fehlermeldung deutet also auf einen Programmierfehler (falsche Parameter&uuml;bergabe)
im Lisp-Code hin, der gerade ausgef&uuml;hrt wurde.

Wie man dem Bild entnehmen kann, ist allerdings die Fehlermeldung selbst auch nicht ganz fehlerfrei .-)

-- Main.ClausBrod

---

#PortCustomizationCode
---+++ %ENGLISH% How do I port customization code from HP-UX to Windows?

If you only used the official APIs in the Integration Kit, there should rarely 
be a need to port anything. Almost all of them are cross-platform.

However, there are exceptions. One such exception is when you use =sd-sys-background-job= or =sd-sys-exec= to execute external commands. 
Such code will only continue to work if the external commands are 
available on the Windows platform as well.

In some cases, the HP-UX code will try to execute UNIX shell commands, such as =grep=,
=awk=, =sort=, =ls= etc etc. For many external commands, you will actually find
equivalent Integration Kit APIs or Lisp commands, which is the clearly preferable
implementation. For instance, rather than using =cp= as an external command, use
the =sd-copy-file= API; and to create a directory, =sd-make-directory= is more
portable than =mkdir=. Consult the "Filing and Operating System" section of
the Integration Kit documentation for details. Lisp also has a number of
system-level commands, such as to access files, so the Common Lisp HyperSpec is
also a good place to start your search.

Sometimes, however, you will still have to use external commands. The good news
is that the DOS batch language (which can be used in =sd-sys-exec= commands
on Windows) is actually quite flexible and powerful, even though the syntax differs
significantly from UNIX systems. For example, =grep= can almost always be replaced
by =findstr=, =rm= is the same as =del=, =dir= matches =ls= most of the time etc.
A good book on the subject is [[http://www.amazon.com/exec/obidos/ASIN/1578700477/][Windows NT Shell Scripting]] by Timothy Hill. Also, there are many sources in the Internet which discuss batch file programming, such as [[http://www.robvanderwoude.com/][Rob van der Woude's Scripting Pages]].

Yet another alternative is to use one of the UNIX-lookalike tool collections
and shell environments out there. These allow to continue to use =grep=, =ksh=
and friends, so instead of porting your macros, you simply install a UNIX
shell environment on your systems.

There are both commercial and free implementations. Examples:
   * [[http://www.cygwin.com][Cygwin]] (free)
   * [[http://www.research.att.com/sw/tools/uwin/][U/Win]] (free for non-commercial use)
   * [[http://www.microsoft.com/windows/sfu/productinfo/overview/default.asp][Windows Services for UNIX]]
   * [[http://ppt.perl.org/][Perl Power Tools]] (free)

---++++ %GERMAN% Wie portiert man Anpassungen von HP-UX nach Windows?

Solange man nur die offiziellen APIs im Integration Kit verwendet, sollte es selten
&uuml;berhaupt einen Bedarf geben, irgendetwas zu portieren. Fast alle dieser APIs
sind f&uuml;r alle Plattformen g&uuml;ltig.

Es gibt aber Ausnahmen. Eine solche Ausnahme ist es, wenn man =sd-sys-background-job=
oder =sd-sys-exec= zum Ausf&uuml;hren externer Kommandos verwendet. Solcher Programmcode
wird nur dann auf der neuen Plattform (in unserem Beispiel Windows) weiter funktionieren, 
wenn die externen Kommandos dort ebenfalls verf&uuml;gbar sind.

In einigen F&auml;llen versuchen HP-UX-Makros, UNIX-Kommandos auszuf&uuml;hren,
beispielsweise =grep=, =awk=, =sort= oder =ls=. F&uuml;r viele solcher externen Kommandos
kann man &uuml;brigens Entsprechungen in Lisp selbst oder im Integration Kit finden -
ganz klar ist das einer plattformabh&auml;ngigen Programmierung vorzuziehen.
Beispielsweise kann man statt =cp= als externem Kommando einfach =sd-copy-file= 
verwenden; zum Anlegen eines Verzeichnisses ist =sd-make-directory= portabler
als =mkdir=. Der Abschnitt "Filing and Operating System" in der Dokumentation
zum Integration Kit ist hier besonders interessant. Lisp stellt ebenfalls
eine Reihe von Kommandos zur Verf&uuml;gung, die von der verwendeten Plattform
abstrahieren, beispielsweise zum Zugriff auf Dateien - die HyperSpec-Dokumentation
zu Common Lisp ist also auch hier ein guter Anlaufpunkt.

Manchmal mu&szlig; man aber doch auf externe Kommandos ausweichen.
Die gute Nachricht ist hier, da&szlig; die Batch-Sprache von DOS (die
man f&uuml;r mit =sd-sys-exec= ausgef&uuml;hrte Kommandos einsetzen kann)
recht flexibel und vielseitig ist, auch wenn die Syntax doch oft erheblich
von UNIX-Systemen abweicht. Beispielsweise kann man =grep= fast immer durch
=findstr= ersetzen; =rm= ist fast identisch mit =del=, und =dir= entspricht meistens
=ls=. Ein gutes Buch zu diesem Thema ist 
[[http://www.amazon.com/exec/obidos/ASIN/1578700477/][Windows NT Shell Scripting]]
von Timothy Hill. Es gibt auch viele weitere Quellen im Internet, die Batch-Programmierung
behandeln, beispielsweise [[http://www.robvanderwoude.com/][die Scripting-Seiten von Rob van der Woude]].

Eine weitere Alternative sind  UNIX-&auml;hnliche Werkzeugsammlungen
und Shell-Umgebungen, die es erlauben, wie gewohnt =grep=, =ksh=
und Kumpane zu verwenden. Anstatt also die Makros zu portieren, installiert
man einfach eine solche Shell-Umgebung auf den Zielsystemen.

Es gibt sowohl kommerzielle als auch freie Implementierungen. Beispiele:
   * [[http://www.cygwin.com][Cygwin]] (frei)
   * [[http://www.research.att.com/sw/tools/uwin/][U/Win]] (frei f&uuml;r nichtkommerzielle Anwendung)
   * [[http://www.microsoft.com/windows/sfu/productinfo/overview/default.asp][Windows Services for UNIX]]
   * [[http://ppt.perl.org/][Perl Power Tools]] (frei)

-- Main.ClausBrod, last update 2007-04-03

---

#RunOsddMacros
---+++ %ENGLISH% How can I run <nop>CoCreate Drafting (ME10) macros in Annotator?

The IKIT function =sd-execute-annotator-command= is a convenient way to do
this. For example, if you have an OSDD macro which takes two parameters,
you can call it like this:

<pre>
  (oli:sd-execute-annotator-command 
    :cmd (format nil "my_osdd_macro ~A ~A" param1 param2)) 
</pre>

Note how =format= is used to build the full macro string before passing
it to Annotator.

---++++ %GERMAN% Wie kann ich Makros f&uuml;r <nop>CoCreate Drafting (ME10) in Annotation laufen lassen?

Das geht recht bequem &uuml;ber die IKIT-Funktion =sd-execute-annotator-command=.
Wenn man zum Beispiel ein OSDD-Makro hat, das zwei Parameter erwartet, kann man
es wie folgt rufen:

<pre>
  (oli:sd-execute-annotator-command
    :cmd (format nil "my_osdd_macro ~A ~A" param1 param2)) 
</pre>

Man beachte, wie hier =format= benutzt wird, um den Makroaufruf
aufzubauen, bevor man ihn an Annotator schickt.

-- Main.ClausBrod - 11 Jun 2005

---

%COMMENT{type="below" nonotify="on"}%
to top
End of topic
Skip to action links | Back to top
You are here: CoCreateModeling > OsdmFaqLisp

r1.21 - 24 Jul 2009 - 20:57 - ClausBrod to top
CoCreateModeling
Welcome
