This page is also available in

Dokumentation

Dokumentationen nedan ingår i BeeBase-distributionen och finns även tillgänglig i PDF.

16. Programmera BeeBase

Detta kapitel (det största i denna manual) beskriver programmeringsspråket i BeeBase, inklusive alla tillgängliga funktioner. Detta kapitel är dock inte avsett som en allmän guide om programmering. Du bör vara bekant med grunderna i programmering och bör redan ha skrivit några små (och korrekt fungerande :-)) program.

16.1 Programredigerare

För att mata in ett program för ett projekt, öppna programredigeraren genom att välja menyalternativet `Program - Redigera'. Om du använder inställningen programkälla intern (se Program source), öppnas fönstret `Redigera program' som innehåller:

• ett textredigeringsfält där du redigerar projektprogrammet.

• en knapp `Kompilera & stäng' för att kompilera programmet och, vid framgångsrik kompilering, lämna programredigeraren.

• en knapp `Kompilera' för att kompilera programmet. Om ditt program innehåller ett fel någonstans läggs en felbeskrivning in i fönsterrubriken och markören placeras på den felaktiga platsen.

• en knapp `Återgå' som återställer alla ändringar sedan den senaste framgångsrika kompileringen.

Programredigeraren är ett icke-modalt fönster. Du kan låta fönstret vara öppet och fortfarande arbeta med resten av applikationen. Du kan stänga redigeraren när som helst genom att klicka på dess fönsterstängningsknapp. Om du har gjort ändringar sedan den senaste framgångsrika kompileringen visas en dialog som ber om bekräftelse för att stänga fönstret.

Om du har ställt in menyalternativet `Program - Källa' till `Extern' startas den externa redigeraren (se External editor) med filnamnet för den externa källfilen när du väljer `Program - Redigera'. Detta gör att du kan redigera programkällan med din favoritredigerare (se External program source).

Du kan också kompilera ett projekts program utan att öppna programredigeraren genom att välja menyalternativet `Program - Kompilera'. Detta kan vara användbart om du t.ex. gör ändringar i en extern include-fil och vill införliva dessa ändringar i projektets program.

16.2 Extern programkälla

Genom att välja menyalternativet `Program - Källa - Extern' och ange ett filnamn kan du göra programkällan för ett projekt externt tillgänglig. Detta gör att du kan ladda programkällan i din favoritredigerare för programmering.

Om kompileringen lyckas, sätts det kompilerade programmet som projektets program och används när utlösarfunktioner körs. När du sparar ett projekt, lagras det senast framgångsrikt kompilerade programmet med projektet inuti projektfilen. Således, efter att ha sparat och stängt ett projekt, behövs den externa källan egentligen inte längre. Du kan ange om onödiga externa källfiler ska tas bort automatiskt genom att markera menyalternativet `Inställningar - Rensa extern programkälla'.

Status för menyalternativet `Program - källa' lagras med projektet. Om du öppnar ett projekt igen som använder den externa källfunktionen, skapas den externa källfilen efter att projektet öppnats. Om den externa källfilen redan finns och är annorlunda än versionen som lagras inuti projektet, ber en dialog om bekräftelse innan filen skrivs över.

På Amiga kan du skicka kommandot compile till BeeBase ARexx-port från din redigerare. BeeBase läser då den externa programkällan, kompilerar den och returnerar kompileringsstatus med ett valfritt felmeddelande som innehåller filnamn, rad och kolumn, samt en felbeskrivning. Detta gör att du kan placera markören på exakt plats där ett kompileringsfel inträffade. Se ARexx compile, för detaljer om returvärden och felformat.

16.3 Förbehandling

BeeBase-program förbehandlas på liknande sätt som en C-kompilator förbehandlar en C-källfil. Detta avsnitt beskriver hur man använder förbehandlingsdirektiven.

Alla direktiv börjar med ett hash-symbol # som bör vara det första tecknet på en rad. Mellanslag eller tab-tecken kan visas efter det inledande #.

16.3.1 #define

#define namn sträng

Definierar en ny symbol med det givna namnet och innehållet. Symbolen sträng kan vara vilken text som helst inklusive mellanslag och slutar vid radslutet. Om sträng inte får plats på en rad kan du använda ytterligare rader genom att använda ett bakåtstreck \ i slutet av varje rad (utom för den sista). Om symbolen namn förekommer i den återstående källkoden kommer den att ersättas av innehållet i sträng.

Exempel: `(PRINTF "X är %i" X)' skriver ut `X är 1' (Förekomster av namn i strängar ändras inte.)

Ersättningen av definierade symboler görs syntaktiskt vilket innebär att du kan ersätta symboler med vilken text som helst, t.ex. kan du definiera din egen syntax som i följande exempel:

#define BEGIN (
#define END )

BEGIN defun test ()
        ...
END

Ersättningssträngen för en definition kan innehålla en annan symbol som har definierats med direktivet #define för att tillåta nästlade definitioner. Det finns dock en övre gräns på 16 nästlade definitioner.

Se även #undef, #ifdef, #ifndef.

16.3.2 #undef

#undef namn

Tar bort definitionen av symbolen namn. Om namn inte har definierats, händer ingenting.

Se även #define, #ifdef, #ifndef.

16.3.3 #include

#include filnamn

Läser in innehållet i filnamn (en sträng omgiven av dubbla citattecken) på denna plats. BeeBase söker i den aktuella katalogen och i katalogen som anges i inställningarna (se Program include directory) för att ladda filen. Filinnehållet bearbetas av kompilatorn som om de var en del av den aktuella källkoden.

En extern fil kan inkludera en eller flera andra externa filer. Det finns dock en gräns på 16 nästlade #include-direktiv. För att skydda filer från att inkludera dem mer än en gång kan du använda villkorlig kompilering.

Var försiktig när du flyttar källkod till externa filer! Felsökning och spårning av fel är mycket svårare för externa filer. Flytta endast vältestad och projektoberoende kod till externa filer.

16.3.4 #if

#if const-expr

Om det givna konstanta uttrycket resulterar i icke-NIL används texten fram till matchande #else, #elif eller #endif för kompilering, annars (uttrycket resulterar i NIL) kasseras texten fram till matchande #else, #elif eller #endif för kompilering.

För närvarande kan du endast använda TRUE och NIL som konstanta uttryck.

Se även #ifdef, #ifndef, #elif, #else, #endif.

16.3.5 #ifdef

#ifdef namn

Om den givna symbolen har definierats med ett #define-direktiv används texten fram till matchande #else, #elif eller #endif för kompilering, annars kasseras den.

Se även #if, #ifndef, #elif, #else, #endif.

16.3.6 #ifndef

#ifndef namn

Om den givna symbolen inte har definierats med ett #define-direktiv används texten fram till matchande #else, #elif eller #endif för kompilering, annars kasseras den.

Se även #if, #ifdef, #elif, #else, #endif.

16.3.7 #elif

#elif const-expr

Valfritt antal #elif-direktiv kan visas mellan ett #if, #ifdef eller #ifndef-direktiv och ett matchande #else eller #endif-direktiv. Raderna som följer #elif-direktivet används för kompilering endast om alla följande villkor uppfylls:

• Det konstanta uttrycket i föregående #if-direktiv utvärderades till NIL, symbolnamnet i föregående #ifdef är inte definierat, eller symbolen namn i föregående #ifndef-direktiv var definierat.

• Det konstanta uttrycket i alla mellanliggande #elif-direktiv utvärderades till NIL.

• Det aktuella konstanta uttrycket utvärderas till icke-NIL.

Om ovanstående villkor uppfylls ignoreras efterföljande #elif- och #else-direktiv upp till matchande #endif.

Se även #if, #ifdef, #ifndef, #else, #endif.

16.3.8 #else

#else

Detta inverterar innebörden av det villkorliga direktivet som annars är i effekt. Om det föregående villkoret indikerar att rader ska inkluderas, så ignoreras raderna mellan #else och matchande #endif. Om det föregående villkoret indikerar att rader skulle ignoreras, inkluderas efterföljande rader för kompilering.

Villkorliga direktiv och motsvarande #else-direktiv kan nästlas. Det finns dock en maximal nästlingsgräns på 16 nästlade villkorliga direktiv.

Se även #if, #ifdef, #ifndef, #elif, #endif.

16.3.9 #endif

#endif

Avslutar ett avsnitt av rader som påbörjats av ett av de villkorliga direktiven #if, #ifdef eller #ifndef. Varje sådant direktiv måste ha ett matchande #endif.

Se även #if, #ifdef, #ifndef, #elif, #else.

16.4 Programmeringsspråk

BeeBase använder ett programmeringsspråk med lisp-liknande syntax. Flera konstruktioner och funktioner har faktiskt adopterats från standard-lisp. BeeBase är dock inte helt kompatibelt med standard-lisp. Många funktioner saknas (t.ex. destruktiva kommandon) och betydelsen av vissa kommandon är annorlunda (t.ex. return-kommandot).

16.4.1 Varför Lisp?

Fördelen med ett lisp-liknande språk är att du kan programmera på både ett funktionellt och ett imperativt sätt. Funktionella språk har blivit ganska populära i matematiska tillämpningar. Det grundläggande konceptet i funktionella språk är användningen av uttryck. Funktioner definieras på ett matematiskt sätt och rekursion används flitigt.

Imperativa programmeringsspråk (t.ex. C, Pascal, Modula) använder en imperativ beskrivning av hur saker ska beräknas. Här är tillståndet det grundläggande konceptet (t.ex. variabler) och ett program beräknar sin utdata genom att gå från ett tillstånd till ett annat (t.ex. genom att tilldela värden till variabler).

Lisp kombinerar båda teknikerna och därför kan du välja på vilket sätt du vill implementera saker. Använd det som är mer lämpligt för det specifika problemet eller det du föredrar.

16.4.2 Lisp-syntax

Ett lisp-uttryck är antingen en konstant, en variabel eller en funktionsapplikation. För att anropa funktioner använder lisp en prefixnotation. Funktionen och dess argument omges av parenteser. Till exempel, för att addera två värden a och b, skriver du

(+ a b)

Alla uttryck returnerar ett värde, t.ex. i exemplet ovan returneras summan av a och b. Uttryck kan nästlas, det vill säga du kan placera ett uttryck som ett deluttryck i ett annat.

Funktionsutvärdering görs genom att använda en anropa-med-värde-metod, vilket betyder att argumenten utvärderas först innan en funktion anropas.

Om inget annat anges är alla funktioner strikta, det vill säga, alla argument till en funktion utvärderas innan funktionen anropas. Vissa funktioner är dock icke-strikta, t.ex. IF, AND och OR. Dessa funktioner utvärderar eventuellt inte alla argument.

16.4.3 Typer av program

BeeBase känner till tre typer av program. Den första är projektprogramtypen. I program av denna typ kan du definiera funktioner och globala variabler. Funktionerna kan användas som utlösarfunktioner för fält. Du definierar ett projektprogram i programredigeraren (se Program editor).

Den andra typen är frågeprogram. För denna typ kan du endast ange uttryck. Ett uttryck får innehålla globala variabler och anrop till funktioner som är definierade i projektprogrammet. Du kan dock inte definiera nya globala variabler eller funktioner i ett frågeprogram. Frågeprogram anges i frågeeditorn (se Query editor).

Den tredje typen av program är filteruttryck. Här kan du endast ange uttryck som innehåller anrop till fördefinierade BeeBase-funktioner. Inte alla fördefinierade funktioner är tillgängliga, endast de som inte har en sidoeffekt, t.ex. kan du inte använda en funktion som skriver data till en fil. Filteruttryck anges i dialogen för att ändra filter (se Changing filters).

16.4.4 Namnkonventioner

I ett BeeBase-program kan du definiera symboler som funktioner och lokala eller globala variabler. Namnen på dessa symboler måste följa följande konventioner:

• den första bokstaven i ett namn måste vara en liten bokstav. Detta skiljer programsymboler från tabell- och fältnamn.

• Följande tecken kan vara bokstäver, siffror eller understreck. Andra tecken som tyska omljud är inte tillåtna.

16.4.5 Åtkomst till postinnehåll

För att komma åt tabeller och fält i ett BeeBase-program måste du ange en sökväg till dem. En sökväg är en punktseparerad lista över komponenter där varje komponent är namnet på en tabell eller ett fält.

