Harbor (programmeringsspråk)

Hamnprojekt
Paradigm multi-paradigm : imperativ , funktionell , objektorienterad , reflekterande
Designad av Antonio Linares
Utvecklare Viktor Szakáts och samhället
Dök först upp 1999 ; 24 år sedan ( 1999 )
Stabil frisättning
3.0.0 / 17 juli 2011 ; för 11 år sedan ( 2011-07-17 )
Förhandsgranska release
Maskinskrivningsdisciplin Eventuellt anka , dynamisk , säker , delvis stark
OS Cross-plattform
Licens GPL-kompatibel med öppen källkod
Filnamnstillägg .prg, .ch, .hb, .hbp
Hemsida harbor .github .io
Dialekter
Clipper, Xbase++, FlagShip, FoxPro, xHarbour
Influenced by
dBase, Clipper
Influenced
xHarbour

Harbor är ett datorprogrammeringsspråk som främst används för att skapa databas-/företagsprogram. Det är en moderniserad, öppen källkod och plattformsoberoende version av det äldre Clipper- systemet, som i sin tur utvecklades från dBase- databasmarknaden på 1980- och 1990-talen.

Hamnkod som använder samma databaser kan kompileras under en mängd olika plattformar, inklusive Microsoft Windows , Linux , Unix- varianter, flera BSD- avkomlingar, Mac OS X , MINIX 3 , Windows CE , Pocket PC , Symbian , iOS , Android , QNX , VxWorks , OS/2 (inklusive eComStation och ArcaOS ), BeOS / Haiku , AIX och MS-DOS .

Historia

Idén om en fri programvara Clipper-kompilator hade svävat runt länge och ämnet har ofta dykt upp i diskussioner på comp.lang.clipper. Antonio Linares grundade Harbour-projektet och implementeringen påbörjades i mars 1999. Namnet "Harbour" föreslogs av Linares, det är en lek på en Clipper som en typ av fartyg. Harbour är en synonym för hamn (där fartyg lägger till) och Harbour är en hamn i Clipper-språket.

2009 gjordes om Harbour väsentligt om, främst av Viktor Szakáts och Przemyslaw Czerpak.

Databasstöd

Harbor utökar tillvägagångssättet Clipper Replaceable Database Drivers (RDD). Den erbjuder flera RDD:er som DBF , DBFNTX, DBFCDX, DBFDBT och DBFFPT. I Harbor kan flera RDD:er användas i en enda applikation, och nya logiska RDD:er kan definieras genom att kombinera andra RDD:er. RDD-arkitekturen tillåter arv, så att en given RDD kan utöka funktionaliteten hos andra befintliga RDD(ar). RDD:er från tredje part, som RDDSQL, RDDSIX, RMDBFCDX, Advantage Database Server och Mediator, exemplifierar några av RDD-arkitekturfunktionerna. DBFNTX-implementeringen har nästan samma funktionalitet som DBFCDX och RDDSIX. NETIO och LetoDB ger fjärråtkomst över TCP- protokoll.

Harbor erbjuder även ODBC- stöd med hjälp av en OOP- syntax, och ADO- stöd med hjälp av OLE . MySQL , PostgreSQL , SQLite , Firebird , Oracle är exempel på databaser som Harbor kan ansluta till.

xBase-teknologier förväxlas ofta med RDBMS- programvara. Även om detta är sant, är xBase mer än ett enkelt databassystem eftersom samtidigt xBase-språk som använder enbart DBF inte kan tillhandahålla hela konceptet av ett riktigt RDBMS.

Programmeringsfilosofi

Till skillnad från Java som är tänkt att skrivas en gång, köras var som helst, syftar Harbor till att skrivas en gång, kompileras var som helst . Eftersom samma kompilator är tillgänglig för alla ovanstående operativsystem, finns det inget behov av omkodning för att producera identiska produkter för olika plattformar, förutom när operativsystemberoende funktioner används. Korskompilering stöds med MinGW . Under Microsoft Windows är Harbor mer stabil men mindre väldokumenterad än Clipper, men har multiplattformskapacitet och är mer transparent, anpassningsbar och kan köras från ett USB-minne.

Under Linux och Windows Mobile kan Clipper-källkoden kompileras med Harbor med mycket liten anpassning. De flesta program som ursprungligen skrevs för att köras på Xbase++, FlagShip, FoxPro, xHarbour och andra dialekter kan kompileras med Harbor med viss anpassning. Från och med 2010 har många ansträngningar gjorts för att göra övergången från andra xBase- dialekter lättare.

