[Demos]
Count=21
Item0=Simple expression
Item1=One function
Item2=One function with variable
Item3=Unit and recursion
Item4=OnGetValue Event
Item5=Access to Delphi's objects
Item6=Exception handling
Item7=Working with sets
Item8=Handling Delphi events
Item9=Records
Item10=Calling external functions
Item11=Ole automation
Item12=JvInterpreter Adapters
Item13=How to import Delphi units
Item14=Arrays
Item15=Running delphi forms
Item16=Running delphi reports
Item17=Running delphi units
Item18=List of supported statements
Item19=Credits
Item20=Our plans

[Simple expression\Source]
Count=1
Item0=2*2+(122.34-54.67)*123.5

[Simple expression\Description]
Count=12
Item0=This is simple expression.
Item1=JvInterpreterProgram component automatically
Item2=detects 3 types of sources:
Item3="  1) simple expression;"
Item4="  2) one function;"
Item5="  3) unit;"
Item6=
Item7=Press 'Run' button, please.
Item8=Button 'Compile' requires unit as source,
Item9=so it doesn't work with this sample.
Item10=
Item11=See next example...

[One function\Source]
Count=4
Item0=begin
Item1="  Result := '2*2+(122.34-54.67)*123.5=' +"
Item2="    IntToStr(2*2+(122.34-54.67)*123.5);"
Item3=end;

[One function\Description]
Count=3
Item0=This is one function.
Item1=JvInterpreter detects it by first word;
Item2=it have to be 'begin' or 'var'.

[One function with variable\Source]
Count=6
Item0=var
Item1="  Variable : real {type ignored} ;"
Item2=begin
Item3="  Variable := 2*2+(122.34-54.67)*123.5;"
Item4="  Result := '2*2+(122.34-54.67)*123.5=' + IntToStr(Variable);"
Item5=end;

[One function with variable\Description]
Count=3
Item0=This is one function with var-statement.
Item1=JvInterpreter detects function by first word;
Item2=it have to be 'begin' or 'var'.

[Unit and recursion\Source]
Count=20
Item0=unit MyUnit;
Item1=
Item2=function main: string;
Item3=var
Item4="  IntVariable : integer;"
Item5=begin
Item6="  IntVariable := 5;"
Item7="  Result := 'Factorial(5)=' +"
Item8="    IntToStr(Factorial(IntVariable));"
Item9=end;
Item10=
Item11=function Factorial(F : integer) : integer;
Item12=begin
Item13="  if F <= 1 then"
Item14="    Result := F"
Item15="  else"
Item16="    Result := F * Factorial(F-1);"
Item17=end;
Item18=
Item19=end.

[Unit and recursion\Description]
Count=4
Item0=This example shows structure of JvInterpreter unit.
Item1=It is similar to delphi's unit, but 'interface'
Item2=and 'implementation' keywords are not required
Item3=(more over, they are raise an error).

[OnGetValue Event\Source]
Count=1
Item0=MyFunction(10000)

[OnGetValue Event\Description]
Count=2
Item0=Function MyFunction is calculated in OnGetValue - event.
Item1=It simply adds 1 to passed value.