Sökvägar kan antingen vara relativa eller absoluta. Absoluta sökvägar anges med ett tabellnamn som första komponent, följt av en lista över fält som leder till det slutliga fältet du vill komma åt. T.ex. den absoluta sökvägen `Person.Namn' kommer åt fältet `Namn' i den aktuella posten i tabellen `Person', eller den absoluta sökvägen `Person.Far.Namn' kommer åt fältet `Namn' i posten som refereras av fältet `Far' (ett referensfält till tabellen `Person').

Relativa sökvägar har redan en aktuell tabell till vilken de är relativa. Till exempel i ett filteruttryck är den aktuella tabellen den tabell för vilken du skriver filteruttrycket. Den relativa sökvägen för ett fält i den aktuella tabellen är helt enkelt själva fältnamnet. För fält som inte är direkt åtkomliga från den aktuella tabellen utan indirekt via ett referens- fält gäller samma regler som för absoluta sökvägar.

Det är inte alltid klart om en angiven sökväg är relativ eller absolut, t.ex. anta att du skriver ett filteruttryck för en tabell `Foo' som har ett fält `Bar' och det finns också en tabell `Bar'. Om du skriver `Bar' skulle det vara tvetydigt, vad avses, tabellen eller fältet? Därför behandlas alla sökvägar först som relativa. Om inget fält hittas för den angivna sökvägen behandlas sökvägen som global. I vårt exempel skulle fältet föredras.

Men nu, vad om du vill komma åt tabellen i exemplet ovan? Därför måste sökvägen anges absolut. För att indikera att en sökväg är global måste du infoga två kolon framför sökvägen. I vårt exempel skulle du behöva skriva `::Bar' för att komma åt tabellen.

För att ge dig en bättre förståelse av sökvägar och deras semantik, betrakta i vårt exempel att fältet `Bar' i tabellen `Foo' är en referens till tabellen `Bar', och tabellen `Bar' har ett fält `Namn'. Nu kan du komma åt fältet `Namn' genom att skriva `Bar.Namn' eller `::Bar.Namn'. Båda uttrycken har olika betydelse. `::Bar.Namn' betyder att ta den aktuella posten i tabellen `Bar' och returnera värdet av fältet `Namn' för denna post, medan `Bar.Namn' tar den aktuella posten i tabellen `Foo', extraherar postreferensen från fältet `Bar' och använder denna post för att få värdet av fältet `Namn'.

För att göra ett mer komplett exempel, anta att tabellen `Bar' har två poster. En som innehåller `Ralph' och en som innehåller `Steffen' i fältet `Namn'. Den första posten bör vara den aktuella. Dessutom har tabellen `Foo' en post (den aktuella) vars fält `Bar' refererar till den andra posten i tabellen `Bar'. Nu resulterar `::Bar.Namn' i `Ralph' och `Bar.Namn' i `Steffen'.

16.4.6 Datatyper för programmering

Programmeringsspråket i BeeBase känner till följande datatyper:

Typ         Beskrivning

Boolean     alla uttryck. Icke-NIL-uttryck behandlas som TRUE.

Integer     lång heltal, 32 bitar, valvärden konverteras automatiskt
            till heltal

Real        dubbel, 64 bitar

String      strängar av godtycklig längd

Memo        som strängar men radformaterat

Date        datumvärden

Time        tidsvärden

Record      pekare till en post

File        filbeskrivning för läsning/skrivning

List        lista över objekt, NIL är tom lista.

Alla programmeringstyper stöder NIL-värdet.

16.4.7 Konstanter

Programmeringsspråket i BeeBase kan hantera konstanta uttryck som kan anges beroende på typen av uttrycket:

Typ         Beskrivning

Integer     Heltalskonstanter i intervallet -2147483648 till
            2147483647 kan anges som vanligt. Värden
            som börjar med 0 tolkas som oktala tal,
            värden som börjar med 0x som hexadecimala tal.

Real        Flyttalskonstanter i intervallet -3,59e308
            till 3,59e308 kan anges som vanligt, i vetenskapligt
            eller icke-vetenskapligt format. Om du utelämnar decimal-
            punkten kan talet inte behandlas som ett reellt
            tal utan som ett heltal istället.

String      Strängkonstanter är alla teckensträngar omgivna
            av dubbla citattecken, t.ex. "exempelsträng". Inom de
            dubbla citattecknen kan du ange vilka tecken som helst förutom
            kontrolltecken eller nya rader. Det finns dock
            speciella escape-koder för att ange sådana tecken:

                \n              ny rad (nl)
                \t              horisontell tabulator (ht)
                \v              vertikal tabulator (vt)
                \b              backspace (bs)
                \r              vagnretur (cr)
                \f              sidmatning (ff)
                \\              bakstreckstecken själv
                \"              dubbelt citattecken
                \e              escape-kod 033
                \nnn            tecken med oktal kod nnn
                \xnn            tecken med hex-kod nn

Memo        Samma som strängkonstanter.

Date        Konstanta datumvärden kan anges i ett av
            formaten `DD.MM.ÅÅÅÅ', `MM/DD/ÅÅÅÅ', eller `ÅÅÅÅ-MM-DD', där
            `DD', `MM' och `ÅÅÅÅ' står för två- och fyrsiffriga
            värden som representerar dag, månad och år för
            datumet respektive.

Time        Konstanta tidsvärden kan anges i formatet
            `TT:MM:SS', där `TT' representerar timmar,
            `MM' minuter och `SS' sekunder.

För vissa andra fördefinierade konstantvärden, se Pre-defined constants.

16.4.8 Kommandosyntax

I resten av detta kapitel hittar du beskrivningen av alla kommandon och funktioner som är tillgängliga för att programmera BeeBase. Följande syntax används för att beskriva kommandona:

• text skriven inom hakparenteser [] är valfri. Om du utelämnar texten innanför hakparenteserna antas ett standardvärde.

• text separerad av ett vertikalt streck | betecknar flera alternativ, t.ex. `a | b' betyder att du kan ange antingen `a' eller `b'.

• text skriven i ett typsnitt som var indikerar en platshållare som kan fyllas med andra uttryck.

• punkter ... indikerar att ytterligare uttryck kan följa.

• all annan text är obligatorisk.

16.5 Definierande kommandon

Detta avsnitt listar kommandon för att definiera funktioner och globala variabler. Kommandona är endast tillgängliga för projektprogram.

16.5.1 DEFUN

DEFUN definierar en funktion med det angivna namnet, en lista över argument som skickas till funktionen, och en lista över uttryck att utvärdera.

(DEFUN namn (varlista) uttryck ...)

Namnet på en funktion måste börja med en liten bokstav, följt av ytterligare bokstäver, siffror eller understreck (se Name conventions).

Parametern varlista anger funktionens argument:

varlista: var1 ...

där var1 ... är namnen på argumenten. Namnen måste följa samma regler som funktionsnamnet.

Det är också möjligt att lägga till typspecificerare till argumenten (se Type specifiers).

Funktionen utför uttrycken uttryck, ... en efter en och returnerar värdet av det sista uttrycket. Funktionen kan anropa ytterligare funktioner inklusive sig själv. En egendefinerad funktion kan anropas som att anropa en fördefinierad funktion.

Till exempel för att räkna antalet element i en lista kan du definiera följande funktion:

(DEFUN len (l)
    (IF (= l NIL)
        0
        (+ 1 (len (REST l)))
    )
)

Funktioner definierade med DEFUN listas i popup-listvyer för tabell- och fältdialoger (se Creating tables och Creating fields).

Detta kommando är endast tillgängligt för projektprogram.

Se även DEFUN*, DEFVAR.

16.5.2 DEFUN*

DEFUN* är stjärnversionen av DEFUN och har samma effekt som DEFUN (se DEFUN). Den enda skillnaden är att funktioner definierade med DEFUN* inte listas i popup-listvyerna när du skapar eller ändrar tabeller och fält. Det är dock fortfarande möjligt att ange funktionsnamnet i motsvarande strängfält.

Detta kommando är endast tillgängligt för projektprogram.

Se även DEFUN, DEFVAR.

16.5.3 DEFVAR

(DEFVAR var [uttryck])

Definierar en global variabel med initialvärdet av uttryck eller NIL om uttryck saknas. Namnet på variablerna måste börja med en liten bokstav följt av ytterligare bokstäver, siffror eller understreck (se Name conventions).

Du kan också lägga till en typspecificerare till variabelnamnet (se Type specifiers).

DEFVAR är endast tillgängligt för projektprogram. Alla DEFVAR-kommandon bör placeras ovanför alla funktionsdefinitioner.

Efter att en utlösarfunktion har körts (när BeeBase återgår till användar- gränssnittet), förlorar alla globala variabler sitt innehåll. De återinitialiseras med sitt initialvärde uttryck vid nästa anrop av en utlösarfunktion. Om detta inte är önskvärt, använd kommandot DEFVAR* (se DEFVAR*) som tillåter att lagra värdet av globala variabler mellan programanrop.

Använd globala variabler sparsamt (om alls). Alla globala variabler måste initialiseras (och uttryck utvärderas om angivet) varje gång en utlösarfunktion anropas utifrån.

Exempel: `(DEFVAR x 42)' definierar en global variabel `x' med värdet 42.

Det finns några fördefinierade globala variabler i BeeBase (se Pre-defined variables).

Se även DEFVAR*, DEFUN, DEFUN*, LET.

16.5.4 DEFVAR*

(DEFVAR* var [uttryck])

DEFVAR* har samma effekt som kommandot DEFVAR (se DEFVAR) förutom att en variabel definierad med DEFVAR* inte förlorar sitt värde efter att programmet avslutas.

Vid första anropet av programmet initialiseras var med uttryck eller NIL om uttryck utelämnas. Efterföljande anrop av programmet utvärderar inte uttryck igen utan använder värdet av var från föregående anrop. På detta sätt är det möjligt att överföra information från ett programanrop till ett annat utan att lagra data i en extern fil eller en databastabell. Observera dock att alla globala variabler definierade med DEFVAR* förlorar sitt innehåll när projektprogrammet kompileras om. Om du vill permanent lagra information, använd ett (möjligen dolt) fält i en tabell.

Se även DEFVAR, DEFUN, DEFUN*, LET.

16.6 Programkontrollfunktioner

Detta avsnitt listar funktioner för programkontroll, t.ex. funktioner för att definiera lokala variabler, loopfunktioner, villkorlig programexekvering, loopkontrollfunktioner och mer.

16.6.1 PROGN

För att utvärdera flera uttryck efter varandra kan konstruktionen PROGN användas.

([uttryck ...])

utför uttryck ... en efter en. Returnerar resultatet av det sista uttrycket (eller NIL om inget uttryck har angetts). I Lisp är denna konstruktion känd som (PROGN [uttryck ...]).

Exempel: `(1 2 3 4)' resulterar i 4.

Se även PROG1.

16.6.2 PROG1

Ett annat sätt, förutom funktionen PROGN, att utvärdera flera uttryck efter varandra är uttrycket PROG1.

(PROG1 [uttryck ...])

utför uttryck ... och returnerar värdet av det första uttrycket (eller NIL om inget uttryck har angetts).

Exempel: `(PROG1 1 2 3 4)' resulterar i 1.

Se även PROGN.

16.6.3 LET

LET definierar ett nytt block av lokala variabler. Detta är användbart, t.ex. för att definiera lokala variabler för en funktion. Syntaxen är

(LET (varlista) uttryck ...)

där varlista är en lista över lokala variabler.

varlista: varspec ...

varspec: (var uttryck) | var

Här är var namnet på variabeln och måste börja med en liten bokstav, följt av ytterligare bokstäver, siffror eller understreck (se Name conventions).

I fallet med en (var uttryck)-specifikation, initialiseras den nya variabeln med det givna uttrycket. I det andra fallet sätts den nya variabeln till NIL.

Det är också möjligt att lägga till typspecificerare till variablerna. (se Type specifiers).

Efter initialisering av alla variabler utvärderas listan av uttryck uttryck ... och värdet av det sista returneras.

Till exempel resulterar följande LET-uttryck

(LET ((x 0) y (z (+ x 1)))
    (+ x z)
)

i 1.

Se även DOTIMES, DOLIST, DO, DEFVAR.

16.6.4 SETQ

Funktionen SETQ sätter värden till variabler, fält och tabeller.

(SETQ lvärde1 uttryck ...)

Sätter lvärde1 till värdet av uttryck. Punkterna indikerar tilldelningar för ytterligare lvärden. Ett lvärde är antingen en variabel, ett fält i en tabell, eller en tabell. I fallet med en variabel måste variabeln ha definierats tidigare (t.ex. genom ett LET-uttryck).

Att sätta värdet på en tabell betyder att sätta dess program- eller GUI-postpekare: `(SETQ Tabell uttryck)' sätter programpostpekaren för Tabell till värdet av uttryck, `(SETQ Tabell* uttryck)' sätter GUI-postpekaren för den och uppdaterar visningen. För mer information om program- och GUI-postpekare, se Tables.

SETQ returnerar värdet av det sista uttrycket.

Exempel: `(SETQ a 1 b 2)' tilldelar 1 till variabeln `a', 2 till variabeln `b' och returnerar 2.

Se även SETQ*, SETQLIST, LET, DEFVAR, Tables, Semantics of expressions.

16.6.5 SETQ*

SETQ* är stjärnversionen av SETQ (se SETQ) och har liknande effekter. Skillnaden är att när man tilldelar ett värde till ett fält, anropar SETQ* utlösarfunktionen för det fältet (se Field trigger) istället för att direkt tilldela värdet. Om ingen utlösarfunktion har specificerats för ett fält, beter sig SETQ* som SETQ och tilldelar helt enkelt värdet till fältet.

Exempel: `(SETQ* Tabell.Fält 0)' anropar utlösarfunktionen för `Tabell.Fält' med ett argument på 0.

Varning: Med denna funktion är det möjligt att skriva oändliga loopar, t.ex. om du har definierat en utlösarfunktion för ett fält och denna funktion anropar SETQ* för att sätta ett värde till sig själv.

Se även SETQ, SETQLIST*, LET, DEFVAR.

16.6.6 SETQLIST

SETQLIST liknar SETQ (se SETQ) men använder en lista för att sätta flera lvärden till elementen i listan.

(SETQLIST lvärde1 ... list-uttryck)

Sätter lvärde1 till det första elementet i list-uttryck. Punkterna indikerar tilldelningar för ytterligare lvärden till motsvarande element i listan. Antalet lvärden måste vara lika med längden på listan, annars avslutas programkörningen med ett felmeddelande.

Samma regler gäller som i SETQ (se SETQ). Till exempel är följande två versioner av variabeltilldelning ekvivalenta:

(SETQLIST a b c (LIST 1 2 3))

(SETQ a 1 b 2 c 3)

SETQLIST returnerar värdet av list-uttryck.

Se även SETQLIST*, SETQ.

16.6.7 SETQLIST*

SETQLIST* är stjärnversionen av SETQLIST (se SETQLIST) och har liknande effekter. Skillnaden är att när man tilldelar ett värde till ett fält, anropar SETQLIST* utlösarfunktionen för det fältet (se Field trigger) istället för att direkt tilldela värdet. Om ingen utlösarfunktion har specificerats för ett fält, beter sig SETQLIST* som SETQLIST och tilldelar helt enkelt värdet till fältet.

Se även SETQLIST, SETQ*.

16.6.8 FUNCALL

FUNCALL används för att anropa en funktion med argument.

(FUNCALL funk-uttryck [uttryck ...])

Anropar funktionen funk-uttryck med de givna argumenten. Uttrycket funk-uttryck kan vara vilket uttryck som helst vars värde är en fördefinierad eller användardefinierad funktion, t.ex. en variabel som innehåller funktionen att anropa. Om antalet argument inte är korrekt genereras ett felmeddelande.

FUNCALL returnerar returvärdet från funktionsanropet eller NIL om funk-uttryck är NIL.

För mer information om funktionella uttryck, se Functional parameters.

Se även APPLY.

16.6.9 APPLY

APPLY används för att tillämpa en funktion på en lista av argument.

(APPLY funk-uttryck [uttryck ...] list-uttryck)

Tillämpar funktionen funk-uttryck på en lista skapad genom att consa argumenten uttryck ... till list-uttryck. Med andra ord: anropar funktionen funk-uttryck med argumenten uttryck ... och list-uttryck expanderat till dess listelement.

Uttrycket funk-uttryck kan vara vilket uttryck som helst vars värde är en fördefinierad eller användardefinierad funktion, t.ex. en variabel som innehåller funktionen att anropa. Det sista argumentet list-uttryck måste vara en giltig lista eller NIL, annars genereras ett felmeddelande. Om antalet argument inte är korrekt uppstår ett fel.

APPLY returnerar returvärdet från funktionsanropet eller NIL om funk-uttryck är NIL.

För mer information om funktionella uttryck, se Functional parameters.

Exempel: `(APPLY + 4 (LIST 1 2 3))' returnerar 10.

Se även FUNCALL.

16.6.10 IF

IF är en villkorlig operator.

(IF uttryck1 uttryck2 [uttryck3])

Uttrycket uttryck1 testas. Om det resulterar i icke-NIL då returneras värdet av uttryck2 annars returneras värdet av uttryck3 (eller NIL om det inte finns).

Denna funktion är inte strikt, det vill säga, endast ett uttryck av uttryck2 eller uttryck3 kommer att utvärderas.

Se även CASE, COND.

16.6.11 CASE

CASE liknar switch-satsen i C-språket.

(CASE uttryck [fall ...])

Här är uttryck selektionsuttrycket och fall ... är par bestående av:

fall: (värde [uttryck ...])

där värde är ett enskilt uttryck eller en lista av uttryck och uttryck ... är uttrycken som ska utföras om ett av falluttrycken matchar.

CASE-uttrycket utvärderar först uttryck. Sedan kontrolleras varje fallpar om det (eller ett av uttrycken i listan) matchar det utvärderade uttrycket. Om ett matchande falluttryck hittas så utförs motsvarande uttryck och värdet av det sista uttrycket returneras. Om inget fall matchar, returneras NIL.

Exempel: `(CASE 1 ((2 3 4) 1) (1 2))' returnerar 2.

Se även IF, COND.

16.6.12 COND

COND är, liksom IF, en villkorlig operator.

(COND [(test-uttryck [uttryck ...]) ...])

COND testar det första uttrycket i varje lista en efter en. För den första som inte resulterar i NIL, utvärderas motsvarande uttryck uttryck ... och värdet av det sista uttrycket returneras.

Om alla testade uttryck resulterar i NIL returneras NIL.

Exempel

(COND ((> 1 2) "1 > 2")
      ((= 1 2) "1 = 2")
      ((< 1 2) "1 < 2")
)

resulterar i "1 < 2".

Se även IF, CASE.

16.6.13 DOTIMES

För enkla loopar kan kommandot DOTIMES användas.

(DOTIMES (namn int-uttryck [result-uttryck ...]) [loop-uttryck ...])

Här är namn namnet på en ny variabel som kommer att användas i loopen. Namnet måste börja med en liten bokstav, följt av ytterligare bokstäver, siffror eller understreck (se Name conventions).

Antalet gånger loopen utförs anges i int-uttryck. I result-uttryck ... kan uttryck specificeras som utförs efter att loopen avslutats. I loop-uttryck specificerar du loopens kropp, det vill säga, uttrycken som utvärderas i varje loopkörning.

Innan loopen utförs, beräknar DOTIMES värdet av int-uttryck för att bestämma antalet gånger loopen ska utföras. Här utvärderas int-uttryck endast en gång i början av loopen och måste resultera i ett heltalsvärde. Sedan sätter DOTIMES loopvariabeln till värdena från 0 till int-uttryck-1 en efter en för varje loopkörning. Först initialiseras variabeln med noll och kollas om den redan är större eller lika med värdet av uttryck. Om int-uttryck är negativt eller NIL eller om variabeln är större eller lika med värdet av uttryck avslutas loopen och resultatuttrycken utvärderas. Annars utvärderas looputtrycken och variabeln ökas med ett. Sedan återgår exekveringen till avslutningstestet och, eventuellt, utför ytterligare loopkörningar.

DOTIMES-uttrycket returnerar värdet av det sista resultatuttrycket eller NIL om inget resultatuttryck har angetts.

Exempel

(DOTIMES (i 50 i) (PRINT i))

Skriver ut talen från 0 till 49 och returnerar värdet 50.

Se även DOLIST, DO, FOR ALL, LET.

16.6.14 DOLIST

För loopar genom listor kan DOLIST-uttrycket användas.

(DOLIST (namn list-uttryck [result-uttryck ...]) [loop-uttryck ...])

Här är namn namnet på en ny variabel som kommer att användas i loopen. Namnet måste börja med en liten bokstav, följt av ytterligare bokstäver, siffror eller understreck (se Name conventions).

I list-uttryck anger du listan över vilken loopen ska utföras, result-uttryck ... är uttryck som utvärderas efter att loopen avslutats, och loop-uttryck ... bygger loopens kropp.

Innan loopen utförs, beräknar DOLIST värdet av list-uttryck. Detta uttryck utvärderas endast en gång i början av loopen och måste resultera i ett listvärde. Sedan sätter DOTIMES loopvariabeln till listans noder en efter en för varje loopkörning. Först initialiseras loopvariabeln till den första noden i listan. Om listan redan är tom (NIL) avslutas loopen och resultatuttrycken utvärderas. Annars utvärderas looputtrycken och variabeln sätts till nästa nod i listan. Sedan återgår exekveringen till avslutningstestet och, eventuellt, utför ytterligare loopkörningar.

DOLIST-uttrycket returnerar värdet av det sista resultatuttrycket eller NIL om inget resultatuttryck har angetts.

Exempel

(DOLIST (i (SELECT * FROM Accounts)) (PRINT i))

Skriver ut alla poster i tabellen `Accounts' och returnerar NIL.

Se även DOTIMES, DO, FOR ALL, LET.

16.6.15 DO

Med DO-uttrycket kan godtyckliga loopar programmeras.

(DO ([bindning ...]) (term-uttryck [result-uttryck ...]) [loop-uttryck ...])

där bindning ... är variabelbindningarna, var och en antingen:

• ett nytt namn för en variabel (som initialiseras till NIL)

• en lista i formen: (namn init [steg]) där namn är ett namn för den nya variabeln, init är det initiala värdet av variabeln, och steg är ett steguttryck.

Vidare är term-uttryck avslutningstest-uttrycket, result-uttryck ... är resultatuttrycken (standard är nil) och loop-uttryck ... bygger loopens kropp.

DO-loopen initialiserar först alla lokala variabler med init- uttrycken, testar sedan avslutningsuttrycket. Om det resulterar i TRUE, avslutas loopen och resultatuttrycken utvärderas. Värdet av det sista resultatuttrycket returneras. Annars utförs loopens kropp (loop-uttryck ...) och varje variabel uppdateras med värdet av dess steguttryck. Sedan återgår exekveringen till att testa avslutningsuttrycket och så vidare.

Exempel

(DO ((i 0 (+ i 1))) ((>= i 5) i) (PRINT i))

Skriver ut värdena 0, 1, 2, 3 och 4 och returnerar värdet 5. Detta är förstås ett ganska komplicerat sätt att bygga en enkel FOR-loop. Därför finns en enklare version, DOTIMES-uttrycket.

Se även DOTIMES, DOLIST, FOR ALL, LET.

16.6.16 FOR ALL

FOR ALL-uttrycket används för att loopa över en lista av poster.

(FOR ALL tabell-lista [WHERE where-uttryck] [ORDER BY ordnings-lista] DO uttryck ...)

Här är tabell-lista en kommaseparerad lista av tabeller, where-uttryck ett uttryck för att testa varje uppsättning av poster, ordnings-lista en kommaseparerad lista av uttryck efter vilka postuppsättningarna sorteras, och uttryck ... är uttrycken som utförs för varje postuppsättning.

FOR ALL genererar först en lista över alla postuppsättningar för vilka loopkroppen ska utföras. Detta görs som i SELECT-uttrycket. Se se SELECT, för mer information om hur denna lista genereras. För varje element i denna lista utförs loopkroppen uttryck ....

Till exempel kan summering av ett fält i en tabell göras på följande sätt:

(SETQ sum 0)
(FOR ALL Accounts DO
    (SETQ sum (+ sum Accounts.Amount))
)

FOR ALL-uttrycket returnerar NIL.

Se även SELECT, DOTIMES, DOLIST, DO.

16.6.17 NEXT

NEXT kan användas för att kontrollera DOTIMES, DOLIST, DO och FOR ALL loopar.

Att anropa NEXT i loopkroppen hoppar till nästa loopiteration. Detta kan användas för att hoppa över ointressanta loopkörningar, som t.ex. i följande exempel:

(FOR ALL Tabell DO
    (IF inte-intresserad-av-den-aktuella-posten (NEXT))
    ...
)

Se även EXIT, DOTIMES, DOLIST, DO, FOR ALL.

16.6.18 EXIT

EXIT kan användas för att avsluta en loop.

(EXIT [uttryck ...])

EXIT inom en loopkropp avslutar loopen, utför de valfria uttrycken uttryck ..., och returnerar värdet av det sista uttrycket (eller NIL i fall av inget uttryck) som returvärde för loopen. Eventuella returuttryck för loopen som till exempel i

(DOTIMES (x 10 ret-uttryck ...) ...)

utförs inte.

Du kan använda EXIT-funktionen till exempel för att avsluta en FOR ALL-loop när du hittat posten du är intresserad av:

(FOR ALL Tabell DO
    (IF intresserad-av-den-aktuella-posten (EXIT Tabell))
    ...
)

Se även NEXT, RETURN, HALT, DOTIMES, DOLIST, DO, FOR ALL.

16.6.19 RETURN

Inom en funktionsdefinition kan du återvända till anroparen genom att använda kommandot RETURN.

(RETURN [uttryck ...])

avslutar funktionen, utför de valfria uttrycken uttryck ..., och returnerar värdet av det sista uttrycket (eller NIL i fall av inget uttryck).

Exempel

(DEFUN find-record (name)
    (FOR ALL Table DO
        (IF (= Name name) (RETURN Table))
    )
)

Exemplet söker efter en post vars Name-fält matchar det givna namnet. Funktionen returnerar den första posten som hittas eller NIL i fall av att ingen post hittas.

Se även HALT, EXIT.

16.6.20 HALT

HALT kan användas för att avsluta programexekveringen.

(HALT)

stoppar programexekveringen tyst.

Se även ERROR, EXIT, RETURN.

16.6.21 ERROR

För att avbryta programexekveringen med ett felmeddelande kan funktionen ERROR användas.

(ERROR fmt [arg ...])

stoppar programexekveringen och visar en dialog med ett felmeddelande. Felmeddelandet genereras från fmt och de valfria argumenten arg ... som i funktionen SPRINTF (se SPRINTF).

Se även HALT, SPRINTF.

16.7 Typpredikat

För varje typ finns ett predikat definierat som returnerar TRUE om det angivna uttrycket är av den specificerade typen och NIL annars. Predikaten är:

Predikat             Beskrivning

(STRP uttryck)        TRUE om uttryck är av typen sträng, NIL annars.

(MEMOP uttryck)       TRUE om uttryck är av typen memo, NIL annars.

(INTP uttryck)        TRUE om uttryck är av typen heltal, NIL annars.

(REALP uttryck)       TRUE om uttryck är av typen reellt tal, NIL annars.

(DATEP uttryck)       TRUE om uttryck är av typen datum, NIL annars.

(TIMEP uttryck)       TRUE om uttryck är av typen tid, NIL annars.

(NULL uttryck)        TRUE om uttryck är NIL (en tom lista), NIL annars.

(CONSP uttryck)       TRUE om uttryck är en icke-tom lista, NIL annars.

(LISTP uttryck)       TRUE om uttryck är en lista (kan vara NIL), NIL annars.

(RECP tabell uttryck)  TRUE om uttryck är en postpekare för den angivna tabellen.
                    Om uttryck är NIL returneras TRUE (initiell post).
                    Om tabell är NIL görs en kontroll om uttryck
                    är en postpekare för någon tabell.

16.8 Typkonverteringsfunktioner

Detta avsnitt listar funktioner för att konvertera värden från en typ till en annan.

16.8.1 STR

STR kan användas för att konvertera ett uttryck till en strängrepresentation.

(STR uttryck)

konverterar uttryck till en strängrepresentation. Typen av uttryck bestämmer konverteringen:

Typ              Returnerad sträng

String          Strängen själv.

Memo            Hela memotexten i en sträng.

Integer         Strängrepresentation av heltalsvärdet.

Real            Strängrepresentation av reellt värde.
                Om uttryck är ett fält används antalet
                decimaler som specificerats för detta fält,
                annars används 2 decimaler.

Choice          Etikettsträng för valfältet.

Date            Strängrepresentation av datumvärde.

Time            Strängrepresentation av tidsvärde.

Boolean         Strängen "TRUE"

NIL             Användardefinierad nil-sträng om uttryck är ett fält,
                strängen "NIL" annars.

Record          Strängrepresentation av postnummer.

Others          Strängrepresentation av intern adresspekare.

Se även MEMO, SPRINTF.

16.8.2 MEMO

MEMO kan användas för att konvertera ett uttryck till ett memo.

(MEMO uttryck)

konverterar uttryck till en memo-representation. Den behandlar uttrycket som funktionen STR (se STR) men returnerar en memotext istället för en sträng.

Se även STR.

16.8.3 INT

INT används för att konvertera ett uttryck till ett heltal.

(INT uttryck)

konverterar uttryck till ett heltalsvärde. Möjliga konverteringar är:

Typ              Returvärde

String          Om hela strängen representerar ett giltigt heltalsvärde,
                konverteras den till ett heltal. En sträng som börjar
                med 0 tolkas som ett oktalt tal, en som börjar
                med 0x som ett hexadecimalt tal. Inledande och efterföljande
                mellanslag ignoreras.
                Om strängen inte representerar ett heltalsvärde, returneras NIL.

Memo            Samma som för sträng.

Integer         Värdet självt.

Real            Om värdet ligger inom heltalsintervallet rundas det reella värdet
                och returneras, annars returneras NIL.

Choice          Det interna numret (börjar med 0) för den aktuella etiketten.

Date            Antal dagar sedan 01.01.0000.

Time            Antal sekunder sedan 00:00:00.

Record          Postnummer.

NIL             NIL

Others          Ett felmeddelande genereras och programexekveringen avbryts.

Se även REAL, ASC.

16.8.4 REAL

REAL används för att konvertera ett uttryck till ett värde av typen reellt tal.

(REAL uttryck)

konverterar uttryck till ett reellt tal. Den behandlar uttrycket som funktionen INT (se INT) men returnerar ett värde av typen reellt tal istället för ett heltal.

Se även INT.

16.8.5 DATE

DATE används för att konvertera ett uttryck till ett datum (med din favoritvän :-).

(DATE uttryck)

konverterar det givna uttrycket till ett datumvärde. Möjliga konverteringar är:

Typ              Returvärde

String          Om hela strängen representerar ett datumvärde konverteras
                strängen till ett datumvärde. Inledande och efterföljande
                mellanslag ignoreras.
                Om den inte representerar ett datumvärde, returneras NIL.

Memo            Samma som för sträng.

Integer         Ett datumvärde genereras där det givna heltalet representerar
                antalet dagar sedan 01.01.0000. Om heltalsvärdet är
                för stort (datumvärdet skulle vara större än 31.12.9999) eller
                negativt returneras NIL.

Real            Samma som för heltal.

Date            Värdet självt.

NIL             NIL

others          Ett felmeddelande genereras och programexekveringen avbryts.

Se även DATEDMY.

16.8.6 TIME

TIME används för att konvertera ett uttryck till ett tidsvärde.

(TIME uttryck)

konverterar det givna uttrycket till ett tidsvärde. Möjliga konverteringar är:

Typ              Returvärde

String          Om hela strängen representerar ett tidsvärde konverteras
                strängen till ett tidsvärde. Inledande och efterföljande
                mellanslag ignoreras.
                Om den inte representerar ett tidsvärde, returneras NIL.

Memo            Samma som för sträng.

Integer         Ett tidsvärde genereras där det givna heltalet representerar
                antalet sekunder sedan 00:00:00.

Real            Samma som för heltal.

Time            Värdet självt.

NIL             NIL

others          Ett felmeddelande genereras och programexekveringen avbryts.

16.9 Booleska funktioner

Detta avsnitt listar Booleska operatorer.

16.9.1 AND

AND kontrollerar om alla dess argument är TRUE.

(AND [uttryck ...])

kontrollerar uttryck ... ett efter ett tills ett uttryck utvärderas till NIL. Om alla uttryck utvärderas till icke-NIL returneras värdet av det sista uttrycket. Annars returneras NIL.

Denna funktion är icke-strikt vilket betyder att argument till AND kanske inte utvärderas, t.ex. i `(AND NIL (+ 1 2))' utvärderas uttrycket `(+ 1 2)' inte eftersom ett NIL-värde redan har bearbetats, men i `(AND (+ 1 2) NIL)' utvärderas uttrycket `(+ 1 2)'.

Se även OR, NOT.

16.9.2 OR

OR kontrollerar om alla dess argument är NIL.

(OR [uttryck ...])

kontrollerar uttryck ... ett efter ett tills ett uttryck utvärderas till icke-NIL. Returnerar värdet av det första icke-NIL-uttrycket eller NIL om alla uttryck utvärderas till NIL.

Denna funktion är icke-strikt vilket betyder att argument till OR kanske inte utvärderas, t.ex. i `(OR TRUE (+ 1 2))' utvärderas uttrycket `(+ 1 2)' inte eftersom ett icke-NIL-värde (här `TRUE') redan har bearbetats, men i `(OR (+ 1 2) TRUE)' utvärderas uttrycket `(+ 1 2)'.