Harbor kan bland annat använda följande C-kompilatorer: GCC , MinGW , Clang , ICC , Microsoft Visual C++ (6.0+), Borland C++ , Watcom C , Pelles C och Sun Studio .

Harbor kan använda flera grafiska terminalemuleringar, inklusive konsoldrivrutiner, och hybridkonsoler/GUI:er, som GTWvt och GTWvg.

Harbor stöder externa GUI:er, gratis (t.ex. HBQt, HWGui, Mini-GUI (senaste versionen baserad på Qt och QtContribs) och kommersiella (t.ex. FiveWin, Xailer). HBQt är ett bibliotek som tillhandahåller bindningar till Qt. HBIDE-applikationen är ett exempel på HBQt-potential .

Harbor är 100 % Clipper-kompatibel och stöder många språksyntaxtillägg inklusive kraftigt utökade runtime-bibliotek som OLE , Blat, OpenSSL , Free Image, GD , hbtip, hbtpathy, PCRE , hbmzip ( zlib ), hbbz2 ( bzip2 ), cURL , Kairo , sin egen implementering av CA-Tools, uppdaterade NanFor-bibliotek och många andra. Harbour har en aktiv utvecklingsgemenskap och omfattande stöd från tredje part.

Alla xBase -språk ger ett mycket produktivt sätt att bygga affärs- och dataintensiva applikationer. Hamnen är inget undantag.

Makrooperator (runtime kompilator)

En av de mest kraftfulla funktionerna i xBase-språk är Macro Operator '&'. Harbours implementering av Macro Operator möjliggör körtidskompilering av alla giltiga Harbor-uttryck. Ett sådant kompilerat uttryck kan användas som ett VÄRDE, dvs den högra sidan av en tilldelning (rvalue), men ett sådant kompilerat uttryck kan användas för att lösa den vänstra sidan (lvalue) av en tilldelning, dvs. privata eller offentliga variabler, eller ett databasfält.

Dessutom kan makrooperatören kompilera och utföra funktionsanrop, slutföra tilldelningar eller till och med lista med argument, och resultatet av makrot kan användas för att lösa något av ovanstående sammanhang i den kompilerade applikationen. Med andra ord kan alla Harbor-applikationer utökas och modifieras under körning för att kompilera och exekvera ytterligare kod på begäran.

Den senaste makrokompilatorn kan kompilera valfri giltig Harbor-kod inklusive kod till per process innan kompilering.

Syntax:

&(...)

Textvärdet för uttrycket '...' kommer att kompileras, och värdet som resulterar från körningen av den kompilerade koden är resultatet.

&SomeId

är den korta formen för &( SomeId ).

&SomeId.postfix

är den korta formen av &( SomeId + "postfix" ).

Objektorienterad programmering

Programmering i en OOP-stil är en bredare fråga än ett specifikt bibliotek eller ett specifikt gränssnitt, men OOP-programmering är något som många Clipper-programmerare har kommit att förvänta sig. CA-Clipper 5.2 och speciellt 5.3 lade till ett antal basklasser och en matchande OOP-syntax. Bibliotek som Class(y) , FieWin, Clip4Win och Top Class tillhandahåller ytterligare OOP-funktioner.

Harbor har OOP-tillägg med fullt stöd för klasser inklusive arv, baserat på klass(y)-syntax. OOP-syntax i Harbor är mycket lik den i tidigare Clipper-klassbibliotek så det borde vara möjligt att underhålla äldre Clipper-kod med minimala ändringar.

Syntax och semantik

Hamnkod på HBIDE

Harbor as varje xBase-språk är skiftlägesokänsligt och kan valfritt acceptera nyckelord skrivna bara av deras första fyra tecken.

Inbyggda datatyper

Harbor har sex skalärtyper: Noll , String , Date , Logical , Numeric , Pointer och fyra komplexa typer: Array , Object , CodeBlock och Hash . En skalär har ett enda värde, till exempel en sträng, numerisk eller referens till någon annan typ. Matriser är ordnade listor med skalärer eller komplexa typer, indexerade efter nummer, med början på 1. Hashes, eller associativa matriser , är oordnade samlingar av valfri typvärden som indexeras av deras associerade nyckel, som kan vara av valfri skalär eller komplex typ.

Bokstavlig (statisk) representation av skalära typer:

  • Noll: Noll
  • Sträng: "hej", "hej", [hej]
  • Datum: 0d20100405
  • Logisk: .T., .F.
  • Numeriska: 1, 1,1, −1, 0xFF

Komplexa typer kan också representeras som bokstavliga värden:

  • Array: { "String" , 1, { "Nested Array" }, .T. , FunctionCall(), @FunctionPointer() }
  • Kodblock: { |Arg1, ArgN| Arg1 := ArgN + OuterVar + FunctionCall() }
  • Hash: { "Name" => "John" , 1 => "Numerisk nyckel" , "Name2" => { "Nested" => "Hash" } }

Hashes kan använda vilken typ som helst inklusive andra hash som nyckel för alla element. Hashes och arrays kan innehålla vilken typ som helst som värdet för vilken medlem som helst, inklusive kapslande arrayer och hashes.

Kodblock kan ha referenser till variabler av den procedur/funktion>metod som den definierades i. Sådana kodblock kan returneras som ett värde, eller med hjälp av ett argument som skickas BY REFERENCE , i sådana fall kommer kodblocket att "överleva" rutinen där det definierades, och alla variabler som det refererar till kommer att vara en DETACHED variabel.

Fristående variabler kommer att behålla sitt värde så länge som ett kodblock som refererar till dem fortfarande finns. Sådana värden kommer att delas med alla andra kodblock som kan ha tillgång till samma variabler. Om kodblocket inte överlevde sin innehållande rutin, och kommer att utvärderas inom livslängden för den rutin i vilken den är definierad, kommer ändringar av dess fristående variabler med hjälp av dess utvärdering att återspeglas i dess moderrutin.

Kodblock kan utvärderas hur många gånger som helst med hjälp av funktionen Eval( BlockExp ) .

Variabler

Alla typer kan tilldelas namngivna variabler. Namngivna variabelidentifierare är 1 till 63 ASCII-tecken långa, börjar med [AZ|_] och består vidare av tecknen [AZ|0–9|_] upp till maximalt 63 tecken. Namngivna variabler är inte skiftlägeskänsliga.

Variabler har ett av följande omfång:

  • LOCAL : Synlig endast inom rutinen som deklarerade det. Värdet går förlorat när rutinen avslutas.
  • STATISK : Synlig endast inom rutinen som deklarerade det. Värdet bevaras för efterföljande anrop av rutinen. Om en STATIC-variabel deklareras innan någon procedur/funktion/metod har definierats, har den ett MODULE-omfång och är synlig inom alla rutin som definieras inom samma källfil, kommer den att behålla sin livslängd under hela programmets livslängd.
  • PRIVAT : Synlig i rutinen som deklarerade det, och alla rutiner som anropas av den rutinen.
  • PUBLIC : Synlig av alla rutiner i samma applikation.

LOCAL och STATIC löses vid kompilering och är därför mycket snabbare än PRIVATE och PUBLIC variabler som är dynamiska enheter som nås med hjälp av en runtime Symbol-tabell . Av samma anledning inte LOCAL och STATIC variabler för makrokompilatorn, och alla makrokoder som försöker referera till dem kommer att generera ett körtidsfel.

På grund av den dynamiska naturen hos PRIVATE och PUBLIC variabler kan de skapas och förstöras under körning, kan nås och modifieras med hjälp av runtime-makron och kan nås och modifieras av kodblock som skapas i farten.

Kontrollstrukturer

De grundläggande kontrollstrukturerna inkluderar alla standardkontrollstrukturerna dBase och Clipper samt ytterligare sådana som är inspirerade av programmeringsspråken C eller Java :

Slingor 

    [DO] MEDAN  ConditionExp  ...  [LOOP] [EXIT] END[DO] 
 FOR  Var  :=  InitExp  TO  EndExp  [STEP  StepExp  ]  ...  [LOOP] [EXIT] NÄSTA 
    FÖR VARJE  Var  IN  CollectionExp  ...  [  Var  : __enumIndex()] [LOOP] [EXIT] NÄSTA
  • ... är en sekvens av ett eller flera Harbor - satser, och hakparenteser [ ] anger valfri syntax.
  • Var :__enumIndex() kan valfritt användas för att hämta det aktuella iterationsindexet (1 baserat) .
  • LOOP - satsen startar om den aktuella iterationen av den omslutande loopstrukturen, och om den omslutande loopen är en FOR- eller FOR EACH -loop, ökar den iteratorn och går vidare till nästa iteration av loopen.
  • EXIT - satsen avslutar omedelbart exekveringen av den omslutande slingstrukturen.
  • NEXT - satsen stänger kontrollstrukturen och flyttar till nästa iteration av loopstrukturen.

I FOR -satsen utvärderas tilldelningsuttrycket före den första loopiterationen. TO - uttrycket utvärderas och jämförs mot värdet på kontrollvariabeln, före varje iteration, och slingan avslutas om den utvärderas till ett numeriskt värde som är större än det numeriska värdet för kontrollvariabeln. Det valfria STEP -uttrycket utvärderas efter varje iteration, innan man beslutar om nästa iteration ska utföras.

I FOR EACH kommer Variabeln Var att ha värdet (skalärt eller komplext) för respektive element i samlingsvärdet. Samlingsuttrycket kan vara en Array (av valfri typ eller kombinationer av typer), en Hash-tabell eller en Objekttyp.

IF uttalanden 

   
    IF  CondExp  ...  [ELSEIF]  CondExp  ...  [ELSE]  ...  END[IF]

... representerar 0 eller fler påståenden .

Villkorsuttrycket/-en måste utvärderas till ett LOGISKT värde.

SWITCH uttalanden

Harbor stöder en SWITCH-konstruktion inspirerad av C-implementeringen av switch().

    SWITCH  SwitchExp  CASE  LiteralExp  ...  [EXIT] [CASE  LiteralExp  ]  ...  [EXIT] [ANNAT]  ...  END[SWITCH]
  • LiteralExp måste vara ett kompilerat tidsupplösbart numeriskt uttryck och kan involvera operatorer , så länge som sådana operatorer involverar ett statiskt värde för kompileringstid.
  • Den valfria EXIT- satsen är ekvivalent med C-satsen break , och om den finns, kommer exekveringen av SWITCH-strukturen att avslutas när EXIT-satsen nås, annars fortsätter den med den första satsen under nästa CASE-sats (fall through).

BEGIN SEQUENCE-satser 

 BÖRJA SEKVENS  ...  [BROTT] [Avbrott( [  Exp  ] )] ÅTERSTÄLLA [ANVÄNDA  Var  ]  ...  AVSLUTA[SEKVENS]

eller:

 BÖRJA SEKVENS  ...  [BREAK] [Break()] END[SEKVENS]

BEGIN SEQUENCE-strukturen tillåter en väluppfostrad abort av vilken sekvens som helst, även när man korsar kapslade procedurer/funktioner. Detta innebär att en anropad procedur/funktion kan utfärda en BREAK-sats, eller ett Break()-uttryck, för att framtvinga uppveckling av alla kapslade procedur/funktioner, hela vägen tillbaka till den första yttre BEGIN SEQUENCE-strukturen, antingen efter dess respektive END-sats , eller en RECOVER-klausul om sådan finns. Break-satsen kan valfritt passera vilken typ av uttryck som helst, som kan accepteras av RECOVER-satsen för att möjliggöra ytterligare återställningshantering.

stöder Harbor Error Object egenskaperna canDefault , canRetry och canSubstitute , vilket gör att felhanterare kan utföra vissa förberedelser och sedan begära en Retry Operation , en Resume eller returnera ett värde för att ersätta uttrycket som utlöser feltillståndet.

Alternativt PROVA [CATCH] [FINALLY]-satser är tillgängliga på xhb- biblioteket som fungerar som SEQUENCE-konstruktionen.

Rutiner och funktioner 

 [STATISK] PROCEDUR  SomeProcedureName  [STATIC] PROCEDURE  SomeProcedureName  ) [STATIC] PROCEDURE  (  Param1  [  ,  ParamsN  ] ) 
 SomeProcedureName  (  [STATIC  ] FUNCTION  SomeProcedureName ]   SomeProcedureName ureName  (  Param1  [ ,  ParamsN  ]) 
 INIT PROCEDURE  SomeProcedureName  AVSLUTA PROCEDURE  SomeProcedureName

