Podstawowe cechy języka jPALIO

• język skryptowy wykonywany po stronie serwera
• rozróżnianie małych i wielkich liter
• brak konieczności definiowania zmiennych
• zmienne są traktowane jak tablice indeksowane od 0
• tablice mogą przechowywać wartości różnych typów jednocześnie
• wartości wyrażeń i rezultaty zwracane przez funkcje są dodawane do kodu HTML

Zależności pomiędzy typami danych dostępnymi w systemie są hierarchiczne według schematu


Zestawienie typów danych

"text text text"
onewordstring
""
"description \"quotation\" description"

879
-52322
0 

true
false

-0.75982
11.034
3.14159265358979

14-04-966
1-1-2005 15:45
sysdate 

$=(@linkedList, $sql.read("select ID, LOGIN from P_USERS"))
$=(@oneElement, (Object[])null)
$for(@oneElement, $@linkedList, {
	id=$@oneElement[0], login=$@oneElement[1]
})

{ $=(var, 7) $var }

[19, false, -0.142857, "XYZ"]
[]
["A", [4, 5, 6], [7, 8], sysdate]

$for(oneElement,(List)$setOfElements,{
	$toLong($oneElement[0])
})

Zmienne dostępne są podczas pojedynczego wywołania strony ale mogą być przekazywane przez parametry wywołania strony w adresie URL. Wszystkie wywołania strony z przekazaniem parametrów dotyczą przekazania parametrów typu String. Aby otrzymać parametry danego typu należy dokonać konwersji typów za pomocą specjalnych funkcji.

Przypisanie wartości do zmiennej

$=(variableName, value)

Odwołanie do wartości zmiennej

$variableName

Przypisanie tablicy wartości do zmiennej

$=(variableName, [value1, value2, value3, ...]) 

Odwołanie do tablicy wartości zapisanej w zmiennej

$variableName[]

Odwołanie do drugiego elementu takiej tablicy (elementy tablic są indeksowane od 0)

$variableName[1]

Wszystkie zmienne są traktowane jak tablice a odwołanie do wartości zmiennej jest równoważne z odwołaniem do pierwszego elementu tablicy (elementu o indeksie 0). Zatem zapis

$variableName

jest równoważny z

$variableName[0]

Zmiana typu wartości zmiennej przez rzutowanie

(TypeName)$variableName

Zmienna, która nie istnieje albo której nie została przypisana żadna wartość ma wartość pustą określoną stałą null typu Object. Zmiennej można także przypisać wartość pustą

$=(variableName, null)

W celu przypisania pustych wartości wszystkim elementom tablicy stosuje się rzutowanie typu stałej null

$=(variableName, (Object[])null)

Każda zmienna w kodzie aplikacyjnym programu jest traktowana jako zmienna typu Object. Dlatego przekazanie wartości zmiennej jako parametru wywołania funkcji wymaga rzutowania lub konwersji typu (o ile funkcja taka oczekuje typu argumentu innego niż Object). Wymaganie to dotyczy również przekazywania wartości null.

Aby umieścić w kodzie aplikacyjnym znak $ należy napisać

$$

Począwszy od wersji 6.2.10 jPALIO znaki specjalne można uzyskiwać korzystając z konstrukcji

$\SPECIAL_SIGN

tak więc znak dolara można uzyskać również przez

$\$

Zmienne lokalne

Wraz z wersją 5.0.0 jPALIO wprowadzone zostały zmienne lokalne. Nazwy zmiennych lokalnych poprzedzane są znakiem @. Zmiennych lokalnych można używać bez groźby nadpisania przez inny obiekt lub rekurencyjne wywołanie tego samego obiektu

$@=(text, "Some text")
Text: $@text

Zmienne lokalne mają statyczne zapamiętywane typy na podstawie pierwszego przypisania. Można zatem ponownie przypisywać wartości lecz tylko tego typu - zapamiętany typ jest podstawiany pod każde użycie zmiennej (nie jest wymagane rzutowanie)

$@=(value, 2)
2+2 = $+($@value, $@value)