Se även AND, NOT.

16.9.3 NOT

NOT används för att invertera värdet av ett booleskt uttryck.

(NOT uttryck)

resulterar i TRUE om uttryck är NIL, NIL annars.

Se även AND, OR.

16.10 Jämförelsefunktioner

I detta avsnitt hittar du funktioner för att jämföra värden.

16.10.1 Relationsoperatorer

För att jämföra två värden i ett BeeBase-program, använd

(op uttryck1 uttryck2)

där op är i {=, <>, <, >, >=, <=, =*, <>*, <*, >*, >=*, <=*}. Stjärnan används för särskild jämförelse (strängar jämförs skiftlägesokänsligt, poster jämförs genom att använda ordningen som definieras av användaren).

Följande tabell visar alla regler för att jämföra två värden i ett BeeBase-program.

Typ         Ordningsrelation

Integer     NIL < MIN_INT < ... < -1 < 0 < 1 < ... < MAX_INT

Real        NIL < -HUGE_VAL < ... < -1.0 < 0.0 < 1.0 < ... < HUGE_VAL

String:     NIL <  "" <  "Z" <  "a"  <  "aa" <  "b" < ... (skiftlägeskänslig)
            NIL <* "" <* "a" <* "AA" <* "b" < ...       (skiftlägesokänslig)

Memo:       samma som sträng

Date        NIL < 1.1.0000 < ... < 31.12.9999

Time        NIL < 00:00:00 < ... < 596523:14:07 

Boolean     NIL < TRUE

Record:     NIL < any_record    (poster själva är inte jämförbara med <)
            NIL <* rec1 <* rec2 (ordning specificerad av användaren)

Se även CMP, CMP*, LIKE.

16.10.2 CMP

CMP returnerar ett heltal som representerar ordningen av dess argument.

(CMP uttryck1 uttryck2)

returnerar ett värde mindre än 0 om uttryck1 är mindre än uttryck2, 0 om uttryck1 är lika med uttryck2, och ett värde större än 0 om uttryck1 är större än uttryck2. För att bestämma ordningen används den enkla (icke-stjärn) ordningsrelationen som för relationsoperatorer (se Relational operators).

Anta inte att det returnerade värdet alltid kommer att vara -1, 0 eller 1!

Exempel: `(CMP "Bike" "bIKE")' resulterar i -1.

Se även CMP*, Relational operators.

16.10.3 CMP*

CMP* är stjärnversionen av CMP. Skillnaden är att CMP* använder den utökade ordningen som definieras för relationsoperatorer (se Relational operators) där strängar jämförs skiftlägesokänsligt och poster jämförs med användardefinierad postordning.

Exempel: `(CMP* "Bike" "bIKE")' resulterar i 0.

Se även CMP, Relational operators.

16.10.4 MAX

MAX returnerar det argument som har det största värdet.

(MAX [uttryck ...])

Returnerar maxvärdet av argumenten uttryck .... Om inga argument ges returneras NIL. För att bestämma det största elementet används den enkla (icke-stjärn) ordningsrelationen som för relationsoperatorer (se Relational operators).

Se även MAX*, MIN, Relational operators.

16.10.5 MAX*

MAX* är stjärnversionen av MAX. Skillnaden är att MAX* använder den utökade ordningen som definieras för relationsoperatorer (se Relational operators) där strängar jämförs skiftlägesokänsligt och poster jämförs med användardefinierad postordning.

Exempel: `(MAX* "x" "Y")' resulterar i "Y".

Se även MAX, MIN*, Relational operators.

16.10.6 MIN

MIN returnerar det argument som har det minsta värdet.

(MIN [uttryck ...])

Returnerar minvärdet av argumenten uttryck .... Om inga argument ges returneras NIL. För att bestämma det minsta elementet används den enkla (icke-stjärn) ordningsrelationen som för relationsoperatorer (se Relational operators).

Se även MIN*, MAX, Relational operators.

16.10.7 MIN*

MIN* är stjärnversionen av MIN. Skillnaden är att MIN* använder den utökade ordningen som definieras för relationsoperatorer (se Relational operators) där strängar jämförs skiftlägesokänsligt och poster jämförs med användardefinierad postordning.

Exempel: `(MIN* "x" "Y")' resulterar i "x".

Se även MIN, MAX*, Relational operators.

16.11 Matematiska funktioner

Här listas några matematiska funktioner.

16.11.1 Addera värden

För att addera värden, använd

(+ uttryck ...)

Returnerar summan av argumenten uttryck .... Om något argumentvärde är NIL då är resultatet NIL. Om värdena är av typen reellt tal eller heltal då är ett reellt (eller heltal) värde resultatet.

Du kan också addera strängar eller memon. I detta fall är resultatet en sammanslagning av strängarna/memona.

Om uttryck är av typen datum och resten av argumenten är heltal/reella tal då tolkas summan av heltal/reella tal som ett antal dagar och läggs till uttryck. Om det resulterande datumet är utanför intervallet (mindre än 1.1.0000 eller större än 31.12.9999) då är NIL resultatet.

Om uttryck är av typen tid och resten av argumenten är heltal/reella tal eller andra tidsvärden då läggs summan av heltal/reella tal (tolkade som ett antal sekunder) och tidsvärden till uttryck. Om den resulterande tiden är utanför intervallet (mindre än 00:00:00 eller större än 596523:14:07) då är NIL resultatet.

Exempel

Uttryck                          Värde

(+ 1 2 3)                        6
(+ 5 1.0)                        6.0
(+ "Hello" " " "world!")         "Hello world!"
(+ 28.11.1968 +365 -28 -9)       22.10.1969
(+ 07:30:00 3600)                08:30:00
(+ 03:00:00 23:59:59)            26:59:59

Se även -, 1+, *, CONCAT, CONCAT2, ADDMONTH, ADDYEAR.

16.11.2 Subtrahera värden

För att subtrahera värden, använd

(- uttryck1 uttryck2 ...)

Subtraherar summan av uttryck2 ... från uttryck1. Här gäller samma regler som för att addera värden (se +), förutom att strängar och memon inte kan subtraheras.