Procedurer och funktioner i Harbor kan specificeras med nyckelorden PROCEDURE eller FUNCTION . Namnreglerna är desamma som för variabler (upp till 63 tecken som inte är skiftlägeskänsliga). Både procedurer och funktioner kan kvalificeras av omfångskvalificeraren STATIC för att begränsa deras användning till modulens omfattning där den definieras.

De valfria INIT- eller EXIT -kvalificeringarna kommer att flagga proceduren som ska anropas automatiskt precis innan startproceduren för programmet anropas, respektive precis efter att programmet avslutats. Parametrar som skickas till en procedur/funktion visas i subrutinen som lokala variabler och kan acceptera vilken typ som helst, inklusive referenser.

Ändringar av argumentvariabler återspeglas inte i respektive variabler som skickas av anropsproceduren/funktionen/metoden om de inte uttryckligen skickas BY REFERENCE med @ -prefixet .

PROCEDUR har inget returvärde, och om det används i ett uttryckssammanhang kommer det att producera ett NIL- värde.

FUNCTION kan returnera vilken typ som helst med hjälp av RETURN-satsen, var som helst i dess definition.

Ett exempel på en procedurdefinition och ett funktionsanrop följer:

  x  := Kub( 2 )  FUNKTION  Kub( n )  RETURN  n ** 3