[Access to Delphi's objects\Source]
Count=22
Item0=var
Item1="  v : TObject;"
Item2="  B : TStringList;"
Item3="  L : integer;"
Item4="  r : boolean;"
Item5=begin
Item6="  V := Application.FindComponent('Test')."
Item7="     FindComponent('Memo2').Lines;"
Item8="  B := TStringList.Create;"
Item9="  try"
Item10="    B.Assign(V);"
Item11="    B.Add('MyLine');"
Item12="    r := B.Find('MyLine', L);"
Item13="    if r then"
Item14="      Result := 'found line at position ' +"
Item15="        IntToStr(L)"
Item16="    else"
Item17="      Result := 'not found';"
Item18="  finally"
Item19="    B.Free;"
Item20="  end;"
Item21=end;

[Access to Delphi's objects\Description]
Count=9
Item0=This example demonstrates:
Item1="  - assigning delphi object to JvInterpreter variable;"
Item2="  - calling method from object;"
Item3="  - creating new object through to"
Item4="    class function Create;"
Item5="  - calling function with var parameter"
Item6="    (TStringList.Find);"
Item7="  - if/then/else statement;"
Item8="  - try/finally statement;"

[Exception handling\Source]
Count=20
Item0=var
Item1="  v, B : Variant;"
Item2=begin
Item3="  B := 'ok';"
Item4="  try"
Item5="   // raise Exception.Create('Self generated error');"
Item6="    V := 1 div 0;"
Item7="    V := V + 1;"
Item8="  except"
Item9="    on E: EOverflow do"
Item10="      B : = 'EOverflow: ' + E.Message;"
Item11="    on EIntOverflow do"
Item12="      B : = 'EIntOverflow: ' + E.Message;"
Item13="    on E: EZeroDivide do"
Item14="      B : = 'EZeroDivide: ' + E.Message;"
Item15="    else"
Item16="      raise"
Item17="  end;"
Item18="  Result := ': ' + B;"
Item19=end;

[Exception handling\Description]
Count=17
Item0=JvInterpreter understands try/finally and
Item1=try/except statements.
Item2=Exceptions in JvInterpreter is native Delphi
Item3=exceptions. It means that exceptions
Item4=raised in JvInterpreter may be handled in
Item5=Delphi and exceptions, raised in
Item6=Delphi functions called from JvInterpreter
Item7=source may be handled in JvInterpreter source.
Item8=To raise exception use standard
Item9=Delphi directive: raise <Object>.
Item10=
Item11=Note: to raise exceptions you need
Item12=create instance of object. It means,
Item13=that this object must be registered
Item14=in JvInterpreter adapter.
Item15=
Item16=See next examples.

[Handling Delphi events]
Page=Event

[Handling Delphi events\Source]
Count=18
Item0=unit Unit1;
Item1=
Item2=procedure ButtonClick(Sender: TObject);
Item3=begin
Item4="  MessageBox(0, TButton(Sender).Caption + ' clicked!', 'Information', MB_ICONINFORMATION);"
Item5=end;
Item6=
Item7=procedure main;
Item8=var
Item9="  v, B : Variant;"
Item10="  L : integer;"
Item11="  r : boolean;"
Item12=begin
Item13="  V := Test.FindComponent('Button4');"
Item14="  TButton(V).OnClick := ButtonClick;"
Item15=end;
Item16=
Item17=end.

[Handling Delphi events\Description]
Count=8
Item0=In JvInterpreter source you can handle
Item1=delphi events with standard delphi
Item2=manner.
Item3=
Item4=Note: to handle events event type
Item5=must be registered in JvInterpreter Adapter.
Item6=
Item7=Now click 'Run', then click 'Button4'.

[Working with sets\Source]
Count=17
Item0=var
Item1="  v : Variant;"
Item2="  S : string;"
Item3="  St: Variant;"
Item4=begin
Item5="  V := Test.FindComponent('Button1');"
Item6="  St := V.Font.Style;"
Item7="  S := V.Caption;"
Item8="  try"
Item9="    V.Font.Style := V.Font.Style + [fsBold, fsItalic];"
Item10="    V.Caption := 'Hello';"
Item11="    MessageBox(0, 'Hello', 'Information', MB_ICONINFORMATION);"
Item12="  finally"
Item13="    V.Caption := S;"
Item14="    V.Font.Style := St;"
Item15="  end;"
Item16=end;

[Working with sets\Description]
Count=7
Item0=JvInterpreter allows you to work with native
Item1=delphi sets, but only sets with
Item2=up to 32 elements are allowed.
Item3=
Item4=Note: you can't work with charset,
Item5=because it contains more than 32 elements.
Item6=Sorry.

[Records\Source]
Count=19
Item0=var
Item1="  F : TSearchRec;"
Item2="  DosError: Integer;"
Item3="  Strings: TStrings;"
Item4=begin
Item5="  Strings := Test.FindComponent('Memo2').Lines;"
Item6="  Strings.Clear;"
Item7="  DosError := FindFirst('C:\*.*', faAnyFile, F);"
Item8="  while DosError = 0 do"
Item9="  begin"
Item10="    if (F.Attr and faDirectory) = 0 then"
Item11="      Strings.Add(F.Name)"
Item12="    else"
Item13="      Strings.Add('\' + F.Name);"
Item14="    DosError := FindNext(F);"
Item15="  end;"
Item16="  FindClose(F);"
Item17="  DosError := 0;"
Item18=end;

[Records\Description]
Count=7
Item0=In JvInterpreter you can work with Delphi
Item1=records. We provide access to
Item2=following record types:
Item3=TPoint, TRect, TSearchRec.
Item4=
Item5=You can add other records using
Item6=JvInterpreter Adapters.

[Calling external functions\Source]
Count=11
Item0=unit Unit1;
Item1=
Item2=function MessageBox(hWnd: integer; lpText, lpCaption: PChar; uType: integer): Integer;
Item3="  external 'user32.dll' name 'MessageBoxA';"
Item4=
Item5=Procedure main;
Item6=begin
Item7="  MessageBox(0, 'Hello, World !', 'calling dll', MB_ICONINFORMATION);"
Item8=end;
Item9=
Item10=end.

[Calling external functions\Description]
Count=5
Item0=You can declare external function
Item1=in source and then call it.
Item2=
Item3=Note: only standard types are allowed;
Item4=var parameters don't allowed.

[JvInterpreter Adapters]
Page=Empty

[JvInterpreter Adapters\Description]
Count=33
Item0=All functions, classes, records, ..
Item1=must be registered in JvInterpreter Adapter
Item2=before they can be used in JvInterpreter
Item3=source. Usually you create special
Item4=unit to obtain access to delphi
Item5=functions and objects.
Item6=We call this special units as
Item7='JvInterpreter Adapters' or 'Adapters'.
Item8=
Item9=This version of JVCL Library includes
Item10=Adapters:
Item11=JvInterpreter_System, JvInterpreter_SysUtils,
Item12=JvInterpreter_Windows(only few functions and constants),
Item13=JvInterpreter_Classes, JvInterpreter_Controls,
Item14=JvInterpreter_StdCtrls, JvInterpreter_ExtCtrls,
Item15=JvInterpreter_Forms, JvInterpreter_Dialogs,
Item16=JvInterpreter_Graphics, JvInterpreter_Menus,
Item17=JvInterpreter_Grids, JvInterpreter_Db,
Item18=JvInterpreter_DbTables, JvInterpreter_DBCtrls,
Item19=JvInterpreter_DBGrids, JvInterpreter_Quickrpt;
Item20=
Item21=All adapters are based on Delphi 3
Item22=units;
Item23=Compiler {$IF} directives allow
Item24=to compile it in all version.
Item25=
Item26='Quickrpt' unit is very different
Item27=in different Delphi versions.
Item28=JvInterpreter_Quickrpt is based on Delphi3
Item29=and contains code for Delphi2
Item30=and CBuilder1, but this code not
Item31=complete, because we don't have
Item32=QuickReport 1 sources.

[Ole automation\Source]
Count=10
Item0=var
Item1="  MSW: Variant;"
Item2="  i: Integer;"
Item3=begin
Item4="  MSW := GetOleObject('Word.Basic');"
Item5="  MSW.AppShow;"
Item6="  MSW.FileNew;"
Item7="  MSW.Insert('JvInterpreter Demo !');"
Item8="  MSW := 0;"
Item9=end;

[How to import Delphi units]
Page=Empty

[How to import Delphi units\Description]
Count=17
Item0=You can create adapter units
Item1=manually, but it is not very
Item2=interesting.
Item3=
Item4=Use program Pas2JvInterpreter, placed in
Item5='RALib\Tools\Pas2JvInterpreter' folder to
Item6=automatically create JvInterpreter Adapters.
Item7=In most cases errors occured when
Item8=you try to compile created unit, so
Item9=you must manually correct it.
Item10=
Item11=Take a look at the adapter sources,
Item12=which are included in JVCL Library.
Item13=Those are good examples. All adapters
Item14=illustrate access to Delphi objects.
Item15=JvInterpreter_Windows shows access to
Item16=records and external functions.

[Running delphi forms]
Page=ExternalForm

[Running delphi forms\Description]
Count=12
Item0=TJvInterpreterFm component can create
Item1=delphi form from dfm-file, and load
Item2=assotiated pas-file.
Item3=Then it can show form, or you can
Item4=call any function from its pas-file.
Item5=
Item6=JvInterpreter attempts to load normal Delphi
Item7=pas-file and ignore all interface part.
Item8=
Item9=Click 'Run form...' and select
Item10='Unit1.pas'. Then try to interact
Item11=with form.

[Running delphi reports]
Page=ExternalReport

[Running delphi reports\Description]
Count=16
Item0=This sample is based on previous one
Item1=but loaded form is not shown.
Item2=We attempt to find QuickRep1 (for
Item3=QR2) or QuickReport1 (for QR1)
Item4=component on the form  and then
Item5=call its Preview method.
Item6=
Item7=Loaded form can contain its own
Item8=data access components or reference
Item9=to components in .exe forms or
Item10=data modules;
Item11=
Item12=Click 'Run report...' and select
Item13='QRUnit_D3_D4_B3.pas' or
Item14='QRUnit_D2_B1.pas' depending on
Item15=your Delphi versions.

[Running delphi units]
Page=ExternalUnit

[Running delphi units\Description]
Count=11
Item0=This is more efficient way
Item1=to work with Delphi forms.
Item2=
Item3=Delphi's pas/dfm file can be placed
Item4=in uses clause of JvInterpreter-script.
Item5=This allows to manipulate with
Item6=other form with standard Delphi manner
Item7=
Item8=Click 'Run unit...' and select
Item9='project1\project1.pas'.
Item10=Then try to interact with form.

[List of supported statements]
Page=Empty

[List of supported statements\Description]
Count=18
Item0=Now JvInterpreter supports following pascal
Item1=statements:
Item2="  - begin/end;"
Item3="  - var declaration;"
Item4="  - const declaration;"
Item5="  - if/then/else;"
Item6="  - for/do;"
Item7="  - while/do;"
Item8="  - repeat/until;"
Item9="  - break, continue;"
Item10="  - case;"
Item11="  - exit;"
Item12="  - try/finally;"
Item13="  - try/except/on;"
Item14="  - raise and raise <object>;"
Item15="  - assignment;"
Item16="  - function calls;"
Item17="  - uses clause;"

[Credits]
Page=Empty

[Credits\Source]
Count=1
Item0==>

[Credits\Description]
Count=13
Item0=JvInterpreter is fully written by us,
Item1=R&A Library authors.
Item2=
Item3=But some good ideas (no line
Item4=of code) was taken from
Item5='Delphin interpreter' by
Item6=Dream Company:
Item7="  www.dreamcompany.com"
Item8=
Item9=Many guys sent us bug reports and
Item10=fixes.
Item11=Andrej Olejnik has coded initial
Item12=array support in JvInterpreter.

[Our plans]
Page=Empty

[Our plans\Source]
Count=1
Item0==>

[Our plans\Description]
Count=13
Item0=Like all great product :) JvInterpreter
Item1=is always in development.
Item2=Now it contains most of things
Item3=we are need to.
Item4=And all that we do now are
Item5=we correct bugs.
Item6=
Item7=We very need you comments.
Item8=If you found JvInterpreter interesting
Item9=or have found any bug
Item10=please mail to us:
Item11=
Item12="  black@infa.ru."