(- uttryck) har en speciell betydelse, den returnerar det negativa värdet av uttryck (heltal eller reellt tal), t.ex. `(- (+ 1 2))' resulterar i -3.

Se även +, 1-.

16.11.3 1+

1+ ökar ett heltal, reellt tal, datum eller tiduttryck med ett.

(1+ uttryck)

Returnerar värdet av uttryck (heltal, reellt tal, datum eller tid) plus ett. Om uttryck är NIL returneras NIL.

Se även +, 1-.

16.11.4 1-

1- minskar ett heltal, reellt tal, datum eller tiduttryck med ett.

(1- uttryck)

Returnerar värdet av uttryck (heltal, reellt tal, datum eller tid) minus ett. Om uttryck är NIL returneras NIL.

Se även -, 1+.

16.11.5 Multiplicera värden

För att multiplicera heltal/reella värden, använd

(* uttryck ...)

Returnerar multiplikationen av heltal/reella värden uttryck .... Om alla argument är heltal returneras ett heltal, annars är resultatet ett värde av typen reellt tal.

Se även +, /.

16.11.6 Dividera värden

För att dividera heltal/reella värden, använd

(/ uttryck1 [uttryck2 ...])

Dividerar uttryck1 med multiplikationen av resten av argumenten. Returnerar ett reellt värde. Vid division med noll returneras NIL.

Se även *, DIV, MOD.

16.11.7 DIV

DIV används för heltalsdelning.

(DIV int1 int2)

Returnerar heltalsdelningen av int1 med int2. Till exempel, `(DIV 5 3)' resulterar i 1.

Se även /, MOD.

16.11.8 MOD

MOD används för moduloberäkning.

(MOD int1 int2)

Returnerar int1 modulo int2. Till exempel, `(MOD 5 3)' resulterar i 2.

Se även DIV.

16.11.9 ABS

ABS beräknar absolutvärdet av ett uttryck.

(ABS uttryck)

Returnerar absolutvärdet av uttryck (heltal eller reellt tal). Om uttryck är NIL returneras NIL.

16.11.10 TRUNC

TRUNC trunkerar decimaler av ett reellt värde.

(TRUNC real)

Returnerar det största heltalet (som ett reellt tal) som inte är större än det angivna reella talet. Om real är NIL returneras NIL.

Exempel: `(TRUNC 26.1)' resulterar i 26, `(TRUNC -1.2)' resulterar i -2.

Se även ROUND.

16.11.11 ROUND

ROUND avrundar ett reellt värde.

(ROUND real digits)

Returnerar det angivna reella talet avrundat till digits decimaler. Om real eller digits är NIL returneras NIL.

Exempel: `(ROUND 70.70859 2)' resulterar i 70.71, `(ROUND 392.36 -1)' resulterar i 390.0.

Se även TRUNC.

16.11.12 RANDOM

RANDOM kan användas för att generera slumptal.

(RANDOM uttryck)

Returnerar ett slumptal. Vid första anropet initialiseras slumptalsgeneratorn med ett värde genererat från aktuell tid. RANDOM genererar ett slumptal i intervallet 0 ... uttryck, exklusive värdet av uttryck självt. Typen av uttryck (heltal eller reellt tal) är returtypen. Om uttryck är NIL returneras NIL.

Exempel:

Exempel                 Betydelse

(RANDOM 10)             returnerar ett värde från 0 till 9,
(RANDOM 10.0)           returnerar ett värde från 0.0 till 9.99999...

16.11.13 POW

POW beräknar potens av värden.

(POW x y)

Returnerar värdet av det reella värdet x upphöjt till det reella värdet y. Om antingen x eller y är NIL, eller om x är negativt och y inte ett heltal, returneras NIL.

Exempel: `(POW 2 3)' resulterar i 8.

Se även SQRT, EXP.

16.11.14 SQRT

SQRT beräknar kvadratroten av ett tal.

(SQRT x)

Returnerar kvadratroten av reellt värde x. Om x är NIL eller ett negativt tal returneras NIL.

Se även POW.

16.11.15 EXP

EXP beräknar exponentialfunktionen.

(EXP x)

Returnerar värdet av basen för den naturliga logaritmen upphöjt till det reella värdet x. Om x är NIL returneras NIL.

Se även POW, LOG.

16.11.16 LOG

LOG beräknar den naturliga logaritmen av ett tal.

(LOG x)

Returnerar den naturliga logaritmen av reellt värde x. Om x är NIL eller inte ett positivt tal returneras NIL.

Se även EXP.

16.12 Strängfunktioner

Detta avsnitt behandlar funktioner som är användbara för strängar.

16.12.1 LEN

LEN beräknar längden på en sträng.

(LEN str)

Returnerar längden på den givna strängen eller NIL om str är NIL.

Se även WORDS, LINES, MAXLEN.

16.12.2 LEFTSTR

LEFTSTR extraherar en delsträng ur en sträng.

(LEFTSTR str len)

Returnerar den vänstra delen av den givna strängen med högst len tecken. Om str eller len är NIL eller om len är negativt då returneras NIL.

Exempel: `(LEFTSTR "Hello world!" 5)' resulterar i "Hello".

Se även RIGHTSTR, MIDSTR, WORD, LINE, MEMOHEAD.

16.12.3 RIGHTSTR

(RIGHTSTR str len)

Returnerar den högra delen av den givna strängen med högst len tecken. Om str eller len är NIL eller om len är negativt då returneras NIL.

Exempel: `(RIGHTSTR "Hello world!" 6)' resulterar i "world!".

Se även LEFTSTR, MIDSTR, WORD, LINE, MEMOTAIL.

16.12.4 MIDSTR

MIDSTR extraherar en delsträng ur en sträng.

(MIDSTR str pos len)

Returnerar en del av den givna strängen med högst len tecken. Delsträngen börjar vid pos-te positionen (börjar med noll). Om len är NIL returneras hela delsträngen som börjar vid pos. Om str är NIL eller om len är negativt returneras NIL. Om pos är utanför intervallet, det vill säga, negativt eller större än stränglängden, returneras NIL.

Exempel: `(MIDSTR "Hello world!" 3 5)' resulterar i "lo wo".

Se även LEFTSTR, RIGHTSTR, WORD, LINE, SETMIDSTR, INSMIDSTR.

16.12.5 SETMIDSTR

SETMIDSTR ersätter en delsträng i en sträng.

(SETMIDSTR str index set)

Returnerar en kopia av strängen str där delsträngen som börjar vid index skrivs över med strängen set. Längden på den returnerade strängen är större än eller lika med längden på str. Om ett av argumenten är NIL eller om index är utanför intervallet returneras NIL.

Exempel: `(SETMIDSTR "Hello world!" 6 "Melanie!")' resulterar i "Hello Melanie!".

Se även INSMIDSTR, REPLACESTR.

16.12.6 INSMIDSTR

INSMIDSTR används för att infoga en delsträng i en sträng.

(INSMIDSTR str index insert)

Returnerar en kopia av strängen str där strängen insert har infogats vid det angivna indexet. Om ett av argumenten är NIL eller om index är utanför intervallet returneras NIL.

Exempel: `(INSMIDSTR "Hello world!" 6 "BeeBase-")' resulterar i "Hello BeeBase-world!".

Se även SETMIDSTR, REPLACESTR.

16.12.7 INDEXSTR

INDEXSTR söker i en sträng efter den första förekomsten av en delsträng.

(INDEXSTR str substr)

Söker efter den första förekomsten av substr i str. Strängjämförelse görs skiftlägeskänsligt. Returnerar indexet (börjar med 0) för delsträngen i str eller NIL om delsträngen inte finns. Om ett av argumenten är NIL returneras NIL.

Exempel: `(INDEXSTR "Hello world!" "world")' returnerar 6.

Se även INDEXSTR*, RINDEXSTR, RINDEXSTR*, INDEXBRK, INDEXBRK*.

16.12.8 INDEXSTR*

INDEXSTR* har samma effekt som INDEXSTR (se INDEXSTR) förutom att strängjämförelse görs skiftlägesokänsligt.

Se även INDEXSTR, RINDEXSTR, RINDEXSTR*, INDEXBRK, INDEXBRK*.

16.12.9 INDEXBRK

INDEXBRK söker efter den första förekomsten av ett tecken i en sträng.

(INDEXBRK str brkstr)

Söker efter den första förekomsten av ett tecken från brkstr i str. Strängjämförelse görs skiftlägeskänsligt. Returnerar indexet (börjar med 0) för det första tecknet som hittas i str eller NIL om inget tecken hittas. Om ett av argumenten är NIL returneras NIL.

Exempel: `(INDEXBRK "Hello world!" "aeiou")' returnerar 1.

Se även INDEXBRK*, RINDEXBRK, RINDEXBRK*, INDEXSTR, INDEXSTR*.

16.12.10 INDEXBRK*

INDEXBRK* har samma effekt som INDEXBRK (se INDEXBRK) förutom att strängjämförelse görs skiftlägesokänsligt.

Se även INDEXBRK, RINDEXBRK, RINDEXBRK*, INDEXSTR, INDEXSTR*.

16.12.11 RINDEXSTR

RINDEXSTR söker i en sträng efter den sista förekomsten av en delsträng.

(RINDEXSTR str substr)

Söker efter den sista förekomsten av substr i str. Strängjämförelse görs skiftlägeskänsligt. Returnerar indexet (börjar med 0) för delsträngen i str eller NIL om delsträngen inte finns. Om ett av argumenten är NIL returneras NIL.

Exempel: `(RINDEXSTR "Do itashimashite." "shi")' returnerar 11.

Se även RINDEXSTR*, INDEXSTR, INDEXSTR*, RINDEXBRK, RINDEXBRK*.

16.12.12 RINDEXSTR*

RINDEXSTR* har samma effekt som RINDEXSTR (se RINDEXSTR) förutom att strängjämförelse görs skiftlägesokänsligt.

Se även RINDEXSTR, INDEXSTR, INDEXSTR*, RINDEXBRK, RINDEXBRK*.

16.12.13 RINDEXBRK

RINDEXBRK söker efter den sista förekomsten av ett tecken i en sträng.

(RINDEXBRK str brkstr)

Söker efter den sista förekomsten av ett tecken från brkstr i str. Strängjämförelse görs skiftlägeskänsligt. Returnerar indexet (börjar med 0) för det sista tecknet som hittas i str eller NIL om inget tecken hittas. Om ett av argumenten är NIL returneras NIL.

Exempel: `(RINDEXBRK "Konnichiwa" "chk")' returnerar 6.

Se även RINDEXBRK*, INDEXBRK, INDEXBRK*, RINDEXSTR, RINDEXSTR*.

16.12.14 RINDEXBRK*

RINDEXBRK* har samma effekt som RINDEXBRK (se RINDEXBRK) förutom att strängjämförelse görs skiftlägesokänsligt.

Se även RINDEXBRK, INDEXBRK, INDEXBRK*, RINDEXSTR, RINDEXSTR*.

16.12.15 REPLACESTR

REPLACESTR ersätter delsträngar med andra strängar.

(REPLACESTR str [substr1 replacestr1 ...])

Ersätter alla förekomster av substr1 i str med replacestr1. Fortsätter ersätta ytterligare delsträngar i den nya strängen med användning av nästa par av sök- och ersättningssträng tills alla argument har bearbetats. Observera att antalet argument måste vara udda med argument på jämna positioner som specificerar söksträngarna vardera följt av ersättningssträngen. På grund av det faktum att resultatet av en ersättning används i nästa följande ersättning, kan flera ersättningar äga rum. Detta bör beaktas när denna funktion används. En annan ordning av argumenten kan hjälpa till att lösa konflikter eftersom ersättningar görs från vänster till höger.

Om någon av strängarna är NIL eller någon söksträng är tom returneras NIL.

Exempel: `(REPLACESTR "black is white" "black" "white" "white "black")' resulterar i "black is black".

Se även REPLACESTR*, SETMIDSTR, INSMIDSTR, REMCHARS.

16.12.16 REPLACESTR*

REPLACESTR* har samma effekt som REPLACESTR (se REPLACESTR) förutom att strängjämförelse görs skiftlägesokänsligt vid sökning efter delsträngar.

Se även REPLACESTR, SETMIDSTR, INSMIDSTR, REMCHARS.

16.12.17 REMCHARS

REMCHARS tar bort tecken från en sträng.

(REMCHARS str chars-to-remove)

Returnerar en kopia av str där alla tecken i chars-to-remove har tagits bort. Om str eller chars-to-remove är NIL då returneras NIL.

Exempel: `(REMCHARS your-string " \t\n")' tar bort alla mellanslag, tabbar och nyradstecken från your-string.

Se även REPLACESTR, TRIMSTR.

16.12.18 TRIMSTR

TRIMSTR tar bort inledande och avslutande tecken från en sträng.

(TRIMSTR str [front back])

Returnerar en kopia av str där inledande och avslutande tecken har tagits bort. Om anropad med endast ett argument tas mellanslag, sidmatningar, nyradstecken, vagnreturer och horisontella och vertikala tabbar bort. När anropad med tre argument, specificerar front de inledande och back de avslutande tecknen som ska tas bort. Observera att TRIMSTR inte kan anropas med två argument.

Om något av str, front eller back är NIL returneras NIL.

Exempel: (TRIMSTR " I wrecked Selma's bike. ") resulterar i "I wrecked Selma's bike.", (TRIMSTR "007 " "0" " \f\n\r\t\v") resulterar i "7".

Se även REMCHARS.

16.12.19 WORD

WORD returnerar ett ord i en sträng.

(WORD str num)

Returnerar det num-te ordet (börjar med noll) i den givna strängen. Ord i en sträng är icke-tomma delsträngar separerade av en eller flera icke-brytbara mellanslagstecken (t.ex. mellanslag, tab eller nyradstecken).

Om str eller num är NIL, eller om num är utanför intervallet, det vill säga, mindre än noll eller större än eller lika med antalet ord, returneras NIL.

Exempel: `(WORD "Therefore, I lend Selma my bike." 3)' resulterar i "Selma".

Se även WORDS, LINE, FIELD, LEFTSTR, RIGHTSTR, MIDSTR, STRTOLIST.

16.12.20 WORDS

WORDS räknar antalet ord i en sträng.

(WORDS str)

Returnerar antalet ord i den givna strängen eller NIL om str är NIL. Ord är delsträngar separerade av en eller flera icke-brytbara mellanslagstecken (t.ex. mellanslag, tab eller nyradstecken).

Exempel: `(WORDS "Actually, it wasn't really my bike.")' resulterar i 6.

Se även WORD, FIELDS, LINES, LEN.

16.12.21 FIELD

FIELD returnerar ett fält i en sträng.

(FIELD str num [sep [quotes]])

Returnerar det num-te fältet (börjar med noll) i den givna strängen. Fält i en sträng är delsträngar separerade av exakt ett separatortecken. Ett fält kan vara en tom sträng. Argumentet sep innehåller tecknen som separerar fält. Om sep är NIL eller inte anges används icke-brytbara mellanslagstecken (t.ex. mellanslag, tab eller nyradstecken). Om quotes anges och inte är NIL kan fält omges av dubbla citattecken och kan innehålla separatortecken. De dubbla citattecknen tas bort när fältet returneras.

Om str eller num är NIL, eller om num är utanför intervallet, det vill säga, mindre än noll eller större än eller lika med antalet fält, returneras NIL.

Exempel: `(FIELD "My name is \"Darth Vader\"" 3 " " TRUE)' resulterar i "Darth Vader".

Se även FIELDS, WORD, LEFTSTR, RIGHTSTR, MIDSTR, STRTOLIST.

16.12.22 FIELDS

FIELDS räknar antalet fält i en sträng.

(FIELDS str [sep [quotes]])

Returnerar antalet fält i den givna strängen eller NIL om str är NIL. Fält i en sträng är delsträngar separerade av exakt ett separatortecken. Ett fält kan vara en tom sträng. Argumentet sep innehåller tecknen som separerar fält. Om sep är NIL eller inte anges används icke-brytbara mellanslagstecken (t.ex. mellanslag, tab eller nyradstecken). Om quotes anges och inte är NIL kan fält omges av dubbla citattecken och kan innehålla separatortecken.

Se även FIELD, WORDS, LEN.

16.12.23 STRTOLIST

STRTOLIST konverterar en sträng till en lista av delsträngar.

(STRTOLIST str [sep])

Skapar en lista av delsträngar genom att dela strängen str vid förekomster av separationssekvensen sep. Om sep inte specificeras används tab-tecknet "\t". Om sep är den tomma strängen "" returneras en lista av alla tecken i strängen.

Om str eller sep är NIL returneras NIL.

Exempel

`(STRTOLIST "I\tlike\tJapan.")' resulterar i ( "I" "like" "Japan." ).

`(STRTOLIST "Name|Street|City" "|")' resulterar i ( "Name" "Street" "City" ).

`(STRTOLIST "abc" "")' resulterar i ( "a" "b" "c" ).

Se även MEMOTOLIST, LISTTOSTR, WORD.

16.12.24 LISTTOSTR

LISTTOSTR konverterar en lista av objekt till en sträng.

(LISTTOSTR list [sep])

Konverterar den givna listan av objekt till en sträng genom sammanfogning av strängrepresentationerna av varje listelement separerade av sekvensen sep. Om sep inte specificeras används tab-tecknet "\t". Om list eller sep är NIL returneras NIL.

Exempel

`(LISTTOSTR (LIST "Peter is" 18 "years old"))' resulterar i: "Peter is\t18\tyears old".

`(LISTTOSTR (LIST "Name" "Street" "City") "|")' resulterar i: "Name|Street|City".

Se även LISTTOMEMO, CONCAT, CONCAT2, STRTOLIST.

16.12.25 CONCAT

CONCAT sammanfogar strängar.

(CONCAT [str ...])

Returnerar sammanfogningen av den givna listan av strängar där mellanslagstecken har infogats mellan strängarna. Om en av strängarna är NIL, eller listan är tom, returneras NIL.