Exempelkod

Det typiska " hej världen "-programmet skulle vara: 

 ?  "Hej världen!"

Eller:

   QOut  (  "Hej, värld!"  )

Eller:

   Alert  (  "Hej, värld!"  )

Eller, inkluderat i ett uttryckligt förfarande:

 

     PROCEDUR  Main() ?  "Hej världen!"  LÄMNA TILLBAKA

OOP exempel

Huvudprocedur:

  

 

    
    

     #include  "hbclass.ch"  PROCEDUR  Main()  LOCAL  oPerson  CLS  oPerson  := Pers  on  ():New(  "Dave"  )  oPerson  :Eyes :=  "Ogiltig"  oPerson  :Eyes :=  "Blue"  Alert  ( oPerson:Describe( ) )  RETUR

Klassdefinition:

SKAPA KLASS Person VAR Namn INIT "" METOD New( cName ) METOD Describe() ACCESS Eyes INLINE ::pvtEyes ASSIGN Eyes( x ) INLINE iif( HB_ISSTRING( x ) .AND. x $ "Blue,Brown,Green", :: pvtEyes := x, Alert( "Ogiltigt värde") ) PROTECTED: VAR pvtEyes ENDCLASS // Exempel på normal metoddefinition METOD New( cName ) CLASS Person ::Name := cName RETURN Self METOD Describe() CLASS Person LOCAL cDescription IF Tom ( ::Name ) cDescription := "Jag har inget namn ännu." ELSE cDescription := "Mitt namn är: " + ::Namn + ";" ENDIF OM! Empty( ::Eyes ) cDescription += "min ögonfärg är: " + ::Ögon ENDIF RETURN cDescription

