SAS-Makro-Programmierung - Universitaetsrechenzentrum · 6 1. Einführung 1.1 Was ist ein...

Click here to load reader

  • date post

    15-Sep-2019
  • Category

    Documents

  • view

    3
  • download

    0

Embed Size (px)

Transcript of SAS-Makro-Programmierung - Universitaetsrechenzentrum · 6 1. Einführung 1.1 Was ist ein...

  • U n i v e r s i t ä t s r e c h e n z e n t r u m H e i d e l b e r g

    SAS-Makro-Programmierung: Eine Einführung

    Holger Geißler & Dr. Carina Ortseifen

    Oktober 1995

    Universitätsrechenzentrum Heidelberg, 1995, Im Neuenheimer Feld 293, D-69120 Heidelberg

  • 2

    VORWORT.................................................................................................................................................................4 LEGENDE ..................................................................................................................................................................5

    1. EINFÜHRUNG .................................................................................................................................................6

    1.1 WAS IST EIN SAS-MAKRO?.................................................................................................................................6 1.2 WO WIRD DIE SAS-MAKRO-SPRACHE EINGESETZT? ...........................................................................................6 1.3 ELEMENTE DER MAKRO-SPRACHE......................................................................................................................6

    2. SAS-MAKROVARIABLEN ............................................................................................................................7

    2.1 AUTOMATISCHE MAKROVARIABLEN...................................................................................................................8 2.2 BENUTZERDEFINIERTE MAKROVARIABLEN.......................................................................................................10

    2.2.1 Erzeugung von benutzerdefinierten Makrovariablen ...............................................................................10 2.2.2 Ausgabe des Wertes benutzerdefinierter Makrovariablen........................................................................10 2.2.3 Verkettung von Makros ............................................................................................................................10 2.2.4 Indirekte Zuweisung von Werten ..............................................................................................................11 2.2.5 Das Auflösen von mehrfachen Ampersands .............................................................................................11

    ÜBUNGSAUFGABEN.................................................................................................................................................11

    3. DIE %MACRO-ANWEISUNG.....................................................................................................................13

    3.1 DEFINITION UND AUFRUF VON SAS-MAKROS...................................................................................................13 3.2 MAKRO-NAME..................................................................................................................................................13 3.3 MAKRO-PARAMETER ........................................................................................................................................13

    3.3.1 Positions- und Schlüsselparameter ..........................................................................................................14 ÜBUNGSAUFGABEN.................................................................................................................................................15

    4. LOKALE UND GLOBALE MAKROVARIABLEN...................................................................................16

    4.1 ERZEUGUNG VON LOKALEN UND GLOBALEN MAKROVARIABLEN......................................................................16 4.1.1 Die %Global-Anweisung..........................................................................................................................17 4.1.2 Die %Local-Anweisung............................................................................................................................18

    4.2 MAKROS INNERHALB VON MAKROS..................................................................................................................18 ÜBUNGSAUFGABEN.................................................................................................................................................19

    5. SAS-MAKRO-PROGRAMMANWEISUNGEN...........................................................................................20

    5.1 %*-ANWEISUNG ...............................................................................................................................................20 5.2 %PUT-ANWEISUNG...........................................................................................................................................21 5.3 %INPUT-ANWEISUNG........................................................................................................................................21 5.4 %IF - %THEN / %ELSE-ANWEISUNG.................................................................................................................22 5.5 %DO - %END-ANWEISUNG...............................................................................................................................22 ÜBUNGSAUFGABE ...................................................................................................................................................23 5.6 %DO - %TO - %END-ANWEISUNG (ITERATIVE %DO-ANWEISUNG) .................................................................23 5.7 %DO - %UNTIL - %END-ANWEISUNG...............................................................................................................24 5.8 %DO - %WHILE - %END-ANWEISUNG..............................................................................................................25 5.9 %GOTO LABEL; %LABEL-ANWEISUNG..............................................................................................................25 5.10 %SYSEXEC-ANWEISUNG.................................................................................................................................26 5.11 %KEYDEF-ANWEISUNG ..................................................................................................................................28 ÜBUNGSAUFGABEN.................................................................................................................................................28 5.12 %WINDOW-ANWEISUNG.................................................................................................................................28

    5.12.1 Fensteroptionen......................................................................................................................................29 5.12.2 Felddefinitionen .....................................................................................................................................30 5.12.3 Gruppen-Definition ................................................................................................................................31 5.12.4 Automatische Variablen .........................................................................................................................31

    5.13 %DISPLAY-ANWEISUNG..................................................................................................................................33 ÜBUNGSAUFGABE ...................................................................................................................................................34

    6. SAS-MAKRO-FUNKTIONEN.......................................................................................................................34

    6.1 FUNKTIONEN ZUR BEARBEITUNG VON ZEICHENKETTEN ...................................................................................36 6.1.1 %INDEX-FUNKTION .......................................................................................................................................36 6.1.2 %LENGTH-FUNKTION ....................................................................................................................................37 6.1.3 %SCAN- UND %QSCAN-FUNKTION ................................................................................................................37 6.1.4 %SUBSTR- UND %QSUBSTR-FUNKTION.........................................................................................................39

  • 3

    6.1.5 %UPCASE- UND %QUPCASE-FUNKTION ........................................................................................................39 ÜBUNGSAUFGABE ...................................................................................................................................................40 6.2 %EVAL FUNKTION ZUR AUSWERTUNG VON LOGISCHEN UND NUMERISCHEN AUSDRÜCKEN.............................41 6.2.1 %EVAL-FUNKTION.........................................................................................................................................41 ÜBUNGSAUFGABEN.................................................................................................................................................43 6.3 FUNKTIONEN ZUR BEARBEITUNG VON SPEZIELLEN ZEICHEN (TEXTFUNKTIONEN) ............................................43 6.3.1 %QUOTE-FUNKTION ......................................................................................................................................45 6.3.2 %BQUOTE-FUNKTION ....................................................................................................................................45 6.3.3 %NRQUOTE-FUNKTION..................................................................................................................................46 6.3.4 %NRBQUOTE-FUNKTION................................................................................................................................46 6.3.5 %UNQUOTE-FUNKTION..................................................................................................................................46 6.3.6 %STR-FUNKTION ...........................................................................................................................................47 6.3.7 %NRSTR-FUNKTION.......................................................................................................................................47 6.3.8 %SUPERQ-FUNKTION.....................................................................................................................................48 ÜBUNGSAUFGABEN.................................................................................................................................................48

    7. BERÜHRUNGSPUNKTE ZWISCHEN MAKRO-SPRACHE UND DATENSCHRITT .........................49

    7.1 ZUGRIFF AUF DATEN IN SAS-MAKROS .............................................................................................................49 7.1.1 SYMGET-FUNKTION .......................................................................................................................................49 7.1.2 SYMPUT-FUNKTION .......................................................................................................................................52 7.1.3 RESOLVE-FUNKTION......................................................................................................................................54 7.2 %SYSPROD-FUNKTION......................................................................................................................................55 7.3 EXECUTE-ROUTINE...........................................................................................................................................56 ÜBUNGSAUFGABEN.................................................................................................................................................58

    8. AUFRUF VON SAS-MAKROS......................................................................................................................58

    8.1 NAMED STYLED MAKROS .................................................................................................................................59 8.2 STATEMENT STYLED MAKROS ..........................................................................................................................59 8.3 COMMAND STYLED MAKROS ............................................................................................................................60

    9. MAKRO-BIBLIOTHEKEN (AUTOCALL-FACILITY).............................................................................60

    9.1 AUTOMATISCHER AUFRUF VON MAKROS (AUTOCALL FACILITY) .....................................................................60 9.2 AUTOMATISCHES SPEICHERN VON KOMPILIERTEN MAKROS .............................................................................62 9.3 ALLGEMEINE SYSTEMOPTIONEN .......................................................................................................................64

    10. FEHLERMELDUNGEN UND MÖGLICHE URSACHEN.......................................................................65

    LÖSUNGVORSCHLÄGE ZU DEN ÜBUNGSAUFGABEN ...........................................................................66

    ZUSÄTZLICHE ÜBUNGSAUFGABEN ...........................................................................................................71

    LITERATURLISTE: ...........................................................................................................................................74

    INDEX...................................................................................................................................................................75

  • 4

    Vorwort

    Für wen ist dieses Skript gedacht? Dieses Skript ist eine Einführung in die Makroprogrammierung mit SAS, keine Einführung in SAS. Der mit SAS vertraute Anwender wird mit diesem Skript eine erste Anleitung zur Erstellung eigener Makros finden. Für Anwender, die SAS bislang nicht oder nur selten benutzt haben, wird dieses Skript keine Hilfe sein, da es auf einem grundlegenden Verständnis von SAS aufbaut und bestimmte Kenntnisse voraussetzt. Es liegt im Wesen der Makros, daß es erst dann Sinn macht die Makroprogrammierung zu lernen, wenn Sie bestimmte Abläufe in SAS öfters wiederholen müssen.

    Was will dieses Skript?

    Eine Einführung in die Makroprogrammierung sein. Der erfahrene SAS-Makro-programmierer wird hier wenig Neues finden. Die AnwenderIn, die ihre ersten Schritte in die Welt der Makros unternehmen will, soll nach Lektüre des Skripts in der Lage sein, einfachere Makros zu schreiben. Vermittelt werden soll außerdem, ein grundlegendes Verständnis für den Aufbau und die Struktur von Makros in SAS.

    Wie arbeiten Sie am Besten mit diesem Skript?

    Am Besten, indem Sie vorne anfangen, und es bis zum Schluß aufmerksam lesen. Außerdem sollten Sie die Übungsaufgaben bearbeiten, da gerade bei der Arbeit mit dem Computer praktisches Ausprobieren unerläßlich ist. Es gibt zu jedem größeren Abschnitt (meist ist dies ein Kapitel) mehrere Übungsaufgaben, die nach dem Studium des jeweiligen Abschnitts gelöst werden sollten. Wenn es mal gar nicht funktioniert, bleibt natürlich immer noch der Blick in die Lösungen, die sich im hinteren Teil des Buches befinden.

    Das vorliegende Skript basiert auf Kursunterlagen, die für SAS-Makroprogrammierkurse am Universitätsrechenzentrums erstellt wurden. Die Literatur, die in diesem Skript verwendet wurde, ist ausnahmslos in der Bibliothek des Universitätsrechenzentrum verfügbar. Bei Fragen und Hinweise erreichen Sie uns entweder über Telefon oder per E-Mail. Holger Geißler, � 565582, E-Mail: holger.geiß[email protected] Carina Ortseifen, � 564541, E-Mail: [email protected]

  • 5

    Legende

    SAS-Schlüsselworte, -Anweisungen und sonstige Programmzeilen sind in Courier geschrieben: %macro, %nrstr; C:\SAS, Hervorhebungen im Text sind Fett gesetzt:

    Makro-Parameter können entweder als Positionsparameter (posparm) oder Schlüssel-parameter (keyparm) übergeben werden. Benennungen, die variabel sind, werden in der

    Optionen und Argumente, die der Benutzer wählen kann, sind kursiv in Times New Roman geschrieben: %keydef key-name | 'key-name' | "keyname" ; Numerierungen in schwarzen Kreisen sind Erläuterungen zu Beispielprogrammen: � Mit dieser %let-Anweisung wird die Makrovariable name global definiert.

  • 6

    1. Einführung

    1.1 Was ist ein SAS-Makro?

    Ein SAS-Makro ist ein in der SAS-Makro-Sprache geschriebenes Programm, welches aus SAS-Elementen wie z.B. Proc- und Data-Schritten bestehen kann. Falls Sie regelmäßig die gleichen Programmanweisungen durchführen müssen, kann es zeitsparend sein, sich dafür ein Makro zu schreiben. Nachdem das Makro einmal aktiviert ist, kann es immer wieder allein durch seinen Namen aufgerufen und benutzt werden. Das Makro spricht einen eigens für die Makro-Sprache bereitgestellten Prozessor an, der durch Schlüsselzeichen, wie z.B. das Prozentzeichen "%" aktiviert wird. Dieser Prozessor nennt sich Makro-Prozessor. Mit Hilfe der SAS-Makro-Sprache können Sie mit ihm kommunizieren. Beispiel: %macro aufruf;

    libname co v604 'N:\SASurz\daten';libname co608 v608 'N:\SASurz\daten';libname daten 'M:\SAS\daten';libname b 'B:\';libname a 'A:\';libname library 'M:\SAS\formate';

    %mend aufruf;Aufruf: %aufruf Bevor Sie mit einem Makro arbeiten können, müssen sie es kompilieren. Dies geschieht dadurch, das sie das gesamte Makro submittieren. Durch den Aufruf wird der Makro-Prozessor aktiviert, der nun die Programmanweisungen durchführt. Das Makro aufruf setzt alle notwendigen Libname-Anweisungen. Da sie normalerweise bei jeder SAS-Sitzung gesetzt werden müssen, ist es zeitsparend, sie durch ein Makro zusammenzufassen. 1.2 Wo wird die SAS-Makro-Sprache eingesetzt?

    Die SAS-Makro-Sprache wird an folgenden Stellen eingesetzt: • Zusammenfassung von Proc- und Data-Schritten, die häufig wiederholt werden müssen • Erzeugung von Anwendungen, die das SAS-System bisher nicht anbietet, z.B. der Jonckheere-Test • Erzeugung von datenabhängigen Programmen durch eine Schnittstelle zu SAS-Dateien (DATA Step Interface) • Entwicklung von Eingabefenstern • Automatische Einbindung von Systeminformationen (z.B. Datum, Uhrzeit und Betriebssystem) • Bedingtes Ausführen von Daten- und Prozedurschritten

    1.3 Elemente der Makro-Sprache

    Es gibt vier wesentliche Elemente der SAS-Makro-Sprache: • Makrovariablen • Makro-Programmanweisungen • Makro-Funktionen • Makro-Routinen

  • 7

    Makrovariablen unterscheiden sich grundlegend von den Variablen einer SAS-Datei. Der Wert einer Datenschritt-Variablen hängt von der Beobachtung ab, die sie gerade darstellt. Datenschritt-Variablen können nur in Data- oder Proc-Schritten verwendet werden. Makrovariablen sind dagegen überall einsetzbar. Sie haben einen konstanten Wert, den ihnen zugewiesen oder vorgegeben wird. Makrovariablen speichern Zeichenketten ab und können manipuliert werden. Es gibt zwei unterschiedliche Arten von Makrovariablen: Benutzerdefinierte und Automatische Variablen. Benutzerdefinierte Makrovariablen können, wie der Name schon sagt, vom der Benutzer selbst bestimmt werden. Sie können lokal oder global vereinbart werden. (siehe Kap. 2.2). Ihr zugewiesener Wert bleibt konstant bis er explizit geändert wird. Automatische Makrovariablen beginnen immer mit den Buchstaben SYS. Sie enthalten z.B. Informationen über das Datum, das Betriebssystem oder den Ausführungsmodus. Makro-Programmanweisungen sind den Anweisungen im Datenschritts ähnlich. Der Unterschied besteht darin, daß Makro-Programmanweisungen immer mit "%" beginnen, auf das ein Makro-Schlüsselwort folgt. Sie können z.B. Variablen verändern, Werte zuweisen und ausgeben, und sie können Verzweigen und bedingtes Ausführen (%IF..%THEN) von SAS-Anweisungen herbeiführen. Makro-Funktionen verarbeiten Argumente (z.B. Zeichenketten). Sie können z.B. logische Ausdrücke auswerten und Zeichenketten zählen. Sie sind den Funktionen im Datenschritt ähnlich, weisen darüber hinaus aber auch spezielle Möglichkeiten auf, die nur im Makrobereich gelten. Makro-Funktionen sind auch im Data- oder Proc-Schritt einsetzbar. Makro-Routinen bewerkstelligen z.B. den Datenaustausch zwischen Makros und Data-Schritt (SYMPUT, SYMGET) oder rufen Anwendungen innerhalb eines Makros auf.

    2. SAS-Makrovariablen

    Syntax: &Variablenname Länge: 1-8 Zeichen, der Variablenname muß mit einem Buchstaben oder einem Unterstrich beginnen, gefolgt von Buchstaben, Zahlen oder Unterstrichen. Beispiel: &SYSDATE

    &SDS &HANSI SAS-Makrovariablen sind gekennzeichnet durch ein Ampersand (&) gefolgt von mindestens einem nichtleeren Zeichen. Es gibt

    • automatische Makrovariablen (die direkt vom SAS System zur Verfügung gestellt werden) und • benutzerdefinierte Makrovariablen.

    Der Makro-Prozessor setzt an die Stelle des Variablennamens den entsprechenden Wert ein (Textstring). Dieser Textstring kann mindestens 1024 Zeichen lang sein, der maximale Wert ist vom Betriebssystem abhängig.

  • 8

    2.1 Automatische Makrovariablen

    Automatische Makrovariablen werden automatisch vom Makro-Prozessor zur Verfügung gestellt. Sie beginnen alle mit den Buchstaben SYS. Da diese Kombination für das SAS-System reserviert ist, sollten Sie deshalb nie diese Kombination am Anfang eines Variablennamens benutzen. Die wichtigsten automatischen Makrovariablen und ihre Funktion:

    SYSDATE Aktuelles Datum des Programmstarts SYSDAY Wochentag des Programmstarts SYSTIME Zeit des Programmstarts

    SYSENV Ausführungsmodus, FORE=interaktiv, BACK=Batchjob SYSSCP Betriebssystem (als Abkürzung) SYSVER SAS-Version SYSDEVIC aktueller Device Driver SYSSCPL ausführlichere Infos zum Betriebssystem (ab SAS-Version

    6.10)

    SYSERR Fehlerinformation (Return Code) von Prozeduren SYSINFO ähnlich wie SYSERR SYSFILRC Return Code der letzten Filename-Anweisung SYSLIBRC Return Code der letzten Libname-Anweisung SYSRC Return Code des letzten Betriebssystem-Kommandos

    SYSLAST Name der zuletzt erzeugten SAS-Datei

    libref.dateiname (ein Name) SYSDSN Name der zuletzt erzeugten SAS-Datei

    libref dateiname (zwei Namen) Verwendet werden können diese Variablen u.a. in Textzeilen, die mit

    • Title-Anweisungen, • Footnote-Anweisungen • Note-Anweisungen und • Put-Anweisungen

    erzeugt werden. Falls Sie, wie z.B. im nächsten Beispiel, Title- und Footnote-Anweisungen benutzen, müssen Sie doppelte Anführungszeichen (Gänsefüßchen) verwenden, da ansonsten die automatischen Makrovariablen nicht aufgelöst werden. Beispiel: proc gslide;

    title "Heute ist &sysday, der &sysdate,&systime Uhr";footnote "SAS-Version &sysver";run;

    Anmerkung: Die automatischen Makrovariablen geben ihre Information in englischer Sprache aus. Alle automatischen Makrovariablen finden Sie auf den Seiten 55-59 im "SAS Guide to Makro Processing" beschrieben.

  • 9

    2.2 Benutzerdefinierte Makrovariablen

    Sie können eigene Makrovariablen auf verschiedene Weise definieren. Die einfachste und gebräuchlichste Art ist die Verwendung von "%let". Weitere Möglichkeiten der Erzeugung benutzerdefinierter Makrovariablen finden Sie im Kapitel 4.1. 2.2.1 Erzeugung von benutzerdefinierten Makrovariablen Syntax: %let makrovariable=wert; Beispiel: %let A=13;

    %let Name=Alois Vorderhuf%let Monat=November

    Die Variable makrovariable wird erzeugt, falls diese nicht bereits existiert, und sie bekommt den Wert wert zugewiesen. Falls Sie der gleichen Variablen nacheinander mehrere Werte zuweisen, wird der Wert überschrieben. Als Wert können Sie beliebige Zeichenketten zuweisen. Es ist auch möglich, Makrovariablen bereits bestehende Makrovariablen als Wert zuzuweisen. Beispiel: %let Datum=&SYSDATE; Die Zuweisung erfordert keine Anführungszeichen. Werden diese trotzdem verwendet, werden sie als Teil des Wertes interpretiert. Die %LET-Anweisung entfernt führende und nachfolgende Leerzeichen des zugewiesenen Textes. Wollen Sie nachfolgende Leerzeichen berücksichtigen oder ein Semikolon als Textzeichen verwenden, müssen Sie die "%STR-Funktion" (siehe Kap. 6.3.6) verwenden. Beispiel: %let Name=%STR( Herr Hans Ulrich Meier);

    %let Druck=%STR(Proc Print; Run;); Falls Sie dagegen nur %let druck=Proc print;run;schreiben, hat ihre Variable druck nur den Wert "Proc print", da die %let-Anweisung nur bis zum Semikolon liest. 2.2.2 Ausgabe des Wertes benutzerdefinierter Makrovariablen Wenn Sie sich den Wert ihrer Makrovariablen anzeigen lassen wollen, verwenden Sie am einfachsten die "%put-Anweisung". Sie schreibt den Wert ihrer Makrovariablen ins LOG-Fenster. (Analog zur Put-Anweisung für die Ausgabe von normalen Variablen.) Beispiel: %put &Name;Ausführlich beschrieben wird die "%put-Anweisung" in Kapitel 5.2. 2.2.3 Verkettung von Makros Sie können Text direkt an einen Makro-Namen anhängen. Damit läßt sich z.B. eine Variablenliste für die Keep-Anweisung erzeugen: Beispiel: Ergebnis: %LET start=1;%LET ende=10;keep var&start-var&ende;

    keep var1-var10

  • 10

    Wollen Sie Makrovariablen voranstellen, müssen Sie dies folgendermaßen tun: Beispiel: %let prefix=item;

    var &prefix.1-&prefix.10; Der Punkt beendet die Makro-Anweisung und es wird die var-Anweisung var item1-item10erzeugt. Ohne den Punkt sucht der Makro-Prozessor nach den Makrovariablen &prefix1, bzw. &prefix10. Zur Erzeugung eines zweiteiligen SAS-Dateinamens sind daher zwei hintereinander folgende Punkte zu verwenden: Einen zum Beenden der Makrovariablen, den anderen zur Abtrennung des Librefs vom Dateinamen: Beispiel: %let lref=mein;

    %let dat=eins;

    data &lref&dat; erzeugt data meineins;data &lref.&dat; erzeugt ebenfalls data meineins;data &lref..&dat;erzeugt dagegen data mein.eins; 2.2.4 Indirekte Zuweisung von Werten Beispiel: Ergebnis: %let device=hp7475a;%let &device=online;%put &device=&hp7475a; hp7475a=online Die Zeile %put der &device ist &hp7475a..; liefert der hp7475a ist online, da die eingesetzte Makrovariable &device zu hp7475a aufgelöst wird. 2.2.5 Das Auflösen von mehrfachen Ampersands Zwei Ampersands (&&) lösen sich zu einem Ampersand (&) auf. Mehrfache Ampersands sind sinnvoll beim Auflösen von Variablen, die einen gemeinsamen Stamm und numerische Endungen haben. Beispiel: %Let device1=hp7475a;

    %Let device2=hp7475b;%Let device3=xcolor;%Let device4=ps300;%let n=3;

    Ergebnis: %put &device&n; erzeugt einen Fehler, da &device nicht referenziert ist. %put &&&device&n; löst zuerst && zu & auf, danach &n zu 3 und letztendlich &device3 zuxcolor. Übungsaufgaben

    1. Welchen Wert nehmen die Variablen an, wenn Sie die folgenden Anweisungen der Reihe nach ausführen? Überlegen Sie sich die Antworten zunächst ohne Zuhilfenahme von SAS und überprüfen Sie danach am Computer, indem Sie die Anweisungen ausführen, ob ihre Antworten richtig waren.

    Anweisung Wert

  • 11

    %let vname=hans; %let name=&vname Schreiner; %let nachname=Schreiner; %let nname=&&nachname; 2. Im Verzeichnis n:\SASurz\daten finden Sie die SAS-Datei IRIS.SSD mit den Meßergebnissen von Fishers berühmtem Experiment mit seinen Iris-Arten. Schreiben Sie ein SAS-Programm zum Ausdruck der Datei (proc print). Übergeben Sie Libref und Dateinamen über Makrovariaben. Bilden Sie eine Titel- Anweisung, die aussagt, um welche Datei es sich handelt. Versehen Sie die Fußnote mit dem aktuellen Datum und der Uhrzeit. 3. Gegeben seien folgende %let Anweisungen %let a=Hallo;

    %let a1=Auf Wiedersehen;%let b=Gutes Gelingen;%let c=Tschuess;

    Überlegen Sie, was die folgenden %put-Anweisungen erzeugen und überprüfen Sie es: %put &a,&b;

    %put c&a,&b;%put c&a.&b;%put &c,&a1;%put &c,&a.1;

    4. Submittieren Sie folgendes Programm. Woran liegt es, daß der Makro-Prozessor die automatischen Makrovariablen nicht auflöst? proc gslide;

    title 'Grafik vom &Sysdate, SAS-Version &sysver';run;

    TIP! Verwenden Sie folgende System-Optionen, die Ihnen bei der Fehlersuche behilflich sind: • MPRINT• MLOGIC• SYMBOLGEN

    Alle drei System-Optionen geben zusätzliche Informationen über das ablaufende SAS-Makro im Log-Fenster aus. Sie aktivieren sie, indem sie die Options-Anweisung entsprechend einstellen. Aufruf: options symbolgen mlogic mprint; MPRINT: Der Makro-Prozessor gibt den aufgelösten SAS-Code aus. Sie erfahren dadurch, ob eine Makro-Programmanweisung ausgeführt wurde oder nicht. MLOGIC: Spiegelt den Ablauf des Makros, indem es zeitgleich die Programmanweisungen ins Log-Fenster schreibt. SYMBOLGEN: Zeigt Makro-Referenzen an, z.B. ob eine Variable aufgelöst wurde und welchen Wert die Variable besitzt. Alle drei Optionen werden mit nomprint, nomlogic und nosymbolgen wieder zurückgesetzt.

  • 12

    3. Die %Macro-Anweisung

    3.1 Definition und Aufruf von SAS-Makros

    Ein SAS-Makro ist ein Text zwischen einer %macro und einer %mend-Anweisung. Syntax: %macro name(parameter) / optionen; Makrotext;

    %mend name;

    Beispiel: %macro datum;Title "Heute ist &sysday, der &sysdate";

    %mend datum;

    Aufruf: %datum

    Das Makro %datum erzeugt automatisch eine Überschrift mit dem aktuellen Datum. Die %macro-Anweisung

    •�beginnt die Definition des Makros, • weist dem Makro einen Namen zu und • kann (optional) eine Parameterliste und Optionen übergeben.

    3.2 Makro-Name

    Der Name des Makros muß ein gültiger SAS-Name sein. Es gibt reservierte Worte, die nicht verwendet werden dürfen, etwa GO,RUN,OPEN usw.. Werden Sie trotzdem verwendet, erscheint folgende Fehlermeldung: ERROR: Macro NAME has been given a reserved name.ERROR: A dummy macro will be compiled.

    3.3 Makro-Parameter

    Makro-Parameter sind Makrovariablen, die mit dem Aufruf an das Makro übergeben werden. Dies ist, neben der %let-Anweisung, eine weitere Art, Makrovariablen zu bilden. Beispiel: %macro mittel (SDS);

    Proc means data=&SDS;run;

    %mend mittel; Aufruf: %mittel(co.blutbild) In Klammern steht der Wert, der an die Makrovariablen SDS übergeben wird. In diesem Beispiel bekommt der Parameter SDS den Wert co.blutbild zugewiesen. Die Parameter in der Makro-Definition

    • sind in Klammern eingeschlossen, • werden durch Kommas getrennt, • können mit ihrer Position oder mit einem Schlüsselwort spezifiziert werden und

  • 13

    • definieren lokale Makrovariablen, d.h. Variablen, die nur während der Ausführung des Makros gültig sind. (Im Gegensatz zu globalen Makrovariablen, siehe Kap. 4.) 3.3.1 Positions- und Schlüsselparameter

    Makro-Parameter können entweder als Positionsparameter (posparm) oder Schlüssel-parameter (keyparm) übergeben werden. Der wesentliche Unterschied zwischen beiden besteht darin, daß das Makro Positionsparameter allein durch ihre Position beim Aufruf erkennt, und Schlüsselparameter mit Variablennamen und Gleichheitszeichen aufgelistet werden müssen. Beispiel für Positionsparameter: %macro name(posparm-1, posparm-2);Beispiel für Schlüsselparameter: %macro name(keyparm-1=wert1, keyparm-2=wert2);

    Die Positionsparameter • erscheinen ohne Gleichheitszeichen, • müssen in der im Makro-Aufruf definierten Reihenfolge aufgelistet werden, • haben den Wert Null zum Zeitpunkt der Defintion und können diesen beibehalten, wenn ein

    Komma als Platzhalter beim Aufruf eingesetzt wurde. Die Schlüsselparameter

    • werden mit einem Gleichheitszeichen aufgelistet, • können in beliebiger Reihenfolge angegeben werden, • können mit Defaultwerten (auch Null) versehen werden und • brauchen beim Aufruf nicht genannt zu werden.

    Positions- und Schlüsselparameter können auch gemeinsam in Makros auftreten, doch müssen die Positionsparameter zuerst aufgelistet werden. Beispiel 1: %macro print (var1,var2,var3,sds=_last_);

    proc print data=&SDS;var &var1 &var2 &var3;run;

    %mend print; Aufruf: %print(albumin,calcium,alter,SDS=co.blutbild); Die Positionsparameter Var1, Var2 und Var3 erhalten die Werte Albumin, Calcium undAlter. Der Schlüsselparameter SDS erhält den Wert co.blutbild. Der Defaultwert ist auf _last_ gesetzt; dies bedeutet, daß automatisch der zuletzt bearbeitete Datensatz verwendet wird, falls im Makroaufruf kein neuer Dateiname angegeben wird. Beispiel 2: %macro ttest (var1,var2,classvar,sds);

    proc ttest data=&SDS;class &classvar;var &var1 &var2 ;

    run;%mend ttest;

    Aufruf 1: %ttest (calcium,albumin,pille, co.blutbild);Aufruf 2: %ttest (calcium,,pille, co.blutbild);

    Im zweiten Beispiel werden die Positionsparameter var1, var2, classvar und sds verwendet. Beim zweiten Aufruf soll der T-Test nur für eine Variable berechnet werden. Um eine

  • 14

    Fehlermeldung zu vermeiden, muß anstelle eines Wertes für var2 ein Komma angegeben werden. Durch das Komma überspringt der Makro-Prozessor diesen Wert, und erkennt die nachfolgenden Variablen richtig. Probieren Sie aus, was passiert, wenn sie bei Aufruf 2 das Komma weglassen. Übungsaufgaben

    5. Welcher SAS-Code wird mit folgendem Makro erzeugt: %macro meintitl;

    title "Heute ist &sysday, &sysdate";%mend meintitl;

    Wie lautet der Aufruf dieses Makros? 6. Schreiben Sie ein Makro %sortier, das die Proc Sort aufruft. Übergeben Sie die Informationen über den zu bearbeitenden Datensatz und die by-Variable über Positionsparameter. 7. Fügen Sie in das Makro %Sortier folgende Ergänzungen ein: • die Prozedur Print zur Kontrolle und • eine Titel-Zeile mit dem aktuellen Datum. 8. Schreiben Sie ein Makro %Plotte, das die Prozedur Gplot aufruft. Das Makro sollte 3 Schlüsselparameter haben: • Name der zu verwendenden SAS-Datei, • Name der Variable, die auf der x-Achse aufgetragen wird und • Name der Variable, die auf der y-Achse aufgetragen wird, a. Ergänzen Sie das Makro um eine dritte Variable z, die als Gruppierungsvariable fungieren soll. (plot x*y=z). b. Bearbeiten Sie mit dem Makro den Beispieldatensatz IRIS, den sie im Verzeichnis 'N:\SASURZ\DATEN' finden. Plotten sie PL gegen PW, mit der Variable BLUME als Gruppierungsvariable. c. Fügen Sie eine where-Anweisung für die Variable z ein, und übergeben Sie die Einschränkungsbedingung als Positionsparameter. d. Fertigen Sie sich für jede der drei Blumenarten ein eigenes Schaubild an. 9. Schreiben Sie ein Makro KREUZTAB, das die Prozedur FREQ aufruft. Das Makro sollte drei

    Parameter haben: Zwei Positionsparameter für die Variablen in den Zeilen und den Spalten und ein Schlüsselparameter für den Namen des SAS-Datensatzes.

    Klassifizieren Sie die Variable SL so, daß vier etwa gleichgroße Gruppen entstehen. Dazu

    müssen sie sich ein Format definieren. Erzeugen Sie danach eine temporäre Datei IRIS, in der sie das Format zuweisen. Rufen Sie das Makro für die temporäre Datei IRIS auf und tragen Sie die klassifizierte Variable SL gegen BLUME auf. (Tip: Quartil-Bildung mit PROC UNIVARIATE, Klassifizierung mit PROC FORMAT.)

  • 15

    4. Lokale und globale Makrovariablen

    Das SAS-System unterscheidet zwischen • globalen und • lokalen Makrovariablen.

    Die globalen Makrovariablen gelten während der gesamten SAS-Sitzung und können an beliebiger Stelle verwendet werden, sobald sie definiert wurden. Globale Variablen sind z.B. die unter Kap. 2.1 beschriebenen automatischen Makrovariablen wie &sysdate oder &systime. Im Unterschied dazu gelten die lokalen Makrovariablen nur in der Umgebung, die während eines Makroaufrufs angelegt wird. Diese Variablen sind daher nur innerhalb des Makros oder innerhalb darin verschachtelter Makros verfügbar. Die Werte der Makrovariablen werden in Symboltabellenabgelegt: die Werte der globalen Variablen in einer einzigen globalen Tabelle, die Werte der lokalen Variablen in jeweils eigenen lokalen Symboltabellen. 4.1 Erzeugung von lokalen und globalen Makrovariablen

    Makrovariablen können auf verschiedene Weise erzeugt werden: • vom SAS-System (automatische Variablen, Kap.2.1), • mit der Symput-Routine (siehe Kap. 7.1.2), • durch die Parameter beim Makro-Aufruf (siehe Kap. 3.3), • mit der %input-Anweisung (siehe Kap. 5.3), • mit der %let-Anweisung (siehe Kap. 2.2), • mit der %global-Anweisung (siehe Kap. 4.1.1), • mit der %local-Anweisung (siehe Kap. 4.1.2).

    Die Stelle, an der die Variable erzeugt wird, entscheidet, ob die Variable global oder lokal ist: wie wo was automatisch beim SAS-Aufruf global (immer) %let-Anweisung außerhalb eines Makros global (aktuelle Sitzung) %let-Anweisung innerhalb eines Makros lokal Makro-Parameter Parameterliste beim Aufruf lokal %input-Anweisung innerhalb und außerhalb von

    Makros global (aktuelle Sitzung)

    symput-Routine innerhalb und außerhalb von Makros

    global (aktuelle Sitzung)

    %global-Anweisung innerhalb und außerhalb von Makros

    global (aktuelle Sitzung)

    %local-Anweisung innerhalb eines Makros lokal Beispiel: %let name=WILHELM;�

    %macro chameleo;%let name=HANS;�%put &name;

    %mend chameleo;

  • 16

    %chameleo%put &name;�

    Überprüfen Sie am Computer, was passiert. � Mit dieser %let-Anweisung wird die Makrovariable name global definiert. Falls Sie die erste %let-Anweisung weglassen, ist die Makrovariable name nur lokal definiert und die Variable wird nicht richtig aufgelöst, wenn Sie sie außerhalb des Makros � verwenden wollen. Sie erhalten folgende Mitteilung: WARNING: Apparent symbolic reference NAME not resolved.

    � Ist die Variable global definiert, so trägt sie den Wert, den sie zuletzt zugewiesen bekommen hat. In diesem Beispiel nimmt die Variable name zuerst den Wert WILHELM � und dann HANS � an. 4.1.1 Die %Global-Anweisung Die %global-Anweisung erzeugt globale Makrovariablen, d.h. Variablen, die sowohl innerhalb als auch außerhalb von Makros benutzt werden können. Mit der %global-Anweisung bilden sie zunächst lediglich eine Variable, weisen ihr aber im Unterschied zur %let-Anweisung noch keinen Wert zu. Sie vereinbaren damit den Status der Makrovariablen, in diesem Fall global. Syntax: %global Makrovariablenname; Beispiel: %global Gfirst; Sie haben nun eine globale Makrovariable Gfirst angelegt, die aber bislang keinen Wert hat. Den weisen Sie ihr mit der %LET-Anweisung zu. Da Sie global vereinbarte Makrovariablen sowohl innerhalb als auch außerhalb eines Makros verwenden können, ist es möglich z.B. mittels globaler Makrovariablen Informationen eines Makros in ein anderes Makro zu transportieren. Beispiel: %let sds=co.blutbild;

    %macro compute;%global monat;�%let monat=juli;proc means data=&sds;

    Title "report für &month";run;

    %mend compute;

    %macro write;proc print data=&sds;

    Title "report für &monat";run;

    %mend write;Aufruf: %compute

    %write Submittieren Sie dieses Programm zuerst ohne und dann mit der %global-Anweisung �, und achten Sie auf die Überschrift (title) im Output-Fenster. Wenn Sie die %global-Anweisung weglassen, erscheint im Log-Fenster für das Makro write folgende Mitteilung:

    WARNING: Apparent symbolic reference MONAT not resolved.

  • 17

    Dies bedeutet, daß der Makro-Prozessor die Makrovariable monat nicht auflösen kann, da diese nur lokal für das Makro compute vereinbart wurde. Fügen Sie jetzt die %global-Anweisung wieder hinzu, ist die Variable monat global vereinbart und kann überall verwendet werden. Ausnahme: Globale Makrovariablen können nicht innerhalb eines Makros verwendet werden, wenn die Makrovariablen dort bereits lokal verwendet werden. Die %global-Anweisung hat keine Auswirkung, wenn die Variable bereits global definiert wurde, z.B. mit einer %Let-Anweisung außerhalb eines Makros. 4.1.2 Die %Local-Anweisung

    Syntax: %local Makrovariablenname; Beispiel: %local nummer; Die %local-Anweisung benennt Variablen, die nur innerhalb des aktuellen Makros Gültigkeit haben. Dies ist nur dann notwendig, wenn die Variable bereits außerhalb existiert. Dies kann z.B. zum Schutz von Indexvariablen sein, die nicht überschrieben werden sollen. Die %local-Anweisung kann nur innerhalb von Makros verwendet werden. Variablen, die mit einer %local-Anweisung definiert wurden, besitzen den Wert 0, solange ihnen kein anderer Wert mittels einer %let-Anweisung zugewiesen wurde. Dieser Wert gilt aber nur innerhalb des Makros. Variablen mit gleichem Namen, die bereits in der Umgebung definiert wurden, behalten ihren zuvor vereinbarten Wert. 4.2 Makros innerhalb von Makros

    Wird in einem Makro ein anderes Makro aufgerufen, spricht man von verschachtelten (oder genesteten) Makros. Die globale äußere Umgebung wird als Niveau 0 bezeichnet. Je tiefer die Verschachtelung fortschreitet, desto höher wird das Niveau gezählt. Eine Makrovariable ist innerhalb der Umgebung, in der sie definiert wurde und in jeder höheren Umgebung referenzierbar (also in den verschachtelten Makros). Beispiel: %macro drei;

    proc means data=&sds;NIVEAU 3 var &xvar &yvar;

    run;%mend drei;

    %macro zwei;proc gplot data=&SDS;

    NIVEAU 2 plot &yvar*&xvar;run;%drei

    %mend zwei;

    %macro eins(SDS,yvar,xvar);proc print data=&SDS;

    NIVEAU 1 var &yvar &xvar;run;

    %zwei%mend eins;

    Aufruf: %eins(co.blutbild,alter,albumin)

  • 18

    In diesem Beispiel ruft das tiefste Makro eins, das höher verschachtelte Makro zwei auf, welches wiederum das Makro drei aufruft. Sowohl Makro zwei, als auch Makro drei verwenden die Makrovariablen sds, yvar und xvar, die im Makro eins definiert wurden. Übungsaufgaben

    10. Beantworten Sie zu dem folgenden SAS-Makro untenstehende Frage: %let id=ssn;

    %macro write(SDS=_last_);%let ort=NEW YORK;proc sort data=&SDS;

    by &id;proc print;

    title1 "Arbeiter im &ort Büro";title2 "aufgelistet nach &id";footnote "Stand: &sysdate";

    run;%mend write;

    Welche der folgenden Variablen sind lokal, welche global? Warum? id, SDS, ort, sysdate;

    11. Welcher SAS-Code wird von dem Makro %let first=Text außerhalb des Makros definiert;%macro refs;%local first;%global second;%let first=Text innerhalb des Makros definiert;%let second=Zweite Textzeile;%let third=Dritte Textzeile;%put first;%put second;%put third;

    %mend refs;

    erzeugt, wenn nacheinander die Zeilen %refs%put &first;%put &second;%refs%put &first;%put &second;%put &third;

    submittiert werden? 12. Schreiben Sie ein Makro %machdat, mit dem sie sich einen Datensatz erstellen können, der zwei zufällig normalverteilte Variablen besitzt (x und y) und eine Indexvariable i, die gleichzeitig die Anzahl der Beobachtungen sein soll. Übergeben Sie an das Makro außerdem einen Schlüsselparameter, der den Dateinamen enthält (Variable dateinam) (Tip: Verwenden Sie die rannor-Funktion und eine do-Anweisung). Schreiben Sie ein zweites Makro %prinsort, das Datensätze sortieren und ausgeben kann (Proc Sort und Proc Print). Verschachteln Sie dieses Makro im Makro %machdat, sodaß sie den soeben erstellten Datensatz damit bearbeiten können (Zusatz: Vereinbaren Sie die Variable, die den Dateinamen enthält als globale Makrovariable).

    5. SAS-Makro-Programmanweisungen

  • 19

    Makro-Programmanweisungen sind die Datenschritt-Anweisungen der Makro-Sprache. Sie unterscheiden sich oftmals nur dadurch, daß die Makro-Programmanweisungen mit einem "%" beginnen und dadurch den Makro-Prozessor ansprechen. Sie können alle Makro-Programmanweisungen innerhalb von Makros benutzen, manche zusätzlich auch außerhalb von Makros. Makro-Programmanweisungen und wo sie benutzt werden können:

    Anweisungen, die überall benutzt werden können

    Anweisungen, die nur innerhalb von Makros benutzt werden können

    %* %MACRO %DO %IF-%THEN%DISPLAY %MEND %DO %UNTIL Iteratives %DO%GLOBAL %PUT %DO %WHILE %label%INPUT %SYSEXEC %END %LOCAL%KEYDEF %WINDOW %GOTO%LET

    5.1 %*-Anweisung

    Diese Anweisung dient der Kommentierung des Makros. Sie kann überall verwendet werden. Im Unterschied zu normalen Kommentarzeilen (*..;) erscheinen die Makro-Kommentare nicht im Log-Fenster. Wie gewohnt können Sie aber auch mit der Zeichenfolge /*......*/kommentieren. Syntax: %*Kommentar; Beispiel: %macro kommenta(sds,x);

    %*Dieses Makro überprüft, ob versehentlich eineIdentifikationsnummer vergeben wurde, die

    kleiner als 0 ist.;data _null_;%***Schreibe die Beobachtungen mit x

  • 20

    %mend testput;

    %testput; Ergebnis: Makro TESTPUT beginnt die Ausführung

    Makro TESTPUT beginnt am Friday.Semikolons(;) beenden SAS-Anweisungen.

    Fisher's exakter Test

    � Die erste %put-Anweisung schreibt eine einfache Textzeile. � Es müssen am Satzende zwei Punkte verwendet werden, da ein Punkt automatisch als

    Begrenzungszeichen erkannt wird und erst der zweite Punkt den Satz beendet. � Um ein Semikolon als Textzeichen zu verwenden, muß die %str-Funktion verwendet werden,

    die Sonderzeichen als Text behandelt. � Produziert eine Leerzeile; � Diese %put-Anweisung erzeugt ein offenes Anführungszeichen. Dies erkennt SAS nur dann als

    Textzeichen, wenn das Prozentzeichen davor steht. Probieren Sie aus, was passiert, wenn Sie das Prozentzeichen weglassen.

    5.3 %Input-Anweisung

    Mit der %input-Anweisung ist es möglich, während des Ablaufs eines Makros Daten vom Benutzer zu erfragen. Diese können sogleich im Makro verwendet werden, indem der erfragte Wert einer Makrovariable zugewiesen wird. Die %input-Anweisung kann innerhalb und außerhalb von Makros verwendet werden, allerdings nur im interaktiven Modus. Werte mit Leerzeichen müssen in Anführungszeichen eingegeben werden, z.B. bei Vor- und Nachname. Syntax: %INPUT name1 name2...; Beispiel: %macro identi;

    %put Nennen Sie Ihren Namen und Wohnort;%input Name Ort;%put Nennen Sie Ihr Alter;%input alter;%put &Name wohnt in &ort, und ist &alter alt.;

    %mend identi;Aufruf: %identi; Wenn Sie das Makro %identi submittieren und aktivieren, erscheint der Text der %put-Anweisungen im Log-Fenster und verlangt die Eingabe ihrer Daten. Sie schreiben diese in den Programm Editor und submittieren anschließend. Mit Hilfe der %input-Anweisung erfasst der Makro-Prozesor nun den Wert ihrer Variable. Werden mehr Werte angegeben, als Variablen definiert sind, werden diese in der automatischen Variable SYSBUFFR gespeichert (siehe Seite 80 in "SAS Guide to Macro Processing"). Der einfachste Weg, einen aus mehreren Teilen bestehenden Wert aufzunehmen, ist der Umweg über die SYSBUFFR-Variable. Beispiel: %macro vornach;

    %put Geben Sie ihren vollen Namen an;%input;�%let name=&sysbuffr;�

  • 21

    %put &name;%mend vornach;

    � Der Makro-Prozessor schreibt zunächst die Antwort auf die erste %put-Anweisung in die automatische Variable &SYSBUFFR.

    � Danach wird mit der %let-Anweisung vereinbart, daß der Inhalt von SYSBUFFR in die Variable name geschrieben wird.

    5.4 %If - %Then / %Else-Anweisung

    Mit dieser Anweisung können Anweisungen bedingt ausgeführt werden. Die %if-%then/%else-Anweisung der Makro-Sprache funktioniert synonym zur if-then/else Anweisung im Datenschritt. Sie kann nur innerhalb von Makros verwendet werden. Syntax: %IF logischer Ausdruck %THEN SAS-Anweisung; %ELSE SAS-Anweisung; Die %else-Anweisung ist optional. Die SAS-Anweisungen, die %then und %else folgen, können

    • Makro-Programmanweisungen, • konstanter Text und • logische Ausdrücke

    sein. Beispiel: %if &i=1 and &j>5

    %then %put Überprüfen Sie die Indexvariablen.;%else %put Alles Okay;

    Wenn die Makrovariablen i gleich 1 und j größer als 5 sind, dann, und nur dann, soll ins Log-Fenster Überprüfen Sie die Indexvariablen geschrieben werden. Sonst (%else) soll im Log-Fenster Alles okay erscheinen. 5.5 %Do - %End-Anweisung

    Sie können mit der %do und der %end-Anweisung eine Do-Gruppe definieren, die als Block ausgeführt wird. In Verbindung mit der %if-%then-Anweisung können Sie auf diese Weise mehrere SAS-Anweisungen ausführen. Die %do-%end-Anweisung kann nur innerhalb eines Makros verwendet werden. Syntax: %do; Text und Makro-Programmanweisungen %end; Beispiel: %macro frage(aaa,sds);

    %if &aaa=1 %then �%do;

    Proc Print data=&sds;run;

    %end;%else �

    %do;Proc contents data=&sds;

    run;%end;

    %mend frage;

  • 22

    Aufruf: %frage(1, co.iris)� %frage(Unsinn, co.iris)� � Falls die Variable aaa den Wert 1 annimmt, wird die Prozedur Print verwendet. � Falls die Variable aaa einen anderen Wert als 1 zugewiesen bekommt, wird die Prozedur Contents ausgeführt. Übungsaufgabe

    13. Erzeugen Sie ein Makro NUMMER, das zuerst abfragt, welchen Datensatz Sie bearbeiten wollen, und danach folgenden Text im Log-Fenster erzeugt: Wählen Sie eine der beiden Möglichkeiten:

    Ausdruck (geben Sie eine 1 ein)Mittelwerte (geben Sie eine 2 ein).

    Je nachdem, welche Entscheidung der Benutzer getroffen hat, soll nun entweder Proc

    Print oder Proc Means ausgeführt werden. Kommentieren Sie das Makro entsprechend seinen Programmteilen. 5.6 %Do - %To - %End-Anweisung (Iterative %Do-Anweisung)

    Die %Do-%To-%End-Anweisung führt bis zu einem definierten Endpunkt immer wieder die gleichen Programmteile aus. Man spricht von iterativen %Do-Schleifen (loops). Iterative %Do-Schleifen sind nicht mit %while und %until verknüpfbar. Syntax: %do Makrovariable=Start %to Stop ; Text und Makro-Programmanweisungen %end;

    Makro-variable

    Benennt eine Makrovariable, deren Wert die Anzahl der %Do-Schleifen regelt. Existiert diese Indexvariable noch nicht, wird sie vom Makro-Prozessor angelegt.

    start Startpunkt der %Do-Schleifen, muß ganzzahlig sein. stop Endpunkt der %Do-Schleifen, muß ganzzahlig sein

    Inkrement Mit der optionalen %by-Anweisung kann vereinbart werden, in welchen Schritten die %DO-Schleife ausgeführt wird (Standard=1).

    Beispiel 1: %macro create;

    %do i=1 %to 3;data monat&i;

    infile in&i;input produkt kosten datum;

    run;%end;

    %mend create; Aufruf: %create;Ergebnis: data monat1;

    infile in1;input produkt kosten datum;

    run;data monat2;

  • 23

    infile in2;input produkt kosten datum;

    run;data monat3;

    infile in3;input produkt kosten datum;

    run; Die %do-Schleife wird 3 mal hintereinander ausgeführt. Die Indexvariable i wird in jedem Durchgang um das Inkrement 1 erhöht. Es ist auch möglich %Do-Schleifen zu verschachteln: Beispiel 2: %macro create2;

    %do jahr=90 %to 92;%do mon=1 %to 12;

    data dat_&jahr&mon;infile in&jahr&mon;input person umsatz zeit;

    run;%end;

    %end;%mend create2;

    Aufruf: %create2;Die Schleife wird 36 mal(3*12) durchgeführt, und erzeugt für jeden Monat der Jahre 90 bis 92 einen Datenschritt (siehe Ergebnis des ersten Beispiels). 5.7 %Do - %Until - %End-Anweisung

    Die %Do - %Until -Anweisung führt die %Do-Schleife so lange aus, bis eine zuvor vereinbarte Bedingung erfüllt ist. Syntax: %do %until (Ausdruck); Text und Makro-Programmanweisungen %end; Beispiel: %macro tue_bis(num);

    %put Start Macro tue_bis: num ist #%do %until(&num>10);

    %put ****&num****;%let num=%eval(&num+1);

    %end;%put Ende Macro tue_bis: num ist #

    %mend tue_bis; Aufruf: %tue_bis(-23) In unserem Beispiel soll die %do-%until-Schleife so lange ausgeführt werden, bis die Variable NUM größer als 10 ist. Nach jedem Durchgang bekommt die Variable NUM mit Hilfe der %eval-Funktion (siehe Kap. 6.2) zu ihrem Ausgangswert (im Beispiel -23) eine 1 aufaddiert, und erhält somit einen neuen Wert. In dem Moment, in dem dieser Wert größer als 10 (also bei 11) geworden ist, bricht das Makro ab und es erscheint die Meldung, daß das Makro beendet ist. 5.8 %Do - %While - %End-Anweisung

  • 24

    Die %Do-%While-%End-Anweisung wiederholt Programmanweisungen, solange eine Bedingung erfüllt bleibt. Syntax: %Do %While(logischer Ausdruck); Text und Makro-Programmanweisungen; %End; Beispiele: %do %while(&a

  • 25

    run;%kurz: proc print data=_last_(obs=10);

    run;%mend info;

    Aufruf: %info Das Makro Info kann über den zuletzt benutzten Datensatz (data=_last_) optional kurz oder lang Auskunft geben. Wenn eine 2 eingegeben wird, springt der Makro-Prozessor automatisch zur Sprungmarke %kurz und führt die Prozedur Print für 10 Beobachtungen durch. 5.10 %Sysexec-Anweisung

    Mit Hilfe der %sysexec-Anweisung können innerhalb und außerhalb von Makros Betriebs-systemkommandos ausgeführt werden. Syntax: %sysexec Kommando; Beispiel: %sysexec cd\;

    %sysexec time;Beispiel: %macro makedir;

    if %upcase(&sysscp)=WIN %then%do;%sysexec cd\;%sysexec md Aufgabe;

    %end;%else %if %upcase(&sysscp)=RS6000 %then%do;%sysexec mkdir aufgabe;

    %end;%mend makedir;

    Aufruf: %makedir; Das Makro makedir erstellt auf Betriebssystemebene, wenn Sie unter SAS für Windows arbeiten, im Laufwerk D: das Verzeichnis aufgabe. Falls Sie unter AIX arbeiten, wird das Verzeichnis aufgabe in ihrem Home-Verzeichnis angelegt.

  • 26

    5.11 %Keydef-Anweisung

    Die %keydef-Anweisung ermöglicht die Definition und Abfrage von Funktionstastenbelegungen. Sie ist sowohl lokal als auch global verwendbar. Die Definition gilt nur für die aktuelle Sitzung oder solange, bis sie geändert wird. Sie können so z.B. Makros über Funktionstasten aufrufen. Syntax: %keydef key-name | 'key-name' | "keyname" ;

    key-name ist der Name einer beliebigen Funktionstaste, z.B. F1. Die maximale Länge für keyname ist 8 Zeichen

    text kann jeder beliebiger Text sein, die maximale Länge beträgt 80 Zeichen. Falls Sie Anführungszeichen, Semikola u.ä. verwenden wollen, müssen Sie den Text in Anführungszeichen setzen�.

    Beispiele: %keydef f12 zoom;

    %keydef f5 "clear log; clear output";�%keydef f11 %makedir;

    Übungsaufgaben

    14. Erzeugen Sie ein Makro MENUE, das folgenden Text im Log-Fenster erzeugt:

    Sie haben folgende Möglichkeiten:

    1. Patientenaufnahme2. Löschen eines Patienten3. Listenausdruck

    mit Sortierreihenfolgea. Familiennameb. Wohnort

    Treffen Sie Ihre Entscheidung: ___

    (Tip: %input und %str.) 15. Schreiben Sie ein Makro PROMPT, das den Namen einer SAS-Prozedur und den Namen des SAS-Datensatzes erfragt und die gewünschte Prozedur ausführt (Hinweis: Dies ist nicht für alle Prozeduren möglich). 5.12 %Window-Anweisung

    Die %Window-Anweisung erzeugt Fenster, die vom Makro-Prozessor gesteuert werden. Makro-Windows können Text darstellen und Eingabe aufnehmen. Sie haben verschiedene Gestaltungs-optionen, z.B. Farbe, Schriftpositionierung usw. Mit der %window-Anweisung definierte Fenster, können mit der %display-Anweisung (siehe 5.13) am Bildschirm anzeigt werden. Einmal definiert, gilt das Fenster bis zum Ende der aktuellen SAS-Sitzung. Der Name des Fensters erscheint in der Kopfzeile. Es kann sowohl über Kommando- als auch über Message-Zeilen verfügen. Anstatt der Kommandozeile kann man dem Fenster auch ein Pull-Down-Menü zuweisen, welches man zuvor mit der PMENU-Routine gebildet hat. Syntax: %window Fenstername Feld-Definition-1 ; %window Fenstername Gruppen-Definition-1 ;

  • 27

    Fenstername benennt das Fenster und muß angegeben werden. Es gelten die

    üblichen SAS-Namenskonventionen. Fensteroptionen spezifizieren allgemeine Eigenschaften des Fensters. Felddefinitionen Felder verbinden Text oder Makrovariablen mit einer Position im

    Fenster und dessen Eigenschaften Gruppen definiert eine Gruppe von Feldern, die gleichzeitig angezeigt

    werden. Beispiel: %window fenster� color=black irow=5�

    #10 @10 'Dies ist mein erstes Fenster'� color=white;Aufruf: %display fenster; �Fenstername �Fensteroptionen �Felddefinitionen 5.12.1 Fensteroptionen Es gibt folgende Optionen für die Fenstergestaltung, die Sie verwenden können: columns=Spaltenanzahl Hier bestimmen Sie die Anzahl der Spalten des Fensters, inklusive dem Rand. Wenn Sie

    dies nicht ausdrücklich festlegen, wird die größtmöglichste Spaltenanzahl, die auf dem jeweiligen Monitor möglich ist, gewählt.

    rows=Zeilenanzahl Anzahl der Zeilen des Fensters inkl. Rand, auf die das Fenster plaziert wird (Die Anzahl

    der Zeilen ist abhängig vom verwendeten Monitor). icolumn=Spalte Steht für "Initial Column" (frei übersetzt "anfängliche Spalte"). Definiert die Spalte, auf die

    das Fenster plaziert wird (Default=1, dies ist die linke obere Ecke des Fensters). irow=Zeile Steht für "Initial Row". Bestimmt die Zeile, auf die das Fenster plaziert wird (def.=1). color=Farbe Spezifiziert die Hintergrundfarbe des Fensters.Die Darstellung der Farben ist abhängig von

    ihrem Bildschirm. Folgende Farben können Sie wählen: Black Gray (oder Grey) Pink Blue Green Red Brown Magenta White Cyan Orange Yellow

    keys=keys-entry Sie können an dieser Stelle bestimmen, in welchem Katalog ihre Funktionstastenbelegungen zu finden sind. Ohne Katalogangabe wird der von SAS angelegte Katalog sasuser.profile verwendet. menu=pmenu-entry Falls Sie sich mit der Prozedur PMENU ein eigenes Pull-Down-Menü angelegt haben,

    können sie an dieser Stelle den Katalog vereinbaren, in dem das PMENU abgelegt ist. Ohne Katalogangabe wird der von SAS angelegte Katalog SASuser.profile verwendet.

    5.12.2 Felddefinitionen

  • 28

    Feld-Definitionen verbinden konstanten Text oder Makrovariablen mit einer Position im Fenster und dessen Attributen. Konstanter Text muß in Anführungszeichen stehen. Felder dürfen sich nicht überlappen. Es können sonst Fehler auftauchen, wie z.B. die inkorrekte Zuweisung von Werten zu einer Makro-Variable, da diese an einer falschen Stelle vereinbart sind. Syntax einer Feld-Definition mit konstantem Text: 'Text' | "Text“ Syntax einer Feld-Definition mit Makrovariable: Makro-Variable row column bezeichnet die genaue Position einer Makro-Variable oder eines konstanten Textes im Fenster. Sie vereinbaren die Position mit Hilfe von Zeilen- bzw. Spaltenpointern:

    Zeilenpointer (row): # und / (bewegt den Pointer in die nächste Zeile, auf Spalte 1) Spaltenpointer (column): @ und + (bewegt den Pointer in derselben Zeile, um eine von ihnen bestimmte Anzahl von Spalten weiter.)

    Beispiel: #3 @5 "Geben Sie ihren Vornamen ein"; Der Text erscheint in der dritten Zeile, beginnend mit der fünften Spalte. 'Text' | "Text" An dieser Stelle können Sie einen konstanten Text darstellen. Der Text muß in Anführungszeichen geschrieben sein. Makro-Variable benennt eine Makro-Variable, deren Wert entweder erscheinen soll, oder die an dieser Stelle einen Wert erhalten soll. Feldlänge definiert, wie lang die Eingabe des Wertes der Makro-Variable sein soll. Dies beeinflußt allerdings nicht die vereinbarte Länge der Makro-Variable. Wenn Sie lediglich den Wert einer Makrovariablen darstellen wollen, wählt der Makro-Prozessor automatisch die ihrer Größe entsprechende Länge der Variablen. Optionen Es gibt folgende Optionen: ATTR=attribute (Abkürzung A=) Mit Hilfe dieser Option können Sie vereinbaren, wie ihr Feld aussehen soll. Es gibt folgende Möglichkeiten: BLINK (blinkendes Feld) HIGHLIGHT (hell leuchtendes Feld) REV_VIDEO UNDERLINE (Feld wird unterstrichen)

    COLOR=color (Abk. C=) spezifiert die Farbe, in der ihr Feld erscheinen soll.

  • 29

    PROTECT=YES|NO Falls Sie PROTECT=YES angeben, ist ihr Feld geschützt und kann nicht überschrieben werden. Dies ist nur dann sinnvoll, wenn Sie eine Makro-Variable in einem Feld darstellen wollen; konstanter Text ist automatisch geschützt. REQUIRED=YES|NO vereinbart, daß eine Eingabe ins Feld erfolgen muß, da der Makro-Prozessor sonst nicht zum nächsten Feld springt. DISPLAY=YES|NO bestimmt, ob die Eingabe am Bildschirm erscheint oder nicht, z.B. bei der Abfrage von Passwörtern. AUTOSKIP=YES |NO (Abkürzung Auto=) Kontrolliert, ob der Cursor automatisch auf das nächste Eingabefeld springt oder erst nach Drücken der Enter-Taste. Wenn Sie AUTOSKIP=YES angeben, springt der Cursor automatisch in das nächste ungeschützte Eingabefeld. 5.12.3 Gruppen-Definition Die Gruppendefinition definiert eine Gruppe von Feldern, die gleichzeitig in einem Fenster angezeigt werden. Syntax: GROUP=Gruppenname Der Gruppenname muß den üblichen SAS-Namenskonventionen entsprechen. Zum Aufruf ist dann sowohl der Name des Fensters, als auch der Gruppenname anzugeben

    Beispiel: Fenster.monatDamit wird die Gruppe monat des Fensters Fenster aufgerufen.

    5.12.4 Automatische Variablen Die %window-Anweisung generiert automatisch die beiden folgenden Variablen: SYSCMD, die den Text des letzten Fensterkommandos enthält und SYSMSG, die den Text enthält, der in der Message-Zeile (erscheint unter der Komanndozeile) ausgegeben werden kann. Der Wert der Variable SYSMSG kann z.B. über eine %let- Anweisung definiert werden. Beispiele Beispiel 1: Das erste Fenster soll nur drei Textzeilen anzeigen. %window grusswin color=white

    #9 @32 'Guten Tag, hier ist ihr SAS System!'attr=highlight color=black#11 @35 "Heute ist &sysday, der &sysdate.." color=black#17 @28 'Drücken Sie die Enter-Taste um weiterzumachen.'color=blue;

    %display grusswin;

  • 30

    Das Fenster grusswin begrüßt den Benutzer und zeigt das aktuelle Datum (mit Hilfe der beiden automatischen Makrovariablen &sysday und &sysdate) an. Die Hintergrundfarbe ist Gelb, der Text erscheint Schwarz und Blau. Außerdem hat die erste Zeile das Attribut highlight. Um das Fenster am Bildschirm anzeigen zu lassen, ist folgende Makro-Programmanweisung nötig:

    %display grusswin;

    Folgendes Fenster erscheint auf dem Bildschirm:

    Beispiel 2: Im zweiten Beispiel werden zwei Gruppen definiert, die wahlweise angezeigt werden sollen. %window eingabe color=whitegroup=lang

    #3 @5 "Geben Sie in die folgenden Zeilen bitte die Daten ein." c=black#5 @5 "Bedenken Sie dabei, das Sie für das Geschlecht" c=black#7 @5 "folgende Codierung vornehmen müssen:" c=black

    #9 @5 "Frauen=1, Männer=0" c=black

    group=kurz#11 @8 "Name:" c=black @20 name 34 attr=underline required=yes c=black#13 @8 "Geschlecht:" c=black @20 sex 1 attr=underline required=yesc=black#15 @8 "Alter:" c=black @20 alter 2 attr=underline required=yes

    c=black;

    %macro DISP(typ);%if &typ=lang %then %display eingabe.lang noinput;%display eingabe.kurz;

    %mend DISP; In dem Fenster EINGABE enthält die Gruppe LANG eine ausführliche Anleitung zur Dateneingabe, die Gruppe KURZ zeigt dagegen lediglich die Variablennamen an. Das Makro DISP zeigt entweder beide Gruppen des Fensters an oder nur die kürzere Version, je nachdem welchen Wert die Variable Typ besitzt. Der Aufruf %DISP(lang)führt dazu, daß beide Gruppen des Fensters angezeigt werden, wie in Bild 2 zu sehen ist.

  • 31

    Bild 2: Makro DISP zeigt beide Gruppen des Fensters an.

    Falls die Makrovariable TYP allerdings einen anderen Wert als "lang" zugewiesen bekommt, wird nur die kurze Version am Bildschirm präsentiert, z.B. %DISP(x).

    Bild 3: Makro DISP zeigt nur die Gruppe "kurz" an.

    5.13 %Display-Anweisung

    Mit Hilfe der %Display-Anweisung können Makro-Windows angezeigt werden. Wenn ein Fenster mit geschützten Feldern (Protect=YES) angezeigt wird, kann die Anzeige durch Drücken der Enter-Taste beendet werden. Wenn das Fenster ungeschützte Felder enthält, müssen zuerst Werte in die Felder eingegeben werden, bevor das Fenster geschlossen werden kann. Syntax: %DISPLAY Fenster ;

    Fenster benennt das Fenster, das angezeigt werden soll Falls das Fenster Gruppen enthält (siehe Bsp. 5.12), müssen an dieser

    Stelle auch die Gruppen angegeben werden (müssen durch einen Punkt voneinander getrennt sein).

    NOINPUT Verhindert, das Werte in ein Feld eingegeben werden können. Außerdem können Sie die NOINPUT-Option verwenden, wenn Sie mehrere Gruppen eines Fensters gleichzeitig anzeigen wollen. Durch die NOINPUT-Option bleibt die Gruppe sichtbar, auch wenn spätere Gruppen angezeigt werden.

  • 32

    BLANK Löscht die Anzeige. Nur dann sinnvoll, wenn die %Display-Anweisung innerhalb eines Makros verwendet wird, da ansonsten die Anzeige automatisch nach Ausführung der %Display-Anweisung entfernt wird.

    BELL Sobald die Anzeige erscheint, ertönt ein kurzer Klingelton. DELETE Löscht den Fensterinhalt, nach dem das Fenster verarbeitet wurde

    (erst ab SAS-Version 6.10). Beispiel: %Display eingabe.kurz noinput bell;

    Übungsaufgabe

    16. Schreiben Sie ein Makro BEGINN, daß ein Fenster Anfang aufruft, das Sie am Anfang jeder SAS-Sitzung fragt, ob Sie folgende libname-Anweisungen setzen wollen:

    libname b'B:\';libname a'A:\';libname co 'N:\sasurz\daten';

    Falls die Abfrage mit JA (oder einer 1) beantwortet wird, sollen die Libname-Anweisungen gesetzt werden.

    6. SAS-Makro-Funktionen

    Makro-Funktionen verarbeiten Makroausdrücke, sogenannte Argumente, wie z.B. Variablen oder Zahlenketten, und erzeugen daraus ein Resultat, z.B. einen Buchstaben oder eine Zahl. Makro-Funktionen sind sowohl lokal als auch global zu verwenden. Beispiel: %put %eval(200+400); In diesem Beispiel wird mit Hilfe der %Eval-Funktion die Summe der beiden Argumente 200 und 400 berechnet. Mit Hilfe der %put-Anweisung wird das Resultat 600 ausgegeben. Die Makro-Funktionen lassen sich in vier Kategorien einteilen: 1. Bearbeitung von Zeichenketten 2. Auswertung von logischen und numerischen Ausdrücken 3. Behandlung von speziellen Zeichen 4. Interaktion mit Dateivariablen (siehe Kap. 7)

  • 33

    6.1 Funktionen zur Bearbeitung von Zeichenketten

    %index Findet das erste Auftreten einer Zeichenkette %length Bestimmt die Länge des Arguments %scan Sucht nach Worten %substr Erzeugt einen Substring %upcase Verwandelt Klein- in Großbuchstaben %qscan, %qsubstr%qupcase

    analog zu oben, führen aber zusätzliche Quotierungen durch

    6.1.1 %Index-Funktion

    Die Funktion sieht nach, ob ein Argument in einer Zeichenkette (Quelle) vorhanden ist, und gibt die Position, an der sich das Argument zum ersten Mal in der Zeichenkette befindet, zurück. Ist das Argument nicht in der Quelle enthalten, wird eine 0 zurückgegeben. Syntax: %index(Quelle, Argument); Die Quelle und das Argument können

    • konstanter Text, • referenzierte Makro-Variable • andere Makro-Funktion und • Makro-Aufruf

    sein. Beispiel 1: %let a=ein sehr langer Wert;

    %let b=%index(&a,n);%put I erscheint an Position &b;

    Ergebnis: I erscheint an Position 3 Im Beispiel 2 wird die %index-Funktion dazu benutzt, zu bestimmen, ob ein Datensatz (dsn) permanent oder temporär ist. Es wird überprüft, ob das Argument &dsn einen Punkt enthält. Enthält das Argument keinen Punkt, so ist die If-Bedingung erfüllt, und der Datensatz wird als temporär erkannt. Beispiel 2: %macro check(dsn);

    %global name;%if %index(&dsn,.)=0%then %put Der Name des temporären Datensatz ist work.&dsn;%else %put Der Name des permanenten Datensatz ist &dsn;

    %mend check;

    Der Aufruf %check(report) liefert den Satz Der Name des temporären Datensatz ist work.report. Der Aufruf %check(daten.report) liefert als Ergebnis den Satz Der Name des permanenten Datensatz ist &daten.report.

  • 34

    6.1.2 %Length-Funktion

    Diese Funktion ermittelt die Länge eines Arguments. Wenn das Argument einen Nullwert hat, gibt die Funktion 0 zurück. Syntax: %length(Argument) Das Argument kann

    • konstanter Text, • referenzierte Makro-Variable • andere Makro-Funktion und • Makro-Aufruf

    sein. Beispiel: %let a=Guten;

    %let b=Tag;%put *%length(&a)* **%length(&b)** ***%length(&a&b)***;

    Ergebnis: *5* **3** ***8*** 6.1.3 %Scan- und %Qscan-Funktion

    Die Funktion %scan gibt das n-te Wort des argument zurück, wobei Worte Zeichenketten in argument sind, die durch Trennzeichen (delimiters) getrennt sind. Syntax: %scan(argument,n

  • 35

    6.1.4 %Substr- und %Qsubstr-Funktion

    Die Aufgabe der %substr-Funktion ist es, eine Zeichenkette argument ab der Position position einzulesen und ein unquotiertes Resultat zurückzugeben. Syntax: %substr (argument, position ) argument, position und länge können

    • konstanter Text, • Makro-Variable, • andere Makro-Funktion und • Makro-Aufruf

    sein, wobei sich position und länge zu einer Zahl auflösen müssen. Die länge und position können Ergebnisse von Makro-Ausdrücken sein. Wenn länge nicht angegeben wird, dann wird bis zum Ende gelesen. Ist länge größer als das argument erscheint eine Warnung. Beispiel Ergebnis %let Text=Lebe wild und gefährlich;%let resultat=%substr(&text,6);%put Das Ergebnis ist: &resultat;

    Das Ergebnis ist: wild und gefährlich

    %let resultat=%substr(&text,6,4);%put Das Ergebnis ist: &resultat; Das Ergebnis ist: wild

    %let p=15;%let l=10;%let resultat=%substr(&text,&p,&l);%put Das Ergebnis ist: &resultat; Das Ergebnis ist: gefährlich

    %let resultat=%substr(&text,%length(&text)-13);

    %put Das Ergebnis ist: &resultat; Das Ergebnis ist: und gefährlich

    Die Funktion %qsubstr ist identisch mit der %substr-Funktion, mit dem Unterschied, daß sie ein quotiertes Resultat liefert (zu Quoting siehe Kap. 6.3). Syntax: %substr (argument, position ) Beispiel: %let a=1;

    %let abc=5;%let def=%nrstr(&abc);%put *&def* *%qsubstr(&def,1,2)* *%substr(&def,1,2)*;

    Ergebnis: *&abc* *&a* *1* 6.1.5 %Upcase- und %Qupcase-Funktion

    Diese Funktion %upcase transformiert alle kleinen Buchstaben, die im argument genannt sind, in Großbuchstaben. Die %upcase-Funktion liefert ein unquotiertes Resultat (vergl. Kap. 6.3). Nützlich ist die Funktion besonders bei Vergleichsoperationen, da der Makro-Prozessor nicht automatisch Kleinbuchstaben in Großbuchstaben verwandelt, wenn er Vergleiche ausführt. Dies kann dann zu Fehlermeldungen führen, da z.B. das Argument add nicht als ADD erkannt wird. Syntax: %upcase (argument)

  • 36

    Beispiel 1: %macro Verglei;

    %put Geben Sie ihr Geschlecht an (w für weiblich,m für männlich):;

    %input sex;%if &sex =W %then %put weiblich;�%else %put männlich;

    %mend verglei;Aufruf: %verglei Eingabe: wErgebnis: männlich � Wenn Sie für Geschlecht ein W eingeben, soll weiblich ausgegeben werden. In diesem Beispiel passiert dies allerdings nur, wenn sie ein großes W eingeben. Bei einem kleinen Buchstaben erscheint männlich. Beispiel 2: %macro Verglei;

    %put Geben Sie ihr Geschlecht an (W für weiblich,M für männlich):;

    %input sex;%if %upcase(&sex) =W %then %put weiblich;�%else %put männlich;

    %mend verglei;Aufruf: %verglei Eingabe: wErgebnis: weiblich � Mit Hilfe der %upcase-Funktion wird auch das kleine w als weiblich erkannt. Die Funktion ist identisch mit der %upcase-Funktion, mit dem Unterschied, daß sie ein quotiertes Resultat liefert (zu Quoting siehe Kap. 6.3). Syntax: %qupcase(argument)

    Beispiel: Ergebnis: %let x=%nrstr(%eval(5+23));%put *&x* *%qupcase(&x)*%upcase(&x)*;

    *%eval(5+23)* *%EVAL(5+23) *28*

    Übungsaufgabe

    17. Verwenden Sie die Makro-Funktionen, um aus einem zweiteiligen SAS-Dateinamen den Libref und den eigentlichen Dateinamen herauszulesen. Vereinbaren Sie, daß als Default- Wert immer der zuletzt verwendete Datensatz verwendet wird (Tip: syslast).

  • 37

    6.2 %Eval Funktion zur Auswertung von logischen und numerischen Ausdrücken

    Zur Auswertung von logischen und numerischen Ausdrücken steht die %eval-Funktion zur Verfügung. Da der Makro-Prozessor buchstabenbasiert arbeitet, werden Zahlen normalerweise als Buchstaben behandelt. Beispiel: %let y=100+200; erzeugt nicht y=300, sondern y=100+200. %let %eval(100+200); erzeugt y=300.

    6.2.1 %Eval-Funktion

    Die Funktion %eval • wertet logische und numerische Ausdrücke aus • erlaubt nur ganzzahlige Arithmetik (keine nichtganzzahlige), • schneidet nichtganzzahlige Werte ohne Warnung ab (rundet somit immer ab), • erlaubt keine Verkettung (||,concatenation) und kein Minimum und Maximum (> LT, GT kleiner als, größer als 6 = LE, GE kleiner gleich, größer gleich 6 ¬= ^= ~= NE ungleich1) 6 & AND logisches Und 7 | OR logisches Oder 8 1) Die Symbole hierfür sind tastaturabhängig. Mnemonic ist eine alternative Schreibweise.

  • 38

    Beispiele: Ergebnisse: %let wert=%eval(50+60);%put Der wert ist:&wert; Der wert ist:110

    %let x=50;%let y=60;%let wert=%eval(&x+&y);%put Der wert ist:&wert; Der wert ist:110

    %let wert=%eval(&x+&y/11);%put Der wert ist:&wert;

    Der wert ist:55

    (sollte eigentlich 55,4545 sein, die %eval-Funktion rundet aber immer ab)

    %let wert=%eval((&x+&y)/11);%put Der wert ist:&wert; Der wert ist:10

    Übungsaufgaben

    18. Lassen Sie sich mit Hilfe von Makrofunktionen ihren Namen in Großbuchstaben ausgeben und die Anzahl der Buchstaben. 19. Erstellen Sie ein Makro INTSUM, das die Zahlen von 1 bis N aufsummiert, wobei N als

    Argument mitgegeben wird und das Makro nur das Ergebnis zurückgeben soll (Tip: Die Formel dazu lautet n(n+1)/2).

    a) Rufen sie das Makro mit N=10 in einer %let-Anweisung und weisen Sie das Ergebnis der Variable TOTAL zu, die mit einem anschließenden %put ausgegeben wird.

    b) Behandeln sie das Makro wie eine Funktion, indem Sie das Ergebnis in einem Datenschritt einer Variable SUM zuweisen und mit put (nicht %put) ausgegeben.

    c) Schreiben Sie ein Makro GETSUM (ohne Parameter), das das Makro INTSUM als Funktion verwendet, indem INTSUM in einem Datenschritt für die Werte N=1, 2, 3, 4 und 5 aufgerufen wird. GETSUM soll den gesamten Datenschritt mitsamt PUT-Anweisungen zur Ausgabe der Ergebnisse erzeugen.

    d) Erweitern Sie das Makro GETSUM durch Aufrufparameter, die das erste und letzte N angeben, für die die Summen gebildet werden sollen und eventuell die Zwischenschritte (Inkrements) (Tip: %Do-Schleife).

    6.3 Funktionen zur Bearbeitung von speziellen Zeichen (Textfunktionen)

    Da bestimmte Textzeichen, wie z.B. Prozentzeichen, Semikolon oder Anführungszeichen für den Makro-Prozessor eine andere Bedeutung haben, bzw. der Makro-Prozessor anders darauf reagiert, als im normalen SAS-System, bedarf es spezieller Funktionen, der Quoting-Funktionen, um deren "normale" Bedeutung innerhalb des Makrosystems zu erzielen, und sie als Teil des Textes zu interpretieren. Folgende Zeichen werden vom Makro-Prozessor nicht als Textzeichen interpretiert: Zeichen Bedeutung ; Ende einer Anweisung , Trennung von Argumenten einer Funktion/ eines Makros &, % Referenz auf Makro- Variablen und -Aufruf +,-,*,/, u.ä. werden als arithmetische und Vergleichsoperatoren erkannt LT, NE, u.ä. werden als logische Operatoren erkannt Leerzeichen nicht unterdrücken

  • 39

    Übersicht über die Textfunktionen: Funktion Berücksichtigte Zeichen Beschreibung %str ; , + - * / ** | = LT

    LE u.ä. quotiert konstanten Text zur Zeit der Kompilierung

    %nrstr s.o., zusätzlich % und & s.o. %quote ; , + - * / ** | = LT

    LE u.ä. quotiert konstanten Text zur Zeit der Makro-Ausführung

    %bquote siehe %quote, zusätzlich offene Anführungszeichen & Klammern (unmatched)

    s.o.

    %nrquote siehe %quote, zusätzlich % und & s.o. %nrbquote vereinigt die Funktionen von

    %bquote und %nrquote s.o.

    %unquote löst Quotierungen wieder auf löst Quotierungen zur Zeit der Makro-Ausführung wieder auf

    %superq & und % verhindert das Auflösen von Makroausdrücken bei der Auflösung von Makrovariablen.

    6.3.1 %Quote-Funktion

    Die %quote-Funktion quotiert während der Makro-Ausführung konstanten Text. Die Funktion entfernt allerdings nicht die Bedeutung von Hochkommata, Klammern oder Makrohinweiszeichen, wie % und &. Syntax: %quote(Argument) Beispiel: %macro dept1(bdl);

    %if %quote(&bdl)=bw %then %put Bundesland BadenWürttemberg;

    %else %put Bundesland;%mend dept1;

    6.3.2 %Bquote-Funktion

    Die Funktion verarbeitet Argumente, die besondere Zeichen enthalten, welche der Makro-prozessor normalerweise nicht als Textzeichen interpretieren würde, z.B. offene Anführungs-zeichen und Klammern. Syntax: %bquote(Argument) Beispiel: %macro bq;

    %global platz;%put Geben Sie den Treffpunkt ein.;%input;%let platz=%bquote(&sysbuffr);%put &platz;

    %mend bq;Aufruf: %bq

    Eingabe: Rick's Café

  • 40

    Der Makro-Prozessor würde ohne die %bquote-Funktion die Fehlermeldung ERROR: Literal contains unmatched quote. melden. Mit der %bquote-Funktion wird das Anführungszeichen als Teil des Texts erkannt und korrekt verarbeitet. 6.3.3 %Nrquote-Funktion

    Diese Funktion ist analog zur %nrbquote-Funktion (siehe unten), kann allerdings keine Klammern und Anführungszeichen verarbeiten. 6.3.4 %Nrbquote-Funktion

    Mit Hilfe dieser Funktion können Ampersands und Prozentzeichen, sowie Anführungszeichen und Klammern als Teile von Argumenten erkannt und verarbeitet werden. Syntax: %nrbquote(Argument) Beispiel : %macro nrbq;

    %global platz;%put Geben Sie den Treffpunkt ein.;%input;%let platz=%nrbquote(&sysbuffr);%put &platz;

    %mend nrbq;Aufruf: %nrbqEingabe: R&D in Rick's CafeErgebnis: WARNING: Apparent symbolic reference D not resolved.

    R&D in Rick's Cafe Der Makro-Prozessor versucht zuerst, die vermeintliche Makrovariable &D aufzulösen. Diese Meldung taucht aber, dank der %nrbquote-Funktion, nur ein einziges Mal auf. Überprüfen Sie es mit: '%put &Platz;'. 6.3.5 %Unquote-Funktion

    Die %unquote-Funktion löst die Quotierung wieder auf, d.h. Argumente erhalten ihre ursprüngliche Bedeutung zurück. Sonderzeichen werden wieder als solche erkannt. Die %unquote-Funktion kann in folgenden Situationen nötig sein:

    • Wenn ein quotiertes Argument zu einem späteren Zeitpunkt der Makroausführung mit seinem ursprünglichen Wert benötigt wird.

    • Wenn eine Quoting-Funktion die Bedeutung des Eingabe-Arguments verändert hat. Syntax: %unquote(Argument) Beispiel : %macro rechne(wert1,wert2,op=add);

    %if %upcase(&op)=ADD %then %let op=%str(+);�%else%if %upcase(&op)=DIFF %then %let op=%str(-);%else%if %upcase(&op)=MAL %then %let op=%str(*);%else

    %do;%put Der Operator &op ist nicht erlaubt;%goto ende;

  • 41

    %end;%put Ergebnis: &wert1 &op &wert2 =%eval(&wert1 %unquote(&op)� &wert2);%ende:

    %mend rechne;Aufruf: %rechne(18,25,op=ADD);

    %rechne(18,25,op=diff);%rechne(18,25,op=mal);

    � Wenn die Variable op den Wert ADD zugewiesen bekommt, wird sie in ein Pluszeichen (+) verwandelt. Durch die %str-Funktion wird das Pluszeichen von seiner Funktion als arithmetisches Operator enthoben. Es wird jetzt vom Makro-Prozessor als "normales" Textzeichen behandelt. � Durch die %unquote-Funktion wird dem Pluszeichen (+) seine ursprüngliche Bedeutung zurückgegeben, und es kann als arithmetischer Operator verwendet werden. Ohne Rück-Quotierung durch die %unquote-Funktion taucht folgende Fehlermeldung auf: ERROR:A character operand was found in the %EVAL function or %IF conditionwhere a numeric operand is required. 6.3.6 %Str-Funktion

    Die %str-Funktion quotiert konstanten Text zur Zeit der Kompilierung (Konstruktion). Der Zeitpunkt der Quotierung ist der grundlegende Unterschied zur %quote-Funktion, die bei jeder Makro-Ausführung neu durchgeführt wird. Wenn es darum geht, einen Makro-Ausdruck aufzulösen, sollte die %quote-Funktion benutzt werden. Die %str-Funktion entfernt nicht die Bedeutung von Ampersands, Prozentzeichen und nicht-geschlossenen Hochkommata. Um nicht geschlossene Hochkommata zu quotieren, muß ein Prozentzeichen vor das Zeichen gesetzt werden: Beispiel: %let place=%str(Clinton%'s America); Die %str-Funktion sollte bei folgenden Gegebenheiten verwendet werden:

    • Wenn ein Semikolon statt als Makroausdruck als Textzeichen verwendet werden soll. • Um ein Leerzeichen (Blank) bedeutsam zu machen. • Um ein nicht geschlossenes Hochkomma oder eine offene Klammer, die mit einem

    Prozentzeichen versehen sind, zu benutzen. Syntax: %str(argument)Beispiele: %let p=%str(Proc Print; run;);

    %put &p;

    %let time=%str( now); 6.3.7 %Nrstr-Funktion

    Die %nrstr-Funktion quotiert, zusätzlich zu den Funktionen der %str-Funktion, auch Prozentzeichen und Hochkommata. Beispiel: %let p=%nrstr(%rechne);

    %put &p;

  • 42

    6.3.8 %Superq-Funktion

    Diese Funktion verhindert die Auflösung von Makro-Ausdrücken bei der Auflösung von Makrovariablen. Die %superq-Funktion ist in folgenden Fällen nützlich:

    • Bei Benutzung einer Makrovariablen, die mit einer %Input- oder %Window- Anweisung definiert wurde und ein Ampersand oder Prozentzeichen enthält.

    • Bei Benutzung einer Makrovariablen, die mit der SYMPUT-Routine geschaffen wurde und ein Ampersand oder Prozentzeichen enthält. Syntax: %superq(Makrovariable) Beispiel: %input x;

    %testvariable&anton%put Der Inhalt der Variablen x ist: %superq(x).;

    Ergebnis: Der Inhalt der Variablen x ist: %testvariable&anton Übungsaufgaben

    20. Erzeugen Sie eine %put-Anweisung, die folgenden Text ins Log-Fenster schreibt: Der Wert von %sysdate ändert sich nicht innerhalb eines SAS Programms. 21. Geben Sie folgende Sätze mit Hilfe von %put-Anweisungen im Log-Fenster aus: Das ist der Schnupperhund von C&A.

    Die Gewinner waren die Nummern 3;12;1 & 7So 'n Blödsinn!

    22. Stellen Sie sich vor, Sie arbeiten in der Univerwaltung und sind für die Adreßkartei der Studenten zuständig. Schreiben Sie ein Makro, das Ihnen schnell summarische Informationen über die Studenten liefern kann. Das Makro soll in einem Fenster die Variablen darstellen, die erfragt werden können, etwa folgendermaßen:

    Gruppierung nach1. Wohnort2. Semesterzahl3. Studienfach4. Abschlußart

    (Tip: Prozedur Freq mit by-Anweisung.) 23a) Erstellen Sie ein Makro SASERROR, das es SAS-Benutzern ermöglicht, auftretende Fehlermeldungen in einer Datei abzulegen. Die Fehlermeldungen müssen dazu aus dem Log-Fenster in den Zwischenspeicher kopiert werden und dann über ein %input- Statement eingelesen werden. b) Vervollständigen Sie das Makro SASERROR, indem Sie es ermöglichen Erläuterungen (z.B.

    Kontext und Situation) zu den Fehlermeldungen abzulegen. Verändern Sie das Makro dahingehend, das die Fehlermeldungen in eine permanente Datei STAMM hinzugefügt werden, in der die Fehlermeldungen gesammelt werden (Tip: Proc Append). Überprüfen Sie in dem Makro, ob die Datei STAMM bereits existiert; falls nicht, soll diese gebildet werden.

  • 43

    7. Berührungspunkte zwischen Makro-Sprache und Datenschritt

    7.1 Zugriff auf Daten in SAS-Makros

    Das SAS-System stellt zwei Funktionen bereit, die den Austausch zwischen SAS-Datenschritt und Makro-Sprache erlauben: • symget: transferiert Inhalt einer Makro-Variable in den Datenschritt und • symput: transferiert Datenschritt-Informationen in eine Makro-Variable. Dieser Austausch ist notwendig, da die Variablen des SAS-Datenschritts und die Makro-Sprache in unterschiedlichen Speichern abgelegt werden. Die Datenschritt-Variablen werden in einen Speicher namens "Programm Data Vektor" geschrieben, die Makro-Sprache legt ihre Variablen in Symboltabellen ab (siehe Kap. 4). Um zwischen diesen Speichern Informationen auszutauschen, benötigen Sie die Funktionen symput und symget.

    SAS-Data-SchrittProgramm DataVektor

    Datenschrittvariablen

    Makro-SpracheSymboltabellen

    Makrovariablen

    SYMGET

    SYMPUT

    Der verwendete Speicher hängt ab:

    • von der Stelle, wo der Datenschritt aufgerufen wird, • von der Verschachtelung der Umgebungen und • von der Definition lokaler und globaler Variablen.

    7.1.1 Symget-Funktion

    Syntax: symget(argument) datenschritt-variable=symget(argument); Das argument kann

    • eine in Anführungszeichen eingeschlossen Makrovariable, • eine Datenschritt-Zeichenkettenvariable oder • ein Datenschritt-Zeichenkettenausdruck

    sein.

  • 44

    Die Datenschritt-Variable • kann zuvor als Charakter- oder Numerische Variable definiert sein, • wird ansonsten als Charakter-Variable mit Länge 200 definiert, • wird - falls länger - auf 200 Zeichen gekürzt und • wird als Numerische-Variable definiert, falls die symget-Funktion in einen arithmetischen Ausdruck eingesetzt wird.

    Beispiele 1. Das Argument ist eine Zeichenkette Beispiel: %let name=recklinghausen;

    data loc;input land $;stadt=symget('name');cards;Deutschland;proc print;run;

    Ergebnis: OBS LAND STADT1 Deutschl recklinghausen

    Der Makrovariablenname muß in Anführungszeichen eingeschlossen sein. Beachtenswert ist, daß die durch die symget-Funktion referenzierte Datenschrittvariable einen Wert mit mehr als 8 Buchstaben (bis zu 200 Buchstaben, recklinghausen=14 Buchstaben) annehmen kann, wobei bei der Variablen land die Eingabe standardmäßig auf 8 Zeichen begrenzt ist. Dies ist durch die unterschiedlichen Speicher bedingt und kann Probleme mit der Speicherkapazität verursachen, da jede Makrovariable standardmäßig mit 200 Zeichen abgelegt wird, auch wenn diese nur 14 Zeichen hat. Durch Vereinbaren eines Input-Formats können sie dies begrenzen (siehe Beispiel 3). 2. Das Argument ist eine Datenschrittvariable Beispiel: %let fluss=arno;�

    %let land=Italien;%let stadt=roma;data loc;input gebiet $ Zahl;name=symget(gebiet);�cards;stadt 12�land 34fluss 83gebirge 97�;proc print;run;

    Ergebnis: OBS GEBIET ZAHL NAME

    1 stadt 12 roma2 land 34 Italien3 fluss 83 arno4 gebirge 97

  • 45

    Die Ausprägung der Variable muß ein gültiger SAS-Makrovariablenname sein. � Es werden 3 Makrovariablen gebildet. � Die 3 Makrovariablen werden als gebiet definiert. � Beim Einlesen dieser Beobachtung wird überprüft, ob eine Makrovariable mit dem Namen stadt existiert. Wenn dies der Fall ist, wird ihr Wert aus dem Makro-Speicher übernommen. � Da keine Makrovariable gebirge vereinbart wurde, bekommt die Variable name an dieser Stelle einen Nullwert. Außerdem erscheint folgende Mitteilung: NOTE: Invalid argument to function SYMGET at line 218 column 6.RULE:--+----1----+----2----+----3----+----4----+----5----+----6----+----7--220GebirgeGEBIET=Gebirge NAME= _ERROR_=1 _N_=1

    3. Bildung von numerischen Variablen Beispiel: %let einheit=1.50;

    data dollars;input dm;dollar=dm*input(symget('einheit'�),4.);cards;2.0013.5;proc print;run;

    Ergebnis: OBS DM DOLLAR

    1 2.0 3.02 13.5 20.25

    � Hier wird die symget-Funktion dazu benutzt, einen numerischen Wert, der mit Hilfe der Makro-Sprache definiert wurde, in einem arithmetischen Ausdruck eines Datenschritts zu benutzen. Mit der Input-Funktion wird das Format 4. zugewiesen.

    ERROR 85-322: Expecting a