Exempel: `(CONCAT "I" "thought" "it" "was" "an" "abandoned" "bike.")' resulterar i "I thought it was an abandoned bike.".

Se även CONCAT2, +, LISTTOSTR, COPYSTR, SPRINTF.

16.12.26 CONCAT2

CONCAT2 sammanfogar strängar.

(CONCAT2 insert [str ...])

Returnerar sammanfogningen av den givna listan av strängar. Strängarna kommer att separeras med den givna insert-strängen. Om insert är NIL, en av strängarna är NIL, eller listan är tom, returneras NIL.

Exempel: `(CONCAT2 "! " "But" "it" "wasn't!")' resulterar i "But! it! wasn't!".

Se även CONCAT, +, LISTTOSTR, COPYSTR, SPRINTF.

16.12.27 COPYSTR

COPYSTR skapar kopior av en sträng.

(COPYSTR str num)

Returnerar en sträng bestående av num gånger strängen str. Om str är NIL, num är NIL eller mindre än noll, returneras NIL.

Exempel: `(COPYSTR "+-" 5)' resulterar i "+-+-+-+-+-".

Se även CONCAT CONCAT2, +, SPRINTF.

16.12.28 SHA1SUM

SHA1SUM beräknar SHA1-hash av en sträng.

(SHA1SUM str)

Returnerar en sträng som innehåller SHA1-hashen av den givna strängen. Om str är NIL returneras NIL.

Exempel: `(SHA1SUM "flower, sun and beach")' resulterar i "47b6c496493c512b40e042337c128d85ecf15ba4".

Se även ADMINPASSWORD, demo `Users.bbs'.

16.12.29 UPPER

UPPER konverterar en sträng till versaler.

(UPPER str)

Returnerar en kopia av den givna strängen där alla tecken är konverterade till versaler. Om str är NIL då returneras NIL.

Exempel: `(UPPER "Selma found a letter attached to my bike.")' resulterar i "SELMA FOUND A LETTER ATTACHED TO MY BIKE.".

Se även LOWER.

16.12.30 LOWER

LOWER konverterar en sträng till gemener.

(LOWER str)

Returnerar en kopia av den givna strängen där alla tecken är konverterade till gemener. Om str är NIL då returneras NIL.

Exempel: `(LOWER "The letter was from Silke.")' resulterar i "the letter was from silke.".

Se även UPPER.

16.12.31 ASC

ASC konverterar ett tecken till dess interna heltalsrepresentation.

(ASC str)

Returnerar den interna heltalskoden för det första tecknet i str. På Windows, Mac OS och Linux är detta unicode-representationen. På Amiga är det den 8-bitars heltalskoden i standardteckenkodningen. Om str är tom returneras 0. Om str är NIL returneras NIL.

Exempel: (ASC "A") resulterar i 65.

Se även CHR, INT.

16.12.32 CHR

CHR konverterar en heltalskod till ett tecken.

(CHR int)

Returnerar en sträng som innehåller tecknet med heltalskod int. På Windows, Mac OS och Linux tolkas int som ett unicode-tecken. På Amiga är int den 8-bitars heltalet i standardteckenkodningen. Om int är 0 returneras en tom sträng. Om int är NIL eller inte i intervallet av giltiga teckenvärden, returneras NIL.

Exempel: `(CHR 67)' resulterar i "C".

Se även ASC, STR.

16.12.33 LIKE

LIKE jämför strängar.

(LIKE str1 str2)

Returnerar TRUE om str1 matchar str2, NIL annars. Strängen str2 kan innehålla jokertecknen '?' och '*' där '?' matchar exakt ett tecken och '*' matchar en sträng av godtycklig längd. Strängjämförelse görs skiftlägesokänsligt.

Exempel: `(LIKE "Silke has been in France for one year." "*France*")' resulterar i TRUE.

Se även Comparison functions.

16.12.34 SPRINTF

SPRINTF formaterar en sträng med olika data.

(SPRINTF fmt [uttryck ...])

SPRINTF tar en serie argument, konverterar dem till strängar, och returnerar den formaterade informationen som en sträng. Strängen fmt bestämmer exakt vad som skrivs till retursträngen och kan innehålla två typer av objekt: vanliga tecken som alltid kopieras ordagrant och konverteringsspecificerare som instruerar SPRINTF att ta argument från sin argumentlista och formatera dem. Konverteringsspecificerare börjar alltid med ett `%'-tecken.

Konverteringsspecificerare har alltid följande form:

%[flaggor][bredd][.precision]typ

där

• Det valfria fältet flaggor styr utdatajustering, tecken på numeriska värden, decimalpunkter och avslutande blanktecken.

• Det valfria fältet bredd specificerar det minsta antalet tecken att skriva ut (fältbredden), med utfyllnad med blanktecken eller nollor.

• Det valfria fältet precision specificerar antingen det maximala antalet tecken att skriva ut för typerna sträng, Boolean, datum och tid, eller antalet siffror efter decimalpunkten att skriva ut för värden av typen reellt tal.

• typ-fältet specificerar den faktiska typen av argumentet som SPRINTF kommer att konvertera, såsom sträng, heltal, reellt tal, etc.

Observera att alla ovanstående fält är valfria förutom typ. Följande tabeller listar de giltiga alternativen för dessa fält.

Flaggfält

-:

Resultatet är vänsterjusterat, med utfyllnad på höger sida med blanktecken. Som standard när `-' inte specificeras, är resultatet högerjusterat med utfyllnad på vänster sida med `0':or eller blanktecken.

+:

Resultatet kommer alltid att ha ett `-' eller `+'-tecken framför det om det är en numerisk konvertering.

0:

För tal görs utfyllnad på vänster sida med ledande nollor istället för mellanslag.

space:

Positiva tal börjar med ett mellanslag istället för ett `+'-tecken, men negativa värden har fortfarande ett `-' framför.

Bredd-fält

n:

Minst n tecken matas ut. Om konverteringen har färre än n tecken, fylls fältet ut med blanktecken eller ledande nollor.

*:

Breddspecificeraren tillhandahålls i argumentlistan som ett heltal eller reellt värde, före det faktiska konverteringsargumentet. Detta värde är begränsat till intervallet 0 till 999.

Precision-fält

.n:

För sträng-, Boolean-, datum- och tidvärden, är n det maximala antalet tecken som skrivs från det konverterade objektet. För konverteringar av reella värden specificerar n antalet siffror efter decimalpunkten (konverteringarna `f' och `e') eller antalet signifikanta siffror (konvertering `g'). För heltalskonverteringar ignoreras detta fält.

.*:

Precisionen tillhandahålls i argumentlistan som ett heltal eller reellt värde, före det faktiska konverteringsargumentet. Detta värde är begränsat till intervallet 0 till 999.

Typ-fält

b:

Konverterar en Boolean-parameter till "TRUE" eller "NIL".

i:

Konverterar ett heltalsvärde till en numerisk decimalnotation med tecken.

o:

Konverterar ett heltalsvärde till en oktal notation utan tecken.

x:

Konverterar ett heltalsvärde till en hexadecimal notation utan tecken med användning av gemener `abcdef'.

X:

Konverterar ett heltalsvärde till en hexadecimal notation utan tecken med användning av versaler `ABCDEF'.

e:

Konverterar ett reellt tal med formatet [-]d.ddde+dd. Exakt en siffra är före decimalpunkten, följt av ett `e', följt av en exponent. Antalet siffror efter decimalpunkten bestäms av precision-fältet, eller är 2 om precision inte är specificerat. Decimalpunkten visas inte om precision är 0.

f:

Konverterar ett reellt värde med formatet [-]ddd.ddd. Antalet siffror efter decimalpunkten bestäms av precision-fältet, eller är 2 om precision inte är specificerat. Decimalpunkten visas inte om precision är 0.

g:

Konverterar ett reellt värde med stil `e' eller `f' beroende på antalet siffror för att representera värdet. Om precisionen inte är specificerad används 15 signifikanta siffror. Avslutande nollor förutom en enda nolla efter decimalpunkten tas bort.

s:

Skriver ett strängvärde tills antingen strängens slut nås eller antalet skrivna tecken är lika med precision-fältet.

d:

Konverterar ett datumvärde.

t:

Konverterar ett tidsvärde.

%:

Tecknet `%' skrivs, och inget argument konverteras.

SPRINTF returnerar den formaterade strängen eller NIL om fmt är NIL.

Exempel

Anrop                    Resultat

(SPRINTF "Hello")                "Hello"
(SPRINTF "%s" "Hello")           "Hello"
(SPRINTF "%10s" "Hello")         "     Hello"
(SPRINTF "%-10.10s" "Hello")     "Hello     "
(SPRINTF "%010.3s" "Hello")      "       Hel"
(SPRINTF "%-5.3b" TRUE)          "TRU  "
(SPRINTF "%i" 3)                 "3"
(SPRINTF "%03i" 3)               "003"
(SPRINTF "%0- 5.3i" 3)           " 3   "
(SPRINTF "%f" 12)                "12.00"
(SPRINTF "%10e" 12.0)            "  1.20e+01"
(SPRINTF "%+-10.4f" 12.0)        "+12.0000  "
(SPRINTF "%10.5t" 12:30:00)      "     12:30"
(SPRINTF "%d" 28.11.1968)        "28.11.1968"
(SPRINTF "He%s %5.5s!"
   "llo"
   "world champion ship")        "Hello world!"

Se även PRINTF, FPRINTF, STR, +, CONCAT, CONCAT2, COPYSTR.

16.13 Memo-funktioner

Detta avsnitt behandlar funktioner som är användbara för memon.

16.13.1 LINE

LINE extraherar en rad i ett memo.

(LINE memo num)

Returnerar den num-te raden (börjar med noll) i det givna memot. Raden kommer inte att ha ett avslutande nyradstecken. Om memo eller num är NIL eller om num är utanför intervallet, det vill säga, mindre än noll eller större än eller lika med antalet rader, då returneras NIL.

Se även LINES, MEMOHEAD, MEMOTAIL, WORD.

16.13.2 LINES

LINES returnerar antalet rader i ett memo.

(LINES memo)

Returnerar antalet rader i det givna memot eller NIL om memo är NIL.

Se även LINE, WORDS, LEN.

16.13.3 MEMOHEAD

MEMOHEAD returnerar de första n raderna i ett memo.

(MEMOHEAD memo nth)

Extraherar de första n raderna i ett memo. Om memo eller nth är NIL eller nth är mindre än noll returneras NIL. Om nth är noll returneras ett tomt memo. Om memo innehåller färre än nth rader returneras memo.

Exempel

`(MEMOHEAD "The golden\nlight of dawn\nspilled through the window" 2)' resulterar i "The golden\nlight of dawn".

Se även MEMOTAIL, LINE, LEFTSTR.

16.13.4 MEMOTAIL

MEMOTAIL returnerar de sista n raderna i ett memo.

(MEMOTAIL memo nth)

Extraherar de sista n raderna i ett memo. Om memo eller nth är NIL eller nth är mindre än noll returneras NIL. Om nth är noll returneras ett tomt memo. Om memo innehåller färre än nth rader returneras memo.

Exempel

`(MEMOTAIL "The golden\nlight of dawn\nspilled through the window" 2)' resulterar i "light of dawn\nspilled through the window".

Se även MEMOHEAD, LINE, RIGHTSTR.

16.13.5 MEMOTOLIST

MEMOTOLIST konverterar ett memo till en lista av strängar.

(MEMOTOLIST memo [expandstr])

Konverterar det givna memot till en lista. Om memo är NIL då returneras NIL, annars genereras en lista där varje element innehåller en rad i memot.

Om expandstr anges och inte är NIL bearbetas den resulterande listan av strängar ytterligare genom att tillämpa STRTOLIST på varje listelement. Detta resulterar i en lista av listor av strängar.

Exempel

`(MEMOTOLIST "My insurance\npays for\nthe wrecked bike.")' resulterar i ( "My insurance" "pays for" "the wrecked bike." ).