Verktyg

  • hbmk2 – Bygg verktyg som make
  • hbrun – Shell-tolk för Harbour. Makrokompilering gör det möjligt att köra valfri giltig Harbor-kod när den kompileras
  • hbformat – Formaterar källkod skriven på Harbor eller annan dialekt enligt definierade regler
  • hbpp – Pre-processor, ett kraftfullt verktyg som undviker typiska problem som finns på C-språk per processor
  • hbi18n – Verktyg för att lokalisera text i applikationer
  • hbdoc – Skapar dokumentation för Harbor

Alla verktyg är multiplattformar.

Utveckling

HBIDE-utseende.

Idag leds hamnutvecklingen av Viktor Szakáts i samarbete med Przemysław Czerpak som också bidrar med många komponenter i kärnspråket och kompletterande komponenter. HBIDE och några andra komponenter, särskilt HBQt, är utvecklade av Pritpal Bedi. Andra medlemmar av utvecklingscommunityt skickar ändringar till GitHub- källarkivet. Från och med 2015 är hamnutvecklingen aktiv och levande.

xHarbour jämförelse

xHarbour är en gaffel från det tidigare Harbour-projektet. xHarbour tar ett mer aggressivt tillvägagångssätt för att implementera nya funktioner i språket, medan Harbour är mer konservativt i sitt tillvägagångssätt, och siktar först och främst på en exakt replikering av Clipper-beteende och sedan implementerar nya funktioner och tillägg som en sekundär faktor. Det bör också noteras att Harbor stöds på en mängd olika operativsystem medan xHarbour bara verkligen stöder MS Windows och Linux 32-bitars.

Harbour-utvecklarna har försökt dokumentera allt dolt beteende i Clipper-språket och testa Harbour-kompilerad kod tillsammans med samma kod som kompilerats med Clipper för att upprätthålla kompatibiliteten.

Harbor-utvecklarna avvisar uttryckligen tillägg till språket där dessa tillägg skulle bryta Clippers kompatibilitet. Dessa avslag mildrades nyligen eftersom den nya Harbour-arkitekturen tillåter förlängningar från kärnkompilatorn.

En detaljerad jämförelse mellan tillägg implementerade i Harbor och xHarbour kan hittas i projektets källarkiv på GitHub.

GUI-bibliotek och verktyg

Se även

externa länkar

Hämtad från " https://en.wikipedia.org/w/index.php?title=Harbour_(programming_language)&oldid=1139120510 "