Aby zapamiętany został bardziej szczegółowy typ należy rzutować przy pierwszym przypisaniu

$=(ID, 7)
$@=(ID, (Long)$ID)
$@ID

Specjalna instrukcja umożliwia szybkie przypisanie parametrów wywołania obiektów do zmiennych lokalnych wraz z zapamiętaniem typów

$#params(Long id, String action, Object[] parameters)

co jest równoważne z zapisem

$@=(id, (Long)$0)
$@=(action, (String)$1)
$@=(parameters, $2[])
Na rzecz zmiennych lokalnych można wywoływać metody

$@=(text, "Some string")
Text: $@text <br/>
Length: $@text.length() <br/>
Some string? $@text.contains("string") <br/>

Wszystkie błędy związane z wywoływaniem metod są wyłapywane w momencie kompilacji ponieważ typy zmiennych lokalnych są znane.

Istnieją 2 typy komentarzy komentarz rozciągający się począwszy od ciągu znaków $// do końca linii tekstu

$// comment

komentarz rozciągający się pomiędzy ciągiem znaków $/* a ciągiem znaków $*/ na dowolną ilość linii tekstu

$/*
   comment
$*/

Operatory

W systemie jPALIO zdefiniowano wiele różnego rodzaju operatorów

Operatory arytmetyczne

+  operator dodawania (dwuargumentowy)
–  operator odejmowania (dwuargumentowy)
*  operator mnożenia (dwuargumentowy)
/  operator dzielenia (dwuargumentowy)
%  operator reszty z dzielenia (dwuargumentowy)
++  operator inkrementacji (jednoargumentowy)
––  operator dekrementacji (jednoargumentowy)

Operatory logiczne

&&  iloczyn logiczny (dwuargumentowy)
||  suma logiczna (dwuargumentowy)
!  negacja (jednoargumentowy)
==  równość (dwuargumentowy)
!=  różność (dwuargumentowy)
<>  różność (dwuargumentowy)
<  mniejszość (dwuargumentowy)
<=  mniejszość lub równość (dwuargumentowy)
>  większość (dwuargumentowy)
>=  większość lub równość (dwuargumentowy)

Operatory bitowe

&  iloczyn bitowy (dwuargumentowy)
|  suma bitowa (dwuargumentowy)
^  bitowa różnica symetryczna (dwuargumentowy)
~  negacja bitowa (jednoargumentowy)

Inne

• = operator przypisania (dwuargumentowy)
• + operator konkatenacji ciągów znaków (dwuargumentowy)
• ? operator wyrażenia warunkowego (trójargumentowy)
• += operator dodawania wartości lub dołączania ciągu znaków (dwuargumentowy)
• -= operator odejmowania wartości (dwuargumentowy)

Sposób użycia operatorów

$operator(argumenty)

Operator konkatenacji ciągów znaków poza wersją dwuargumentową posiada także wersję jednoargumentową, gdzie argumentem jest tablica ciągów znaków a wynikiem działania konkatenacja wszystkich ciągów znaków z tej tablicy

$+([ciąg1, ciąg2, ciąg3, ... ])

Operatory logiczne iloczynu i sumy logicznej poza wersją dwuargumentową posiadają również wersję jednoargumentową, gdzie argumentem jest tablica wyrażeń logicznych a wynikiem zastosowania operatora odpowiednio iloczyn i suma logiczna wszystkich wyrażeń z takiej tablicy.

Operator dzielenia poza wersją dwuargumentową posiada też wersję trójargumentową, w której trzeci argument określa pożądaną dokładność wyniku dzielenia (ilość miejsc po przecinku).

Operatory stanowią skrócony zapis wywołań określonych funkcji i w trakcie kompilacji są zamieniane na wywołania odpowiednich funkcji

+   funkcja add
–   funkcja subtract
*   funkcja multiply
/   funkcja divide
%   funkcja remainder
++  funkcja increment
––  funkcja decrement
&&  funkcja and
||  funkcja or
!   funkcja not
==  funkcja equals
!=  funkcja notEquals
<>  funkcja notEquals
<   funkcja lesser
<=  funkcja lesserOrEquals
>   funkcja bigger
>=  funkcja biggerOrEquals
&   funkcja bitwiseAnd
|   funkcja bitwiseOr
^   funkcja bitwiseXor
~   funkcja bitwiseNot
=   funkcja setParam
?   funkcja condition