`(MEMOTOLIST "Here is\ta multi-columned\nexample." TRUE)' resulterar i ( ( "Here is" "a multi-columned" ) ( "example" ) ).

Se även STRTOLIST, LISTTOMEMO.

16.13.6 LISTTOMEMO

LISTTOMEMO konverterar en lista till ett memo.

(LISTTOMEMO list)

Konverterar den givna listan till ett memo. Om list är NIL då returneras NIL, annars genereras ett memo där varje rad består av strängrepresentationen av motsvarande listelement. Om ett listelement är en dellista tillämpas LISTTOSTR (se LISTTOSTR) på det innan den resulterande strängen integreras i memot.

Exempel

`(LISTTOMEMO (LIST "Silke" "lends me" "'my' bike" "till" 01.09.1998)' resulterar i: "Silke\nlends me\n'my' bike\ntill\n01.09.1998".

`(LISTTOMEMO (LIST (LIST "Name" "Birthday") (LIST "Steffen" 28.11.1968)' resulterar i: "Name\tBirthday\nSteffen\t28.11.1968".

Se även LISTTOSTR, MEMOTOLIST.

16.13.7 FILLMEMO

FILLMEMO fyller i ett memo med resultaten av uttryck.

(FILLMEMO memo)

Skapar en kopia av det givna memot där alla delsträngar på formen `$(uttryck)' ersätts av sina resultat efter utvärdering.

Exempel: `(FILLMEMO "(+ 1 1) is $(+ 1 1).")' resulterar i "(+ 1 1) is 2."

Använd endast små uttryck i memot eftersom felsökning och spårning av fel inte är lätt här.

Se även FORMATMEMO, INDENTMEMO.

16.13.8 FORMATMEMO

FORMATMEMO formaterar ett memo.

(FORMATMEMO memo width [fill [singlelinesec]])

Formaterar memo till ett memo med rader som inte är längre än width tecken. Om fill anges och är icke-NIL används mellanslag för att fylla ut raderna till exakt width tecken. Memot bearbetas sektionsvis. En sektion börjar vid det första icke-blanktecknet. Om singlelinesec anges och är icke-NIL tas alla tecken fram till slutet av denna rad som sektionen. Annars räknas alla tecken på denna och följande rader som sektionen tills en rad som börjar med ett blanktecken nås. Hela sektionen formateras ordvis, det vill säga, så många ord som får plats läggs på en rad. Återstående ord läggs sedan på nästa rad och så vidare.

Se även FILLMEMO, INDENTMEMO.

16.13.9 INDENTMEMO

INDENTMEMO indenterar ett memo genom att lägga till mellanslag till vänster.

(INDENTMEMO memo indent)

Returnerar en kopia av det givna memot där varje rad är indenterad med indent mellanslag. Om memo eller indent är NIL returneras NIL. Om indent är negativ används värdet 0.

Se även FILLMEMO, FORMATMEMO.

16.14 Date and Time Functions

Detta avsnitt behandlar funktioner för datum- och tidsvärden.

16.14.1 DAY

DAY extraherar dagfältet från ett datum.

(DAY date)

Returnerar ett heltal som representerar dagen i det givna datumvärdet. Om date är NIL returneras NIL.

Se även MONTH, YEAR, DATEDMY.

16.14.2 MONTH

MONTH extraherar månadsfältet från ett datum.

(MONTH date)

Returnerar ett heltal som representerar månaden i det givna datumvärdet. Om date är NIL returneras NIL.

Se även DAY, YEAR, DATEDMY, MONTHDAYS.

16.14.3 YEAR

YEAR extraherar årsfältet från ett datum.

(YEAR date)

Returnerar ett heltal som representerar året i det givna datumvärdet. Om date är NIL returneras NIL.

Se även DAY, MONTH, DATEDMY, YEARDAYS.

16.14.4 DATEDMY

DATEDMY skapar ett datumvärde från dag, månad och år.

(DATEDMY day month year)

Skapar ett datumvärde från de angivna dag-, månads- och årsvärdena. Om någon av day, month eller year är NIL eller utanför det giltiga intervallet, eller om det resulterande datumet är ogiltigt, returneras NIL.

Exempel: `(DATEDMY 28 11 1968)' resulterar i den 28:e november 1968.

Se även DATE, TODAY, DAY, MONTH, YEAR.

16.14.5 MONTHDAYS

MONTHDAYS ger antalet dagar i en månad.

(MONTHDAYS month year)

Returnerar antalet dagar i den angivna månaden och året som ett heltal. Om month är NIL eller utanför det giltiga intervallet (mindre än 1 eller större än 12) returneras NIL. Om year är NIL så antas ett icke-skottår för beräkningen av antalet dagar. Om year är ogiltigt (mindre än 0 eller större än 9999) returneras NIL.

Exempel: `(MONTHDAYS 2 2004)' resulterar i 29, `(MONTHDAYS 2 NIL)' resulterar i 28.

Se även YEARDAYS, MONTH.

16.14.6 YEARDAYS

YEARDAYS ger antalet dagar i ett år.

(YEARDAYS year)

Returnerar antalet dagar i det angivna året som ett heltal. Om year är NIL eller utanför det giltiga intervallet (mindre än 0 eller större än 9999) returneras NIL.

Exempel: `(YEARDAYS 2004)' resulterar i 366, `(YEARDAYS 2005)' resulterar i 365.

Se även MONTHDAYS, YEAR.

16.14.7 ADDMONTH

ADDMONTH lägger till ett antal månader till ett datum.

(ADDMONTH date months)

Returnerar ett datumvärde där det angivna antalet månader har lagts till det givna datumvärdet. Negativa värden för months subtraherar månader. Om date eller months är NIL, eller om det resulterande datumet är ogiltigt, returneras NIL.

ADDMONTH hanterar över- och underflöde av månadsfältet genom att justera årsfältet därefter. Om dagfältet överstiger maximalt antal dagar i den resulterande månaden, minskas det till den högsta tillåtna dagen.

Exempel: `(ADDMONTH 30.01.2004 1)' resulterar i 29.02.2004, `(ADDMONTH 30.01.2004 -1)' resulterar i 30.12.2003.

Se även ADDYEAR, +.

16.14.8 ADDYEAR

ADDYEAR lägger till ett antal år till ett datum.

(ADDYEAR date years)

Returnerar ett datumvärde där det angivna antalet år har lagts till det givna datumvärdet. Negativa värden för years subtraherar år. Om date eller years är NIL, eller om det resulterande datumet är ogiltigt, returneras NIL.

ADDYEAR minskar dagfältet med 1 om date representerar den 29:e februari och det resulterande året inte är ett skottår.

Exempel: `(ADDYEAR 29.02.2004 1)' resulterar i 28.02.2005, `(ADDMONTH 04.02.2004 -1962)' resulterar i 04.02.0042.

Se även ADDMONTH, +.

16.14.9 TODAY

TODAY returnerar aktuellt datum.

(TODAY)

Returnerar aktuellt datum som ett datumvärde.

Se även NOW, DATEDMY.

16.14.10 NOW

NOW returnerar aktuell tid.

(NOW)

Returnerar aktuell tid som ett tidsvärde.

Se även TODAY.

16.15 List Functions

Detta avsnitt listar funktioner för att bearbeta listor.

16.15.1 CONS

CONS bygger ett par av uttryck.

(CONS elem list)

Konstruerar en ny lista. Det första elementet i den nya listan är elem, resten är elementen i list (som bör vara en lista eller NIL). Listan list kopieras inte, endast en pekare används för att referera till den!

Exempel: `(CONS 1 (CONS 2 NIL))' resulterar i ( 1 2 ).

Elementen i en lista kan vara av vilken typ som helst, t.ex. är det också möjligt att ha en lista av listor (t.ex. se SELECT). Konstruktorn CONS kan också användas för att bygga par av element, t.ex. `(CONS 1 2)' är paret med de två heltalen 1 och 2.

Se även LIST, FIRST, REST.

16.15.2 LIST

LIST genererar en lista av sina argument.

(LIST [elem ...])

tar argumenten elem ... och genererar en lista av dem. Detta är ekvivalent med att anropa (CONS elem (CONS ... NIL)). Observera att NIL ensamt står för en tom lista.

Se även CONS, LENGTH.

16.15.3 LENGTH

LENGTH bestämmer längden på en lista.

(LENGTH list)

returnerar längden på den givna listan.

Exempel: `(LENGTH (LIST "a" 2 42 3))' resulterar i 4.

Se även LIST.

16.15.4 FIRST

FIRST extraherar det första elementet i en lista.

(FIRST list)

returnerar det första elementet i den givna listan. Om list är tom (NIL) returneras NIL.

Se även REST, LAST, NTH, CONS.

16.15.5 REST

REST returnerar dellistan efter det första elementet i en lista.

(REST list)

returnerar resten av den givna listan (listan utan det första elementet). Om list är tom (NIL) returneras NIL.

Exempel: `(REST (LIST 1 2 3))' resulterar i ( 2 3 ).

Se även FIRST, CONS.

16.15.6 LAST

LAST extraherar det sista elementet i en lista.

(LAST list)

Returnerar det sista elementet i den givna listan eller NIL om list är NIL.

Se även FIRST, NTH.

16.15.7 NTH

NTH extraherar det n:te elementet i en lista.

(NTH n list)

Returnerar det n:te elementet i den givna listan (börjar med 0) eller NIL om elementet inte existerar.

Se även FIRST, LAST, REPLACENTH.

16.15.8 REPLACENTH

REPLACENTH ersätter det n:te elementet i en lista.

(REPLACENTH n elem list)

Returnerar en ny lista där det n:te elementet i den givna listan (börjar med 0) har ersatts med elem.

Om n är NIL eller om det n:te elementet inte existerar, returneras NIL.

Se även NTH, REPLACENTH*, MOVENTH, REMOVENTH.

16.15.9 REPLACENTH*

REPLACENTH* är stjärnversionen av REPLACENTH. Den enda skillnaden mot REPLACENTH är att REPLACENTH* returnerar den ursprungliga listan om det n:te elementet inte existerar.

REPLACENTH* kan implementeras som

(DEFUN REPLACENTH* (n e l)
    (LET ((r (REPLACENTH n e l)))
        (IF r r l)
    )
)

Se även NTH, REPLACENTH, demo `FileList.bbs'.

16.15.10 MOVENTH

MOVENTH flyttar det n:te elementet i en lista till en ny position.

(MOVENTH n m list)

Returnerar en ny lista där det n:te elementet i den givna listan (börjar med 0) har flyttats till m:te positionen.

Om n eller m är NIL eller om det n:te eller m:te elementet inte existerar, returneras NIL.

Exempel: `(MOVENTH 0 1 (list 1 2 3))' resulterar i ( 2 1 3 ).

Se även NTH, MOVENTH*, REPLACENTH, REMOVENTH.

16.15.11 MOVENTH*

MOVENTH* är stjärnversionen av MOVENTH. Den enda skillnaden mot MOVENTH är att MOVENTH* returnerar den ursprungliga listan om det n:te eller m:te elementet inte existerar.

MOVENTH* kan implementeras som

(DEFUN MOVENTH* (n m l)
    (LET ((r (MOVENTH n m l)))
        (IF r r l)
    )
)

Se även NTH, MOVENTH, demo `FileList.bbs'.

16.15.12 REMOVENTH

REMOVENTH tar bort det n:te elementet i en lista.

(REMOVENTH n list)

Returnerar en ny lista där det n:te elementet i den givna listan (börjar med 0) har tagits bort.

Om n är NIL eller om det n:te elementet inte existerar, returneras NIL.

Exempel: `(REMOVENTH 1 (list 1 2 3))' resulterar i ( 1 3 ).

Se även NTH, REMOVENTH*, REPLACENTH, MOVENTH.

16.15.13 REMOVENTH*

REMOVENTH* är stjärnversionen av REMOVENTH. Den enda skillnaden mot REMOVENTH är att REMOVENTH* returnerar den ursprungliga listan om det n:te elementet inte existerar.

REMOVENTH* kan implementeras som

(DEFUN REMOVENTH* (n l)
    (LET ((r (REMOVENTH n l)))
        (IF r r l)
    )
)

Se även NTH, REMOVENTH, demo `FileList.bbs'.

16.15.14 APPEND

APPEND sammanfogar listor.

(APPEND [list ...])

returnerar sammanslagningen av list ....

Exempel: `(APPEND (list 1 2) (list 3 4) (list 5))' resulterar i ( 1 2 3 4 5 ).

Se även LIST.

16.15.15 REVERSE

REVERSE vänder en lista.

(REVERSE list)

returnerar den omvända listan.

Exempel: `(REVERSE (list 1 2 3))' resulterar i ( 3 2 1 ).

16.15.16 MAPFIRST

MAPFIRST tillämpar en funktion på alla listelement.

(MAPFIRST func list [...])

Bygger en lista vars element är resultatet av den angivna funktionen anropad med argumenten från de givna listelementen en efter en. Längden på den returnerade listan är lika lång som längden på den längsta angivna listan. Om en av de angivna listorna är för kort fylls listan ut med NIL-element.

Exempel

Uttryck                                    Värde

(MAPFIRST 1+ (LIST 1 2 3))             ( 2 3 4 )
(MAPFIRST + (LIST 1 2 3) (LIST 2 3))   ( 3 5 NIL )

16.15.17 SORTLIST

SORTLIST sorterar elementen i en lista.

(SORTLIST func list)

Returnerar en kopia av den angivna listan som har sorterats med hjälp av funktionen func för ordning. Ordningsfunktionen måste ta två argument, ett för varje element, och returnera ett heltalsvärde mindre än noll om det första elementet är mindre än det andra, ett värde större än noll om det första elementet är större än det andra, och ett värde på noll om de två elementen är lika.

Exempel på en strängsjämförande funktion som kan användas för sortering:

(DEFUN cmp_str (x y)
    (COND
        ((< x y) -1)
        ((> x y) 1)
        (TRUE 0)
    )
)

Nu kan du sortera en lista genom att anropa:

(SORTLIST cmp_str (LIST "hi" "fine" "great" "ok"))

vilket resulterar i ( "fine" "great" "hi" "ok" ).

Se även SORTLISTGT, MAPFIRST.

16.15.18 SORTLISTGT

SORTLIST sorterar elementen i en lista.

(SORTLISTGT gtfunc list)

Som SORTLIST men här anger du en ordningsfunktion som returnerar ett värde inte lika med NIL om det första elementet är större än det andra, och NIL annars.

Exempel: `(SORTLISTGT > (LIST "hi" "fine" "great" "ok"))' resulterar i ( "fine" "great" "hi" "ok" ).

Se även SORTLIST, MAPFIRST.

16.16 Input Requesting Functions

För att begära information från användaren kan följande funktioner användas.

16.16.1 ASKFILE

ASKFILE uppmanar användaren att ange ett filnamn.

(ASKFILE title oktext default savemode)

Visar en fildialogruta för att ange ett filnamn. Fönsterrubriken kan anges i title, texten på knappen `Ok' i oktext, och det initiala filnamnet i default. Du kan ange NIL för någon av dessa för att använda standardvärden. Det sista argumentet savemode (Boolean) låter dig ställa in fildialogrutan till sparläge. Detta läge bör användas när man frågar efter ett filnamn för att skriva något till.

ASKFILE returnerar det angivna filnamnet som en sträng eller NIL om användaren avbröt dialogen.

Se även ASKDIR, ASKSTR.

16.16.2 ASKDIR

ASKDIR uppmanar användaren att ange ett katalognamn.

(ASKDIR title oktext default savemode)

Visar en fildialogruta för att ange ett katalognamn. Argumenten används på samma sätt som i ASKFILE (se ASKFILE).

ASKDIR returnerar det angivna katalognamnet som en sträng eller NIL om användaren avbröt dialogen.

Se även ASKFILE, ASKSTR.

16.16.3 ASKSTR

ASKSTR uppmanar användaren att ange en sträng.

(ASKSTR title oktext default maxlen [secret])

Visar en dialogruta som ber om en sträng att ange. Fönsterrubriken, texten på knappen `Ok', och det initiala värdet kan anges i title, oktext, och default respektive (strängar eller NIL för standardvärden), maxlen bestämmer det maximala antalet tecken användaren kan ange. Om secret anges och inte är NIL görs den angivna strängen osynlig genom att visa en punktsymbol för varje strängtecken.

ASKSTR returnerar den angivna strängen eller NIL om användaren avbröt.

Se även ASKFILE, ASKDIR, ASKCHOICESTR, ASKINT.

16.16.4 ASKINT

ASKINT uppmanar användaren att ange ett heltalsvärde.

(ASKINT title oktext default min max)

Visar en dialogruta som ber om ett heltal att ange. Fönsterrubriken och texten på knappen `Ok' kan anges i title och oktext (strängar eller NIL för standardvärden). I default anger du det initiala heltalsvärdet eller NIL för att börja med ett tomt redigeringsfält. I min och max kan du ställa in heltalsintervallet. Angivna värden utanför detta intervall accepteras inte av dialogrutan. Använd NIL för standard min- och maxvärden.

ASKINT returnerar det angivna heltalet eller NIL om användaren avbröt dialogen.

Se även ASKSTR.

16.16.5 ASKCHOICE

ASKCHOICE uppmanar användaren att välja ett objekt bland många alternativ.

(ASKCHOICE title oktext choices default [titles])

Visar en dialogruta som låter användaren välja ett objekt från en lista med alternativ. Du kan ange fönsterrubriken och texten på knappen `Ok' i title och oktext (strängar eller NIL för standardvärden). I choices anger du en lista med valmöjligheter. Du kan använda ett flerkolumnsformat genom att tillhandahålla varje valalternativ som en lista med underobjekt. Det initiala valvärdet kan anges i default och är indexet i listan med val (börjar med index 0 för det första objektet). Använd NIL för inget initialt val. Om det valfria argumentet titles anges och inte är NIL, visas en listhuvud som innehåller titles. För att använda ett flerkolumnsformat, ange titles som en lista med kolumntitlar.

Både choices och titles kan också anges som ett memo och en sträng (istället för listor). Om så är fallet konverteras de till listor automatiskt genom anrop till (MEMOTOLIST choices TRUE) (se MEMOTOLIST) och (STRTOLIST titles) (se STRTOLIST) respektive.

ASKCHOICE returnerar indexet för det valda objektet eller NIL om användaren avbröt dialogen.

Exempel

(LET ((items (LIST "First Entry" 2 3.14 "Last entry")) index)
    (SETQ index (ASKCHOICE "Choose one item" "Ok" items NIL))
    (IF index
        (PRINTF "User chose item num %i with contents <%s>\n"
            index (STR (NTH index items))
        )
    )
)

Anta fallet där du vill be användaren att välja en viss post i en tabell. Tabellen ska kallas `Article' med fält `Name', `Number' och `Prize'. Följande kodfragment visar hur man använder ASKCHOICE för att be om att välja en post med Prize större än 10 och sorterad efter Name:

(LET ((query (SELECT Article, Name, Number, Prize from Article 
	      WHERE (> Prize 10) ORDER BY Name))
     (recs (MAPFIRST FIRST (REST query)))	; postpekare
     (items (MAPFIRST REST (REST query)))	; valmöjligheter
     (titles (REST (FIRST query)))		; titlar
     (index (ASKCHOICE "Choose" "Ok" items NIL titles))
     (rec (NTH index recs)))
     ; nu innehåller rec den valda posten (eller NIL vid avbrott)
)

Se även ASKCHOICESTR, ASKOPTIONS.

16.16.6 ASKCHOICESTR

ASKCHOICESTR uppmanar användaren att ange ett strängvärde och erbjuder flera fördefinierade alternativ.

(ASKCHOICESTR title oktext strings default [titles])

Visar en dialogruta som låter användaren välja en sträng bland många strängar eller ange en annan valfri sträng i ett separat strängfält. Du kan ange fönsterrubriken och texten på knappen `Ok' i title och oktext (strängar eller NIL för standardvärden). I strings anger du en lista med valmöjligheter. Du kan använda ett flerkolumnsformat genom att tillhandahålla varje valalternativ som en lista med underobjekt. Det initiala värdet för strängfältet kan anges i default (sträng eller NIL för ett tomt strängfält). Om det valfria argumentet titles anges och inte är NIL, visas en listhuvud som innehåller titles. För att använda ett flerkolumnsformat, ange titles som en lista med kolumntitlar.

Både strings och titles kan också anges som ett memo och en sträng (istället för listor). Om så är fallet konverteras de till listor automatiskt genom anrop till (MEMOTOLIST strings TRUE) (se MEMOTOLIST) och (STRTOLIST titles) (se STRTOLIST) respektive.

ASKCHOICESTR returnerar den valda strängen eller NIL om användaren avbröt dialogen.

Exempel

(LET ((strings (LIST "Claudia" "Mats" "Ralphie")) likebest)
    (SETQ likebest
        (ASKCHOICESTR "Who do you like the best?" "Ok" strings 
	    "My collies!"
	)
    )
    (IF likebest (PRINTF "User chose <%s>\n" likebest))
)

Se även ASKCHOICE, ASKOPTIONS.

16.16.7 ASKOPTIONS

ASKOPTIONS uppmanar användaren att välja flera objekt från en lista med alternativ.

(ASKOPTIONS title oktext options selected [titles])

Visar en dialogruta som låter användaren välja flera alternativ från en lista med alternativ. Du kan ange fönsterrubriken och texten på knappen `Ok' i title och oktext (strängar eller NIL för standardvärden). I options anger du en lista med alternativ. Du kan använda ett flerkolumnsformat genom att tillhandahålla varje alternativ som en lista med underobjekt. Det initiala urvalstillståndet kan anges i selected som en lista med heltal där varje tal anger ett index vars motsvarande objekt i options initialt ska vara markerat. Använd NIL för att alla objekt ska vara omarkerade. Om det valfria argumentet titles anges och inte är NIL, visas en listhuvud som innehåller titles. För att använda ett flerkolumnsformat, ange titles som en lista med kolumntitlar.

Både options och titles kan också anges som ett memo och en sträng (istället för listor). Om så är fallet konverteras de till listor automatiskt genom anrop till (MEMOTOLIST options TRUE) (se MEMOTOLIST) och (STRTOLIST titles) (se STRTOLIST) respektive.

ASKOPTIONS returnerar en lista med heltal där varje tal anger indexet för ett valt objekt, eller NIL om användaren avbröt eller inte valde något objekt.

Exempel

(LET ((options (LIST "Salva Mea" "Insomnia" "Don't leave" "7 days & 1 week"))
        (selected (LIST 0 1 3))
    )
    (SETQ selected (ASKOPTIONS "Select music titles" "Ok" options selected))
    (IF selected
        (
            (PRINTF "User has selected the following items:\n")
            (DOLIST (i selected)
                (PRINTF "\tnum: %i contents: <%s>\n" i (STR (NTH i options)))
            )
        )
    )
)

16.16.8 ASKBUTTON

ASKBUTTON uppmanar användaren att trycka på en knapp.

(ASKBUTTON title text buttons canceltext)

Visar en dialogruta med den angivna fönsterrubriken (sträng eller NIL för en standardrubrik) och angiven beskrivningstext (sträng eller NIL för ingen text). Funktionen väntar tills användaren trycker på en av knapparna som anges i buttons (lista med strängar) eller knappen `Cancel'. Texten på avbrytknappen kan anges i canceltext. Om du anger NIL här används en standardtext baserad på antalet knappar du har angett.

ASKBUTTON returnerar numret på den knapp som trycktes (börjar med 0 för den första (vänstra) knappen) eller NIL om användaren tryckte på knappen `Cancel'.

Exempel

(LET ((buttons (LIST "At home" "In bed" "In front of my computer")) index)
    (SETQ index (ASKBUTTON "Please answer:"
        "Where do you want to be tomorrow?" buttons "Don't know")
    )
    (IF index
        (PRINTF "User chose: <%s>\n" (NTH index buttons))
    )
)

(ASKBUTTON "Info" "BeeBase is great!" NIL NIL)

Se även ASKCHOICE.

16.16.9 ASKMULTI

ASKMULTI uppmanar användaren att ange olika typer av information.

(ASKMULTI title oktext itemlist)

ASKMULTI är en dialogruta för flera syften. Den öppnar ett fönster med den angivna rubriken, en uppsättning GUI-objekt för att redigera data, och två knappar (`Ok' och `Cancel') för att avsluta dialogen. Texten på knappen `Ok' kan anges i oktext (sträng eller NIL för standardtext). Uppsättningen GUI-objekt anges i itemlist som är en lista av objekt där varje objekt har en av följande former:

    (LIST title "String" initial [help [secret]])  för att redigera en textrad,
    (LIST title "Memo" initial [help])     för att redigera flerradig text,
    (LIST title "Integer" initial [help])  för att redigera ett heltal,
    (LIST title "Real" initial [help])     för att redigera ett reellt tal,
    (LIST title "Date" initial [help])     för att redigera ett datum,
    (LIST title "Time" initial [help])     för att redigera en tid,
    (LIST title "Bool" initial [help])     för ett Booleanskt fält,
    (LIST title "Choice" initial
        (LIST choice ...) [help]
    )                                      för ett valfält.
    (LIST title "ChoiceList" initial
        (LIST choice ...) [help]
    )                                      för att välja ett objekt i en lista.
    (LIST title "Options" initial
        (LIST option ...) [help]
    )                                      för att välja flera objekt i en lista.
    non-list-expr                          för statisk text

Titeln (sträng eller NIL för ingen titel) kommer att visas till vänster om GUI-objektet. Om det initiala värdet är NIL används ett standardvärde (t.ex. ett tomt textfält). För valfält måste det initiala värdet vara indexet (börjar med 0) för den initialt aktiva posten, för vallistefält kan det initiala värdet vara NIL (inget objekt är aktiverat), och för alternativfält måste det initiala värdet vara en lista med heltal som representerar indexen (börjar med 0) för de objekt som är initialt valda. Det valfria hjälpfältet (sträng) kan användas för att ge mer information till användaren om användningen av fältet. För strängfält kan en ytterligare parameter `secret' anges. Om den inte är NIL görs innehållet i strängfältet osynligt genom att visa en punktsymbol för varje strängtecken.

ASKMULTI returnerar en lista med resultatvärden som användaren har redigerat och bekräftat genom att trycka på knappen `Ok'. Varje resultatvärde för ett fält har samma format som den för det initiala värdet, t.ex. för ett vallistefält är resultatvärdet indexet för det valda objektet (eller NIL om inget objekt har valts), eller för ett alternativfält är resultatvärdet en lista med heltal som representerar indexen för de valda objekten. För statisk text returneras ett värde av NIL.

T.ex. om du har angett ett datumfält, ett statiskt textfält, ett val- fält, ett alternativfält och ett strängfält med initialvärdet "world", och användaren har angett 11.11.1999, valt valalternativet med indexnummer 2, valt 3:e och 4:e objektet i alternativfältet, och lämnat strängfältet orört, då returnerar funktionen listan ( 11.11.1999 NIL 2 ( 3 4 ) "world" ).

Om användaren avbryter dialogen returneras NIL.

Exempel

(ASKMULTI "Please edit:" NIL (LIST
    (LIST "N_ame" "String" "")
    (LIST "_Birthday" "Date" NIL)
    (LIST "_Sex" "Choice" 0 (LIST "male" "female"))
    (LIST "_Has car?" "Bool" NIL)
    (LIST "_Likes" "Options" (LIST 0 2)
        (LIST "Beer" "Wine" "Whisky" "Wodka" "Schnaps")
    ))
)

Se även projektet `AskDemo.bbs' för fler exempel.

16.17 I/O Functions

Detta avsnitt listar funktioner och variabler för in- och utmatning (t.ex. utskrift) av data.

16.17.1 FOPEN

FOPEN öppnar en fil för läsning/skrivning.

(FOPEN filename mode [encoding])

Öppnar filen som anges av filename (sträng). Parametern mode (sträng) styr åtkomstläget. Använd `"w"' för att öppna en fil för skrivning, `"a"' för att lägga till i en fil, och `"r"' för att läsa från en fil. Du kan också använda andra flaggor (eller kombination av flaggor) som `"r+"' för läsning och skrivning. Det finns ingen kontroll som testar om du har angett en giltig flaggsträng. Om filen inte kan öppnas returneras dock NIL.

Den valfria parametern encoding styr kodningen av filen och är en av följande strängar:

`"none"':

Ingen tolkning av tecken utförs. Använd detta för binära filer.

`"UTF-8"':

Text är kodad i UTF-8. Läsning och skrivning konverterar från/till UTF-8.

`"locale"':

Text är kodad i din systemlokal. På Windows är detta systemets codepage. På Mac OS och Linux är det inställningen av LANG och LC_* miljövariabler, se man locale. På Amiga är det standard 8-bitars kodning.

`"8-bit"':

Text är kodad i standard 8-bitars teckenuppsättning. På Windows, Mac OS och Linux är detta ISO-8859-1 (latin 1) kodning. På Amiga är det systemets standard 8-bitars kodning (samma som `locale').

`"auto"':

Kodningen detekteras automatiskt. Om filen är läsbar bestäms kodningen enligt följande: Om allt innehåll följer UTF-8 antas `"UTF-8"'. Annars om systemets lokala inställning inte är UTF-8 antas `"locale"'. Annars antas `"8-bit"'. Vid skrivning, om kodningen ännu inte har bestämts, provas först systemets lokala kodning. Om det inte fanns några konverteringsfel används `"locale"', annars används `"UTF-8"'.

Om ingen encoding-parameter anges används `"auto"'.

FOPEN returnerar ett filhandtag vid lyckad öppning. Vid misslyckande returneras NIL. Om filename, mode eller encoding är NIL returneras NIL.

Exempel

`(FOPEN "index.html" "w" "utf-8")' öppnar och returnerar ett filhandtag för att skriva till filen `index.html' och kodar den i UTF-8.

`(FOPEN "output.txt" "a+")' öppnar filen `output.txt' för att lägga till använder samma textkodning som redan finns i filen. Observera att om du endast anger `"a"' som läge kan BeeBase kanske inte läsa filen och avgöra den befintliga kodningen. I detta fall bestäms kodningen när du skriver till filen (och kan vara annorlunda än den befintliga).

Se även FCLOSE, stdout, FFLUSH.

16.17.2 FCLOSE

FCLOSE stänger en fil.

(FCLOSE file)

Stänger den angivna filen. Returnerar 0 vid lyckad stängning, NIL om ett fel har inträffat. Om file är NIL returneras 0 (inget fel). Efter att en fil har stängts är åtkomst till filhandtaget en ogiltig operation och resulterar i att programkörningen avbryts med ett felmeddelande.

Se även FOPEN, FFLUSH.

16.17.3 stdout

Den globala variabeln stdout innehåller filhandtaget till BeeBase standardutmatningsfil. Utmatningsfilnamnet kan ställas in i menyposten `Program - Output file' (se Program output file).

Utmatningsfilen öppnas vid den första åtkomsten av denna variabel (t.ex. när du anropar `(FPRINTF stdout ...)', eller när du anropar `(PRINTF ...)'). Filen öppnas inte i förväg när programmet körs. Detta undviker att öppna filen när ingen utmatning genereras, t.ex. när du helt enkelt vill göra några beräkningar och ändra vissa postinnehåll.

Vid öppning av utmatningsfilen är lägesparametern antingen `"w"' eller `"a+"' beroende på inställningen `Append' i menyalternativet `Program - Output file'. Kodningen är inställd på `"auto"'.

Om BeeBase inte kan öppna programutmatningsfilen avbryts körningen och ett felmeddelande genereras.

Se även FOPEN, PRINTF.

16.17.4 PRINT

PRINT konverterar ett uttryck till en sträng och skriver ut det.

(PRINT elem)

Konverterar värdet av elem till en läsbar sträng och skriver ut den till stdout. Denna funktion finns huvudsakligen för felsökningsändamål och anses inte ha en sidoeffekt så att den kan användas t.ex. i en jämförelsefunktion.

Se även PRINTF, stdout, Comparison function.

16.17.5 PRINTF

PRINTF skriver ut en formaterad sträng.

(PRINTF format [expr ...])

Formaterar en sträng med hjälp av den angivna formatsträngen och argumenten och skriver ut den till stdout. Formatering görs som i SPRINTF (se SPRINTF).

PRINTF returnerar antalet utmatade tecken eller NIL vid misslyckande. Om format är NIL returneras NIL.

Denna funktion anses inte ha en sidoeffekt så att den kan användas t.ex. för att felsöka en jämförelsefunktion.

Exempel: `(PRINTF "%i days and %i week" 7 1)' skriver ut strängen "7 days and 1 week" till stdout och returnerar 17.

Se även PRINT, FPRINTF, stdout, Comparison function.

16.17.6 FPRINTF

FPRINTF skriver ut en formaterad sträng till en fil.

(FPRINTF file format [expr ...])

Formaterar en sträng med hjälp av den angivna formatsträngen och argumenten och skriver ut den till den angivna filen. Formatering görs som i SPRINTF (se SPRINTF).

FPRINTF returnerar antalet utmatade tecken eller NIL vid misslyckande. Om file är NIL returnerar FPRINTF fortfarande antalet potentiellt skrivna tecken men ingen utmatning skrivs faktiskt. Om format är NIL returneras NIL.

Se även PRINTF, FOPEN.

16.17.7 FERROR

FERROR kontrollerar om ett fil-I/O-fel har inträffat.

(FERROR file)

returnerar TRUE om ett fel för den angivna filen har inträffat, NIL annars. Om `file' är NIL returneras NIL.

Se även FEOF, FOPEN, FCLOSE.

16.17.8 FEOF

FEOF kontrollerar filslutsstatus.

(FEOF file)

Testar filslutindikatorn för den givna filen och returnerar TRUE om den är satt. Annars returneras NIL. Om `file' är NIL returneras NIL.

Se även FERROR, FTELL, FOPEN, FCLOSE.

16.17.9 FSEEK

FSEEK ställer in läs-/skrivpositionen i en fil.

(FSEEK file offset whence)

Ställer in läs-/skrivpositionen för den angivna filen. Den nya positionen, mätt i byte, erhålls genom att lägga till offset byte till positionen som anges av whence. Om whence är inställd på SEEK_SET, SEEK_CUR eller SEEK_END, är offset relativ till filens början, den aktuella positionen respektive filens slut.

Vid framgång returnerar FSEEK 0. Annars returneras NIL och filpositionen förblir oförändrad. Om file, offset eller whence är NIL, eller om whence inte är något av konstantvärdena SEEK_SET, SEEK_CUR eller SEEK_END returneras NIL.

Observera att efter en läsoperation stöds anrop till FSEEK med whence som SEEK_CUR endast för kodning `"none"'.

Se även FTELL, FOPEN, Pre-defined constants.

16.17.10 FTELL

FTELL returnerar läs-/skrivpositionen för en fil.

(FTELL file)

Bestämmer den aktuella läs-/skrivpositionen för den angivna filen i förhållande till filens början och returnerar den som ett heltal. Om ett fel inträffar eller om `file' är NIL, returneras NIL.

Observera att efter en läsoperation stöds anrop till FTELL endast för kodning `"none"'.

Se även FSEEK, FOPEN, FEOF.

16.17.11 FGETCHAR

FGETCHAR läser ett tecken från en fil.

(FGETCHAR file)

Returnerar nästa tecken från den angivna filen som en sträng eller NIL om file är NIL, filslut har nåtts, eller ett fel har inträffat. Om nästa tecken är ett nolltecken, returneras en tom sträng.

Se även FGETCHARS, FGETSTR, FPUTCHAR.

16.17.12 FGETCHARS

FGETCHARS läser tecken från en fil.

(FGETCHARS num file)

returnerar en sträng som innehåller de nästa num tecknen från den angivna filen. Om filslut har nåtts innan num tecken har lästs eller om ett nolltecken har lästs, returneras endast dessa tecken. Om num eller file är NIL, num är negativ, filslut har nåtts innan det första tecknet lästs, eller ett läsfel har inträffat, returneras NIL.

Se även FGETCHAR, FGETSTR.

16.17.13 FGETSTR

FGETSTR läser en sträng från en fil.

(FGETSTR file)

returnerar nästa rad från den angivna filen som en sträng eller NIL om file är NIL, filslut har nåtts, eller ett fel inträffade. Slutet på en rad upptäcks om antingen ett nyradstecken eller ett nolltecken läses, eller om filslut upptäcks. I båda fallen innehåller strängen inga nyradstecken.

Se även FGETCHAR, FGETCHARS, FGETMEMO, FPUTSTR.

16.17.14 FGETMEMO

FGETMEMO läser ett memo från en fil.

(FGETMEMO file)

returnerar ett memo som innehåller innehållet i den angivna filen upp till nästa nolltecken eller upp till filens slut. Om file är NIL, filslut har nåtts innan läsning av några tecken, eller ett fel inträffade, returneras NIL.

Se även FGETSTR, FPUTMEMO.

16.17.15 FPUTCHAR

FPUTCHAR skriver ett tecken till en fil.

(FPUTCHAR str file)

Skriver det första tecknet i str till den angivna filen. Om str är tom skrivs ett nolltecken, om str eller file är NIL händer ingenting. Returnerar str eller NIL om ett utmatningsfel inträffade.

Se även FPUTSTR, FGETCHAR.

16.17.16 FPUTSTR

FPUTSTR skriver en sträng till en fil.

(FPUTSTR str file)

Skriver ut str tillsammans med ett nyradstecken till den angivna filen. Om str eller file är NIL händer ingenting. Returnerar str eller NIL om ett utmatningsfel inträffade.

Se även FPUTCHAR, FPUTMEMO, FGETSTR.

16.17.17 FPUTMEMO

FPUTMEMO skriver ett memo till en fil.

(FPUTMEMO memo file)

Skriver ut memo till den angivna filen. Om memo eller file är NIL händer ingenting. Returnerar memo eller NIL om ett utmatningsfel inträffade.

Se även FPUTSTR, FGETMEMO.

16.17.18 FFLUSH

FFLUSH flushar väntande data till en fil.

(FFLUSH file)

Flushar all väntande utmatning för den angivna filen. Returnerar 0 vid framgång, NIL om ett fel inträffade. Om file är NIL returneras 0 (inget fel).

Se även FOPEN, FCLOSE.

16.18 Record Functions

Detta avsnitt listar funktioner som hanterar poster.

16.18.1 NEW

NEW allokerar en ny post för en tabell.

(NEW table init)

Allokerar en ny post i den angivna tabellen. Parametern init anger den post som ska användas för att initialisera den nya posten. Ett värde av NIL står för den initiala posten.

NEW returnerar en postpekare till den nya posten.

Funktionen NEW har sidoeffekten att den ställer in programpostpekaren för den angivna tabellen (se Tables) till den nya posten.

Exempel: `(NEW table NIL)' allokerar en ny post i den givna tabellen och initialiserar den med den initiala posten.

Se även NEW*, DELETE, Tables.

16.18.2 NEW*

NEW* är stjärnversionen av NEW (se NEW).

(NEW* table init)

NEW* kontrollerar om du har angett en `New' utlösarfunktion för den angivna tabellen (se New trigger). Om så är fallet anropas denna utlösarfunktion för att allokera posten och dess resultat returneras. Parametern init kan användas för att ange en post med vilken den nya posten ska initialiseras (använd NIL för den initiala posten).

Om ingen utlösarfunktion har angetts beter sig funktionen som funktionen NEW.

Varning: Med denna funktion är det möjligt att skriva oändliga loopar, t.ex. om du har definierat en `New' utlösarfunktion för en tabell och denna funktion anropar NEW* för att allokera posten.

Se även NEW, DELETE*.

16.18.3 DELETE

DELETE tar bort en post i en tabell.

(DELETE table confirm)

Tar bort den aktuella programposten i den angivna tabellen efter en valfri borttagningsbekräftelse. Det första argumentet anger tabellen för vilken den aktuella programposten ska tas bort, det andra argumentet är ett Booleskt uttryck. Om det är NIL tas posten bort tyst, om det inte är NIL kontrolleras inställningen i menyalternativet `Confirm delete record' i inställningsmenyn. Om det inte är satt tas posten bort tyst, annars visas standardborttagningsdialogen som ber om bekräftelse. Om användaren avbryter borttagningsoperationen kommer posten inte att tas bort.

Returkoden för funktionen DELETE återspeglar den valda åtgärden. Om den returnerar TRUE har posten tagits bort, annars (användaren har avbrutit operationen) returneras NIL.

Vid borttagning ställer DELETE in programpostpekaren (se Tables) för den angivna tabellen till NIL.

Exempel: `(DELETE table NIL)' tar bort den aktuella posten i den givna tabellen tyst.

Se även DELETE*, DELETEALL, NEW, Tables.

16.18.4 DELETE*

DELETE* är stjärnversionen av DELETE (se DELETE).

(DELETE* table confirm)

DELETE* kontrollerar om du har angett en `Delete' utlösarfunktion för den angivna tabellen (se Delete trigger). Om så är fallet anropas denna utlösarfunktion för att ta bort posten och dess resultat returneras. Parametern confirm kan användas för att ange om utlösarfunktionen ska visa en bekräftelsedialogruta innan posten tas bort.