Zatem przykładowo wywołanie

$+(2, 7)

jest równoważne z

$add(2, 7)

Przykłady

$// assign 5 to variable "z"
$=(z, 5)
$// incrementation
$++(z)
$// get variable value and place it in your HTML code
$z
$// calculation and put in the HTML the expression ((24 + 76) * 8.99)
$*($+(24, 76), 8.99)
$// assign 7 to variable "x"
$=(x, 7)
$// assign value of "x" devided by 14 to the nearest 1 decimal place to variable "y"
$=(y, $/((Long)$x, 14, 1))
$// assign string "def" to variable "t"
$=(t, "def")
$// concatenation of strings "abc" and "def" and put the result in HTML
$+("abc", "def")
$// assign to variable "t" result of concatenation "abc" string and variable "t" 
$=(t, $+("abc", (String)$t))
$// assigment to variable "s" result of concatenation "abc", "def" and "ghi" strings 
$// ciągów znaków "abc" , "def" i "ghi"
$=(s, $+(["abc", "def", "ghi"]))
$// assigment true value to "b" variable
$=(b, true)
$// calculate and place in your HTML code expression (~ b)
$!((Boolean)$b)
$// calculate and place in your HTML code expression (b? (True? ~ B))
$||((Boolean)$b, $&&(true, $!((Boolean)$b))) 
$// assigment 3 vaue to "i" varable
$=(i, 3)
$// putting in the HTML code letter "P" if the variable has a value even or N is not
$?($==($%((Long)$i, 2), 0), "P", "N")
$// assign current date to "today" variable
$=(today, sysdate)
$// assign number of seconds elapsed since the beginning of 2005 to the present to variable "s"
$=(s, $-((Date)$today, 01-01-2005 00:00:00))
$// put in HTML code number of days elapsed since the begining of 2005 to the present
$toLong($/((Long)$s, 86400))
$// assign array of arrays to tab2D
$=(tab2D, [[1, 2, 3], ["A", "B"]])
$// assign a second array of tables tab2D to table tab1D
$=(tab1D, (Object[])$tab2D[1])
$// put first element of the array tab1D to HTML code
$tab1D[0]

Zdefiniowane zostały 3 typy instrukcji sterowania

• if – wykonanie operacji jeśli spełniony jest określony warunek
• for – wykonanie operacji w pętli określoną ilość razy
• try – wykonanie operacji z obsługą sytuacji wyjątkowych

Instrukcja if

Instrukcji if można użyć na 2 sposoby:

$if(condition, { 
  codeOnTrue
})

gdzie:

• condition – warunek typu Boolean
• codeOnTrue – ciąg instrukcji wykonywanych gdy warunek ma wartość true

lub:

$if(condition, { 
  codeOnTrue
}, {
  codeOnFalse
})
gdzie:

• condition – warunek typu Boolean
• codeOnTrue – ciąg instrukcji wykonywanych gdy warunek condition ma wartość true
• codeOnFalse – ciąg instrukcji wykonywanych gdy warunek condition ma wartość false

Przykłady
$// assign true value to "condition" variable
$=(condition, true)
$if((Boolean)$condition, {
  $// If condition is true put in the HTML header
  <h3>Header content</h3>
})
$// assign 5 value to "x" variable
$=(x, 5)
$if($==((Long)$x, 7), {
  $// if "x" variable has value 7 then assign 0 value to variable "y"
  $=(y, 0)
}, {
  $// if "x" variable has not 7 valuethen assign 3 value to variable "y"
  $=(y, 3)
})
$// put in the HTML code value of "y"
$y


Instrukcja for
Instrukcja for posiada 4 konstrukcje:
$for(loopCount, {
  loopCode
}) 

gdzie:

• condition – liczba iteracji
• codeOnTrue – ciąg instrukcji wykonywanych w każdej z loopCount iteracji pętli

lub:
$for(conditionParamName, { 
  loopCode 
})

gdzie: 

ConditionParamName - nazwa zmiennej
loopCode -  ciąg instrukcji wykonywanych w pętli dopóki zmienna o nazwie 
conditionParamName będzie miała wartość true

lub:
$for(paramName, loopTable, {
  loopCode
})
gdzie:

paramName – nazwa zmiennej
loopTable – tablica typu Object[]
loopCode – ciąg instrukcji wykonywanych dla każdego elementu tablicy loopTable
w każdej iteracji pętli pojedynczy element tablicy loopTable zostanie przypisany zmiennej paramName

lub:
$for(paramName, loopList, {
  loopCode
})
gdzie:

paramName – nazwa zmiennej
loopList – lista typu LinkedList
loopCode – ciąg instrukcji wykonywanych dla każdego elementu z listy loopList
w każdej iteracji pętli pojedynczy wiersz  listy loopList  zostanie przypisany zmiennej paramName
 pojedynczy wiersz listy loopList jest tablicą typu Object[]

Przykłady
$// assign value 1 to "cnt" variable
$=(cnt, 1)
$// execution of the loop 7 times
$for(7, {
  $// put in the HTML code value of "cnt"
  $cnt
  $// incerement "cnt"
  $++(cnt)
})

$// assign value 1 to "ctr" variable
$=(ctr, 1)
$// assirn true to "loop" variable
$=(loop, true)
$// util loop is true do instruction
$for(loop, {
  $// put in the HTML code value of "ctr"
  $ctr
  $// increment ctr by 1
  $++(ctr)
  $// if value of "ctr" is greater then 4 then assign false to "ctr" variable
  $if($>((Long)$ctr, 4), { $=(loop, false) })
}) 

$// assign ["html","xml","txt"] table to variable "extensions"
$=(extensions, ["html","xml","txt"])
$// for each element in table do instructions
$for(i, $extensions[], {
  $// put in the HTML code the current array element
  $i
})
$// assign the result of SQL query to "users" variable
$=(users, $sql.read("select id, login from p_users order by login"))
$// for each element in "users" list do instructions
$for(i, (LinkedList)$users, {
  $// put in the HTML code value of current list line
  $// (first element is the id, and the second login)
  $i[0] $i[1]
})

Instrukcja try
Instrukcja try posiada 2 konstrukcje
$try({
  tryCode
}, {
  catchCode
})
gdzie

tryCode – ciąg instrukcji których próba wykonania może wywołać powstanie sytuacji wyjątkowej
catchCode – ciąg instrukcji realizujących obsługę sytuacji wyjątkowych

lub
$try({
  tryCode
}, {
  catchCode
}, {
  finallyCode
})

gdzie

tryCode – ciąg instrukcji których próba wykonania może wywołać powstanie sytuacji wyjątkowej
catchCode – ciąg instrukcji realizujących obsługę sytuacji wyjątkowych
finallyCode – ciąg instrukcji wykonywanych na końcu niezależnie od tego 
czy w bloku try wystąpiła sytuacja wyjątkowa i niezależnie czy została obsłużona

Przykłady
$try({
  $// divide by zero causes an exception 
  $// and go to exception handling block
  $/(7, 0)
}, {
  $// put in the HTML code information about exception
  Error:Devided by zero!
})  

$try({
  $// try to open file
  $=(WRITER, $pipe.openWriter("/tmp/text.txt", "FILE", "ISO-8859-2"))
  $// try to write to file
  $pipe.write((java.io.Writer)$WRITER, "TEXT")
}, {
  $// displey error
  $error.getMessage()
}, {
  $// try to close file
  $try({ $pipe.closeWriter((java.io.Writer)$WRITER) }, {})
})

Obiekty zawierają w sobie kod sterowania aplikacyjnego. Raz stworzony obiekt może być używany wielokrotnie. Wywołanie obiektu z wnętrza innego obiektu lub niego samego (rekurencyjnie) ma postać

$*object_identifier

lub