Om ingen utlösarfunktion har angetts beter sig funktionen som funktionen DELETE.

Varning: Med denna funktion är det möjligt att skriva oändliga loopar, t.ex. om du har definierat en `Delete' utlösarfunktion för en tabell och denna funktion anropar DELETE* för att ta bort posten.

Se även DELETE, DELETEALL, NEW*.

16.18.5 DELETEALL

DELETEALL tar bort alla poster i en tabell.

(DELETEALL table[*])

Tar bort alla poster i den angivna tabellen. Om du lägger till en stjärna efter tabellnamnet tas endast de poster bort som matchar tabellens aktuella filter. Det finns ingen bekräftelsedialogruta innan posterna tas bort.

DELETEALL returnerar TRUE vid lyckad borttagning av alla poster, annars returneras NIL. Om table är NIL returneras NIL.

Exempel: `(DELETEALL table*)' tar bort alla poster i den givna tabellen som matchar tabellens filter.

Se även DELETE, Tables.

16.18.6 GETMATCHFILTER

GETMATCHFILTER returnerar match-filter-tillståndet för en post.

(GETMATCHFILTER rec)

Returnerar TRUE om den angivna posten matchar filtret för dess tabell, NIL annars. Om tabellens filter för närvarande inte är aktivt returneras TRUE. Om rec är NIL (den initiala posten) returneras NIL.

Se även SETMATCHFILTER, GETISSORTED, GETFILTERSTR, SETFILTERSTR.

16.18.7 SETMATCHFILTER

SETMATCHFILTER ställer in match-filter-tillståndet för en post.

(SETMATCHFILTER rec on)

Ändrar match-filter-tillståndet för den angivna posten till värdet av on. SETMATCHFILTER returnerar det nya match-filter-tillståndet för den givna posten. Det nya tillståndet kan vara annorlunda än det förväntade eftersom inställning av match-filter-tillståndet till NIL endast fungerar när filtret för motsvarande tabell för närvarande är aktivt, annars returneras TRUE. Anrop till SETMATCHFILTER med ett värde av NIL för rec (den initiala posten) kommer alltid att returnera NIL.

Se även GETMATCHFILTER, SETISSORTED, GETFILTERSTR, SETFILTERSTR.

16.18.8 GETISSORTED

GETISSORTED returnerar sorteringstillståndet för en post.

(GETISSORTED rec)

Returnerar TRUE om den angivna posten är sorterad i den ordning som har definierats för dess tabell, NIL annars. Om rec är NIL returneras NIL.

Se även SETISSORTED, GETMATCHFILTER, REORDER, GETORDERSTR, SETORDERSTR, Comparison function.

16.18.9 SETISSORTED

SETISSORTED ställer in sorteringstillståndet för en post.

(SETISSORTED rec on)

Ändrar sorteringstillståndet för den angivna posten till värdet av on. Använd denna funktion om du tror att en viss post är i rätt ordning (on = TRUE), eller att den bör omordnas (on = NIL). Omordning av alla osorterade poster kan göras genom att anropa funktionen REORDER (se REORDER).

SETISSORTED returnerar det nya sorteringstillståndet för den givna posten. Anrop till SETISSORTED med ett värde av NIL för rec (den initiala posten) kommer att returnera NIL.

För ett exempel på hur du använder denna funktion, se Comparison function.

Se även GETISSORTED, SETMATCHFILTER, REORDER, GETORDERSTR, SETORDERSTR, Comparison function.

16.18.10 GETREC

GETREC returnerar postreferensen för ett uttryck.

(GETREC expr)

Returnerar den post som har använts när expr skapades. Uttryck som skapas från ett fält i en tabell har den post de härrör från satt som denna postreferens.

Om expr är en lista och inte själv har en postreferens satt returnerar GETREC posten för det första elementet i listan som har en postreferens. GETREC undersöker dock inte dellistor.

Om ingen postreferens har hittats returnerar GETREC NIL.

Funktionen att undersöka element i en lista är praktisk vid inhämtning av postreferensen för en rad i en select-from-where-fråga. Till exempel returnerar följande kodfragment den post som har använts när man skapade den 7:e raden i en select-from-where-fråga:

(GETREC (NTH 7 (SELECT field FROM table)))

Denna funktion är användbar, t.ex. i en sort drop-utlösarfunktion för en virtuell lista, se Sort drop trigger.

Se även SETREC, RECORD, Sort drop trigger.

16.18.11 SETREC

SETREC ställer in postreferensen för ett uttryck.

(SETREC expr record)

Returnerar expr med en postreferens satt till record.

SETREC är användbar när ett uttryck ska kopplas till en viss post, t.ex. vid beräkning av information som härleds från ett fält i en tabell. Till exempel, i en tabell `Person' med ett Booleanskt fält `Female', kan en select-from-where-fråga mappa `Female' till strängarna "F" och "M":

SELECT (SETREC (IF Female "F" "M") Person) FROM Person

Med kommandot SETREC är nu både "F" och "M" kopplade till den post de är härledda från, vilket till exempel tillåter en virtuell lista som använder denna fråga att stödja öppning av motsvarande post vid dubbelklick (se Field object editor)

Se även GETREC.

16.18.12 RECNUM

RECNUM returnerar postnumret för en post.

(RECNUM record)

Returnerar postnumret för den givna posten. Observera att numreringen för poster är annorlunda än t.ex. för listor. För listor, strängar och andra börjar räkningen med noll, men för poster börjar den med 1 för den första posten. Numret 0 är reserverat för den initiala posten. Detta verkar vara inkonsistent med resten av BeeBase programmeringsfunktioner, men det är faktiskt logiskt här eftersom postnumren också används i fönstervisningen.

Se även RECORDS, MOVEREC, INT.

16.18.13 MOVEREC

MOVEREC flyttar en post till en ny position.

(MOVEREC record pos)

Flyttar den givna posten till den givna positionen i tabellen så att postnumret blir pos. Observera att postnummer börjar med 1 för den första positionen. Returnerar det nya postnumret eller NIL om flyttning av posten misslyckades, t.ex. om pos inte är inom 1 och antalet poster i tabellen.

Om posten har flyttats rensas även postens sorteringstillstånd. Observera att om tabellen har en definierad ordning kommer omordning av poster i tabellen att flytta tillbaka posten till sin plats. Därför är denna funktion huvudsakligen användbar för tabeller som inte har någon definierad ordning.

Denna funktion är användbar i en sort drop-utlösarfunktion för en virtuell lista, se Sort drop trigger.

Se även RECNUM, GETISSORTED, Sort drop trigger.

16.18.14 COPYREC

COPYREC kopierar poster.

(COPYREC rec source)

Kopierar innehållet i posten source till posten rec. Om source är NIL sätts rec till värdena för den initiala posten. Om rec är NIL genereras ett felmeddelande.

COPYREC returnerar rec.

Se även NEW.

16.19 Field Functions

Detta avsnitt listar funktioner som arbetar med fält i en tabell.

16.19.1 FIELDNAME

FIELDNAME returnerar namnet på ett fält.

(FIELDNAME field)

Returnerar en sträng som innehåller namnet på det angivna fältet.

Se även TABLENAME

16.19.2 MAXLEN

MAXLEN returnerar maximal storlek för ett strängfält.

(MAXLEN string-field)

Returnerar det maximala antalet tecken som det givna strängfältet kan innehålla.

Se även LEN.

16.19.3 GETLABELS

GETLABELS returnerar alla etiketter för ett val- eller strängfält.

(GETLABELS field)

Returnerar etiketterna för det givna val- eller strängfältet. För ett valfält returneras de etiketter du angav i fältdialogen (se Type specific settings), för ett strängfält returneras de statiska etiketterna du angav för listvypopuppen (se Field object editor) (observera att denna funktion endast är användbar för statiska etiketter).

Etiketterna returneras i en enda sträng och är separerade med nyradstecken.

Till exempel, anta att du har ett valfält med etiketterna `Car', `House' och `Oil'. Då resulterar anrop till GETLABELS på det fältet i strängen "Car\nHouse\nOil".

Obs: du kan enkelt konvertera resultatsträngen till en lista genom att anropa MEMOTOLIST (se MEMOTOLIST) på resultatsträngen.

Se även SETLABELS.

16.19.4 SETLABELS

SETLABELS används för att ställa in etiketterna för ett strängfält.

(SETLABELS field str)

Ställer in de statiska etiketterna för strängfältet field till etiketterna som anges i argumentet str. Argumentet str består av rader där varje rad innehåller en etikett. Etiketterna ersätter de du har angett för popuplistvyn i fältobjektredigeraren (se Field object editor). Observera att denna funktion endast är användbar för statiska etiketter.

SETLABELS returnerar värdet av argumentet str.

Exempel: `(SETLABELS Table.String "My house\nis\nyour house")' ställer in de statiska listvyetiketterna för det angivna strängfältet till `My house', `is' och `your house'.

Obs: du kan enkelt konvertera en lista med etiketter till det nödvändiga sträng- formatet genom att anropa LISTTOMEMO på listan.

Se även GETLABELS.

16.20 Table Functions

16.20.1 TABLENAME

TABLENAME returnerar namnet på en tabell.

(TABLENAME table)

Returnerar en sträng som innehåller namnet på den angivna tabellen.

Se även FIELDNAME

16.20.2 GETORDERSTR

GETORDERSTR returnerar postordningen för en tabell.

(GETORDERSTR table)

Returnerar det aktuella ordningsuttrycket för den givna tabellen. Om tabellen använder en fältlista för ordning så innehåller den returnerade strängen fältnamnen separerade med mellanslag. Varje fältnamn föregås av ett `+' eller ett `-' tecken som anger stigande eller fallande ordning.

Om tabellen är ordnad efter en jämförelsefunktion så returneras namnet på denna funktion.

En tom sträng betyder ingen ordning.

Exempel

Anta en tabell `Person' som är ordnad efter fälten `Name' (stigande), `Town' (stigande) och `Birthday' (fallande). Då kommer `(ORDERSTR Person)' att resultera i strängen "+Name +Town -Birthday".

Se även SETORDERSTR, REORDER, REORDERALL, GETISSORTED, SETISSORTED, Order, Comparison function.

16.20.3 SETORDERSTR

SETORDERSTR ställer in postordningen för en tabell.

(SETORDERSTR table order)

Ställer in ordningen för den givna tabellen enligt order-strängen. Strängen order kan antingen innehålla en lista med fältnamn eller namnet på en jämförelsefunktion.

För sortering med hjälp av en fältlista måste order-strängen innehålla fältnamnen separerade med valfritt antal mellanslag, tabbar eller nyradstecken. Varje fältnamn kan föregås av ett `+' eller ett `-' tecken som anger stigande eller fallande ordning. Om du utelämnar detta tecken antas stigande ordning.

För sortering med hjälp av en jämförelsefunktion måste order-strängen innehålla namnet på funktionen.

SETORDERSTR returnerar TRUE om den har kunnat ställa in den nya ordningen, NIL annars, t.ex. om ett okänt fält har angetts eller typen av fältet inte är tillåten för ordning. Om du anger NIL för argumentet order händer ingenting och NIL returneras.

Obs: För att bygga ordningssträngen bör du inte direkt skriva fältnamnen i strängen eftersom när du ändrar ett fältnamn kommer ordningssträngen inte att uppdateras. Bättre att använda funktionen FIELDNAME (se FIELDNAME) för att kopiera fältets namn till ordningssträngen.

Exempel

Anta en tabell `Person' med fälten `Name', `Town' och `Birthday'. Då kommer `(SETORDERSTR Person (SPRINTF "+%s" (FIELDNAME Person.Name)))' att ställa in ordningen för tabellen `Person' med `Name' som (stigande) ordningsfält.

Se även GETORDERSTR, REORDER, REORDERALL, GETISSORTED, SETISSORTED, Order, Comparison function.

16.20.4 REORDER

REORDER återför alla osorterade poster till rätt ordning.

(REORDER table)

Undersöker alla poster i den angivna tabellen efter osorterade poster och återinfogar dem till deras rätta positioner. Efter återinfogande av en osorterad post sätts sorteringstillståndet för posten till TRUE, så vid returvärdet av REORDER är sorteringstillståndet för alla poster TRUE.

REORDER returnerar NIL.

Vanligtvis behöver du bara anropa denna funktion när du använder en jämförelsefunktion för att definiera ordningen i en tabell. Ordningar definierade med en fältlista är automatiska, det vill säga, en post omordnas automatiskt när det behövs.

För ett exempel på hur du använder denna funktion, se Comparison function.

Se även REORDERALL, GETORDERSTR, SETORDERSTR, GETISSORTED, SETISSORTED, Order, Comparison function.

16.20.5 REORDERALL

REORDERALL omordnar alla poster i en tabell.

(REORDERALL table)

Omordnar alla poster i den angivna tabellen genom att ställa in sorteringstillståndet för alla poster till NIL och sedan anropa REORDER för att omordna allt.

REORDERALL returnerar NIL.

Se även REORDER, GETORDERSTR, SETORDERSTR, GETISSORTED, SETISSORTED, Order, Comparison function.

16.20.6 GETFILTERACTIVE

GETFILTERACTIVE returnerar filtertillståndet för en tabell.

(GETFILTERACTIVE table)

Returnerar TRUE om filtret för den angivna tabellen för närvarande är aktiverat och NIL annars.

Se även SETFILTERACTIVE, GETFILTERSTR, GETMATCHFILTER.

16.20.7 SETFILTERACTIVE

SETFILTERACTIVE ställer in filtertillståndet för en tabell.

(SETFILTERACTIVE table bool)

Ställer in filtertillståndet för den angivna tabellen. Om bool inte är NIL aktiveras filtret, annars inaktiveras det.

SETFILTERACTIVE returnerar det nya tillståndet för filtret. Det nya tillståndet kanske inte är det förväntade om du aktiverar filtret men ett feltillstånd inträffar och filtret inte kan aktiveras. Att inaktivera filtret lyckas dock alltid.

Se även GETFILTERACTIVE, SETFILTERSTR, SETMATCHFILTER.

16.20.8 GETFILTERSTR

GETFILTERSTR returnerar postfilteruttrycket för en tabell.

(GETFILTERSTR table)

Returnerar postfilteruttrycket för den angivna tabellen som en sträng. En tom sträng betyder att inget filteruttryck har ställts in för denna tabell.

Se även SETFILTERSTR, GETFILTERACTIVE, GETMATCHFILTER.

16.20.9 SETFILTERSTR

SETFILTERSTR ställer in postfilteruttrycket för en tabell.

(SETFILTERSTR table filter-str)

Ställer in postfilteruttrycket för den angivna tabellen till uttrycket i argumentet filter-str (som måste vara en sträng och inte det faktiska uttrycket självt!). Om filtret för den givna tabellen för närvarande är aktivt tillämpas det nya filteruttrycket direkt på alla poster och match-filter-tillståndet för alla poster beräknas om.

SETFILTERSTR returnerar TRUE om den har kunnat kompilera det givna filterstränguttrycket, annars returneras NIL. Observera att du endast får resultatet av kompileringen. Om filtret för den givna tabellen för närvarande är aktivt och omberäkning av alla match-filter-tillstånd för motsvarande poster misslyckas kommer du inte att märka det från resultatet av denna funktion. Det rekommenderade sättet att ställa in ett nytt filteruttryck är som följer:

(SETFILTERACTIVE Table NIL)               ; lyckas alltid.
(IF (NOT (SETFILTERSTR Table filter-string))
    (ERROR "Can't set filter string for %s!" (TABLENAME Table))
)
(IF (NOT (SETFILTERACTIVE Table TRUE))
    (ERROR "Can't activate filter for %s!" (TABLENAME Table))
)

Om SETFILTERSTR anropas med ett värde av NIL för argumentet filter-str händer ingenting och NIL returneras.

Exempel: `(SETFILTERSTR Table "(> Value 0.0)")'.

Se även GETFILTERSTR, SETFILTERACTIVE, SETMATCHFILTER.

16.20.10 RECORDS

RECORDS returnerar antalet poster i en tabell.

(RECORDS table)

Returnerar antalet poster i den angivna tabellen. Du kan lägga till en stjärna till tabellnamnet för att räkna antalet poster som matchar tabellens filter.

Se även RECORD, RECNUM.

16.20.11 RECORD

RECORD returnerar en postpekare för ett givet postnummer.

(RECORD table num)

Returnerar postpekaren till den num:te posten i den angivna tabellen eller NIL om en post med detta nummer inte existerar. Du kan lägga till en stjärna till tabellnamnet för att få den num:te posten som matchar tabellens postfilter.

Observera att postnummer börjar med 1 och postnummer 0 används för den initiala posten.

Se även RECORDS, RECNUM.

16.20.12 SELECT

SELECT extraherar och returnerar diverse data från poster.

(SELECT [DISTINCT] exprlist FROM tablelist
        [WHERE where-expr] [ORDER BY orderlist])

där exprlist är antingen en enkel stjärna `*' eller en lista med uttryck med valfria titlar separerade med kommatecken:

exprlist:     * | expr "title", ...

och tablelist är en lista med tabellnamn:

tablelist:      table[*] [ident], ...

För varje tabell i tabellistan kan du ange en identifierare. Detta kan vara mycket användbart om en tabell förekommer mer än en gång i tabellistan (se exempel på jämförelse av åldrar nedan). Om du lägger till en stjärna till en tabell kommer endast poster som matchar det för närvarande definierade filtret för den tabellen att undersökas.

Ordningslistan har följande syntax:

orderlist:    expr [ASC | DESC], ...