$*object_code

w przypadku obiektów bezparametrowych oraz

$*object_identifier(param1, param2, ... )

lub

$*object_code(param1, param2, ... )

w przypadku obiektów wywoływanych z parametrami, przy czym identyfikator_obiektu jest unikalną liczbą nadawaną każdemu obiektowi automatycznie w chwili jego utworzenia, a kod_obiektu unikalnym ciągiem znaków nadawanym każdemu obiektowi przez użytkownika. Pierwszym znakiem kodu obiektu musi być litera lub znak podkreślenia, kolejne znaki mogą być dodatkowo cyframi lub kropką, po kropce musi znajdować się litera lub znak podkreślenia. Ta sama zasada dotyczy tworzenia kodów stron, mediów i elementów hierarchicznej struktury typów.

Odwołanie w obiekcie do wartości dowolnego parametru jego wywołania ma postać

$param_number

lub (w przypadku parametrów stanowiących tablice wartości)

$param_number[]

przy czym parametry są numerowane od 0, czyli $0 oznacza wartość pierwszego parametru ($0[] jeśli pierwszy parametr jest tablicą), $1 – wartość drugiego parametru ($1[] jeśli drugi parametr jest tablicą) itd. Odwołanie do parametru, który nie został przekazany do obiektu jest równoważne z odwołaniem do wartości null.

Parametry wywołania obiektu istnieją tylko w czasie wykonywania tego obiektu i nie są widoczne poza tym obiektem.

Zmienne ustawione przed wywołaniem obiektu są widoczne wewnątrz tego obiektu i mogą być przezeń modyfikowane.

Zmienne ustawione wewnątrz obiektu pozostają widoczne w kodzie aplikacyjnym także po wywołaniu tego obiektu.

Wraz z wersją 5.0.0 jPALIO wprowadzona została instrukcja zwracania wartości przez obiekt. Instrukcja return powoduje natychmiastowe wyjście z kodu / obiektu ze zwróceniem wartości. Wszystko co znajduje się po instrukcji return już się nie wykona

$return("WARTOŚĆ")

Zwróconą wartość można pobrać

$@=(RESULT, (String)$*ID_OR_OBJECT_CODE)

Można także wykonać wyjście z obiektu bez zwracania wartości

$return()

Jeżeli instrukcja wyjścia zostanie wykonana wewnątrz pętli, iteracja jest przerywana i następuje wyjście z obiektu. Zachowanie takie dotyczy większości zagnieżdżonego kodu wewnątrz obiektu (pętle, instrukcje warunkowe, itd.). Wyjątkiem są wszystkie metody typu $palio.execute...(). Użycie instrukcji wyjścia w kodzie wewnątrz tej metody, przerywa wykonanie tylko tego kodu (nie całego obiektu). W związku z tym wszystkie te metody zwracają teraz wartość (zazwyczaj null, jeżeli wykonywanie kodu nie zostało przerwane). Metoda $palio.executeToBuffer zwraca wyjście (ewentualna zwrócona wewnątrz kodu wartość jest tracona). Metoda wywołująca kod w innym wątku nie zwraca wartości (wyjście jest logowane, ewentualna zwrócona wartość jest tracona).

W wersji 5.0.0 jPALIO została także wprowadzona instrukcja importowania typów i pakietów JAVA. Importowanie konkretnego typu, aby można go było potem szybciej używać

$#import(palio.pelements.PObject)
Importowanie całego pakietu (w pierwszej kolejności przy mapowaniu sprawdzane są dokładne wskazania, pakiety w drugiej kolejności)

$#import(palio.pelements.*)

Wywołanie funkcji z określonego modułu

$modue_name.function_name(arguments)

Wielkość liter w nazwie modułu nie ma znaczenia.

W przypadku modułów Logic, Mth, Page, Palio, Std, Text i Util nie jest wymagane poprzedzanie nazwy funkcji nazwą modułu i zapis upraszcza się do

$function_name(arguments)

Pełną dokumentację wszystkich funkcji można znaleźć na stronach

http://docs.torn.com.pl/jPalio/modules/