Home

Bigloo - Sophia Antipolis

1. 221 searching for source code 0 302 SECONdS gt dates icine bk wed el ens eked 94 SQCONdS gt StLING fice tal res 94 seconds utc string lesse 94 seed random eeri rere rees ineei 35 select Cunik ida aed EERE 187 SCHAA CHARS nit a wes ce AT E PROCERES des 63 SOMA a AA 63 Serialization i cia a IRE 68 SM aro a 19 Set ear ai PR EPI EA UR ELT 27 Set cdrl seco vene A dis che o T 27 set input port position 59 set output port position oooooo 59 E eL IP E TPE 222 Set read syntax ree dr eE 60 set repl printer o ao heiu ia ar pa ne 222 Std iaa ria a 77 Set ld a AA acon ren ant eo 77 shal ra ioe a tz 96 Shalsum eer A 96 Shadsu m file eo lead p eere ERR 96 shaisum mmap ess LesseslLe e heenephRe meg ads 96 Shafs msportz csss vere eene EV UP EE 96 Shaisum string 5 s eise sh rs s 96 sla2B6 x rre lan noi NEPPAEEERODENR 96 Sha256sulti a rh olas RW xu ad HEY 97 sha2lb6stm Lil cias ec eve Um 97 sha256sum mmap eee 97 sha2b6sum port ihe c4 v e OU ROT 97 sha256sum sString 6 cece cece eee 97 Shrink lada a nas 118 Signal 1 s a RE ees 75 SM te ce tad stelle a ates weave 36 Sinfl 5sssd rate Riera ba MN EOS 36 SLC SP iste re eeu Er RU OE ee 76 Socket support 00 0 eee eee eee ro 84 SOcket acCept ssec wale elise wing Beas 86 Socket client 7 iii Faved Hansen 85 SO cket CloSse vede xev Ver
2. 00 0 55 WITH AC lt beh EE m etus 178 MEAT bins O eed 63 Write Dyte xoti Sut e cp edes 63 WIlte Char sai ex Eee natty eR Ee dius 63 Chapter 35 Global Index Write circle 6m ve A a YER 65 Wri teases fusca A DA Re RUE us 202 Write pem key mir tb see wees 163 write pem key file eee 163 write pem key port cee eee eee eee ee 163 write pem key string eee 163 321 Z ZOO irene Seed ee hate Sd be RU RIMPa 33 Ze robx l2l2la4d R III l4 pel e a hak 33 z roelong qe A AA 33 ZOLOLLT e ai l9 n P RHOSHPE a ES 33 ZOTOLR a Ss kale t oNtes Se ha p x ONT I qe 33 zeroblong z30 22 510920 Beton Dnne NIE 33 ZIDS uu hup ente td Rae eet re etd 57 66 Chapter 36 Library Index 323 36 Library Index Index is nonexistent Bibliography 325 Bibliography e Bobrow et al 88 D Bobrow L DeMichiel R Gabriel S Keene G Kiczales and D Moon Common lisp object system specification In special issue number 23 in SIGPLAN Notices September 1988 e BoehmWeiserS8 H J Boehm and M Weiser Garbage collection in an unco operative environment Software Practice and Experience 18 9 807 820 Sept ember 1988 e Boehm91 H J Boehm Space efficient conservative garbage collection In Conference on Programming Language Design and Implementation number 28 6 in SIGPLAN Notices pages 197 206 1991 e Caml light P Weis and X Leroy Le langage CAML InterEditions P
3. 69 open input c string ee 57 Open Input Lile mitra a y Xv eS 56 open input ftp file oo o oo ooooooo 57 open input gzip file ce eee 57 open input gzip port esee 57 open input inflate file 67 open input procedure cece eee 58 Open inputostrindg oooooooooommmomooo 57 open inputostring oooooooommmmmooo 57 open input zlib file 0 cee 57 open input zlib port sese 57 Open MMap Chirino 65 open output binary file ooooooooo 69 open output file dni beta ad 58 open output procedure sess 59 open output string eene 58 OpenPGP siete TRI PRAG IF 163 operating system interface ooooooocooccooo 75 operatorn jo ios 18 OPt 1 ON ri c uev qe arate hee Saree wot ee e 12 OT Sa ert nas ge Sse ges ok E eret US ed 20 otat o god a PE uestes ease eue utt een sd Sd 76 os charBSet v u da adv tee as ia E Cte Tas SM 76 OS C1ASS a id 76 OS MAME a Goines 76 O A PERURT 76 OS VOTS OD ii Peek rfe I4 uter id 76 Chapter 35 Global Index OUtPUt CA o 69 QUEPULTOD laica a Ed la 69 output port close ho0k o ooooooooommmooo 54 output port close hook set 54 output port flush buffer 54 output port flush buffer set 54 output port flush ho0k o o ooooooomoooo 54 output port flush hook set 54 output port
4. lt integer gt lt re gt uncase lt re gt in lt cset gt out lt cset gt and lt cset gt lt cset gt but lt cset gt lt cset gt posix lt string gt lt variable gt gt lt symbol gt lt cset gt lt string gt char lt string gt lt char gt lt char gt Here is a description of each construction context lt symbol gt lt re gt This allows us to protect an expression A protected expression matches or accepts a word only if the grammar has been set to the corresponding context See Section 10 3 The Semantics Actions page 129 for more details when lt s expr gt lt re gt This allows us to protect an expression A protected expression matches or accepts a word only if the evaluation of lt s expr gt is t For instance define g let armed f regular grammar when not armed 4 or alpha set armed stt print start the string ignore in Space Tab ignore else the failure define main argv let port open input string bin sh bin zsh print read rp g port bol lt re gt Matches re at the beginning of line eol re Matches re at the end of line bof lt re gt Matches re at the beginning of file eof re Matches re at the end of file Chapter 10 Regular parsing 127 lt variable gt lt char gt lt str
5. rgc context context bigloo rgc procedure If no context is provide this procedure reset the reader context state That is the reader is in no context With one argument context set the reader in the context context For instance let g regular grammar context foo foo print foo bis foo rgc context foo print foo ignore else done p open input string foofoo read rp g p 4 foo foo bis Note that RGC context are preserved across different uses of read rp the context bigloo rgc procedure Returns the value of the current Rgc context 10 4 Options and user definitions Options act as parameters that are transmitted to the parser on the call to read rp Local defines are user functions inserted in the produced parser at the same level as the pre defined ignore function Here is an example of grammar using both define gram regular grammar x y define foo s cons foo x s ignore define bar s cons bar y s ignore Ha foo the string Hb bar the string else This grammar uses two options x and y Hence when invokes it takes two additional values such as with input from string aabb lambda read rp gram current input port option x option y foo option x aa bar option y bb 132 Bigloo 4 2b 10 5 Examples of regular grammar The reader who wants to find a real example should read the code of Bigloo s reader Bu
6. instantiate fthread body lambda print 1 thread yield print 2 name my thread The former thread start function can be rewritten as follow define make thread body name if pair name instantiate fthread body body name car name instantiate fthread body body thread start thread scheduler SRFI 18 function Runs a thread created with make thread If scheduler is provided the thread is started in this particular scheduler Otherwise it is started in the current sched uler see Section Section 16 2 2 2 Scheduler page 189 Threads are started at the beginning of reactions see Section Section 16 2 2 2 Scheduler page 189 thread yield SRFI 18 function The current thread cooperates That is it is suspended for the reaction and the scheduler selects a new thread to be resumed The scheduler resumes the next avali able thread If there is only one thread started in the scheduler the same thread is resumed A reaction corresponds to the invocation of a scheduler react call see Section Section 16 2 2 2 Scheduler page 189 thread sleep timeout SRFI 18 function The current thread cooperates during exactly timeout reactions see Section 16 2 2 2 Scheduler page 189 It is suspended and the scheduler selects a new thread to be resumed If there is only one thread started in the scheduler the same thread will be resumed let t1 instantiate fthread body lambda thread sleep
7. o ioscan aieaetine i pede 36 INOKAC HC ha Se PEELS Es at Bhai ISSUE 33 inflate sendchars 0c cece eee eee 67 inline procedure cece eee eee eee eee 15 input and output 0 cee eee eee eee 53 input char ys i038 hee o a e 69 input fill string oooooococooomomro 69 input obje rod taa praia 69 input port close hook cc eee eee 55 input port close hook set 55 input port length ccce 54 input port name eee eee 54 59 input port name set ooooccocccccccccc 54 input port position sees 59 input port reopen ssssss 55 59 input port timeout set 0 54 Input port enie reen he de ee iaa 53 Input String n ce aE REA Asawa E EE DE EE AS 69 inp t string port ln ril 53 installing the bee 0 0000008 299 instantiate iii 115 instantiate clasS c leeia ee ees eee es 115 instantiate fthread suus 184 instantiate pthread 0 192 int bits flo8t jzeicsspbssieddek ek 3T integer 5charf i e ceien sales iene poig 38 integer second esses eese 95 integer 5string iiu reia T 36 integer gt string padding 36 integer uc82 iria 39 Integer cao 2 ns peu ta aed es ae ER ele 32 interaction environment 221 internet ciu Soe ee gsi ce ease Sete es 100 Interpreting cociendo tele es
8. read lines input port bigloo procedure Accumulates all the line of an input port into a list read of strings input port bigloo procedure Reads a sequence of non space characters on input port makes a string of them and returns the string read string input port bigloo procedure Reads all the characters of input port into a string read chars size input port bigloo procedure read chars buf size input port bigloo procedure The function read chars returns a newly allocated strings made of size characters read from input port or from current input port if input port is not provided If less than size characters are available on the input port the returned string is smaller than size Its size is the number of available characters The function read chars fills the buffer buf with at most size characters read fill string so len input port bigloo procedure Fills the string s starting at offset o with at most len characters read from the input port input port or from current input port if input port is not provided This function returns the number of read characters which may be smaller than len if less characters are available or the end of file object The argument len is a small integer The function read fill string is similar to read chars except that it returns the end of file object on termination while read chars returns 0 Example let s make string 10 with input from stri
9. ucs2 string obj bigloo procedure bigloo procedure bigloo procedure bigloo procedure make ucs2 string k make ucs2 string k char ucs2 string k ucs2 string length s ucs2 ucs2 string ref s ucs2 k ucs2 string set s ucs2 k char bigloo procedure bigloo procedure bigloo procedure ucs2 string s ucs2a s ucs2b ucs2 string ci s ucs2a s ucs2b ucs2 string lt s ucs2a s ucs2b ucs2 string gt s ucs2a s ucs2b ucs2 string lt s ucs2a s ucs2b ucs2 string gt s ucs2a s ucs2b bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure ucs2 string ci lt s ucs2a s ucs2b ucs2 string ci gt s ucs2a s ucs2b ucs2 string ci lt s ucs2a s ucs2b ucs2 string ci gt s ucs2a s ucs2b subucs2 string s ucs2 start end ucs2 string append s ucs2 ucs2 string gt list s ucs2 list gt ucs2 string chars bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure Chapter 5 Standard Library 45 ucs2 string copy s ucs2 bigloo procedure ucs2 string fill s ucs2 char bigloo procedure Stores char in every element of the given s ucs2 and returns an unspecified value ucs2 string downcase s ucs2 bigloo procedure Builds a newly allocated ucs2 string with lower case letters ucs2 string upcase s ucs2 bigloo procedure Builds a new allocated ucs2 string with upper case letters ucs2 string dow
10. 0 269 31 Compiler description 271 ALI C requirement eer ee 8 ce edi Reuter EYE ETE 271 31 2 JVM requirement eeeeeleee een 271 31 3 Running NET programs on Microsoft NET platforms 271 SAS Ema ae 271 31 5 The compiler environment and options ssssesss 272 3L5 l Efficiency c oes td la a 272 31 5 2 Stack allocation 0 00 cece eee eee eee 272 31 5 3 Genericity of arithmetic procedures 4 272 SUDA Safety sic AS 272 31 5 5 The runtime command file 0 0 273 31 5 6 The Bigloo command line 0 0 c cee eee 273 32 Cross Compilation Luuuuuu 293 32 1 Introducti n 2er osse as 293 32 2 Building the Bigloo library for the host platform 293 92 21 Most he scs A ERSDLDE P ESRUR E 293 32 22 Building zie eC REED Ev eEREER NE NS 294 32 3 Cross Compiling Bigloo Programs 000e eee 294 92 4 QAVeBlS ccs eee v oett Ee p UposEF hae foe pb 294 92 5 Examples cse de Ee e et tte S REC a 295 33 User Extensions uuueeeee 297 33 n User PIS ees err nre ae EE E E a assem sets 297 viii 34 Bigloo Development Environment 299 34 1 Installing the BEE 0 cen eee 299 34 2 Entering the Bee 0c cece cee ere 300 34 3 The Bee Root Directory 0 60 c ccc cnn e 300 34 4 Building a Makefile 00 cece 300 34 5 Compiling 2 2 4 A a 30
11. 5 7 5 1 SSL Sockets Bigloo defines SSL sockets on systems that support them as first class objects SSL Sockets permits processes to communicate even if they are on different machines securely via encrypted connections SSL Sockets are useful for creating secure client server applications ssl socket obj SSL library procedure Returns t if an only if obj is a SSL socket either client or server Returns f otherwise make ssl client socket hostname port number key SSL library procedure buffer t timeout 0 protocol sslv23 cert f pkey f CAs Y accepted certs f make ssl client socket returns a new client socket object This object satisfies the Socket predicate see Section 5 7 4 Socket page 84 can be used in any context where a socket created by make client socket can be used A SSL client socket establishes a link between the running application client and a remote application server listening on port port number of hostname Tf optional argument bufsiz is lesser or equal to 1 then the input port associated with the socket is unbuffered This is useful for socket clients connected to servers that do not emit Newline character after emissions The optional argument buffer can either be e positive fixnum this gives the size of the buffer e The boolean stt a buffer is allocated e The boolean f the socket is unbufferized e A string it is used as buffer If the optional argument timeout is 0
12. TO get prompter reme iie eers RR II ERREUR 222 Eget protocOl ai ee unb O Ve pe MER 89 EGt protocolsS secs A in 89 Chapter 35 Global Index get signal handler 00005 75 get trace stack serene prai ia das EAR 171 Petenv uo deu ceti eee tbc ed 75 getgide ryan i ADSL Ri eh dA DS 77 EStgErOUpS ini eye cent a die Meee es 77 getpido c A heen 77 gBetppidic vere yet tua ein yee dee eames 77 Betprop ise Meats eee bh eae 31 Pet pwnaMm Ni 77 getpwild i o horita a nodo 77 getuldi ii eon aggere ua en MU eh aon lle slate a 77 LUNA Prod a as ER EUIS 66 gunzip parse header ooococcoccccccccccccc 67 gunzip sendchars ccc eee 67 PAI eet uae the e abet tay at 57 66 hardware fixnum 0 ese eee eee 32 hashtable list sese eese 73 hashtabl vector d soeben alo Sohne cere 73 hashtable add iii acia 73 hashtable contains sees 73 hashtable filter sess recuse nese bees 74 hashtable for each 0 cece eee 74 hashtable get 0 cece eee eee een eens 73 hashtable key list oooooooooococmcmmmmo 73 hashtable Map ecos tdi tees does 74 hashtable put z i uper ERE E XS 73 hashtable remove eee 73 hashtable size coco cia ld 73 hashtable update eee 73 hashtable weak data o oooooooooocommmmmoo 73 hashtable weak keys ooooooooooommmmmmooo 73 hashtable taria tapes 72 hmac md5sum string cece e
13. The second element should be a string that denotes additional parameter Example http host localhost port 8080 method post header enctype multipart form data args x foo foo scm filename foo scm nContent type application octet stream E An http connection blocks until the connection is established If the optional argu ment timeout is provided the connection must be established before the specified time interval elapses The timeout is expressed in microseconds http read line input port bigloo procedure http read crlf input port bigloo procedure Reads a line or an end of line of an HT TP response http parse status line input port bigloo procedure Parses the status line of an HTTP response This returns a three values e The http version e The status code e the explanation phrase http parse header input port output port bigloo procedure Parses the whole header of an HTTP response It returns multiple values which are e the whole header as an alist e the host given in the host header e the port given host field e the optional content length header field e the optional transfer encoding header field e the optional authorization header field e the optional proxy authorization header field e the optional connection header field Chapter 5 Standard Library 103 http parse response input port output port procedure bigloo procedure Parses the whole response of
14. p2 instantiate pthread body lambda Sets the thread s specific scheduler default scheduler s2 3 One reaction for s2 scheduler react Starts si thread start joinable p1 Do three reactions scheduler start 3 Waits for p1 s1 termination thread join p1 The final reaction scheduler react thread start fla s1 thread start fib s1 thread start f2a s2 thread start f2b s2 thread join thread start joinable p2 Chapter 17 Database 197 17 Database Bigloo supports database programming The current version proposes a SQLite binding 17 1 SQLite The Bigloo s C back end supports SQL queries It relies on the SQLite library http www sqlite org The SQLite binding is accessible to Bigloo via the sqlite library Here is an example of module that uses this library module examplel library sqlite let db instantiate sqlite sa sqlite Bigloo Sqlite class class sqlite path bstring read only default memory The instances of the class sqlite hold SQLite databases A database may be perma nently stored on a disk or loaded in memory The class attribute path is the location on the disk where the database is stored The special path memory denotes in memory databases When an instance is created a SQLite database is opened Example define dbi instantiate sqlite path tmp foo db define db2 instantiate sqlite Binds the g
15. set n n 1 n let g gen counter eqv g g eqv gen counter define gen loser lambda let n 0 gen counter lambda set n n 1 27 let g gen loser eqv g g gt eqv gen loser gen loser letrec f lambda g lambda equ f g letrec f lambda g lambda equ f g equ a a equ a a gt unspecified unspecified unspecified unspecified t f t unspecified O if equ f g both f O if equ f g both g gt O if equ f g O if equ f g g gt gt gt unspecified gt both gt both f unspecified unspecified Chapter 5 Standard Library equ b cdr a b let x a eqv equal objl obj2 equal equal equal equal equal equal equal x x a a a a a b c a b c abc abc 2 2 make vector 5 a make vector 5 a lambda x x lambda y y y y Y y 44L yu See Section r5rs info in R5RS for more details 5 1 3 Pairs and lists The form is illegal pair obj cons ad pair or null obj Returns t if obj is either a pair or the empty list Otherwise it returns f car pair cdr pair set car pair obj set cdr pair obj caar pair cadr pair cadar pair caadr pair caaar pair caddr pair cadar pair cdddar pair cddddr pair
16. string fill string char bigloo procedure Stores char in every element of the given string and returns an unspecified value string downcase string bigloo procedure Returns a newly allocated version of string where each upper case letter is replaced by its lower case equivalent string upcase string bigloo procedure Returns a newly allocated version of string where each lower case letter is replaced by its upper case equivalent string capitalize string bigloo procedure Builds a newly allocated capitalized string string downcase string bigloo procedure Physically downcases the string argument string upcase string bigloo procedure Physically upcases the string argument string capitalize string bigloo procedure Physically capitalized the string argument Chapter 5 Standard Library 43 string for read string bigloo procedure Returns a copy of string with each special character replaced by an escape sequence blit string stringl ol string2 o2 len bigloo procedure Fill string string2 starting at position o2 with len characters taken out of string string from position ol let s make string 20 blit string toto O s 16 4 s A E ca toto string replace string charl char2 bigloo procedure string replace string charl char2 bigloo procedure Replace all the occurrence of char1 by char2 in string The function string replace returns a newly allocated string The function string replace mo
17. type struct struct idi typel name1 dais tjpen namen The following functions are created e A creator struct struct type 1 type n This function allocates a fresh struct in the same heap as any Scheme value and fills the fields of the C structure with the proper values provided in the call e A type checker struct bool obj obj This function returns t if and only if the argument obj is of type struct e A null checker struct null bool struct This function returns t if and only if its argument is Null e A null creator Chapter 26 The C interface 237 make null struct struct This function creates a NULL value of type struct e Anequality checker sstruct bool struct struct This function returns t if and only if its arguments are equal e Accessors and mutators struct id 1 type 1 struct struct id 1 set obj struct type 1 These functions read and store field values Here is an example of structure usage module foo extern include named point declaration h type named point struct x double x y double y name string name struct named point c print point int named point ppoint define scheme print point point print point name point x named point x point y named point y point let orig named point 0 0 0 0 orig if named point null orig error bigloo cannot a
18. unsafe type Runtime type safety default f unsafe version Module version safety default f user heap size Heap size in MegaByte or f for default value default 0 user inlining User inlining optimization default t 291 292 Bigloo 4 2b user pass The user specific compilation pass default H unspecified verbose The verbosity level default 0 warning overriden slots Set to t to warn about virtual slot overriding default t warning overriden variables Set to t to warn about variable overriding default f warning types Set to t to warn about type checks default f with files The additional modules default Chapter 32 Cross Compilation 293 32 Cross Compilation Bigloo is very portable and can be cross compiled for most Posix platforms As long as there exists a C cross compiler for the platform and the garbage collector is supported on the targeted platform there is a good chance that Bigloo or Bigloo compiled programs will run on the platform This chapter describes how to cross compile Bigloo with a C cross compiler Follow ing established conventions we will call the platform where the compiled programs should run the Host platform and we will call the build platform where we actually compile the programs the Build platform 32 1 Introduction We assume that the host and build system are not the same and that there exists a C cross co
19. x bar a b a gt bar 1 Tn the cases of pattern matching in lists and vectors not in structures for the moment 106 Bigloo 4 2b 6 2 The pattern language The syntax for pattern is pattern gt Matches atom the atom kwote lt atom gt any expression eq to atom and pati lt patn gt ifallof pati match Cor pati lt patn gt if any of pati through lt patn gt matches not lt pat gt if pat doesn t match lt predicate gt if predicate is true lt pati gt lt patn gt a list of n elements Here isa meta character denoting a finite repetition of patterns lt pat gt a possibly empty repetition of pat in a list lt pat gt lt patn gt a vector of n elements lt struct gt pat a structure id anything and binds id as a variable anything any possibly empty repetition of anything in a list any end of list Remark and or not check and kwote must be quoted in order to be treated as literals This is the only justification for having the kwote pattern since by convention any atom which is not a keyword is quoted matches any s expr a matches the atom a a matches any expression and binds the variable a to this expression integer matches any integer a a b matches the only list a a b can only appear at the end of a
20. 1 2 3 4 0 4 gt 1 2 3 4 vector copy 1 2 3 4 1 3 gt 2 3 vector copy target tstart source sstart send bigloo procedure Copies a block of elements from source to target both of which must be vectors starting in target at tstart and starting in source at sstart ending when send sstart elements have been copied It is an error for target to have a length less than tstart send sstart Sstart defaults to 0 and send defaults to the length of source See Section 5 1 11 r5rs info page 47 for more details vector append vector bigloo procedure Returns a newly allocated vector that contains all elements in order from the subse quent locations in vector Examples vector append x y gt y vector append a b c d gt a b c d vector append a b c gt a b c vector map proc vector bigloo procedure vector map proc vector bigloo procedure The function vector map creates a new vector whose size the is the size of its ar gument vector Each elements of the new vector is the result of apply proc to the corresponding elements of the initial vectors The function vector map modifies the elements of the argument vector 5 1 12 Homogeneous Vectors SRFI 4 Bigloo fully supports SRFI 4 specification of homogeneous vectors see http srfi schemers org srfi 4 srfi 4 html Each homogeneous vector is represented by a Bigloo
21. 1 x list 1 2 3 0 gt 234 begin expression expression library syntax define x 0 begin set x 5 x 1 gt 6 22 Bigloo 4 2b begin display 4 plus 1 equals display 4 1 gt unspecified 4 plus 1 equals 5 do variable init step test expression body library syntax do vec make vector 5 i 0 i 10 i 5 vec vector set vec i i gt 0 1 2 3 4 let x 1 3 57 9 do x x cdr x sum O sum car x null x sum gt 25 delay expression library syntax quasiquote template syntax template syntax list 1 2 4 gt list 3 4 let name a list name name gt list a quote a a 1 2 map abs 4 5 6 b gt a3 45 6b foo 10 3 cdr c car cons gt foo 7 cons 10 5 sqrt 4 map sqrt 16 9 8 gt 10 5 2 4 3 8 a b 1 2 foo 1 3 d e f gt a b 1 2 foo 4 d e f let namel x name2 y a b namei name2 d e gt a b x y d e quasiquote list unquote 1 2 4 gt list 3 4 gt quasiquote list unquote 1 2 4 gt list 1 2 4 i e quasiquote list unquote 1 2 4 3 1 3 Definitions Global bindings are introduced by the define form define variable expression syntax define variable arg body syntax define add3 l
22. Chapter 15 Errors Assertions and Traces 15 5 Tracing Bigloo provides a trace facility whose is intended for simple debugging tasks It is a re placement for user displays that clutters the source code Here is a typical example using it define foo x with trace 1 foo let loop n x with trace 2 loop trace item n n when gt n 0 let liip m n with trace trace item m m 2 liip when gt m 0 liip loop n 1 foo 3 foo loop n 3 m 1 which produces the following output liip I m 3 liip I m 2 liip I m51 liip m 0 loop 153 2 liip m 2 liip m 1 liip m 0 loop n 1 liip l m 1 liip m 0 loop n 0 177 Traces generation is controlled by a set of functions and parameters see Chapter 24 Parameters page 229 The functions are described in this chapter 178 Bigloo 4 2b with trace level label body bigloo syntax The variable level is the level of a trace It is a positive integer It enables simple filtering for traces A trace is displayed if and only if the debugging level used to compile or to execute the program is greater than the trace level The variable label is a label e i an identifier denoting the trace This identifier will be displayed in debug mode The variable body is the body of the form that
23. Denotes union of characters Characters may be described individually such as in in Ha Hb c Had They may be described by strings The expression in abcd is equivalent to in Ha b c Hd Charac ters may also be described using a range notation that is a list of two characters The expression in a d is equivalent to in Ha b c Hd The Ranges may be expresses using lists of string The ex pression in ad is equivalent to in Ha b c Had Chapter 10 Regular parsing 129 out lt cset gt The language described by out cset is opposite to the one de scribed by in cset For instance out azAZ 0 9 ac cepts all words of one character that are neither letters nor digits One should not that if the character numbered zero may be used inside regular grammar the out construction never matches it Thus to write a rule that for instances matches every character but Newline including the character zero one should write or out Newline a000 and lt cset gt lt cset gt The language described by and cseti cset2 accepts words made of characters that are in both cset1 and cset2 but lt cset gt lt cset gt The language described by but cseti cset2 accepts words made of characters of cset1 that are not member of cset2 posix lt string gt The expression posix string allows one to use Posix string notation for regular expressions So for example the following two
24. NET requirement 2 cece eee eee 271 OE eee EAN 35 PORE RSet Deter eRe hha DDD 35 LO a 35 NOR 35 PER A NI 35 TIlong 1 RI AI AAA RES 35 lt A A ae 34 CM 34 E lia e 34 A ed b ug ZR E RIDE 34 SSE ihe sree tate tata ue pM ERE REA NOE ERES 34 ono JM CP TL E 34 EIlong resist ya ec i geDUrtr x xk EU DRUCKEN 34 Mod T 34 constant eoi us ct Aet ot I Eua 18 306 COLOM ii A TW e 34 KEW cee O Piet d sire ath 34 o PE 34 Lbl ng cce a Sa es 34 yatiable cz etes i ls BV Tare 18 PEE 34 Dictate A A NN 34 SS 5 5 RN 34 O Ao 34 ii tic dle te ha deus a 34 SVL ONG A 34 gt Pale ahane Mmee tess ds es ee 34 E Maen ee ee reet ap E ak ES 34 S SbX iisisi s ua aakildaueeR rg a IRE DEIERS IA 34 2zelong oce eg IAN I EP IE ed Deas 34 A ene QE Pci 34 Sf RK own i Seat ecw db x bent n vada ees es 34 AAA egi rfi l4 iege p b4lis 34 O ace decies med 34 POLON Bs mao deeribstrte sie 34 dt ur im Rc md 34 o M ens seti e doped T on 34 A PO a 34 a A we Slat da ana See 15 6 ptu eur P t E tuna A ti ure 22 Sbitss2utf8 vci N s 46 BITS AMEES e a A idee i xc 46 A a simple example of Lalr 1 parsing 138 A complete library example 258 A new way Of reading ooooococcoccncrnco 125 abandoned mutex exception 191 ADS iret tia a tins thaws er xe EI RET E 35 ADSL to paras ie 35 abstract claSS eee hr e rn 113 Acknowledgements 000ee ee eee eee eee 1 ACOS e
25. foo bar gt foo bar sqlite format q foo bar gt foo bar sqlite format a foo bar foo gt foo bar foo sqlite format k foo bar foo gt foo bar foo sqlite format l foo bar foo gt foo bar foo sqlite exec sqlite string arg Bigloo Sqlite function The function sqlite exec erecutes an SQLite command The command is the built by implicitly invoking sqlite format on string and the optional arg arguments This function returns a single element the first one returned by the SQL engine Example module example library sqlite define db instantiate sqlite sqlite exec db CREATE TABLE foo x INTEGER y INTEGER for each lambda x sqlite exec db INSERT INTO foo VALUES A A x x x iota 10 sqlite exec db SELECT FROM foo 9 sqlite eval sqlite procedure string arg Bigloo Sqlite function The function sqlite eval invokes a SQLite command built by implicitly invoking sqlite format on string and the optional arg arguments The result of the function is built by applying procedure to the first value returned by the SQLite call Note user callback procedure must not exit That is they must not invoke a function create by bind exit Exiting from a callback will leave the database in a inconsistent state that prevent transactions to be rolled back sqlite map sqlite procedure string arg Bigloo Sqlite funct
26. from from bigloo module clause from clauses have the syntax of import clauses The allow the re exportation of imported bindings That is any module can export any bindings imported via a from clause As an example suppose we have module bar module bar export fun define fun bar Now suppose we have a module foo that imports bar by the means of a from clause Module foo is able to re export the bar binding of module bar Chapter 2 Modules module foo from fun bar bar scm 11 A third module let s name it gee importing module foo can see the binding for function bar module gee import foo foo scm print fun This feature is very useful when compiling modules exporting functions with type annotations In particular one may write module foo export class c1 x Then module bar import foo from foo export fun c1 define fun instantiate c1 x 10 And module gee import bar main main define main x let o fun print o print c1 0 load load A load is a list of the form load gt lt lclause gt lt lclause gt gt lt module name gt lt file name gt lt module name gt bigloo module clause This clause forces Bigloo to load the module specified in the Iclause in the environment used by the macro expansion mechanism This means that the user s macros can use all the bindings of all
27. let mbox if network up instantiate imap socket instantiate maildir path my local cache mailbox close mbox mailbox separator mailbox Bigloo Mail procedure Returns a string denoting the separator commonly or used by the mailbox mailbox prefix mailbox Bigloo Mail procedure Returns the prefix of the mailbox a string or f mailbox hostname mailbox Bigloo Mail procedure Returns the hostname of the mailbox a string or f mailbox folders mailbox Bigloo Mail procedure Returns a list of strings denoting the folder names of the mailbox mailbox folder select mailbox string Bigloo Mail procedure Selects one folder of the mailbox This function is central to mailboxes because all messages are referenced relatively to the folder selection All the functions that operates on uid implicitly access the current folder selection mailbox folder unselect mailbox Bigloo Mail procedure Unselects the mailbox current selected folder mailbox folder create mailbox folder Bigloo Mail procedure Creates a new folder denotes by a fully qualified name Example mailbox create mbox INBOX scheme bigloo Chapter 19 Mail 213 mailbox folder delete mailbox folder Bigloo Mail procedure Deletes an empty folder mailbox folder rename mailbox old new Bigloo Mail procedure Renames a folder mailbox folder move mailbox folder dest Bigloo Mail procedure Moves the folder into the destination folder dest
28. null obj list obj list obj length list append list append list A destructive append reverse list reverse list A destructive reverse unspecified t t t t t t t unspecified 27 library procedure procedure procedure bigloo procedure procedure procedure procedure procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure bigloo procedure library procedure bigloo procedure 28 list ref list k take list k drop list k list tail list k list ref returns the k element of the list take returns a new list made of the first k element of the list Bigloo 4 2b library procedure library procedure library procedure library procedure Drop and list tail returns the sublist of list obtained by omitting the first k ele ments last pair list Returns the last pair in the nonempty possibly improper list memq obj list memv obj list member obj list assq obj alist assv obj alist assoc obj alist remq obj list Returns a new list which is a copy of list with all items eq to obj remq obj list Same as remq but in a destructive way delete obj list eq equal bigloo procedure library procedure library procedure lib
29. release number 3 4b endianess little endian bigloo config endianess gt little endian bigloo config int size gt 61 register exit function proc bigloo procedure Register proc as an exit functions Proc is a procedure accepting of one argument This argument is the numerical value which is the status of the exit call The registered functions are called when the execution ends exit int bigloo procedure Apply all the registered exit functions then stops an execution returning the integer int signal n proc bigloo procedure Provides a signal handler for the operating system dependent signal n proc is a procedure of one argument get signal handler n bigloo procedure Returns the current handler associated with signal n or f if no handler is installed system strings bigloo procedure Append all the arguments strings and invoke the native host system command on that new string which returns an integer system gt string strings bigloo procedure Append all the arguments strings and invoke the native host system command on that new string If the command completes system gt string returns a string made of the output of the command getenv name bigloo procedure Returns the string value of the Unix shell s name variable If no such variable is bound getenv returns f If name is not provided getenv returns an alist composed of all the environment variables putenv s ring val bigloo proced
30. url path encode http tmp foo gt http 3A tmp foo url encode url bigloo procedure uri encode url bigloo procedure uri encode component url bigloo procedure Encode URL by removing any illegal character url encode http tmp foo gt http tmp 80 foo url encode http tmp foo amp bar http tmp 80 fo00426 Chapter 5 Standard Library 101 url decode url bigloo procedure url decode url bigloo procedure uri decode url bigloo procedure uri decode url bigloo procedure uri decode component url bigloo procedure uri decode component url bigloo procedure Decode a URL The function url decode may return its argument unmodified if no decoding is for the URL The variants component treat do not escape URI reserved characters i e Q amp and 5 13 HTTP http in 41 out 41 socket 741 bigloo procedure protocol http method get timeout 0 proxy f host localhost port 80 path login f authorization f username f password f http version HTTP 1 1 content type f connection close header user agent Mozilla 5 0 args body f Opens an HTTP connection Returns a socket It is an error to specify a header twice In particular it is illegal to re define keyword ed arguments in the header list For instance it is illegal to include in the header actual list value a value for the Connection HT
31. 0 9 pregexp match date re jan 1 1970 gt jan 1 1970 jan T 1970 pregexp match date re jan 1970 gt jan 1970 jan 1970 12 2 9 Backreferences Submatches can be used in the insert string argument of the procedures pregexp replace and pregexp replace The insert string can use An as a backreference to refer back to the nth submatch ie the substring that matched the nth subpattern XO refers to the entire match and it can also be specified as amp pregexp replace _ _ the nina the pinta and the santa maria NN I gt the nina the pinta and the santa maria pregexp replace 4 the nina the pinta and the santa maria x 1 the nina the pinta and the santa maria recall S stands for non whitespace character pregexp replace S S S eat to live NAS 2 41 gt live to eat 146 Bigloo 4 2b Use NN in the insert string to specify a literal backslash Also stands for an empty string and is useful for separating a backreference Nn from an immediately following number Backreferences can also be used within the regexp pattern to refer back to an already matched subpattern in the pattern Xn stands for an exact repeat of the nth submatch pregexp match a z and 1 billions and billions billions and billions billions Note that the backreference is not simply a repeat of the previous subpatt
32. 1 002 1 010 gt 1 string natural compare 1 010 1 02 gt 1 string natural compare 1 02 1 1 oad string natural compare 1 1 1 02 gt 1 string natural compare 1 02 1 3 gt 1 42 Bigloo 4 2b substring string start end library procedure string must be a string and start and end must be exact integers satisfying O lt START lt END lt string length STRING The optional argument end defaults to string length STRING substring returns a newly allocated string formed from the characters of STRING beginning with index START inclusive and ending with index END exclusive substring abcdef 0 5 gt abcde substring abcdef 1 5 gt bcde string shrink string end library procedure string must be a string and end must be an exact integers satisfying 0 lt END lt string length STRING string shrink returns a newly allocated string formed from the characters of STRING beginning with index 0 inclusive and ending with index END exclusive As much as possible string shrink changes the argument string That is as much as possible and for the back ends that enable it string shrink operate a side effect on its argument let s string Ha Hb c Hd e set s string shrink s 3 s abc string append string library procedure string gt list string library procedure list gt string list library procedure string copy string library procedure
33. 128 bits Bigloo supports the following block cipher modes mode e ecb Electronic codebook e cbc Cipher block chaining e pcbc Propagating cipher block chaining e cfb Cipher feedback e ofb Output feedback e ctr Counter By default cfb is chosen Electronic codebook mode en decodes each block independently and is hence the closest to the block cipher It is however inherently unsafe as blocks with the same content are encrypted to the same output With the exception of ecb all other modes can be initialized with an IV Initialization vector If IV is false then a random one will be generated During encryption this randomly generated IV will be prefixed to the result When calling the decryption routine without any IV the procedure will use the first block of the input as IV In ctr counter mode the IV parameter serves as nonce Two additional key parameters nonce init and nonce update are then used to initialize and update the block sized nonce string Before encrypting the first block nonce init will be invoked with an empty block sized string and the initial nonce IV It must initial ize the string with the nonce For each block nonce update will be called with the string the nonce and the number of already encrypted blocks hence 0 at the very beginning By default nonce init takes the IV string and blits it into the given string nonce update simply increments the string treating the given string as one big
34. 4 foo thread cleanup thread Bigloo function thread cleanup set thread fun Bigloo function Associates a cleanup function to a thread The cleanup function is called with the thread itself The cleanup function is executed in a context where current thread is the thread owning the cleanup function let t instantiate thread body lambda done foo thread cleanup set t lambda v print thread name current thread exit value v thread start t 4 foo exit value done thread parameter ident Bigloo function thread parameter set ident value Bigloo function Returns the value of the parameter ident in the current thread If no value is bound to this parameter f is returned A thread parameter is implemented by a chunk of memory specific to each thread All threads are created with an empty set of parameters The next functions have different behaviors depending in the library used more details will be given in the specific sections below thread start thread args SRFI 18 function thread start joinable thread Bigloo function thread join thread timeout SRFI 18 function thread terminate thread SRFI 18 function thread yield SRFI 18 function thread sleep timeout SRFI 18 function 16 1 2 Mutexes Thread locking mechanism is common to Fair Threads and Posix Threads mutex obj SRFI 18 function make mutex name SRFI 18 function mutex name mutex SRFI 18 function mutex spec
35. 59 Temple Place Suite 330 Boston MA 02111 1307 USA November 1995 e SerranoWeis94 M Serrano and P Weis 1 1 1 an optimizing Caml compiler In ACM SIGPLAN Workshop on ML and its Applications pages 101 111 Orlando Florida USA June 1994 ACM SIGPLAN INRIA RR 2265 e Steele90 G Steele COMMON LISP The language Digital Press DEC Burlington MA USA 2nd edition 1990 Chapter 37 Table of contents 327 37 Table of contents Table of Contents Acknowledgements 000 cece eee ee 1 1 Overview of Bigloo Luususuue 3 UM IER E T 3 1 2 Separate compilation sesssssesseeee eee eee 3 1 85 C mnterfaees s i oett ede A Eos o RN ad ideo xa 4 L4 Java interface oaar ios aa a Te a RR En EAS 4 1 5 Object language ense eens abe tuU PD nee eR Rea 4 1 6 Thread aia prine xxt nb EA aed E OR qu Ct 4 1 7 SO Ll RU Ee EE CEN RN VOU tr da 4 1 8 Type annotations censi eleEeCekevebalve de mete iE 4 1 9 Uricode support ziehe aie evi E REV ia IDer ati 5 1 10 DSSSLi cR pica 5 2 MVModiles cdd dios meta ra OR Rc otia eva Rants T 21 PrograntSUr cbLure Lud Re dee LES WE Ra 7 2 2 Module declarati0O oooooooccccoccccccnncccrn nr 7 2 3 Module initialization oocoooocccocooocccrnarncrnar nac 13 2 4 Qualified notati0N ooooccoooccccnnccnccnonncrrn ree 15 2 5 Inline procedures 0 00 eee eee ne 15 2 6 Module access file 00 cic cee ccc ene E T
36. 9 8 1 Structures There is in Bigloo a new class of objects structures which are equivalent to C struct define struct name field bigloo syntax This form defines a structure with name name which is a symbol having fields field which are symbols or lists each list being composed of a symbol and a default value This form creates several functions creator predicate accessor and assigner functions The name of each function is built in the following way e Creator make name e Predicate name e Accessor name field e Assigner name field set Function make name accepts an optional argument If provided all the slots of the created structures are filled with it The creator named name accepts as many argu ments as the number of slots of the structure This function allocates a structure and fills each of its slots with its corresponding argument If a structure is created using make name and no initialization value is provided the slot default values when provided are used to initialize the new structure For instance the execution of the program define struct pti a b define struct pt2 h 4 g 6 make pt1 gt HPT1 O O make pti 5 gt PT1 5 5 make pt2 gt PT2 4 6 make pt2 5 gt PT2 5 5 struct obj bigloo procedure Returns t if and only if obj is a structure 8 2 Records SRFI 9 Bigloo supports records has specified by SRFI 9 This section is a copy of the SRFI 9 s
37. Bigloo Multimedia procedure Set the comment of the EXIF metadata section of the file file name to text exif Bigloo Multimedia class class exif version default f jpeg encoding default f jpeg compress default f comment default f commentpos default f commentlen default f date default f make default f model default f orientation default landscape width default height default f ewidth default f eheight default f xresolution default f yresolution default f resolution unit default f focal length default f flash default f fnumber default f iso default f shutter speed value default f 202 Bigloo 4 2b exposure time default f exposure bias value default f aperture default f metering mode default f cdd width default f focal plane xres default f focal plane units default f thumbnail default f thumbnail path default f thumbnail offset default f thumbnail length default f The instance of the exif class maps the EXIF metadata found in JPEG files into Bigloo objects Since all fields are optional they are untyped exif date gt date Bigloo Multimedia procedure Parses an exif date i e a string of characters and returns corresponding date Raises an amp io parse error if the string does not represents an exif date whose syntax is given by the following regula
38. RFC 3447 allows other hash algorithms but they are not yet implemented RSAES OAEP encrypt key m str label Bigloo Cryptography procedure RSAES OAEP decrypt key cypher str label Bigloo Cryptography procedure RSASSA PSS sign key msg str Bigloo Cryptography procedure RSASSA PSS verify key msg str sig str Bigloo Cryptography procedure These functions pad mask etc the input string before they perform their operation on them See RFC 3447 for more information 14 2 2 Digital Signature Algorithm DSA Bigloo has rudimentary but usually sufficient support for DSA While it is not possible to generate new DSA keys inside Bigloo one can sign or verify with Bigloo DSA keys can be read and written using read pem Section 14 2 4 PEM page 162 For consistency with RSA we have named DSA keys in a similar way as the RSA keys The public part of a DSA key can be found in the class DSA Key while the private part is added in the Complete DSA Key subclass DSA Key Bigloo Cryptography class Complete DSA Key Bigloo Cryptography class class Dsa Key p bignum q bignum g bignum y bignum final class Complete Dsa Key Dsa Key x bignum the private key extract public dsa key complete key Bigloo Cryptography procedure Returns a DSA Key without the private x dsa sign m key Bigloo Cryptography procedure Signs the bignum m using the private dsa key key The result are two values r and S A typical call to ds
39. When executed within a JVM the form with handler also catches Java exceptions Chapter 15 Errors Assertions and Traces 173 Important note Since Bigloo version 3 2c error handlers are executed after the exe cution stack is unwound Hence error handlers are executed after protected blocks For instance in the following code with handler lambda e action unwind protect body protect The action is executed after protect raise obj SRFI 18 function Calls the current exception handler with obj as the single argument obj may be any Scheme object Note that invoking the current handler does not escape from the current computation It is up the to handler to perform the escape It an error signaled by the runtime system if the current exception handler returns define f n if lt n 0 raise negative arg sqrt n define g bind exit return with exception handler lambda exc return if string exc string append error exc unknown error lambda write f 4 write f 1 write f 9 g 4 2 and returns error negative arg The standard Bigloo runtime system uses the following classes for signaling errors and warnings e amp exception which is defined as class amp exception fname read only default f location read only default f e amp error defined as class terror amp exception proc read only msg read only obj read only e a
40. and request a password to decrypt the private part of the subkey If the message can be decrypted with a password Bigloo will then request a passkey by invoking the passkey provider The optional arguments hash algo and symmetric algo are only used for messages that have been encrypted with pgp password encrypt pgp sign msg string key password provider Bigloo OpenPGP procedure detached signature t 0ne pass f hash algo sha 1 Signs msg string with the given key Ideally the key should be a subkey but if a complete PGP Key is given Bigloo will use the main key instead If the main key is not suitable for signing then an error is raised If the private part of the key has not yet been decrypted then Bigloo will call the password provider a procedure with the subkey to get a password a string The function returns a PGP composition If the optional detached signature parameter is set to f then the msg string is not included in the returned composition The one pass and hash algo parameters are usually left at its default values Example let my key car pgp read file my key pgp pgp write file msg sig pgp sign my signed message my key lambda key my password detached signature f pgp verify signature key manager msg 1 Bigloo OpenPGP procedure Verifies a signature The key manager is a function that takes a substring identifier and returns a list of keys matching this id S
41. consisting of the two bignums c1 and c2 with the given private key elgamal key length key Bigloo Cryptography procedure Returns the key length in bytes ElGamal works very similar to RSA Have a look at RSA s example section 14 2 4 PEM Bigloo is able to read and write RSA and DSA keys in PEM format This is the default format used by OpenSSL The following example creates a new DSA key pair in OpenSSL and stores it in PEM format openssl dsaparam 1024 out tmp dsaparam openssl gendsa tmp dsaparam read pem key in Bigloo Cryptography procedure read pem key port input port Bigloo Cryptography procedure read pem key file filename Bigloo Cryptography procedure Chapter 14 Cryptography 163 read pem key string str Bigloo Cryptography procedure These functions will read a PEM encoded key The encoded file may contain a private or public RSA key or a private or public DSA key The procedure read pem key accepts input ports and strings In the case of a string it will invoke read pem key file and not read pem key string write pem key key out public key only Bigloo Cryptography procedure write pem key port key out public key only Bigloo Cryptography procedure write pem key file key out public key only Bigloo Cryptography procedure write pem key string key public key only Bigloo Cryptography procedure These functions write the given key The key may be a private public RSA DSA key The procedure
42. e bigloo lt major release gt e bigloo lt major release gt lt minor release gt When a library is used the name of the library is added to the compiler SRFI register That is module foo library srfi1 print cond expand srfil with srfil else nothing d with srfil print eval cond expand srfii with srfil else nothing 4 with srfil A property representing actual integers bit size is defined e bint lt integers bit size gt e elong lt exact long bit size gt The frequently defined values are e bint30 32 bits architectures e g x86 e elong32 32 bits architectures e g x86 e bint32 JVM e elong64 JVM e bint61 64 bits architectures e g x86_64 e elong64 64 bits architectures e g x86_64 Other values could be observed in the future Note that the actual values of a par ticular setting can be obtained with bigloo config int size bigloo config elong size register eval srfi srfi name bigloo procedure This argument srfi name is a symbol It registers srfi name in the Bigloo interpreter SRFI register This function must only be used when implementing a library The code of that library must contain one unique call to register eval srfi Let s suppose for instance a format library The implementation for that library must contain an expression like register eval srfi format Calling register eval srfi name makes name supported by interpreted cond expand for
43. f and returns f otherwise boolean f gt t boolean 0 gt f boolean 0 gt 5 1 2 Equivalence predicates eqv objl obj2 procedure eq objl obj2 procedure eqv and eq are equivalent in Bigloo eq a a gt t eq a a gt unspecified eq list a list a gt f eq a a gt unspecified eq gt unspecified eq 0 0 gt t eq 2 2 gt unspecified eq A A gt unspecified eq car car gt dt let n 2 3 eq n n gt unspecified 26 let x a eq x x let x 0 eq x x let p lambda x eq p p gt gt x gt Bigloo 4 2b t t t Since Bigloo implements eqv as eq the behavior is not always conforming to R5RS eqv a a gt eqv a b gt eqv 2 2 gt eqv O O gt eqv 100000000 100000000 gt eqv cons 1 2 cons 1 2 gt equ lambda O 1 lambda 2 eqv tf nil gt let p lambda x x eqv p p gt t f t t t f f f unspecified The following examples illustrate cases in which the above rules do not fully specify the behavior of eqv All that can be said about such cases is that the value returned by eqv must be a boolean eqv nn n equ O 0 eqv lambda x x yy lambda x x eqv lambda x x lambda y y define gen counter lambda let 0 lambda
44. gt ieee string z float gt ieee string z Returns a big endian representation of the given number bigloo procedure bigloo procedure Chapter 5 Standard Library 37 string gt number string radix 10 procedure string gt real string bigloo procedure string gt elong string radix bigloo procedure string gt llong string radix bigloo procedure string gt bignum string radix bigloo procedure Bigloo implements a restricted version of string gt number If string denotes a floating point number then the only radix 10 may be send to string gt number That is string gt number 1243 16 gt 4675 string gt number 1243 0 16 4 ERROR bigloo string gt number Only radix 10 is legal for floating point number 16 string gt elong 234456353 gt e234456353 In addition string gt number does not support radix encoded inside string That is string gt number x1243 gt df octet string gt bignum string bigloo procedure Counterpart to bignum gt octet string Takes the bignum representation in big endian format string and returns the corresponding bignum octet string gt bignum bignum gt octet string z1234 gt 21234 ieee string gt double string bigloo procedure ieee string gt float string bigloo procedure Convert the big endian representations to their numeric values fixnum gt flonum i bigloo procedure flonum gt fixnum r bigloo procedure elong gt fixnum i bigloo procedure
45. if present is selected if none of the previous clauses is selected A feature requirement has an obvious interpretation as a logical formula where the variables have meaning true is the feature corresponding to the feature identifier as specified in the SRFT registry is in effect at the location of the cond expand form and false otherwise A feature requirement is satisfied it its formula is true under this interpretation The formula may make use of identifier and or and not operators Since Bigloo version 3 1b cond expand formula may use the new library operator that checks if a library exists and is available Its syntax is library lt libname gt Examples write cond expand srfi 0 1 2 Cor library fthread library pthread 4 1 else 3 4 42 cond expand bigloo define command line arguments command line else define command line arguments The second example assumes that bigloo is an alias for the SRFI associated with the specification of Bigloo i e the documentation for that Scheme system 266 Bigloo 4 2b Since Bigloo 3 4b cond expand formula may use the new config operator that checks the value of a configuration entry Its syntax is config endianeness little endian This feature relies on the bigloo config function See Section 5 7 System Programming page 74 for additional details When writing portable code the case used for the feature identifier should match
46. mailbox subscribe mailbox folder Bigloo Mail procedure mailbox unsubscribe mailbox folder Bigloo Mail procedure Subscribe unsubscribe to a folder This allows imap servers not to present the entire list of folders Only subscribed folders are returned by mailbox folders These functions have no effect on maildir servers mailbox folder exists mailbox folder Bigloo Mail procedure Returns stt if and only if folder exists in mailbox Returns f otherwise mailbox folder status mailbox folder Bigloo Mail procedure Returns the status of the folder A status is an alist made of the number of unseen mail the uid validity information the uid next value the number of recent messages and the overall number of messages mailbox folder uids mailbox Bigloo Mail procedure Returns the list of UIDs a list of integers of the messages contained in the currently selected folder mailbox folder dates mailbox Bigloo Mail procedure Returns the list of dates of the messages contained in the currently selected folder mailbox folder delete messages mailbox Bigloo Mail procedure Deletes the messages marked as deleted of the currently selected folder mailbox folder header fields mailbox field Bigloo Mail procedure Returns the list of headers fields of the message of the current folder mailbox message mailbox uid Bigloo Mail procedure Returns the message uid in the current folder mailbox message path mailbox uid Bigloo Mail procedure
47. name string fname string sex symbol read only wide class married man person mate person Chapter 9 Object System 119 wide class married woman person maiden name string mate person As we can see people are allowed to change their name but not their sex The identity of a person can be printed as define method object display p person op with access person p name fname sex print firstname fname print name name print sex sex p A married woman s identity is printed by we suppose an equivalent method definition for married man define method object display p married woman op with access married woman p name fname sex mate call next method print married to mate p We create a person with the birth function define birth name string fname string sex assert sex memq sex male female instantiate person name name fname fname sex sex We celebrate a wedding using the get married function define get married woman person man person if not and eq gt woman sex female eq gt man sex male error get married Illegal wedding cons woman man let mname gt woman name wife widen married woman woman maiden name mname mate man person name set wife gt man name widen married man man mate woman We can check if two people are married by define couple woman pers
48. safee mkaddlib cc gcc fsharing q rm unsafev bformat scm o bformat_u o c bigloo O3 mkaddlib g cg cc gcc N fsharing q rm N unsafev bformat scm o bformat o c The first compilation produces the unsafe version the second the produced the debug ging version The third step is to build the host operating system libraries There is no portable way to do this This operation may looks like ar qcv libbigloobformat_s 1 0 a bformat o ranlib libbigloobformat s 1 0 a ld G o libbigloobformat s 1 0 so bformat o lm lc ar qcv libbigloobformat_u 1 0 a bformat_u o ranlib libbigloobformat_u 1 0 a ld G o libbigloobformat_u 1 0 so bformat u o lm lc The fourth step consist in creating the bformat_es and bformat_eu libraries for eval For the unsafe version we use bigloo O3 unsafe safee mkaddlib cc gcc fsharing q rm unsafev make lib scm o make_lib o c ld G o libbigloobformat_eu 1 0 so make_lib o Im lc Chapter 28 Bigloo Libraries 257 ar qcv libbigloobformat_eu 1 0 a make_lib o ranlib libbigloobformat_eu 1 0 a For the safe version we do bigloo O3 mkaddlib N cc gcc fsharing q rm N unsafev make lib scm o make lib o c ld G o libbigloobformat es 1 0 so make_lib o lm lc ar qcv libbigloobformat_es 1 0 a make_lib o ranlib libbigloobformat_es 1 0 a e The last step is to create an initialization file bformat init declare library bformat version 1 0 srfi bformat ba
49. sese 96 base64 encode 1 eee eee eee eee 96 base64 encode port 0 eee eee 96 basename tees ies tas elas en ace ae dad 77 begins isis tered Ska ae hee ere ERA eee ieu 21 beglafile aa ei 16 Da DU Ck A E E E E E E 217 ibtex fil n pi ee eed 217 bibtex parse authors eese 217 bibtex port ii 4 eer ai 217 bibtex String 6 cece eee eee 217 bigloo development environment 299 bigloo variable 005 219 220 bigloo class demangle 243 bigloo class mangled Lus 243 bigloo compiler debug 229 bigloo compiler debug set 229 bigloo GOnfig oue ve a UH 75 bigloo debug cece cece 229 bigloo debug set 0 cece eee eee 229 Chapter 35 Global Index bigloo demangle ccc eee 243 bigloo dns cache validity timeout 230 bigloo dns cache validity timeout set 230 bigloo dns enable cache 230 bigloo dns enable cache set 230 bigloo eval strict module 221 230 bigloo eval strict module set 230 bigloo library path e tr 254 bigloo library path set 254 bigloo mangle 6 cece eee 242 bigloo mangled cece cece eee eee 243 bigloo module mangle 000 242 bigloo need mangling 006 243 bigloo strict rbrs strings
50. the regular grammar used with an Lalr 1 grammar should follow some conventions e If a semantic value is to be associated with the token just parsed the regular grammar should return a pair whose car is the token name a symbol and the cdr is the semantic value e If there is no value associated with the token the regular grammar can return just the token name When used in conjunction with an Lalr grammar regular grammar should never return f as a token value This is specially true when the regular grammar detects the end of parsing In that case the regular grammar must not return the f value good way to handle end of file is illustrated in the following example let g regular grammar else let c the failure if eof object c c error rgc Illegal character c 1 lalr grammar read lalrp 1 g current input port This way the Lalr grammar will automatically handles the end of file 138 Bigloo 4 2b 11 5 Debugging Lalr Grammars Currently the debugging facility for debugging Lalr grammars is very limited When the parameter bigloo debug is set to a value greater or equal to 100 the Lalr engine outputs all of the state changes the parser is going through 11 6 A simple example Here is the code for a simple calculator implemented by an Lalr 1 grammar begin read lalrp lalr grammar nl plus mult minus div const lpar rpar lines CO lines expression nl lin
51. unserialize procedures User may specify there own procedure serializer and unse rializer This is the role of register procedure serialization The argument serializer is a procedure of one argument converting a procedure into a characters strings The argument unserializer is a procedure of one argument converting a char acters string into a procedure It belongs to the user to provide correct serializer and unserializer 70 Bigloo 4 2b Here is an example of procedure serializer and unserializer that may be correct under some Unix platform module foo extern macro sprintf int string string procedure sprintf define string gt procedure str pragma obj t strtoul BSTRING TO STRING 1 0 16 str define procedure gt string proc let item make string 10 Asprintf item tp 1x proc item register procedure serialization procedure gt string string gt procedure let x 4 let obj cons toto lambda y x y let nobj string gt obj obj gt string obj print cdr nobj 5 register class serialization class serializer unserializer bigloo procedure Register a serializer unserializer for a class Subclasses of class inherit this serializer module class serialization example static class point object x default 10 y default 20 register class serialization point lambda o with access point o x y cons x y lambda 1 instantia
52. 1 Operating System interface 0 0 cece eens 75 52 2 Bles See Lait atest es athe dette bs bats doen este Se dun e ets 77 5 17 3 Process Support das 81 DA Socket support iui e ERG d a 84 O OO EE T PEN 90 56b SSL Sockets uit Eh RR I 90 5 1 5 2 Certificates cute cea ER SERRA Eu 93 5 15 5 3 Private Keys osse esr Reda 93 A Atl nus Y tpe e ae Ore Pete e Wana OVER 93 9 9 Digesta i o oes eto te pac ele ipo ERR Rees 96 5 10 Cyclic Redundancy Check CRC ooooooooooorcrcmomomoo 97 ell RN 100 Si URI a aa e da tr cd e e fe tks ats scie de do 100 A EEN 101 Pattern Matching ooh et ss 105 6 1 Bigloo pattern matching facilities o ooooooooo 105 6 2 The pattern language esses Ie 106 Il oso bse ane se hod Cor eR Dad 107 7 1 Knuth Morris and Pratt o ooocccocoocccccnccccnnnccccneo 107 Structures and Records 109 SL Sir ct res ueee Ee eG ig wh A 109 A eet Asta baud a eus 109 Bigloo 4 2b O Dbject OEM a ds 113 9 1 Class declarati0N oooccococcccoonnccrnr e 113 9 2 Creating and accessing objects 0 00 cece eee eee eee 115 9 3 Generic functiOnSs 0c s ced nEn rro atte 117 9 4 Widening and shrinking 00 cece eee ene ee eee 117 9 5 Object library cinc a edges 120 9 5 1 Classes handling 0 00 yee e eaa a e e eee 120 9 5 2 Object handling 0 cece ah Ea eee 121 9 6 Object serialization 0 cece
53. 2 display foo t2 instantiate fthread body lambda O let loop n 1 display n thread yield if n 5 loop n 1 thread start t1 thread start t2 scheduler start 4 12f0034 thread terminate thread SRFT 18 function Terminates thread at the end of the current reaction thread join thread timeout timeout val SRFI 18 function The current thread waits until thread terminates or until timeout is reached when supplied If the timeout is reached thread join returns timeout val Tf thread Chapter 16 Threads 185 terminates thread join returns the end result of the thread or the end exception if that thread terminates abnormally If several threads wait for the termination of the same thread they are all notified of the termination during the current reaction let t1 thread start instantiate fthread body lambda thread sleep 3 foo t2 thread start instantiate fthread body lambda print ti thread join t1 1 t3 thread start instantiate fthread body lambda print t2 thread join t1 2 bar t3 thread start instantiate fthread body lambda print t3 thread join t1 t4 thread start instantiate fthread body lambda print t4 thread join t1 scheduler start ti l uncaught exception reason exception join timeout t2 bar t3 foo t4 foo thread join ca
54. AO 40 el A ue ere pbi ea 40 StriBgB Tult lod Sek elke A Ie e nied ant EEEE 39 String ef e it e rure i REED 40 SULING A cp peeseUpUsbuuw he eid RE T 40 SEUNG Trae runc dee We ae tla ae a shen deh ear 39 String 2key ihe ARR RT eee takes 157 Mia 39 struct 2obj ctio ar bal oe vere 121 A O 109 SETUCLUTOS 2 eg ies Ande a dd 109 SUD Ea a ind za 42 substring at micii faaee ei ge i Pa Tp esee 39 s bstring ci at eai ea e cece n oo 39 s bstring ci2 2 dy yonishi oe aw punts 40 S bStriRg pobede ada oto ie eda EE 39 subucs2 stringi c il pli teli edd pean 44 SUfflX Le vedo adsis aes rie 78 symbol gt keyword 2 eee eee 32 symbol gt string cee eee eee eee eee 30 symbol append oio ahead econ ed eA 31 Symbol plist sins dene eke etd 31 SYMDOM a ete Senta eek ies 30 symbols a ose EI M Oei SEU 30 Symmetric Block Ciphers 153 synchronize Mii 181 Synb X sig saletesig tue eagle este ete 17 SYNCAX LulLes ies ista 227 System ecd ted lhe trie ol es aS ae 75 System programming 0025 74 system gt string eee eee eee eee eee 75 T TAGVeCtOI d ges Mand wick ies A Acne dts 49 TAGVeCtor S1ist imac cling esa alar 49 TAGvector length ooooooooommmmmooo 49 TAGvector ref ci iei A a 49 TAGvector sSet e Irc E e ales oni ds 49 TAGUECLO Pida di is gw e SRI RE NE 49 pl 28 Anc gue DOR Rea REOR ER ERR MIRO 36 DUMAS ex wach e RENE me WE PAS 36 GAL lt lig Rind Gr
55. Bigloo Cryptography class Complete RSA Key Bigloo Cryptography class class Rsa Key modulus bignum exponent bignum final class Complete Rsa Key Rsa Key for the complete rsa key exponent takes the role of d e bignum p bignum q bignum expi bignum d mod p 1 exp2 bignum d mod q 1 coeff bignum inverse of q mod p RSA keys can be read and written using read pem key and write pem key Section 14 2 4 PEM page 162 generate rsa key key 1024 show trace Bigloo Cryptography procedure This function generates a new RSA key with its public and private components Do not use this function for critical applications No special effort has been undertaken to guarantee the randomness of the generated prime numbers nor to weed out insecure keys Complete keys can be accessed using the following functions extract public rsa key complete key Bigloo Cryptography procedure Returns the public partial key of the given complete key This procedure is implemented as follows define extract public rsa key Rsa Key key Complete Rsa Key with access Complete Rsa Key key modulus e make Rsa Key modulus e extract private rsa key complete key Bigloo Cryptography procedure Returns the private partial key of the given complete key rsa key keyl key2 Bigloo Cryptography procedure Returns true if the two keys have the same modulus and public exponent The exponent of a partial key is consider
56. Bigloo Libraries 253 e The following declares a library named pthread When loaded the Bigloo run time system will seek a file named libbigloopth_s 1 1a so libbigloopth_ u 1 1a so libbigloopth_es 1 1a so libbigloopth_eu 1 1a so Once the library loaded the SRFI 0 features pthread and srfi 18 will be bound When loading the library the two modules __pth_thread and __pth_makelib will be initialized In the JVM version these modules are compiled in the classes bigloo pthread pthread and bigloo pthread make lib declare library pthread basename bigloopth version 1 1a srfi pthread srfi 18 module init __pth_thread module eval __pth_makelib class init bigloo pthread pthread class eval bigloo pthread make lib library translation table add ident name library procedure library translation table add ident name version library procedure library translation table add ident name version library procedure dlopen init initsym The function library translation table add is obsolete It should no longer be used in new code It is totally subsumed by declare library The function library translation table add is still documented for enabling readers to un derstand old Bigloo source code This function registers a name for the library id An optional version can be specified The optional named argument dlopen init gives the base name of the initialization entry point of a library Imagine that we woul
57. C interface The goal of the design of Bigloo is to allow the merging of high and low level programming This means that Bigloo is designed to be fully connected to the already existing outside world of C This connection has two components a function call interface and a data storage inter face Bigloo code is able to call C code and vice versa Bigloo data storage is accessible from C and vice versa There are no frontiers between the Bigloo and C worlds See Chapter 26 C Interface page 233 for details 1 4 Java interface Since release 2 3 Bigloo is able to produce Java Virtual Machine byte codes in addition to C code By producing class files 1t is possible to connect Scheme code and Java code in the same spirit as the Scheme and C connection This connection has two components a function call interface and a data storage inter face Bigloo code is able to call Java code and vice versa Bigloo data storage is accessible from Java and vice versa There are no frontiers between the Bigloo and Java worlds See Chapter 27 Java Interface page 245 for extra details 1 5 Object language Since release 1 9 Bigloo has included an object system This system belongs to the CLOS Bobrow et al 88 object system family but whose design has been mainly inspired by C Queinnec s MEROON Queinnec93 It is based on ad hoc polymorphism generic func tions and methods uses single inheritance and mono dispatch and provides the user with intr
58. E y1 y co instantiate var value body bigloo syntax This form is only available from compiled modules In other words it is not available from the interpreter It permits the creation of recursive instances It is specially useful for creating instances for which class declarations contain cyclic type references for instance a class c1 for a which a field is declared of class c2 and a class c2 for which a class is declared of type c1 The syntax of a co instantiate form is similar to a let form However the only legal values are instantiate forms The variables introduced in the binding of a co instantiate form are bound in body In addition they are partially bound in the values expressions In a value position a variable var can only be used to set the value of a field of an instantiated class It cannot be used in any calculus Example module obj example export class cl a b o2 c2 class c2 x y oi c1 co instantiate o1 instantiate ci a 10 b 20 02 02 02 instantiate c2 x 10 y 20 o1 01 with access c1 o1 02 with access c2 02 x y x y gt 30 duplicate class obj ident value bigloo syntax This forms allocates an instance of class class The field values of the new object are picked up from the field values of the old object unless they are explicitly given in the parameter list For instance with access point old x instantiate point x x y 10
59. LOK ceu Ee ER UEISU I 212 uailbox celoSe 6 bd 212 mailbox folder create oooocccccccco o 212 mailbox folder dates 00 213 mailbox folder delete 00 213 mailbox folder delete messages 213 mailbox folder exists suse 213 mailbox folder header fields 213 mailbox folder move 00 213 mailbox folder rename 0 213 mailbox folder select ee eee 212 mailbox folder status sess 213 mailbox folder uids 004 213 mailbox folder unselect 212 mailbox folders cc cece eee eee eee 212 mailbox hostname eee eee eee eee ee 212 mailbox MesSsage 6 cece eee eee eee 213 mailbox message body cee sees 213 mailbox message create 4 214 mailbox message delete 0 214 mailbox message flags sess 214 mailbox message flags set 214 mailbox message header 0005 213 mailbox message header field 214 mailbox message header list 213 mailbox message infO oooooccocccccocncc 214 mailbox message MmoVe l oo o o oooocoomooo 214 mailbox message path ooooocccocccooom 213 Chapter 35 Global Index mailbox message size sss 214 mallbox prefix il celum eS 212 mailbox separator eeeee nee 212 mailbox
60. Limitation of the JVM back end 0 0 cee eee 246 27 4 Connecting Scheme and Java code 0 cece cece ee 247 27 4 1 Automatic Java clauses generation 20000 247 27 4 2 Declaring Java classes 0c c cece eee eee eee 247 27 4 8 Declaring abstract Java classes 0 ooooooooooo 248 27 4 4 Extending Java classes 248 27 4 5 Declaring Java arrays ssssseeeesesee eee 248 27 4 6 Exporting Scheme variables ooooooooccoconmo o 249 27 4 7 Bigloo module initialization ooooooccoconooo o 249 27 5 Performance of the JVM back end sssesss esee 249 Bigloo 4 2b vil 28 Bigloo Libraries yd do 251 28 1 Compiling and linking with a library ooo oooooooooo 251 28 2 Library and inline functions lees 253 28 3 library and eval 2 suite ikorira Ri Gp tL nes 254 28 4 library and repas ascii IR p ndn 255 28 5 Building a library sssseseeesseesse e 255 28 6 Library and modules 0 eee eee eee need 257 28 7 Library and macros ssseessssse eee eee aes 258 28 8 A complete library example 0 00 e cece eee eee 258 29 Extending the Runtime System 263 EUR CE 265 SOMA RELOAD o les 265 30 2 SREP eoe n aa bea ta tens bed eg 268 30 35 SREE 228 c eset tests is Dedo 28 2 268 30 3 1 An example of SRFI 22 script 0 20 00 268 30 3 2 Lazy compilation with SRFI 22
61. Otherwise the table is extended by an entry linking key and init value hashtable gt vector table bigloo procedure hashtable gt list table bigloo procedure Returns the hash table table s data as a vector respectively a list If the hash table is weak the result will consist only of the data which haven t dissapeared yet and whose keys haven t dissapeared either hashtable key list table bigloo procedure Returns the list of keys used in the table If the hash table is weak the result will consist only of the keys which haven t dissapeared yet and whose data haven t dissapeared either 74 Bigloo 4 2b hashtable map table fun bigloo procedure Returns a list whose elements are the result of applying fun to each of the keys and elements of table no order is specified In consequence fun must be a procedure of two arguments The first one is a key and the second one an associated object If the hash table is weak fun will only be mapped on sets of key datum which haven t dissapeared yet hashtable for each table fun bigloo procedure Applies fun to each of the keys and elements of table no order is specified In consequence fun must be a procedure of two arguments The first one is a key and the second one an associated object If the hash table is weak fun will only be called on sets of key datum which haven t dissapeared yet hashtable filter table fun bigloo procedure Filter out elements from table according to pred
62. RIRs ede RIT 48 yector fill iii a 47 Vector length ic iiscccncia na ica da 4T vectorcmap c sense vaga c e pa races rdi 48 A 48 X ctOr tef c ue lada sn cui 47 vector setl s ge pL dI haia RUPEE P 47 A O 47 VEL o aa ree 47 void mula ie re 238 Vorbis muSictag 6 eee eee eee 203 W il AA 4 pea ae acest as 175 warning notify 6 cece cece esses 172 warning location l l 172 Weakptr data gx ix e Lie ged 72 NOA PEA ci 71 Wldezclass o atten rend A E 113 wide obJect josey tee td BS 121 Widen is tacts Te o 118 widen wide clasS oooooooooooo o 118 Widening and shrinking 117 With Mamet sores hae ai eal onary si Po 9 WIth ACCESS o annn a tee ne Sex HERE ota ee rege 115 with access ClasS oooooooommmmmo o 115 With append to ilimitada 55 with error to file eu et a 55 With error to Port o gu e Uer 55 with error to procedure sss 55 with error to string sess 55 with exception handler sss 172 with handler 2 5 eee ata e iaee 172 with input from file sss 55 with input from port s ssssssss 55 with input from procedure 55 with input from string 005 55 vith tock edra en ESSE eke oe ae uus 181 with output to file c gil ipe piii 55 With output tos port is agnya E a AE s 55 with output to procedure oooooooommoo 55 with output to string
63. Returns the full path name of the message uid mailbox message body mailbox uid len Bigloo Mail procedure Returns the body of the message uid If len is provided only returns the first len characters of the body mailbox message header mailbox uid Bigloo Mail procedure Returns the header as a string of the message uid mailbox message header list mailbox uid Bigloo Mail procedure Returns the header as an alist of the message uid 214 Bigloo 4 2b mailbox message header field mailbox uid field Bigloo Mail procedure Extracts one field from the message header mailbox message size mailbox uid Bigloo Mail procedure Returns the size of the message mailbox message info mailbox uid Bigloo Mail procedure Returns the information relative to the message uid This a list containing the message identifier its uid the message date the message size and the message flags mailbox message flags mailbox uid Bigloo Mail procedure mailbox message flags set mailbox uid lst Bigloo Mail procedure Sets Gets the flags of the message uid This is a list of strings Typical flags are e NFlagged e Answered e NDeleted e Seen mailbox message delete mailbox uid Bigloo Mail procedure Deletes the message uid mailbox message move mailbox uid folder Bigloo Mail procedure Moves the message uid into the new folder denoted by a string mailbox message create mailbox folder content Bigloo Mail procedure Crea
64. SREDA acia its al 48 SREEA3 uti eens Soot ead wre 48 SREE6 eos 57 59 SREES IRISH EMERIS ieee 53 SREL9 24 pr iR VIRES 109 SSI SOCK6t 1 2 nara Fado 90 SSl VerSiOnz v Up PU o aes 90 Sob npn ifte ege eps eise tes piss efte 90 SOL DOCKObS tac voip e tutae wee aee 90 SSL Support elerigrkDeTxerLeiuti ck Rute 90 Stack allocation oee e EEA AEE DE E 272 Static AA A AY 10 String il la a 39 string escape characters 004 229 string gt bignum eee eee eee 37 string gt elong 2 eee ee 37 string key hash esses esses 157 318 string gt key iterated salted 157 string key salted sess esses 157 string gt key Simple ss sess 157 string key zero esee ese 157 string 2keywOrd du clle le M Dena 32 string listaoi i e pla bx 42 String 2llong s onu EUER RID 37 a A ON 66 string number esses eee eee 37 StrifgsroD jairo idad pos 68 string 2real ii Hp Wee Mp dae 37 string gt symbol en iia da 31 String gt symbol ci ers ren eee eee 31 string gt vcard vcard 0 cee ooo 211 String append si gi ties ep eas Dae sat 42 string capitalize lesse 42 string capitalize esses 42 String Case ic ll a E ERROR 129 String cl 7 oed aa beso ders ie ati ts 40 ST LNE CIST E E dare ETE 40 string cis dl a eee 40 String Cis Piro io 40 SETE SCA rad 40 String C mpa
65. a connection on the port 1234 Once the connection with the distant program is established we read a line on the input port associated to the socket and we write the length of this line on its output port let s make server socket 1234 s2 socket accept s let 1 read line socket input s2 fprint socket output s2 Length is string length 1 flush output port socket output s2 socket close s2 socket shutdown s Under Unix you can simply connect to listening socket with the telnet command With the given example this can be achived by typing the following command in a window shell telnet localhost 1234 Chapter 5 Standard Library 87 socket close socket bigloo procedure The function socket close closes the connection established with a socket client socket shutdown socket optional how t bigloo procedure Socket shutdown shutdowns the connection associated to socket Close is either a boolean or one of the symbols RDWR RD or WR The meaning of the optional how which defaults to t is as follows e dtt the socket is shutdown for reading and writing and the socket is closed e f the socket is shutdown for reading and writing e RDWR the socket is shutdown for reading and writing e RD the socket is shutdown for reading e WD the socket is shutdown for writing The function socket shutdown returns an integer which is O is the operation has succeeded and a positive integer
66. a custom interpreter Fortunately this is easy What has to be done is to wrap the foreign functions within Scheme and make an interpreter module 244 Bigloo 4 2b Let us consider an example where a C function get system time returning and int is used in an interpreter When linking be sure to add the o file containing the get_ system time The ffi interpreter scm file module ExtendendInterpreter import wrapper wrapper scm main main define main argv rep1 The wrapper scm file module wrapper extern macro get system time int get_system_time export get system time eval export exports define get system time Aget system time Compile and link your application with something like cc gettime c c gettime o bigloo wrapper scm c bigloo ffi interpreter scm wrapper o gettime o Chapter 27 The Java interface 245 27 The Java interface When the Bigloo is configured for a JVM back end support the compiler is able to produce Java class file instead of C files In order to produce JVM class files use the jvm compiler option Example cat gt foo scm module foo main main define main argv print Hello world argv bigloo jvm foo scm a out 4 Hello world a out 27 1 Compiling with the JVM back end 27 1 1 Compiler JVM options All the compiler options that control the compilation optimization options debugging options etc can be used in conjunction
67. a number in num columns with padding padding a and s when encountered require a corresponding Scheme value to be present after the format string The values provided as operands are used by the escape sequences in order It is an error if fewer values are provided than escape sequences that require them 4 and require no corresponding value format Hello a World 4 Hello World format Error list is too short s 4 one two 3 4 Error list is too short one two 3 format a 1 l list 12 3 4 a list 123 format a 1 list 1 2 3 d list 1 2 3 format 3d 4 4 format 3 d 4 ed 4 format 3x 16 Ll 10 format 3 0d 5 j 005 printf format string objs bigloo procedure fprintf port format string objs bigloo procedure Formats objs to the current output port or to the specified port Chapter 5 Standard Library 65 pp obj output port bigloo procedure Pretty print obj on output port pp case bigloo variable Sets the variable to respect lower or upper to change the case for pretty printing pp width bigloo variable The width of the pretty print write circle obj output port bigloo procedure Display recursive object obj on output port Each component of the object is dis played using the write library function display circle obj output port bigloo procedure Display recursive object obj on output port Each compon
68. accessors set kar to be a modifier and pare to be a predicate for pares Chapter 8 Structures and Records pare kons 1 2 pare cons 1 2 kar kons 1 2 kdr kons 1 2 let k kons 1 2 set kar k 3 kar k HY ud y 111 Chapter 9 Object System 113 9 Object System Bigloo s object system is designed to be as simple as possible and belongs to the CLOS Bobrow et al 88 object system family in that it uses classes generic functions and methods Its design has been strongly influenced by C Queinnec s MEROON Queinnec93 It does not include any meta object protocol 9 1 Class declaration Classes are defined in a module declaration A class declaration can take place in a compiled or interpreted module If a class declaration takes place in a static module clause see Section Section 2 2 Module Declaration page 7 its scope is limited to the current module but if it takes place in an export module clause its scope is extended to all modules that import the current module The syntax of a class declaration is class ident field bigloo module clause class gt class ident constructor lt field gt final class ident constructor lt field gt Gride class ident constructor lt field gt Cabstract class ident constructor lt field gt constructor gt lt expr gt lt field gt gt ident lt ident gt lt field prop gt lt
69. and it can do three things call extern programs unix programs define macros modify the values of some of the compiler s variables for example the list of the libraries to be linked with The Bigloo s initializing procedure is the following e If it exists Bigloo loads the runtime command file see Section Chapter 31 Compiler Description page 271 e It then parses the command line to find the source file to compile e It extracts the source file suffix and looks it up in its auto mode variable e If the suffix is found the associated file is loaded This file could contain a function named extend entry which must accept a list as argument It is invoked with the Bigloo s unparsed arguments e The result of the extend entry application has to be a regular list of arguments and these are parsed by Bigloo For now two extension packages exist the Meroon package which is a native version of the Christian Queinnec object language the Camloo SerranoWeis94 package which is a front end compiler for the Caml language Caml light Furthermore Bigloo supports the extend option which forces the usage of an extension file When Bigloo encounters this option it immediately loads the extension file invoking the function extend entry with the list of arguments which have not been parsed yet The extension files are always sought in the directory containing the Bigloo s libraries 33 1 User pass Bigloo allows the user to ad
70. bd4df3b2ddef790c RSA Encrypt or Sign pgp key id subkey Bigloo OpenPGP procedure pgp key fingerprint subkoy Bigloo OpenPGP procedure Returns the id resp fingerprint of a subkey A subkey id is a 8 character binary string A fingerprint is a 20 character binary string pgp make key db Bigloo OpenPGP procedure pgp add key to db db key Bigloo OpenPGP procedure pgp add keys to db db keys Bigloo OpenPGP procedure pgp resolve key db id Bigloo OpenPGP procedure pgp db print keys db Bigloo OpenPGP procedure A simple key manager implementation based on lists 14 3 1 Examples 14 3 1 1 Signatures Unless you already have a gpg key create a new PGP key with gpg Note that DSA with a keysize greater than 1024 does not work with SHA 1 SHA 224 256 384 512 would work but are not yet implemented in Bigloo Chapter 14 Cryptography 167 gpg gen key pub 1024D A2DA694E 2010 08 07 expires 2010 08 27 Key fingerprint DFAF 5894 9003 8640 D45B 6199 07CA 0495 A2DA 694E uid Bigloo Example sub 1024g 0B8985E5 2010 08 07 expires 2010 08 27 We export both the public and the private key gpg a o A8453FAB Bigloo Example User pkey export A8453FAB gpg a o A8453FAB Bigloo Example User skey export secret keys A8453FAB This small program will simply read the key and print a human readable representation contents of print key scm module print key library openpgp main my main define my
71. bigloo procedure bigloo procedure bigloo procedure Parses RFC2822 string representing a date These functions produce a Bigloo date object date gt rfc2822 date date bigloo procedure Converts a Bigloo date into a string representation compliant with the RFC2822 format iso8601 date gt date string iso8601 parse date input port bigloo procedure bigloo procedure Parses ISO8601 string representing a date These functions produce a Bigloo date object 96 Bigloo 4 2b 5 9 Digest base64 encode string padding 64 bigloo procedure base64 decode string no eof padding bigloo procedure Encodes respec decodes a string into a base64 representation When decoding if the optional parameter no eof padding is tt the decoding success even if the input stream is not padded with characters base64 encode port input port output port padding 64 bigloo procedure base64 decode port input port output port no eof padding bigloo procedure Encodes respec decodes an input port into a base64 representation When decode succeeds base64 decode port returns t it returns f otherwise When decoding if the optional parameter no eof padding is tt the decoding success even if the input stream is not padded with characters pem read file file name bigloo procedure pem decode port input port output port bigloo procedure Reads a PEM Privacy Enhanced Mail base64 encoded file md5sum obj bigloo procedure mdb5
72. cond expand fthread thread await make aynchronous signal lambda s read map lambda x e x e cdr x else read map lambda x e x e cdr x 16 2 3 SRFI 18 This section presents the functions that are not necessary to Bigloo but supported for compliance with SRFI 18 provided by the Fair Thread library current time scheduler SRFI 18 function Returns the reaction number of scheduler time obj SRFI 18 function time gt seconds obj SRFI 18 function join timeout exception obj SRFI 18 function abandoned mutex exception obj SRFI 18 function terminated thread exception obj SRFI 18 function uncaught exception obj SRFI 18 function uncaught exception reason exc SRFI 18 function 16 3 Posix Threads This section describes two Posix Like multi threading Bigloo libraries The two libraries pthread and srfi 18 are all the same but the mutex state function that returns different results Because of these differences that might seem thin at first glance the pthread library is significantly faster than the srfi 18 library For that reason it is recommended to use the pthread library instead of the srfi 18 library that is mostly supported for backward compatibility As much as possible the names exported by this library are compatible with the Fair Threads library see Section Section 16 2 Fair Threads page 182 192 Bigloo 4 2b 16 3 1 Using Posix Threads The Bigloo modules initialization
73. dit bigloo class demangle string bigloo procedure Demangle previously mangled class identifier 26 4 Embedded Bigloo applications It is possible to design and realize embedded Bigloo applications This facility is useful for adding a new Scheme part to an already existing C program The C part of the program has only to enter the Bigloo initialization hence it can call any Bigloo function Normally Bigloo creates an initialization function called main when it reads a main module clause To use an embedded Bigloo program such an initialization function would have to be created but with a different name Changing the name can be be done using the following Bigloo option copt DBIGLOO_MAIN lt new name gt To prevent exit from the program after lt new name gt is executed the following Bigloo option must be used copt DBIGLOO EXIT BUNSPEC A very important part of designing embedded Bigloo programs is being sure that all used Bigloo modules are correctly initialized and the normal way to initialize them is to use with clauses in the module which contains the main clause An example of an embedded program can be found in the distribution s examples direc tory 26 5 Using C bindings within the interpreter To be able to get access to foreign functions within the Bigloo interpreter some extra measurements have to be taken The foreign functions have to be present in the interpreter binary which means you have to compile
74. e 121 9 5 EQU Pico at eal See ed ote 121 9 8 Introspection mein tine 122 10 Regular parsing esse 125 10 1 A new way of reading 0 ccc cece eee eee eee 125 10 2 The syntax of the regular grammar 0 200e eee 125 10 3 The semantics actions 0 0 e cece eee nee eee 129 10 4 Options and user definitions 0 0 c cece cece 131 10 5 Examples of regular grammar 0 00 e cece 132 I0 5 1 Word COMA id 132 10 5 2 Roman numbers 0c c cece e 132 11 Lar par ro iii 135 11 1 Grammar definiti0N oocoocccccoococcccnnnccrrnr anar 135 11 2 Precedence and associativity oooooocccoocccccnocncccn oso 136 11 3 The parsing function ssessessseeeeee e 137 11 4 The regular grammar sseessse II 137 11 5 Debugging Lalr Grammars esses 138 11 6 A simple example ssssssssssss III 138 12 Posix Regular Expressions 139 12 1 Regular Expressions Procedures 0 000s eee eee ees 139 12 2 Regular Expressions Pattern Language sisse 142 12 2 Basic assertions 0 cece cece eee eee een 142 12 2 2 Characters and character classes ooooooooooommo 142 12 2 8 Some frequently used character classes 143 12 2 4 POSIX character classes ooooooccocooocccccnanccoo 143 12270 Quantifiers acia A hd Io en E 144 12 2 0 Numeric quantifiers 0 cece eee eee 144 12 2
75. eat 203 18 2 39 Playback iius repete ome t b etate tei 203 18 2 4 Music Player Daemon ssssseeeeseeeeeeees 207 18 3 MP E 208 T9 Meira TO eaque tardo crat 209 19 1 RFC 2045 MIME Part one 000s 209 19 2 RFC 2047 MIME Part three 00 cee eee 210 19 3 RFC 2426 MIME Part three 0 0 cece 210 19 4 RFC 2822 Internet Message Format ooooccoooocccoo 211 19 5 Mail servers imap and maildir 0 0 e eae 212 19 5 1 Mallboxes cr a sii 212 19 5 2 IMAP RFC 200 Dat 214 19 5 3 Mala 0 gta er t REESE Ree roe eat 215 20 Tex ch bo eter oto tun itte de ie ro 217 201 AA ee SURE dne eoi ng 217 20 2 Character strings aer cece me 217 20 3 Character encodings 0 0 cece eee e eee ee 218 UJWEC Pm 219 2L OVerview ces ect nte ege Eta uen PRI Le betty 219 21 2 API Reference sssssssslsssssss ee mes 219 22 Eval and code interpretation 221 22 1 Evalconipliance naviera aia ere 221 22 2 Eval standard functions 0 00 eens 221 22 3 Eval command line options 00 cece eee eee eee 224 22 4 Eval and the foreign interface 0 e cece eee eee 225 vi 23 Macro expansion eeeeeesss 227 23 1 Expansion passing style macros ooooccocooocccccrccccnr so 227 23 2 Revised 5 macro expansion oue eror di ve 227 A bU Rane oes 229 25 Explicit typing ers soe eee EARS 231 26 The C interf
76. ee va gane Rer eke dal ues 67 tar header checksum eee eee 67 tar header devmajor cece eee 67 tar header devminir cece eee eee ee 67 Tar header gid iii Ue e eR brc sarees 67 tar header gname 0 cece eee eee eee 67 tar header linkname esse 67 tar head r mode cnica a 67 Lar header MtiM imita a al as 67 tar header mame cuida aa a a eine oes 67 Chapter 35 Global Index Par header siZeres cess ssh as 67 tar header type cece cece cece eee eee 67 tar header nid s ove V E E ene UT 67 tar header uname s eese eese 67 tar read block wis ein ees ein ewes eet RUE 67 tar read header coccion ler pr ees 67 tar round up to record size 67 terminated thread exception 191 193 ES E ON 217 the bee root directory ooooooocccocccococo 300 The compiler environment and options 272 the interpreter see 221 the lalr 1 parsing function 137 the pattern language oooocooocccocnccccccoo 106 The runtime command file 273 the semantics actioOS 0oooooooccocccccco 129 The syntax of the foreign declarations 233 The syntax of the regular grammar 125 The very dangerous pragma Bigloo special forms A SES o 242 Che A eee euer us ame PS 130 the byte ref c0 e X CON oo ode 130 the character sobrers nep veLrU ren 130 the context ouo xci reU E RE LE
77. eee eee 18 PEC cio eee Se MERGER 49 DPLOCESS eroderat cree eo eee e ra 81 Process support e soced iseia cece ei eee eee 81 Process ali lei e ists 83 PTOCOSS COMIDO nico 84 process error port cio sees 83 process exit status esee ee 83 process input port sese 83 process killog 9 rar ains 84 process listillo 84 process output port v e 83 POCOS Pic iS a 83 process send signal 0 eee 84 process stop is i b be VERA ee 84 proces8 wall an er nage 83 processi ai 83 PONNE sess coste odo onec T Oda vers 302 Program Structure 00 cece eee eee 7 Public Key Cryptography 157 PUC dd 75 PUtPPOp aci de eee x deme Ahan das 31 Pud 28522876 MG MES SERGE e MA MEL 78 316 Q qualified notation cece eee eee eee eee 15 quasiquot r amic 22 guit reha a ida 222 AS cue ns pU e nr Eai 22 quote i la el e cts eres 18 quoted printable cece eee eee eee 209 quoted printable decode 209 quoted printable decode port 209 quoted printable encode 209 quoted printable encode port 209 quotient PEI eos 35 quotientelong ai eee eese 35 quotientllong 66 ccc eee 35 raise a A AA aed da 173 random rs nta 35 Tandombxisi4 ccd teal eet t gebe LE Ss 35 randomfl 4l ifaegsCnPhOeT INA A EDS 35 rational a oc eonen roor als alee sedg ck ana 32 read 2 5 cca deed eee ata deg
78. encrypted by a session key which in turn is encrypted separately for each recipient Since the session key is not very big compared to the data the size overhead is usually insignificant Let s start by encrypting a message with a simple passkey let secret data My secret data n composition pgp encrypt secret data My secret passkey pgp write file secret pgp composition As usual the pgp message is compatible with gpg gpg secret pgp gpg CAST5 encrypted data Enter passphrase My secret passkey gt gpg encrypted with 1 passphrase Chapter 14 Cryptography 169 cat secret My secret data As expected Bigloo can decrypt password protected files that have been generated by 8P8 echo A secret message encrypted with gpg gpg o encrypted pgp symmetric A passphrase secret key The Bigloo code to decrypt the message is very simple print pgp decrypt pgp read file encrypted pgp passkey provider lambda secret key In a similar vein it is possible to use public key encryption The following example tests the encryption and decryption part of Bigloo let my key car pgp read file A2DA694E_Bigloo_Example skey db pgp make key db secret data My secret message encrypted pgp encrypt secret data my key 0 pgp add key to db db my key let key manager lambda id pgp resolve key db id password provider lambda key lt Bigloo Example Password
79. expressions are equivalent posix az x ly 3 5 or in az x kx 35 y string case string rule bigloo syntax This form dispatches on strings it opens an input on string a read into it according to the regular grammar defined by the binding and rule Example define suffix string string case string C all ignore out the string else L5 10 3 The semantics actions The semantics actions are regular Scheme expressions These expressions appear in an environment where some extra procedures are defined These procedures are the port bigloo rgc procedure Returns the input port currently in used the length bigloo rgc procedure Get the length of the biggest matching string the string bigloo rgc procedure Get a copy of the last matching string The function the string returns a fresh copy of the matching each time it is called In consequence 130 Bigloo 4 2b let 11 the string 12 the string eq 11 12 gt df the substring start len bigloo rgc procedure Get a copy of a substring of the last matching string If the len is negative it is subtracted to the whole match length Here is an example of a rule extracting a part of a match regular grammar C Ce out the substring 1 fx the length 1 Which can also be written regular grammar CC k out the substring 1 1 t
80. f64vector If the fill value is not specified the content of the vector is unspecified but individual elements of the vector are guaranteed to be in the range of values permitted for that type of vector 5 1 13 Control features procedure obj procedure apply proc argl args procedure 50 Bigloo 4 2b map proc list1 list2 library procedure map proc list1 list2 bigloo procedure for each proc listl list2 library procedure filter pred list library procedure filter pred list library procedure Strip out all elements of list for which the predicate pred is not true The second version filter is destructive filter number 1 2 Ha foo foo 3 gt 12 3 let A list 1 2 Ha foo foo 3 set 1 filter number 1 1 gt 123 append map proc listl list2 library procedure append map proc list1 list2 library procedure The expression append map f clisti clist2 is equivalent to apply append map f clist1 clist2 The expression append map f clisti clist2 is equivalent to apply append map f clisti clist2 filter map pred list bigloo procedure As map but only none f values are accumulated in the resulting list The Bigloo implementation complies with the SRFI 1 description filter map lambda x if number x f 1 2 a foo foo 3 gt sort proc obj bigloo procedure sort obj proc bigloo procedure Sorts
81. file gzip string bigloo procedure This procedure returns t if and only if the file string exists and can be unzip by Bigloo Otherwise it returns sf 80 Bigloo 4 2b delete file string bigloo procedure Deletes the file named string The result of this procedure is t is the operation succeeded The result is otherwise rename file stringl string2 bigloo procedure Renames the file string as string2 The two files have to be located on the same file system If the renaming succeeds the result is tt otherwise it is amp f truncate file path size bigloo procedure Truncates shall cause the regular file named by path to have a size which shall be equal to length bytes Returns t on success Returns f otherwise copy file stringl string2 bigloo procedure Copies the file stringl into string2 If the copy succeeds the result is t otherwise it is 4f directory string bigloo procedure This procedure returns t if the file string exists and is a directory Otherwise it returns f make directory string bigloo procedure Creates a new directory named string It returns t if the directory was created It returns f otherwise make directories string bigloo procedure Creates a new directory named string including any necessary but nonexistent parent directories It returns t if the directory was created It returns amp f otherwise Note that if this operation fails it may have succeeded in creating some of the
82. fixnum gt elong bigloo procedure llong gt fixnum bigloo procedure fixnum gt llong bigloo procedure elong gt flonum bigloo procedure flonum gt elong bigloo procedure llong gt flonum bigloo procedure flonum gt llong r bigloo procedure For efficiency string gt real and string gt integer do not test whether the string can be read as a number Therefore the result might be wrong if the string cannot be read as a number These last procedures implement the natural translation from and to fixnum flonum elong and llong double gt llong bits z bigloo procedure float gt int bits z bigloo procedure Returns the double bits as a llong llong bits gt double llong bigloo procedure int bits gt float int bigloo procedure Converts the given llong bits to a double See Section r5rs info in R5RS for more details 38 Bigloo 4 2b 5 1 7 Characters Bigloo knows one more named characters tab return and nu11 in addition to the iN space and newline of R5RS A new alternate syntax exists for characters a lt ascii code gt where lt ascii code gt is the three digit decimal ASCII number of the character to be read Thus for instance the character space can be written a032 char obj char charl char2 char lt charl char2 char gt charl char2 char lt charl char2 char gt charl char2 char ci charl char2 char ci lt charl char2 char ci gt charl char2 char ci lt charl char2 char ci gt
83. functions and variables may be automatically inserted in an export module clause see Chapter 2 Modules page 7 Bring the cursor to an identifier of a binding that has to be exported then either click on the Export tool bar icon or use the C c C m b key binding Bigloo bindings may be automatically inserted in an import module clause Bring the cursor to an identifier of a binding that has to be imported Either click on the Import tool bar icon or use the C c C m i key binding The BEE will search the modules for the wanted binding Foreign bindings e g C variables and C functions may be automatically inserted in the file module clause Click on the Extern tool bar icon or use the key binding C c C m c to import whole the definition of an extern file You will be prompted an extern file name to be imported This operation automatically updates the Makefile for reflecting that the extern file is required in the compilation 34 12 Debugging The Bigloo symbolic Debugger may be spawned either clicking on the Bdb tool bar icon or using the key binding C c C b C b Once the debugger is not is possible to connect the current buffer to the debugger This is done using the tool bar icon Connect or the key binding C c C b c This enables breakpoints to be inserted using mouse clicks 34 13 Profiling Automatically produced Makefile provides entry for profiling In order to get a profile you must first compile your application for profiling T
84. generate parsers for more powerful languages namely a subset of context free languages These tools take as input a description of the language to be recognized and generate a parser for that language written in some other language for example Yacc and Bison generate parsers written in C The user must always be aware of the generated parser and that is a nuisance Bigloo provides such a tool that overcomes this annoyance It generates parsers for the class of Lalr 1 grammars in a more opaque way 11 1 Grammar definition An lalr 1 grammar is defined by the form lalr grammar term def non term def bigloo syntax term def is a list of terminal elements of the grammar Terminals can grouped to gether to form precedence groups by including the related symbols in a sub lists of the term def list Each precedence group must start with one of the keywords left right or none this indicates the associativity of the terminal symbol Here is a sample term def which declares eight terminals terminal 1 terminal 2 left terminal 3 terminal 4 terminal 5 right terminal 6 none terminal 7 terminal 8 In this case terminal 3 and terminal 4 both have the same precedence which is greater than the precedence assigned to terminal 6 No precedence was assigned to symbols terminal 1 terminal 2 terminal 5 or terminal 8 Each non term def is a list whose first element is the non terminal being defined i e a symbol The remainin
85. gt decrypted pgp decrypt encrypted key manager key manager password provider password provider if not string decrypted secret data error decrypt test Something went horribly wrong decrypted Note that a secret secret key has a part that is encrypted by a password During decryption Bigloo needs access to this encrypted data and therefore invokes the password provider so it can decrypt it In many cases this will trigger an interactive callback with the user Here in this toy example we know that the password that is needed is for the Bigloo Example key In a more general case the password provider will have to print the key to give more information to the user In the following example we show how to encrypt data for 3 passwords and one key let my key car pgp read file A2DA694E_Bigloo_Example skey db pgp make key db secret data My secret message encrypted pgp encrypt secret data my key pass1 pass2 pass3 pgp write file multi receiver pgp encrypted We believe that gpg has a bug and does not know how to handle such messages correctly Bigloo however decrypts the message with any of the possible options 14 4 Development Bigloo s OpenPGP implementation only exposes few library functions As a consequence some features are not accessible The key management system is very rough and there are no means to inspect messages in more detail It should be possible to exp
86. if it found a f element that satisfied pred or if it did not find any element at all In many situations this ambiguity cannot arise either the list being searched is known not to contain any f elements or the list is guaranteed to have an element satisfying pred However in cases where this ambiguity can arise you should use find tail instead of find find tail has no such ambiguity cond find tail pred lis gt lambda pair Handle CAR PAIR else Search failed find tail pred clist bigloo procedure Return the first pair of clist whose car satisfies pred If no pair does return false find tail can be viewed as a general predicate variant of the member function Examples find tail even 3 1 37 8 5 0 0 gt 8 5 0 0 find tail even 3 1 37 5 gt tf MEMBER X LIS find tail lambda elt equal x elt lis In the circular list case this procedure rotates the list reduce f ridentity list bigloo procedure If list if null returns ridentity if list has one element returns that element Otherwise returns f applied to the first element of the list and to reduce of the rest of the list Examples reduce max O 1 apply max 1 make list n fill bigloo procedure Returns an n element list whose elements are all the value fill If the fill argument is not given the elements of the list may be arbitrary values make list 4 c gt c ccc list tabulate n i
87. implementation for the convention this SRFI describes an interpretation of the external form as a read time appli cation Examples define reader ctor list list with input from string tt list 1 2 f 4 5 read gt 1 2 f 4 5 define reader ctor with input from string 1 2 read gt 3 set read syntax char procedure bigloo procedure Note This feature is experimental and might be removed in feature versions Registers a function procedure to be invoked with one argument an input port that is invoked when the reader hits an unparsed character Example set read syntax lambda port Chapter 5 read char read byte peek char peek byte eof objec char read As sp Standard Library 61 let loop c peek char port exps cond eof object c error EOF encountered while parsing clause port char c read char port discard begin reverse exps char whitespace c read char port discard whitespace loop peek char port exps else let exp read port loop peek char port cons exp exps port procedure port procedure port procedure port procedure t obj procedure y port procedure ecified in the R5Rs Section r5rs info in R5RS char ready returns t if a character is ready on the input port and returns f otherwise If char ready returns t then the next
88. is the expression to be evaluated Unless a trace is activated with trace lv la body when its level Iv is greater than the current debug level is equivalent to begin body When traces are activated before executing body The debugging level is controlled by two parameters bigloo debug and bigloo compiler debug see Chapter 24 Parameters page 229 trace item args bigloo function This function displays all its arguments It has to be used nested in a with trace form trace bold s bigloo function trace string s bigloo function These two functions are provided for convenience They returns strings made of their parameters trace color color args bigloo function The color argument is a positive integer This function returns a string which is the representation of args and that appears on the terminal in color color Colors can be enable or disabled using the bigloo trace color parameter see Chapter 24 Parameters page 229 trace margin bigloo function trace margin set bigloo function The trace margin parameter is used to control the characters that are displayed in the margin of a trace Usual applications should not use this However it may be convenient to set the margin by hands in some context For instance it can be used to distinguished threads in a multi threaded application such as make thread lambda trace margin set trace color 1 e make thread lambda trace margin set
89. is disabled 1 when daylight saving is enabled date copy date key sec min hour day month year timezone Creates a new date from the argument date Example date copy current date sec 32 min 24 day 5 current date Returns a date object representing the current date current seconds current microseconds current nanoseconds bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure Returns an elong integer representing the current epoch i e the date since 0 00 00 UTC on the morning of 1 January 1970 expressed in seconds resp in micro seconds date gt seconds date gt nanoseconds seconds gt date nanoeconds gt date Convert from date and elong date gt string date date gt utc string date seconds gt string elong seconds gt utc string elong Construct a textual representation of the date passed in argument date second date Returns the number of seconds of a date in the range 0 59 date nanosecond date Returns the number of nano seconds of a date to be added to dat date minute date Returns the minute of a date in the range 0 59 date hour date Returns the hour of a date in the range 0 23 date day date Returns the day of a date in the range 1 31 date wday date bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure e
90. is equivalent to Chapter 9 Object System 117 duplicate point old y 10 9 3 Generic functions A generic function is a bag of specific functions known as methods When invoked on a Bigloo object a generic function determines the class of the discriminating variable corresponding to the first argument of the generic function and invokes the appropri ate method Generic functions implement single inheritance and each is defined using the define generic Bigloo syntax define generic name arg default body bigloo syntax A generic function can be defined with a default body which will be evaluated if no method can be found for the discriminating variable The default default body signals an error As an example here is a possible definition of the object display generic function define generic object display obj object op let port if pair op car op current output port display port display class name object class obj port display port Methods can be defined to specialize a generic function and such methods must have a compatible variable list That is the first argument of the method must be a sub type i e belong to a sub class of the first argument of the generic function Other formal parameters must be of same types Moreover the result type of the method must be a sub type of the result of the generic function define method name arg body bigloo syntax call next
91. is stopped and replaced by the execution of command It defaults to stt env must be followed by a string of the form var val This will bound an environment variable in the spawned process run process command may contain several env arguments The current variables of the current process are also passed to the new process The following example launches a process which execute the Unix command 1s with the arguments 1 and bin The lines printed by this command are stored in the file tmp X run process ls 1 bin output tmp X The same example with a pipe for output let proc run process ls 1 bin output pipe port process output port proc let loop line read line port if eof object line close input port port begin print line loop read line port One should note that the same program can be written with explicit process handling but making use of the notation for open input file let port open input file ls 1 bin let loop line read line port if eof object line close input port port begin Chapter 5 Standard Library 83 print line loop read line port Both input and output ports can be piped let proc run process usr bin dc output pipe input pipe inport process input port proc port process output port proc fprint inport 16 o fprint inport 16 i fprint inport 10 fprint inport 10 fpri
92. l sss 154 encrypt string bstring 153 encrypt bString 6 Kee waed Ror ti eee 153 Entering the Bee 2 005 300 Gof object rore Mote lap tan gute enr 61 O Ey mU Sees Ve Ego 25 equal edens deg RET Ea ons Neq 27 Equality ad ha era EE es 121 Equivalence predicatesS o ooooccooocccocoo 25 equ inccr a aos ia 25 OTTO tia dada 171 error andlig esri ari a e a antaa 171 error notify i i iie RESET 172 error location h eE eee ee 171 vallas ia es M api 12 221 Eval and the foreign interface 225 310 Eval command line options ooooo 224 Eval operator inlining oooocccoooooom 221 Eval standard functions 221 Oca p eere ERE rcr 33 SVENDK A derzv sheet TREE UNES 33 eyenelong il0gbesQ bs REV RM A RE HR Id 33 SV SME Ul iia v scene ace e eer EN Ue 33 SVENER uu Sek cols dnt arenes gigs dee a HERE Oe 33 SVENTLON Gh oe secs so 4 ive Me ea Er pu AF eae Ya 33 O 28 exact Bxbum A eee Oe be vu Hen UE 32 exact inexa6t o gu gau pa E Xs ma 36 GXdCU 1 ies ede ets n E RR CE Re n 33 examples of regular grammar 132 exception notify Pie weg b SEEN 172 exceptions sono He eSI PR SU ERU 172 executable name fini sce node hentia aes 76 exif E E ON 201 exif date dat eoo ve epe 202 exit iol ese teen ri 75 Dri a fex ique uve E ERU 36 expand rd 222 expand once g i nas ee ae os ee A Ib 222 EXPa
93. leftmost of these elements in the result The order of these surviving elements is the same as in the original list delete duplicates does not disorder the list hence it is useful for cleaning up association lists The equal parameter is used to compare the elements of the list it defaults to equal If x comes before y in list then the comparison is performed x y The comparison procedure will be used to compare each pair of elements in list no more than once the order in which it is applied to the various pairs is not specified delete duplicates is allowed to share common tails between argument and result lists for example if the list argument contains only unique elements it may simply return exactly this list See Section r5rs info in R5RS for more details 5 1 4 Symbols Symbols are case sensitive and the reader is case sensitive too So eq foo FOO gt f eq string gt symbol foo string gt symbol F00 gt f Symbols may contain special characters such as Newline or Space Such symbols that have to be read must be written The function write uses that notation when it encounters symbols containing special characters write foo gt foo write Foo gt Foo write foo bar gt foo bar symbol obj procedure symbol gt string symbol procedure Returns the name of the symbol as a string Modifying the string result of symbol gt string could yield incoh
94. method bigloo syntax If there is no appropriate method an error is signaled Methods can use the form call next method to invoke the method that would have been called if not present The call next method cannot be used out of method definition example define method object display p person op let port if pair op car op current output port fprint port firstname gt p fname fprint port name gt p name fprint port sex gt p sex p 9 4 Widening and shrinking Bigloo introduces a new kind of inheritance widening This allows an object to be tem porarily widened that is transformed into an object of another class a wide class and then shrink ed that is reshaped to its original class This mechanism is very useful for implementing short term data storage For instance Bigloo compilation passes are imple mented using the widening shrinking mechanism On entry to a pass objects are widened 118 Bigloo 4 2b with the specific pass fields and on exit from a pass objects are shrunk in order to forget the information related to this pass Only instances of final classes can be widened and objects can only be widened in order to become instances of wide classes Widening is performed by the widen syntax widen wide class obj id value bigloo syntax The object obj is widened to be instance of the wide class wide class Fields values are either picked up from the pa
95. modulei o module2 o module3 o Execution produces a out module3 module2 Chapter 2 Modules 15 modulel argv a out The order of module initialization can be explicitly specified using with and use clauses 2 4 Qualified notation Global variables can be referenced using implicit notation or using qualified notation Im plicit notation is used when variables are referenced just by their name whereas qualified notation is used when variables are referenced by their name and the name of the module which defines them Qualified notation has the following syntax 0 lt bind name gt lt module name gt and is useful when several imported modules export a variable with the same name Using qualified notations instead of short notation only affects compilation When several variables are defined under the same identifier the compiler uses the two following rules in order to decide which variable is selected by an implicit reference 1 the variable defined in a module has a higher precedence than all imported variables 2 imported variables have a higher precedence than library variables 2 5 Inline procedures Bigloo allows procedures called inline and which differ from normal ones only in the type of code planted An inline procedure is a first class object which can be manipulated in the same way as any other procedure but when Bigloo sees a reference to one rather than generating a C function call to the function the bo
96. name eee nnn 54 output port name set 0 0008 54 output port position eee 59 output port timeout set ooooooco 54 output port ys tu o ds 53 output stringe esii rioter ee enne 69 output string port sss 53 Overview of Bigloo 0 00005 3 P peir nid isasueerD6oeledu NES PESEE inii Dents 236 pair or null eio we tena ae seres ks 27 E 27 Pairsvand lists lt i ect aaa ES 27 Parallelism tds A See wed EY re 191 parameters iud veste e RES EI 229 Password O ste Sehr eq xe Sra 65 path separator i ei cuya ere es 76 pattern matchings sire an E EEPE Ea EN 105 peek byte silx erp A oe 61 posk charity a ia EG 61 pem decode port eee 96 pemsread file isis il ii NAR EDU 96 Performance of the JVM back end 249 pgp add key to dDb cone rene pente metres 166 pgp add keys to db 5 ve eie 166 pgp db print k6yS comia es t VELIE uer 166 Pep dec Primicia ad 165 pBEp encrypt ida 164 pgp key string cesses eese 166 pgp key fingerprint see 166 pEp key id i e REC Eae it 166 PEPE iie demo E esc NOCTEM USE 166 pep make key db 0 cece cece ee eee 166 pgp password encrypt sees 164 PEp read file a RE 163 pEp read port 1 M IP aras 163 pgp read string esses 163 Pgp resolve key ee 166 A hab Reed css M rire ripis 165 pgp signature message sess 166 pgp subkey st
97. need a passphrase to unlock the secret key for user Bigloo Example 1024 bit DSA key ID A2DA694E created 2010 08 07 The following program reads OpenPGP signatures and verifies them For simplicity the key database will only contain one key but it could contain any number of keys let my key car pgp read file A2DA694E_Bigloo_Example pkey sig pgp read file msg gpg sig db pgp make key db pgp add key to db db my key print Signature message pgp signature message sig let signers pgp verify sig lambda id pgp resolve key db id for each lambda subkey display pgp subkey gt string subkey signers As expected the program verifies the correct signature verify Signature message Bigloo can verify gpg s signatures Bigloo Example 07ca0495a2da694e DSA Digital Signature Standard 14 3 1 2 Email Usage Usage of OpenPGP within mails is described in RFC 3156 Encrypted parts and signatures are encoded with their separate content types Sig natures are done over a canonicalized version of the message They also hash over the content type headers OpenPGP s recette program has an example for a signature from kmail that can be succesfully verified with Bigloo 14 3 1 3 Encryption OpenPGP allows messages to be encrypted with passwords in this context passkey or public keys It is also possible to encrypt a message for more than one recipient In such a case the data will be
98. not ensure hygiene for let syntax and letrec syntax Hygienic expansion is only guaranteed for define syntax Chapter 24 Parameters 229 24 Parameters The Bigloo parameters drive the global behavior programs A parameter is accessed via a pair of functions a reader and a setter The type of the value is given in this documentation by the name of the parameter of the setter bigloo strict r5rs strings bigloo function bigloo strict rbrs strings set boolean bigloo function Traditional syntax conforms to the Revised Report if the parameter bigloo strict rbrs strings is not f Otherwise constant strings specified by the are considered as foreign strings For example after reading the expression 11n231t4X 5 the following string is built which is equal to string 1 n 4X2 3 t 4 5 if bigloo strict rbrs strings is not f It is string 1 n 2 3 tab H4 5 oth erwise Printing this string will produce 1n23t4 5 The new foreign syntax allows C escape sequences to be recognized For example the expression 1 n23 t4 5 builds a string equal to string 1 newline 2 3 t 4 5 and printing this string will then produce 1 23 4 5 bigloo compiler debug bigloo function bigloo compiler debug set integer bigloo function bigloo debug bigloo function bigloo debug set integer bigloo function bigloo warning bigloo function bigloo warning set integer bigloo function
99. null environment 5 interaction environment Scheme report environment version procedure null environment version procedure interaction environment version procedure These three procedures have the definitions given in the R5RS so see Section 6 5 Eval in RRS for more details byte code compile exp env default environment bigloo procedure byte code run byte code bigloo procedure The function byte code compile compiles a Scheme expression into a sequence of byte codes that is implemented as a string The function byte code run execute such a sequence repl bigloo procedure This invokes the read eval print loop Several repl can be embedded The rep1 function can be used to implement custom Bigloo interpreters For instance one may write module repl rep1 When compiled this will deliver an executable containing the sole Bigloo interpreter 222 Bigloo 4 2b quit bigloo procedure This exits from the currently running repl If the current repl is the first one then this function ends the interpreter set prompter proc bigloo procedure The argument proc has to be a procedure of one argument and invoking this function sets the repl prompter That is to display its prompt repl invokes proc giving it the nesting level of the current loop as its argument get prompter bigloo procedure Returns the current repl prompter set repl printer proc bigloo procedure The argument proc has to be a procedure
100. number Note that the initial nonce passed using IV may be of any type As long as nonce init and nonce update correctly initialize and update the passed string The input s length of modes ecb cbc and pcbc must be a multiple of the block size Should this not be the case a padding algorithm must be specified pad Currently are implemented examples for hexadecimal string DD and cipher block size 4 e none No padding Raises an error should the input not be a multiple e bit Bit padding Add a 1 bit and then 0 bits Example DD 80 00 00 e ansi x 923 Byte padding Fill with x00s followed by the number of added bytes the counter inclusive Example DD 00 00 03 e iso 10126 Fill with random characters followed by the number of added bytes the counter inclusive Example DD 42 31 03 e pkcs7 Fill with the number of added bytes Example DD 03 03 03 e zero Fill with zeros This is only reversible if the input is guaranteed not to finish with a zero character Example DD 00 00 00 Alternatively users can supply their own un pad functions instead of a symbol The signature of a padding function is pad bool str bstring valid chars long 156 It receives the last block of the input Should the Bigloo 4 2b input be of correct length then the an empty block will be sent to the padding function valid chars indicates the number of read characters It ranges from 0 to blo
101. other than zero define ip re string append 1 9 ensure there s a non 0 digit ip re1 Or we could use negative lookahead to ensure that what s ahead isn t composed of only zeros and dots define ip re string append 7 0 not just zeros and dots note dot is not metachar inside ip re1 The regexp ip re will match all and only valid IP addresses pregexp match ip re 1 2 3 4 gt 1 2 3 4 pregexp match ip re 0 0 0 0 gt sf 6 Note that n0 255 lists prefixes as preferred alternates something we cautioned against in section Section 12 2 12 Alternation page 147 However since we intend to anchor this subregexp explicitly to force an overall match the order of the alternates does not matter Chapter 13 Command Line Parsing 151 13 Command Line Parsing Bigloo supports command line argument parsing That is when an application is spawn from an Unix shell the main function is called and its argument is bound to the list of the command line arguments See Chapter 2 Module declaration page 7 The args parse form may be used to parse these args parse list rules null rule else rule bigloo syntax The argument list is a list of strings Rules is defined by the following grammar rule gt section lt string gt lt option gt lt help gt lt s expression gt lt option gt lt s expression gt lt flag gt lt var gt lt var gt lt s ex
102. range 0 1 exp z expfl z log z logfl z sin z sinfl z COS Z cosfl z tan z tanfl z asin z asinfl z acos z acosfl z atan zl z2 atanfl zl z2 sqrt z sqrtfl z expt zl x2 exptfl z1 x2 exact gt inexact z inexact gt exact z number gt string z integer gt string i radix 10 integer gt string padding i padding radix 10 elong gt string i radix 10 llong gt string i radix 10 bignum gt string i radix 10 real gt string z unsigned gt string i radix 16 Bigloo 4 2b procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure The function integer gt string padding converts its arguments into a string with a left padding filled of characters O integer gt string padding 3 5 The function unsigned gt string only accepts the following radixes 2 8 and 16 It converts its argument into an unsigned representation unsigned gt string 123 16 unsigned gt string 123 16 bignum gt octet string bignum bigloo procedure Returns a binary big endian representation of the given bignum bignum string hex extern bignum gt octet string zx1234567 01234567 double
103. read char operation on the given port is guaranteed not to hang Tf the which When port is at end of file then char ready returns t Port may be omitted in case it defaults to the value returned by current input port using char ready consider the latency that may exists before characters are available For instance executing the following source code let proc run process bin ls 1 bin output pipe port process output port proc let loop line read line port print char ready char ready port if eof object line close input port port begin print line loop read line port Produces outputs such as For a Note char ready f total 7168 char ready f rwxr xr x lroot root 2896 Sep 6 2001 arch char ready f rwxr xr x 1 root root 66428 Aug 25 2001 ash char ready t discussion of Bigloo processes see Section 5 7 3 Process page 81 Thanks to Todd Dukes for the example and the suggestion of including it this documentation 62 Bigloo 4 2b read line input port bigloo procedure read line newline input port bigloo procedure Reads characters from input port until a Newline a Return or an end of file condition is encountered read line returns a newly allocated string composed of the characters read The strings returned by read line do not contain the newline delimiters The strings returned by read line newline do contain them
104. read only Chapter 18 Multimedia 203 comment bstring read only genre bstring read only track int default 1 This class is used as the base class of music tag formats id3 musictag Bigloo Multimedia class class id3 musictag version bstring orchestra obj read only default f conductor obj read only default f recording read only default f cd obj default f This class is used to reify the ID3 metadata used in the MP3 format vorbis musictag Bigloo Multimedia class class vorbis musictag This class is used to reify the Vorbis comments of OGG and Flac files 18 2 2 Mixer Bigloo proposes various functions and classes for controlling the audio volume of sound cards mixer Bigloo Multimedia class class mixer devices pair nil default The field devices is a list of available channels mixer close mix Bigloo Multimedia procedure Closes a mixer The argument mix must be an instance of the mixer class mixer volume get mix channel Bigloo Multimedia procedure mixer volume set mix channel leftv rightv Bigloo Multimedia procedure The function mixer volume get returns the left and right volume levels two values of the channel of the mixer mix The channel is denoted by its name and is represented as a string of characters The argument mix is an instance of the mixer class The function mixer volume set changes the audio level of a mixer channel soundc
105. represented as an UTF 8 string at the position i in string utf8 substring string start end library procedure string must be a string and start and end must be exact integers satisfying 46 Bigloo 4 2b O lt START lt END lt string length STRING The optional argument end defaults to utf8 string length STRING utf8 substring returns a newly allocated string formed from the characters of STRING beginning with index START inclusive and ending with index END ex clusive If the argument string is not a well formed U TF 8 string an error is raised Otherwise the result is also a well formed UTF 8 string iso latin gt utf8 string bigloo procedure iso latin gt utf8 string bigloo procedure utf8 gt iso latin string bigloo procedure utf8 gt iso latin string bigloo procedure utf8 gt iso latin 15 string bigloo procedure utf8 gt iso latin 15 string bigloo procedure Encode and decode iso latin strings into utf8 The functions iso latin gt utf8 string utf8 gt iso latin and utf8 gt iso latin 15 may return as result the string they receive as argument cp1252 gt utf8 string bigloo procedure cp1252 gt utf8 string bigloo procedure utf8 gt cp1252 string bigloo procedure utf8 gt cp1252 string bigloo procedure Encode and decode cp1252 strings into utf8 The functions cp1252 gt utf8 string and utf8 gt cp1252 may return as result the string they receive as argument 8bits gt utf8 string
106. second bigloo procedure bigloo procedure bigloo procedure bigloo procedure date week day date Returns the week day of a date in the range 1 7 bigloo procedure Chapter 5 Standard Library date yday date date year day date Returns the year day of a date in the range 1 366 date month date Returns the month of a date in the range 1 12 date year date Returns the year of a date date timezone date Returns the timezone in seconds of a date date is dst date 95 bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure Returns 1 if the information is not available O is the date does not contain daylight saving adjustment 1 if it contains a daylight saving adjustment integer gt second Converts a Bigloo fixnum integer into a second number day seconds Returns the number of seconds contained in one day day name int day aname int Return the name and the abbreviated name of a week day month name int month aname int Return the name and the abbreviated name of a month date month length date Return the length of the month of date leap year int Returns stt if and only if the year int is a leap year Returns f otherwise rfc2822 date gt date string rfc2822 parse date input port bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure
107. sha 1 symmetric algo cast5 mdc t Deprecated Encrypts msg string with the given password The returned PGP composition does not contain any information which hash algorithm and symmetric encryption algorithm has been used RFC 4880 specifies that IDEA and MD5 should be used However GnuPG uses SHA 1 and CAST5 Therefore Bigloo defaults to the latter algorithms Even though the usage of this PGP message is deprecated it yields the smallest encrypted data It may be of interest when compatibility with other tools is not a requirement but why use OpenPGP then The optional mdc flag triggers the usage of a modification detection code It is more secure against tampering but requires more space and might not be recognized by old openpgp implementations Chapter 14 Cryptography 165 pgp decrypt encrypted passkey provider lambda Bigloo OpenPGP procedure 1 password provider lambda key f key manager lambda key id 0 hash algo sha 1 symmetric algo cast5 Decrypts a PGP composition that has been generated by pgp encrypt or by Pgp password encrypt The function returns the decrypted message a string or f if decryption was not possible If the message can be decrypted with a private key then Bigloo will call the key manager and request a list of PGP subkeys that match the given key id If a subkey returned by the key manager is not yet decrypted Bigloo will invoke the password provider with the subkey
108. simple beta reduction default f optim symbol case Optimize case forms descrimining on symbols only default f optim sync failsafe Enable failsafe synchronize optimization default f optim unroll loop Loop unrolling optimization default unspecified pass Stop after the pass default ld pre processor An optional function that pre processes the source file default ZZ procedure 40aca0 1 prof table name Bprof translation table file name default bmon out profile library Use the profiled library version default f profile mode Bigloo profile mode default 0 purify Produce byte code verifier compliant JVM code default t qualified type file The qualifed type association file name default f qualified type file default The qualifed type association file name default jfile reader The way the reader reads input file plain or intern 290 Bigloo 4 2b default plain rm tmp files Shall the c and il produced files be removed default t saw Do we go to the saw mill default f saw no register allocation functions The list of functions disabling register allocation default saw register allocation functions The list of functions allowing register allocation default saw register allocation max size Max function size for optimizing the register allocation default 4000 saw register allocation onexpression Enable dis
109. special form which allows the inclusion of C text into the produced code It is only applicable to the C back end In particular the JVM back end see Chapter Chapter 27 Java Interface page 245 does not support it pragma ident string args bigloo syntax free pragma ident string args bigloo syntax This force Bigloo to include string in the produced C code as a regular C fragment of code This form must not be used without an in depth understanding of Bigloo C code production with unskilled use the produced C file may be unacceptable to the C compiler Values can be passed to a pragma form being referenced in string by expressions of the form number Such expression are replaced by the corresponding values the number of referenced values in string being exactly the number of values provided Here is an example of pragma usage define fibo x long pragma printf fib d d n 1 2 x fib x Arguments provided to a pragma form are not converted during compilation Hence pragma arguments can be of any types including foreign types A pragma result type can be specified using the notation pragma name where the default type is unspecified Then for instance the expression pragma bool 1 0 x will be considered to be returning a object of type bool C boolean while the expression pragma 1 0 x will be considered by Bigloo to be returning the unspecified typed object The compiler assum
110. standard input file of the process Redirection can come from a file or from a pipe To redirect the standard input from a file the name of this file must be specified after input Use the special keyword pipe to redirect the standard input from a pipe output permits to redirect the standard output file of the process Redirection can go to a file or to a pipe To redirect the standard output to a file the name of this file must be specified after output Use the special keyword pipe to redirect the standard output to a pipe error permits to redirect the standard error file of the process Redirection can go to a file or to a pipe To redirect the standard error to a file the name of this file must be specified after error Use the special keyword pipe to redirect the standard error to a pipe wait must be followed by a boolean value This value specifies if the process must be ran asynchronously or not By default the process is run asynchronously i e wait if f host must be followed by a string This string represents the name of the machine on which the command must be executed This option uses the external command rsh The shell variable PATH must be correctly set for accessing it without specifying its absolute path fork must be followed by a boolean value This value specifies if the process must substitute the current execution That is if the value is t a new pro cess is spawned otherwise the current execution
111. subscribe lss essen 213 mailbox unsubscribe ssss 213 maldita eue weis 212 215 Mi di lide eres eS hp PES 8 make asynchronous signal 191 make client socket sess o 84 make condition variable 181 make csv lexer oll fig woe E E 219 make datagram server socket 88 make datagram unbound socket 88 WMak6 date ssc eae up TEN MUERTE VEA 93 make directoriesSu ii rt in noer a MAH ER 80 make directory is toc ts de Tam eae ene ux 80 m make elong v ie ode STA Deut 32 MAKETAS MAME LN ey een hea 78 Make file path tidad nr dere ia 78 make hashtable cece cece eee eens 12 make hyphens 0 00 cc cece eee ee 218 n k liSt i Petes eit A Sie Na 29 makes le aii aes ee meee RSS 32 Inak mut x ness lacie se is 180 mak scheduler snapser wets as Meets Rex 189 make server socket cece eee e eens 86 make shared library name 79 make ssl client socket oooooomooooo 90 make ssl server socket ss 92 make static library name 79 Make S tr iia o SR Sea er exe 39 make string ptr null 06 238 make TAGveCtOEr nli drid ii a wa bine ae Vg 49 make thread iii A Ius 192 make ucs2 string lesse 44 make vector oros 4 pev atu ane perd tne 47 make void null sesleeeeses 238 make weakptr 0
112. temet er ede EE EAS 202 Insti cesa oder petet n aa eM AA 204 pusi closes ui A PER EHE 206 in sic clos8d vac sera IE eR 206 nusic crossfade tra ie REY 206 music event loop cece eee eee nne 207 MUSIC Mid a ecto ies eta E E eels 207 mn sic next lis 206 MUSIC Pali8G yeridi sd En ii 206 pu sic play aia 206 music playlist add ore 206 music playlist clear 206 music playlist delete 0 206 music playlist 88t mmooooooomooooo 206 musiC prev eode ux ea IAS 206 n sic random set oewnoscneae veu es 206 music repeat set eee 206 nusic reset eus Au Used 206 m sic reset error cided ireid y 207 mn sic seek iaa eee ye wa eee Bw od 206 MUST SOM ii Sanaa aque 207 MUSIC SONZPOS aep inper en a eee eee 207 MUSIC SCA Sata bees np bep ioo d ate 206 pisic STOP elle OLE Vence eno 206 music update status ccce 206 music volume get 66 cece cece ees 206 nusic volume set cusco 206 MUSICPLOC MUSIC inicia ei eee 205 MUsiCS CAUSAS ama 205 MUSICA Lin ra cn 202 mutex lock aiii arde 180 n tex name v TR vex 4 RD dis 180 m tex Specifio 2042 3 iso DAL MP MES 180 mutex specific set i lw PpfopngeixeRid 180 puter state e or 0 ro pRUE ES ES 180 193 194 n tex nlock 2 RT ARES E 180 MUG OX Pai pl wane eel oN eee e 180 N Name mangling 00 e eee e eee eee 242 nanoeconds date lessen 94 native r epl prin
113. the one in the SRFI registry This is to ensure that the feature identifier will be correctly recognized whether or not the Scheme system is case sensitive To support case insensitive Scheme systems the feature identifiers in the SRFI registry are guaranteed to be unique even when ignoring the case In order to distinguish Bigloo versions the following symbols are recognized in cond expand forms e bigloo e bigloo lt branch release gt e bigloo lt major release gt e bigloo lt major release gt lt minor release gt When finalizers have been configured the two following symbols are recognized by cond expand e bigloo finalizer e bigloo weakptr Bigloo implements differents SRFI for the compiler and the interpreter Thus their are two Bigloo SRFI registers One for the compiler and one for the interpreter Bigloo compiler SRFI register contains at least the following symbols e srfi 0 e srfi 1 e srfi 2 e srfi 6 e srfi 8 e srfi 9 e srfi 22 e srfi 28 e srfi 30 With respect to the currently used Bigloo back end one of these symbols is registered e bigloo c e bigloo jvm Bigloo compiler implements the following SRFI e bigloo e bigloo compile e bigloo lt major release gt e bigloo lt major release gt lt minor release gt Then the g flag is used the Bigloo compiler additionally implements the SRFI Chapter 30 SRFIs 267 e bigloo debug Bigloo interpreter implements the following SRFI e bigloo e bigloo eval
114. the execution blocks until the connection is established If the timeout is provided the execution unblocks after timeout microsec onds unless the connection is established If the protocol option argument is given it Chapter 5 Standard Library 91 specifies the encryption protocol Accepted values are ss1v2 ss1v3 ss1v23 alias ss1 tls alias t1sv1 or dtls alias dtlsv1 The default value is ss1v23 The SSL socket will sign the connection using the optional arguments cert for the certificate and pkey for the private key The certificate cert must be of type certificate and the private key pkey must be of type private key If any of those two arguments is given they must both be given If those optional arguments are missing the connection will be encrypted but not signed from the client side The CAs optional argument specifies the list of certificates to trust as CA Certificate Authority for the connection It must be a list of values of type certificate If the list is empty the default list of trusted CA is used set by the system Note that giving a list of trusted certificates turns on the peer server certificate validation an amp io error will be raised if the peer server certificate is not signed directly or indirectly by one of the certificates in CAs The accepted certs optional argument gives a list of certificate objects of type certificate which are accepted as peer server certificate If ac
115. the following source code The value of the read case s case argument may either be upcase downcase or sensitive Using any other value is an error 60 Bigloo 4 2b define main argv let loop exp read case sensitive if not eof object exp begin display exp write exp display display exp display print eq eq exp F00 eq exp foo loop read case sensitive Thus gt a out foo 4 exp foo foo eq f t FOO 4 exp FOO FOO eq t f read rp grammar port bigloo procedure read lalrp lalrg rg port emptyp bigloo procedure These functions are fully explained in Chapter 10 Regular Parsing page 125 and Chapter 11 Lalr Parsing page 135 define reader ctor symbol procedure bigloo procedure Note This feature is experimental and might be removed in feature versions The present SRFI 10 http srfi schemers org srfi 10 srfi 10 html pro poses an extensible external representation of Scheme values a notational convention for future SRFIs This SRFI adds as a new token and extends production rules of the grammar for a Scheme reader The form can be used for example to denote values that do not have a convenient printed representation as well for conditional code compilation It is proposed that future SRFIs that contain new read syntax for values use the amp notation with an appropriate tag symbol As a particular example and the reference
116. the globalization stage Stop after the type recovery stage Stop after the Bdb code production Stop after the constant allocation Stop after the integration stage Stop after the tailc stage Stop after the initialization construction stage Produce an include file for class accessors Produce an include file for effects requires saw Produce a C header file with class definitions Do not C compile and produce a c file Produce an indented c file Produce a JVM jas file Constants initialization mode Object system initialization Compile a library module Compile an additional library module Build an heap file Build an additional heap file Compile a main file for a distribution Display the Bigloo license and exit Add the license to the generated C files Specify an heap file or f to not load heap The library the heap belongs to Dump the content of a heap Specify an additional heap file Read source from binary interned file Read source only from binary interned file fread internal src file name NAME Set fake source file name fread plain target LANG Shell Variables TMPDIR Read source from plain text file DON T USE see native jvm 280 Bigloo 4 2b temporary directory default tmp BIGLOOLIB libraries directory BIGLOOHEAP the initial heap size in megabytes 4 MB by default BIGLOOSTACKDEPTH the error stack depth printing BIGLOOLIVEPROCESS the maximum number of Bigloo live processes BIGLOOTRACE l
117. the same order until their termination By default it is set to false which improve performances when there is a lot of thread to schedule Scheduler obj Bigloo function Returns stt if obj is a scheduler Otherwise returns 8f Scheduler obj Bigloo function Returns stt if obj is a scheduler Otherwise returns f current scheduler Bigloo function Returns the current scheduler The current scheduler is the scheduler which currently schedules the current thread This value is not mutable as it is set during the call to thread start default scheduler scheduler Bigloo function Sets or gets the default scheduler The default scheduler is the scheduler that will be used in the calls to scheduler react scheduler start or thread start if not specified It always exists a default scheduler T hat is it is optional for an application to create a scheduler scheduler react scheduler Bigloo function Executes all the threads started see thread start Section Section 16 2 2 1 Thread page 184 in the scheduler until all the threads are blocked A thread is blocked if the has explicitly yield the processor thread yield and thread sleep or because it is waiting a signal thread await A thread can be selected several times during the same reaction The function scheduler react returns a symbol denoting the state of the scheduler The possible states are e ready The Scheduler is ready to execute some threads e done All
118. to initili aze bigloo modules jvm char info tion to line info no jvm char info fjvm inlining fjvm constr inlining fno jvm inlining fno jvm constr inlining fjvm peephole fno jvm peephole fjvm branch fno jvm branch fjvm fasteq fno jvm fasteq jvm env VAR jvm jar no jvm jar jvm java FILE jvm opt STRING Traces t 21314 tPASS shape mkt Talun Compilation stages mco syntax expand expand module ast syntax check bdb spread obj trace callec bivalue inline inline beta fail abound initflow narrow tlift dataflow dataflow dataflow fuse Bigloo 4 2b Generate char info for the debugger in addi Do not generate char info for the debugger Enable JVM back end inlining Enable JVM back end inlining for constructors Disable JVM back end inlining Disable JVM back end inlining for constructors Enable JVM back end peephole Disable JVM back end peephole Enable JVM back end branch Disable JVM back end branch EQ no longer works on integers use FX Disable JVM back end fasteq transformation Make the shell variable visible to GETENV Enable JVM jar files generation Disable JVM jar files generation default Use FILE as JVM JVM invocation option Generate a trace file Force pass to be traced Some debugging tools private Stop after mco production Stop after the syntax stage see hygiene Stop after the preprocessing stage Produce the expanded mod
119. trace color 2 TOD trace port bigloo function trace port set bigloo function These functions return and set the output port used by traces Chapter 16 Threads 179 16 Threads Bigloo supports multithreaded programming Two different libraries programming are avail able The first one the Fair Thread see Section Section 16 2 Fair Threads page 182 enables simple easy to develop and to maintain code The second one the Posix Thread see Section Section 16 3 Posix Threads page 191 enables more easily to take benefit of the actual parallelism that is now available on stock hardware Because it is easier to program with fthread than with pthread we strongly recommend to use the former as much as possible and leave the former for specially demanding applications Both libraries are described in this chapter 16 1 Thread Common Functions Bigloo implements SRFI 18 Multithreading support This SRFI is available at http srfi schemers org srfi 18 srfi 18 html As Bigloo s threads are objects see Section Chapter 9 Object System page 113 the SRFT 18 s thread specific functions can be used with either the pthread or the fthread library This section describes the functions that are available independently of the multi threading library 16 1 1 Thread API Bigloo uses a set of primitive functions and methods to create run and handle thread For the sake of standardization the name and semantic of SRFI 18 has be
120. tte tex 1 1x z and zx For each generic arithmetic procedure Bigloo provides two specialized procedures one for fixnums and one for flonums The names of these two specialized procedures is the name of the original one suffixed by x fixnum 1 flonum elong exact C long 11ong exact C long long and bx big integer A fixnum has the size of a C 1ong minus 2 bits A flonum has the size of a C double An elong has the size of a C long An llong has the size of a C long long A big integer has an unbounded size number obj procedure real obj procedure integer obj procedure complex x bigloo procedure rational x bigloo procedure fixnum obj bigloo procedure flonum obj bigloo procedure These two procedures are type checkers on types integer and real elong obj bigloo procedure llong obj bigloo procedure The elong procedures is a type checker for hardware integers that is integers that have the very same size has the host platform permits e g 32 bits or 64 bits integers The 11ong procedure is a type checker for hardware long long integers Exact integers literal are introduced with the special te and ex prefixes Exact long integers literal are introduced with the special 1 and 1x prefixes bignum obj bigloo procedure This type checker tests if its argument is a big integer make elong int bigloo procedure make llong int bigloo procedure Create an exact fixnum integer from the fixnum
121. unwind protect print read csv record in close input port in Chapter 22 Eval and code interpretation 221 22 Eval and code interpretation This chapter describes the Bigloo evaluator 22 1 Eval compliance Bigloo includes an interpreter Unfortunately the language accepted by the interpreter is a proper subset of that accepted by the compiler The main differences are e No foreign objects can be handled by interpreter e Classes of the object system cannot be declared within interpreted code e The interpreter ignores modules and has a unique global environment Compiled code and interpreted code can be mixed together That is interpreted code is allowed to call compiled code and vice versa This connection can be use to circumvent the missing features of the interpreter see Section see Section 2 2 Module Declaration page 7 for a description of how to connect compiled and interpreted code By default the evaluator assumes that operators from the standard library e g car are immutable Hence it optimizes these operators s calls This optimization can be disabled using the bigloo eval strict module parameter described in the chapter describing the parameters see see Chapter 24 Parameters page 229 22 2 Eval standard functions eval exp env procedure This form evaluates exp The second argument is optional It can be the evaluation of one of these three function forms scheme report environment 5
122. use by default the lexer supporting standard csv files It returns unspecified Upon error it will throw an amp invalid port error or amp io parse error exception csv map proc input port custom lexer bigloo procedure csv map has two required arguments a procedure to apply to each record and the input port of the csv data to parse and an optional argument indicating the lexer to use by default the lexer supporting standard csv files It returnsthe results of applying proc to each record as a list Upon error it will throw an amp invalid port error or amp io parse error exception make csv lexer sep quot bigloo form make csv lexer has two required arguments a character used to separate records and a character for quoting It returns custom lexer bigloo variable csv lexer Variable csv lexer is a bigloo csv lexer supporting the standard comma separated value for mat bigloo variable tsv lexer Variable tsv lexer is a bigloo csv lexer supporting the tab separated value format 220 Bigloo 4 2b bigloo variable psv lexer Variable psv lexer is a bigloo csv lexer supporting the pipe separated value format The following is a simple example of using the bigloo csv library It parses a single record from the given csv data and prints it module example library bigloo csv main main define csv data dog cat horse npig cow squirrel define main args let in open input string csv data
123. z key i j 1 export foo x y optional z key i j 1 Chapter 5 Standard Library 25 5 Standard Library This chapter presents the Bigloo standard library Bigloo is mostly R5RS compliant but it proposes many extensions to this standard In a first section Section 5 1 Scheme Library page 25 the Bigloo R5RS support is presented This section also contains various function that are not standard for instance various functions used to manage a file system Then in the following sections Section 5 3 Serialization page 68 Section 5 4 Bit Manipulation page 70 and Section 5 7 System Programming page 74 Bigloo specific extensions are presented Bigloo input and output facilities constitute a large superset of the standard Scheme definition For this reason they are presented in a separate section Section 5 2 Input and Output page 53 5 1 Scheme Library When the definition of a procedure or a special form is the same in Bigloo and Scheme we just mention its name otherwise we explain it and qualify it as a bigloo procedure 5 1 1 Booleans The standard boolean objects are t and f Note the empty list is true not obj library procedure not returns t if obj is false and returns f otherwise not t gt f not 3 gt f not list 3 gt df not f gt Ht not 0 gt HI not list gt f not nil gt boolean obj library procedure Boolean returns t if obj is either t or
124. 0 34 67 Interpreting deck AD ye a 300 JAM Pretty Printings cache eer t e id 301 94 8 EXPO ias A A gee eee eed 301 34 9 On line Documentation sssessseseeeee ee eee 301 34 10 Searching for Source Code 6 eee ees 302 34 11 Importing and Exporting 0 cece eee eee 302 34 12 Debugelng iia ken HON DE Saka PIN ME 302 94 13 Prohlmgc sce AA 302 34 14 Revision Control ssssssseeeee e 302 34 15 Literate Programming 0 ee eee eee 303 35 Global Index uis v LER t bad 305 36 Library Index nthe ot etr n DEC ER 323 Bibliography onic d o doch et a pe dH A x 325 37 Table of contents eese 327 Bigloo 4 2b Short Contents Acknowledgements A A a Stee eae 1 1 Overview OLBIEIOO cbr bere que Tous to boe foil 3 2 WMO eG ae A A A e UM esr anc ri 3 Gore Langage ev s ee Xo bh E epi Wr eura esce dt 17 4 JSSSbGQUppOEb s equ re dod dob ec Ded tte doberde aoc mus tane nos 23 a dear neon ma oes ne pes eee eee 25 6 Pattern Matching eure RR A ee eee eee eae 105 q Fast search ur 6d qux en e d eh and NES Ese dede Ted du 107 8 structures and Hecordsuilg luce ra e ex ERO 109 9 Object Systems a6 obi dere e RO eS Ce Erb RR o E UR 113 IU Deeular parsitgs sarro d Ae REESE ds eee ees 125 LE Tari parete el en teeta aye deci alea 135 12 Posix Regular Expressions 2436 ena RR Xp E ed 139 13 Command Line Parsing 234324929 ras al een ees 151 14 a A St are ne tie t dte EE Ata e
125. 0 directory path list s sese 80 A A e kf series 80 dirname 235 2 Res ate pois Aedes eu er ale ra ee Peg 78 display a ii E MEDI DHU ULIS 63 displays ul inte 63 display circle 419p RED SUCHE DIG eme d 65 display string ver E REEL IEEE RAS 65 display substring ccce 65 dO c ets salutes sa ike ati eee Eh Sieve adh EE 22 double ieee string esses 36 double llong bits sels 37 POD i ume TO 28 dSa SIgnuilcooiad uemmeba AR enm UAE 161 dsa verify io ue a Ad EE 162 DER nep NP ME NEP 161 DSSSL formal argument lists 23 DSSSL SUppOEl emethE e E EMUT DS EAE 23 dump trace stack iiiseilec ducere cete 171 duplicates dano 116 duplicate class sese 116 dynamics demi e tee bild 223 dynamic unload ccc cece eee eee eee 224 dynamic wind 2v itx et ia 51 E is Seg Ee PRG RES REPE 272 elgamalo decIypt o ooooooooommmmmmmooo 162 elgamal encIypPt ooooomoommmmmmmmooo 162 ElGamal Key eee 162 elgamal key length ssssss 162 elong fixnum it UNE 37 elong flonum 6 id 37 elong gt string 00 e eee eee ee eee 36 Glong t b A ia 32 email normalize csse 211 Embedded Bigloo applications 243 encrypt file bString oooooooooomo 153 encrypt mmap DSTI iNB oooooocoooommmo 153 encrypt port bsString8 oooooocoooommmo 153 encrypt sendchars l
126. 0 final classu o125 epee na eevee e RRLC RE 113 find Shite mde a uo Leod te eru ae 29 find clas8 ewxb4AEISPQe b Ob CH I hM 120 find class field uerus ets 122 find file path eee eee 79 Pind staal sii iia eee ea edn ES 29 a 32 e A pee fda ona tees 32 o A ek eR wee dae x 37 fixnum flonum A eee 37 fizun Li a xx 37 LIA a 32 TLac musICtag cuina tiria euer ends 202 float gt ieee string 00000 36 float int BitS 2s db gea ET 3T flon m qe rece Lacer d nee A 32 flon m elong ti ta 37 ETOnUM PAM ei a E 37 flonim Lio tar o id 37 A RR 32 LO tad de A wa E XN EE 35 PLOOLL 2k rr Pet ees aad Pelle he hat 35 flush binary port iii 69 flush output port p e6e ehee ede 63 for each iuo sueco ko ee ered Sore hae ws SUG 50 RN 50 format oieee AS AA 63 EPICA e id 63 fprintf eier c lS UI Eie 64 free pragma lt ident src sdb woken eee ee eee 242 BLOM tii AR ad She ed VG 10 G b2312 Sucs2 i ee tS 218 Bed wrens A AD esa bee NER a dt eae 35 generate rsa key eee 158 Generic functions 117 Genericity of arithmetic procedures 272 POMAR 31 genuurd A DARE RA pn peg 31 get class serialization TO get custom serialization TO Bet interfaces 2 0 sos ae aire ee ay 89 get opaque serialization 70 get output string cece eee eee 59 get procedure serialization TO get process serialization
127. 1 let syntat ar toi 227 DOCKS Cta E 20 231 letreck AN 21 O A RE DE IERI 227 libFATI6S roce creer kostet I e 251 IA prary e dad Deu edi 13 library and eval ooooooooocoocmrmm m o 254 Library and inline functions 253 Library and macros sselseessesssee 258 Library and modules essseesus 257 library and repl sslseseseeee esses 255 lXbrary existB Grete ai eee 254 Library dra os 254 library translation table add 253 Limitation of the JVM back end 246 O o een ce 271 Bigloo 4 2b VS EEEE dt S 27 IiSt 2Stringu da eese e 42 list 2TAGYVGCUOE S evo posee tad 49 list ucs2 string eia EE k pE REE 44 liSt 2yeCt E se nds ck eae enon gh ee nates 47 Ii1StzCODY rn la aaa 30 A ERE Wee O 28 Iist split x ld ee se IAS ia 29 Jist tabulate e enr eee UE 29 Iist tallic i debe eU eue RR Gd 28 TISTE A NI RR v RD LIE E ata 27 literate programming sese 303 E i ed byte i eer iA 37 liong flomim erratas wi eu EIE EE 37 llong z string 2k dns td 36 llong bits double 0 00 37 LLO AAA 32 Toad ri ta RIA 11 222 load hyphedsiurats alii 217 AA ggg bt eee eke 223 loadqunisesiicte 9nbpesnre b PIN PER 222 A esrb celata dites 36 LT aOR ae Nei ROPE rere DEO P REN 36 long fixn m 2 tt hanes aes E Epp 32 macro expansion e pe vimana neii ia a E eee 227 Mad 209 nail head r list uu cwee e EE 211 Mad
128. 1 v2 26 1 6 8 C opaques This form defines opaque types lt opaque type gt opaque Let us suppose the type type opa opaque Bigloo creates the following functions e A type checker opa bool obj obj This function returns stt if the argument obj is of type opa and f otherwise e Anequality checker opa bool opa opa This function returns t if the arguments are equal and f otherwise Opaque types are relevant when a C value must transit via a Scheme function from a C function to another C function The value can t be used in Scheme because no accessors are defined over that type it can only be send back to a C function Here is an example of Scheme code using opaque type module foo extern type filedes opaque FILE macro _fopen filedes string string fopen fgetc int filedes fgetc fclose filedes fclose export fopen filedes bstring bstring fclose filedes fgetc char filedes define fopen fname mode fopen fname mode define fclose filedes fclose filedes define fgetc filedes integer gt char fgetc filedes 242 Bigloo 4 2b Note To illustrate the default type compilation of extern function we have voluntary introduced an incomplete declaration for the fclose function This will make Bigloo to produce a warning when compiling that module 26 2 The very dangerous pragma Bigloo special forms y g Bigloo has a
129. 229 bigloo strict r5rs strings set 229 bigloO LfdCe ia iris il ad 229 bigloo trace color cece eee eee 229 bigloo trace color set s 229 bigloo trace set 6 cece eee eee 229 bigloo trace stack depth 230 bigloo trace stack depth set 230 bigloo warning cece eee eee ee 229 bigloo warning set 00 cee eee 229 Dign m cu chads eee Want E tia q 32 bignum gt octet string 00008 36 bignum gt string a Ea EEEa aa 36 bigHum e narena wi pene a aE n 32 binary port i i iia 69 bind exit cidcid 51 bit manipulation 00 eee eee eee ee 70 DAM hate a cee e 71 bit andelong ici hice es ere ged Mawes aes 71 bit andllong cenar e eee ted Y gd 71 DitSl Said Da 71 bit lshel ong 2 kee vit dida e eu tye alada 71 bit lshllong armeene ia ad bye eem pe aid doe 71 bit nOot ue otv X RDUM eee Mise 71 bit notelong cece eee eee 71 Dit notllong osc seca ree rm 71 Dit HOF asa iiaye a ecules eas 71 pit orel ng nl esl eed pete ion tek 71 Bait orllong adria rw Sell neat dela 71 bit rSh is Gee then do 71 bit rshelong 2 2 e cscs evar ipod pte 71 bit rsh llog ii ee 71 DLbqursh cece hens ieee ne Eee 71 bit urshelong genii akiai eee eee 71 bit urshllong l eclcll cx ee ed et eee eed 71 DICO neon athe tke ieee ue edet 71 bit xorelongz ordi ate elie dus id 71 bit xorllOng be
130. 3 certificate subject s isecen ccc eee eee ee 93 o a AA ree ey ate sansa uns 93 Certificates csi ED RARE REA PERROS 93 char 2integer ics ouv p D lcd 38 clar 2u682 4 d diverge Edad Ere 39 char alphabetic eese 38 Ghar ciks T 22e 3 ada 38 charecicX s E P AER 38 ehar eIn era ei reen 43 e piRECHEO E P TR 38 Ghar ci SSR 4 4L ccs eere ea pea eed 38 Ghar ResbrbhRawpReqQunbesp chant 38 char downcase eese 38 char lower case t i enge o a Ea egt n 38 char numeric pedio aeri ee o 38 har ready ci ne ta REC iee Ena i RR eo dag 61 char ready and run process 61 char pCcase v e rre ads 38 char upper case ls nn 38 char whitespace see 38 charem wor ouis Lee RM MER CUN 38 308 CAT A A PUES 38 CO cutn ie A ERA 38 CAT Maid naaa 38 CA alada 38 Char is dada aa ia 38 Characters 3 ida 38 Chdir 3 oes kas NC 78 CAM rra tias pollas 81 CIPLOO Piru oa 234 circular representation 00e eee eee 65 CLASS Lp IA dao 113 Class declaration sees 113 class all tido ariel aa et od 122 ClASS Creator nid ais eg Seis b AN EU E 123 class field accessor uees 122 class field lnfOt ceu ia 122 class field mutable ssssus 122 class field mutator lees 122 class field nam e is hiv rs 122 Glass cfieldf creases vec Eu iras 122 cl sscfieldS 1 ta e eL eu 122 Class OMS idad 121 CLASS DML tia ey 115 class predicate cioen o
131. 3 Signal broadcast signal val Bigloo function Broadcasts signal to all threads started in scheduler immediately that is during the reaction This function can only be called from within a running thread If the optional argument val is omitted the signal is broadcast with an unspecified value thread start instantiate fthread body lambda thread await foo print scheduler instant current scheduler thread start instantiate fthread body lambda broadcast foo scheduler start t Chapter 16 Threads 191 Scheduler broadcast scheduler signal val Bigloo function At the next react broadcasts signal to all threads started in scheduler This is used to impact running threads from outside any threads If the optional argument val is omitted the signal is broadcast with an unspecified value make asynchronous signal proc Bigloo function This function invokes in the background the procedure proc This function takes one parameter which is the signal that is broadcast when the invocation returns When the host operating system supports parallel executions the invocation of proc is executed in parallel with the waiting thread Asynchronous signals can be used to implement non blocking system operations such as input output Here is an example that illustrates how to implement concurrent programs that behaves similarly with Fair Threads and Posix Threads define expander read lambda x e
132. 4 2b Bigloo A practical Scheme compiler User manual for version 4 2b October 2015 Manuel Serrano Copyright c 1992 99 2000 02 Manuel Serrano This program is free software you can redistribute it and or modify it under the terms of the GNU General Public License as published by the Free Software Foundation either version 2 of the License or at your option any later version This program is distributed in the hope that it will be useful but WITHOUT ANY WARRANTY without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE See the GNU General Public License for more details You should have received a copy of the GNU General Public License along with this program if not write to the Free Software Foundation Inc 59 Temple Place Suite 330 Boston MA 02111 1307 USA Acknowledgements 1 Acknowledgements Bigloo has been developed at Inria Rocquencourt by the Icsla team from 1991 to 1994 at the University of Montreal in 1995 and at Digital s Western Research laboratory in 1996 University of Geneva during 1997 and from the end of 1997 at the University of Nice I would like to express my gratitude to Hans J Boehm for his Garbage Collector BoehmWeiser88 Boehm91 Jean Marie Geffroy for his pattern matching compiler Quein necGeffroy92 Dominique Boucher for his Lalr grammar compiler William Clinger for his syntax expansion implementation and Dorai Sitaram for his contribution with
133. 5 current microsecondS o ocococcccccccccccc 94 current nanoseconds 00 cece eee eee 94 current output port csse 55 current scheduler ssssssss 189 current seconds ie isnsli e T9 bre epe b els 94 current thread cocina vs 179 current time idcmelRt petli9 es ee tats 191 Customtypes i diel be I eb eI UPPER TUER 263 D database cei eeclesie ene rie 197 datagram socket TeceiVe oooooocococococcoooo 88 datagram socket send suse 89 date uerus wrd dei dd Sosa nip qu ito d tfe 75 Datini EU E ERU 93 Chapter 35 Global Index date nanoseconds eee eee eee 94 date gt ric2822 date ica chee tensa rea 95 date seconds wee ib 94 date strihg isz s s vi lik It ERES 94 dat utc string ocxi xl yl es 94 ES s EnA M OXORUURNLDILE SO RES 94 date day v s d A de eL raus 94 date ho eed ubt bm et ud 94 date Ts dst ween pide ede ees ee te 95 date Minute s kh imrar ae hese teted ied 94 date A Gis ad ie Ae eas ee 95 date month length 6 cece eee eee 95 date nanosecond liii eI d ees 94 date second onse aA eh Ger dle 94 date timezone stan cic tia Sette ety eae viet 95 date wdaysilzrieccma v eR EuIPe Y E eta eens aa d 94 date week day perle cre 2k et 94 date ydayL AN NN o 95 date year d eg remi eR TA 95 date year day ii e P PURREODESUEYE 95 ptr CLER 93 day aname i c s idis hb eese els ubt 95 da DM to o pu SS ted 95 day seconds
134. 5string sees o 36 unspecrfied Mei ve xl es RIDE es 52 Ud ia ie 68 unwind protect o bocas dia Dia bk 51 uri decode si poeh h eS pA RRTLE 101 uricdecodel oo v pua ES rE eS 101 uri decode component 0 cece 101 uri decode component 0 101 Uri AAA Deas Soe anata ws Bae td 100 uri encode component eee eee 100 mdp M ares TA 100 rl decode Js ON 101 url decodel iii a 101 url encode vec A br a 100 UGTA par Ses 5 face Salas CR PTS 100 url path encode ye ELEren en Eat 100 url sans protocol parse 100 Usd a ds setis de dal e 9 user EXTENSIONS oia acia 297 Using C bindings within the interpreter 243 uUtf8 8b3bSuT o ho ds 46 utt9 8bitsSl 9 1 01 p PARS AIDS 46 utf8 5Ccpi2b2 5 pe trei es 46 utfS8 2cpi2b2 ace 46 Wtfo iS0 latin a 46 utfS iso latinl coeneecetr er are 46 utf8 is latin 1b e eL pas 46 utf8 iso latin 15 esses 46 utf8 codepoint length sss 45 utf8 string gt ucs2 string sss 45 utf8 string encode cece eee eee 45 utf8 string length oseere eoi iseni 45 utf 8 string ref 6 ccc eee Ee 45 MELS StrIN GP sects ined A a 45 Bigloo 4 2b VALUES a AAA cee ca eee SY 52 vCard Soke Sheed e 210 MOAR Dies te ima oia 210 MECHA a da iones E 47 yector 118t lix EPIS EM 47 vector append id s ii hes 48 yector copy tacita SEP 48 vector copyls kl
135. 6 Bigloo 4 2b music close music Bigloo Multimedia procedure music reset music Bigloo Multimedia procedure music closed music Bigloo Multimedia procedure Closes resets and tests the state of a music player music playlist get music Bigloo Multimedia procedure music playlist add music song Bigloo Multimedia procedure music playlist delete music int Bigloo Multimedia procedure music playlist clear music Bigloo Multimedia procedure These functions controls the playlist used by a player Note The song argument is an UTF8 encoded string see Section Section 5 1 10 Unicode UCS 2 Strings page 44 whatever the local file system encoding is The function music playlist get returns a list of UTF8 encoded names e music playlist get returns the list of songs UTF8 names of the current playlist e music playlist add adds an extra song UTF8 name at the end of the playlist e music delete removes the song number int from the playlist e music clear erases the whole playlist music play music song Bigloo Multimedia procedure music seek music time song Bigloo Multimedia procedure music stop music Bigloo Multimedia procedure music pause music Bigloo Multimedia procedure music next music Bigloo Multimedia procedure music prev music Bigloo Multimedia procedure These functions changes the state of the music player The function music seek seeks the playback position to the position time which is an integer den
136. 7 Non greedy quantifiers 0 cece eee eee eee 144 12 2 8 Clusters cen tortie DS Pa quad 145 12 2 9 Backreferences ata eee eee eee eres 145 12 2 10 Non capturing clusters 0 0 0 e eee eee eee eee 146 12 2 L1 C A O 146 12 2 12 AMA Miri a na 147 12 213 Backtrack ii ting ete el ae aie eee 148 12 2 14 Disabling backtracking 2 0 e cee eee eee 148 12 2 15 Looking ahead and behind 204 148 lv 12 2 16 Lookahead esses 149 T2207 bookbehlimdz oa iet Ad a 149 12 3 An Extended Example 0 0c cece eee een eee 149 13 Command Line Parsing 151 14 Cryptography AA oti A A 153 14 1 Symmetric Block Ciphers 0 00 c cece eee eee 153 1451 String to Key ii perii ERREUR 157 14 2 Public Key Cryptography occcococccccnnccccnnccccn 157 14 2 1 Rivest Shamir and Adleman RSA 158 14 24 11 RSA Keys eui Re PIER ta 158 14 2 1 2 RSA basic operations 0 0 0c eee eee 159 142 13 bxamplesi 5e een ie ete RI s 159 142 14 RSA REC 3 4 resina eb pan 160 14 2 2 Digital Signature Algorithm DSA sss 161 14 2 3 ElGamalicin ad E ERREUR E 162 14 24 PEM AA AA 162 14 39 OpenPGP cerae teet EA tg 163 14 9 1 Examples cer dE ERG 166 143 020 AS A Aer hereto eet 166 14 3 1 2 Email Usage roca DIY LER 168 14 3 1 3 Emncrypti n utet UO qub 168 14 4 Development sssssese
137. Arrate 300 IntfospectioOn d te ERE 122 inverse utf8 table eee 47 io unknown host error ooocooocooocccccccoc 89 A duele aperta doles 30 IP n mb er vui ira ERES 85 18 87 A DICEREM CU 121 VIA ln devo 115 312 iso latin Sutff A 46 iso latin utf8 onere ve I bes 46 iso8601 date date oooo ocoooooocccc eee 95 iso8601 parse date cece eee eee 95 J DAA eec nce Vr etre AE NE HE IU ODER 12 Java interface vs argar vans Moka a Uns 245 jfile oie od A Ue Lust 245 JiglOO J Iib he EA 24T join timeout exception 191 Jpeg eif entiere Blane ED Pee NE Nen US 201 jpeg exif comment set 06 201 JVM requirement 0 0 c eee eee eee eee 271 K keyword 2String i Losi cys sie tent Ltda 32 keyword gt symbol copita 32 E A s al hid t3 eA is 32 keywords i sai tae IRE EM oe de at 32 kmpsMmap 2 3208 sydd es E eels 107 kmp String ctiRSILAVexS REPRE e 107 Temps Ba DO i dac de RB CERE AUC RM xS 107 Knuth Morris and Pratt 00 107 L VADER 21 231 Lalr grammar and Regular grammar 137 Lale Darse Ad 135 Lalr precedence and associativity 136 lalr 1 grammar definition 135 lalr grammar o a poa as 135 Lambda coria epe EUR HEN DURAS 18 Last pair oii cesses aad bie eee ia 28 DCM ich ee as 35 LP EA id 95 Tength iisen il de ss ta 27 let xy dd dad e baie MER 20 231 e essit RA eeu ea Lames eam ees 20 23
138. Bigloo type a Bigloo class an already defined Java class or an already defined Java array For an array named ar Bigloo generates e a creator named make ar which is a function of one integer argument e a predicate named ar e a getter named ar ref which is a function of one integer argument e a setter named ar set which is a function of two arguments an integer and a value of the array item types e a length named ar length Example module foo java array int int class bar method static hello int int hello bar main main Chapter 27 The Java interface 249 define main argv let tab make int 2 int set tab O 3 int set tab 1 6 print bar hello tab 27 4 6 Exporting Scheme variables As for the C connection a Scheme variable or function can be exported to the Java world if and only if it is also exported using an export Java clause Type information is given in the Scheme exportation thus the only requirement for a variable to be Java exported is to be given a Java name The Java lt export clause gt does this lt export clause gt gt export ident lt string gt Here is an example of exportation module example export fib long long java export fib scheme_fib define fib x if x 2 1 27 4 7 Bigloo module initialization By default Bigloo modules are initialized when the application starts It might be convenient to initia
139. ING cheader STRING C header cfoot STRING C foot rpath PATH Add C runtime path rpath ldopt STRING Invoke ld with STRING ldpostopt STRING Invoke ld with STRING end of arguments force cc o Force the C compiler to use o instead of mv ld relative Link using l notation for libraries default Id absolute Link using absolute path names for libraries static bigloo Link with the static bigloo library static all bigloo Link with static version of all bigloo libraries ld libs1 Add once user libraries when linking 1d libs2 Add twice user libraries when linking default ILIBRARY Link with host library auto link main Enable main generation when needed for linking no auto link main Disable main generation Jvm specific options jvm shell SHELL Shell for JVM scripts sh msdos jvm purify Produce byte code verifier compliant JVM code default no jvm purify Don t care about JVM code verifier jvm mainclass CLASS JVM main class jvm classpath PATH JVM application classpath jvm bigloo classpath P JVM Bigloo rts classpath jvm path separator SEP Set the JVM classpath separator jvm directory NAME Directory where to store class files jvm catch errors Catch internal JVM errors no jvm catch errors Don t catch internal JVM errors jvm jarpath NAME Set the JVM classpath for the produced jar file jvm cinit module Enable JVM class constructors to initili aze bigloo modules no jvm cinit module Disable JVM class constructors
140. L it exists a simple workaround It consists in implementing a new REPL and linking it against dynamic libraries This can be done as cat gt new repl scm lt lt EOF module new repl repl EOF bigloo new repl scm o new repl new repl 1 gt dynamic load If init point is specified and if it is a string and if the library defines a function named init point this function is called when the library is loaded Init point is a C identifier not a Scheme identifier In order to set the C name a Scheme function use the extern export clause see Section see Chapter 26 C Interface page 233 If the init point is provided and is not a string no initialization function is called after the library is loaded If the init point value is not provided once the library is loaded dynamic load uses the Bigloo default entry point Normally you should not provide an init point to dynamic load unless you known what you are doing When producing C code to force the Bigloo compiler to emit such a default entry point use the dload sym compilation option see Section see Chapter 31 Compiler Description page 271 This option is useless when using the JVM code generator Let s assume a Linux system and two Bigloo modules The first module modi eval export foo export foo x define foo x print foo x 224 Bigloo 4 2b foo 4 The second module mod2 import modi mod1 scm eval export bar expor
141. NAME dload init gc For GC initialization for dynamic code heapsize SIZE Set the initial heap size value in megabyte Configuration and path version The current release revision The current release short format query Dump the current configuration q Do not load any re file eval STRING Evaluate STRING before compiling load FILE Load FILE before compiling I DIR Add DIR to the load path lib dir DIR Set lib path to DIR L NAME Set additional library path lib version VERSION Set the Bigloo library version libgc version VERSION Set the Bigloo GC library version libgc GC Use the given GC library Back end native Compile module to native object file via C jvm Compile module to JVM class files saw Cut the AST in the saw mill no saw Disable saw back ends i Interprete module Dialect snow Compiles a snow source code scmpkg spi Compiles a ScmPkg source code nil Evaluate as f in if expression call cc Enable call cc function Chapter 31 Compiler description 275 hygien Obsolete R5rs macros are always supported fidentifier syntax SYNTAX Identifiers syntax r5rs default or bigloo fno reflection Deprecated fno reflection Deprecated fclass nil Deprecated fno class nil Deprecated farithmetic Suppress genericity of arithmetic operators farithmetic overflow Suppress arithmetic overflow checks fno arithmetic overflow Enable arithmetic overflow checks fcase sensitive Case sensitive reader def
142. R 131 the downcase keyword eee 130 the downcase symbol ssssss 130 the failure og x e b yx e elder Pates 130 the fixn m 0 50 X Sb RRERURZeROHbI 130 th flonum i t vite Evite UR E Beek eS 130 the keywordt acuedsein gy e MER er eas 130 the length l l airada 129 tHE Sport sie Duce b ARR IRR NEP EPIS 129 Lh StrlHpg tt v HG 129 th Substring i gave er I gate 130 the subsymbOol i I RR MD EE va 130 the SymbOol Soter atem dv aD trt 130 the upcase keyword eee 130 the upcase symbol o oooocoococccccccoo o 130 thread aWait lio cts ao REESE Go 185 thread Wait tt uem REESE n 187 thread await values o o o ocooommmcooo oo 187 thread await values o o o o oooooooo 189 thread cleanup ec eee eee cece eee 180 thread cleanup set 0005 180 thread get values 0 cece eae 186 thread get values terenon ics 188 thread join stesso RISE 180 184 193 CA tee BR REI PE ERES 179 thread parameter ee 180 thread parameter set sssss 180 thread fesume o IIb es 185 thread sleep 0 180 184 192 thread specifici core exert is 179 thread specific set eee 179 thread sStart c ooooo ooo 180 184 192 thread start joinable 180 192 thread suspend 0 cece eee 185 thread terminate 180 184 192 319 thread yi
143. TP connection define wget url define parser ip status code header clen tenc if not and gt fx status code 200 lt fx status code 299 case status code 401 raise instantiate amp io port error proc open input file msg Cannot open URL authentication required obj ur1 404 raise instantiate amp io file not found error proc open input file msg Cannot open URL obj ur1 else raise instantiate amp io port error proc open input file msg format Cannot open URL a status code obj url cond not input port ip open input string clen input port fill barrier set ip elong gt fixnum clen ip else ip multiple value bind protocol login host port abspath 102 Bigloo 4 2b url parse url let sock http host host port port login login path abspath ip socket input sock op socket output sock with handler lambda e if isa e amp http redirection with access amp http redirection e url wget ur1 raise e read string http parse response ip op parser The optional argument args is used for post method The actual value should be a list of lists Each of these sublists must have two values e the argument name e the argument actual value The argument name can be either a string which is the name of the argument or a list of two elements In that case the first element of these list is the argument name
144. Tables Bigloo offers hash tables with support for weak pointers Here are described functions which define and use them make hashtable bucket len max bucket len eqtest hash bigloo procedure weak keys weak data create hashtable size max bucket len eqtest hash bigloo procedure weak max length bucket expansion Defines an hash table for which the number of buckets is size The variable max bucket len specify when the table should be resized If provided these two values have to be exact integers greater or equal to 1 Normally you could ignore size and max bucket len arguments and call make hashtable with no argument at all The argument eqtest enables the specification of a comparison function The first argument of this function is the keys contained in the table The second argument is the searched key By default hash tables rely on hashtable equal which is defined as define hashtable equal obji obj2 or eq obji obj2 and string obj1 string obj2 string obji obj2 The argument hash specifies an hashing function It defaults to get hashnumber The arguments weak keys weak data and weak both specify respectively whether the hash table should use weak pointers to store the keys and or the data By default a hash table uses strong pointers for both keys and data Each optional arguments size max bucket len eqtest hash weak keys and weak data can be bound to the Bigloo value unspecifi
145. The Bigloo module foo scm will first be compiled and then executed Of course one may consider more complex compiler drivers where it is first checked that the module is not already compiled Chapter 31 Compiler description 271 31 Compiler description 31 1 C requirement Instead of producing assembly code Bigloo produces C code This C code is ISO C com pliant IsoC So it is necessary to have an ISO C compiler The current version has been developed with gcc Stallman95 31 2 JVM requirement In order to compile the Bigloo JVM back end you have to be provided with a JDK 1 2 or more recent available at http www javasoft com The JVM must support for noverify option because by default Bigloo produces JVM code that is not conform to the rules enforced by the Java byte code verifiers 31 3 Running NET programs on Microsoft NET platforms Bigloo uses Portable NET assembler and linker to produce NET binaries As such pro duced binaries are linked and signed against Portable NET runtime libraries and are rejected by Microsoft NET platforms In order to run Bigloo NET binaries on Microsoft NET plat forms binaries must first be disassembled and then reassembled and linked against Microsoft runtime libraries The pnet2ms utility automates this process Before the first use of pnet2ms a pub lic private key pair must first be registered to the Bigloo container You may either use the provided pair in the bigloo dotnetkey
146. The parser generator encounters a similar shift reduce conflict this time except that when it tries to determine whether to shift or reduce it finds that both actions have the same precedence In this case the parser generator looks at the associativity of the precedence group containing the op add and op sub Since these are declared to be left associative the parser generator chooses to reduce from this state effectively calculating the 1 2 Had these symbols been right associative the parser would have chosen to shift effectively calculating 2 3 first If these symbols had been declared non associative with the none keyword the parser would generate an error if it ever encountered this state 11 3 The parsing function Once a grammar has been defined it can be used to parse some input using the following function read lalrp lg rg port emptyp bigloo procedure This function takes three possibly four arguments The first lg is the Lalr 1 grammar The second rg is the lexical analyzer that feeds the grammar with tokens The third argument port is the port that contains the input to be parsed The last argument emptyp if provided should be a function of one argument It is called with each new token read from the port and should return t if the token denotes the end of input The result of the call is the value computed by the semantic actions of the production rules 11 4 The regular grammar In order to work properly
147. These parameters control the debugging and warning level The bigloo compiler debug is automatically controlled by the compiler command line g option see Chapter 13 Command Line Parsing page 151 When a program is compiled in debug mode lvl the compiler introduces a call to bigloo debug set lv1 before the evaluation of the first expression The bigloo debug parameter is used to control traces see Section 15 5 Tracing page 177 bigloo trace bigloo function bigloo trace set list bigloo function Specifies the active trace see with trace form The argument list is the list of symbols which are active and which triggers the display of a with trace form This parameter is dynamically adjusted according to the value of the SHELL variable BIGLOOSTACKDEPTH bigloo trace color bigloo function bigloo trace color set bool bigloo function Enables disables traces coloring see Section 15 5 Tracing page 177 230 Bigloo 4 2b bigloo trace stack depth bigloo function bigloo trace stack depth set integer bigloo function Controls the depth of the stack trace to be displayed on errors With systems that supports shell variables such as Unix this parameter is dynamically adjusted ac cording to the value of the SHELL variable BIGLOOSTACKDEPTH bigloo eval strict module bigloo function bigloo eval strict module set bool bigloo function When set to stt enables eval optimization that inlines operators calls This
148. This function returns an output string port This object has almost the same pur pose as output port It can be used with all the printer functions which accept output port An output on a output string port memorizes all the characters writ ten An invocation of flush output port or close output port on an output string port returns a new string which contains all the characters accumulated in the port Chapter 5 Standard Library 59 get output string output port bigloo procedure Given an output port created by open output string returns a string consisting of the characters that have been output to the port so far open output procedure proc flush close bigloo procedure This function returns an output procedure port This object has almost the same purpose as output port It can be used with all the printer functions which accept output port An output on a output procedure port invokes the proc procedure each time it is used for writing That is proc is invoked with a string denoting the displayed characters When the function flush output port is called on such a port the optional flush procedure is invoked When the function close output port is called on such a port the optional close procedure is invoked close input port input port procedure close output port output port procedure According to R5RS the value returned is unspecified However if output port was created using open output string the value returned is the s
149. UID as returned by the procedure getuid If the user is found these two procedures returns a list of seven elements e the user name e his encrypted password e his uid e his group id e his real name e his home directory e his preferred shell When no user is found these procedures returns f 5 7 2 Files See Section 5 2 Input and Output page 53 for file and directory handling This section only deals with name handling Four procedures exist to manipulate Unix filenames basename string bigloo procedure Returns a copy of string where the longest prefix ending in is deleted if any existed prefix string bigloo procedure Returns a copy of string where the suffix starting by the char is deleted If no prefix is found the result of prefix is a copy of string For instance 78 Bigloo 4 2b prefix foo scm gt foo prefix foo scm gt foo prefix foo tar gz gt foo tar suffix string bigloo procedure Returns a new string which is the suffix of string If no suffix is found this function returns an empty string For instance suffix foo scm gt scm suffix foo scm gt scm suffix foo tar gz gt gz dirname string bigloo procedure Returns a new string which is the directory component of string For instance dirname abc def ghi gt abc def dirname abc gt 7 dirname abc gt abc dirname abc gt nyn
150. a o WA 71 bIldt string aceon ow NIV p e XR da 43 AA ee rd we dem eu Besta 25 Bool6ans ceci mee rer XE EOM VUE ER 25 broadcast 2 0 6 cece cee eens 190 Building a library 0 004 255 building a makefile oooooooocooooooo 300 byte code compile senis rei cee cece eee ee 221 307 byte codesrun osso iaa Ps gece 221 C Clarrays egere dx A ood eae edes 239 C atomic types usse cvs Ea Were ve eo wee 235 enumo deste kee ens 4 u a Dada eres 240 CPN CHIONS sd 240 O intebface vice eeu rere oes Ca 233 Cnull polnters2 ione rhe pas 238 C OPAQUE suere ere See AA NS 241 COPOS cutis ci cis 237 C TEQUITE Meyi a re 271 C structure and union types 236 CA A cen 27 CAM ida a as las 27 Caaf AA E ys 27 CAadaR A E O E e e 27 caddr iia a io TET Ee 27 CAAT eis yaq eue Rr De eund e Mere Ed teed 27 Calendari A e ee 93 Cll cts elas yee a 18 callsnext method s iii a 117 call with append file ooooooommmmmmmm o 53 call with input file 2 gie 53 call with input string sess 53 call with output file esses 53 call with output string sess 53 call with values esses 52 53 GALA CC d oou MN ARE Id e e EARUM 50 51 CAP CU uates hows Notare utetur e frat Gems 27 CaSB ii dando 19 refs s so adi CPP 27 Cddddr acercas en e eR IRR A RR US 27 SO 27 COL ii aladdin Subd Silene gi ed 35 Colin a 35 certificate isSu r tennis da riada 9
151. a sign is hence of the following form receive r s dsa sign secret key hashed msg bignum process signature r s 162 Bigloo 4 2b dsa verify m key rs Bigloo Cryptography procedure Verifies a signature consisting of r and s DSA works very similar to RSA Have a look at RSA s example section 14 2 3 ElGamal Bigloo supports ElGamal encryption but not signing Bigloo s implementation is minimal For consistency with RSA ElGamal keys are similarly named as their RSA counterparts ElGamal Key Bigloo Cryptography class Complete ElGamal Key Bigloo Cryptography class class ElGamal Key p bignum g bignum y bignum final class Complete ElGamal Key ElGamal Key x bignum the private key extract public elgamal key complete key Bigloo Cryptography procedure Returns a copy of the public part as ElGamal Key elgamal encrypt key m Bigloo Cryptography procedure Encrypts the bignum m using the given public key The result are two values c1 and c2 Note that ElGamal encryption needs random bytes for every encryption This means that this function may return different results with the same parameters It further more implies that the result is insecure if the operating system provides bad random numbers or if Bigloo s random number generation is buggy For critical applications be sure to verify both requirements elgamal decrypt complete key cl c2 Bigloo Cryptography procedure Decrypts an ElGamal encrypted message
152. able saw register allocation on expression default f saw register allocation Enable disable saw register allocation default f saw register reallocation Enable disable saw register re allocation default f shared cnst Shared constant compilation default t shell The shell to exec C compilations default bin sh src files The sources files default src suffix Scheme legal suffixes default scm bgl startup file A startup file for the interpreter default f static all bigloo Do we use the static version of all Bigloo libraries default f static bigloo Do we use the static Bigloo library default f stdc Chapter 31 Compiler description Shall we produce ISO C default f strip Shall we strip the executable default t sync profiling Instrument code for synchronize profiling default f target language The target language either c c saw jvm or net default native trace name Trace file name default trace trace write length Trace dumping max level default 80 unsafe arity Runtime type arity safety default f unsafe eval Disable type checking for eval functions default f unsafe heap Disable heap version checking default f unsafe library Use the unsafe library version default f unsafe range Runtime range safety default f unsafe struct Runtime struct range safety default f
153. able to work with bignums up to 1024 bits 128 bytes Now some Bigloo code that uses this key Start by loading the library module rsa example library crypto Now read the key define key read pem key my rsa key pem define public key extract public rsa key key The public portion of the key can be distributed publish the public key write pem key string public key Now let s sign the message My Important Message This message is sufficiently short to be signed directly but in general it is better to get a hash of the message define msg hash shaisum my message define msg hash bignum octet string gt bignum msg hash The result of shaisum returns a human readable representation of the hash It would hence be possible to transform it back to an internal representation before applying the octet string gt bignum function 160 Bigloo 4 2b define msg hash bignum octet string gt bignum string hex intern msg hash In our case both variants are small enough to fit into our keys The latter version is however more often used Now that we have a message hash in bignum form we can sign it define signature rsa sign key msg hash bignum The signature is again in bignum form If needed there are several ways to transform it into string form for instance bignum gt string or bignum gt octet string The signature can now be distributed Anyone wanting to verify the signature simply has to creat
154. accepting one or two arguments This function sets the rep1 display function That is to display the result of its evaluations repl invokes proc giving it the evaluated expression as first argument and the current output port or a file in case of transcript as second argument Set repl printer returns the former rep1 display function For instance one may write 1 gt define x cons 1 2 4X 1 gt define y cons x x 4 Y 1 gt y 4 0 1 2 0 1 gt set repl printer display lt procedure 83b8c70 2 gt 1 gt y 4 1 2 1 2 native repl printer bigloo procedure Returns the native default rep1 display function expand exp bigloo procedure Returns the value of exp after all macro expansions have been performed expand once exp bigloo procedure Returns the value of exp after one macro expansion has been performed It is possible to specify files which have to be loaded when the interpreter is invoked For this see section see Chapter 31 Compiler Description page 271 If a Bigloo file starts with the line bigloo command name and if this file is executable in the meaning of the system and if the user tries to execute it Bigloo will evaluate it Note also that SRFI 22 support enables to run any Unix interpreter see Chapter 30 SRFIs page 265 load filename bigloo procedure loadq filename bigloo procedure Filename should be a string naming an existing file which contains Bigl
155. ace init 233 26 1 The syntax of the foreign declarati0OS 0oooooooooom o 233 26 1 1 Automatic extern clauses generati0O oooooooooooo 234 26 1 2 Importing an extern variable o ooooooocccconco o 234 26 1 3 Importing an extern function eee eee eee 234 26 1 4 Including an extern file 00 cee ee eee 234 26 1 5 Exporting a Scheme variable 000 cece eee eee 235 26 1 6 Defining an extern type 6 cece eee eee 235 26 1 6 1 Atomic types snes cae eed ERR UR kee ae 235 26 1 6 2 Struct and Union types 0 0 e ee eee eee 236 26 1 6 3 C pointers ie vce eee eee aad wees 237 26 1 6 4 C null pointers 0 eee eee 238 20 1 0 5 COTAS esee pe ean Regi pO Settee acre doce 239 20 16 60 C functions inset ida ta ERR ides 240 26 1 6 7 CNM sesso eek Se net eee ead Peaks teens 240 26 1 6 8 CxOpaques ctra 241 26 2 The very dangerous pragma Bigloo special forms 242 26 3 Name mangling 0 eee eee a 242 26 4 Embedded Bigloo applications 2 eee eee eee 243 26 5 Using C bindings within the interpreter 243 27 The Java interface 245 27 1 Compiling with the JVM back end 00 2200 245 27 1 1 Compiler JVM options seesseseeeeee 245 27 1 2 Compiling multi modules applications 245 27 2 JVM back end and SRFI 0 0 cece eee eee 246 27 3
156. ach lambda x if negative x exit x 54 0 37 3 245 19 tt gt 3 define list length lambda obj bind exit return letrec r lambda obj cond null obj 0 pair obj r cdr obj 1 else return f r obj list length 1 2 3 4 gt 4 list length a b c gt f unwind protect expr protect bigloo syntax This form provides protections Expression expr is evaluated If this evaluation re quires the invocation of an escape procedure a procedure bounded by the bind exit special form protect is evaluated before the control jump to the exit procedure If expr does not raise any exit procedure unwind protect has the same behaviour as the begin special form except that the value of the form is always the value of expr define my open f if file exists f let port open input file f if input port port unwind protect bar port close input port port dynamic wind before thunk after procedure Calls thunk without arguments returning the result s of this call Before and after are called also without arguments as required by the following rules note that in the absence of calls to continuations captured using call cc the three arguments are called once each in order Before is called whenever execution enters the dynamic extent of the call to thunk and after is called whenever it exits that dynamic extent The dynamic extent of a procedure call is the perio
157. ad locking mechanism is common to Fair Threads and Posix Threads see Section 16 1 Thread Common Functions page 179 mutex state mutex SRFI 18 function Returns the symbol locked when the mutex is locked by a thread Otherwise it returns the symbol unlocked 16 3 4 Condition Variables Posix thread condition variables follows the common thread API see Section 16 1 Thread Common Functions page 179 module example library pthread main main define main argv let res f lock make mutex cv make condition variable thread join thread start joinable instantiate pthread body lambda O mutex lock lock thread start instantiate pthread body lambda O mutex lock lock condition variable signal cv mutex unlock lock condition variable wait cv lock set res 23 mutex unlock lock res 194 Bigloo 4 2b 16 3 5 SRFI 18 mutex state mutex SRFT 18 function Returns information about the state of the mutex The possible results are e thread T the mutex is in the locked owned state and thread T is the owner of the mutex e symbol not owned the mutex is in the locked not owned state e symbol abandoned the mutex is in the unlocked abandoned state e symbol not abandoned the mutex is in the unlocked not abandoned state Examples mutex state make mutex gt not abandoned define thread alive thread let mutex make mutex mutex lock mutex f th
158. ad only Info declarations allow arbitrary user information field values This value can be re trieved by introspection by the means of the class field info introspection func tion For the means of an example with add to information to the slot of the point class module example static class point x double info range 0 0 10 0 y double info range 1 0 1 0 Chapter 9 Object System 115 9 2 Creating and accessing objects Objects and classes are created and manipulated via library functions and forms created automatically by Bigloo when a new class is defined isa obj class bigloo procedure This function returns t if obj is an instance of class or an instance of a sub class of class otherwise it returns amp tf instantiate class ident value bigloo syntax This forms allocates object of class class and fills the fields with values found in the list of parameters note that field are explicitly named and that there is no ordering for field naming Field values which are not provided in the parameter list must have been declared with a default value which is used to initialize the corresponding field For instance module example export class point x default 0 class point2d point y instantiate point x 0 y 0 instantiate point y 0 instantiate point x 0 gt Error because y has no default value class nil class bigloo procedure This function returns the NIL pr
159. adcast bar 0 thread start instantiate fthread body lambda O thread await list s1 s2 s3 set res thread get values list s1 s2 s3 thread start instantiate fthread body lambda O thread sleep 2 broadcast bar current time scheduler start res gt foo 3 bar 3 0 gee Used with asynchronous signal the functions thread await and thread get values can be used to read concurrently in a non blocking way several files Chapter 16 Threads 189 thread await values signals timeout Bigloo function This blocks the current thread until at least one of signals has been broadcast It then returns at the next instant all the values associated with all the broadcasts that took place during the instant It can be defined as define thread await values signal tmt apply thread await signal tmt thread get values signal 16 2 2 2 Scheduler make scheduler strict order envs Bigloo function Creates a new scheduler The optional boolean argument strict order is used to ask the scheduler to always schedule the threads in the same order it defaults to sf The optional arguments envs are fair thread environments which will be defined in forthcoming Bigloo releases scheduler strict order Bigloo function scheduler strict order set bool Bigloo function Gets or sets the strict scheduling policy of the scheduler If set the threads will always be scheduled in
160. adddr 0 11 pregexp match positions c gt ad r cr 4f pregexp match positions c ad r cadaddadddr gt ttf pregexp match positions c ad r cr gt 0 2 pregexp match positions c ad r car gt 0 23 12 2 6 Numeric quantifiers You can use braces to specify much finer tuned quantification than is possible with The quantifier m matches exactly m instances of the preceding subpattern m must be a nonnegative integer The quantifier m n matches at least m and at most n instances m and n are nonnegative integers with m lt n You may omit either or both numbers in which case m defaults to 0 and n to infinity It is evident that and are abbreviations for 1 and 0 1 respectively abbreviates which is the same as 0 pregexp match aeiou 3 vacuous uou pregexp match aeiou 3 evolve gt df pregexp match aeiou 2 3 evolve gt sf pregexp match aeiou 2 3 zeugma gt eu 12 2 7 Non greedy quantifiers The quantifiers described above are greedy ie they match the maximal number of instances that would still lead to an overall match for the full pattern pregexp match lt gt lt tag1 gt lt tag2 gt lt tag3 gt gt lt tagl gt lt tag2 gt lt tag3 gt To make these quantifiers non greedy append a to them Non greedy quantifiers match the minimal number of instances needed to ensure an overall match pregex
161. ake client socket hostname port number key timeout 0 bigloo procedure inbuf t outbuf t domain inet make client socket returns a new socket object T his socket establishes a link be tween the running application listening on port port number of hostname If keyword arguments inbuf and outbuf describe the buffer to be used Each can either be e A positive fixnum this gives the size of the buffer e The boolean itt a buffer is allocated by the Bigloo runtime system with a default size e The boolean f the socket is unbufferized e string it is used as buffer Unbuffered sockets are useful for socket clients connected to servers that do not emit Newline character after emissions If the optional argument timeout is missing or is 0 the execution blocks until the connection is established If the timeout is provided the execution unblocks after timeout microseconds unless the connection is established The domain argument specifies the protocol used by the socket The supported domains are e inet IPv4 Internet protocols e unix Unix sockets for local inter process communications e local Same as unix Chapter 5 Standard Library 85 If the connection cannot be established an amp io error is raised see Chapter 15 Errors Assertions and Traces page 171 When a socket is used in unbufferized mode the characters available on the input port must be read exclusively with read char or read line It is forbidd
162. al 5 11 Internet This section presents the Bigloo function aimed at helping internet programming 5 12 URLs url parse url bigloo procedure The argument url can either be a string or an input port The function url parse parses the url and returns four values e the protocol e the optional user info e the host name e the port number e the absolute path Example multiple value bind protocol uinfo host port abspath url parse http www inria fr sophia teams indes index html list protocol uinfo host port abspath gt http 4f www inria fr 80 sophia teams indes index html multiple value bind protocol uinfo host port abspath url parse https foo barQwww inria fr sophia teams indes index html list protocol uinfo gt https foo bar url sans protocol parse url protocol bigloo procedure The argument url can either be a string or an input port This function behaves as url parse except it assumes that the protocol part of the url has already been extracted from the URI It is explicitly provided using the protocol argument http url parse url bigloo procedure The argument url can either be a string or an input port As url parse it returns four values This function parses URL found in HTTP GET responses url path encode path bigloo procedure Encode a path that can be used in valid URL url path encode tmp foo tmp foo url path encode tmp fookbar tmp foo 26bar
163. ambda x x 3 add3 3 6 define first car first 1 2 gt 1 See Section 3 1 3 r5rs info page 22 for more details The Bigloo module language See Section 2 2 Module Declaration page 7 enables exports and imports of global definitions Chapter 4 DSSSL support 23 4 DSSSL support Bigloo supports extensions for the DSSSL expression language Dsssl96 e Keywords Bigloo supports full Dsssl keywords e Named constants Bigloo implements the three DsssL named constants optional rest and key e Dsssl formal argument lists In addition Bigloo extends DSSSL formal parameters It supports rest argument following key arguments In that case the rest formal parameter is bound to the list of non keyword values 4 1 DSSSL formal argument lists DsssL formal argument lists are defined by the following grammar lt formal argument list gt gt lt required formal argument gt Gt optional lt optional formal argument gt Gt rest lt rest formal argument gt key lt key formal argument gt rest lt rest formal argument gt lt required formal argument gt gt lt ieee ident gt lt optional formal argument gt gt lt ieee ident gt lt ieee ident gt lt initializer gt lt rest formal argument gt gt lt ieee ident gt lt key formal argument gt gt lt ieee ident gt lt ieee ident gt lt initializer gt lt initializer gt gt lt expr gt When a
164. ame server lookup The backlog argument specifies the size of the wait queue used for accepting connec tions Socket accept socket key errp t inbuf t outbuf t bigloo procedure Socket accept waits for a client connection on the given socket It returns a client socket If no client is already waiting for a connection this procedure blocks its caller otherwise the first connection request on the queue of pending connections is connected to socket l his procedure must be called on a server socket created with make server socket The arguments inbuf and outbuf are similar to the ones used by make client socket That is each can either be e A positive fixnum this gives the size of the buffer e The boolean t a buffer is allocated e The boolean f the socket is unbufferized e A string it is used as buffer The keyword argument errp is a boolean The value t means that if an error is raised it is signaled Otherwise it is omitted Note When a socket is used in unbufferized mode the characters available on the input port must be read exclusively with read char or read line It is forbidden to use read or any regular grammar This limitation is imposed by Rgc see Chapter 10 Regular Parsing page 125 that intrinsicly associate buffers with regular grammars If the current Rgc implementation is improved on the coming version this restriction will be suppressed The following exemple is a simple server which waits for
165. an HTTP request The argument procedure is invoked with five arguments the input port to read the characters of the response the status code the header of the response the content length the type encoding http response body gt port input port output port bigloo procedure Parses an HTTP response and build an output port that delivers the characters of the content http chunks gt procedure input port bigloo procedure http chunks gt port input port bigloo procedure http send chunks input port output port bigloo procedure Chapter 6 Pattern Matching 105 6 Pattern Matching Pattern matching is a key feature of most modern functional programming languages since it allows clean and secure code to be written Internally pattern matching forms should be translated compiled into cascades of elementary tests where code is made as efficient as possible avoiding redundant tests Bigloo s pattern matching compiler provides this The technique used is described in details in QueinnecGeffroy92 and the code generated can be considered optimal due to the way this pattern compiler was obtained The pattern language allows the expression of a wide variety of patterns including e Non linear patterns pattern variables can appear more than once allowing comparison of subparts of the datum through eq e Recursive patterns on lists for example checking that the datum is a list of zero or mo
166. and module cksum main main define main args let loop sum crc file ieee 32 cadr args size elong gt fixnum file size cadr args if fx size 0 printf a a a n bit andllong 1xFFFFFFFF elong gt llong bit notelong sum file size cadr args Chapter 5 Standard Library 99 cadr args loop crc string ieee 32 string integer gt char ur bit and size xFF init sum bit rsh size 8 In the following example we implement OpenPGP s CRC 24 define openpgp crc 24 str crc string radix 64 24 str init xB704CE Be aware that many common CRCs use 1 as init value and invert the result For compatibility with other implementations you might want to try one of the following alternatives define alti name obj crc name obj init 1 define alt2 name obj crc name obj final xor 1 define alt3 name obj crc name obj init 1 final xor 1 Bigloo provides means to create additional CRCs one can either simply provide a new polynomial or use Bigloo s low level functions register crc name poly len bigloo procedure Adds the given CRC to Bigloo s list Name can be of any type crc will use assoc to find it in its list The polynomial can be either a fixnum an elong or an llong len should give the CRCs size The type of the polynomial and the given len must be consistent On a 32 bit machine the following CRC registration would be invalid and yield undefined results
167. ange struct version library eval heap Enforce check type arity range struct version library eval Emit line directives Don t emit line directives Compile with bdb debug informations Enables self compiler debug options Debug module initialization Localize error calls in the source code Don t localize error calls in the source code Annote JVM classes for debug Producing stack traces Produce Bigloo debug informations Compile C files with debug option Eval export all all routines Eval export exports all routines Enables Eval redefinition of all obj routines Compile files for cpu profiling Compile files for memory profiling Profile synchronize expr see exitd mutex profile Be silent and inhibit all warning messages Be verbose Say hello Dont say hello even in verbose mode Inhibit all warning messages Inhibit overriden slots warning messages Enable overriden variable warning messages Chapter 31 Compiler description 277 Wtypes Enable type check warning messages Wall warn about all possible type errors Compilation modes lt gt rm Don t or force removing c or il files extend NAME Extend the compiler fsharing Attempt to share constant data fno sharing Do not attempt to share constant data fmco Produce an mco file fmco include path DIR Add dir to mco C include path Native specific options cc COMPILER Specify the C compiler stdc Generate strict ISO C code copt STRING Invoke cc with STR
168. ansform it to a key string of a given length In all the functions the len is expressed in bytes string gt key zero str len Bigloo Cryptography procedure If the length of the input string str is greater or equal to len bytes then the first str characters are returned Otherwise str is suffixed with 0 a000 characters string gt key hash str len hash fun Bigloo Cryptography procedure The input string str is run through the given hash function hash fun The result is then concatenated multiple times with itself until a string of the len bytes is obtained In the following example we encrypt some message using a password my password The password will be transformed to 256 bits 32 bytes using the string gt key256 function define string gt key256 password string gt key hash password 32 lambda str string hex intern shalsum str encrypt aes some message m assword string gt key string gt key256 yP g y P g y g y Note that the following example yields an identical result define string gt key256 password string gt key hash password 32 lambda str string hex intern shalsum str encrypt aes some message string gt key256 my password string gt key lambda x x string gt key simple str len hash fun Bigloo Cryptography procedure This function implements the simple s2k algorithm of OpenPGP RFC 2440 Ba sically str is run through the hash fun several times until the concatena
169. ard mixer Bigloo Multimedia class class soundcard mixer device bstring read only The instances of the class soundcard a subclass of the mixer class are used to access physical soundcard as supported by operating systems The class field device stands for the name of the system device e g dev mixer for the Linux OS During the initialization of the instance the device is opened and initialized 18 2 3 Playback Bigloo supports various functions for playing music These functions rely on two data structure music players and music status The first ones are used to control player back ends The second ones are used to get information about the music being played The following example shows how a simple music player using either MPlayer MPG123 or MPC can be programmed with Bigloo 204 Bigloo 4 2b module musicplay library multimedia main main define main args let files O backend mplayer command f args parse cdr args mpgi23 help Select the mpg123 back end set backend mpg123 mpc help Select the mpc back end set backend mpc mplayer help Select the mplayer back end set backend mplayer command cmd help Set the command path set command cmd help help This help print usage music options file args parse usage itf exit 0 else set files cons else files create a music player let player c
170. aris 1993 e Dsssl96 ISO IEC Information technology Processing Languages Document Style Semantics and Specification Languages dsssl Technical Report 10179 1996 E ISO 1996 e Dybvig et al 86 K Dybvig D Friedman and C Haynes Expansion passing Style Beyond conventional macros In Conference om Lisp and Functional Pro gramming pages 143 150 1986 e Gallesio95 E Gallesio STk Reference Manual Technical Report RT 95 31a I3S CNRS University of Nice Sophia Antipolis July 1995 e IsoC ISO IEC 9899 programming language C Technical Report DIS 9899 ISO July 1990 e Les75 M E Lesk Lex a lexical analyzer generator Computing Science Technical Report 39739 AT amp T Bell Laboratories Murray Hill N J 1975 e Queinnec93 C Queinnec Designing MEROON v3 In Workshop on Object Oriented Programming in Lisp 1993 e QueinnecGeffroy92 C Queinnec and J M Geffroy Partial evaluation applied to symbolic pattern matching with intelligent backtrack In M Billaud P Cast eran MM Corsini K Musumbu and A Rauzy Editors Workshop on Static Analysis number 81 82 in bigre pages 109 117 Bordeaux France September 1992 e R5RS R Kelsey W Clinger and J Rees Editors The Revised 5 Report on the Algorithmic Language Scheme e Stallman95 R Stallman Using and Porting GNU CC for version 2 7 2 ISBN 1 882114 66 3 Free Software Foundation Inc
171. ase backend mpg123 if command instantiate mpg123 path command instantiate mpg123 mplayer if command instantiate mplayer path command instantiate mplayer mpc instantiate mpc fill the music play list for each lambda p music playlist add player p reverse files start playing music play player run an event loop with call backs associated to some events music event loop player onstate lambda status with access musicstatus status state song volume print state state print song song onmeta lambda meta print meta meta onvolume lambda volume print volume volume music Bigloo Multimedia abstract class abstract class music frequency long default 2000000 This abstract class is the root class of all music players Chapter 18 Multimedia 205 musicproc music Bigloo Multimedia class class musicproc music charset symbol default ISO LATIN 1 This class is used to reify player that are run in an external process mplayer musicproc Bigloo Multimedia class class mplayer musicproc path bstring read only default mplayer args pair nil read only default vo null quiet slave idle ao obj read only default unspecified ac obj read only default unspecified A player based on the external software MPlayer Creating such a player spawns in background a MPla
172. ault fcase insensitive Case insensitive reader downcase symbols fallow type redefinition allow type redifinition Optimization Obench Benchmarking mode O 0 6 Optimization modes fcfa arithmetic Enable arithmetic spec see farithmetic overflow fno cfa arithmetic Disable arithmetic spec fcfa arithmetic fixnum Enable fixnum arithmetic spec fno cfa arithmetic fixnum Disable fixnum arithmetic spec fcfa arithmetic flonum Enable flonum arithmetic spec enabled from O2 fno cfa arithmetic flonum Disable flonum arithmetic spec fcfa tracking Enable CFA tracking enabled from O2 fnocfa tracking Disable CFA tracking fcfa pair Enable CFA pairs approximations fnocfa pair Disable CFA pairs approximations fcfa unbox closure args Enable CFA unboxed closure args enabled from 02 fnocfa unbox closure args Disable CFA unboxed closure args funroll loop Enable loop unrolling enabled from O3 fno unroll loop Disable loop unrolling fno loop inlining Disable loop inlining floop inlining Enable loop inlining default fno inlining Disable inline optimization fno user inlining Disable user inline optimization fbeta reduce Enable simple beta reduction enabled from O2 fno beta reduce Disable simple beta reduction fdataflow Enable dataflow optimizations enabled from O fno dataflow Disable dataflow optimizations fdataflow for errors Enable dataflow optimizations for improviing type er ror messages fno dataflow for errors Di
173. ay also load a different file after making a reasonable check that loading it is semantically equivalent to loading lt script gt For example the script interpreter may assume that a file with a related name say with an additional extension is a compiled version of lt script gt 30 3 1 An example of SRFI 22 script Let us consider the following Bigloo script located in a file foo scm usr bin env execute module foo main main define main argv print foo argv Let us consider the following execute shell script cat gt execute bin sh bigloo i Provided that foo scm as the execute flag switched on it is possible to execute it Chapter 30 SRFIs 269 chmod u x foo scm foo scm 4 foo foo scm The same Bigloo module can be compiled and executed such as bigloo foo scm a out 4 foo a out 30 3 2 Lazy compilation with SRFI 22 SRFI 22 can be used to implement azy compilation For instance let us consider the following shell script cat bgl bin sh SOURCEFILE 1 case SSOURCEFILE in scm OUTFILE SOURCEFILE scm if bigloo s o SOUTFILE SOURCEFILE then bin rm SOUTFILE o shift SOUTFILE echo Error need a scm file esac And the following Bigloo script usr bin env bgl module foo main main define main argv print foo argv When executed in the following way chmod u x foo scm foo scm foo foo scm
174. b lambda x x SELECT name FROM sqlite master WHERE type table sqlite name of columns sqlite table Bigloo Sqlite function Returns the name of columns in the table sqlite last insert rowid sqlite Bigloo Sqlite function Returns the SQLite rowid of the last inserted row Chapter 18 Multimedia 201 18 Multimedia Bigloo provides various facilities for programming multimedia applications It provides func tions for parsing images and sounds and functions for controlling music players All the func tions variables and classes presented in the document are accessible via the multimedia library Here is an example of module that uses this library Extract the thumbnail of a digital photography module thumbnail library multimedia main main define main argv when and pair cdr argv file exists cadr argv let ex jpeg exif cadr argv when exif ex display exif thumbnail ex 18 1 Photography The multimedia library provides functions for accessing the metadata generated by digital camera jpeg exif file name Bigloo Multimedia procedure The function jpeg exif extracts the EXIF http en wikipedia org wiki Exif metadata of a JPEG file as created by digital camera The argument file name is the name of the JPEG file If the file contains an EXIF section it is returned as an instance of the exif class Otherwise this function returns 8f jpeg exif comment set file name text
175. bigloo library path print BFORMAT library path a bigloo library path eval library load bformat rep1 28 8 A complete library example For the means of an example let s suppose we want to design a Bigloo library for 2d points That library is made of three implementation files two C files cpoint h and cpoint c and one Scheme file spoint scm Here are defined the three files cpoint h struct point 2d double x y 3 cpoint c include lt stdio h gt include cpoint h int print_point_2d struct point 2d pt printf lt point 2d g g gt pt gt x pt gt y spoint scm module __point include spoint sch Chapter 28 Bigloo Libraries 259 extern include cpoint h export make point s point 2d double double print point s point_2dx point 0bj define make point s point 2d x double y double s point 2d x y define print point p s point 2d print point 2d p define point obj obj s point 2d obj obj makelib scm We want our library to be composed of the whole exported Scheme functions Thus the file to build the heap library could look like module point makelib import point eval export all point init Let s suppose that the point library requires the libposix library This means that any file linked with the point library needs to be also linked with the posix library Furthermore programs making use of
176. bigloorc or bigloorc Bigloo tries to load one of these in this order This file is a Scheme file Bigloo exports variables which allow the user to change the behavior of the compiler All these variables can be checked using the help2 option The Bigloo s runtime command file is read before the arguments are parsed 31 5 6 The Bigloo command line If no input file is specified Bigloo enters its interpreter Here is the exhaustive list of Bigloo options and configuration variables usage bigloo options name suf Misc Read source code on current input channel 274 Bigloo 4 2b help help This help message help2 The exhaustive help message help manual The help message formatted for the manual o FILE Name the output FILE to stdout Write C code on current output channel C Suppress linking and produce a o file suffix SUFFIX Recognize suffix as Scheme source afile FILE Name of the access file access MODULE FILE Set access between module and file jfile FILE Name of the Jvm package file jadd MODULE QTYPE Set JVM qualifed type name for module main FUN Set the main function with MODULE Import addition module multiple inclusion Enables multiple inclusions of the Bigloo includes library LIBRARY Compile link with additional Bigloo library srfi SRFI Declares srfi support dload sym Emit a Bigloo dynamic loading entry point dload init sym NAME Emit a Bigloo dynamic loading entry point named
177. bsum string string bigloo procedure md5sum mmap mmap bigloo procedure md5sum file string bigloo procedure mdb5bsum port input port bigloo procedure Computes MD5 message digest The function md5sum dispatches over its argument and invokes the ad hoc function That is it invokes md5sum string if its argument is a string mdbsum mmap if it is a mmap md5sum port if its argument is an input port hmac md5sum string key string bigloo procedure Computes the Hmac MD5 authentication hmac md5sum string make string 16 a011 Hi There gt 9294727a3638bb1c13f48ef8158bfc9d cram md5sum string user key string bigloo procedure Challenge Response Authentication Mechanism as specified in RFC 2195 The function cram md5sum string assumes that data is base64 encoded The result is also base64 encoded shaisum obj bigloo procedure shaisum string string bigloo procedure shaisum mmap mmap bigloo procedure shaisum file string bigloo procedure shaisum port input port bigloo procedure Computes SHA1 message digest The function shaisum dispatches over its argument and invokes the ad hoc function That is it invokes shalsum string if its argument is a string shalsum mmap if it is a mmap shaisum port if its argument is an input port Chapter 5 Standard Library 97 hmac shalsum string key string bigloo procedure Computes the Hmac SHA1 authentication sha256sum obj bigloo procedure sha256sum string string bigloo proced
178. c LEGS 8T 317 socket d own ic E EEEE ERR 8T Socket host address esses 85 socket hostname ceived a 85 SOCket input d nii d URP TUN des 85 socket local address 004 85 SOcket OptiOn s res een ERE LORI PR ad 89 Socket option set eee 89 Socket Output ss snes tahoe edhe eee ES 85 Socket port number eee 85 Soket servert egnade cue put iR REPUPN 85 Ssocket shutdown eese eee 8T SOCKETT e d dp ee LADDER 85 SOPE eostin peux erit E ea ee eee eG 50 soundcard mixer eiri oni eee 203 Salite A id al 197 salito Cl au a a 197 sqlite VA VARIA AO 198 Sglite exeC uico gl E os 198 Sglite format evene Xa did 197 Sglite last insert rowid 199 salito mapa ij ek a IS MP TS 198 sqlite name of columns 04 199 sqlite name of tables 00 199 SOLUTE 4i td 197 To h a A 36 SdQrtfl x ie RN 36 A E i PRUEBERO RC MR 48 breeds 265 SECO DIO i er Etre EP ERR Ee 265 SEDIS 4 ML ESI Le hee he RLS SSS 172 SRED ciate ae terete te eis ares ees 265 SRFLO bigloo c 2 0 eee eee 246 SRFLO bigloo jvm esses 246 SRELA ses dex teta tute E eS 28 29 30 50 268 SREISQ 4 caia ado 60 SEEISU Ioue esI a x ee o REOR DRE 40 SEELDIS eese nee ee RBS 171 172 191 REEL cos e RRPSCN nace hae UN OT 19 SREE22 5 teas Hn Bo Soh EU Por otia na 268 REE td al se EOM 63 SA ttERI E tage ais sehen d s hae eens 17 SRE EBS Moe d 171
179. c bar scm bigloo jvm c hux scm bigloo jvm main scm foo class bar class hux class For an explanation about the afile see Chapter 2 Modules page 7 27 2 JVM back end and SRFI 0 The currently running back end may be tested by the means of the SRFI 0 cond expand form see Chapter 30 SRFIs page 265 That is when the JVM is ran the bigloo jvm clause is true Otherwise the bigloo c is true Example cat gt foo scm module foo main main define main argv cond expand bigloo jvm print JVM back end bigloo c print C back end else error main unsupported back end unspecified bigloo jvm foo scm a out JVM back end igloo foo scm out C back end oT 27 3 Limitation of the JVM back end The JVM back end supports the entire Bigloo source language but the ca11 cc function Mo re precisely using the JVM back end the continuation reified in a call cc form can only be invoked in the dynamic extent of that form The other restrictions of the C back end apply to the JVM back end Mainly Bigloo is not able to compile all the tail recursive call without stack consumption however most of the tail recursive calls are optimized by Bigloo and don t use stack activation frames Bigloo compiled applications do not check for arithmetic overflow When compiling to Jvm the extern module clauses are not used Jvm runtime system does support the following function chdir Jvm runtime
180. c2047 is found mime content decode string Bigloo Mail procedure mime content decode port input port Bigloo Mail procedure These two functions parse respectively a string and an input port and return a list of three elements e a content type e a content subtype e options Example mime content type decode text plain boundary Apple Mail 11 gt text plain boundary Apple Mail 11 mime content disposition decode string Bigloo Mail procedure mime content disposition decode port input port Bigloo Mail procedure These two functions parse respectively a string and an input port and return a list describing the content disposition Example mime content disposition decode attachment filename smine p7s gt attachment filename smine p7s 210 Bigloo 4 2b mime multipart decode string boundary recursive Bigloo Mail procedure mime multipart decode port input port boundary Bigloo Mail procedure recursive These two functions parse respectively a string and an input port and return a list of mime sections If the optional argument recursive controls whether subparts of a multipart section must be decoded are not If the recursive is t then all subparts of the multipart content are decoded The result is a fully decoded multipart section If recursive is f subparts are not decoded and included in the result as plain strings 19 2 RFC 2047 MIME Part three This section described th
181. cb x9c 33 0x98 xe2 x84 xa2 0x99 xc5 xai Ox9a xe2 x80 xba Ox9b xc5 x93 33 Ox9c wu Ox9d xc5 xbe Ox9e xc5 xb8 Ox9f The argument inv table is an inverse table that can be build from a table and using the function inverse utf8 table inverse utf8 table vector procedure Inverse an UTF 8 table into an object suitable for utf8 gt 8bits and utf8 gt 8bits 5 1 11 Vectors Vectors are not autoquoted objects vector obj procedure make vector k procedure make vector kobj procedure vector obj library procedure vector length vector procedure vector ref vector k procedure vector set vector k obj procedure vector gt list vector library procedure list gt vector list library procedure vector fill vector obj library procedure Stores obj in every element of vector For instance let v make vector 5 f vector fill v stt v copy vector vector len bigloo procedure Allocate a new vector of size len and fills it with the first len element of vector The new length len may be bigger than the old vector length 48 Bigloo 4 2b vector copy vector start end bigloo procedure vector must be a vector and start and end must be exact integers satisfying O lt START lt END lt vector length VECTOR vector copy returns a newly allocated vector formed from the elements of VECTOR beginning with index START inclusive and ending with index END exclusive vector copy
182. cece cece cece eee nn zal eY o ESEE EET ET EEE TEE 50 E E E Ni eee GS ae a 50 mnatch case dg rei xu udi AAA 105 match lambda 221 etarras 105 MA Eu eau ue d e WA E dni en E 33 MAXDR cc as aos poe aes 34 Mal iii A 33 MAXEX ze vile ek E EXTR yia 33 maxvalelong 66 eee cece eee eee 33 E A exer ae RET a 33 maxvalllong isyulseveenivi deve dele aes 33 MOD rr e CE 96 A 43 3X WW ie ea v vd 96 Idbsum file 0222055 Ll e asbEERU RE 96 MAD SUMMA toa Ru tre o au 96 mdbsu m port acepte a 96 md5sum string csse 96 Inember arenas dan aves ra 28 MOM NE 28 IDGmy iau aeui drew ea doutes dere a eie m dg 28 313 AMES Ducem etr dome tme 209 mime content decode eee 209 mime content decode port 55 209 mime content disposition 0 oooooccoooo 209 mime content disposition decode 209 mime content disposition decode port 209 mime content type c c 209 mime multipart 0 0 eee eee eee eee 209 mime multipart decode sus 210 mime multipart decode port 210 MIDS folk tic Quee a coh ee SUA pa cach bos 33 MIND sti o o Anclas rd 33 Mi ea 33 MAINE Me tbe a lewi ue title reae 33 ninyalelong cit e ne a 33 MAN VAL Ts cies eat es settore one see 33 Minvald Long cria fex dax 33 IMIKEE 8s e ad 203 mixer close te 203 mixer volume get 6 ise cece eee eens 203 mixer volume set sees eee 203 MIM AD ccna re ig ot Meee ERE SEL RES 65 m
183. ceive var producer exp bigloo syntax Evaluates exp in a environment where var are bound from the evaluation of producer The result of producer must be a call to values where the number of argument is the number of bound variables define bar a values modulo a 5 quotient a 5 define foo a multiple value bind x y bar a print x y foo 354 4 70 5 2 Input and output This section describes Scheme operation for reading and writing data The section Section 5 7 2 Files page 77 describes functions for handling files 5 2 1 Library functions call with input file string proc library procedure call with input string string proc bigloo procedure call with output file string proc library procedure call with append file string proc library procedure call with output string proc library procedure These two procedures call proc with one argument a port obtained by opening string See Section r5rs info in R5RS for more details call with input file etc passwd lambda port let loop line read line port if not eof object line begin print line loop read line port input port obj procedure input string port obj procedure output port obj procedure output string port obj procedure 54 Bigloo 4 2b port obj procedure input port name obj input port name set obj name output port name obj output port name set obj name Returns sets
184. cepted certs is 4f then every peer server certificate is accepted aside from eventual certificate validation If accepted certs is a list the peer server certificate must match one of the given certificates Otherwise an amp io error will be raised If the connection cannot be established an amp io error is raised see Chapter 15 Errors Assertions and Traces page 171 When a socket is used in unbufferized mode the characters available on the input port must be read exclusively with read char or read line It is forbidden to use read or any regular grammar This limitation is imposed by Rgc see Chapter 10 Regular Parsing page 125 that intrinsicly associates buffers with regular grammars If the current Rgc implementation is improved on the coming version this restriction will be eliminated The function make ssl client socket is defined in the SSL library A module that needs this facility must then use a library clause see Chapter 2 Modules page 7 The SSL library can also be loaded from the interpreter using the library load function see Chapter 28 Bigloo Libraries page 251 module imap library ssl main main let s make ssl client socket localhost 993 p socket output s display string p newline p display abc p flush output port p let loop O 100p client socket use ssl socket key protocol sslv23 SSL library procedure cert f pkey f CAs accepted cer
185. ch easier for Scheme s recursive procedures to navigate 12 1 Regular Expressions Procedures Four procedures pregexp pregexp match positions pregexp match pregexp replace and pregexp replace enable compilation and matching of regular expressions pregexp U regexp opt args bigloo procedure The procedure pregexp takes a U regexp which is a string and returns an S regexp which is a tree 1 The double backslash is an artifact of Scheme strings not the regexp pattern itself When we want a literal backslash inside a Scheme string we must escape it so that it shows up in the string at all Scheme strings use backslash as the escape character so we end up with two backslashes one Scheme string backslash to escape the regexp backslash which then escapes the dot Another character that would need escaping inside a Scheme string is 140 Bigloo 4 2b pregexp c r gt sub or seq c any r There is rarely any need to look at the S regexps returned by pregexp The opt args specifies how the regular expression is to be matched Until documented the argument should be the empty list pregexp match positions regexp string beg 0 end 1 bigloo procedure The procedure pregexp match positions takes a regexp pattern and a text string and returns a match if the pattern matches the text string The pattern may be either a U or an S regexp pregexp match positions will internally compile a U regexp to an S regexp b
186. ch positions but instead of returning index pairs it returns the matching substrings pregexp match brain bird gt dif pregexp match needle hay needle stack gt needle pregexp match also takes optional third and fourth arguments with the same mean ing as does pregexp match positions pregexp replace regexp stringl string2 bigloo procedure The procedure pregexp replace replaces the matched portion of the text string by another string The first argument is the regexp the second the text string and the third is the insert string string to be inserted Chapter 12 Posix Regular Expressions 141 pregexp replace te liberte ty gt liberty If the pattern doesn t occur in the text string the returned string is identical eq to the text string pregexp replace regexp stringl string2 bigloo procedure The procedure pregexp replace replaces all matches in the text stringl by the insert string2 pregexp replace te liberte egalite fraternite ty liberty egality fratyrnity As with pregexp replace if the pattern doesn t occur in the text string the returned string is identical eq to the text string pregexp split regexp string bigloo procedure The procedure pregexp split takes two arguments a regexp pattern and a text string and returns a list of substrings of the text string where the pattern identifies the delimiter separating the substrings pregexp split bin usr bin u
187. characters the characters themselves dependent on the semantics of the escape sequence encountered 64 Bigloo 4 2b An escape sequence is a two character sequence in the string where the first character is a tilde Each escape code s meaning is as follows e a The corresponding value is inserted into the string as if printed with display e s The corresponding value is inserted into the string as if printed with write e or n A newline is inserted A newline is inserted e A tilde is inserted e r A return Return is inserted e v The corresponding value is inserted into the string as if printed with display followed by a newline This tag is hence equivalent to the sequence a n e c The corresponding value must be a character and is inserted into the string as if printed with write char e d x o b The corresponding value must must be a number and is printed with radix 16 8 or 2 e 1 If the corresponding value is proper list its items are inserted into the string separated by whitespaces without the surrounding parenthesis If the corresponding value is not a list it behaves as s e lt sep gt If the corresponding value is a proper list its items are inserted into the string separated from each other by sep without the surrounding parenthesis If the corresponding value is not a list it behaves as s e Ndxob Print a number in N columns with space padding e N lt padding gt dxob Print
188. charl char2 char alphabetic char char numeric char char whitespace char char upper case char char lower case char char gt integer char integer gt char char upcase char char downcase char procedure procedure procedure procedure procedure procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure procedure procedure library procedure library procedure 5 1 8 UCS 2 Characters UCS 2 Characters are two byte encoded characters They can be read with the syntax u lt unicode gt where unicode is the four digit hexadecimal Unicode value of the character to be read Thus for instance the character space can be written u0020 ucs2 obj ucs2 ucs2a ucs2b ucs2 lt ucs2a ucs2b ucs2 gt ucs2a ucs2b ucs2 lt ucs2a ucs2b ucs2 gt ucs2a ucs2b ucs2 ci ucs2a ucs2b ucs2 ci lt ucs2a ucs2b ucs2 ci gt ucs2a ucs2b ucs2 ci lt ucs2a ucs2b ucs2 ci gt ucs2a ucs2b ucs2 alphabetic ucs2 bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure Chapter 5 Standard Library 39 ucs2 numeric ucs2 bigloo procedure ucs2 whitespace ucs2 bigloo procedure ucs2 upper case ucs2 bigloo proce
189. cified 5 greater equal composite unspecified consonant f g 1 2 null my list and let x assq key alist cdr x 19 syntax syntax library syntax library syntax library syntax bigloo syntax Bigloo 4 2b or and let c read char not eof object c string set some str i c set i 1 1 or test library syntax or 2 2 gt 2 1 gt dt or 2 2 lt 2 1 gt dt or f f f gt f or memq b a b c 30 gt b c let name binding body library syntax let x 2 y 3 x y 6 let x 2 y 3 let x 7 z x y z x gt 35 let loop 1 1 2 3 if null 1 Q cons 1 car 1 loop cdr 1 gt 2 3 4 If a binding is a symbol then it introduces a variable bound to the unspecified value let x x gt unspecified Bigloo s named let differs from R5Rs named let because name is bound in binding That is let 1 a symbol let 1 x 1 x lt procedure gt while R5Rs states that let 1 a symbo1 let 1 x 1 x gt a symbol let binding body library syntax let x 2 y 3 let x 7 z x y z x gt 70 letrec binding body library syntax letrec even lambda n if zero n t odd n 1 odd lambda n if zero n Chapter 3 Core Language 21 f even n 1
190. cksize 1 The padding function should fill the block and return t if this last block should be encoded By returning f the last block will be discarded This makes only sense if valid chars was equal to 0 The unpadding procedure has the signature unpad long str bstring The in put string will have the length of the block size The unpadding function may modify the string and must return the number of characters that are valid decrypt bstring cipher ciphertext password string gt key mode cfb IV f pad none decrypt string bstring cipher ciphertext bstring password string gt key mo nonce init nonce update decrypt mmap bstring cipher ciphertext mmap password string key mode cfb IV 4 pad none nonce init nonce update decrypt port bstring cipher ciphertext input port password string gt key nonce init nonce update decrypt file bstring cipher filename bstring password string gt key mode cfb IV 4 pad none nonce init nonce update decrypt sendchars cipher in input port Bigloo Cryptography procedure nonce init nonce update Bigloo Cryptography procedure de cfb IV 1 pad none Bigloo Cryptography procedure Bigloo Cryptography procedure mode cfb IV z4f pad none Bigloo Cryptography procedure Bigloo Cryptography procedure out output port password string key mode c
191. cters are introduced by the X character To decode an ex tension the unserializer starts decoding the item following the X as a regular serialized item Then if the extension parameter is bound to a function the unserializer calls that function and use the returned value as the unserialized object If the extension argument is not a function the unserializer return the ream item obj gt string object bigloo procedure This function converts into a string any Bigloo object which does not contain a procedure Chapter 5 Standard Library 69 The implementation of the last two functions ensures that for every Bigloo object obj containing no procedure the expression equal obj string gt obj obj gt string obj dt binary port obj bigloo procedure open output binary file file name bigloo procedure append output binary file file name bigloo procedure open input binary file file name bigloo procedure close binary port binary port bigloo procedure flush binary port binary port bigloo procedure input obj binary port bigloo procedure output obj binary port obj bigloo procedure Bigloo allows Scheme objects to be dumped into and restored from files These operations are performed by the previous functions The dump and the restore use the two functions obj gt string and string gt obj It is also possible to use a binary file as a flat character file This can be done by the means of output char input char output string a
192. d it raises an amp io error condition Otherwise the list of certificate contained in the file is returned certificate obj SSL library procedure Returns stt if obj is an SSL certificate Otherwise returns f certificate subject cert SSL library procedure Returns the CommonName CN part of the subject of the given certificate certificate issuer cert SSL library procedure Returns the CommonName CN part of the issuer of the given certificate 5 7 5 3 Private Keys read private key file SSL library procedure Reads a private key stored in PEM format in the given file name If the file cannot be read it raises an amp io error condition Otherwise the private key is returned private key obj SSL library procedure Returns t if obj is an SSL private key Otherwise returns f 5 8 Date date obj bigloo procedure Returns stt if and only if obj is a date as returned by make date current date or seconds date It returns f otherwise make date key nsec 0 sec 0 min 0 hour 0 day 1 month bigloo procedure 1 year 1970 timezone dst 1 Creates a date object from the integer values passed as argument The argument timezone if provided is expressed in minute Example 94 Bigloo 4 2b write make date sec 0 min 22 hour 17 day 5 month 2 year 2003 dst 0 4 lt date Wed Feb 5 17 22 00 2003 gt The argument dst is either 1 when the information is not available O when daylight saving
193. d a special pass to the regular compilation this pass taking place before macro expansion There are two ways to add a user pass e Add a compiled pass The module user user in the comptime User user scm file is the user entry pass point To add a compiled pass put the code of the pass in this directory import your new modules in user user and modify the user walk function e Add an interpreted pass Set the value of user pass which has to be a unary function in your bigloorc file and Bigloo will invoke it with the code as argument Chapter 34 Bigloo Development Environment 299 34 Bigloo Development Environment Bigloo release 2 0 or more recent contains an Integrated Development Environment This environment proposes some services Automatic Makefile creation and update Code browsing Revision control Symbol debugging Profiling On line documentation Source code interpretation Source code expansion Literate programming The environment relies on Bigloo tools bglafile a Module access file generator see Section 2 6 Module Access File page 16 bglmake a Makefile creator bgldepend a that creates Bigloo dependencies in makefiles bglpp a pretty printer bglprof a profiler bgltags a generator of tag file for Emacs Each of these tools comes with a dedicated manual page and are not described in this documentation Extra tools are required for the environment to go its full speed Emacs v
194. d arguments Here is an example of argument parsing deploying all the possible rules module args example main main define main argv args parse cdr argv section Help args parse usage f 152 Bigloo 4 2b h help help h help This help message args parse usage f section Misc C v version help Version number print version o file help The output file set dest file input file help The input file set input file else print Illegal argument else Usage args parse usage f Invoking the compiled args example module could produce gt bigloo new args scm args scm gt a out toto Illegal argument toto Usage Help h help This help message Misc v version Version number o lt file gt The output file input lt file gt The input file Chapter 14 Cryptography 153 14 Cryptography Bigloo provides several functions for encrypting and decrypting documents These are de scribed in the chapter Unless explicitly mentioned all functions presented in this document are accessible via the crypto library None of the cryptographic functions are protected against timing attacks No effort has been spent on protecting used memory Here is an example of a module that uses this library Encrypt a string using AES module aes encrypt library crypto main main
195. d between when the call is initiated and when it returns In Scheme because of call cc the dynamic extent of a call may not be a single connected time period It is defined as follows e The dynamic extent is entered when execution of the body of the called procedure begins 52 Bigloo 4 2b e The dynamic extent is also entered when execution is not within the dynamic extent and a continuation is invoked that was captured using call cc during the dynamic extent e It is exited when the called procedure returns e It is also exited when execution is within the dynamic extent and a continuation is invoked that was captured while not within the dynamic extent If a second call to dynamic wind occurs within the dynamic extent of the call to thunk and then a continuation is invoked in such a way that the afters from these two invocations of dynamic wind are both to be called then the after associated with the second inner call to dynamic wind is called first If a second call to dynamic wind occurs within the dynamic extent of the call to thunk and then a continuation is invoked in such a way that the befores from these two invocations of dynamic wind are both to be called then the before associated with the first outer call to dynamic wind is called first If invoking a continuation requires calling the before from one call to dynamic wind and the after from another then the after is called first The effect of using a captured co
196. d like to name our bformat library bigloobformat This can be achieved by adding the following expression in the initialization file library translation table add bformat bigloobformat Using this translation on a Unix platform the library used during the linking will be named libbigloobformat_s lt BIGLOO VERSION gt a In order to change the lt BIGLOO VERSION gt to another suffix such as 1 0 one may use library translation table add bformat bigloobformat 1 0 In such a case the library searched will be named libbigloobformat_s 1 0 a Specifying a prevents the insertion of any suffix Hence library translation table add bformat bigloobformat sf instructs the compiler to look at a library named l1ibbigloobformat s a 28 2 Library and inline functions It is illegal for libraries to include inline functions that make use of new foreign types By new foreign type we mean foreign types that are defined inside the library A library may contain inline functions but these inline functions must not call functions using foreign types in their prototypes Including inline functions making use of foreign C types will make the compiler fail when compiling user code prompting type errors A library may contains non inline functions that make use of new foreign types 254 Bigloo 4 2b 28 3 library and eval The function library load loads a library in the interpreter library exists ident path library procedure C
197. define main argv when and pair cdr argv pair cddr argv let encrypt string e cadr argv passwd caddr argv input read string if encrypt display encrypt aes input passwd display decrypt aes input passwd 14 1 Symmetric Block Ciphers Bigloo supports some common block ciphers Block ciphers work on blocks of fixed size A mode of operation defines the way bigger input is handled For instance in ECB Elec tronic Codebook mode the blocks are all encrypted separately whereas CBC Cipher Block Chaining chains all blocks All modes that chain the blocks need an IV Initial Vector to bootstrap the chaining Block ciphers by themselves can only work on full blocks Some modes are constructed in a way that even incomplete blocks can be safely processed For the remaining blocks a padding function needs to be given Most block ciphers only work with keys of specific length The following functions take passwords strings of arbitrary length as input and preprocess the given password by a string key function The result must then be of correct length encrypt bstring cipher plain password Bigloo Cryptography procedure string gt key mode cfb IV 4 pad none nonce init nonce update encrypt string bstring cipher Bigloo Cryptography procedure plaintext bstring password string gt key mode cfb IV f pad none nonce init nonce updatel encr
198. dia procedure Reset the previous errors detected by a player music event loop music onstate onmeta Bigloo Multimedia procedure onerror onvolume The function music event loop enable event notifications when the state of a player changes The keyword arguments are e onstate a function of one parameter When the player state changes this function is called with an instance of musicstatus as first actual parameter e onmeta a function of two parameters This function is called when a metadata is detected in the music currently played e onerror a function of one parameter invoked when an error is detected e onvolume a function of one parameter invoked when the volume changes 18 2 4 Music Player Daemon Music Player Daemon MPD in short allows remote access for playing music http www musicpd org MPD is designed for integrating a computer into a stereo system that provides control for music playback over a local network The Bigloo class mpc implements a mpd client All Bigloo players can be access via the MPD protocol using the The following example shows how to access a MPlayer music player using the MPD protocol with a simple Bigloo program module mpd library multimedia pthread main main define main argv let db instantiate mpd database directories cdr argv serv make server socket 6600 music instantiate mplayer let loop O thread start make mpd connection th
199. difies its first argument string split string bigloo procedure string split string delimiters bigloo procedure Parses string and returns a list of tokens ended by a character of the delimiters string If delimiters is omitted it defaults to a string containing a space a tabulation and a newline characters string split usr local bin usr local bin string split once upon a time gt once upon a time string cut string bigloo procedure string cut s ring delimiters bigloo procedure The function string cut behaves as string split but it introduces empty strings for consecutive occurrences of delimiters string cut usr local bin gt usr local bin string cut once upon a time gt once upon a time string delete string char charset pred s start end SRFI 13 procedure Filter the string string retaining only those characters that are not equal to char not present in charset or not satisfying pred This function returns a fresh string no larger than end start string prefix length s1 s2 start1 end1 start2 end2 SRFI 13 procedure string suffix length s1 s2 startl end1 start2 end2 SRFI 13 procedure string prefix length ci sl s2 start1 end1 start2 end2 SRFI 13 procedure string suffix length ci sl s2 start1 end1 start2 end2 SRFI 13 procedure Return the length of the longest common prefix suffix of the two strings For prefixes this is equ
200. dure ucs2 lower case ucs2 bigloo procedure ucs2 gt integer ucs2 bigloo procedure integer gt ucs2 i bigloo procedure ucs2 gt char ucs2 bigloo procedure char gt ucs2 char bigloo procedure ucs2 upcase ucs2 bigloo procedure ucs2 downcase ucs2 bigloo procedure 5 1 9 Strings There are three different syntaxes for strings in Bigloo traditional foreign or Unicode The traditional syntax for strings may conform to the Revised Report see Section r5rs info in R5RS With the foreign syntax C escape sequences are interpreted as specified by ISO C In addition Bigloo s reader evaluate x sequence as an hexadecimal escape character For Unicode syntax see Section 5 1 10 Unicode UCS 2 Strings page 44 Only the reader distinguishes between these three appearances of strings ie there is only one type of string at evaluation time The regular expression describing the syntax for foreign string is 8 C INM Escape characters are controlled by the parameter bigloo strict rbrs strings see Chapter 24 Parameters page 229 The library functions for string processing are string obj procedure string null s SRFI 13 procedure Is s an empty string make string k procedure make string k char procedure string char library procedure string length string procedure string ref string k procedure string set string k char procedure string stringl string2 library procedure This function returns stt if the strin
201. dy of the inline procedure is open coded The definition of an inline is given in the following way define inline name args body bigloo syntax define inline name args arg body bigloo syntax Apart from the initial word this form has the same syntax as that used by define for procedures Inline procedures are exportable which means that the compiler scans imported files to find the bodies of all inline procedures Here is a small example of a module which exports an inline and a module which imports it 5 the exporter module module exporter export inline make list objs define inline make list objs objs the importer module module importer import exporter print make list 1 2 3 4 5 Because of the open coding of the exporter procedure the above print statement is equivalent to print let objs list 1 2 3 4 5 objs Any procedure can be an inline Also any exported procedure can be an inline pro vided all global variables and functions it uses are also exported 16 Bigloo 4 2b Note Bigloo can decide to inline procedures declared with define but this can be achieved only with local procedures whereas procedures declared with the define inline form are open coded even through module importation Note Procedures declared inline are macro expanded with the macro defined in the module where they are invoked That is if module module1 declares an inline proce dure p and module modul
202. e passwd gt passwd file name unix canonicalize passwd gt home a user passwd file name unix canonicalize foo passwd gt home foo passwd relative file name name base bigloo procedure Builds a file name relative to base relative file name etc passwd etc gt passwd find file path name path bigloo procedure make shared library name name bigloo procedure file exists string bigloo procedure Search in sequence in the directory list path for the file name If name is an absolute name then path is not used to find the file If name is a relative name the function make file name is used to build absolute name from name and the directories in path The current path is not included automatically in the list of path In conse quence to check the current directory one may add to the path list On success the absolute file name is returned On failure f is returned Example find file path etc passwd toto titi gt etc passwd find file path passwd toto etc gt etc passwd find file path pass wd etc gt f make static library name name bigloo procedure Make a static library name from name by adding the static library regular suffix Make a shared library name from name by adding the shared library regular suffix This procedure returns stt if the file respectively directory and link string exists Otherwise it returns f
203. e procedure Chapter 5 Standard Library fx il i2 fl r1r2 elong rl r2 llong rl r2 bx rl r2 negfx i negfl r negelong r negllong r negbx r These two functions implement the unary function z1 z2 z1 z2 fx il i2 f1 r1 r2 elong rl r2 llong rl r2 bx rl r2 abs z absfl z quotient zl z2 quotientelong zl z2 quotientllong zl z2 remainder zl z2 remainderelong z1 z2 remainderllong z1 z2 remainderfl z1 z2 modulo zl z2 gcd z lcm z floor z floorfl z ceiling z ceilingfl z truncate z truncatefl z round z roundfl z random z randomfl randombx z seed random z 35 bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure library procedure bigloo procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure the random function returns a pseudo random integer between 0 and z If no seed value is provided the random function is automatically seeded with a value of 1 36 The function randomf1 returns a double in the
204. e 16 DO Reading pathz c3 iaa pace DXX TENE Nec as 16 3 Core Language eese 17 SUM SY TUCO CC O aaah ater IE ate toi 17 DLL COMME ii A ds 17 3 1 2 Expressions eosa 9 eR aa eee ed en 17 9 L 3 A e ettet PE mite nang acer 22 4 DSSSL Sup POE cce EE rh E dS CAR 23 4 1 DSSSL formal argument lists 23 4 2 Modules and DSSSL formal argument lists ooo 24 5 Standard Library 5 oue epo EE oU tta 25 5 1 Scheme Library sssssssssessseseeee nen 25 DLL E et oe het err e n A 25 5 1 2 Equivalence predicates 000 c cece eee eee eee 25 5 1 3 Pairs and lists iaa eee a o 27 DLA Symbols seh oa ii ida M udi 30 5 1 5 Key WOrds ia o da 32 5 1 6 Numbers a ia da 32 bold EA E ERR ee eU RUPEE 38 5 18 UC 5 2 Characters A Mer hM REIS 38 5 19 SUNS S i vos eme a Pleni ga 39 5 1 10 Unicode UCS 2 Strings iioc e ER 44 LA MECO eee cans oak eret e RIO uev eee Ts 47 5 1 12 Homogeneous Vectors SREFT 4 ooooooommmmmm mo 48 5 1 13 Control features sess 49 9 2 Input and output sssessssseeseees een ee 53 5 2 1 Library functions pb lenders dene Tae ene 53 0 2 2 dn mapzsa eese A ete esi evene eg e 65 d EAE s 66 5 2 4 CI eese ett rm ao n Ce DEA ERE LR pd UU aces 67 0 9 A ere p meee buit pibe ated 68 5 4 Bit manipulation sessie aara E nec 70 5 5 Weak Pontes its 71 016 Hash Tables A Us 72 5 7 System programming 0 cece eee eee eee eee 74 5 7
205. e 17 3 Core Language This chapter presents the Bigloo basics It presents the elements that compose the body of a module see Chapter 2 Modules page 7 3 1 Syntax The syntax of Bigloo is that of Scheme a parenthesis based one with two exceptions type information and multi line comments Type information is supplied when identifiers are introduced via lambda let define and those identifiers holding type information are referred to as typed identifiers They are defined by the following grammar ident lt rbrs ident gt lt typed ident gt lt typed ident gt gt lt rb5rs ident gt lt rbrs ident gt lt r5rs ident gt gt the standard Scheme identifiers For details of the standard Scheme identifiers see Section Lexical structure in RRS Multi lines comments see http srfi schemers org srfi 30 are defined as lt ident gt lt rbrs ident gt lt typed ident gt lt comment gt gt lt all subsequent characters up to a line break amp lt comment text gt lt comment gt lt comment text gt i lt comment text gt lt character sequence not containing or i 3 1 1 Comments Comments and whitespaces are the same as in Section r5rs info in R5RS 333 The FACT procedure computes the factorial of a non negative integer define fact lambda n if n 0 1 Base case return 1 n fact n 1 In addition Bigloo supports s erpressions c
206. e FUSE E 35 rsa decrypt o 2 eee eles oe tele nates 159 SAO Pic beetle Vt LP una 159 rsa key length coir arene he enS inan eee ens 158 ESA Fd Sete teas eee ae E T s 158 PSarsign A Meee eu eet eles 159 rsa verify bad 159 RSATK y s illl a IO 158 RSADR ad Shade aes oan Ta is 160 RSAEP Sada da oe Mae dr prp eU 160 RSAES OAEP decrypt 0 cece eee e eee 161 RSAES UAEP encrypt cc vere e ii 161 RSAES PKCS1 vi 5 decrypt oooccocococococo o 161 RSAES PKCS1 vi 5 encrypt oooccocococcccc 161 ROASP1 Lacus uites Sra teet Mo et ses 160 RSASSA PKCS1 v1 5 sign 005 161 RSASSA PKCS1 v1 5 sign bignum 161 RSASSA PKCS1 v1 5 verify o o ooo o o 161 RSASSA PKCS1 v1 5 verify bignum 161 RSASSA POSO dia it ele 161 Chapter 35 Global Index RSASSA PSS verify eseni iteh naa 161 RSAVPT o aid R de 160 TUN POCOS 5 vita neces seer es ok eee eee 81 run process and char ready 61 run process and input output l esses 61 S safety c Le RED ru RT dv 272 scheduler broadcast 00000 191 scheduler instant 00000 190 Scheduler rescth oy eee chide Eri ees 189 schedul r start i ei ior Mieka ead ead 190 scheduler strict order 189 Scheduler strict order set 189 scheduler terminate 000 190 Sched l r ll ornebib o ROER oem 189 Scheme report environment
207. e existing class instance This instance plays the role of void in C or null in Java The value of each field is unspecified but correct with respect to the Bigloo type system Each call to class nil returns the same object in the sense of eq module example export class point x class point2d point y eq class nil point class nil point gt dit eq class nil point class nil point2d gt df with access class obj binding body bigloo syntax A reference to any of the variables defined in as a binding is replaced by the appro priate field access form This is true for both reference and assignment A binding is either a symbol or a list of two symbols In the first place it denotes a field In the second case it denotes an aliases field For instance with access point p x y1 y with access point p2 y set x x set y1 E yl y 116 Bigloo 4 2b var field bigloo syntax Class instances can be accesses using the gt special form The the first argument must be the identifier of a local typed variable otherwise an error is raised The form can be used to get or set value of an instance field For instance define example p1 point p2 point set gt p1 x E gt pl x set gt p1 y E gt pl y gt p2 y This is equivalent to define example p1 point p2 point with access point pl x y1 y with access point p2 y set x x set y1
208. e function offered by Bigloo to decode the RFC 2047 encoding used in mail headers see http tools ietf org html rfc2047 rfc2047 decode port ip op charset iso latin 1 Bigloo Mail procedure rfc2047 decode string charset iso latin 1 Bigloo Mail procedure These functions decode mail header fields encoded using the RFC 2047 specification The optional argument charset specified in which charset the result should be encoded The allowed values are e utf 8 e iso latin 1 e cp 1252 Example rfc2047 decode Poste IS0 8859 1 Q t E91 E9phonique gt Poste tphonique string for read rfc2047 decode Poste IS0 8859 1 Q t E91 E9phonique charset utf8 gt Poste t 303 2511 303 251phonique 19 3 RFC 2426 MIME Part three This section presents the facilities supported by Bigloo for dealing with vcards vcard Bigloo Mail class class vcard version bstring default 2 1 fn default f familyname default f firstname default f face default f url default f org default f emails pair nil default phones pair nil default addresses pair nil default The class vard is used to reify in memory a vcard as parsed by the function port gt vcard and string gt vcard Except emails phones and addresses all fields are optional They should be either 4f or a string Chapter 19 Mail 211 e face is a flat list of strings e phones is an alist whose
209. e the same message hash and call rsa verify with our public key rsa verify public key msg hash bignum signature gt t Encryption and decryption work in a similar way Suppose someone let s say Alice wants to send us the following secret message Cryp tography The encryption and decryption functions work similar to the signature func tions on bignums We could as before simply transform this short string into a bignum and directly encrypt the bignum This approach would however not work for longer strings In the following we will present the generic version that works with strings of any size Public key cryptography is relatively slow and Alice thus starts by encrypting our mes sage a fast block cipher with a random password define encrypted encrypt aes Cryptography my random password Alice can already send us the encrypted message We will just not yet be able to decrypt it as we don t have the random password yet Alice now takes her random password string and encrypts it with our public key define encrypted key rsa encrypt public key octet string gt bignum my random password Alice simply sends us the encrypted key On our side we can now decrypt the key define aes key bignum gt octet string rsa decrypt key encrypted key We can now decrypt the previously received message decrypt aes aes key encrypted Cryptography 14 2 1 4 RSA RFC 3447 The following functions have b
210. e2 imports it p may have two different macro expansions one for module1 and one for module2 2 6 Module access file Bigloo is different from languages such as C where a module is defined by a file For Bigloo the module name is not necessarily the name of the file where the text of the module is written and modules can even be split across several files Since modules are defined independently of files it is necessary to make a link between a module and its files and there are two ways of doing this Choosing an import clause where the file names are specified or creating a module access file Such a file must contain only one list each element of the list being of the form module name file name file name Use the afile lt file gt option to specify the module access file when compiling By default Bigloo checks if a file named afile exists If it exists it is loaded as a module access file See Chapter 31 The Bigloo command line page 271 Note The Bigloo distribution contains a tool bglafile that can automatically build a module access file See the manpage for bglafile for details 2 7 Reading path Imported included or loaded files are sought first in the current directory and then in the directories sequentially from start to end of the list in the 1oad path variable This variable initially set to the empty list can be reset by the I option of the compiler Chapter 3 Core Languag
211. eady three example scripts inside Bigloo s source tree e one asks using KDE s kdialog to execute the command by hand on the host side and to report the result e another one copies the file by ssh and executes it then on the other side Note there exists an Ipod Iphone version that automatically signs on jail broken devices e and finally as last resort there exists a netcat version if no ssh is available This one can be used on devices that only have telnet access and where ssh is not available Its only requirement is a running netcat on the host side which should be easily achievable since there exists a working cross compiler 294 Bigloo 4 2b 32 2 2 Building Armed with a working cross compiler CC and a script HOSTSH that invokes commands and executables on the host side the configure invocation is simple configure prefix PREFIX_PATH_ON_TARGET hostsh HOSTSH cc CC Other configuration options are of course possible too Once the configuration has finished one can build Bigloo and its library simply by calling make This will build the libraries as well as the binaries If shared libraries are needed on the host platform one still needs to install them The easiest way is probably to install them temporary on a build system inside a special directory and then copy them from there to the host system make DESTDIR temporary directory install Only the lib directory is needed on the host side 32 3 Cross Compi
212. ece eee eee 44 UCSLE SLIDE CA iia p EPI eR EE 44 ucs2 string Cci4T s ena cts 44 ucs2 string Ci 7 da 44 ucs2 string ci 2 lees 44 ucs2 string Ci5 ope ie e d repe EE 44 ucs2 string CODy ou sea rer ak erp CES 44 ucs2 string downcase esses 45 ucs2 string downcase cece 45 ucs2 string fill ceseess see 45 ucs2 string length sss 44 ucs2 string ref iia arias 44 ucs2 string set slo nen v0 pO 44 ucs2 string upcase cece ee eee eee 45 ucs2 string upcase sess 45 320 ucs2 String4 cT A px dns 44 ucs2 string4t esp oaa ni Eeh E a TAEAE 44 UCSLESTTADES a See EAER es 44 ucs2 string T osni merete n e a ede 44 ucs2 String T isde eoa Pese EI 44 cs2 string erinti ad REP alas 44 UCS2 pCase oll ead el pps oad oa 39 ucs2 Upper Case cc 39 ucs2 whitespace o csl elie eee es 39 UC dpi geben nantes 38 UBIL Ar gee et a 38 ucs2 t oid ih en A ee de 38 UCLA dl SI ta 38 cs237 VUA LT PRONUM aid 38 MCS 250 i e dole attr ete iae ido etie eee 38 UGS 2Characters ratita 38 UGS 2 Strings act decease ise e S ee 44 unbufferized socket port 84 90 92 uncaught exception reason 191 193 uncaught exception 191 193 unix path list 4 idad ynie 76 unread char aia dde 58 unread string 6 cece EEE G eee eens 58 unread substring 0 0 e cece e eee 58 unsigned
213. ed a right bracket immediately occurring after the opening left bracket also doesn t need to be a metacharacter Eg ab matches a and b 12 2 3 Some frequently used character classes Some standard character classes can be conveniently represented as metasequences instead of as explicit bracketed expressions Nd matches a digit 0 9 Ns matches a whitespace character and Nw matches a character that could be part of a word The upper case versions of these metasequences stand for the inversions of the corre sponding character classes Thus ND matches a non digit NS a non whitespace character and NW a non word character Remember to include a double backslash when putting these metasequences in a Scheme string pregexp match d d O dear 1 have 2 read catch 22 before 9 gt 22 These character classes can be used inside a bracketed expression Eg a z d matches a lower case letter or a digit 12 2 4 POSIX character classes A POSIX character class is a special metasequence of the form that can be used only inside a bracketed expression The POSIX classes supported are alnum letters and digits alpha letters algor the letters c h a and d ascii 7 bit ascii characters blank widthful whitespace ie space and tab cntrl control characters viz those with code lt 32 digit digits same as Md graph characters that use ink lower lower case
214. ed to be public rsa key length key Bigloo Cryptography procedure Returns the key length in bytes Chapter 14 Cryptography 159 14 2 1 2 RSA basic operations RSA only works on bignums up to the size of the modulus The following procedures implement basic encryption decryption signing and signature verification rsa encrypt key m Bigloo Cryptography procedure Encrypts the bignum m using the given key If the key is a complete key then its public exponent is used For partial keys only one exponent is available which is assumed to be the public e of the recipient The result is again a bignum rsa decrypt key c Bigloo Cryptography procedure Decrypts the bignum c using the given key If the key is a complete key then its private exponent is used For partial keys only one exponent is available which is assumed to be the private d The result is again a bignum rsa sign km Bigloo Cryptography procedure Signs the bignum m using key k Uses the private exponent of complete keys The result is a bignum rsa verify kms Bigloo Cryptography procedure Verifies the signature s Returns true if s is the signature of m The key k should be the public key of the signer 14 2 1 3 Examples In this section we will present an example of using RSA Let s start by generating an RSA key in openssl openssl genrsa out my_rsa_key pem 1024 Our key will have 1024 bits for the public modulus and therefore RSA will only be
215. ed which forces its default The argument max length specifies a maximum length in number of buckets for this hashtable It defaults to 16384 If during the execution the hashtable tries to expand itself more than max length an exception is raised This feature helps debugging incorrect hashtable uses because excessive expansion is generally the signs of an incorrect behavior Excessive expansions cause the garbage collector to crash at some point This debugging feature can be disabled by specifying a negative max length in which case no check is performed at runtime The argument bucket expansion controls how max bucket len is expanded each time the table grows This is a floating point number that is a multiplicative coefficient It defaults to 1 2 The function create hashtable is equivalent to make hashtable but it uses a key word interface The keyword argument weak can either be none data or keys hashtable obj bigloo procedure Returns t if obj is an hash table constructed by make hashtable Chapter 5 Standard Library 73 hashtable weak keys table bigloo procedure Returns stt if table is a hash table with weakly pointed keys hashtable weak data table bigloo procedure Returns t if table is a hash table with weakly pointed data hashtable size table bigloo procedure Returns the number of entries contained in table Note that for a weak hash table the size does not guarantee the real size since keys and o
216. edirection s es 00 e cece eee eee amp http redirection error 00 eee eee amp http status error 0 2 0 eee eee eee amp imap ertOr soe Mee lee et ee ge amp imap parse error eee amp io closed error 00 eee eee eee SAO O A sk amp io file not found error ssssssssss amp io malformed url error 79 SL O PArSe erTOT 6 eee ee amp i0 port error 2 eee eee amp io read error 6 eee eee ees amp io unknown host error 0 000e eee amp io write error 2 2 2 2 eee eee eee mailbox error epi ee r a Ai pa amp maildir error i a oni eee amp process exception sss eese A serie he haee awe EAS Swarming A ia eg ag ROL iia a eae ak eet eRe canas 305 O ctun he Mee Lust epe euet ia goed 34 ALTO iiti eensnis amp ee y bI er ERR aS 34 Load patb iile ne Sina etka kes 16 223 Dp CaseXic c ssenciekreme eed per ee aS 65 pp widtlet o euet Re Te ELESE RERE 65 ser pass s nc le rd as 297 Sse she dee Seah E 34 PRE RO tte ant Fan 34 Tel ng ni vg s gg REYAT UMP Sana ETE dah ons 34 MEL S ned dpsnnid ves Deyo end Ub reset 34 ioc c ETE 34 e ree chante sia pe I eoe edm 34 Tua dens e eM evt Pda aad m coe Res 34 ni EE 116 noc ET 35 A e ER Ide ee HEINE SACR een 35 Ai RH UR Eh OC E NN RET 35 A d uh ea OPEP DUO avi E 34 jvm cinit module 00 2 008 249 EAN 35 O 16 DILO Ci ta ds 273 A E e RE 245
217. ee eee 96 hmac shalsum string cece eeee 97 hmac sha256sum string sess 97 homogeneous vectors 0 00 eee eee ee eee 48 OS Tie eth Bis cis Bd Lec BOS Hee ed BOS os 89 HoOstint oii is Puc 4e veri eu tit aes 89 A cade one iade ee ah ier oe 76 ll sos seminee yang feres pesi 208 HSV SE Oi ta ted 208 http4 soaks EE bet D MEPRMPERUPN 100 101 http chunks gt port coco 103 http chunks procedure sss 103 http parse header cece eee eee 102 http parse response eee eee eee 103 http parse status line 102 http read Ctlf c sis oe ta 102 http Tread 1ine 4 0 ey enc ae A 102 http response body gt port 103 http send chunks eee 103 http url p rse 22 hhc clea hte he eR 100 hyphenate uide 44 wid dad 217 311 I 103 NSU ninnan as eV ey otal SEAS wA 202 LASS MUST CHAR socere traded rid dr bee 203 ieee string gt double 0 00 37 ieee string gt float o eoor una AETR 37 nia AE TE E E EEE E e rcu eu a at 19 ighores i irene tiie ni ede oe haat 130 LADA RA 212 214 imap capability 220 co ss dea ai 215 imap login id ad 214 imap logout ocio de 215 importi ea Sa 8 importing an extern function 234 importing an extern variable 234 Importing and Exporting sues 302 include bp I MEDII eA 8 including an extern file oo 234 inexact exact
218. een defined in RFC 3447 RSAEP k m Bigloo Cryptography procedure RSADP kc Bigloo Cryptography procedure RSASP1 km Bigloo Cryptography procedure RSAVP1 ks Bigloo Cryptography procedure These are the RFC 3447 names for encryption decryption signature and signature verification Note that the verification does not receive the original message as pa rameter In fact rsa verify is implemented as follows define rsa verify k m s bx m RSAVPI k s PKCS1 v1 5 pad m str key len mode Bigloo Cryptography procedure PKCS1 v1 5 unpad em str mode Bigloo Cryptography procedure Pads resp unpads the given string using PKCS1 v1 5 specifications Mode must be 0 1 or 2 Chapter 14 Cryptography 161 RSAES PKCS1 v1 5 encrypt key m str Bigloo Cryptography procedure RSAES PKCS1 v1 5 decrypt key c str Bigloo Cryptography procedure RSASSA PKCS1 v1 5 sign key msg str hash algo Bigloo Cryptography procedure sha 1 RSASSA PKCS1 v1 5 verify key msg str S str Bigloo Cryptography procedure RSASSA PKCS1 v1 5 sign bignum key msg str Bigloo Cryptography procedure hash algo sha 1 RSASSA PKCS1 v1 5 verify bignum key msg str Bigloo Cryptography procedure S RSAES PKCS1 v1 5 functions work on strings However their length is limited by the size of the modulus to be exact by key len 11 The bignum functions skip the last step of converting the internal bignum to strings The optional hash algo must be either sha 1 or md5
219. efault f ivm bigloo classpath JVM Bigloo classpath default f jvm catch Catch internal errors default t jvm cinit module Enable JVM class constructors to initiliaze bigloo modules default f ivm classpath JVM classpath default ivm debug JVM debugging mode default f ivm directory JVM object directory default f jvm env List of environment variables to be available in the compiled code default jvm foreign class id The identifier of the Jlib foreign class default foreign jvm foreign class name The name of the Jlib foreign class default bigloo foreign jvm jar Enable disable a JAR file production for the JVM back end default f 286 Bigloo 4 2b jvm jarpath JVM jarpath default f jvm java JVM to be used to run Java programs default java jvm mainclass JVM main class default f jvm options JVM options default ivm path separator JVM classpath default f jvm shell Shell to be used when producing JVM run scripts default sh ld debug option The C linker debugging option default g ld library dir Depreacted don t use default home serrano prgm project bigloo lib bigloo 4 2b ld o option The C linker o option default o ld optim flags The C linker optimization flags default ld options ld options default ld post options Id post options default ld relati
220. efore proceeding with the matching If you find yourself calling pregexp match positions repeatedly with the same U regexp it may be advisable to explicitly convert the latter into an S regexp once beforehand using pregexp to save needless recompilation pregexp match positions returns f if the pattern did not match the string and a list of index pairs if it did match Eg pregexp match positions brain bird gt f pregexp match positions needle hay needle stack gt 4 10 In the second example the integers 4 and 10 identify the substring that was matched 1 is the starting inclusive index and 2 the ending exclusive index of the matching substring substring hay needle stack 4 10 gt needle Here pregexp match positions s return list contains only one index pair and that pair represents the entire substring matched by the regexp When we discuss subpat terns later we will see how a single match operation can yield a list of submatches pregexp match positions takes optional third and fourth arguments that specify the indices of the text string within which the matching should take place pregexp match positions needle his hay needle stack my hay needle stack her hay needle stack 24 43 gt 31 37 Note that the returned indices are still reckoned relative to the full text string pregexp match regexp string bigloo procedure The procedure pregexp match is called like pregexp mat
221. el expressions see Section 3 1 2 Expressions page 17 2 2 Module declaration The module declaration form is module name clause bigloo syntax This form defines a module and must be the first in the file The argument name is a symbol naming the module If the same module name is used more than once Bigloo signals an error The runtime library is composed of modules that are read when a user module is compiled and hence if a user module has the same name as one of the library modules an error is signaled A simple module can be module foo display this is a module The first line here is the complete module definition the last line is the complete module body and together they form a complete Bigloo program If these lines were stored in file zz scm invoking bigloo zz scm would create the executable a out which when obeyed would display this is a module on the terminal Note Some special identifiers are reserved and can t be used to name modules If such an identifier is used the compiler will produce the message module t 4 8 Bigloo 4 2b ERROR bigloo TOP LEVEL Parse error Illegal module name MODULE eval The list of reserved identifiers may be enlarged for next release For the current release that list is made of eval foreign and t Module clauses can be main name bigloo module clause This clause defines the entry point for a stand alone application to be procedu
222. eld ica 180 184 192 threasd sie set eine evt eir hR8Rbesees Mm 179 Threads actrices 179 182 191 194 LIMA A al 76 LIME a a 93 TiMO ASECON S pis ii Nya Less ie beatae 2 191 LAME ED sends 191 o c gn Rte c Pg Mees Medea 177 ltrace bold ur a pene ERE HR 178 b race color i eo0s0 WRAP noia 178 Lrace litem oocnsb dite egre E Cie nd 178 trace margin is llssse laca nr 178 trace margin set 0c cece eee eee 178 Lrace portaz 2eesceR eu ae hebhp Gia aa 178 lrace port set il rsen dea ae E 178 Drace string ig lip EET REIR E ONT 178 Ltraunscript off ces ni REC Re ADR RE Im 224 transcript On ici espbbersese de lps adn da 224 A nce dik thaw ool E EE 30 IMC zs cig ri 35 truncato file otis es oe tak ese As 80 trunca tefl cie A US 35 VLry ede ee UM UJ DS ULIS 52 174 UDYpOec A dass 13 Typed identifier ooooooooocrorrorrrmo 17 Utypeofelcd ilu neldesh fex heic boh 171 U ucs2 2clab co sse rp A QerEONS 39 UCSI ME ii HR PHIL IR URS 39 ucs2 alphabetic c c sees 38 MCS2 C LSS Pte hse sles P ER RS RU ERA RES 38 ucs2 ci fT s M ad EEN 38 ucs2 ci f sviberp DR is 38 uc82 6123 0 Loro No 38 UCSI S lp eq p epI QU EUR CHEREPUSUE 38 ucs2 downca8e ve p o a 39 ucs2 loWer case l jl lg vi Ie e e 39 ucs2 numerlC ise d as 38 UCS2 SUring noli og a hare Rule Rew ele ba 44 ucs2 string list liess 44 ucs2 string gt utf8 string o oooooo 45 ucs2 string append c
223. eld is mutable and f otherwise class field mutator field bigloo procedure Returns a procedure of two arguments Applying this function to an object changes the value of the field described by field It is an error to apply class field mutator to an immutable field class field info field bigloo procedure Returns the information associated to field this the class declaration info attribute For means of an example here is a possible implementation of the equal test for objects Chapter 9 Object System 123 define object equal obji obj2 define class field equal fd let get value class field accessor fd equal get value obji get value obj2 let classi object class obj1 class2 object class obj2 cond not eq classi class2 8f else let loop fields class fields class1 class class1 cond null fields let super class super class if class super loop class fields super super t class field equal car fields loop cdr fields class else class creator class bigloo procedure Returns the creator for class The creator is a function for which the arity depends on the number of slots the class provides see Section see Section 9 2 Creating and accessing objects page 115 When an instance is allocated by the means of the class creator as for direct instantiation the class constructor is automatically invoked Example module foo
224. elements are pairs of two strings e addresses is a list composed of e the postoffice a string e a list of strings denoting the street address e a string denoting the city e a string denoting the region e a string denoting the zip code e a string denoting the zip country All street values are required and must be provided The empty string should be used to denote empty values port gt vcard vcard ip charset encoder Bigloo Mail function string gt vcard vcard str charset encoder Bigloo Mail function These two functions parse a vcard to produce a vcard instance The optional argu ment charset encoder when provided must be a function of argument a string to be decoded Vcard strings are UTF 8 encoded The charset encoder can be used to encode on the fly the strings found in the vcard in a difference encoding 19 4 RFC 2822 Internet Message Format This section described the functions offered by Bigloo to encode and decode some of the formats specified in the RFC 2822 http tools ietf org html rfc2045 It mainly supports functions for parsing email headers and for decoding email addresses mail header gt list obj Bigloo Mail procedure The function mail header gt list parses a mail header that can either be imple mented as a string or an input port It returns a list of fields Example mail header gt list Return Path lt foo bar inria fr gt Received from eurus inria fr unix socket
225. elf Operations on record types such as defining print methods reflection etc are left to other SRFIs e lt constructor name gt is bound to a procedure that takes as many arguments as the re are field tag s in the lt constructor name gt subform and returns a new lt type name gt record Fields whose tags are listed with lt constructor name gt have the corresponding argument as their initial value The initial values of all other fields are unspecified e lt predicate name gt is a predicate that returns t when given a value returned by lt constructor name gt and f for everything else e Each lt accessor name gt is a procedure that takes a record of type lt type name gt and returns the current value of the corresponding field It is an error to pass an accessor a value which is not a record of the appropriate type e Each lt modifier name gt is a procedure that takes a record of type lt type name gt and a value which becomes the new value of the corresponding field an unspec ified value is returned It is an error to pass a modifier a first argument which is not a record of the appropriate type Records are disjoint from the types listed in Section 4 2 of R5RS Seting the value of any of these identifiers has no effect on the behavior of any of their original values The following define record type pare kons x y pare x kar set kar y kdr defines kons to be a constructor kar and kdr to be
226. en to use read or any regular grammar This limitation is imposed by Rgc see Chapter 10 Regular Parsing page 125 that intrinsicly associates buffers with regular grammars If the current Rgc implementation is improved on the coming version this restriction will be eliminated Example open a client socket on port 80 make client socket www inria fr 80 open an unbufferized connection make client socket www inria fr 80 inbuf f outbuf f Socket obj bigloo procedure Socket server obj bigloo procedure Socket client obj bigloo procedure Returns t if obj is a socket a socket server a socket client Otherwise returns f Socket servers and socket clients are sockets Socket hostname socket bigloo procedure Returns a string which contains the name of the distant host attached to socket If socket has been created with make client socket this procedure returns the official name of the distant machine used for connection If socket has been created with make server socket this function returns the official name of the client connected to the socket If no client has used yet the socket this function returns 8f socket host address socket bigloo procedure Returns a string which contains the IP number of the distant host attached to socket If socket has been created with make client socket this procedure returns the IP number of the distant machine used for connection If socket has been created with make serv
227. en used This section presents only the mandatory functions to program with threads in Bigloo The most important difference with SRFI 18 is the missing of the function make thread which is not available for all libraries as it can be hard to predict the type of thread which will be created if several thread libraries are used simultaneously As threads are regular Bigloo objects they can be created using the instantiate syntax See the Section 16 2 Fair Threads page 182 and Section 16 3 Posix Threads page 191 specific sections for more details about thread creation and examples The examples given in this section use a generic syntax with instantiate thread to run the examples you will have to put them in a function in a module see Section Chapter 2 Modules page 7 and import one of the libraries using library module declaration current thread SRFI 18 function Returns the current thread thread obj SRFI 18 function Returns t if obj is a thread otherwise returns f thread name thread SRFI 18 function Returns the name of the thread thread specific thread SRFI 18 function thread specific set thread obj SRFI 18 function Returns and sets value in the specific field of the thread If no value has been set thread specific returns an unspecified value 180 Bigloo 4 2b let t instantiate thread body lambda print thread specific current thread thread specific set t foo thread start t
228. ent of the object is dis played using the display library function For instance define 1 list 1 2 3 set car cdr 1 1 set car cddr 1 1 display circle 1 4 0 1 0 4045 display string string output port bigloo procedure display substring string start end output port bigloo procedure String must be a string and start and end must be exact integers satisfying 0 lt start lt end lt string length string Display substring displays a string formed from the characters of string beginning with index start inclusive and ending with index end exclusive password prompt bigloo procedure Reads a password from the current input port The reading stops when the user hits the code Enter key 5 2 2 mmap The mmap function asks to map a file into memory This memory area can be randomly accessed as a string In general using mmap improves performance in comparison with equivalent code using regular ports mmap obj bigloo procedure Returns stt if and only if obj has been produced by open mmap Otherwise it returns Hf open mmap path mode bigloo procedure Maps a file path into memory The optional argument mode specifies how the file is open The argument can be e read t The memory can be read e read 4f The memory cannot be read e write t The memory can be written e write f The memory is read only 66 Bigloo 4 2b string gt mmap string mode bigloo procedure Wrap a Bigloo st
229. environment and options There are four ways to change the behaviour of Bigloo Flags on the command line the option module clause runtime command file and environment variables See Chapter 2 Modules page 7 When the compiler is invoked it first gets the environment variables then it scans the runtime command file and at end it parses the command line If the same option is set many times Bigloo uses the last one 31 5 1 Efficiency In order to get maximum speed compile with the Obench option This will enable all compiler optimization options and disable dynamic type checks To improve arithmetic performance see next section 31 5 2 Stack allocation When the fstack flag is enabled the compiler may automatically replace some heap allo cations with stack allocations This may improve performance because stack allocations are handled more efficiently than heap allocations On some cases fstack may also cause slow down or memory extra retentions In this last case when compile using fstack the pro gram will consume more memory Unfortunately this is nasty phenomenon is unpredictable it depends on the nature of the source file 31 5 3 Genericity of arithmetic procedures By default arithmetic procedures are generic T his means that it is allowed to use them with flonum and fixnum This feature of course implies performances penalty To improve performance you may use specialized procedures such as fx fx or f1
230. er or a string If no character is found string index returns f string skip string charset start 0 bigloo procedure string skip right string charset start len 1 bigloo procedure string skip resp string skip right searches through the string from the left resp right returning the index of the first occurrence of a character which e is not equal to c if c is a character e is not in c if c is a character set e does not satisfy the predicate c if c is a procedure If no such index exists the functions return false The start and end parameters specify the beginning and end indices of the search the search includes the start index but not the end index Be careful of fencepost con siderations when searching right to left the first index considered is end 1 whereas when searching left to right the first index considered is start That is the start end indices describe a same half open interval start end string contains stringl string start 0 bigloo procedure string contains ci stringl string start 0 bigloo procedure Does string string contain string string2 Return the index in string where string2 occurs first as a substring or false string contains ci is the case insensitive variant Case insensitive comparison is done by case folding characters with the operation char downcase char upcase c Chapter 5 Standard Library 41 string compare3 stringl string2 bigloo procedure strin
231. er socket this function returns the address of the client connected to the socket If no client has used yet the socket this function returns Socket local address socket bigloo procedure Returns a string which contains the IP number of the local host attached to socket Socket port number socket bigloo procedure Returns the integer number of the port used for socket Socket input socket bigloo procedure Socket output socket bigloo procedure Returns the file port associated for reading or writing with the program connected with socket If no connection has already been established these functions return f The following example shows how to make a client socket Here we create a socket on port 13 of the machine kaolin unice fr 1 Port 13 is generally used for testing making a connection to it permits to know the distant system s idea of the time of day 86 Bigloo 4 2b let s make client socket kaolin unice fr 13 print Time is read line socket input s socket shutdown s make server socket J optional port 0 key name f bigloo procedure backlog 5 make server socket returns a new socket object The socket will be listening on the network interface name either on the specified port or on a port chosen by the system usually the first port available on the network interface The name can be an IP number as a string or a host name whose first IP address will be used as returned by the n
232. ere qa ura esee erg ed 59 read eval print l00p 0ooooooooooomo 221 Read Eval Print Loop customized 221 read byte ence y de 61 read case insensitive uus us 59 read case Sensitive ccc eee eee 59 read certificate i 03 ol e ee ee 93 readschar ji 22hbeliegppeies ld e pere da lhe 61 rea d charg lp xa id ER 62 read charg 2 234 09 ia ed 62 read csv reCOord ic ucl sl RUE Ael 219 read csv records eee ee 219 read fill stringl ce l2 s tana Seed eet 62 re d linec i ise hs Soe Met a ee aS 62 read line newline ooo ooocoocrococoomo 62 Lead AM Sa a 62 LAA A AE UP ERES 202 read of stringS 4 eate e kid e THES 62 read pem file wert e IRE ER 93 read pem key eese imn pep SiS 162 read pem key file cece ee eee 162 read pem key port see 162 read pem key string 0005 162 read privat key coi da ae 93 Fead SLIM CH eee T cus 62 read case ci uiui Pees uL ora dened eae ides 59 read Pal rps eu m wade abe hones ie ee 60 137 read Ipss eiR c she wees RN ele os 60 125 reading path 24 iis RED ew lees 16 rea l String ci Sek Bie es 36 real i lllgcqsbenebveRetae Axe vetus E o adoos 32 Teclea dir ds an E Seb 53 PECOPAS ta e Anc URERTERE MD o ERA 109 reduces iig do 29 register class serialization 70 register crcl Lock IA io 99 Bigloo 4 2b register custom serialization 69 register e
233. erent programs It is better to copy the string before any physical update For instance don t write Chapter 5 Standard Library 31 string downcase symbol gt string foo See Section r5rs info in R5RS for more details but prefer string downcase symbol gt string foo string gt symbol string procedure string gt symbol ci string bigloo procedure symbol append symbol bigloo procedure String gt symbol returns a symbol whose name is string String gt symbol respects the case of string String gt symbol ci returns a symbol whose name is string upcase string Symbol append returns a symbol whose name is the concatenation of all the symbol s names gensym obj bigloo procedure Returns a new fresh symbol If obj is provided and is a string or a symbol it is used as prefix for the new symbol genuuid bigloo procedure Returns a string containing a new fresh Universal Unique Identifier see http fr wikipedia org wiki Universal Unique Identifier symbol plist symbol or keyword bigloo procedure Returns the property list associated with symbol or key word getprop symbol or keyword key bigloo procedure Returns the value that has the key eq to key from the symbol or keyword s property list If there is no value associated with key then f is returned putprop symbol or keyword key val bigloo procedure Stores val using key on symbol or keyword s property list remprop symbol or key
234. erminated It returns t otherwise process exit status process bigloo procedure This function returns the exit status of process if it is has finished its execution It returns f otherwise 84 Bigloo 4 2b process send signal process s bigloo procedure Sends the signal whose integer value is s to process Value of s is system dependent The result of process send signal is undefined process kill process bigloo procedure This function brutally kills process The result of process ki11 is undefined process stop process bigloo procedure process continue process bigloo procedure Those procedures are only available on systems that support job control The function process stop stops the execution of process and process continue resumes its execution process list bigloo procedure This function returns the list of processes which are currently running i e alive 5 7 4 Socket support Bigloo defines sockets on systems that support them as first class objects Sockets permits processes to communicate even if they are on different machines Sockets are useful for creating client server applications The implementation and this documentation are to a great extent copies of the STk Gallesio95 socket support Bigloo supports both stream oriented sockets and datagram sockets see Section The GNU C Library Reference Manual in libc Stream oriented sockets are created and manipulated with the following procedures m
235. ern Rather it is a repeat of the particular substring already matched by the subpattern In the above example the backreference can only match billions It will not match millions even though the subpattern it harks back to a z would have had no problem doing so pregexp match a z and 1 billions and millions gt df The following corrects doubled words pregexp replace S MW now is the the time for all good men to to come to the aid of of the party 1 now is the time for all good men to come to the aid of the party The following marks all immediately repeating patterns in a number string pregexp replace d 1 123340983242432420980980234 01 145 gt 12 3 3 40983 24 24 3242 098 098 0234 12 2 10 Non capturing clusters It is often required to specify a cluster typically for quantification but without triggering the capture of submatch information Such clusters are called non capturing In such cases use instead of as the cluster opener In the following example the non capturing cluster eliminates the directory portion of a given pathname and the capturing cluster identifies the basename pregexp match a z a z usr local bin mzscheme usr local bin mzscheme mzscheme 12 2 11 Cloisters The location between the and the of a non capturing cluster is called a cloister You can put modifiers there that will cause the enclu
236. ersion 21 or more recent http www emacs org or Xemacs version 20 4 or more recent http www xemacs org prcs version 1 2 1 or more recent http prcs sourceforge net gdb version 4 17 or more recent http www cygnus com gdb gprof ftp prep ai mit edu pub gnu texinfo ftp prep ai mit edu pub gnu gmake ftp prep ai mit edu pub gnu The following document describes the BEE the Bigloo Emacs Environment 34 1 Installing the BEE The standard procedure for installing Bigloo handles the compilation of all tools required by the BEE Additional Emacs lisp code have to be appended to your emacs file autoload bdb bdb bdb mode t autoload bee mode bee mode bee mode t setq auto mode alist append scm bee mode 300 Bigloo 4 2b sch bee mode scme bee mode NN bgl bee mode bee bee mode auto mode alist This code will force emacs to switch to BEE mode when editing Scheme source files 34 2 Entering the Bee Once your emacs is updated to start the BEE you just need to edit a file suffixed with one of the suffix listed in auto mode alist with Emacs You may either enter the Bee within Emacs with ESC X bee mode 34 3 The Bee Root Directory The Bee Root Directory is the directory that contains information files that describe a project When editing a file the BEE tries to automatically setup the Bee Root Directory For that i
237. es n1 expression expression plus term expression minus term term term term mult factor term div factor display gt display expression newline expression term expression term term term factor term factor factor factor factor lpar expression rpar expression const const regular grammar Cor tab space ignore newline nl digit cons const string gt number the string GIN plus gt minus gt mult div GA C lpar GIN rpar current input port reset eof current input port Chapter 12 Posix Regular Expressions 139 12 Posix Regular Expressions This whole section has been written by Dorai Sitaram It consists in the documentation of the pregexp package that may be found at http www ccs neu edu dorai pregexp pregexp html The regexp notation supported is modeled on Perl s and includes such powerful direc tives as numeric and nongreedy quantifiers capturing and non capturing clustering POSIX character classes selective case and space insensitivity backreferences alternation back track pruning positive and negative lookahead and lookbehind in addition to the more basic directives familiar to all regexp users A regexp is a string that describes a pattern A regexp matcher tries to match this pattern against a portion of another string which we will call the te
238. es that a pragma forms operates a side effects and that it writes into its parameters This assumption no long holds with free pragma This is the only difference between the two forms 26 3 Name mangling In order to avoid name clashes Bigloo uses name mangling when compiling to C or to Jvm The name mangling for a Scheme identifier may be overridden by the means of an extern export clause see Section Section 26 1 5 Exporting a Scheme variable page 235 Four public functions may be used to mangle and to demangle Scheme identifiers bigloo mangle string bigloo procedure Mangle the identifier string bigloo module mangle stringl string2 bigloo procedure Mangle the identifier string that belongs to module string2 Chapter 26 The C interface 243 bigloo mangled string bigloo procedure Returns t if string has been computed by the bigloo mangle or bigloo module mangle function bigloo class mangled string bigloo procedure Returns t if string is a mangled name of a Bigloo class bigloo need mangling string bigloo procedure Returns t if string requires name mangling because it is not a C or Jvm valid identifier bigloo demangle string bigloo procedure Demangle previously mangled identifiers let id foo module a module let mangled bigloo module mangle id module multiple value bind new id new module bigloo demangle mangled and string id new id string module new module gt
239. esse e I nn 169 15 Errors Assertions and Traces 171 15 1 Errors and WarningSs 0 00 cece eee eee eee aes 171 15 20 Exceptions o iraina tes eae eae eee oe 172 15 3 Deprecated try form 0 0 cece ene eee 174 TBA AS eer a dne td ots onal 175 15 5 Tracing B aao aoa ae de ee dee Sale ee Ree 177 16 SEBPOSUSS ii E ORE SEA 179 16 1 Thread Common Functions 00 e eee eee ees 179 16 L3 Thread APT oe ee an ai 179 10 1 2 Mutex e8S iii m egit ede ede Eee dene 180 16 1 3 Condition Variables 0 0 0 cece eee eee 181 16 2 Threads Gores titans tee ied dare Geetha hee ie 3 dq 182 16 2 1 Introduction to Fair Threads 2000 000s 183 16 2 2 Fair Dhreadsca pinnae Renn id aa 183 0 2 2 1 A A NO 184 16 2 2 2 Scheduler ERR re 189 16 2 2 3 Dima io ado aborda 190 16 23 SRETA Suit 191 16 3 Bosi Threads an it tae ia a ad rene 191 16 3 1 Using Posix Threads oooocccooccccccncncccnnncccoo 192 Bigloo 4 2b 1632 Threads tt RES Ce 192 16 9 8 Mutexes aii coat a ada dica sehen 193 16 3 4 Condition VariableS ooooocccoocccccroccccnanccooo 193 16 3 5 SREL IS e se o A aaa AVES 194 16 4 Mixing Thread APIS veria tia 194 lr Databases 197 SO da dla Do 197 18 WDalCUunediadooe eun ai 201 18 1 Photography ce ee eB oP SONUS 201 18 2 MUSIC vhosdirea tracti da dia 202 18 2 1 Metadata and Playlist 0 cece eee eee eee 202 18 22 Mixer arto to
240. ether to produce stand alone executable programs JVM jar files or NET programs However we designed Bigloo to be as close as possible to the R5RS Hence when Bigloo includes a feature that is extracted from Scheme and implemented as normal this feature is only mentioned in this document and not fully described 1 1 SRFI The Bigloo version 4 2b supports the following SRFIs e srfi O conditional execution e srfi 2 AND LET an AND with local bindings a guarded LET special form e srfi 9 Records specification e srfi 18 e srfi 22 e srfi 28 e srfi 30 e srfi 6 Basic String Ports e srfi 8 Binding to multiple values Multithreading support script interpreter invocation Basic Format Strings IO Sa as Multi line comments 1 2 Separate compilation To allow and stimulate separate compilation Bigloo compiles modules instead of entire programs A module is composed of a module declaration and a module body where a module body can be thought of as an incomplete Scheme program Bigloo strictly enforces variable bindings That is it is illegal in a body to refer to unbound variables In a module declaration some variables can be declared to be immutable functions For such variables the compiler can then check if the number of arguments for some function calls are correct or not When an arity mismatch is detected Bigloo signals an error and aborts the compilation process 4 Bigloo 4 2b 1 3
241. even 88 letrec binding body bigloo syntax Each binding has the form variablei lt init1 gt Each init is an expression Any variable must not appear more than once in the variable s The lt variable gt s are bound to fresh locations each variable is assigned in left to right order to the result of evaluating the corresponding init the lt body gt is evaluated in the resulting environment and the values of the last expression in body are returned Despite the left to right evaluation and assignment order each binding of a variable has the entire letrec expression as its region making it possible to define mutually recursive procedures Examples letrec x 1 f lambda y x y f 3 letrec p lambda x 1 q C x 1 q lambda y if zero y 0 1 p E y 1 x p 5 y x y gt 5 It must be possible to evaluate each lt init gt without assigning or referring to the value of the corresponding variable or the variable of any of the bindings that follow it in bindings Another restriction is that the continuation of each init should not be invoked more than once labels name arg body body bigloo syntax The syntax is similar to the Common Lisp one Steele90 where created bindings are immutable labels 1oop f 1 acc if null 1 reverse acc loop f cdr 1 cons f car 1 acc loop lambda x
242. f1 but it is possible to suppress the genericity and to make all generic arithmetic procedures for example fixnum ones For this you must use the compiler option farithmetic or add the following module clause option set genericity 4f in your module declaration 31 5 4 Safety It is possible to generate safe or unsafe code The safety s scope is type arity version and range Let s see an example define foo f v indice car f vector ref v indice In safe mode the result of the compilation will be Chapter 31 Compiler description 273 define foo f v indice let pair if and procedure f 5 type check procedure arity f 1 arity check if vector v 5 type check if and integer k 5 type check gt k 0 range check lt k vector length v range check f vector ref v indice error error error if pair pair 5 type check car pair error It is possible to remove some or all safe checks For example here is the result of the compilation where safe check on types have been removed define foo f v indice let pair if procedure arity f 1 arity check if and gt k 0 range check lt k vector length v range check f vector ref v indice error error car pair 31 5 5 The runtime command file Each Bigloo s user can use a special configuration file This file must be named
243. fb IV 44f pad none nonce init nonce update Counterpart to the encryption functions With the same parameters the decrypt function will decrypt the result of an encrypt call decrypt function will use the first block as IV Without IV Initial Vector the For compatibility the following functions remain in Bigloo They are in the default library and not inside the crypto library aes ctr encrypt text password nbits 128 aes ctr encrypt mmap mmap password nbits 128 aes ctr encrypt string string password nbits 128 aes ctr encrypt port iport password nbits 128 aes ctr encrypt file filename password nbits 128 bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure These functions are equivalent to a call to aes encrypt with mode set to ctr and a special string gt key parameter The optional argument nbits must either be 128 192 or 256 and determines the size of the key aes ctr decrypt text password nbits 128 aes ctr decrypt mmap mmap password nbits 128 aes ctr decrypt string string password nbits 128 aes ctr decrypt port iport password nbits 128 aes ctr decrypt file filename password nbits 128 Counterpart to aes ctr encrypt bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure Chapter 14 Cryptography 157 14 1 1 String to Key The following string gt key algorithms take a password string and tr
244. ficate cert must be of type certificate and the private key pkey must be of type private key If any of those two arguments is given they must both be given If those optional arguments are missing the connection will be encrypted but not signed from the server side which means the peer client will have to provide a certificate private key pair to encrypt the connection and that seldom happens Typical SSL servers provide their certificate and private key Note that since the peer client certificate is only known when we are accepting a client socket with socket accept the CAs and accepted certs optional arguments are only checked during the accept operation of a server socket The CAs optional argument specifies the list of certificates to trust as CA Certificate Authority for the connection It must be a list of values of type certificate If the list is empty the default list of trusted CA is used set by the system Note that giving a list of trusted certificates turns on the peer client certificate validation an amp io error will be raised if the peer client certificate is not signed directly or indirectly by one of the certificates in CAs when accepting the client socket The accepted certs optional argument gives a list of certificate objects of type certificate which are accepted as peer client certificate If accepted certs is 4f then every peer client certificate is accepted aside from eventual certificate validati
245. field prop gt gt read only get lt bigloo exp gt set lt bigloo exp gt default lt bigloo exp gt info lt bigloo exp gt A class is a Bigloo type see Section Section 26 1 6 1 Atomic types page 235 and the class identifier is extracted from the lt ident gt of the class definition If lt ident gt is also a lt typed ident gt the type part of this identifier denote the super class of the class If ident is a lt IEEE ident gt the super class of the class is the root of the inheritance tree the object class This object class is the only pre existing class Final classes can only be sub classed by wide classes Wide classes only for compiled modules can only inherit from final classes abstract classes can t be instantiated Wide classes cannot be defined within the interpreter The optional constructor is an expression that must evaluate to a one argument function This function is automatically invoked each time a new class instance is created The constructor is passed the fresh instance If a class has not defined a constructor the super class constructors are searched The first constructor found is invoked A constructor may be a generic function with a method specified for one or more classes A class field may be a typed class field which is achieved by using a lt typed ident gt instead of a lt IEEE ident gt for the lt ident gt value Field marked with read only declaration are immutables Defau
246. file or generate your own using sn k bigloo dotnetkey The pair must be registered using sn i bigloo dotnetkey Bigloo The pnet2ms program can be ran with pnet2ms myprogram exe Additional command line options are initlocals force all local variables to be initialized to their default value upon function entrance for PEVerify to succeed k Keep intermediate files register Register DLLs in the Global Assembly Cache v Enable verbose mode v2 Enable very verbose mode v3 Enable very very verbose mode 31 4 Linking It is easier to use Bigloo for linking object files which have been compiled by Bigloo An easy way to perform this operation is after having compiled all the files using the c option to invoke Bigloo with the name of the compiled files 272 Bigloo 4 2b When Bigloo is only given object file name as argument it searches in the current directory and the directory named in the 1oad path list the Scheme source file in order to perform a correct link Scheme source files are supposed to be ended by the suffix scm Additional suffixes can be added using the suffix option Hence if source files are named fool sc and foo2 sc a link command line could look like bigloo suffix sc fool o foo2 o o foo Note In order to understand how the Bigloo linkers operates and which libraries it uses it might be useful to use the v2 option which unveil all the details of the compilation and the link 31 5 The compiler
247. fined flonum arithmetic specialization default f optim cfa free var tracking Enable closure free variables specialization default f optim cfa funcall tracking Track values across funcall default f optim cfa pair quote max length Maximum length for pair literal tracking default 4 optim cfa pair Track values across pairs default f optim cfa unbox closure args Unbox closure arguments default f optim dataflow for errors Enable simple dataflow optimization for eliminating bad error messages default t optim dataflow types Enable dataflow optimization for types default f optim dataflow Enable simple dataflow optimization default f optim initflow Enable initflow optimization for global variables default f optim integrate Enable function integration closure analysis default t optim jvm Enable optimization by inlining jvm code default 0 optim jvm branch Enable JVM branch tensioning default 0 optim jvm constructor inlining Enable JVM inlining for constructors default 0 optim jvm fasteq EQ no longer works on integers use FX instead default f Chapter 31 Compiler description 289 optim jvm inlining Enable JVM inlining default 0 optim jvm peephole Enable JVM peephole optimization default 0 optim loop inlining Loop inlining optimization default t optim reduce beta Enable
248. flag to enable them If the assertions are disabled they are not evaluated If an assertion is evaluated if the expression exp does not evaluate to t an error is signaled and the interpreter is launched in an environment where var are bound to their current values Assertion forms are legal expressions which always evaluate to the unspecified ob ject Here is an example of assertion usage module foo eval export foo define foo x y assert x y lt x y labels gee t assert t gt t 00 let res x t assert res t gt res 10 res set x gee y assert x gt x 100 x rep1 This module is compiled with the g flag to enable assertions then the produced executable is run 176 Bigloo 4 2b a out 1 gt foo 1 2 File foo scm line 9 character 158 assert res t gt res 10 F 4 ERROR bigloo assert assertion failed BEGIN gt RES 10 0 GEE 1 FOO Variables value are RES 3 Kb gt D File foo scm line 12 character 228 assert x gt x 10 4 A ERROR bigloo assert assertion failed BEGIN gt X 10 0 FOO Variables value are X 3 gt 3 1 gt foo 1 2 File foo scm line 9 character 158 assert res t gt res 10 F 4 ERROR bigloo assert assertion failed BEGIN gt RES 10 0 GEE 1 FOO Variables value are RES 3 dl
249. g amp warning 15 3 Deprecated try form try exp handler bigloo syntax This form is deprecated As much as possible it should be replaced with true excep tions i e with exception handler and raise The argument exp is evaluated If an error is raised the handler is called The argument handler is a procedure of four arguments Its first argument is the continuation of try The other arguments are proc mes and obj Invoking the first argument will resume after the error let handler lambda escape proc mes obj print ERROR proc mes obj escape f try car 1 handler 4 ERROR CAR not a pair 1 Chapter 15 Errors Assertions and Traces 175 gt d The argument handler is not evaluated in the dynamic scope of its try form That is let handler lambda escape proc mes obj escape car obj try car 1 handler error ERROR bigloo CAR Type PAIR expected BINT provided 1 Some library functions exist to help in writing handlers warning arg bigloo procedure This form signals a warning That is is arg are displayed on the standard error port define foo 1 if not pair 1 begin warning foo argument not a pair 1 20 car 1 foo 4 WARNING bigloo foo argument not a pair 4 0 15 4 Assertions assert var s expression bigloo syntax Assertions can be enabled or disabled using Bigloo s compilation flags g
250. g compare3 ci stringl string2 bigloo procedure This function compares string and string2 It returns a negative integer if stringl lt string2 It returns zero if the string equal string2 It returns a positive integer if stringl gt string2 string natural compare3 stringl string2 start1 0 start2 0 string natural compare3 ci stringl string2 start1 0 start2 o This function compares stringl and string2 according to a natural string order It returns a negative integer if stringl lt string2 It returns zero if the stringl equal string2 It returns a positive integer if stringl gt string2 bigloo procedure bigloo procedure string natural compare foo foo gt 0 string natural compare foo0 fooi gt 1 string natural compare foo1 foo0 1 string natural compare rfc822 txt rfcl txt gt 1 string natural compare rfci txt rfc2086 txt gt 1 string natural compare rfc2086 txt rfci txt gt 1 string natural compare rfc822 txt rfc2086 txt gt 1 string natural compare a0 al gt 1 string natural compare al ala 1 string natural compare ala a1b gt 1 string natural compare alb a2 gt 1 string natural compare a2 a10 gt 1 string natural compare a10 a20 gt 1 string natural compare a2 a20 gt 1 string natural compare x2 g8 x2 y7 gt 1 string natural compare 1 001 1 002 gt 1 string natural compare
251. g elements are the production rules associated with this non terminal Each rule is a list whose first element is the rule itself a list of symbols and the other elements are the semantic actions associated with that particular rule For example consider the following grammar Eh El id E val El val id val id E val id val With Bigloo it would be written lalr grammar plus id e e plus id e id Cid id The semantic value of a symbol in a rule can be accessed by simply using the name of the symbol in the semantic action associated with the rule Because a rule can contain multiple occurrences of the same symbol Bigloo provides a way to access these occurrences separately To do so the name of each occurrence must be suffixed by var where var is the name of a variable that will be bound to the semantic value of the occurrence For example if the rule is 136 Bigloo 4 2b ifstmt H if E then Stmt else Stmt then in Bigloo it would look like if stmt if e then stmt conseq else stmt altern if eval e eval conseq eval altern 11 2 Precedence and associativity The bigloo lalr 1 parser generator supports operator precedence and associativity The method for specifying the precedence for terminal symbols is described in Section 11 1 Grammar Definition page 135 Precedence is assigned to each non terminal production from the precedence of the last terminal symbol appearing in that
252. gl and string2 are made of the same characters It returns f otherwise substring 7 stringl string2 len bigloo procedure This function returns t if string and string2 have a common prefix of size len substring abcdef ab9989898 2 gt dt substring abcdef ab9989898 3 gt f substring at stringl string2 offset len bigloo procedure substring ci at stringl string2 offset len bigloo procedure This function returns t if string2 is at position offset in the string string1 It returns f otherwise 40 Bigloo 4 2b substring at abcdefghij def 3 gt dt substring at abcdefghij def 2 gt f substring at abcdefghij defz 3 gt f substring at abcdefghij defz 3 3 gt dt string ci stringl string2 library procedure substring ci stringl string2 len bigloo procedure string lt stringl string2 library procedure string gt stringl string2 library procedure string lt stringl string2 library procedure string gt stringl string2 library procedure string ci lt stringl string2 library procedure string ci gt stringl string2 library procedure string ci lt stringl string2 library procedure string ci gt stringl string2 library procedure string index string charset start 0 bigloo procedure string index right string charset start len 1 bigloo procedure Returns the first occurrence of a character of char or set in string The argument charset is either a charact
253. gloo procedure 68 Bigloo 4 2b lst case tar header type h dir let path tar header name h if make directory path 1oop 1st error untar Cannot create directory path anormal let path tar header name h dir dirname path when and file exists dir not directory dir delete file dir unless file exists dir make directory dir with output to file path lambda display tar read block h pz loop cons path 1st else error untar format Illegal file type a tar header type h tar header name h close input port pz untar input port directory pwd file 44f bigloo procedure Untars the archive whose content is provided by the input port input port e If file is provided untar extract the content of the file named file and returns a string The file name must exactly matches the files of the archive files names If the file does not exist untar returns f e If file is not provided it untars the whole content in the directory denoted by directory which defaults to pwd The function untar returns the whole list of created directories and files 5 3 Serialization string gt obj string optional extension bigloo procedure This function converts a string which has been produced by obj gt string into a Bigloo object New in Bigloo 4 2a The extension parameter is used to decode extension sequences Theses sequences of chara
254. gt return path lt foo bar inria fr gt received from eurus inria fr unix socket email normalize string Bigloo Mail procedure The function email normalize extracts the actual email address from an email rep resentation Example email normalize foo bar lt foo bar inria fr gt foo bar inria fr rfc2822 address display name string Bigloo Mail procedure Extract the name component of an email Example rfc2822 address display name Foo Bar lt foo bar inria fr gt Foo Bar rfc2822 address display name lt foo bar inria fr gt gt foo bar 212 Bigloo 4 2b 19 5 Mail servers imap and maildir Bigloo implements the imap protocol http tools ietf org html rfc3501 and the maildir format This section presents the APT for manipulating them both 19 5 1 Mailboxes mailbox Bigloo Mail class abstract class mailbox label bstring default The abstract class mailbox is the common ancestors to all the mailbox implemen tations It allows the definitions of various generic functions that deal with mail messages and mail folders amp mailbox error Bigloo Mail class abstract class amp mailbox error amp error The nailbox error is the super class of all the errors that can be raised when accessing mail servers except the parsing errors that inherit from the amp parse error super class mailbox close mailbox Bigloo Mail procedure Close the mailbox connection Example
255. gular expression matches the string HL 5 This form constructs sequence of regular expression That is a form lt re1 gt lt re2 gt lt ren gt matches the language construction by concatenation of the language described by rei lt re2 gt ren Thus x all y matches all words of three letters started by character the x and ended with the character y D This construction denotes conditions The language described by or re1 re2 accepts words accepted by either re1 or re2 This is the Kleene operator the language described by lt re gt is the language containing 0 or more occurrences of lt re gt Thus the language described by abc accepts the empty word and any word composed by a repetition of the abc abc abcabc abcabcabc 128 Bigloo 4 2b lt re gt This expression described non empty repetitions The form re is equivalent to re re Thus abc matches the words abc abcabc etc lt re gt This expression described one or zero occurrence Thus abc matches the empty word or the words abc integer lt re gt This expression described a fix number of repetitions The form num re is equivalent to re re re Thus the expression 3 abc matches the only word abcabcabc In order to avoid code size explosion when compiling lt integer gt must be smaller than an arbitrary constant In the current version that value
256. gument of a set expression with the compiled code Variables that are exported to the evaluators must be exported If a variable is exported to the evaluators but not exported within an export clause the compiler will produce an error message The library clause makes the variables and functions of a library accessible from the interpreter module foo export fib x eval export fib import bar define fib x print bar The clause class lt bind name gt exports a class definition to the interpreter This makes the class constructor the class predicate and the slots access functions available from the interpreter The form instantiate class and with access class are also available from the interpreter extern extern bigloo module clause Extern aka foreign clauses will be explained in the foreign interface see Chapter 26 C Interface page 233 java java bigloo module clause Java clauses will be explained in the Java interface see Chapter 27 Java Interface page 245 option option bigloo module clause This clause enables variables which affect compilation to be set from inside a module and since the expressions option are evaluated when compiling no code is com Chapter 2 Modules 13 piled for them They are allowed to make side effects and to change the values of the global variables which describe how the compiler must compile Usually they allow the control va
257. he character bigloo rgc procedure the byte bigloo rgc procedure Returns the first character of a match respectively the first byte the byte ref n bigloo rgc procedure Returns the n th bytes of the matching string the symbol bigloo rgc procedure the downcase symbol bigloo rgc procedure the upcase symbol bigloo rgc procedure the subsymbol start length bigloo rgc procedure Convert the last matching string into a symbol The function the subsymbol obeys the same rules as the substring the keyword bigloo rgc procedure the downcase keyword bigloo rgc procedure the upcase keyword bigloo rgc procedure Convert the last matching string into a keyword the fixnum bigloo rgc procedure The conversion of the last matching string to fixnum the flonum bigloo rgc procedure The conversion of the last matching string to flonum the failure bigloo rgc procedure Returns the first char that the grammar can t match or the end of file object ignore bigloo rgc procedure Ignore the parsing keep reading It s better to use ignore rather than an expression like read rp grammar port in semantics actions since the ignore call will be done in a tail recursive way For instance let g regular grammar 20 Chapter 10 Regular parsing 131 let car ignore cdr ignore cons car cdr out the string p open input string foo bar gee read rp g p gt foo bar gee
258. hecks if the library ident exists for the current back end The regular Bigloo library paths are scanned unless optional paths are sent to the function bigloo library path library procedure bigloo library path set library procedure These functions get and set the default path a list of strings for loading libraries library load ident path library procedure Loads a library in the interpreter In addition to dynamically loading the library this function tries to load the _es version of the library if it is linked against the safe Bigloo library version or the _eu version if it is linked against the unsafe version of the Bigloo library Searches for libraries occur in the regular Bigloo library paths unless optional paths are sent to the function This version may be used for automatically exporting bindings to the interpreter In general the es and eu libraries are simple libraries that contain only one module the module that is used to build the heap file For instance let s consider an imple mentation of a library for SSL programming This library is composed of a single implementation module __ss1_ss1 The library is build using a heap file module ssl makelib import ssl ss1 Changing this file for module ssl makelib import ssl ss1 eval export a11 enables the construction of the es and eu libraries When the system loads a dynamic library it initializes it For that it expect
259. his is done using a popup menu entry or the C c C p c key binding Once your program compiled you can run for profile using a popup menu entry of the C c C p r key binding This last will run your program run bglprof to get the profile and this will pops up a window displaying the profile informations 34 14 Revision Control Submitting a new revision is done using C c C v i or using an menu bar entry This builds an new revision for the entire project The file that compose the project are listed in the pop entry of the Bee Root Directory Makefile Chapter 34 Bigloo Development Environment 303 Checking out an older version of the file currently edited is done using the key binding C c C v C o This is not a retrieval of the entire project Global check out may be performed manually Comparing the version of the file currently edited with older one is done using C c C v d A diff of the two buffers will be popped up With both checking out and comparison of versions A window presenting all the avail able version will be popped up to let you choose which version you would like to inspect 34 15 Literate Programming The BEE does not provide real Literate Programming The reason is that we think that when editing documentation we want to benefit the full power of context sensitive editors and we don t want to edit the documentation is the same editor mode as the one we use when editing source code Nevertheless it is possible to place anch
260. icate fun If the hash table is weak fun will only be called on sets of key datum which haven t dissapeared yet Here is an example of hash table define table make hashtable hashtable put table toto tutu hashtable put table tata titi hashtable put table titi 5 hashtable put table tutu tutu hashtable put table foo foo print hashtable get table toto 4 tutu print hashtable get table foo 4 foo print hashtable get table bar 4 hashtable for each table lambda key obj print cons key obj zi toto y tutu tata titi titi 5 tutu TUTU foo foo object hashnumber object bigloo generic This generic function computes a hash number of the instance object Example define method object hashnumber pt point with access point pt x y fx fx x 10 y string hash string start 0 len string length string bigloo procedure Compute a hash value for string starting at index start ending at length len 5 7 System programming Chapter 5 Standard Library 75 5 7 1 Operating System interface bigloo config bigloo procedure bigloo config key bigloo procedure The function bigloo config returns an alist representing the configuration of the running Bigloo system When used with one parameter the function bigloo config returns the value associated with the key Examples bigloo config
261. ich see No value for R5RS 23 1 Expansion passing style macros define expander name proc bigloo syntax This form defines an expander name where proc is a procedure of two arguments a form to macro expand and an expander define macro name args body bigloo syntax This form is itself macro expanded into a define expander form Macro expanders cannot be exported or imported since there is no way to specify expanders in a module declaration Macros defined with define expander and define macro are used by both the com piler and the interpreter Here is an example of an expander define expander when lambda x e match case x test exps e if test begin exps e else error when illegal form x when gt a 0 print a a gt if gt a 0 begin print a a The same example can written with a define macro form define macro when test exps if test begin exps 23 2 Revised 5 macro expansion Bigloo support the Revised 5 Report on the Scheme programming language For a detailed documentation see See Section r5rs info in R5RS let syntax binding body syntax letrec syntax binding body syntax define syntax keyword transformer syntax syntax rules literals rule syntax These three forms are compatible with the description of the Revised 5 Report on the Algorithmic Language Scheme Implementation Note Current Bigloo does
262. ific mutex SRFI 18 function mutex specific set mutex obj SRFI 18 function mutex state mutex SRFI 18 function mutex lock mutex timeout thread SRFI 18 function deprecated mutex unlock mutex SRFI 18 function deprecated let m make mutex thread start instantiate thread body lambda O let loop O if mutex lock m 0 begin Chapter 16 Threads 181 display locked mutex unlock m begin thread yield loop 4 locked let res 0 define mutex lock recursively mutex if eq mutex state mutex current thread let n mutex specific mutex mutex specific set mutex n 1 begin mutex lock mutex mutex specific set mutex 0 define mutex unlock recursively mutex let n mutex specific mutex if n 0 mutex unlock mutex mutex specific set mutex n 1 thread start instantiate thread body lambda O let m make mutex mutex lock recursively m mutex lock recursively m mutex lock recursively m set res cons mutex specific m res mutex unlock recursively m mutex unlock recursively m mutex unlock recursively m set res cons mutex specific m res res gt 02 synchronize mutex expl exp2 Bigloo form The function synchronize evaluates the expressions expl exp2 etc The mutex mutex is acquired and released before expl gets evaluated Its value is the value of the evaluated expression The form synchro
263. ific set 182 condition variable wait 182 condition variable 0 cece eee 181 Connecting Scheme and Java code 247 CONS RE UT 27 CMS dao Pa 28 control features csse 49 COPY files miki ack En ETEL vanes fee odes 80 COPY VECTOR D HE E rrn E IER UER 47 Cda oe get 36 COS o ette 36 Cp1252 utf8 is io 46 Epi2b2 UE aaa ds 46 cram md5sum string sss 96 CIO Seas 4 meer te bat ver Lise putes iius 98 rccelong le tielomng ipkile24 red eds 99 crc elong elong 6 cece eee eee oc 99 a Cinta EA 98 Cre length A O 98 crc llong le llomng ceiix iris 99 crc llong llong 00 cece cece eee 99 cre long less Long arcaicas cla 99 ercclong s Longs cc ci c eid ad et ioe d ede 99 ET CAMP Geet let eee eas 98 re nameg ti ea wedi Awe eb 98 Cre polynomialee st s23 ose tdaGab ed antes Eais 98 crc polynomial be le sss 100 erc polynomial le eee peck ests na stele 98 oa ae eh r EE des O 98 CTO STEINS caida ds 98 CRO E nee id bU 97 create hashtable sse 72 Creating and accessing objects 115 cross compilati0O oooooooccocccconocccco ee 293 CEVDtOBTAPDOY erie iris 153 A E T see ee 219 CSVALOLE cache noriai ei 219 CS mape ts RA a V PURSE 219 current dat rud ebelc oa 94 current error port 6 eee eee 55 current exception handler 172 current input port eee 5
264. iit ee eA PS 95 debug et estesi dl eos dosing 177 debugging uestre REDDERE SERIA OUR 302 Debugging Lalr Grammars 138 declare library teed e VIE p ERE 252 Declaring abstract Java classes 248 Declaring Java arTayS ooooooccoocoorcocoo 248 Declaring Java classes oooooooccoocmoooo 247 decrypt file bstring oooo o o 156 decrypt mmap DStIINDB o ooooooommmmoo 156 decrypt port bstring ooooooommmmoo 156 decrypt sendchars eee 156 decrypt string bstring 156 decrypt Dstrlng eee a AW 156 default scheduler sssssss 189 define wegen pt 22 231 define expander 0 cece eee eee 227 define genericiomn siii laa 117 define inline 0 lr eos 15 231 define Hacro siii tiia ies 227 define method cocino badge ae ae 117 define reader ctor cece eee eee 60 define record type cece eee eee 110 define StruCt interina rain Linn Res 109 define Syntax i be de nei laced hice es 227 defining an extern type 0 04 235 Deli 22 delay stes eiue PE tier DERE lade 22 delta hebes PLE es 28 delet els scri Er eG sae eee oa rns 28 delete directory cxw ea gy SIRE gn 80 delete duplicates cece ee eee 30 delete duplicates 0 eee eee eee 30 delete file ir cate tsk nea diene Date OR NERA E 80 309 directives sei rd O 8 directory liSt 1 oi bs keds a ct 8
265. iler style default gcc cflags Bigloo 4 2b Chapter 31 Compiler description 283 The C compiler option default Wpointer arith Wswitch Wtrigraphs DBGL_ BOOTCONFIG Feflags optim The C compiler optimization option default O3 eflags prof The C compiler profiling option default pg fno inline Wpointer arith Wswitch Wtrigraphs DBGL_BOOTCONFIG cflags rpath The C compiler rpath option default home serrano prgm project bigloo lib bigloo 4 2b compiler debug Debugging level default 0 compiler debug trace Debugging trace level default 0 compiler sharing debug Compiler self sharing debug default f compiler stack debug Compiler self stack trace debug default f compiler type debug Compiler self type debug default f csharp suffix C legal suffixes default cs debug module Module initilazation debugging default 0 default lib dir Depreacted don t use default home serrano prgm project bigloo lib bigloo 4 2b dest The target name default f dlopen init Emit a standard Bigloo dynamic loading init entry point default f dlopen init gc Emit a standard GC init call when initialization the module default f double ld libs Do we include the additional user libraries twice default t 284 Bigloo 4 2b Ferror localization Localize error calls in the source code default f eval options A user variable t
266. ince a signature composition may contain several signatures this function may be invoked several times The result is a list of subkeys that signed the message If the key manager doesn t have any of the signature keys then the result is the empty list A message string needs only be given if the signature is detached Otherwise the original message is encoded in the signature composition Example 166 Bigloo 4 2b let sig pgp read file msg sig let signers pgp verify sig my key manager for each lambda subkey print subkey gt string subkey signed the message signers pgp signature message signature Bigloo OpenPGP procedure Returns the signature s message or f if the signature is a detached signature pgp key key Bigloo OpenPGP procedure pgp subkey key Bigloo OpenPGP procedure Predicates for PGP Key and PGP Subkey pgp subkeys key Bigloo OpenPGP procedure Returns a list of PGP Subkeys of the PGP Key The first key in the list is the main key The main key is used as default for signatures pgp key gt string key Bigloo OpenPGP procedure pgp subkey gt string key Bigloo OpenPGP procedure Returns a string representation of the key resp subkey Example outputs pgp key gt string key John Doe john doe gmail com bd4df3b2ddef790c RSA Encrypt or Sign 424610a65032c42e RSA Encrypt or Sign pgp subkey gt string car pgp subkeys key John Doe john doe gmail com
267. ined in an java clause is an error However the definition of a Java class or an Java abstract class may be enriched from module to module 27 4 1 Automatic Java clauses generation Java clauses can be automatically generated using the Jigloo program which is distributed in the same package as Bigloo Using Jigloo may be a good way to understand how Java classes methods and variables have to be declared in Bigloo Jigloo reads Java class files and generate the Bigloo java clauses for that classes 27 4 2 Declaring Java classes The lt declare class clause gt clause denotes importation of Java classes lt declare class clause gt class lt typed ident gt lt slot gt lt string gt slot field method constructor field field modifier lt typed ident gt lt string gt method method modifier lt typed ident gt lt typed ident gt lt string gt constructor constructor ident typed ident modifier public private protected static final synchronized abstract When the compiler encounters a Java class declaration it automatically creates a pred icate If the class identifier is id the predicate is named id In addition the compiler generates functions that fetch and set the field values For a field named f these functions are named id f and id f set Methods and constructors are also always prefixed the name of the class That is for a meth
268. ing gt re or re re This is the name of a variable bound by a binding construction In addition to user defined variables some already exist These are all out Newline lower in az upper in AZ alpha or lower upper digit in 09 xdigit uncase in af09 alnum uncase in az09 punct in blank in t n space Space It is a error to reference a variable that it is not bound by a lt binding gt Defining a variable that already exists is acceptable and causes the former variable definition to be erased Here is an example of a grammar that binds two variables one called ident and one called number These two variables are used within the grammar to match identifiers and numbers regular grammar ident alpha alnum number digit ident cons ident the string number cons number the string else cons else the failure The regular language described by one unique character Here is an ex ample of a grammar that accepts either the character a or the character b regular grammar a cons a the string Nb cons b the string else cons else the failure This simple form of regular expression denotes the language represented by the string For instance the regular expression Bigloo matches only the string composed of HB Hi g 4X1 Ho Ho The re
269. ion The function sqlite map invokes a SQLite command built by implicitly invoking sqlite format on string and the optional arg arguments The result is a list whose elements are built by applying procedure to all the values returned by the SQLite call Note user callback procedure must not exit That is they must not invoke a function create by bind exit Exiting from a callback will leave the database in a inconsistent state that prevent transactions to be rolled back Example Chapter 17 Database 199 module example library sqlite define db instantiate sqlite sqlite exec db CREATE TABLE foo x INTEGER y INTEGER for each lambda x sqlite exec db INSERT INTO foo VALUES A A x x x iota 10 sqlite map db lambda s1 s2 string gt integer s1 string gt integer s2 SELECT FROM foo gt 0 2 6 12 20 30 42 56 72 90 Example2 module example library sqlite define db instantiate sqlite sqlite exec db CREATE TABLE foo x INTEGER y INTEGER for each lambda x sqlite exec db INSERT INTO foo VALUES A A x x x iota 10 sqlite map db vector SELECT FROM foo g 0 O gor n1 2 4 3 g 4 16 5 25 6 36 7 49 8 64 EJ 81 sqlite name of tables sqlite Bigloo Sqlite function Returns the name of tables in the database This list can also be obtained with sqlite map d
270. is 81 gt integer lt re gt The language described by the expression gt int re accepts word that are at least int repetitions of re For instance gt 10 a accepts words compound of at least 10 times the character a In order to avoid code size explosion when compiling lt integer gt must be smaller than an arbitrary constant In the current version that value is 81 lt integer gt lt integer gt lt re gt The language described by the expression min max re accepts word that are repetitions of re the number of repetition is in the range min max For instance 10 20 a In order to avoid code size explosion when compiling lt integer gt must be smaller than an arbitrary constant In the current version that value is 81 lt integer gt lt re gt The subexpression lt re gt has to be a sequence of characters Sequences are build by the operator or by string literals The language described by int re denotes the first letter of re or the two first letters of re or the three first letters of re or the int first letters of re Thus 3 begin is equivalent to or b be beg uncase lt re gt The subexpression re has to be a sequence construction The language described by uncase re is the same as re where letters may be upper case or lower case For instance uncase begin accepts the words begin beGin BEGIN BegiN etc in lt cset gt
271. is SRFI implies this minor nonconformance to Standard Scheme This external representation is also available in program source code For example set x Hu8 1 2 3 will set x to the object u8 1 2 3 Literal homogeneous vectors must be quoted just like heterogeneous vectors must be Homogeneous vectors can appear in quasiquotations but must not contain unquote or unquote splicing forms i e x u8 1 2 is legal but stu8 1 x 2 is not This restriction is to accomomdate the many Scheme systems that use the read procedure to parse programs e the following predefined procedures are available TAGvector obj SRFI 4 procedure make TAGvector n TAGvalue SRFI 4 procedure TAGvector TAGvalue SRFI 4 procedure TAGvector length TAGvect SRFI 4 procedure TAGvector ref TAGvect i SRFI 4 procedure TAGvector set TAGvect i TAGvalue SRFI 4 procedure TAGvector gt list TAGvect SRFI 4 procedure list gt TAGvector TAGlist SRFI 4 procedure where obj is any Scheme object n is a nonnegative exact integer i is a nonneg ative exact integer less than the length of the vector TAGvect is an instance of the TAGvector datatype TAGvalue is a number of the type acceptable for elements of the TAGvector datatype and TAGlist is a proper list of numbers of the type acceptable for elements of the TAGvector datatype It is an error if TAGvalue is not the same type as the elements of the TAGvector datatype for example if an exact integer is passed to
272. is almost the same as the Lex s one The reader tries to match the longest input from the stream pointed to by input port with one of several regular expressions contained in regular grammar If many rules match the reader takes the first one defined in the grammar When the regular rule has been found the corresponding Scheme expression is evaluated remark The traditional read Scheme function is implemented as define inline read port read rp scheme grammar port 10 2 The syntax of the regular grammar A regular grammar is built by the means of the form regular grammar regular grammar binding rule bigloo syntax The binding and rule are defined by the following grammar binding lt variable gt lt re gt lt option gt lt option gt lt variable gt lt rule gt lt define gt lt cre gt lt s expression gt lt s expression gt else lt s expression gt lt s expression gt lt define gt define lt s expression gt cre gt lt re gt context lt symbol gt lt re gt when lt s expr gt lt re gt bol lt re gt eol lt re gt bof lt re gt eof lt re gt re variable char lt string gt lt re gt Cor re lt re gt 126 Bigloo 4 2b lt re gt lt re gt lt integer gt lt re gt gt lt integer gt lt re gt lt integer gt lt integer gt lt re gt
273. is always preferred to an overall nonmatch In the following the longer alternate still wins because its preferred shorter prefix fails to yield an overall match pregexp match call call with current continuation constrained call with current continuation constrained call with current continuation constrained 12 2 13 Backtracking We ve already seen that greedy quantifiers match the maximal number of times but the overriding priority is that the overall match succeed Consider pregexp match ara aaaa The regexp consists of two subregexps a followed by a The subregexp a cannot be allowed to match all four a s in the text string aaaa even though is a greedy quantifier It may match only the first three leaving the last one for the second subregexp This ensures that the full regexp matches successfully The regexp matcher accomplishes this via a process called backtracking The matcher tentatively allows the greedy quantifier to match all four a s but then when it becomes clear that the overall match is in jeopardy it backtracks to a less greedy match of three a s If even this fails as in the call pregexp match a aa aaaa the matcher backtracks even further Overall failure is conceded only when all possible backtracking has been tried with no success Backtracking is not restricted to greedy quantifiers Nongreedy quantifiers match as few instances as possible and progressively backtrack to m
274. ist of active traces Runtime Command file f bigloorc only available in developing mode option enabled from O3 mode Bigloo Control Variables All the Bigloo control variables can be changed from the interpreter by the means of the eval option or using the module clause option For instance the option eval set strip t will set the variable strip to the value t These variables are access file default The default access file name default afile access files The access file names default Fadditional bigloo libraries The user extra Bigloo libraries default Fadditional bigloo zips The user extra Bigloo Zip files default additional heap name A name of an additional heap file name to be build default f additional heap names A list of Bigloo additional heap file name default Chapter 31 Compiler description additional include foreign The additional C included files default allow type redefinition If true allow type redefinitions default f ast case sensitive Case sensitivity default t auto link main Enable automatically a main generation when linking default t auto mode auto mode extend mode list default ml caml mli caml oon meroon snow bdb debug Bdb debugging mode default 0 bigloo abort Do we have the bigloo abort function in executab
275. itten A flush hook can return two types of values e A string which is then directly displayed to the system stream associated with the output port e An integer which denotes the number of characters of the output port flush buffer see output port flush buffer that have to be displayed on the system stream output port flush buffer port bigloo procedure output port flush buffer set port buffer bigloo procedure These functions gets and sets a buffer that can be used by program by the flush hooks The runtime system makes no provision for automatically allocated these buffers that hence must be manually allocated by programs The motivation for flush buffer is to allow programs to write flush hooks that don t have to allocate a new string each time invoked output port close hook port bigloo procedure output port close hook set port proc bigloo procedure Returns resp sets the close hook of the output port The close hook is a procedure of one argument the closed port The hook is invoked after the port is closed Chapter 5 Standard Library 55 input port close hook port bigloo procedure input port close hook set port proc bigloo procedure Returns resp sets the close hook of the input port The close hook is a procedure of one argument the closed port Example let p open input string etc passwd input port close hook set p lambda display done close input port p input port reope
276. ivalent to the mismatch index for the strings modulo the starti index offsets The optional start end indices restrict the comparison to the indicated substrings of sl and s2 string prefix sl s2 startl end1 start2 end2 SRFI 13 procedure string suffix sl s2 startl end1 start2 end2 SRFI 13 procedure string prefix ci sl s2 startl end1 start2 end2 SRFI 13 procedure 44 Bigloo 4 2b string suffix ci sl s2 startl endl start2 end2 Is s1 a prefix suffix of s2 The optional start end indices restrict the comparison to the indicated substrings of sl and s2 SRFI 13 procedure string hex intern string bigloo procedure string hex intern string bigloo procedure Converts an hexadecimal string of n characters into an actual string of n 2 characters string hex intern 4a4b4c JKL string hex extern string start end bigloo procedure Converts a string into a hexadecimal representation string must be a string and start and end must be exact integers satisfying 0 lt START lt END lt string length STRING The optional argument start default to 0 The optional argument end defaults to string length STRING string hex extern JKL gt 4a4b4c 5 1 10 Unicode UCS 2 Strings UCS 2 strings cannot be read by the standard reader but UTF 8 strings can The special syntax for UTF 8 is described by the regular expression tu C V x The library functions for Unicode string processing are
277. l date process exit mutex condvar mmap s8vector u8vector si6vector ui6vector s32vector u32vector s64vector u64vector f32vector f64vector dynamic env opaque foreign lt c type gt gt cobj char uchar short ushort int uint long ulong slong elong llong bool string file double float void function The type obj denotes the super type of all Bigloo types i e all Bigloo types such as procedure pair is an obj The type cobj denotes the super of all C types i e all preexisting C types such as char uchar schar short The type pair nil denotes values that are either pairs or the value 26 1 6 2 Struct and Union types C struct and Union types can be declared in Bigloo using lt struct type gt clauses lt struct type gt struct lt typed ident gt lt string gt lt union type gt union lt typed ident gt lt string gt This clause declared a C struct but C structure values cannot be handled by Bigloo Instead Bigloo is able to handle pointers to C structure T hus in order to help the definition of extern types when a struct named struct is defined if it does not exists yet Bigloo automatically defines a type pointer to the structure This type is named struct When a pointer to a structure type is defined Bigloo automatically produces functions to manipulate objects of this type Let us suppose the type definition of struct
278. l are the same persons print eq old boy junior junior gt sit print eq old girl pamela pamela t 9 5 Object library 9 5 1 Classes handling No type denotes Bigloo s classes These objects are handled by the following library func tions find class symbol bigloo procedure Returns if any the class named symbol class obj bigloo procedure Returns stt if and only if obj is a class class super class bigloo procedure Returns the super class of class Chapter 9 Object System 121 class subclasses class bigloo procedure Returns the subclasses of class class name class bigloo procedure Returns the name a symbol of class object constructor class bigloo procedure Returns class s constructor object class object bigloo procedure Returns the class that object belongs to 9 5 2 Object handling wide object object bigloo procedure Returns stt if object is a wide object otherwise it returns f object display object port bigloo generic This generic function is invoked by display to display objects object write object port bigloo generic This generic function is invoked by write to write objects object gt struct object bigloo generic struct gt object struct bigloo procedure These functions converts objects into Scheme structures and vice versa object equal object obj bigloo generic This generic function is invoked by equal when the first argument is an instance
279. lect a new thread to be resumed If there is only one thread started in the scheduler the same thread will be resumed The time of timeout is used to determine the time the thread must sleep Here are the possible types for timeout e date the thread sleeps at least until the date timeout e real the thread sleeps at least timeout seconds e fixum elong llong the thread sleeps at least timeout milli seconds thread terminate thread SRFI 18 function Terminates thread as soon as possible Chapter 16 Threads 193 thread join thread timeout SRFI 18 function The current thread waits until the thread terminates lf thread terminates thread join returns the end result of the thread or the end exception if that thread terminates abnormally It is possible to wait for the termination of the a thread if and only if it has been started with thread start joinable In particular threads started with thread start cannot be joined The optional argument timeout forces to wait at for timeout milli seconds for the thread to terminate Note that not all systems support this facility When supported the cond expand see see Chapter 30 SRFIs page 265 pthread timedjoin is de fined When the timeout expires some systems raise an error Other systems abort silently terminated thread exception obj SRFI 18 function uncaught exception obj SRFI 18 function uncaught exception reason exc SRFI 18 function 16 3 3 Mutexes Thre
280. les default f bigloo lib The Bigloo library default bigloo bigloo libraries c setup A list of C functions to be called when starting the application default bigloo licensing Add the Bigloo license default f bigloo name The Bigloo name default Bigloo 4 2b bigloo specific version The Bigloo specific version default bigloo tmp The tmp directory name default tmp bigloo user lib The user extra C libraries default 1d1 lunistring lresolv gmp pcre lm bigloo version The Bigloo major release number default 4 2b bmem profiling Instrument code for bmem profiling 281 snow spi pkgcomp 282 default f c debug C debugging mode default f c debug lines info Emit line directives default f c debug option cc debugging option default g c files The C source files default c object file extension The C object file extension default o c split string C split long strings default f c suffix C legal suffixes default c c user foot C foot default c user header C header default call cc Shall we enable call cc default f ae s The C compiler default gcc cc move Use mv instead of o when C compiling default t cc o option The C compiler o option default o cc options cc options default cc style The C comp
281. letters print ink users plus widthful whitespace space whitespace same as s upper upper case letters word letters digits and underscore same as w xdigit hex digits For example the regexp alpha _ matches a letter or underscore pregexp match alpha _ x gt x pregexp match alpha _ gt _ Following regexp custom we identify word characters as A Za z0 9 although these are too restric tive for what a Schemer might consider a word 144 Bigloo 4 2b pregexp match alpha gt sf The POSIX class notation is valid only inside a bracketed expression For instance alpha when not inside a bracketed expression will not be read as the letter class Rather it is from previous principles the character class containing the characters a 1 p h pregexp match alpha a gt a pregexp match alpha f By placing a caret immediately after you get the inversion of that POSIX char acter class Thus alpha is the class containing all characters except the letters 12 2 5 Quantifiers The quantifiers and match respectively zero or more one or more and zero or one instances of the preceding subpattern pregexp match positions c ad r cadaddadddr 0 11 pregexp match positions c ad r cr CO 2 pregexp match positions c gt ad r cadadd
282. lib is used Bigloo automatically searches for a file called lib init the init file If such a file exits it is loaded at compile time For instance the init file may be used to specify compilation flags or to define macros used by the compiler The initialization file may affect any of the global parameters of the Bigloo compiler For instance a Bigloo library supporting SSL connections would likely need a native library Setting the compiler variable 1d post options has this effect For instance one may define an initialization file such as 252 Bigloo 4 2b cond expand bigloo compile set ld post options string append lssl ld post options bigloo eval ttunspecified When a Bigloo library lib is used the Bigloo linker automatically looks at a library to be linked against the application The name of the file containing the library depends on the operating system and the back end used For instance under Unix for a library called NAME the Bigloo linker searches for a file called 1ibNAME_ s u VERSION a or libNAME s u VERSION DYNLIB SUFFIX in the compilation linker path when using the native back end It searches for a file NAME s lu VERSION zip when the JVM back end is used This default NAME can be overridden in the initialization file The function declare library associates a Bigloo library name and a system name declare library ident attributes library procedure All the attributes are optional e
283. library point BCOMMONFLAGGS mkaddlib fsharing q S VERBOSE N copt CCOMMONFLAGS cc CC BSAFEFLAGS BCOMMONFLAGGS cg 03 g cg unsafev eval set indent 4 rm BUNSAFEFLAGS BCOMMONFLAGS O4 unsafe cigloo flags CIGLOO cigloo cflags CC gcc CCOMMONFLAGS I CSAFEFLAGS CCOMMONFLAGS CUNSAFEFLAGS CCOMMONFLAGS 02 library objects SAFE OBJECT olib spoint o olib cpoint o UNSAFE_OBJECT olib_u spoint o olib_u cpoint o all afile heap lib example afile spoint scm makelib scm bglafile gt heap point heap point heap spoint sch spoint scm BIGLOO S BHEAPFLAGS makelib scm addheap point heap lib lib_u lib a lib a olib S SAFE_OBJECT ar qcv libpoint s RELEASE a S SAFE_OBJECT lib_u olib_u UNSAFE OBJECT ar qcv libpoint_u RELEASE a S UNSAFE_OBJECT Chapter 28 Bigloo Libraries 261 olib mkdir olib olib_u mkdir olib_u olib_u spoint o olib spoint o spoint scm BIGLOO BSAFEFLAGS lt F o 0 c olib_u cpoint o olib cpoint o cpoint c CC CSAFEFLAGS lt F o 0 c spoint sch cpoint h cpoint c cigloo gt example heap lib BIGLOO v2 L library point static bigloo example scm o example clean bin rm f point heap bin rm f spoint sch spoint c bin rm fr olib olib_u bin rm f example example c example o bin rm f libpoint_s RELEASE a libpoint_u RELEASE a Chapter 29 Ex
284. line Documentation On line documentation may be popped up This is always done clicking on the Info icon of the tool bar or C c C d i If an emacs region is active the documentation about that region will be popped up If the cursor is at a Scheme identifier the documentation of that identifier will be printed Otherwise the user will be prompted for the Section of the documentation to be printed Clicking on the icon tool bar pops up a short description of the Bigloo compiler options The BEE uses info files for printing On line documentation It always search the stan dard documentation and the standard definition of Scheme It is possible to add extra info files to be searched The BEE always checks for a directory info in the Bee Root Directory If such a directory exists contained file will be considered for the search of a document 302 Bigloo 4 2b 34 10 Searching for Source Code Searching for source variable declaration module definition variable usage is supported by the BEE Clicking on the Find icon of the tool bar will pops up the definition of the variable the cursor is in or the definition of the module the cursor is in These two operations may be requested using C x 5 for searching a variable definition C c C d m for a module definition Information and usages of a variable may be printed using either the Doc icon of the tool bar or the C c C d u key binding 34 11 Importing and Exporting Bigloo bindings
285. ling Bigloo Programs Once the host library exists cross compilation is straightforward Using the 1ib dir com pilation flag one simply has to pass the library directory to Bigloo bigloo lib dir path to cross compiled library Bigloo will automatically use the same C cross compiler and compilation flags that have been used to build the library 32 4 Caveats In general Bigloo s cross compilation works fine but developers should be aware of some limitations e Macros will be executed on the build platform The macro environment and in particu lar its integer types might not be the same For instance an elong on the build system might be of different size than an elong on the host system e Bigloo will read numbers on the build system and adapt the container size accordingly Suppose for instance that the build system features 64bit longs but the host system only allows for 32bit longs The number 2735 fits easily into a long on the build system but will overflow on the host system The container will however be determined on the build system and thus a long will be used This is only a problem for big integer literals e A cross compiled Bigloo uses by default the same C compiler that has been used to compile the Bigloo Once the executable has been transferred to the host system the C cross compiler does very likely not exist anymore Therefore Bigloo will need to be invoked with the cc flag on the host system under the as
286. list and always succeeds For instance a is equivalent to a when occurring in a list matches any sequence of anything a b matches any list whose car is a and last car is b a matches any list of a s possibly empty x x matches any list of length 2 whose car is eq to its cadr Cand not a x x matches any list of length 2 whose car is not eq to a but is eq to its cadr matches any vector whose length is at least 2 foo integer matches any structure or record foo whose first and second fields are respectively a pair and an integer You can provide only the fields you want to test The order is not relevant Remark and patterns can not appear inside a vector where you should use For example st a b or a are invalid patterns whereas a is valid and matches any vector whose first element is the atom a Chapter 7 Fast search 107 7 Fast search This chapters details the Bigloo s API for fast string search algorithms 7 1 Knuth Morris and Pratt Bigloo supports an implementation of the Knuth Morris and Pratt algorithm on strings and memory mapped area See Section 5 2 2 Memory mapped area page 65 kmp table pattern bigloo procedure This function creates a kmp table used for fast search kmp mmap kmp table mmap offset bigloo procedure kmp string kmp table string offset bigloo procedure This function searches the patter
287. lize the module when the Java classes implementing the Bigloo modules are loaded It is possible to drive the Bigloo compiler to introduce code inside the Java class constructors for initializing the modules This is the role of the jvm cinit module compiler option 27 5 Performance of the JVM back end We are currently improving and investigating about the performance of the JVM back end JVM performance is extremely sensitive to the host platform for instance very unfortunately Linux seems to be a poor platform to run JVM code Currently it seems that the JVM back end produces codes that are in between 4 times and 10 times slower than codes produced by the C back end The ratio between JVM and C is subject to changes The gap between JVM and C code is bound to bridge because of the huge amount of efforts applied to efficiently implement Java virtual machines Chapter 28 Bigloo Libraries 251 28 Bigloo Libraries Bigloo libraries are collections of global bindings global variables and global functions Bigloo libraries are built on the top of the host operating system e g Unix libraries Because Bigloo uses modules a library is not only a bundle of compiled codes and memory locations A Bigloo library is split into several files e one heap that describes the variables and functions of the library e several host library files safe and unsafe versions of the compilation and also eval libraries that contain the code that binds the
288. llocate point orig begin c print point orig scheme print point orig 26 1 6 3 C pointers C pointers are defined by the lt pointer type gt lt pointer type gt gt pointer lt ident gt lt ident gt is the name of a previously defined type Let us suppose the pointer type declaration type ptr pointer ident If ident is the name of a structure type Bigloo automatically creates structure accessors see Section 26 1 6 2 C structures and unions page 236 Otherwise it creates the following functions e A creator make ptr ptr nb long This function allocates memory for nb elements of type ident and returns a ptr to this zone The memory is filled with the C Nu11 value e A type checker ptr bool obj obj This function returns t the argument obj is of type ptr and f otherwise 238 Bigloo 4 2b A null checker ptr null bool ptr This function returns stt if its argument is Null and f otherwise A null creator make null ptr ptr This function creates a NULL value of type ptr An equality checker ptr bool ptr ptr This function returns t if its arguments are equal and f otherwise Accessors and mutators ptr ref ident ptr long ptr set obj ptr long ident These functions read and store field values Here is an example of a program using pointer types module foo extern type double pointer double double define make vect double x
289. lobal variable db1 to a database that is stored on the file system at location tmp foo db This example also binds the global variable db2 to an in memory SQLite database sqlite close sqlite Bigloo Sqlite function This function closes a database previously opened by creating an instance of the class sqlite Example let db instantiate sqlite sqlite exec db CREATE TABLE tablei x INTEGER y INTEGER sqlite exec db INSERT INTO table1 VALUES a a 1 4 sqlite close db sqlite format string arg Bigloo Sqlite function Constructs a string of characters representing an SQLite commands This function acts as format see Section 5 2 Input and Output page 53 It is augmented with three additional escape sequence q k and l The first one build a string of characters where the characters denoting SQL strings i e the character is auto matically escaped The escape character k introduces a list of SQL strings The escape character 1 introduces a SQL list Summary of all escape codes e a The corresponding value is inserted into the string as if printed with display e s The corresponding value is inserted into the string as if printed with write 198 Bigloo 4 2b e A newline is inserted e A tilde is inserted e q n SQL escaped string e 1 Introduces a list comma separated e k Introduces a list of SQL strings Examples module example library sqlite sqlite format a
290. loo syntax define inline f type a type body bigloo syntax let var type body bigloo syntax let loop var type body bigloo syntax let var type body bigloo syntax letrec var type body bigloo syntax labels var type var type b body bigloo syntax Type annotations are optional That is for any of these constructions if a type annotation is missing Bigloo uses the default generic type obj instead Here is an example of type annotated program module example export vector fill vector vector obj define vector fill v filler let loop i long vector length v 1 if i0 v begin vector set v i filler loop E i 1 let v vector make vector 3 4 vector fill v dummy The types that can be used in annotations are any of e the basic Scheme types pair null bstring bint presented in Section Section 26 1 6 Defining an extern type page 235 e the basic extern types long int char string presented in Section Section 26 1 6 Defining an extern type page 235 e the compound extern types described in Section Section 26 1 6 Defining an extern type page 235 e the types introduced by class declarations Section Section 9 1 Class declaration page 113 232 Bigloo 4 2b When a function that contains type annotation is exported the type annotations must be written in the prototype of the function i
291. lt declarations allow default field values 114 Bigloo 4 2b For the means of an example the traditional points and colored points can be defined as module example static abstract class pt class point pt x double y double class point C point color string read only We illustrate final and wide classes by the example module example export final class person name string default Jones sex read only children pair nil wide class married person person mate person Fields may be virtual A field is virtual as soon as its declaration contain a get attribute Virtual fields have no physical implementation within the instance When defining a virtual field the class declaration implements a getter and a setter if that field is not a read only field Access to the virtual field will rely on invocation of the user getter and user setter For instance module example static class complex mag double angle double real double get lambda p with access complex p mag angle mag cos angle read only imag double get lambda p with access complex p mag angle mag sin angle read only let p instantiate complex mag 1 0 angle 2 18 with access complex p real imag print real real print imag imag Virtual fields cannot be associated default values If a virtual field is not provided with a setter it must be annotated as re
292. main args let public key car pgp read file A2DA694E Bigloo Example pkey secret key car pgp read file A2DA694E_Bigloo_Example skey display pgp key gt string public key display pgp key gt string secret key The compilation is straight forward and does not require any special flags bigloo print key scm o print key print key Bigloo Example 07ca0495a2da694e DSA Digital Signature Standard 5fa4e8c90b8985e5 ElGamal Encrypt Only Bigloo Example 07ca0495a2da694e DSA Digital Signature Standard 5fa4e8c90b8985e5 ElGamal Encrypt Only As can be seen the pgp key gt string routine does not differentiate between public and private keys We can also sign a message let my key car pgp read file A2DA694E_Bigloo_Example skey pgp write file msg sig pgp sign read string my key lambda key Bigloo Example Password gt detached signature f Signatures from Bigloo follow RFC 4880 and can therefore be verified by gpg echo Gpg can verify Bigloo s signature sign gpg verify msg sig gpg Signature made Sat 07 Aug 2010 10 12 21 PM CEST using DSA key ID A2DA694E gpg Good signature from Bigloo Example Inversely Bigloo can verify pgp s signature Here we first generate a signature with gpg echo Bigloo can verify gpg s signatures N gpg o msg gpg sig a default key Bigloo Example A 168 Bigloo 4 2b passphrase lt Bigloo Example Password N sign You
293. main main static class c1 c1 constructor define ci constructor let count 0 lambda inst set count 1 count print creating instance count inst define main argv let o1 instantiate c1 o2 instantiate c1 03 class creator c1 done creating instance 1 creating instance 2 creating instance 3 class predicate class bigloo procedure Returns the predicate for class This predicate returns t when applied to object of type class It returns amp f otherwise Chapter 10 Regular parsing 125 10 Regular parsing Programming languages have poor reading libraries since the lexical information that can be specified is directly tied to the structure of the language For example in C it s hard to read a rational number because there is no type rational Programs have been written to circumvent this problem Lex Lesk75 for example is one of them We choose to incorporate in Bigloo a set of new functions to assist in such parsing The syntax for regular grammar also known as regular analyser of Bigloo 2 0 the one described in this document is not compatible with former Bigloo versions 10 1 A new way of reading There is only one way in Bigloo to read text regular reading which is done by the new form read rp regular grammar input port bigloo procedure The first argument is a regular grammar also known as regular analyser and the second a Scheme port This way of reading
294. make file name getenv HOME maildir tprint mailbox folders mbox amp maildir error Bigloo Mail class class amp maildir error amp mailbox error Chapter 20 Text 217 20 Text This chapter describes the Bigloo API for processing texts 20 1 BibTeX bibtex obj Bigloo Text function bibtex port input port Bigloo Text function bibtex file file name Bigloo Text function bibtex string string Bigloo Text function These function parse BibTeX sources The variable obj can either be an input port or a string which denotes a file name It returns a list of BibTeX entries The functions bibtex port bibtex file and bibtex string are mere wrappers that invoke bibtex Example bibtex open input string book as sicp author Abelson H and Sussman G title Structure and Interpretation of Computer Programs year 1985 publisher MIT Press address Cambridge Mass USA gt as sicp BOOK author Abelson H Sussman G title Structure and Interpretation of Computer Programs year 1985 publisher MIT Press address Cambridge Mass USA bibtex parse authors string Bigloo Text function This function parses the author field of a bibtex entry Example bibtex parse authors Abelson H and Sussman G gt Abelson H Sussman G 20 2 Character strings hyphenate word hyphens Bigloo Text function The function hyphena
295. model does not permit to create threads before the main function is started In other words it is unsafe to use the Posix Threads API at the top level of modules On some particular applications this might work correctly On other it could produce an error message stating the threads cannot be created or started before the pthread library is initialized 16 3 2 Threads instantiate pthread body thunk name name Bigloo syntax make thread thunk name SRFI 18 function Returns a new thread which is not started yet The body of the thread is the body of the procedure thunk The optional argument name can be use to identify the thread It can be any Bigloo value Warning the make thread function is deprecated but still provided for a back ward compatibility with previous release of Bigloo T he use of this function is highly discouraged in favor of the instantiate pthread form module example library pthread main main define main argv make thread lambda print 1 thread yield print 2 my thread thread start thread SRFI 18 function thread start joinable thread SRFI 18 function Runs a thread created with instantiate pthread By default threads are de tached and thus they cannot be joined thread yield SRFI 18 function The current thread cooperates thread sleep timeout SRFI 18 function The current thread sleeps for a certain period It is suspended and the scheduler is free to se
296. mp type error defined as class amp type error amp error type read only e amp io error defined as class amp io error amp error e amp io port error defined as class amp io port error amp io error 174 Bigloo 4 2b e amp io read error defined as class amp io read error amp io port error e amp io write error defined as class amp io write error amp io port error e amp io closed error defined as class amp io closed error amp io port error e amp io file not found error defined as class amp io file not found error amp io error e amp io parse error defined as class amp io parse error amp io error e amp io unknown host error defined as class amp io unknown host error amp io error e amp io malformed url error defined as class amp io malformed url error amp io error e amp http error defined as class amp http error amp error e amp http redirection error defined as class amp http redirection error amp http error e amp http status error defined as class amp http status error amp http error e amp http redirection defined as class amp http redirection amp exception port input port read only url bstring read only e amp process exception defined as class amp process exception amp error e amp warning defined as class amp warning amp exception args read only e amp eval warning defined as class amp warnin
297. mpiler CC running on the build system producing executables for the host system In order to execute programs on the host it is however not sufficient to simply com pile Bigloo produced programs with this compiler Indeed these programs depend on the Bigloo library which thus has to exist on the host platform Building a cross compilation environment is done in two phases e Build a Bigloo for the build platform Usually this is a given e Build the Bigloo library for the host platform At the same time one might want to build the Bigloo executable for the host platform too but this is not a requirement Programs can then be cross compiled simply by telling Bigloo to use the host library Note if the cross compiled executable uses shared libraries then Bigloo s cross compiled libraries have to be copied to the host platform Static executables are self contained and can be run without modification on the host 32 2 Building the Bigloo library for the host platform We assume that we have a C cross compiler CC and an empty Bigloo source tree As a first step the configuration script must be executed However Bigloo s configure script requires some runtime information from the host and thus needs access to the host machine This is accomplished by passing a hostsh script to configure 32 2 1 Hostsh A hostsh script is passed to Bigloo s configuration script and is invoked whenever a command should be executed on the host side There are alr
298. ms Note There is no register compiler srfi because the compiler automatically registers SRFI when the library flags are used However it exists several ways to tell the compiler that it actually supports some srfis when compiling some modules e he first way is to insert calls to register eval srfi in the bigloorc file see Chapter 31 Compiler Description page 271 268 Bigloo 4 2b e The second is to use option see Section 2 2 Module Declaration page 7 module clause such as module example option register srfi srfi foobar e The last way is to use the command line option srfi see Chapter 31 Compiler Description page 271 30 2 SRFI 1 The SRFI 1 is implemented as a Bigloo library Hence in order to use the functions it provides a module must import it module ex library srfil print find tail even 3 1 37 8 5 0 0 8 5 0 0 30 3 SRFI 22 The SRFI 22 describes basic prerequisites for running Scheme programs as Unix scripts in a uniform way A file henceforth a scipt conforming SRFI 22 has the following syntax lt script gt gt lt script prelude gt program lt script prelude gt gt space all but linebreak gt lt linebreak gt A Scheme script interpreter loads the lt script gt It ignores the script prelude and in terprets the rest of the file according to the language dialect specified by the name of the interpreter The Scheme script interpreter m
299. ms Instead of import clauses use clauses should be preferred Use clauses do not create dependencies because a module mod1 that uses a second module mod2 does not require mod2 to be initialized Of course it may happen situations where the initialization is mandatory and thus the import must not be replaced with a use clause The source code of the Bigloo library makes use of import and use clauses The Bigloo standard library should be studied as an example 258 Bigloo 4 2b 28 7 Library and macros Bigloo libraries can export macros expanders and syntaxes but these must be handled carefully Macros these also applies to expanders and syntaxes exported by modules are not visible by client code Exported macros have to be placed inside the initialization file For instance if we change the definition of bformat init file for declare library bformat version 1 0 srfi bformat basename bigloobformat module init __bformat module eval __make_lib class init bigloo bformat __bformat class eval bigloo bformat make lib define expander BFORMAT lambda x e match case x lambda s and string s not string index s a string append cdr x else bformat map lambda x e x e cdr x At compile time the macro BFORMAT will be declared Hence we can change the definition of foo scm for module foo library bformat bigloo library path set cons pwd
300. n type clause These newly introduced types can be used in any declaration that is in any extern or Scheme module clause and in any Scheme variable or function definition The syntax of type clause is lt type clause gt type ident lt type def gt lt string gt lt type def gt gt lt atomic type gt lt ident gt lt struct type gt lt union type gt lt function type gt lt array type gt lt pointer type gt lt enum type gt lt opaque type gt The symbol lt ident gt is the Scheme name of the introduced type and lt string gt is the C name of the type When Bigloo produces the definition of a variable v of type s it produces the following C code s v This rules applies unless s is a pointer or an array and then to produce a C definition the name of the elements of the array or the elements pointed by the pointer type are used Hence if v is for instance foo and s is array int the produced C code will be int foo 26 1 6 1 Atomic types The atomic types are the pre existing ones defined in the standard Bigloo s library lt atomic type gt gt lt bigloo type gt lt c type gt lt bigloo type gt gt obj procedure pair nil pair nil bint blong belong bllong bignum real bbool cnst bstring ucs2string bchar bucs2 vector tvector struct tstruct output port input port binary port unspecified symbol keyword 236 Bigloo 4 2b cel
301. n here is the code of the server module server let s make server socket 8080 s2 socket accept s inbuf f let pin socket input s2 let loop O display read char pin flush output port current output port loop At to conclude here the source code for a server waiting for multiple consecutive con nections define main argv let m if pair cdr argv string gt integer cadr argv 10 s make server socket print s s let loop i 0 if fx i n let s2 socket accept s print i i s2 print read line socket input s2 socket close s2 loop fx i 1 socket shutdown s Bigloo also provides primitives dealing with datagram sockets for use with transports such as UDP These are shown below make datagram server socket port bigloo procedure Return a datagram server socket bound to the loopback address on port and whose address family and protocol family are those normally used for services on port make datagram unbound socket domain inet bigloo procedure Return an unbound datagram socket It may then be used in conjunction with datagram socket send and datagram socket receive for instance send to and receive from a UDP multicast address datagram socket receive sock size bigloo procedure Receive up to size bytes from datagram socket sock and return them as a string Chapter 5 Standard Library 89 datagram socket send sock message h
302. n obj bigloo procedure Re open the input port obj That is re start reading from the first character of the input port current input port procedure current output port procedure current error port bigloo procedure with input from file string thunk optional procedure with input from string string thunk optional procedure with input from procedure procedure thunk optional procedure with output to file string thunk optional procedure with append to file string thunk optional procedure with error to file string thunk bigloo procedure with output to string thunk bigloo procedure with output to procedure procedure thunk bigloo procedure with error to string thunk bigloo procedure with error to procedure procedure thunk bigloo procedure A port is opened from file string This port is made the current input port resp the current output port or the current error port and thunk is called See Section r5rs info in R5RS for more details with input from file etc passwd lambda let loop line read line current input port if not eof object line begin print line loop read line current input port with input from port port thunk bigloo procedure with output to port port thunk bigloo procedure with error to port port thunk bigloo procedure with input from port with output to port and with error to port all sup pose port to be a legal port They call thunk making port the current i
303. n a program is compiled with g and when at runtime the shell variable BIGLOOSTACKDEPTH is set and contains a number an execution stack of depth BIGLOOSTACKDEPTH is printed when an error is raised error location proc msg obj file location bigloo procedure This form signals an error by calling the current error handler with proc msg and obj as arguments The error is prompted in file at character position location define foo 1 if not pair 1 error location foo argument not a pair 1 foo scm 115 car 1 foo 4 File foo scm line 4 character 115 car 1 ERROR bigloo foo argument not a pair 4 0 FOO 1 DYNAMIC WIND 2 INTERP 3 ENGINE 4 MAIN get trace stack size bigloo procedure dump trace stack output port size bigloo procedure Switching on the g compilation switch enables stack dumping Chapter 31 Compiler Description page 271 That is the list of the pending calls can be dumped by the 172 Bigloo 4 2b runtime system The function get trace stack builds such a trace The list built by get trace stack only contains the size top most pending calls The function dump trace stack displays a representation of this stack on the output port warning location file location arg bigloo procedure This form signals a warning That is is arg are displayed on the standard error port The warning is prompted in file at character position location define foo 1 if no
304. n be used to wait for a Posix Thread termination The pthread object must be started with thread start joinable thread suspend thread Bigloo function thread resume thread Bigloo function Suspends resumes the thread at the end of reaction While suspended a thread is not eligible to get the processor by the scheduler thread await signal timeout Bigloo function Blocks the thread until signal has been broadcast or until timeout has elapsed The function thread await returns the value associated with the previous emissions of the signal that took place during the reaction let t1 thread start instantiate fthread body lambda display thread await foo display thread await bar t2 thread start instantiate fthread body lambda broadcast foo vali foo broadcast foo val2 foo t3 thread start instantiate fthread body lambda thread sleep 2 broadcast bar val bar let loop n 1 display n scheduler react default scheduler loop n 1 4 i1val2 foo23val bar456 186 Bigloo 4 2b The function thread await cannot be used to intercept all the signals broadcast during a reaction This is illustrated by the following example where obviously thread await cannot intercept the emission of the signal thread start instantiate fthread body lambda thread await foo broadcast foo 1 thread start instantiate fthread b
305. n described by kmp table in the memory mapped area mmap respec in the string The search starts at offset If an occurrence is found its position in the mmap is returned Otherwise 1 is returned For the sake of the example here is a prototypal implementation of the Usenix com mand grep define main args cond nul1 cdr args fprintf current error port Usage grep STRING FILE exit 0 else let t kmp table cadr args for each lambda f grep file t f cddr args define grep file t file let mm open mmap file read t write f 1s mmap length mm let loop o 0 unless gt fx o 1s let n kmp mmap t mm o when gt fx n 0 print file mmap line mm ls n loop fx n 1 close mmap mm define mmap line mm ls n let b 0 e elong gt fixnum 1s beginning let loop i n when fx i 0 if char mmap ref mm i Newline set b fx i 1 loop fx i 1 end let loop i n when fx i 1s if char mmap ref mm i Newline set e i loop fx i 1 mmap substring mm b e b Chapter 8 Structures and Records 109 8 Structures and Records Bigloo supports two kinds of enumerated types the structures and the records They offer similar facilities Structures were pre existing to records and they are maintained mainly for backward compatiblity Recors are compliant with the Scheme request for implementation
306. n input port able to deliver characters from procedure Each time a char acter has to be read the procedure is called This procedure may returns a string of characters or the boolean f This last value stands for the end of file Example let p open input procedure let s t lambda if s begin set s f foobar s read unread char char input port bigloo procedure unread string string input port bigloo procedure unread substring string start end input port bigloo procedure Pushes the given char string or substring into the input port The next read char acter s will be the pushed ones The input port must be buffered and not be closed Example define p open input string a ymbol c read p gt a read char p gt space unread char s p read p gt symbol read char p gt space read p gt c char ready p gt f unread string syml sym2 p char ready p gt t read p gt syml read p gt sym2 open output file file name procedure The same syntax as open input file for file names applies here When a file name starts with Bigloo opens an output pipe instead of a regular file append output file file name bigloo procedure If file name exists this function returns an output port on it without removing it New output will be appended to file name If file name does not exist it is created open output string bigloo procedure
307. n of the tool bar using the popup menu entry or using the C c C r C r binding Parts or the whole buffer may be sent to repl e C c C r b sends the whole buffer Chapter 34 Bigloo Development Environment 301 e C c C r d sends the define form the cursor is in e C c C r 1 sends the s expression that preceeds the cursor e C c C r t sends the top level s expression the cursor is in e C c C r r sends the marked region 34 7 Pretty Printing The whole buffer may be pretty printed long source lines are split using the Lisp icon of the tool bar using the popup menu entry of using C c C i tab Parts or the buffer may be indented no line is split e C c C i d indents the define form the cursor is in e C c C i 1 indents the s expression that preceeds the cursor e C c C i t indents the top level s expression the cursor is in 34 8 Expansing For debug purposes result of the source code macro expansion may be checked within the BEE Parts or the whole buffer may be sent to repl e C c C e C e expands the whole buffer e C c C e C d expands the define form the cursor is in e C c C e C 1 expands the s expression that preceeds the cursor e C c C e C t expands the top level s expression the cursor is in e C c C e C r expands the marked region When a part of the buffer is expanded by opposition to the whole buffer the buffer is scan for macro definitions These macros will be used for expanding the requested form 34 9 On
308. n the export clause In that case the type annotation need to be written in the function definition module foo export succ int int define succ x 1 x Chapter 26 The C interface 233 26 The C interface We call all the pieces of program devoted to the interactions between Scheme and another language a foreign interface In Bigloo the foreign interface allows Scheme s functions and variables to be exported to a foreign language and foreign functions and variables to be imported into the Scheme code Using the foreign interface requires two kind of operations e Declarations type declarations import declarations or export declarations e Foreign reference in the Scheme code Declarations take place in a special module clause see Section 2 2 Module Declaration page 7 and reference to foreign variables within Scheme code requires no special construc tion The current release of Bigloo includes a C and a Java interface The Java connection is specified by the means of a java clause see Chapter 27 Java Interface page 245 The C interface is active that is the extern module clauses are read only when compiling to C So when compiling to Jvm the binding declared in an extern clause are not bound Connecting Bigloo code with C is generally straightforward To illustrate this simplicity let us consider a simple example involving two source files First a simple C file sum c containing a single declaration in
309. ncase s ucs2 bigloo procedure Physically downcases the s ucs2 argument ucs2 string upcase s ucs2 bigloo procedure Physically upcases the s ucs2 argument ucs2 string gt utf8 string s ucs2 bigloo procedure utf8 string gt ucs2 string string bigloo procedure Convert UCS 2 strings to or from UTF 8 encoded ascii strings utf8 string string strict tf bigloo procedure Returns t if and only if the argument string is a well formed UTF 8 string Otherwise returns f If the optional argument strict is t half utf16 surrogates are rejected The optional argument strict defaults to f ascii string string bigloo procedure Returns t if and only if the argument string is only composed of ascii characters Otherwise returns f utf8 string encode string strict f bigloo procedure Returns a copy of string where all the illegal UTF 8 prefix are replaced with the Unicode Replacement Character EF BF BD The result is well formed UTF 8 string utf8 string length string bigloo procedure Returns the number of characters of an UTF 8 string It raises an error if the string is not a well formed UTF 8 string i e it does satisfies the utf8 string predicate utf8 codepoint length string bigloo procedure Returns the number of code points of an UTF 8 string The code points length is the number of 16bits long values needed to encode the utf8 strings in utf16 utf8 string ref string i bigloo procedure Returns the character
310. nclosed within the brackets Thus p aeiou t matches pat pet pit pot put and nothing else Inside the brackets a hyphen between two characters specifies the ascii range between the characters Eg ta b dgn p matches tab tac tad and tag and tan tao tap An initial caret after the left bracket inverts the set specified by the rest of the contents ie it specifies the set of characters other than those identified in the brackets Eg do g matches all three character sequences starting with do except dog z Requiring a bracketed character class to be non empty is not a limitation since an empty character class can be more easily represented by an empty string Chapter 12 Posix Regular Expressions 143 Note that the metacharacter inside brackets means something quite different from what it means outside Most other metacharacters etc cease to be metachar acters when inside brackets although you may still escape them for peace of mind isa metacharacter only when it s inside brackets and neither the first nor the last character Bracketed character classes cannot contain other bracketed character classes although they contain certain other types of character classes see below Thus a left bracket inside a bracketed character class doesn t have to be a metacharacter it can stand for itself Eg a b matches a and b Furthermore since empty bracketed character classes are disallow
311. nd i left my grey socks at the greyhound gt 28 32 The regexp grey hound matches grey but only if it is followed by hound Thus the first grey in the text string is not matched Negative lookahead peeks ahead to ensure that its subpattern could not possibly match pregexp match positions grey hound the gray greyhound ate the grey socks gt 27 31 The regexp grey hound matches grey but only if it is not followed by hound Thus the grey just before socks is matched 12 2 17 Lookbehind Positive lookbehind lt checks that its subpattern could match immediately to the left of the current position in the text string pregexp match positions lt grey hound the hound in the picture is not a greyhound gt 38 43 The regexp lt grey hound matches hound but only if it is preceded by grey Negative lookbehind checks that its subpattern could not possibly match immedi ately to the left pregexp match positions lt grey hound the greyhound in the picture is not a hound gt 38 43 The regexp lt grey hound matches hound but only if it is not preceded by grey Lookaheads and lookbehinds can be convenient when they are not confusing 12 3 An Extended Example Here s an extended example from Friedl that covers many of the features described above The problem is to fashion a regexp that will match any and only IP addresses or dotted quads ie four n
312. nd input string functions input char binary port bigloo procedure output char binary port char bigloo procedure output byte binary port byte bigloo procedure The function input char reads a single character from a binary port lt returns the read character or the end of file object The function output char and output byte writes a character respectively a byte into a binary port input string binary port len bigloo procedure output string binary port bigloo procedure The function input string reads a string from a binary port of maximum length len It returns a newly allocated string whose length is possibly smaller than len The function output string writes a string into a binary port input fill string binary port string bigloo procedure Fills a string with characters read from binary port with at most the length of string The function returns the number of filled characters register procedure serialization serializer unserializer bigloo procedure register custom serialization ident serializer unserializer bigloo procedure register process serialization serializer unserializer bigloo procedure register opaque serialization serializer unserializer bigloo procedure There is no existing portable method to dump and restore a procedure Thus if obj gt string is passed a procedure it will emit an error message Sometime using strict restrictions it may be convenient to use an ad hoc framework to serialize and
313. necessary parent directories delete directory string bigloo procedure Deletes the directory named string The directory must be empty in order to be deleted The result of this procedure is unspecified directory gt list string bigloo procedure directory gt path list string bigloo procedure If file string exists and is a directory the function directory gt list returns the list of files in string The function directory gt path list returns a list of files whose dirname is string file modification time string bigloo procedure file access time s ring bigloo procedure file times set string atime mtime bigloo procedure The date in second of the last modification respec access for file string The number of seconds is represented by a value that may be converted into a date by the means of seconds date see Section 5 8 Date page 93 file size string bigloo procedure Returns the size in bytes for file string The return type is long If an full sized integer is needed one may write Chapter 5 Standard Library 81 let sz llong file size lt PATH gt eS On error 1 is returned file uid string bigloo procedure file gid string bigloo procedure The functions return the user id an integer and group id an integer for file string On error 1 is returned file mode string bigloo procedure Returns the file access mode an integer On error 1 is returned file type string biglo
314. ned by file size write obj output port library procedure display obj output port library procedure print obj bigloo procedure This procedure allows several objects to be displayed When all these objects have been printed print adds a newline display obj bigloo procedure This function is similar to print but does not add a newline fprint output port obj bigloo procedure This function is the same as print except that a port is provided write char char output port procedure write byte byte output port procedure These procedures write a char respec a byte i e in integer in the range 0 255 to the output port newline output port procedure flush output port output port bigloo procedure This procedure flushes the output port output port This function does not reset characters accumulated in string port For this uses reset output port newline output port procedure reset output port output port bigloo procedure This function is equivalent to flush output port but in addition for string ports it reset the internal buffer that accumulates the displayed characters format format string objs bigloo procedure Note Many thanks to Scott G Miller who is the author of SRFI 28 Most of the documentation of this function is copied from the SRFI documentation Accepts a message template a Scheme String and processes it replacing any escape sequences in order with one or more
315. ng abcdefghijlkmnops lambda read fill string s 3 5 s abcde port gt string list input port bigloo procedure Returns a list of strings composed of the elements of input port port gt list input port reader bigloo procedure port gt sexp list input port bigloo procedure Port gt list applies reader to port repeatedly until it returns EOF then returns a list of results Port gt list sexp is equivalent to port gt list read port Chapter 5 Standard Library 63 file gt string path bigloo procedure This function builds a new string out of all the characters of the file path If the file cannot be open or read an IO EXCEPTION is raised send chars input port output port len offset bigloo procedure send file filename output port len offset bigloo procedure Transfer the characters from input port to output port This procedure is sometimes mapped to a system call such as sendfile under Linux and might thus be more efficient than copying the ports by hand The optional argument offset specifies an offset from which characters of input port are sent The function send chars returns the number of characters sent The function send file opens the file filename in order to get its input port On some backends send file might be more efficient than send chars because it may avoid creating a full fledged Bigloo input port Note that the type of len and offset is elong i e exact long which is also retur
316. ng a special compilation mode mkaddheap mkaddlib addheap heap library ident That is for your library you have to create a heap associated source file that imports all the binding you want in your library The heap source file must be excluded from the source files that will be used to build the host library 256 Bigloo 4 2b Suppose we have a unique source file bformat scm for our library The module clause of this source file is module __bformat export bformat fmt bstring args bformat version define bformat fmt args apply format string replace fmt args define bformat version 1 0 Prior to compiling the library we have to create the heap associated file let s name it make lib scm This file could be module __make_lib import __bformat bformat scm eval export all Building it is simple bigloo unsafe safee q mkaddheap mkaddlib heap library bformat make_lib scm addheap bformat heap The options mkaddheap and mkaddlib tell Bigloo that it is compiling an heap asso ciated file The option addheap tells Bigloo the name of the heap file to be produced The option heap library instructs the compiler for the library name to be included inside the heap file This name is used for checking versions at run time The second step is to compile all the library source file These compilation must be done using the mkaddlib compilation mode For example bigloo O3 unsafe
317. nis 153 15 Errors Assertions and Traces ios lo ce Reg 171 167 TFHEIBAdSs3 1p 4M CAS ae SS Mel Aes Ks pa UU eH eS 179 END Jg ELE 197 18 Multimedia A a a he eae 201 A NN 209 A dd Dhaai ha aer E ALIOS dena AU aste Papius 217 dlc AS O IA EA AA obo eps 219 22 Eval and code Interpretation cipal ee oA ees 221 23 Macro expansi A O E tie ey A Toda d 227 24 P rameters dad A A 229 25 Exphcl iy ple ptr ee 231 26 The Ginter late eaae o e eE E a e E PRU DEOR UNES 233 21 The Tara imberlace ses 2486 Ka eta t E oe or iw eee EROS 245 28 Bigloo libranes 2cceatess teat veel sunnere caetex Ae 25 29 Extending the Runtime Systelnu vas cesses ove aden ee 263 OU SREIS 3 dus tua ur x a er Cp Eoi Y Pau d 265 31 Gompilerdescriptiocoxborsrr das rise dancer 271 32 Cr ss Compilation 224095 AAA Pee 293 xX go gt User Extensions 4 scu ik Ca A A 297 34 Bigloo Development Environment 2 4 299 35 Global lnderiercara tensa les RE inq AXES RIS QURE 305 36 Library Indexes weve Agee oe wp Wed de ER ERAS 323 Bibliography A mt ehe b tet oe tuf 325 af Table OF CODO Seis Nux ore docere ca ose Oe eh 327 Bigloo 4 2b
318. nit proc bigloo procedure Returns an n element list Element i of the list where 0 lt i lt n is produced by init proc i No guarantee is made about the dynamic order in which init proc is applied to these indices list tabulate 4 values gt 0 1 2 3 list split list n filler bigloo procedure list split list n filler bigloo procedure Split a list into a list of lists of length n Last smaller list is filled with filler list split 1 234567 8 30 gt 1 2 3 4 5 6 7 8 0 list split iota 10 3 gt 0 1 2 345 6 7 8 9 list split iota 10 3 1 gt 012 345 6 7 8 9 1 1 30 Bigloo 4 2b iota count start step bigloo procedure Returns a list containing the elements start start step start count 1 step The start and step parameters default to 0 and 1 respectively This procedure takes its name from the APL primitive iota 5 01234 iota 5 O 0 1 0 0 1 0 2 0 3 0 4 list copy bigloo procedure tree copy bigloo procedure The function list copy copies the spine of the of the list The function tree copy recursively copies its arguments descending only into the list cells delete duplicates list eq equal bigloo procedure delete duplicates list eq equal bigloo procedure delete duplicates removes duplicate elements from the list argument If there are multiple equal elements in the argument list the result list only contains the first or
319. nize ensures that however the form returns the mutex mutex is always unlocked synchronize mutex print before read read p with lock mutex thunk Bigloo function deprecated The form with lock is similar to synchronize into which it is expanded The function with lock evaluates the body of the thunk The mutex mutex is acquired and released before thunk gets invoked The function with lock might be implemented as define with lock mutex thunk synchronize mutex thunk 16 1 3 Condition Variables condition variable obj SRFI 18 function 182 Bigloo 4 2b make condition variable name SRFI 18 function condition variable name cv SRFI 18 function condition variable specific cv SRFI 18 function condition variable specific set cv obj SRFI 18 function condition variable wait cv mutex timeout Bigloo function condition variable signal cv SRFI 18 function condition variable broadcast cv SRFI 18 function let res 0 define make semaphore n vector n make mutex make condition variable define semaphore wait sema mutex lock vector ref sema 1 let n vector ref sema 0 if gt n 0 begin vector set sema 0 n 1 mutex unlock vector ref sema 1 begin condition variable wait vector ref sema 2 vector ref sema 1 mutex unlock vector ref sema 1 semaphore wait sema define semaphore signal by sema increment mutex lock vector ref sema 1 let n vec
320. nmap get char i4i12 21 lS cg eli 1 i As ela 66 mmap get String ipdn pu iiA ren h EUDE ai 66 nmap length ntc adas bn 66 mmap put char ici adas a eh ee 66 nap put string eu i ean bros 66 mmap read position eee 66 mmap read position set 0 66 nmap e a teehee tye a ben 66 MAPS eG Gueidan oi A sa arses 66 mmap substrings enlace iad Rei e eu 66 mmap substring set 0 cece eens 66 mmap write position 00 e eee eee 66 mmap write position set 66 MAD A chiro M C 65 module ee ah Pitt era eet sh men etse mt 7 module access file 00 0002 eee ee eee 16 Module body language 004 25 module Clas Sii ds aria wet ns ow tet 12 module declaration 0 000008 7 module export all ooccccoccccccccccccccroo 12 module export exports eese 12 module export module o o o ooooocooooooo o 12 modules 52 91h er a NS ME RARUS T Modules and DSSSL formal argument lists 24 modulo s ecce miratur o cern ete 35 month aname i ilrioe e efe ve SE SUpRUEE 95 MONTH hame ii v e locit 95 np3 musictag i ena we eee vr RN QW pia 202 MPE MUST piu GUI 205 MPa aa 208 mpd database osease trii ud ev c RR PIS 208 mpgi23 musicproc n ieem eee eee 205 mplayer muSiCPYOC 6 eee eee 205 Multi line comments 00005 17 multimedia tooo 201 multiple value bind sssssss 53 314 M SICA
321. nput resp output or error port None of these functions close port on the continuation of thunk with output to port current error port lambda display hello 56 Bigloo 4 2b open input file file name buffer f timeout 5000000 procedure If file name is a regular file name open input file behaves as the function defined in the Scheme report If file name starts with special prefixes it behaves differently Here are the recognized prefixes e astring made of the characters and space Instead of opening a regular file Bigloo opens an input pipe The same syntax is used for output file define pin open input file cat etc passwd define pout open output file wc 1 display read pin pout close input port pin newline pout close output port pout e pipe Same as e file Opens a regular file e gzip Opens a port on a gzipped filed This is equivalent to open input gzip file Example with input from file gzip bigloo tar gz lambda send chars current input port current output port e string Opens a port on a string This is equivalent to open input string Example with input from file string foo bar Gee lambda print read print read print read 4 foo bar Gee e http server path Opens an http connection on server and open an input file on file path e http server port number path e http user passwordOserver port number path O
322. nsingesec 6 sui as 301 expansion passing style 00 227 expfl 185 00 vate eek Hy ett ek eles 36 explicit typinge ic asia itee ae 231 exported es e ne tS lea e 9 exporting a Scheme variable 235 Exporting Scheme variables to Java 249 Expressions te ule ehh dats bas 17 CORPO eles fe se Ratna de tee Me 36 AAA ieee le ted le oes 36 Externe cndukeiltt A mise EE E anes 12 extract private rsa key 0 158 extract public dsa key 161 extract public elgamal key 162 extract public rsa key sss 158 F Fair Threads eve wn 182 194 fast string search cit lid 107 Me handle bee ese RIS 77 A oe pedet reg oe dy tse 63 file access time cece cece eee 80 file existS iia ot Ai ri ethos 79 2C A I 81 flle EZID o oup cae E EAE MN RS 79 LILLE MOE mat AAA 81 file modification time 80 file musictag oooococococccconcoronnnr o 202 file name gt list ccc ccc cee ees 78 file name canonicalize 78 file name canonicalize 78 file name unix canonicalize 78 file name unix canonicalize 78 file separator o INNO sy uy pne ER 76 Bigloo 4 2b RON 80 file times set mota ts 80 flle tyDe e dares xs 81 PPV OH WA Ae tM orn sed T enenete d RN EUER e eren 81 PITS oak eh eee ake Ree AREA DUM YA E 50 tiles RUE 50 A Lele hieu 5
323. nt inport p flush output port inport let loop line read line port if eof object line close input port port begin print line loop read line port 4 20 Note The call to flush output port is mandatory in order to get the dc process to get its input characters Note Thanks to Todd Dukes for the example and the suggestion of including it this documentation process obj bigloo procedure Returns t if obj is a process otherwise returns f process alive process bigloo procedure Returns stt if process is currently running otherwise returns sf close process ports command arg bigloo procedure Close the three ports associated with a process In general the ports should not be closed before the process is terminated process pid process bigloo procedure Returns an integer value which represents the Unix identification PID of the process process input port process bigloo procedure process output port process bigloo procedure process error port process bigloo procedure Return the file port associated to the standard input output and error of process otherwise returns 4f Note that the returned port is opened for reading when calling process output port or process error port It is opened for writing when calling process input port process wait process bigloo procedure This function stops the current process until process completion This function re turns 4f when process is already t
324. nterpreter entity Modules have been first designed for the compiler that compiles modules and then links them against libraries in order to produce executables A module may be split into several files but a file cannot contain more than one module A module is made of a module clause that is a list for which the car is the symbol module and followed by any Bigloo expression that is definitions or expressions The module clause names the module and defines the scope of the definitions At last the module clause is also the place where foreign bindings are defined and where classes are defined Recent versions of Bigloo since 2 7b fully supports modules from the interpreter 2 1 Program Structure A Bigloo program is composed of one or more Bigloo modules where a module is defined by the following grammar lt module gt lt module declaration gt lt module body gt lt module declaration gt the module declaration lt module body gt the module body A module is not related to a specific file and can be spread over several files if that is convenient In particular there is no relationship between module names and file names The module declaration see Section 2 2 Module Declaration page 7 must be the first expression in the first of the files containing the module other expressions form the body of the module The module body see Chapter 3 Core Language page 17 contains global variables function definitions and top lev
325. ntinuation to enter or exit the dynamic extent of a call to before or after is undefined let path O c f let add lambda s set path cons s path dynamic wind lambda add connect lambda add call cc lambda cO set c cO talk1 lambda add disconnect if length path 4 c talk2 reverse path gt connect talki disconnect connect talk2 disconnect unspecified bigloo procedure Returns the unspecified noted as tunspecified object with no specific property try exp handler bigloo syntax This form is documented in Section Chapter 15 Errors Assertions and Traces page 171 values obj procedure Delivers all of its arguments to its continuation Except for continuations created by the call with values procedure all continuations take exactly one value Values might be defined as follows define values things call cc lambda cont apply cont things Chapter 5 Standard Library 53 call with values producer consumer procedure Calls its producer argument with no values and a continuation that when passed some values calls the consumer procedure with those values as arguments The continua tion for the call to consumer is the continuation of the call to call with values call with values lambda values 4 5 lambda a b b gt 5 call with values gt 1 multiple value bind var producer exp bigloo syntax re
326. o 64 Ox1b ecma 182 64 0x42f0eleba9ea3693 crc names bigloo procedure Returns a list of all provided CRCs itu 4 epc 5 etc crc polynomial name bigloo procedure crc polynomial le name bigloo procedure Returns the polynomial for the given name The 1e variant returns the little endian polynomial crc polynomial ieee 32 4 e79764439 ttex4c11bd7 crc polynomial 24 4 6122955 33 x5d6dcb crc length name Returns the length of the specified CRC crc name obj init 0 final xor 0 big endian zt crc string name str bstring init 0 final xor 0 big endian zt crc port name p input port init 0 final xor 0 big endian t crc mmap name m mmap init 0 final xor 0 big endian t crc file name f bstring init 0 final xor 0 big endian At bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure Computes the CRC of the given object name must be one of the provided CRC algorithms The optional parameter init can be used to initialize the CRC The result of the CRC will be XORed with final xor The result will however be of the CRC s length That is even if final xor is bigger then the CRC s length only the relevant bits will be used to perform the final XOR The result will be a number Depending on the CRC this number can be a fixnum an elong or an llong The following example mimicks the UNIX cksum comm
327. o procedure Returns the file type a symbol The possible returned values are e regular e directory e link e block e fifo e character e socket e resource e unknown e does not exist chmod string option bigloo procedure Change the access mode of the file named string The option must be either a list of the following symbols read write and execute or an integer If the operation succeeds chmod returns t It returns f otherwise The argument option can also be an integer that represents the native file permission Example chmod make file name getenv HOME bigloorc read write chmod make file name getenv HOME bigloorc ito777 5 7 3 Process support Bigloo provides access to Unix like processes as first class objects The implementation and this documentation are to a great extent copies of the STk Gallesio95 process support Basically a process contains four informations the standard Unix process identification aka PID and the three standard files of the process run process command arg bigloo procedure run process creates a new process and run the executable specified in command The arg correspond to the command line arguments When is process completes its execution non pipe associated ports are automatically closed Pipe associated ports have to be explicitly closed by the program The following values of p have a special meaning 82 Bigloo 4 2b input permits to redirect the
328. o store dynamic command line options default extend entry Extend entry default f csarbage collector The garbage collector default boehm gc custom Are we using a custom GC library default t gc lib The Gc library default bigloogc global tail call Do we apply the self global tail call stage default f heap base name The Bigloo heap base name default bigloo heap dump names The name of the heap to be dumped default heap jvm name The Bigloo heap file name for the JVM backend default bigloo jheap heap library The library the heap belongs to default bigloo heap name The Bigloo heap file name default bigloo heap hello Say hello when verbose default f include foreign The C included files default bigloo h include multiple Enable disable multiple inclusion of same file default f indent The name of the C beautifier Chapter 31 Compiler description 285 default indent npro bap bad nbc bl ncdb nce nfcl ip0 nlp npcs nsc nsob cli0 5 di0 180 d1 c0 ts2 st init mode Module initialization mode default read inlining kfactor Inlining growth factor default lt procedure 40f910 1 gt inlining reduce kfactor Inlinine growth factor reductor default lt procedure 40f860 1 gt inlining Inlining optimization default t interpreter Shall we interprete the source file d
329. obj according to proc test The argument obj can either be a vector or a list In either case a copy of the argument is returned For instance let 1 foo 5 bar 6 hux 1 gee 4 sort lambda x y string lt car x car y 1 gt bar 6 foo 5 gee 4 hux 1 The second form which uses obj before proc ensures backward compatibility with old Lisp systems and older Bigloo versions It is deprecated force promise library procedure call cc proc bigloo procedure This function is the same as the call with current continuation function of the R5RS see Section r5rs info in R5RS but it is necessary to compile the module with the call cc option to use it see Section See Chapter 31 The Bigloo command line page 271 Note Since call cc is difficult to compile efficiently one might consider using bind exit instead For this reason we decided to enable call cc only with a com piler option Chapter 5 Standard Library 51 bind exit escape body bigloo syntax This form provides an escape operator facility bind exit evaluates the body which may refer to the variable escape which will denote an escape function of one argu ment when called this escape function will return from the bind exit form with the given argument as the value of the bind exit form The escape can only be used while in the dynamic extent of the form Bindings introduced by bind exit are immutable bind exit exit for e
330. od named m of a class k the Scheme name of the method is k m Example module java example java class point constructor new default field x int x 248 Bigloo 4 2b method show void point show method static statistics int PointStatistics Point class point 3d point Point3D let p point new default print point p d t point x set p 3 print point x p 4 3 27 4 3 Declaring abstract Java classes A Bigloo abstract Java class declaration corresponds to a Java interface It cannot be instantiate but regular classes may inherit from it lt declare abstract class clause gt gt abstract class lt typed ident gt lt slot gt lt string gt 27 4 4 Extending Java classes A class definition may be split into several pieces One class declaration see lt declare class clause gt and several extensions The syntax for a Java class extension is lt extend class clause gt gt class lt typed ident gt lt slot gt x Example module java example2 import java example java class point field y int y field static num int point num constructor new int int 27 4 5 Declaring Java arrays Java arrays may be allocated and used inside Scheme code The syntax of a Java array module clause is lt array clause gt gt array ident lt typed ident gt The lt typed ident gt must refer to the name of an existing type i e a primitive
331. ody lambda broadcast foo 2 thread get values signal Bigloo function Terminates the instant for the thread as thread yield and returns hence at the next instant all the values associated with broadcast signal see Section Section 16 2 2 3 Signal page 190 during the previous scheduler reaction see Section Section 16 2 2 2 Scheduler page 189 Example thread start instantiate fthread body lambda O for each print thread get values foo thread start instantiate fthread body lambda broadcast foo 1 broadcast foo foo broadcast foo blabla Jj 1 foo blabla Example let t1 thread start instantiate fthread body lambda O for each print thread get values foo name t1 t2 thread start instantiate fthread body lambda O broadcast foo current thread thread yield this second broadcast won t be intercepted because it occurs during the next reaction broadcast foo current thread name t2 t3 thread start instantiate fthread body lambda O broadcast foo current thread broadcast foo current thread name t3 scheduler start 4 lt thread t2 gt lt thread t3 gt lt thread t3 gt Chapter 16 Threads 187 thread await values signal timeout Bigloo function This blocks the current thread until signal has been broadcast It then returns at the next instant all the values a
332. of object object hashnumber object bigloo generic This generic function returns an hash number of object is a obj class bigloo procedure Returns t if obj belongs to class otherwise it returns f 9 6 Object serialization Objects can be serialized and un serialized using the regular string gt obj and obj gt string functions Objects can be stored on disk and restored from disk by the use of the output obj and input obj functions In addition to this standard serialization mechanism custom object serializers and un serializers can be specified by the means of the register class serialization function see Section Section 5 3 Serialization page 68 9 7 Equality Two objects can be compared with the equal function Two object are equal if and only if they belong to a same class all their field values are equal and all their super class s field values are equal 122 Bigloo 4 2b 9 8 Introspection Bigloo provides the programmer with some object introspection facilities See section see Section 9 5 Object library page 120 for information on classes and objects handling Introspection facilities are by default available for all classes However in order to shrink the code size generation it may be useful to disable class introspection This decision can be taken on a per class basis i e one class may be provided with introspection facilities while another one is not The compiler option fno reflection see Chapte
333. of length 128 or 192 bits but only 112 168 of these bits are actually used Bigloo s implementation therefore accepts the smaller keys too Bigloo s DES3 implementation has been changed with release 3 4b Earlier ver sions did not use the full key for en decryption e des np Same as des but the initial and final permutations are not performed e des3 np Same as des3 but the initial and final permutations are not performed e aes Advanced Encryption Standard AES AES works on blocks of 128 bits AES requires keys of length 128 192 or 256 bits e cast 128 CAST 128 CAST5 CAST 128 works on blocks of 64 bits CAST 128 requires a key length of 40 128 bits e idea International Data Encryption Algorithm IDEA IDEA works on blocks of 64 bits It requires keys of length 128 in bits IDEA is patented in many countries including the USA and most European countries but it is free for non commercial use The given password must be a string An optional parameter string gt key should transform this password so that it has the correct length for the cipher A small list of possible functions are provided in the Section 14 1 1 String to Key page 157 section By default string gt key hash with SHA 1 will be used The key length will depend on the chosen cipher e des 56 bits e des3 112 bits e des np Same as des e des3 np Same as des3 e aes 192 bits Chapter 14 Cryptography 155 e cast 128 128 bits e idea
334. ok gt The TeXbook This regexp will allow any casing for the and book but insists that TeX not be differently cased 12 2 12 Alternation You can specify a list of alternate subpatterns by separating them by The separates subpatterns in the nearest enclosing cluster or in the entire pattern string if there are no enclosing parens pregexp match f eelilolum a small final fee gt fi 4310 pregexp replace yil s e sdr linglation it is energising to analyse an organisation pulsing with noisy organisms 1z 2 it is energizing to analyze an organization pulsing with noisy organisms Note again that if you wish to use clustering merely to specify a list of alternate subpat terns but do not want the submatch use instead of pregexp match f eelilolum fun for all gt fo An important thing to note about alternation is that the leftmost matching alternate is picked regardless of its length Thus if one of the alternates is a prefix of a later alternate the latter may not have a chance to match pregexp match call call with current continuation call with current continuation gt call 148 Bigloo 4 2b To allow the longer alternate to have a shot at matching place it before the shorter one pregexp match call with current continuation call call with current continuation gt call with current continuation In any case an overall match for the entire regexp
335. omments These are introduced with the 4 syntax The FACT procedure computes the factorial of a non negative integer define fact lambda n if n 2 1 n fact n 1 if n 0 1 n fact n 1 3 1 2 Expressions Bigloo expressions are the same as in Section r5rs info in R5RS Bigloo has more syntactic keywords than Scheme The Bigloo syntactic keywords are gt do or and else quasiquote begin if quote case lambda set 18 cond unquote splicing delay labels unwind protect regular grammar define expander match lambda assert instantiate widen let syntax cond expand define record type let define letrec try bind exit lalr grammar define macro pragma define generic duplicate shrink letrec syntax receive and let Bigloo 4 2b unquote let module define struct define inline regular search match case failure define method with access multiple value bind define syntax args parse letrec All other non atomic Bigloo forms are evaluated as function calls or macro class variable quote datum gt datum constant define x 28 x quote a quote a b c quote 1 2 a a b c O 1 2 quote a y abc abc 2145932 145932 Ht tt operator operand 3 4 Cif 4f 3 4 lambda x 1 x 5 lambda formals body lambda x x x lambda x x x 4 A REL yy define reve
336. on If accepted certs is a list the peer client certificate must match one of the given certificates Otherwise an amp io error will be raised when accepting the client socket If the connection cannot be established an amp io error is raised see Chapter 15 Errors Assertions and Traces page 171 The function make ssl server socket is defined in the SSL library A module that needs this facility must then use a library clause see Chapter 2 Modules page 7 The SSL library can also be loaded from the interpreter using the library load function see Chapter 28 Bigloo Libraries page 251 module secure echo library ss1 Chapter 5 Standard Library 93 let cert read certificate etc ssl my cert crt pkey read private key etc ssl my key pkey cas read pem file etc ssl ca cert s make ssl server socket 1055 CAs cas cert cert pkey pkey cs socket accept s ip socket input cs op socket output cs let loop e read ip when not eof object e write e op loop read ip socket close s 5 7 5 2 Certificates read certificate file SSL library procedure Reads an X509 certificate stored in PEM format in the given file name If the file cannot be read it raises an amp io error condition Otherwise the certificate is returned read pem file file SSL library procedure Reads a list of X509 certificate stored in PEM format in the given file name If the file cannot be rea
337. on Word Hy phen a tion By Com pu ter available on the TeX Users Group site here http www tug org docs liang This table is a trie see http en wikipedia org wiki Trie for a definition and an explanation Most of this implementation is borrowed from Phil Bewig s work available here http sites google com site schemephil along with his paper describing the program from which the Bigloo implementation is largely borrowed exceptions must be a non empty list of explicitly hyphenated words Explicitly hyphenated words are like the following as so ciate as so ciates dec li na tion where the hyphens indicate the places where hyphenation is al lowed The words in exceptions are used to generate hyphenation patterns which are added to patterns see next paragraph patterns must be a non empty list of hyphenation patterns Hyphenation patterns are strings of the form antibs where a period denotes the beginning or the end of a word an odd number denotes a place where hyphenation is allowed and an even number a place where hyphenation is forbidden This notation is part of Frank Liang s algorithm created for Donald Knuth s TeX typographic system 20 3 Character encodings gb2312 ucs2 string Bigloo Text function Converts a GB2312 aka cp936 encoded 8bits string into an UCS2 string Chapter 21 CSV 219 21 CSV This chapter describes the Bigloo API for processing CSV spreadsheets This chapter has been written by J
338. on man person and isa woman married woman isa man married man eq with access married woman woman mate mate man eq with access married man man mate mate woman Now let us study the life a Junior Jones and Pamela Smith Once upon a time define junior birth Jones Junior male define pamela birth Smith Pamela female Later on they met each other and they got married define old boy junior junior define old girl pamela pamela get married pamela junior 120 Bigloo 4 2b This union can be checked couple pamela junior gt dit We can look at the new identity of pamela print pamela name Jones firstname Pamela sex FEMALE married to Junior Jones But pamela and junior still are the same persons print eq old boy junior junior gt dtt print eq old girl pamela pamela t Unfortunately all days are not happy days After having been married pamela and junior have divorced define divorce woman person man person if not couple woman man error divorce Illegal divorce cons woman man with access married woman woman maiden name begin shrink woman set gt woman name maiden name shrink man divorce pamela junior We can look at the new identity of pamela print pamela name Smith firstname Pamela sex FEMALE And pamela and junior stil
339. oo procedure bigloo procedure bigloo procedure 34 minbx xl x2 maxbx xlx2 zlz2z3 fx il 12 f rl r2 elong rl r2 llong rl r2 bx rl r2 lt 712223 fx il 12 lt fl rl r2 lt elong rl r2 lt lllong rl r2 bx rl r2 gt 712223 gt fx il i2 gt fl rl r2 gt elong rl r2 gt lllong ri r2 gt bx rl r2 lt 717223 lt fx il i2 lt f1 rl r2 lt elong rl r2 lt llong rl r2 lt bx rl r2 gt 717223 gt fx il i2 fl rl r2 gt elong rl r2 gt llong rl r2 gt bx rl r2 A fx il i2 flrir2 elong rl r2 llong rl r2 bx ri r2 Z fx ili2 flrir2 elong rl r2 llong rl r2 bx rl r2 zZz zl 22 Bigloo 4 2b bigloo procedure bigloo procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure procedur
340. oo source code This file is searched in the current directory and in all the directories mentioned in the variable load path The load procedure reads expressions and definitions from the file evaluating them sequentially If the file loaded is a module i e if it begins with a regular module clause load behaves as module initialization Otherwise this Chapter 22 Eval and code interpretation 223 function returns the result of the last evaluation The function loadq differs from the function load in the sense that loadq does not print any intermediate evaluations Both functions return the full path of the loaded file loada filename bigloo procedure Loads an access file which allows the interpreter to find the modules imported by a loaded module It returns the full path of the loaded file load path bigloo variable A list of search paths for the 1oad functions dynamic load filename optional init init point bigloo procedure Loads a shared library named filename Returns the value of the last top level expression Important note The function dynamic load can only be used from interpreters linked against dynamic libraries In particular the dynamic load function can be is sued from the bigloo command if and only if the option sharedcompiler yes has been used when configuring Bigloo If the bigloo command is not linked against dy namic libraries and if dynamic load is required inside a read eval print loop REP
341. optimiza tion reduces the memory footprint of an application and it reduces the execution time bigloo dns enable cache bigloo function bigloo dns enable cache set bool bigloo function Enable disable DNS name caching bigloo dns cache validity timeout bigloo function bigloo dns cache validity timeout set integer bigloo function Get set the validity period for the DNS cache entries It is expressed in seconds Chapter 25 Explicit typing 231 25 Explicit typing Bigloo supports type annotation or type information As shown in Section ref Module declaration these annotations can be written both in the module clauses and in module bodies although module body type information is optional It helps the compiler to produce better quality code and to reject incorrectly typed programs Type annotations can describe both the result and formal parameter types for global functions and also types for local variable Due to our module language design in particular module initialization Scheme global variables cannot support type information Types are either atomic types see Section 26 1 6 1 Atomic types page 235 foreign types see Section 26 1 6 Defining an extern type page 235 or a classes see Section 9 1 Class declaration page 113 Warning All type annotations are ignored by the interpreter Module body type annotations are introduced by the following special forms define 1 typel a type body big
342. ore and more instances in order to attain an overall match There is backtracking in alternation too as the more rightward alternates are tried when locally successful leftward ones fail to yield an overall match 12 2 14 Disabling backtracking Sometimes it is efficient to disable backtracking For example we may wish to commit to a choice or we know that trying alternatives is fruitless A nonbacktracking regexp is enclosed in gt pregexp match gt a aaaa gt f In this call the subregexp gt a greedily matches all four a s and is denied the oppor tunity to backpedal So the overall match is denied The effect of the regexp is therefore to match one or more a s followed by something that is definitely non a 12 2 15 Looking ahead and behind You can have assertions in your pattern that look ahead or behind to ensure that a sub pattern does or does not occur These look around assertions are specified by putting the subpattern checked for in a cluster whose leading characters are for positive looka head negative lookahead lt positive lookbehind negative lookbehind Note Chapter 12 Posix Regular Expressions 149 that the subpattern in the assertion does not generate a match in the final result It merely allows or disallows the rest of the match 12 2 16 Lookahead Positive lookahead peeks ahead to ensure that its subpattern could match pregexp match positions grey hou
343. ors within the source file to the corresponding documentation file Then by the means of simple mouse clicks it becomes possible to edit the documentation of peace of codes The current BEE literate programming system only supports the Texinfo file format For that purpose three anchors are available path node and deffn All anchor have to be delimited with characters e path this anchor set the path to the file containing the documentation Thus module foo Cpath manuals foo texi Tells the BEE that the documentation for the module foo is located in the file named manuals foo texi e node sets the name of the node that documents this particular source file code module foo Cpath manuals foo texi Onode Foo gt e deffn each variable binding may point to its documentation For that it suffices to use the deffn anchor just before the variable definition or within the s expression that defines the variable Odeffn foo define foo chars 2 Or define foo chars Odeffn foo E When clicking on that anchor the BEE will search the documentation file named by the path anchor and within that file will search for a texinfo deffn command that defines the variable named in the anchor Chapter 35 Global Index 35 Global Index MOTO bailo edd bee hhbetecad sh amp eval warning 6 eee amp excepblomi xf aa En sic ght oss na a aS dpe Ahttp error isls eae eR dere ad ee as amp http r
344. ort the funi fun2 and fun3 bindings exported by the module mod funi fun2 fun3 mod import the fun4 bindings that will be known in this module under the alias name f f fun4 mod import all gee bindings the gee module is located in a file called gee scm gee gee scm use use bigloo module clause use has the same meaning as import except that modules which are used are not initialized see Section 2 3 Module Initialization page 13 Used modules are read before imported modules with with bigloo module clause This clause specifies a list of modules which have to be initialized at runtime and is used to force the initialization of modules which are never imported but which are required by an application see Section 26 4 Embedded Bigloo applications page 243 export export bigloo module clause In order to make a module s global bindings available to other modules they have to be exported Export clauses are in charge of this task and an export is a list of the form 10 Bigloo 4 2b lt export gt gt lt eclause gt lt eclause gt ident expander lt ident gt syntax lt ident gt inline ident ident generic ident ident ident lt ident gt ident class macro ident ident The first form of eclause allows the variable ident be exported the second allows the function ident always regarded as immu
345. ose or implement many of those missing features with little effort The most time consuming part is generally designing a clean API and the testing debugging of new features when something goes wrong it can take a huge amount of time to find the reason 170 Bigloo 4 2b Developers interested in improving Bigloo s OpenPGP library can print a huge amount of debugging information by enabling the debug macro in util scm Bigloo s OpenPGP implementation is not designed for speed and takes no shortcuts The debugging output can therefore be used to follow the specification of RFC 4880 or 2440 Chapter 15 Errors Assertions and Traces 171 15 Errors Assertions and Traces 15 1 Errors and Warnings Bigloo permits to signal an error via the error function Errors are implemented by the means of exceptions see with exception handler with handler and raise forms As sertions allow the checking of predicates at certain points in programs typeof obj bigloo procedure Returns a string which is the name of the dynamic type of obj error proc msg obj bigloo procedure This form signals an error by calling the current error handler with proc msg and obj as arguments define foo 1 if not pair 1 error foo argument not a pair 1 car 1 foo 4 error ERROR bigloo foo argument not a pair 4 Switching on the g compilation switch enables stack dumping when the error func tion is invoked That is whe
346. oseph Donaldson as the implementation of the CSV library 21 1 Overview The Bigloo csv library supports the parsing of csv and csv like data By default it enables the parsing of comma tab and pipe separated data In addition facilities are provided that enable extending the library to support additonal csv like formats The rest of this document describes the Bigloo csv application programming interface 21 2 API Reference read csv record input port custom lexer bigloo procedure read csv record has one required argument the input port of the csv data to parse and an optional argument indicating the lexer to use by default the lexer supporting standard csv files It returns a single record as a list or eof object Upon error it will throw an amp invalid port error or amp io parse error exception read csv records input port custom lexer bigloo procedure read csv records has one required argument the input port of the csv data to parse and an optional argument indicating the lexer to use by default the lexer supporting standard csv files It returns all of the records as a list of lists or eof object Upon error it will throw an amp invalid port error or amp io parse error exception csv for each proc input port custom lexer bigloo procedure csv for each has two required arguments a procedure to apply to each record and the input port of the csv data to parse and an optional argument indicating the lexer to
347. ospection facilities 1 6 Threads Since release 2 4d Bigloo has included a thread library Bigloo supports Fair threads that are cooperative threads run by a fair scheduler which gives them equal access to the processor Fair threads can communicate using broadcast events and their semantics does not depends on the executing platform Fine control over fair threads execution is possible allowing the programming of specific user defined scheduling strategies 1 7 SQL Since release 2 7b Bigloo includes a SQL binding Namely the C Bigloo runtime system can access the facilities offered by SQLite http www sqlite org 1 8 Type annotations Type information related to variable or function definitions can be added to the source code If no type information is provided runtime checks will be introduced by the compiler to ensure normal execution provided that the user has not used compilation flags to prevents this If type information is added the compiler statically type checks the program and refuses ones that prove to be incorrect Chapter 1 Overview of Bigloo 5 1 9 Unicode support Bigloo supports UCS 2 Character encoding and also provides conversion functions between UTF 8 and UCS 2 It still maintains traditional ISO LATIN1 characters and strings 1 10 DSSSL Bigloo helps the DSSSL programmer by supporting keywords named constants and keyword functions Chapter 2 Modules 7 2 Modules A modules is a compiler and i
348. ost port bigloo procedure Send string message over datagram socket sock to host and port host must be a string denoting an IPv4 or IPv6 address On success return the number of bytes actually sent host hostname bigloo procedure hostinfo hostname bigloo procedure Returns the IP number of hostname When hostname is not found the io unknown host error exception is raided see Chapter 15 Errors Assertions and Traces page 171 The function hostinfo possibly returns more information about the host It returns an association list made out the information about the host This list might contain a name entry an addresses entry and a aliases entry Some back ends e g the C back end implements DNS caching This may dramat ically improve the performance of intensive networking applications DNS caching can be control by the means of two parameters bigloo dns enable cache and bigloo dns cache validity timeout see Chapter 24 Parameters page 229 get interfaces bigloo procedure Returns the list of configured interfaces their associated IP addresses their protocol and if supported by the system the hardware address the mac address get protocols bigloo procedure Reads all the entries from the protocols database and returns a list of protocol entries Each entries consists in a list of three elements e a string denoting the protocol name e an integer denoting the protocol number e a list of strings denoting the pro
349. otherwise Socket down socket bigloo procedure Returns t if socket has been previously closed with socket shutdown It returns f otherwise Here is another example of making use of stream sockets define si make server socket define s2 ttunspecified dynamic wind Init Launch an xterm with telnet running on the s listening port and connect lambda run process usr X11R6 bin xterm display 0 e telnet localhost number gt string socket port number s1 set s2 socket accept s1 display nWelcome on the socket REPL n n gt socket output s2 flush output port socket output s2 Action A toplevel like loop lambda let loop O let obj eval read socket input s2 fprint socket output s2 Result obj display gt socket output s2 flush output port socket output s2 Loop Termination We go here when 3 a an error occurs HE b connection is closed lambda print Shutdown n socket close s2 socket shutdown s1 Here is a second example that uses sockets It implements a client server architecture and it uses unbufferized see socket accept input ports First here is the code of the client 88 Bigloo 4 2b module client let s make client socket localhost 8080 outbuf f p socket output s display string p newline p display abc p flush output port p let loop O 100p The
350. oting a number of seconds music crossfade music int Bigloo Multimedia procedure music random set music bool Bigloo Multimedia procedure music repeat set music bool Bigloo Multimedia procedure These functions controls how songs playback should follow each other music volume get music Bigloo Multimedia procedure music volume set music vol Bigloo Multimedia procedure Get and set the audio volume of a player Some player use the native mixer supported by the operating system some others use a software mixer unrelated to the hardware music status music Bigloo Multimedia procedure music update status music status Bigloo Multimedia procedure The function music status returns an instance of the musicstatus class which de notes the state of the player The function music update status updates this status Chapter 18 Multimedia 207 music song music Bigloo Multimedia procedure music songpos music Bigloo Multimedia procedure These two functions return the number of the song being played and the position in the song These functions are somehow redundant with the function music status because the status also contains information about the playback song and playback position However for some players getting the music song and the playback position is cheaper than getting the whole player status music meta music Bigloo Multimedia procedure Returns the metadata the current song music reset error music Bigloo Multime
351. owing functions e A type checker fun bool obj 0bj This function returns t if the argument obj is of type fun and f otherwise e Anequality checker fun bool fun fun This function returns t if and only if its arguments are equal e Caller fun call res f fun a ta This function invokes f with the arguments a an Suppose we have to use in Scheme the following C variable double convert char It can be done as in module foo extern type string gt double function double string double char macro cv string gt double convert print string gt double call cv 3 14 26 1 6 7 C enums This form defines enum types lt enum type gt enum lt ident gt lt string gt Let us suppose the type type enum enum id 1 name 1 Cdi name n Bigloo creates the following functions e Creators enum id_1 enum Soe eters These functions create enum values e A type checker enum bool obj obj This function returns t if the argument obj is of type enum and f otherwise Chapter 26 The C interface 241 e An equality checker enum bool enum enum This function returns t if the arguments are equal and f otherwise Here is an example of Scheme code using enum type module foo extern type gizmo enum titi titi tutu tutu tata tata enum toto let vi gizmo titi v2 gizmo tutu print gizmo v
352. p match lt gt lt tagl gt lt tag2 gt lt tag3 gt gt tagi The non greedy quantifiers are respectively m m n Note the two uses of the metacharacter Chapter 12 Posix Regular Expressions 145 12 2 8 Clusters Clustering ie enclosure within parens identifies the enclosed subpattern as a single entity It causes the matcher to capture the submatch or the portion of the string matching the subpattern in addition to the overall match pregexp match a z 0 9 0 9 4 jan 1 1970 gt jan 1 1970 jan 1 1970 Clustering also causes a following quantifier to treat the entire enclosed subpattern as an entity pregexp match poo poo poo platter gt poo poo poo The number of submatches returned is always equal to the number of subpatterns speci fied in the regexp even if a particular subpattern happens to match more than one substring or no substring at all pregexp match a z lather rinse repeat gt lather rinse repeat repeat Here the quantified subpattern matches three times but it is the last submatch that is returned It is also possible for a quantified subpattern to fail to match even if the overall pattern matches In such cases the failing submatch is represented by f define date re match month year or month day year subpattern matches day if present pregexp a z 0 9
353. pa dad 123 class subclasses pap EI eee ee 121 class SUP cidcid 120 CLASS in UEBER BEN ENDS 120 Client server lsseeseeeeee rr 8T client socket use ss1 sss sss 91 close binary port cece eee eee ee eee 69 coge input porten rit use E EDU Lae 59 close mmnap sc cei ae os 66 CLOSE output Poiti ers cta ica ee tm eet 59 close process ports sese 83 closed input port i v pe eei MAE ER 59 closed output port sees 59 Cco instantiste c ve d os ee MEY sed Sa 116 CODY enka gett Aut alent TY eto Ott tue 236 Color cr a a Tio 208 command line parsing 005 151 commnand line ll hp y aoa 76 comments cuts Ai 17 Compiler description 0ooooooocccccooo 271 compiler JVM options 0005 245 compiler options 00 ce eee eee eee eee 273 Compiling sia a 5234048 dis 300 compiling and linking with a library 251 Compiling with the JVM back end 245 Complete DSA Key 6 cece eee eee eee 161 Complete ElGamal Key esee 162 Complete RSA Key 0 cece eee eee 158 COMPLEX nis Sits sik a de See hauled 32 CONG cE isch AA A Gea Rd 19 cond expand ive aati UPPER elk 265 condition variable broadcast 182 condition variable name 182 condition variable signal 182 condition variable specific 182 Bigloo 4 2b condition variable spec
354. pecification by Richard Kelsey This SRFI describes syntax for creating new data types called record types A predicate constructor and field accessors and modifiers are defined for each record type Each new record type is distinct from all existing types including other record types and Scheme s predefined types 110 Bigloo 4 2b define record type expression syntax The syntax of a record type definition is lt record type definition gt define record type lt type name gt lt constructor name gt lt field tag gt lt predicate name gt lt field spec gt lt field spec gt gt lt field tag gt lt accessor name gt lt field tag gt lt accessor name gt lt modifier name gt lt field tag gt lt identifier gt lt accessor name gt lt identifier gt lt predicate name gt Hy lt identifier gt lt modifier name gt lt identifier gt lt type name gt lt identifier gt Define record type is generative each use creates a new record type that is distinct from all existing types including other record types and Scheme s predefined types Record type definitions may only occur at top level there are two possible semantics for internal record type definitions generative and nongenerative and no consensus as to which is better an instance of define record type is equivalent to the following definitions e lt type name gt is bound to a representation of the record type its
355. pect threads are useful for modularity However threads are generally considered as low level primitives leading to over complex programming Moreover threads generally have loose semantics in particular depending on the underlying executing platform to give them a precise semantics is a difficult task and this is a clearly identified problem to get portable code Bigloo proposes a new framework with clear and simple semantics and with an efficient implementation In it threads are called fair basically a fair thread is a cooperative thread executed in a context in which all threads always have equal access to the processor Fair threads have a deterministic semantics relying on previous work belonging to the so called reactive approach 16 2 2 Fair Threads Api The Fair Thread library relies on the Posix Thread one but you don t need to import the pthread library as it is done automatically when importing the fthread one The functions listed in Section 16 1 Thread Common Functions page 179 can be used to manipulates the Fair Thread but thread start joinable as a fair thread can always join any other fair thread in the same scheduler 184 Bigloo 4 2b 16 2 2 1 Thread instantiate fthread body thunk name name Bigloo syntax Returns a new thread which is not started yet The body of the thread is the body of the procedure thunk The optional argument name can be use to identify the thread It can be any Bigloo value
356. pens an http connection on server on port number port with an authentica tion and open an input file on file path e ftp server path e ftp user password server path Opens an ftp connection on server and open an input file on file path Log in as anonymous e ressource Opens a JVM ressource file Opening a ressource file in non JVM backend always return On the JVM backend it returns a input port if the ressource exists Otherwise it returns f The optional argument buffer can either be e positive fixnum this gives the size of the buffer Chapter 5 Standard Library 57 e The boolean ttt a buffer is allocated e The boolean f the socket is unbufferized e A string it is used as buffer The optional argument timeout an integer represents a microseconds timeout for the open operation open input gzip file file name buffer 7t bigloo procedure open input gzip port input port buffer t bigloo procedure Open respectively a gzipped file for input and a port on a gzipped stream Note that closing a gzip port opened from a port pi does not close the pi port let p open input gzip file bigloo tar gz unwind protect read line p1 close input port p let p1 open input file bigloo tar gz p2 open input gzip port p1 unwind protect read line p2 close input port p2 close input port p1 open input zlib file file name buffer Zt bigloo procedure open input zlib port input
357. port buffer t bigloo procedure Open respectively a zlib file for input and a port on a zlib stream Note that closing a zlib port opened from a port pi does not close the pi port open input string string start 0 end bigloo procedure open input string string start 0 end bigloo procedure string must be a string and start and end must be exact integers satisfying O lt START lt END lt string length STRING The optional argument end defaults to string length STRING Returns an input port able to deliver characters from string The function open input string acts as open input string but it might modify the string it receives as parameter open input c string string bigloo procedure Returns an input port able to deliver characters from C string The buffer used by the input port is the exact same string as the argument That is no buffer is allocated open input ftp file file name buffer t bigloo procedure Returns an input port able to deliver characters from a remote file located on a FTP server Example let p open input ftp file ftp sop inria fr ls lR gz unwind protect read string p close input port p The file name may contain user authentication such as 58 Bigloo 4 2b let p open input ftp file anonymous foo ftp sop inria fr ls 1R gz unwind protect read string p close input port p open input procedure procedure buffer t bigloo procedure Returns a
358. pression gt lt flag gt lt var gt lt var gt lt help gt lt s expression gt lt null rule gt gt lt s expression gt lt else rule gt gt else lt s expression gt lt option gt lt flag gt lt string gt lt var gt lt flag gt lt string gt lt string gt lt var gt an identifier leaded by the character lt help gt help lt s expression gt help lt string gt lt s expression gt Each elements of list are match against the rules If one of these matches args parse proceeds as follows 1 The matched argument elements of list are removed from the list 2 The lt s expression gt associated to the matching rule is evaluated in an environ ment where the rule variables are bound 3 The argument parsing is resumed with the rest of list In addition to parsing the command line arguments args parse enables help message printing args parse usage fmt bigloo procedure This is a procedure of one argument an boolean Args parse usage constructs an help message from all the option described in a args parse form Args parse usage is only defined in the lt s expression gt of an args parse form At last if no rule matches an argument and if the args parse form contains an else rule this is evaluated In the s expression part of that rule the pseudo variable else is bound to the first unmatched argument and the pseudo variable rest is bound to all the unmatche
359. procedure is applied to a list of actual arguments the formal and actual argu ments are processed from left to right as follows e Variables in required formal arguments are bound to successive actual arguments start ing with the first actual argument It shall be an error if there are fewer actual argu ments than required formal arguments e Next variables in optional formal arguments are bound to any remaining actual argu ments If there are fewer remaining actual arguments than optional formal arguments then variables are bound to the result of the evaluation of initializer if one was spec ified and otherwise to f The initializer is evaluated in an environment in which all previous optional formal arguments have been bound e If there is a rest formal argument then it is bound to a list of all remaining actual arguments The remaining actual arguments are also eligible to be bound to keyword formal arguments If there is no rest formal argument and there are no keyword formal arguments the it shall be an error if there are any remaining actual arguments e If key was specified in the formal argument list there shall be an even number of remaining actual arguments These are interpreted as a series of pairs where the first member of each pair is a keyword specifying the argument name and the second is the corresponding value It shall be an error if the first member of a pair is not a keyword It shall be an error if the argumen
360. production Typically when the parser generator encounters a shift reduce conflict it produces a warning message then chooses to reduce When a parser generator has precedence and associativity information it can make a much more sophisticated decision Let s use this simple calculator grammar as an example lalr grammar Cleft op mult op div left op add op sub op lparen op rparen op semicolon number file CO file stmt stmt expr op semicolon print expr expr number number expr a op add expr b a b expr a op sub expr b a b expr a op mult expr b a b expr a op div expr b a b op lparen expr op rparen expr Let s start with this input 1 2 3 At the point where the parser has read 1 2 and the lookahead symbol is the parser encounters a shift reduce conflict Should it first reduce by the expr op add expr pro duction or shift the in the hopes of reducing the latter expression first The expr op add expr production has gotten its precedence from the op add terminal symbol This is the precedence of the reduce The precedence of the shift comes from the precedence assigned to the lookahead terminal symbol which is op mult Since op mult has higher precedence the parser generator in this state chooses to shift and does not produce a warning Here s an example which we can use to demonstrate associativity l 42 3 Chapter 11 Lalr 1 parsing 137
361. pwd bigloo procedure Returns the current working directory chdir dir name bigloo procedure Changes the current directory to dir name On success chdir returns t On failure it returns f make file name dir name name bigloo procedure Make an absolute file name from a directory name dir name and a relative name name make file path dir name name names bigloo procedure Make an absolute file name from a directory name dir name and a relative name names file name gt list name bigloo procedure Explodes a file name into a list file name gt list etc passwd gt LS Ga etc passwd file name gt list etc passwd gt etc passwd file name canonicalize name bigloo procedure file name canonicalize name bigloo procedure file name unix canonicalize name bigloo procedure Chapter 5 Standard Library 79 file name unix canonicalize name bigloo procedure Canonicalizes a file name If the file name is malformed this function raises an amp io malformed url error exception The function file name canonicalize may returns its argument if no changes in the string is needed Otherwise as file name canonicalize is returns a new string In addition to handling directory name the function file name unix canonicalize also handles the character file name canonicalize etc passwd gt etc passwd file name canonicalize etc tmp passwd gt tmp passwd file name canonicaliz
362. r A second example using timeouts let res f thread start instantiate fthread body lambda O let sig list foo bar multiple value bind vali sigi thread await sig 1 thread yield multiple value bind val2 sig2 188 Bigloo 4 2b thread await sig 1 thread yield multiple value bind val3 sig3 thread await sig 2 set res list sigl sig2 sig3 thread start instantiate fthread body lambda O thread sleep 2 broadcast foo 1 thread start instantiate fthread body lambda O thread sleep 3 broadcast bar 2 scheduler start res gt 4f foo bar thread get values signals Bigloo function Terminates the instant for the thread as thread yield and returns hence at the next instant all the values associated with all broadcast signals see Section Section 16 2 2 3 Signal page 190 during the previous scheduler reaction see Section Section 16 2 2 2 Scheduler page 189 The function thread get values returns an alist made of the scanned signal and their values That is the length of the returns list is the length of the list signals If a signal of the list signals has not been broadcast its associated entry the list returned by thread get values has an empty cdr Example let s1 foo s2 bar s3 gee res f thread start instantiate fthread body lambda O thread sleep 2 broadcast foo current time bro
363. r Chapter 31 Compiler Description page 271 prevents the compiler to generate the code required for introspecting the classes defined in the compiled module class fields class bigloo procedure Returns the a description of the fields of class This description is a list of field descriptions where each field description can be accessed by the means of the following library functions The fields are those directly defined in class That is class fields does not return fields defined in super classes of class class all fields class bigloo procedure Returns the a description of the fields of class This description is a list of field descriptions where each field description can be accessed by the means of the following library functions By contrast with class fields this function returns fields that are also defined in the super classes of class in th find class field class symbol bigloo procedure Returns the field named symbol from class class Returns f is such a field does not exist class field obj bigloo procedure Returns t if obj is a class field descriptor Otherwise returns f class field name field bigloo procedure Returns the name of the field The name is a symbol class field accessor field bigloo procedure Returns a procedure of one argument Applying this function to an object returns the value of the field described by field class field mutable field bigloo procedure Returns t if the described fi
364. r data can dissapear before the next call to the hash table hashtable contains table key bigloo procedure Returns the boolean ttt if it exists at least one entry whose key is key in table If not entry is found f is returned Note that for a weak hash table the fact this procedure returns t does not guarantee that the key or its associated data will not dissapear before the next call to the hash table hashtable get table key bigloo procedure Returns the entry whose key is key in table If no entry is found or if the key and or value is weakly pointed to and has dissapeard amp f is returned hashtable put table key obj bigloo procedure Puts obj in table under the key key This function returns the object bound in the table If there was an object obj old already in the table with the same key as obj this function returns obj old otherwise it returns obj hashtable remove table key bigloo procedure Removes the object associated to key from table returning t if such object was bound in table and f otherwise hashtable add table key update fun obj init value bigloo procedure If key is already in table the new value is calculated by update fun obj current value Otherwise the table is extended by an entry linking key and update fun obj init value hashtable update table key update fun init value deprecated bigloo procedure If key is already in table the new value is calculated by update fun current value
365. r expression 0 9 0 9 0 9 0 9 0 9 0 9 0 9 0 9 0 9 0 9 0 9 0 9 0 9 18 2 Music The multimedia library provides an extensive set of functions for dealing with music lt provides functions for accessing the metadata of certain music file formats it provides functions for controlling the volume of the hardware mixers and it provides functions for playing and controlling music playback 18 2 1 Metadata and Playlist read m3u input port Bigloo Multimedia procedure write m3u list output port Bigloo Multimedia procedure The function read m3u reads a playlist expressed in the M3U format from input port and returns a list of songs The function write m3u encode such a list encoded in the M3U format to an output port file musictag file name Bigloo Multimedia procedure mp3 musictag file name Bigloo Multimedia procedure ogg musictag file name Bigloo Multimedia procedure flac musictag file name Bigloo Multimedia procedure These functions extract the metadata of a music file named file name The function mp3 musictag returns the ID3 tag section if it exists Otherwise it returns f The function ogg musictag and flac musictag returns the vorbis com ment if it exists musictag Bigloo Multimedia class abstract class musictag title bstring read only artist bstring read only orchestra obj read only default f interpret obj read only default f album bstring read only year int
366. rameter list of the widen form or from the default values in the declaration of the wide class Objects are shrunk using the shrink syntax shrink obj bigloo syntax Here is a first example module example static final class point x default 0 y default 0 wide class named point point name define point instantiate point Two classes have been declared and an instance point of point has been allocated For now point is an instance of point but not an instance of named point and this can be checked by print isa point named gt dt print isa point named point gt f Now we widen point let n point widen named point pointx name orig And we check that now n point is an instance of named point Since named point is a subclass of point n point still is an instance of point print isa n point named point gt itt print isa n point named gt dt Widening affects the objects themselves It does not operate any copy operation Hence point and n point are eq print eq n point point b gt stt To end this example we shrink n point and check its class shrink n point print isa point named point f Here is a more complex example We illustrate widening and shrinking using our wedding simulator First let us define three classes person for man and woman married woman and married man module wedding static final class person
367. ranscript off procedure 22 3 Eval command line options This section presents the Bigloo compiler options that impact the interaction between com piled and interpreted code The whole list of the Bigloo compiler options can be found in Chapter 31 The Bigloo command line page 271 Chapter 22 Eval and code interpretation 225 e i Don t compile a module interpret it e export all Make all the bindings defined by the compiled module available from the interpreter e export export Make all the bindings exported by the compiled module available from the interpreter e export mutable Make all the bindings exported by the compiled module mutable from outside the module This option is dangerous Either all the modules composing the application must be compiled with or without export mutable It is impossible to mix export mutable enabled and disabled compilations 22 4 Eval and the foreign interface To be able to get access to foreign functions within the Bigloo interpreter some extra measurements have to be taken The foreign functions have to be present in the interpreter binary which means you have to compile a custom interpreter This is described in Section Section 26 5 Using C bindings within the interpreter page 243 Chapter 23 Macro expansion 227 23 Macro expansion Bigloo makes use of two macro expansion system The one based on the expansion passing style Dybvig et al 86 and the one advocated by the R5RS for wh
368. rary procedure library procedure library procedure library procedure bigloo procedure removed from it bigloo procedure bigloo procedure Returns a new list which is a copy of list with all items equal to obj deleted from it delete obj list eq equal Same as delete but in a destructive way cons obj bigloo procedure bigloo procedure Returns an object formed by consing all arguments together from right to left If only one obj is supplied that obj is returned every fun clist1 clist2 bigloo procedure Applies the function fun across the lists returning the last non false if the function returns non false on every application If non false the result of value returned by the last application of fun every lt 1 2 3 2 3 4 every lt 1 2 3 2 3 0 any fun clist1 clist2 every is the last bigloo procedure Applies the function fun across the lists returning non false if the function returns non false for at least one application If non false the result of any is the first non false value returned by fun any lt 1 2 3 2 3 4 any lt 123 2 3 0 Chapter 5 Standard Library 29 find pred clist bigloo procedure Return the first element of clist that satisfies predicate pred false if no element does find even 3 14 1 5 9 gt 4 Note that find has an ambiguity in its lookup semantics if find returns f you cannot tell in general
369. re as followed by zero or more bs e Pattern matching on lists as well as on vectors and structures and record types 6 1 Bigloo pattern matching facilities Only two special forms are provided for this in Bigloo match case and match lambda match case key clause bigloo syntax The argument key may be any expression and each clause has the form pattern s expression Semantics A match case expression is evaluated as follows key is evaluated and the result is compared with each successive pattern If the pattern in some clause yields a match then the expressions in that clause are evaluated from left to right in an environment where the pattern variables are bound to the corresponding subparts of the datum and the result of the last expression in that clause is returned as the result of the match case expression If no pattern in any clause matches the datum then if there is an else clause its expressions are evaluated and the result of the last is the result of the whole match case expression otherwise the result of the match case expression is unspecified The equality predicate used is eq match case a b a x x foo x x bar gt bar The following syntax is also available match lambda clause bigloo syntax It expands into a lambda expression expecting an argument which once applied to an expression behaves exactly like a match case expression match lambda x x foo x
370. re name of arity one Bigloo invokes this procedure at the beginning of execution providing the list composed of the shell command line arguments as its single argument module foo main start define start argv display argv newline Then if this program is compiled into foo and invoked using the command foo t bar the list which is the argument for the main procedure start would be foo op bar The special form args parse helps main function argument parsing see Chapter 13 Command Line Parsing page 151 include file name bigloo module clause This is a list of file names to be included in the source file Include files are not modules and may have a special syntax Thus besides containing Bigloo expressions they can contain import and include clauses which must be written in a single list whose first element is the keyword directives Includes files can be used to include implementation neutral Scheme expressions and definitions in a Bigloo module Here is an example of an include file 5 foo sch define struct point x y and the module that includes the foo sch file 3 foo scm module foo include foo sch print point 1 2 Include files may contain module information This is the role of the include directives clause here illustrated with the bar sch example bar sch 5 the directives directives include foobar sch import hux expressions define gee x prin
371. read let state mutex state mutex mutex unlock mutex avoid space leak eq state thread 16 4 Mixing Thread APIs The Section 16 2 Fair Threads page 182 library is Posix Threads safe which means it is possible to use at the same time both libraries In other words it is possible to embed one fair scheduler into a Posix thread Here is a little example with two schedulers started into two different Posix threads each schedulers running two fair threads module mix threads library fthread pthread main main define f1 0 define f2x 0 define main args let si make scheduler t s2 make scheduler t fla instantiate fthread body lambda let loop print fla f1 current thread set fi 1 fi thread yield loop fib instantiate fthread body lambda let loop print fib xfi current thread set f1x 1 fi Chapter 16 Threads 195 thread yield loop f2a instantiate fthread body lambda let loop print f2a f2 current thread set f2 1 f2 thread yield loop f2b instantiate fthread body lambda let loop print f2b f2 current thread set f2 1 f2 thread yield loop let p1 instantiate pthread body lambda Sets the thread s specific scheduler default scheduler s1 scheduler start 5
372. read music db sock 100p define make mpd connection thread music db sock instantiate pthread body lambda let pi socket input sock po socket output sock 208 Bigloo 4 2b input timeout set pi 10000 output timeout set po 10000 unwind protect mpd music pi po db socket close sock mpd music input port output port database log Bigloo Multimedia procedure The function mpd implements a MPD server It reads commands from the input port and write results to output port The argument database an instance of the mpd database class describes the music material that can be delivered by this player mpd database Bigloo Multimedia class class mpd database directories pair nil read only The field directories contains the list of the directories that contains music files 18 3 Color The multimedia library provides functions for dealing with colors hsv gt rgb hsv Bigloo Multimedia procedure hsl gt rgb hsl Bigloo Multimedia procedure rgb hsv rgb Bigloo Multimedia procedure rgb hsl rgb Bigloo Multimedia procedure These procedures converts from and to HSV HSL and RGB representations The argument h is an integer in the range 0 360 the arguments s v and in the range 0 100 The arguments r g and b are in the range 0 255 These procedures returns multiple values multiple value bind r g b hsv rgb 340 34 56 list r g b 143 94 110 multiple val
373. red comicas ds 41 string compare3 Cci eese 41 string contains ceseeeee esses 40 string contains Ci cece ninpis 40 string CODy ise uae EEEO WA Pe 42 Stringocuta iii 43 stringodelete mica ns 43 string downcase lees 42 string downcase isses 42 String fill uznocheewstigeeiceseren n deris 42 String for read co te IX PURUS 43 string hash 552 hb Bake eS 74 String hex ext Maid ea 44 String hex intern cli e ES 44 string hex intern ooooooccccocncccccco 44 String index ooo e RE ken 40 string index right lsssss 40 String lengths ineei eyed dx kc3 le des 39 string natural compare3 sss 41 string natural compare3 ci 41 String nulb i6 jo 4 RLlnb4 o aa ee i es 39 string prefix Ccif 12 64b iii 43 string prefix length sess 43 string prefix length Ci sss 43 string prefix Lo lnc ulli RIIPYSSA 43 String ptf null alas 238 String ref dra e Stute s 39 String replac 4 11 ita elu Piel 43 String replace Licuado 43 Strings 39 String Shrink cti a 42 string Skip liae ca paga ide eres 40 string skip right cece eee 40 string Split 5 de bee herr m duds 43 Bigloo 4 2b string suffix length suus 43 string suffix length ci sss 43 string suffix scele 43 String upcase eee eee 42 string upcase 0 ccc 42 e
374. register crc invalid 1337 55 As 55 is bigger than the fixnum s bit size calling crc with this CRC will yield un definde results crc long 1long c char crc long poly long len long bigloo procedure crc elong elong c char crc elong poly elong len long bigloo procedure crc llong 1llong c char crc llong poly llong len long bigloo procedure crc long le long c char crc long poly long len long bigloo procedure crc elong le elong c char crc elong poly elong len long bigloo procedure crc llong le llong c char crc llong poly llong len long bigloo procedure These function perform a CRC operation on one byte The previously described functions are based on these low level functions The result of all the low level functions will return values that are not cut to the correct length Usually a crc is done in a loop and one needs to bit and only when returning the result Polynomials can be given with or without the high order bit For instance we could implement openpgp crc24 as follows define openpgp init xB704CE define radix 64 24 poly x864CFB define openpgp crc 24 str let loop i 0 crc openpgp init if fx i string length str bit and crc xFFFFFF cut to correct length 24 bits loop fx i 1 crc long string ref str i crc radix 64 24 poly 24 100 Bigloo 4 2b crc polynomial be gt le len polynomial bigloo procedure Returns the little endian variant of a given polynomi
375. riables which are described when Bigloo is invoked with the help2 option to be set as in the following example module examplar option set debug 3 set verbose 2 print dummy Whatever arguments are passed on the command line Bigloo will compile this module in both verbose mode and debug mode library library bigloo module clause type 2 3 This clause enables libraries see Chapter 28 Bigloo Libraries page 251 when com piling and linking Bigloo modules The expressions library are symbols naming the libraries to be used Here is an example of a module declaration which makes use of a library named format module test library format main test format import test2 test2 scm Using a library does not automatically binds its variables and functions to the inter preter In order to make these available to the interpreter an explicit use of an eval library clause must be used type bigloo module clause This forms is used to define builtin Bigloo types It is not recommended to use it in user programs So it is left undocumented Module initialization Initializing a module means evaluating at runtime its top level forms global bindings are top level forms When a module modulel imports a module module2 module2 is initialized before modulel Modules are initialized only once nothing being done if a module already met during initialization is met again Library mod
376. ring esses 166 pEp S bkey s I eie ss eee REY PASE 166 PEp SUDKkeyS cwshei ev ei RP Ae eb 166 Pep Verify nee ak Stes pete ale ase SAO IM 165 pEp write flle bir a esee 163 pEp write portoc aa 163 pep write string e apanr eae 163 Photography iia ES 201 315 PROST VADO PA id dona fa 160 PROSA ViDa RE hae eae 160 port 2gzip port re pes er E eg 66 port inflate port eee eee eee ee 66 portaliano ds 62 port sexp list o iul tae ia 62 port string list og Bees eek IS 62 port gt vcard vcard eee eee 211 o e AA ease aoa eS 66 Port Oin tiie sheets a vata em cas DAS eta AUD ed 53 POSITIVO iodo 33 POSTEAVEDE cerais r Ene E En EENAA 33 positiveelong niio e e ges dai n 33 POSITIVO ii AA viser dex us 33 positivefx c e sie seed sine ana ges 33 positivellong or eir rer ee ded 33 Posix Threads ooooooocmocoomo 179 191 194 Dpeu v ia Lc m pM 65 pragma idento I Pren aI HG TIS 242 Prof AR du t ea TT A A O 139 pregexp mastch 2 6d so seks 140 pregexp match positions 140 pregexp quote vier tote teenie ias 141 pregexp replace cece eee eee eee 140 pregexp replace cece eee eee 141 pregexp Splitencvuesiagesendapue sds eae s Ei 141 pretty printing i en r sit KETE eA 301 PRIDE dota diana A dtes ma ele 63 printf ie pza SE ee es 64 Private Keysosce oi aiie 93 private key gui d iix ERIGI ET 93 procedure call cee eee eee cee
377. ring into a mmap object close mmap mm bigloo procedure Closes the memory mapped Returns t on success tf otherwise mmap length mm bigloo procedure Returns the length an exact integer of the memory mapped mmap read position mm bigloo procedure mmap read position set mm offset bigloo procedure mmap write position mm bigloo procedure mmap write position set mm offset bigloo procedure Returns and sets the read and write position of a memory mapped memory The result and the argument are exact integers mmap ref mm offset bigloo procedure Reads the character in mm at offset an exact long elong This function sets the read position to offset 1 mmap set mm offset char bigloo procedure Writes the character char in mm at offset an exact long elong This function sets the write position to offset 1 mmap substring mm start end bigloo procedure Returns a newly allocated string made of the characters read from mm starting at po sition start and ending at position end 1 If the values start and end are not ranged in O mmap length mm an error is signaled The function mmap substring sets the read position to end mmap substring set mm start str bigloo procedure Writes the string str to mm at position start If the values start and start string length str are not ranged in O mmap length mm an error is signaled The function mmap substring sets the write position to start string length s
378. rse subtract lambda x y E y x reverse subtract 7 10 define add4 let x 4 lambda y x y add4 6 28 A A B C 1 2 A A B C O 1 2 QUOTE A abc abc 145932 145932 Ht Ht syntax syntax a procedure 8 10 Chapter 3 Core Language lambda x x 3 4 5 6 Clambda x y z z 3456 if test consequent alternate if gt 3 2 yes no if gt 2 3 yes no if 32 3 2 3 2 set variable expression define x 2 x 1 set x 4 x 1 cond clause clause Bigloo considers else as a keyword It thus ignores clauses following an else clause cond gt 3 2 greater 3 2 less cond 3 3 greater 3 3 less else equal y gt gt gt gt gt cond assv b a 1 b 2 gt cadr else f case key clause clause case 2 3 Q 3 5 7 prime 1 4 6 8 9 composite case car c d a a b b case car c d a e io u vowel w y semivowel else consonant and test and 2 2 gt 2 1 and 2 2 lt 2 1 and 1 2 c f g and and let test and let x 1 y 2 cons x y and let x 1 z f x gt y HY gt gt and let my list compute list not do something my list define look up key alist 3 4 5 6 5 6 yes no 3 unspe
379. rshelong il i2 bigloo procedure bit urshllong il i2 bigloo procedure bit or 5 3 gt 7 bit orelong e5 e3 gt tte7 bit xor 5 3 gt 6 bit andllong 15 13 gt 11 bit not 5 gt 6 bit 1sh 5 3 gt 40 bit rsh 5 1 gt 2 5 5 Weak Pointers Bigloo may support weak pointers In order to activate this support Bigloo must be config ured with the finalization enabled That is the configure script must be invoked with the option finalization yes When the finalization and weak pointers support is en abled Bigloo defines the cond expand properties bigloo finalizer and bigloo weakptr Then a program may test the support with expressions such as cond expand bigloo weakptr lt something gt else lt something else gt Weak pointers are pointers to objects which can be collected by the garbage collector if they are weakly pointed to An object is weakly pointed to if the only pointers to it are weak pointers Weakly pointed objects can be collected by the garbage collector and all the weak pointers to such objects will cease to point to it and point to unspecified instead make weakptr data bigloo procedure Creates a weak pointer to data weakptr obj bigloo procedure Returns t if obj is a weak pointer constructed by make weakptr 72 Bigloo 4 2b weakptr data ptr bigloo procedure Returns the data object pointed to by ptr If the object has been collected it returns unspecified 5 6 Hash
380. rt all The standard distribution contains examples of such constructions In particular the multi threading libraries pthread and fthread use this facility 28 4 library and repl It is possible to implement a read eval print loop that is extended with the facilities implemented inside a library In order to make the variables functions and classes of a library visible from the interpreter the eval library module clause has to be used see Section 2 2 Module Declaration page 7 For instance here is a module that implements a repl with the format facility available module format repl eval library bformat library bformat a dummy reference to a facility of the format library let dummy format rep1 Alternatively libraries can be explicitly loaded using the library load function such as module format repl a dummy reference to a facility of the format library let dummy format eval library load bformat rep1 28 5 Building a library Build Bigloo libraries require several steps that are explained in this section This section shows how to create static and dynamic or shared libraries However not that creating a dynamic library highly dependent on the host operating system Users willing to create dynamic libraries on other operating systems should use the api directory of the Bigloo source code tree as an example e The first step is to build a library heap This is achieved usi
381. s ie vite a ii 36 acosflg sie e e Regen i ERR SUR AXE UE eee 36 aes ctr decrypt cios i kie RS 156 aes ctr decrypt file sssssss 156 aes ctr decrypt mmap sssssssss 156 Bigloo 4 2b aes ctr decrypt port 0000 156 aes ctr decrypt string s ssssss 156 aes ctr enGrypt s o sg vens i E Reia d aaup 156 aes ctr encrypt file 0 156 aes ctr encrypt mmap eee 156 aes ctr encrypt port sse 156 aes ctr encrypt string sssssss 156 end fates a tae ecco eeu hn CE IPEA EUR ES 19 ANUS LOCH A dtr Sate dsh eI 19 O e aa 28 append aiii 27 append di Di 27 append map erat 50 append map h sis conil a 50 append output binary file 69 append output file o o ooooooommmmmmmmo o o 58 Appl yerdi tech viis eskiesnbctt uS Si eae 49 ALPS parse e eke ede 151 ALES PALSeC USAGE 1 eee eee eee 151 arguments parsing 00 cece eee eee 151 ASCIISSETINg Oe sxe oes e the es ATG ld 45 asi esce a ta uscite 36 asia a a ia 36 A AN 175 ASSCTUIONS tra rss 171 A A att 28 AN a 28 ASS V onho Temini nobop Naa aE S a aA 28 asynchronous signal oooooocooocccoo o 191 AT AMI sl ie eke sella eese xe Lasst 36 atantl ieee che e aia 36 automatic extern clauses generation 234 Automatic Java clauses generation 247 B Das ii A exu ertet 96 base64 decode eee eee eee eee 96 base64 decode port
382. s to find initialization entry points in the dynamic libraries that are named after the library s name More precisely for the LIB s library the loader seeks the entry point named LIB s and for the LIB es it seeks LIB es The name of the initialization entry of a library can be changed using the declare library function If that named is changed one module of the library must contain an option module clause that sets the variable dlopen init with the name of the initialization entry point Since Bigloo 3 1a the runtime system supports a better way for initializing libraries Initialization modules can be associated with a library When loaded these modules are automatically initialized This new method fits harmoniously with the Bigloo initialization process and it relieves users from any requirement to annotate the source code of the library For instance if a library initialization file contains the following declaration declare library foo module init foo Then the library must implement the foo module Chapter 28 Bigloo Libraries 255 module foo import 10 In addition if the library binds variables functions or classes in the interpreter then an eval init clause must be added to the class declaration declare library foo module init foo eval init foo eval Then the module foo eval must be implemented in the libfoo_es and libfoo_eu libraries module foo eval import eval expo
383. sable dataflow optimizations for improviing type er ror messages fdataflow types Enable type dataflow optimizations enabled from O2 fno dataflow ty pes Disable type dataflow optimizations finitflow Enable init flow fno initflow Disable init flow fsync failsafe Enable failsafe synchronize optimization 276 fno sync failsafe fO macro fno O macro fglobal tailc fno global tailc fsaw realloc fsaw regalloc fno saw regalloc fsaw regalloc msize SIZE fsaw regalloc fun NAME fno saw regalloc fun NAME fsaw regalloc onexpr fno saw regalloc onexpr Safety unsafe atrsvleh safelatrsvle Debug glines gbdb no line gbdb 23 gself gmodule gerror localization gno error localization gjvm gtrace 12 g 234 cg export all export exports export mutable Profiling p 2g pmem 2 psync Verbosity S v 23 hello no hello W wslots Wvariables Bigloo 4 2b Disable failsafe synchronize optimization Enable Optimization macro default Disable Optimization macro Enable global tail call optimization Disable global tail call optimization Enable saw register re allocation Enable saw register allocation Disable saw register allocation Set the register allocation body size limit Allocate registers on this very function Don t allocate registers on this very function Allocate registers on expressions Don t allocate registers on expressions Don t check type arity r
384. sename bigloobformat module init bformat module eval make lib class init bigloo bformat bformat class eval bigloo bformat make lib At this time you are ready to use your library For that let s assume the file foo scm module foo library bformat bigloo library path set cons pwd bigloo library path print bformat Library path a bigloo library path eval library load bformat rep1 It can be compiled and executed with bigloo foo scm L copt L LD LIBRARY PATH LD LIBRARY PATH a out The Bigloo distribution contains library exemplars that should probably considered as a departure point for new libraries 28 6 Library and modules A Bigloo library may be composed of several Bigloo modules even if in our example only one module was used The modules composing the library are free to import each other Nevertheless someone designing a Bigloo library should be aware that Bigloo importation creates dependences between modules A module mod1 that imports a module mod2 depends on mod2 because modi requires mod2 to be initialized i e mod1 calls to the initialization function of mod2 The result is that using import clauses inside modules composing a library may create a lot of dependencies between the object files that are used to build the associated Unix library Dependencies should be avoided because they make the Unix linkers unable to produce small stand alone progra
385. sition format Bigloo OpenPGP procedure armored The counter part of pgp read These functions encode PGP compositions By de fault the result is armored i e encoded with ASCII characters If the optional format parameter is different than the symbol armored then the composition is encoded in binary Note that there is no means to encode a list of PGP keys pgp encrypt msg string keys passwords hash algo Bigloo OpenPGP procedure sha 1 symmetric algo cast5 Encrypts the given string The returned composition can be decrypted by the owners of the keys or with one of the passwords In the following example Alice and Bob may use their private key to decrypt the secret message Users knowing the one of the passwords foo and bar will also be able to decrypt the message pgp write file encrypted pgp pgp encrypt my secret message list alice key bob key foo bar The given keys should be subkeys of a PGP key but if a PGP key is given Bigloo will do its best to pick the correct subkey for encryption e If only one subkey exists the main key then this subkey is used e If two subkeys exist and the non main key is suitable for encryption then the non main key is used e If only one of many subkeys including the main key is suitable for encryption then this subkey is used e Else Bigloo raises an error pgp password encrypt msg string password Bigloo OpenPGP procedure hash algo
386. sr bin X11 usr local bin gt bin usr bin usr bin X11 usr local bin pregexp split pea soup gt pea soup If the first argument can match an empty string then the list of all the single character substrings is returned pregexp split smithereens gt s m wy cU ht gU rU gU gU n Ws To identify one or more spaces as the delimiter take care to use the regexp not pregexp split split pea soup split pea soup pregexp split split pea soup s p Wa Ww ww p gU aU Wott Wo y p pregexp quote string bigloo procedure The procedure pregexp quote takes an arbitrary string and returns a U regexp string that precisely represents it In particular characters in the input string that could serve as regexp metacharacters are escaped with a backslash so that they safely match only themselves pregexp quote cons gt cons pregexp quote list gt list pregexp quote is useful when building a composite regexp from a mix of regexp strings and verbatim strings 142 Bigloo 4 2b 12 2 Regular Expressions Pattern Language Here is a complete description of the regexp pattern language recognized by the pregexp procedures 12 2 1 Basic assertions The assertions and identify the beginning and the end of the text string respectively They ensure that their adjoining regexps match at one or other end of the tex
387. ssociated with all the broadcasts that took place during the instant It can be defined as define thread await values signal tmt apply thread await signal tmt thread get values signal thread await signals timeout Bigloo function Wait for one of a list of signals The function thread await can be compared to the Unix select function The argument signals is a list of signal identifier The function thread await blocks the current thread until one of the signal in the list signals is broadcast or until the optional numerical argument timeout is elapsed If the thread unblocks because the timeout is elapsed thread await returns f Otherwise it returns two values that have to be collected with multiple value bind see Section 5 1 13 Control Features page 49 The first one is the value of the broadcast signal The second one is the broadcast signal Example let res f thread start instantiate fthread body lambda O let sig list foo bar multiple value bind vali sig1 thread await sig multiple value bind val2 sig2 thread await sig thread yield multiple value bind val3 sig3 thread await sig set res list sigl sig2 sig3 thread start instantiate fthread body lambda O thread sleep 2 broadcast foo 1 thread start instantiate fthread body lambda O thread sleep 3 broadcast bar 2 scheduler start res gt foo foo ba
388. stered subpattern to be treated specially The modifier i causes the subpattern to match case insensitively pregexp match i hearth HeartH HeartH The modifier x causes the subpattern to match space insensitively ie spaces and com ments within the subpattern are ignored Comments are introduced as usual with a semi colon and extend till the end of the line If you need to include a literal space or semicolon in a space insensitized subpattern escape it with a backslash 4 X0 which is useful in an insert string makes no sense within the regexp pattern because the entire regexp has not matched yet that you could refer back to it 5 A useful if terminally cute coinage from the abbots of Perl Chapter 12 Posix Regular Expressions 147 pregexp match x a lot alot gt alot pregexp match x a lot a lot gt a lot pregexp match x a N man AN NN ignore a plan N me a canal completely a man a plan a canal gt a man a plan a canal You can put more than one modifier in the cloister pregexp match ix a N man AN NN amp ignore a plan N NN 4 me a canal completely A Man a Plan a Canal gt A Man a Plan a Canal A minus sign before a modifier inverts its meaning Thus you can use i and x in a subcluster to overturn the insensitivities caused by an enclosing cluster pregexp match i the i TeX book The TeXbo
389. stic thus programs that deploy Fair threads are predictable e Fair threads are easier to program with because they hide most the of the concurrent programming pitfalls In particular since Fair threads enforce a strong synchronization there is no need to deploy techniques such as mutex semaphore or condition variables This whole chapter has been written in collaboration with Frric Boussinot It uses materials on Fair threads that can be found at http www sop inria fr indes rp FairThreads html FairThreads html 16 2 1 Introduction to Fair Threads Fair threads are cooperative threads run by a fair scheduler which gives them equal access to the processor Fair threads can communicate using broadcast events Their semantics does not depends on the executing platform Fine control over fair threads execution is possible allowing the programming of specific user defined scheduling strategies Contrary to standard sequential programming where the processor executes a single program in concurrent programming the processor is a shared resource which is dispatched to several programs The term concurrent is appropriate because programs can be seen as concurrently competing to gain access to the processor in order to execute Threads are a basic means for concurrent programming and are widely used in operating systems At language level threads offer a way to structure programs by decomposing systems in several concurrent components in this res
390. strings unix path gt list gt 000 unix path gt list usr bin gt usr bin hostname bigloo procedure Returns the fully qualified name of the current host time thunk bigloo procedure Evaluates the thunk and returns four values the result of calling thunk the actual execution time the system time and the user time in millisecond multiple value bind res rtime stime utime time lambda fib 35 print real rtime sys stime user utime Chapter 5 Standard Library TT getuid bigloo procedure getgid bigloo procedure setuid uid bigloo procedure setgid uid bigloo procedure The procedure getuid resp getgid returns the UID resp GID of the user the current process is executed on behalf of The procedure setuid resp setgid set the UID resp GID of the current process In case of failure this procedure raises an error getpid bigloo procedure Get the current process identifier getppid bigloo procedure Get the parent process identifier getgroups bigloo procedure Maps the Posix getgroups function which returns the supplementary group IDs of the calling process The result is a vector of IDs On error an IO exception is raised getpwnam name bigloo procedure getpwuid uid bigloo procedure These two procedures returns information about a user The procedure getpwname accepts a string denoting the user name as argument The procedure getpwuid accepts an
391. sumption that there exists a C compiler This drawback can be eliminated by directly compiling Bigloo on the host since there exists a C compiler Chapter 32 Cross Compilation 295 32 5 Examples In this example we will show how to compile for a host machine that has ssh access We assume e a working Bigloo should be the same version as the one that is going to be compiled for the host in the PATH e ssh access to the host This access should be without password using keys The system should be accessible by ssh host where host should be replaced with the correct address e aC cross compiler CC running on the build system and compiling for the host With these preconditions satisfied we can first build Bigloo for the host system configure hostsh PWD examples hostsh ssh ssh copy sh host cc CC make make DESTDIR TMP install Now let s compile a simple hello world for the host cat gt tmp hello scm EOF module hello main main define main args print hello world EOF bigloo static all bigloo lib dir TMP lib 3 2c o tmp hello tmp hello scm The generated executable should be able to run on the host Chapter 33 User Extensions 297 33 User Extensions The extension package system allows the language compiled by Bigloo to be extended and this is achieved by associating an extension file with a suffix The extension file is loaded at the beginning of a compilation
392. system support for chmod is restricted In order to read a shell variable from a Bigloo compiled Jvm program you have to use the Bigloo link option jvm env when linking that program However some shell variables are automatically defined HOME USER CLASSPATH and TMPDIR JVM code generation does not support pragma forms Chapter 27 The Java interface 247 27 4 Connecting Scheme and Java code When compiling and linking with the JVM back end Bigloo source code may use the Java APT That is Bigloo Scheme source code may use refer or set Java static variables Bigloo source code may call static or virtual Java methods In addition Bigloo variables and functions may be exported to Java that is use set or called in Java source code Java module clauses are enabled read and parsed only when compiling to JVM byte code Java definitions are declared in Bigloo modules by the mean of a Bigloo module clause the java module clause The syntax of a Java clause is defined by java gt lt declare class clause gt lt declare abstract class clause gt lt extend class clause gt lt array clause gt lt export clause gt As for the extern clause java clauses are automatically transmitted by the importation process That is if module module1 imports a module module2 module treats the java clauses of module2 as though they were included in its own module declaration Redefinition of a variable or a function already def
393. t bar x define bar x print bar x bar 5 If these modules are compiled as bigloo mod1 scm c o modl o bigloo mod2 scm c o mod2 o dload sym Then if a shared library is built using these two modules note that on non Linux systems a different command line is required ld G o lib so mod1 o mod2 o Then lib so cant be dynamically loaded and the variables it defines used such as bigloo i dynamic load lib so foo 4 bar 5 1 gt foo 6 foo 7 As the example illustrates when Bigloo modules are dynamically loaded they are initialized This initialization is ensure only if dynamic 1oad is called with exactly one parameter If dynamic 1oad is called with two parameters it is of the responsibility of the program to initialize the dynamically loaded module before using any Scheme reference Note In order to let the loaded module accesses the variables defined by the loader application special compilation flags must be used e g rdynamic under the Linux operating system Dynamic load is implemented on the top of the dlopen facility For more information read the dlopen and 1d manuals dynamic unload filename bigloo procedure On the operating system that supports this facility unloads a shared library Returns t on success Returns f otherwise dynamic load path bigloo variable A list of search paths for the dynamic 1oad functions transcript on filename procedure t
394. t here are small examples 10 5 1 Word count The first example presents a grammar that simulates the Unix program wc let char 0 word 0 line 0 regular grammar Newline set char char the length set line line the length ignore in space tab set char char the length ignore out newline space tab set char char the length set word 1 word ignore 10 5 2 Roman numbers The second example presents a grammar that reads Arabic and Roman number let par open 0 regular grammar arabic in 09 roman uncase in ivxlcdm Cr Cin t n ignore arabic string gt integer the string roman roman gt arabic the string EN let open key par open set par open 1 par open context pair let loop pair walk ignore cond open key par open 20 else cons walk loop pair ignore GIN set par open par open 1 if lt par open 0 begin set par open 0 ignore Gn string gt symbol the string else let char the failure if eof object char Chapter 10 Regular parsing 133 char error grammar roman Illegal char char Chapter 11 Lalr 1 parsing 135 11 Lalr 1 parsing Regular grammar generators like Lex are often coupled with tools such as Yacc and Bison that can
395. t pair 1 begin warning location foo scm 154 foo argument not a pair 1 20 car 1 foo 4 File foo scm line 6 character 154 car 1 4 WARNING bigloo foo argument not a pair 4 0 exception notify exc bigloo procedure error notify err bigloo procedure warning notify err bigloo procedure Display a message describing the error or warning on the default error port 15 2 Exceptions current exception handler SRFI 18 function Returns the current exception handler with is a 0 ary procedure with exception handler handler thunk SRFT 18 function Returns the result s of calling thunk with no arguments The handler which must be a procedure is installed as the current exception handler in the dynamic envi ronment in effect during the call to thunk When possible prefer with handler to with exception handler because the former provides better debugging support and because its semantics is more intuitive with handler handler body bigloo form Returns the result s of evaluating body The handler which must be a procedure is installed as the current exception handler in the dynamic environment in effect during the evaluation of body Contrarily to with exception handler if an exception is raised the handler is invoked and the value of the with handler form is the value produced by invoking the handler The handler is executed in the continuation of the with handler form JVM note
396. t name is not the same as a variable in a keyword formal argument unless there is a rest formal argument If the same 24 Bigloo 4 2b argument name occurs more than once in the list of actual arguments then the first value is used If there is no actual argument for a particular keyword formal argument then the variable is bound to the result of evaluating initializer if one was specified and otherwise 4f The initializer is evaluated in an environment in which all previous formal key arguments have been bound e If rest was specified in the formal argument list after a key formal parameter it is bound to the list of optional non keyword arguments It shall be an error for an lt ieee ident gt to appear more than once in a formal argument list Example lambda x y x 3456 3 45 6 Clambda x y rest z z 3 4 5 6 gt 56 lambda x y optional z rest r key i j 10 list x y zi i j 3 345 i 6 i 7 gt 345i 6 j 1 lambda x y optional z key i j 1 rest r list x y z i i j j r 345i 6i 789 gt 345i 6 j 1 8 9 4 2 Modules and DSSSL formal argument lists Functions using DsssL formal argument lists can be exported or imported in the same way as all regular Bigloo functions When exporting such a Dsssl function the exact prototype of the function must be duplicated in the export clause That is for instance the exportation prototype for the function define foo x y optional
397. t seeks one of the following file Makefile afile or etags This search unwind directories until the root directory is reached or until the number of scanned directories is more than the value of the list variable bee root search depth An alternative Bee Root Directory may be set This is done clicking on the Root of the tool bar icon 34 4 Building a Makefile Once the Bee Root Directory has been setup it is printed on the left part to the Emacs modeline a Makefile can be automatically produced It can be achieved clicking on the Mkmf icon of the tool bar using the popup menu button 3 entries or using one of the two keyboard bindings C c C c C a or C c C c C 1 When creating a Makefile you will be asked to give a file name This file must be the one that is the main entry point of your program or the one that implements an library heap file When the Makefile already exists using the same bindings update Makefile re generate afile and etags files 34 5 Compiling Once a Makefile exists it is possible to compile a program or a library Use either the tool bar icon Compile the popup menu entry or C c C c C c If no Makefile exists the BEE will emit a single file compilation 34 6 Interpreting Scheme source code may be interpreted within the BEE instead of been compiled prior to be executed This facility could be convenient for fast prototyping A Read eval print loop henceforth Repl could be spawned using the Repl ico
398. t string Examples pregexp match positions contact first contact gt f The regexp fails to match because contact does not occur at the beginning of the text string pregexp match positions laugh laugh laugh laugh laugh 18 23 The regexp matches the last laugh The metasequence b asserts that a word boundary exists pregexp match positions yack b yackety yack gt 8 12 The yack in yackety doesn t end at a word boundary so it isn t matched The second yack does and is The metasequence AB has the opposite effect to Nb It asserts that a word boundary does not exist pregexp match positions an B an analysis gt 3 5 The an that doesn t end in a word boundary is matched 12 2 2 Characters and character classes Typically a character in the regexp matches the same character in the text string Some times it is necessary or convenient to use a regexp metasequence to refer to a single char acter Thus metasequences An Nr Mt and match the newline return tab and period characters respectively The metacharacter period matches any character other than newline pregexp match p t pet gt pet It also matches pat pit pot put and p8t but not peat or pfffft A character class matches any one character from a set of characters A typical format for this is the bracketed character class which matches any one character from the non empty sequence of characters e
399. t sum int x int y return x y Then let us assume a Bigloo source code main scm that makes uses of that C function module foo extern sum int int int sum main main define main x print sum length x 10 With a Unix installation of Bigloo this program can be compiled and executed with the following commands gcc sum c c bigloo main scm sum o o main main 12 3 The connection between Scheme and C is made particularly easy by Bigloo because the programmer is free from inserting conversion between Scheme values and C values When needed these are automatically inserted by the compiler 26 1 The syntax of the foreign declarations The syntax of foreign clauses is defined by lt extern gt lt variable clause gt lt function clause gt lt include clause gt lt export clause gt lt type clause gt Foreign clauses are automatically transmitted by the importation process That is if module modulei imports a module module2 module treats the extern clauses of module2 as though they were included in its own module declaration Redefinition of a variable or a function already defined in an foreign clause is an error 234 Bigloo 4 2b 26 1 1 Automatic extern clauses generation Extern clauses can be automatically generated using the Cigloo program which is distributed in the same package as Bigloo Using Cigloo may be a good way to understand how C prototypes and types have
400. t x import import bigloo module clause An import is a list of the form Chapter 2 Modules 9 lt import gt lt iclause gt lt iclause gt gt lt bind name gt lt bind name gt lt module name gt lt file name gt lt bind name gt lt bind name gt lt module name gt lt module name gt lt module name gt lt file name gt lt bind name gt lt rbrs ident gt lt alias name gt lt alias name gt gt lt r5rs ident gt lt r5rs ident gt lt module name gt gt lt rbrs ident gt lt file name gt lt string gt The first alternative in iclause imports the variable named bind name which is defined in the module module name located in the files file name The second does the same but without specifying the name of the file where the module is located The third and the fourth form import all the exported variables of the module module name Note The need for specifying in which files modules are located comes from the fact that there is no automatic mapping between module names and files names Such a mapping can be defined in a module access file see Section 2 6 Module Access File page 16 or in the import clause itself as in the first and fourth alternatives in iclause above Here is an example of an import clause module foo import import all bar exported bindings bar import the hux binding exported by 5 the module hux hux hux imp
401. table bigloo procedure 8bits utf8 string table bigloo procedure utf8 8bits string inv table bigloo procedure utf8 8bits string inv table bigloo procedure These are the general conversion routines used internally by iso latin gt utf8 and cp1252 gt utf8 They convert any 8 bits string into its equivalent UTF 8 representa tion and vice versa The argument table should be either f which means that the basic i e iso latin 1 8bits UTF 8 conversion is used or it must be a vector of at least 127 entries containing strings of characters This table contains the encodings for the 8 bits characters whose code range from 128 to 255 The table is not required to be complete That is it is not required to give the whole character encoding set Only the characters that need a non iso latin canonical representation must be given For instance the CP1252 table can be defined as define cp1252 4 Mxe2Xx82Xxac 0x80 me 33 0x81 xe2 x80 x9a 0x82 xc6 x92 33 0x83 xe2 x80 x9e 0x84 xe2 x80 xa6 0x85 xe2 x80 xa0 0x86 xe2 x80 xal 0x87 Chapter 5 Standard Library 4T xcb x86 0x88 xe2 x80 xb0 0x89 xc5 xa0 Ox8a xe2 x80 xb9 Ox8b xc5 x92 33 Ox8c wu Ox8d xc5 xbd Ox8e un Ox8f un Ox90 xe2 x80 x98 0x91 xe2 x80 x99 0x92 xe2 x80 x9c Ox93 xe2 x80 x9d 0x94 xe2 x80 xa2 0x95 xe2 x80 x93 0x96 xe2 x80 x94 0x97 x
402. table when exported this way to be exported and the third exports an inline procedure see Section 2 5 Inline Procedures page 15 whose name is extracted from the first ident after the word inline The last two are both connected with Bigloo s object system The generic clause exports generic functions see Section 9 3 Generic functions page 117 and class clause exports classes see Section 9 1 Class declaration page 113 Note Only bindings defined in module m can be exported by m i e bindings imported by m cannot be ezported by m Type information specified in any ident in an export clause is used by Bigloo Where no type information is given a default generic type named obj is used Note The last formal argument of a multiple arity function can not be typed because this argument is bound to be a pair or null This union cannot be denoted by any type Here is an example of the module foo that exports bindings module foo export export the bar mutable variable bar export the hux function this function takes exactly two arguments hux x y export the inline function gee that takes at least one argument inline gee x z static static bigloo module clause A static clause has exactly the same syntax as an export clause However bindings declared static are local to the module Since the default scope of all bindings is static static module clauses are useful only for program documentation
403. te point x car 1 y cdr 1 let o instantiate point let s obj gt string list o 0 print string for read s let 1 string gt obj s print 1 eq car 1 cadr 1 gt tt get procedure serialization bigloo procedure get custom serialization ident bigloo procedure get process serialization bigloo procedure get opaque serialization bigloo procedure get class serialization class bigloo procedure Returns the a multiple values whose first element is the current procedure serial izer and whose second element is the current procedure unserializer If no serial izer unserializer is defined these procedures return the values f f 5 4 Bit manipulation These procedures allow the manipulation of fixnums as bit fields Chapter 5 Standard Library 71 bit or il i2 bigloo procedure bit orelong il i2 bigloo procedure bit orllong il i2 bigloo procedure bit xor il i2 bigloo procedure bit xorelong il i2 bigloo procedure bit xorllong il i2 bigloo procedure bit and il i2 bigloo procedure bit andelong il i2 bigloo procedure bit andllong il i2 bigloo procedure bit not i bigloo procedure bit notelong i bigloo procedure bit notllong i bigloo procedure bit lsh il i2 bigloo procedure bit lshelong il i2 bigloo procedure bit 1shllong il i2 bigloo procedure bit rsh il i2 bigloo procedure bit ursh il i2 bigloo procedure bit rshelong il i2 bigloo procedure bit rshllong il i2 bigloo procedure bit u
404. te accepts as input a single word and returns as output a list of subwords The argument hyphens is an opaque data structure obtained by calling the function load hyphens or make hyphens Example hyphenate software load hyphens en gt soft ware load hyphens obj Bigloo Text function Loads an hyphens table and returns a data structure suitable for hyphenate The variable obj can either be a file name containing an hyphens table or a symbol denoting a pre defined hyphens table Currently Bigloo supports two tables en for an English table and fr for a French table The procedure 1oad hyphens invokes make hyphens to build the hyphens table 218 Bigloo 4 2b Example define hyphenate text text lang let table with handler lambda e unless amp io file not found error e raise e load hyphens lang words string split text if table append map lambda w hyphenate w table words words The procedure hyphenate text hyphenates the words of the text according to the rules for the language denoted by its code lang if there is a file lang hyphens sch If there is no such file the text remains un hyphenated make hyphens language exceptions patterns Bigloo Text function Creates an hyphens table out of the arguments exceptions and patterns The implementation of the table of hyphens created by make hyphens follows closely Frank Liang s algorithm as published in his doctoral dissertati
405. tending the Runtime System 263 29 Extending the Runtime System Custom Types types are not documented yet This facility enables extension to the standard Bigloo runtime system The current implementation of custom types is subject to change It will be documented in coming releases Chapter 30 SRFIs 265 30 SRFIs Bigloo supports various SRFIs Scheme Request For Implementation Some of them are integrated in the Bigloo core libraries Some others are implemented by the means of Bigloo libraries see Chapter 28 Bigloo Libraries page 251 Only the first ones are described in the manual The current Bigloo core library support the following SRFIs e srfi 0 Conditional execution AND LET an AND with local bindings a guarded LET special form Basic String Ports e srfi 2 e srfi 6 e srfi 8 Binding to multiple values pa ES eS e srfi 9 Records specification e srfi 18 Multithreading support e srfi 22 Script interpreter invocation e srfi 28 Basic Format Strings e srfi 30 Multi line comments e srfi 34 Exception Handling for Programs 30 1 SRFI 0 cond expand clause bigloo syntax The cond expand form tests for the existence of features at macro expansion time It either expands into the body of one of its clauses or signals and error during syntactic processing cond expand expands into the body of the first clause whose feature requirement is currently satisfied the else clause
406. ter i kirpana errian 222 egatlvet cicle al ie ba FE RIVE E 33 negativeDx usosel4dp o NE MM 33 negativeelong 6 eee eee eens 33 Negativef ctas ni os 33 negatiyefr ad ii 33 negativellong o i ren o yeni cece eee eee 33 DEPL A EE eens 35 negelong ib wiegt E Ee 35 negfl o i as Pet tetigerit 35 O 35 negllong ic deve aia a aR 35 newline n c6 Aa Eee tees a AEG ELENE 63 MOU cce eee eden cts See des una NH S S EM 25 null enyironment v ehe Db SPICE 221 A anced ba adi em I SD 27 Bigloo 4 2b numbet 5string id 36 number iia diia 32 NA pe e fre e ees 32 Obj manor epoca talus etd Get eka tess 236 O nt Re pU Dm e western 68 Objects cereo nux drea VEU ur DENS 113 object dumping rr 68 Object library anita par ER RE d rue 120 Object serialization 0000 121 Object System 00 eee eee eee 113 object gt struct eee eee 121 object cl sS l or I i teen RERUM 121 object constructor eee eee 121 object display ix i llt xU Ri saline es 121 object equ al o ils zer enki EI 121 object hashnumber sess 74 121 object write iiclj6 ell lied tiie yeu 121 octet string bignum esses 37 Aa E 33 ore lo ob A O 33 Oddelong iii a E E eee 33 oddfl A ETET 33 e A Io aka 33 lelo Ke HIN Key at aE E en 33 OBE MUSICAL comida iaa ida 202 on line documentation 00 301 open input binary file
407. tes a new message in the folder whose content is given the string content 19 5 2 IMAP RFC 3501 imap Bigloo Mail class class imap mailbox socket socket read only define mbox instantiate maildir label My Remote Mailbox socket imap login make client socket imap inria fr 993 serrano XXX amp imap parse error Bigloo Mail class class amp imap parse error amp io parse error amp imap error Bigloo Mail class class amp imap error amp mailbox error imap login socket user password Bigloo Mail procedure Log a user into an imap server The socket must have been created first The argument user is a string and denotes the user name The argument password is a string too and it contains the user password This function returns as value the socket it has received If the operation fails the function raises a amp imap error exception Example Chapter 19 Mail 215 define mbox imap login make client socket imap inria fr 993 timeout 200000 serrano XXX print mailbox folders mbox imap logout socket Bigloo Mail procedure Closes an imap connection imap capability socket Bigloo Mail procedure Returns the list of capabilities supported the imap server 19 5 3 Maildir maildir Bigloo Mail class class maildir mailbox prefix bstring read only default INBOX path bstring read only Example define mbox instantiate maildir label My Mailbox path
408. that the function send chars can also be used on gzipped input ports gunzip parse header input port bigloo procedure Parse the header of input port Returns f if and only if the port is not gzipped 5 2 4 Tar tar read header input port bigloo procedure Reads a tar header from input port If the input port does not conform the tar format an IO exception is raised On success a tar header descriptor is returned tar read block tar header input port Reads the content of the tar header block tar round up to record size int Rounds up tar block sizes tar header name tar header tar header mode tar header tar header uid tar header tar header gid tar header tar header size tar header tar header mtim tar header tar header checksum tar header tar header type tar header tar header linkname tar header tar header uname tar header tar header gname tar header tar header devmajor tar header tar header devminir tar header Return various information about tar header The following example simulates the Unix command tar xvfz define untar path let pz open input gzip port path unwind protect let loop 1st let h tar read header pz if not h bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bi
409. the file name for which obj has been opened bigloo procedure bigloo procedure bigloo procedure bigloo procedure input port length obj bigloo gt 3 8d procedure Returns the source number of bytes i e the number characters contains in the source Returns 1 if that number is unknown typically for a pipe input port timeout set port time bigloo gt 2 8b procedure output port timeout set port time bigloo gt 2 8b procedure These two functions limit the time an read or write operation may last If the time limit expressed in microseconds exceeded an exception of time amp io timeout error is raised Setting a timeout equal to 0 restore the socket in blocking mode Setting a timeout with a value lesser than 0 is ignored Note ports created from sockets share their internal file descriptor Hence it is erroneous to set a timeout for only one of the two ports Both must be set output port flush hook port bigloo procedure output port flush hook set port hook bigloo procedure Returns resp sets the flush hook of the output port The flush hook is a procedure of two arguments the output port and the number of characters that are to be actually written out during the flush It is unspecified when the hook is invoked however one may expect the C back end to invoke the hook only when output buffers are full The other back ends JVM and DOTNET are likely to invoke the hook as soon as a character is to be wr
410. the loaded modules but the loaded bindings remains unknown to the compiler If the module foo is defined by module foo export foo x define foo x cons x x then module gee load foo foo scm define macro gee x cons fx x 1 foo x 12 Bigloo 4 2b gee 5 cons 4 cons 5 5 gt 45 5 eval eval bigloo module clause This form allows interactions between compiled code and interpreted code See the Section Chapter 22 Eval command line options page 221 for a presentation of compilation flags that enable compilation tuning for eval Each eval has the following syntax lt eval gt gt export all export module export exports export lt bind name gt export 0 lt bind name gt lt module name gt import lt bind name gt class lt bind name gt library libi The first clause export all exports all the variables bound in the module i e the variables defined in the module and the imported variables The second clause export module exports all the module s variables those declared static and ex ported to the interpreter the third exports all the exports i e the ones present inside an export clause variables to the interpreter the fourth and fifth clause each export one variable to the interpreter The last clause imports a variable from the interpreter and all such imported variables are immutable i e they cannot be the first ar
411. the point library needs to include the point sch file That Scheme file needs in turn the C file point h otherwise the pro duced C files won t compile The need for the libposix library and for the point h file may be specified inside the point init file For our current library the point init file could look like declare library point basename point srfi point eval init __point_makelib set ld options string append L usr lib ld options set bigloo user lib cons 1m bigloo user lib set additional include foreign cons cpoint h additional include foreign define macro point x y make point x y This file updates some compilation variables ld options bigloo user lib additional include foreign and defines a macro point Because the point init file will be loaded each time a compilation require the point library is spawned user code are allowed to use the point macro Here is an example file making use of the point library example scm module example let p point 2 9 3 5 260 Bigloo 4 2b print point point p print point point 4 print point p print done To conclude that example here is the Makefile used to compile the point library heap file and one example 4 bigloo flags BIGLOO bigloo RELEASE BIGLOO eval begin print bigloo version exit 0 BHEAPFLAGS unsafe q mkaddheap mkaddlib v2 heap
412. the pregexp package and its documentation I also especially thank Christian Queinnec for all his useful remarks help suggestions and teaching Other people have helped me by providing useful remarks bug fixes or code improve ments I thank all of them and especially Luc Moreau John Gerard Malecki David Halls and David Gurr I thank Barrie Stott for his help in making much of the documentation more idiomatic Of course any remaining errors are still mine This release of Bigloo may still contain bugs If you notice any please forgive me and send a mail message to the following address bigloo sophia inria fr This is Bigloo documentation version 4 2b October 2015 Chapter 1 Overview of Bigloo 3 1 Overview of Bigloo Bigloo is an implementation of an extended version of the Scheme programming lan guage Without its extensions Bigloo does not entirely conform to Scheme as defined in the Revised 5 Report on on the Algorithmic Language Scheme henceforth R5RS see rbrs info The two reasons are e Bigloo produces C files C code uses the C stack so some programs can t be prop erly tail recursive Nevertheless all simple tail recursions are compiled without stack consumption e Alternatively Bigloo may produce JVM Java Virtual Machine byte code class files These classes may use regular Java classes e Bigloo is a module compiler It compiles modules into o class or obj files that must be linked tog
413. the threads started in the scheduler have terminated e await All the threads started in the scheduler are waiting for a signal An invocation of scheduler react is called a reaction 190 Bigloo 4 2b scheduler start arg scheduler Bigloo function Executes scheduler react as long as the scheduler is not done If the optional argument scheduler is not provided scheduler start uses the current scheduler see current scheduler The optional arg can either be e An integer standing for the number of times scheduler react must be called e A procedure f of one argument The procedure f is invoked after each reaction It is passed a value i which is the iteration number of the scheduler The reactions of the scheduler continue while f returns ttf let s make scheduler t instantiate fthread body lambda O let loop n 0 display n thread yield loop 1 n scheduler start 10 s 4 0123456789 let s make scheduler t instantiate fthread body lambda let loop n 0 display n thread yield loop 1 n scheduler start lambda i read char s 0123456789 scheduler terminate scheduler Bigloo function Terminates all the threads in scheduler scheduler instant scheduler Bigloo function Returns the current reaction number of scheduler The reaction number is the number of times scheduler react has been invoked passing scheduler as argument 16 2 2
414. tion of the results is long enough At each iteration the string is prefixed with count 0 bytes where count is the iteration counter string gt key salted str len hash fun salt Bigloo Cryptography procedure This function implements the salted s2k algorithm of OpenPGP RFC 2440 Similar to string gt key simple but the input string is first prefixed with salt string gt key iterated salted str len hash fun Bigloo Cryptography procedure salt count This function implements the iterated salted s2k algorithm of OpenPGP RFC 2440 The variable count must be a long This algorithm is an extension of string gt key salted where the hash function is applied repeatedly This function has changed with release 3 4b Earlier versions could be incompatible with RFC 2440 14 2 Public Key Cryptography 158 Bigloo 4 2b 14 2 1 Rivest Shamir and Adleman RSA Bigloo s implementation of RSA is based on RFC 3447 PKCS 1 v2 1 It does not feature multiprime RSA though Bigloo s implementation is not secure against timing attacks Furthermore some error codes might reveal information to attackers 14 2 1 1 RSA Keys There are two kinds of RSA keys inside Bigloo complete and partial keys A complete key contains the information of both the public and the private key together with other information that could be reconstructed out of the private key A partial key just contains the modulus and the private or public exponent RSA Key
415. to be declared in Bigloo Cigloo reads C files and generates the Bigloo extern clauses for that files 26 1 2 Importing an extern variable The lt variable clause gt denotes importation of variables lt variable clause gt gt lt typed ident gt lt c name gt macro lt typed ident gt lt string gt macro lt typed ident gt lt typed ident gt lt string gt infix macro lt typed ident gt lt typed ident gt lt string gt Only extern non macro variables are mutable that is mutable using the set con struction Bigloo does not emit extern C prototype for variables introduced by a macro clause string is the C name of variable The Scheme name of that variable is extracted from the lt typed ident gt Here is an example of variable importations module example extern c var double c var macro bufsiz long BUFSIZ print c var c var set c var 1 0 c var print c var c var print bufsize BUFSIZ 26 1 3 Importing an extern function Function are imported using the lt function clause gt lt function clause gt lt typed ident gt lt typed ident gt lt string gt lt typed ident gt lt typed ident gt lt typed ident gt lt string gt macro lt typed ident gt lt typed ident gt lt string gt macro lt typed ident gt lt typed ident gt lt typed ident gt lt string gt The function result type and Scheme name are e
416. tocol aliases get protocol number or name bigloo procedure Returns the protocol entry found in the protocols database The argument number of name is either an integer or a string Socket option socket option name bigloo procedure Socket option set socket option name val bigloo procedure These two functions get and set socket option The argument option name must be a keyword If the option name is not supported by the Bigloo runtime system the function socket option returns the value unspecified otherwise it returns the option value If the option name is not supported the function socket option set returns false Otherwise it returns a non false value Here is a list of possibly supported option name values e S0 KEEPALIVE e S0 OOBINLINE e S0 RCVBUF e S0 SNDBUF e SO_REUSEADDR 90 Bigloo 4 2b e SO_TIMEOUT e SO_SNDTIMEO e SO_RCVTIMEO e TCP_CORK e TCP_QUICKACK e TCP NODELAY The S0 KEEPALIVE option can be use to implement automatic notification of client disconnection It requires system tuning for enabling TCP keeplive support On Linux additional information may be found on the TCP Keepalive HOWTO see http tldp org HOWTO html_single TCP Keepalive HOWTO 5 7 5 SSL Bigloo allows access to SSL sockets certificates and private keys in order to build secure encrypted and or signed communications ssl version SSL library procedure Returns a string representing the SSL library version number
417. tor ref sema 0 increment vector set sema 0 n if gt n 0 condition variable broadcast vector ref sema 2 mutex unlock vector ref sema 1 let sema make semaphore 10 let t1 thread start instantiate thread body lambda O semaphore wait sema set res current time t2 thread start instantiate thread body lambda O let loop n 10 if n 0 begin semaphore signal by sema 1 thread yield loop n 1 scheduler start res 16 2 Threads Bigloo supports fair threads see Section Section 16 2 2 1 Thread page 184 a specification of cooperative threads In this framework a thread must explicitly or implicitly yield the processor to the scheduler see Section Section 16 2 2 2 Scheduler page 189 Explicit cooperation is achieved by library functions such as thread yield or thread sleep The scheduler does not preempt a running thread to allocate the processor to another waiting thread Fair threads have two drawbacks over preemptive threads Chapter 16 Threads 183 e Cooperative threads are not skilled to benefit of multi processors platforms e Single threads programs must be adapted in order to be ran concurrently On the other hand Fair threads have advantages that make them suitable for a high level programming language such as Scheme e Fair threads have a strong and well defined semantic Multi threaded programs using Fair threads are determini
418. tr mmap get char mm bigloo procedure mmap put char mmc bigloo procedure mmap get string mm len bigloo procedure mmap put string mm str bigloo procedure These functions get resp put character and strings into a memory mapped area They increment the read resp write position An error is signaled if the characters read resp writen outbound the length of the memory mapped 5 2 3 Zip port gt gzip port input port buffer t bigloo procedure port gt zlib port input port buffer t bigloo procedure port gt inflate port input port buffer 7t bigloo procedure These functions take a regular port as input input port They construct a new port that automatically unzip the read characters The inflate version does not parse a gunzip header before inflating the content Chapter 5 Standard Library open input inflate file path buffer t 67 bigloo procedure These function open a gzipped file for input The file is automatically unzipped when the characters are read It is equivalent to let p open input port path port gt gzip port p The function open input inflate file is similar to open input gzip file but it does not parse a gunzip header before inflating the content gunzip sendchars input port output port inflate sendchars input port output port bigloo procedure bigloo procedure Transmit all the characters from the gzipped input port to the output port Note
419. tring consisting of all characters sent to the port closed input port input port procedure closed output port output port procedure Predicates that return t if and if their associated port is closed Return f otherwise input port name input port bigloo procedure Returns the name of the file used to open the input port input port position port bigloo procedure output port position port bigloo procedure Returns the current position a character number in the port set input port position port pos bigloo procedure set output port position port pos bigloo procedure These functions set the file position indicator for port The new position measured in bytes is specified by pos It is an error to seek a port that cannot be changed for instance a procedure or a console port The result of these functions is unspecified An error is raised if the position cannot be changed input port reopen input port bigloo procedure This function re opens the input input port That is it reset the position in the input port to the first character read input port procedure read case case input port bigloo procedure read case sensitive input port bigloo procedure read case insensitive input port bigloo procedure Read a lisp expression The case sensitivity of read is unspecified If have to to enforce a special behavior regarding the case use read case read case sensitive or read case insensitive Let us consider
420. ts f Returns an SSL socket built from a socket obtained by make client socket see Section 5 7 4 Socket page 84 Depending on the implementation and back end the returned socket may or may not be eq to socket 92 Bigloo 4 2b make ssl server socket key port 0 name f SSL library procedure protocol sslv23 cert f pkey f CAs accepted certs f make ssl server socket returns a new server socket object which satisfies the socket predicate and which can be used in any context where a socket created by make server socket can be used see Section 5 7 4 Socket page 84 A SSL server socket opens the port port on the current host name the server and allows remote applications clients to connect to it listening on port port number of hostname If the optional argument port is not given or is 0 the server socket will use the first availailable port number If the optional argument name is given the server socket will be bound to the network interface representing the given host name If it is the default the socket will be bound on every local network interface If the protocol option argument is given it specifies the encryption protocol Accepted values are sslv2 sslv3 ss1v23 alias ss1 t1s alias t1sv1 or dtls alias dtlsvi The default value is ss1v23 The SSL socket will sign the connection using the optional arguments cert for the certificate and pkey for the private key The certi
421. tures and unions page 236 Otherwise it creates the following functions e creator make array array This function allocates memory for the array array The memory is filled with the C Null value e type checker array bool obj 0obj This function returns stt if the argument obj is of type array and f otherwise e A null checker null array bool array This function returns t if the argument obj is Null and f otherwise e Anequality checker array bool array array This function returns t if its arguments are equal and f otherwise e Accessors and mutators array ref ident array long array set obj array long ident These functions read and store field values Here is an example of a program using array types module foo extern type double array double double 10 define make vect double x y z let vect make doublex double set vect O x double set vect 1 y double set vect 2 z vect define vect norm vect double sqrt expt double ref vect 0 2 expt double ref vect 1 2 expt double ref vect 2 2 print vect norm make vect 1 2 4 5 4 5 240 Bigloo 4 2b 26 1 6 6 C functions C function types are introduced by the lt function type gt clause lt function type gt function ident ident Let us suppose the array type declaration type fun function res arg Bigloo creates the foll
422. type That is e s8vector signed exact integer in the range 277 to 277 1 e u8vector unsigned exact integer in the range 0 to 278 1 e sl6vector signed exact integer in the range 2715 to 2715 1 e ul6vector unsigned exact integer in the range 0 to 2716 1 e s32vector signed exact integer in the range 2 31 to 2731 1 e u32vector unsigned exact integer in the range 0 to 2732 1 e s64vector signed exact integer in the range 2 63 to 2763 1 e u64vector unsigned exact integer in the range 0 to 2764 1 f32vector inexact small real Chapter 5 Standard Library 49 e 64vector inexact largest real Each homogeneous vector datatype has an external representation which is supported by the read and write procedures and by the program parser Each datatype also has a set of associated predefined procedures analogous to those available for Scheme s heterogeneous vectors As noted by Marc Feeley s specification for each value of TAG in s8 u8 s16 u16 s32 u32 s64 u64 f32 f64 if the datatype TAGvector is supported then e the external representation of instances of the datatype TAGvector is TAG ele ments For example u8 0 e1e2 xff is an u8vector of length 3 containing 0 100 and 255 64 1 5 is an f64vector of length 1 containing 1 5 Note that the syntax for float vectors conflicts with Standard Scheme which parses 41320 as 3 objects f 32 and O For this reason conformance to th
423. ue bind h s v rgb gt hsv 255 0 0 list h s v 0 100 100 Chapter 19 Mail 209 19 Mail Bigloo provides various facilities for handling mails It provides facilities for parsing many formats commonly used in composing mails quoted printable vcard mime types It also provides facilities for dealing with mail servers For that it proposes an abstracted view of mail servers with two implementations imap and maildir 19 1 RFC 2045 MIME Part one This section described the functions offered by Bigloo to encode and decode some of the formats specified in the RFC 2045 http tools ietf org html rfc2045 quoted printable encode string Bigloo Mail procedure quoted printable decode string Bigloo Mail procedure These functions encode decode a string into and from the quoted printable format Examples quoted printable encode foo bar gt foobar 20 quoted printable decode foobar 20 gt foo bar quoted printable encode port ip op Bigloo Mail procedure quoted printable decode port ip op rfc2047 Bigloo Mail procedure These functions are similar to quoted printable encode and quoted printable decode except that they operate on input ports and output ports The function quoted printable decode port accepts an optional argument r c2047 If this argument is t then the parsing stops on the prefix which is a marker in the mail subject as specified by the RFC 2047 see http tools ietf org html rf
424. ule clause Stop after the ast construction stage Stop after checking syntax Stop after the bdb obj spread stage Stop after the trace pass Stop after the callcc pass Stop after the bivaluation stage Stop after the inlining stage Stop after the 2nd inlining stage Stop after the constant beta reduction stage Stop after the failure replacement stage Stop after the array bound checking stage Stop after the type initflow stage Stop after the scope narrowing stage Stop after the type lifting stage Stop after the type dataflow stage Stop after the second type dataflow stage Stop after the third type dataflow stage Stop after the fuse stage Chapter 31 Compiler description user coerce effect effect reduce reduce reduce assert cfa closure recovery bdb cnst integrate tailc init classgen egen hgen cgen indent jvmas Constant initialization init lib read intern init object legacy staged Bootstrap and setup mklib mkaddlib mkheap mkaddheap mkdistrib license LICENSE heap NAME heap library LIB dump heap NAME addheap NAME fread internal fread internal src 279 Stop after the user pass Stop after the type coercing stage Stop after the effect stage Stop after the 2nd effect stage Stop after the reduction opt stage Stop after the 2nd reduction opt stage Stop after the very first reduction stage Stop after the assertions stage Stop after the cfa stage Stop after
425. ules are initialized before user modules and imported modules are initialized in the same order as they appear in import clauses Here is a first example with two modules First the module foo module foo module foo main main import bar bar scm define main argv print argv argv print foo Then the module bar 14 Bigloo 4 2b module bar module bar print bar These can be compiled into the executable a out with bigloo c foo scm bigloo c bar scm bigloo foo o bar o Execution of a out produces a out 4 bar foo argv a out The explanation is e module foo contains the program entry point so this is where initialization begins e because foo imports module bar bar must be initialized before foo This explains why the word bar is printed before anything else e module initialization for foo is completed before main is called This explains why word foo is printed before main is entered Let s consider another example with 3 modules modulel module modulei main main import module2 module2 scm define main argv print argv argv print modulei The second module module2 module module2 import module3 module3 scm print module2 The third module module3 module module3 import module1 modulei scm print module3 Compile with bigloo modulei scm c bigloo module2 scm c bigloo module3 scm c bigloo
426. umbers separated by three dots with each number between 0 and 255 We will use the commenting mechanism to build the final regexp with clarity First a subregexp n0 255 that matches 0 through 255 define n0 255 x d 0 through 9 d d 00 through 99 01 d d 000 through 199 2 0 4 d_ 200 through 249 25 0 5 250 through 255 150 Bigloo 4 2b The first two alternates simply get all single and double digit numbers Since 0 padding is allowed we need to match both 1 and 01 We need to be careful when getting 3 digit numbers since numbers above 255 must be excluded So we fashion alternates to get 000 through 199 then 200 through 249 and finally 250 through 255 An IP address is a string that consists of four n0 255s with three dots separating them define ip rel string append uo nothing before n0 255 the first n0 255 x then the subpattern of IN a dot followed by n0 255 an n0 255 jn which is 3 repeated exactly 3 times with nothing following Let s try it out pregexp match ip rel 1 2 3 4 gt 1 2 3 4 pregexp match ip rel 55 155 255 265 gt sf which is fine except that we also have pregexp match ip rei 0 00 000 00 gt 0 00 000 00 All zero sequences are not valid IP addresses Lookahead to the rescue Before starting to match ip rei we look ahead to ensure we don t have all zeros We could use positive lookahead to ensure there is a digit
427. ure Adds or modifies the global environment variable string so that it is bound to val after the call This facility is not supported by all back end In particular the JVM back end does not support it date bigloo procedure Returns the current date in a string See also Section 5 8 Date page 93 76 Bigloo 4 2b sleep micros bigloo procedure Sleeps for a delay during at least micros microseconds command line bigloo procedure Returns a list of strings which are the Unix command line arguments executable name bigloo procedure Returns the name of the running executable os class bigloo procedure Gives the OS class e g unix os name bigloo procedure Gives the OS name e g Linux os arch bigloo procedure Gives the host architecture e g 1386 os version bigloo procedure Gives the operating system version e g RedHat 2 0 27 os tmp bigloo procedure Gives the regular temporary directory e g tmp os charset bigloo procedure Gives the charset used for encoding names of the file system e g UTF 8 file separator bigloo procedure Gives the operating system file separator e g path separator bigloo procedure Gives the operating system file path separator e g For additional functions such as directory list see Section 5 2 Input and Output page 53 unix path gt list bigloo procedure Converts a Unix path to a Bigloo list of
428. ure sha256sum mmap mmap bigloo procedure sha256sum file string bigloo procedure sha256sum port input port bigloo procedure Computes SHA256 message digest The function sha256sum dispatches over its argument and invokes the ad hoc function That is it invokes sha256sum string if its argument is a string sha256sum mmap if it is a mmap sha256sum port if its argument is an input port hmac sha256sum string key string bigloo procedure Computes the Hmac SHA256 authentication 5 10 Cyclic Redundancy Check CRC Bigloo provides several known cyclic redundancy checks as well as means to create custom checks Usually CRCs are executed starting with the leftmost bit inside a byte big endian However especially for serial port transmissions a scheme where the least significant bit is processed first is desirable Bigloo s CRC procedures accept a key parameter big endian by default t which allows to change this behavior The following CRCs given with the associated polynomial are provided e itu 4 0x3 e epc 5 0x9 e itu 5 0x15 e usb 5 0x5 e itu 6 0x3 e 7 0x9 e atm 8 0x7 e ccitt 8 0x8d e dallas maxim 8 0x31 e 8 0xd5 e sae j1850 8 Oxld e 10 0x233 e 11 0x385 e 12 Ox80f e can 15 0x4599 e ccitt 16 0x1021 e dnp 16 0x3d65 e ibm 16 0x8005 98 Bigloo 4 2b 24 Ox5d6dcb radix 64 24 0x864cfb 30 0x2030b9cf ieee 32 Ox4clldb7 c 32 Oxledc6f41 k 32 0x741b8cd7 q 32 0x814141ab is
429. val sSt i oooooooccoocococoo ooo 267 register exit function 6 75 register opaque serialization 69 register procedure serialization 69 register process serialization 69 Regular analyser oooooooocooocmmmrmo 125 Regular expressions 0 00 0005 139 Regular parsing 0 eee eee eee 125 regular grammar es m ais aa eee eens 125 relative file name sess 79 remainders lira ada 35 remainderelong 2i ii uus 35 remainderfl cce XI VAM ta 35 remainderllong itii e dex 9e i gea ew 35 tempropl 3i seco sp setate rer mettait de 31 Tomo shatter setae ele hee aM eise 28 11 Pe Ra EE PEE SER OE 28 tename file Naa canis patos PIRE 80 LEP esc cod 221 reset output port ees 63 reverse verb id 27 A A RR IE edd 27 revised 5 macro expansion 227 revision control ooooocoocororrcommmomo 302 ric2047 decode cece eee eee eee 210 rfc2047 decode port 0000 210 rfc2822 address display name 211 rfc2822 date date 2 eee 95 rfc2822 parse date jc sci deine D 95 EEG 2045 i di xr eee debe 209 REC2426 ti 210 HEG 2822 xut fes enun Y t ire Sete Hd 211 RPBG 3501L sitis serere MM bU TA cae ees a 212 TED HSI ra f eA ii 208 Igb hSvzoisvelcissR Vw Pharr acc elated bene 208 TECH context aii a X DEI VASOS 131 A A m as 35 roundfb a e uou exec o r
430. value int Chapter 5 Standard Library minvalfx maxvalfx minvalelong maxvalelong minvalllong maxvalllong Returns the minimal value respectively the maximal value for fix integers exact z inexact z zero z positive z negative z odd n even n zerofx z positivefx z negativefx z oddfx n evenfx n zerofl z positivefl z negativefl z oddfl n evenfl n zeroelong z positiveelong negativeelong oddelong n evenelong n zerollong z positivellong negativellong oddllong n evenllong n zerobx z positivebx z negativebx z oddbx n evenbx n min x1 x2 max xl x2 minfx xl x2 maxfx xl x2 minfl xl x2 maxfl xl x2 N N N N 33 bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure bigloo procedure procedure procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure library procedure bigloo procedure bigl
431. variables and functions to the evaluator e possibly C header files e possibly an initialization file Let s consider for example a library that implements the format Common Lisp facility Let s suppose we name this library bformat and that the library number is 1 0 Using a Unix machine the Bigloo library will consist of the following files e bformat heap the heap file e bformat init the initialization file e libbformat s 1 0 a libbformat s 1 0 so libbformat u 1 0 a libbformat u 1 0 so libbformat eu 1 0 so and libbformat es 1 0 s0o the Unix library files The file names with a _u are libraries compiled in unsafe and optimized mode By convention the library using the s suffix are safe libraries _p are profiling libraries _d debug libraries _es and eu eval libraries e bformat h an include file 28 1 Compiling and linking with a library From the user standpoint using a library can be made two ways e Using the Bigloo library lib name option where lib name is the name of the Bigloo library not the name of one of the Unix files implementing the library The name of the library must be lower case For instance bigloo foo scm library bformat e Using the module clause library This second solution avoids using a special compi lation option For instance this module will automatically compile and link with the bformat library module foo library bformat format When a Bigloo library
432. ve Relative or absolute path names for libraries default t ld style Id style default gcc lib dir The lib dir path default home serrano prgm project bigloo lib bigloo 4 2b ib mode Lib mode compilation Chapter 31 Compiler description 287 default f lib sre dir The lib dir path default runtime load path The load path default home serrano prgm project bigloo lib bigloo 4 2b max c foreign arity Max C function arity default 16 max c token length Max C token length default 1024 mco include path Module checksum C include path default mco suffix Module checksum object legal suffixes default mco module checksum object Produce a module checksum object mco default f multi threaded gc Are we using a multi threaded GC default f o files The additional obect files default Fobj suffix Object legal suffixes default o a so object init mode Object initialization mode default stagged Foptim Optimization level default 0 optim O macro Enable optimization by macro expansion default f optim atom inlining Skip atom in inlining parameter counting default t optim cfa apply tracking Track values across apply default f optim cfa fixnum arithmetic 288 Bigloo 4 2b Enable refined fixnum arithmetic specialization default f Foptim cfa flonum arithmetic Enable re
433. version the version number of the library This defaults to the Bigloo version number e basename the base of the filename containing the library This defaults to the library name e srfi a list of symbols denoting the SRFI 0 features implemented by this library Registered SRFIs may be tested by the cond expand form see Chapter 30 SR FIs page 265 This defaults to an empty list e dlopen init a function to be invoked when the library is dynamically loaded using the function dynamic load This defaults to f e module init a module to be initialized when the library is loaded This defaults to e eval init a module to be initialized for binding the library exports in the interpreter This defaults to f e class init the JVM or NET class name containing the module to be initial ized This defaults to f e eval init the JVM or NET class name containing the module to be initialized for eval This defaults to f e init a function to be invoked when a library is loaded This defaults to f e eval a function to be invoked when a library is loaded by the interpreter This defaults to 3f e eval a function to be invoked when a library is loaded by the interpreter This defaults to Examples e The following declares a library named foo When loaded the Bigloo runtime system will seek file named libfoo_s 3 4a so libfoo u 3 4a so libfoo_ es 3 4a so and libfoo_eu 3 4a so declare library foo Chapter 28
434. with the jvm option However the jvm option MUST be the first compiler option on the command line In order to prevent the compiler to produce a script shell file to run the program it is required to use simultaneously the jvm and c options 27 1 2 Compiling multi modules applications In order to compile and link multi modules applications it is required to specify the as sociation between Scheme source modules and Java qualified type names This task is generally complex because of the annoying mapping that exists from Java class names and the operating file system names In order to get rid of this problem the Bigloo standard dis tribution contains a tool jfile that automatically produces Bigloo Module Java classes association files The default name for such a table is jfile When compiling a module Bigloo checks if a jfile exists in the current directory if it exists the file is read The compilation option jfile may be used to specify an alternative jfile name Example cat gt foo scm module foo export foo define foo foo cat gt bar scm module bar export bar define bar bar cat gt hux scm module hux export hux define hux hux cat gt main scm module main main main import foo bar hux define main argv print foo print bar print fhux afile scm gt afile jfile scm gt jfile 246 Bigloo 4 2b bigloo jvm c foo scm bigloo jvm
435. word key bigloo procedure Removes the value associated with key in the symbol or keyword s property list The result is unspecified Here is an example of properties handling getprop a sym a key gt f putprop a sym a key 24 getprop a sym a key gt 24 putprop a sym a key2 25 getprop a sym a key gt 24 getprop a sym a key2 gt 25 symbol plist a sym gt a key2 25 a key 24 remprop a sym a key symbol plist a sym a key2 25 putprop a sym a key2 16 symbol plist a sym a key2 16 32 Bigloo 4 2b 5 1 5 Keywords Keywords constitute an extension to Scheme required by Dsssl Dsssl96 Keywords syntax is either lt ident gt or lt ident gt Keywords are autoquote and case sensitive So eq toto TOTO gt f The colon character does not belong to they keyword Hence eq toto toto gt tt keyword obj bigloo procedure keyword gt string keyword bigloo procedure string gt keyword string bigloo procedure keyword gt symbol keyword bigloo procedure symbol gt keyword symbol bigloo procedure 5 1 6 Numbers Bigloo has only three kinds of numbers fixnum long fixnum and flonum Operations on complexes and rationals are not implemented but for compatibility purposes the functions complex and rational exist In fact complex is the same as number and rational is the same as real in Bigloo The accepted prefixes are stb 0 std tx
436. write pem key accepts output ports and strings as out parameter If out is a string it will delegate to write pem key file 14 3 OpenPGP Bigloo implements parts of OpenPGP RFC 2440 RFC 4880 All OpenPGP functions are accessible via the openpgp library Here is an example of a module that uses this library Encrypt a string using openpgp default encryption module pgp encrypt library openpgp main main define main argv when and pair cdr argv pair cddr argv let encrypt string e cadr argv passwd caddr argv input read string if encrypt display pgp write string pgp encrypt input O no public keys list passwd let composition pgp read string input display pgp decrypt composition passkey provider lambda passwd pgp read string str Bigloo OpenPGP procedure pgp read port iport Bigloo OpenPGP procedure pgp read file file name Bigloo OpenPGP procedure These functions read and decode PGP data OpenPGP allows several keys to be stored in the same message Therefore pgp read will return keys always in a list even if the message only contains one key The return value is either a list of PGP compositions PGP Keys or a single PGP composition Pgp write string composition format armored Bigloo OpenPGP procedure Pgp write port oport composition format armored Bigloo OpenPGP procedure 164 Bigloo 4 2b pgp write file file name compo
437. xt string The text string is treated as raw text and not as a pattern Most of the characters in a regexp pattern are meant to match occurrences of themselves in the text string Thus the pattern abc matches a string that contains the characters a b c in succession In the regexp pattern some characters act as metacharacters and some character se quences act as metasequences That is they specify something other than their literal selves For example in the pattern a c the characters a and c do stand for themselves but the metacharacter can match any character other than newline Therefore the pattern a c matches an a followed by any character followed by a c If we needed to match the character itself we escape it ie precede it with a backslash NX The character sequence is thus a metasequence since it doesn t match itself but rather just So to match a followed by a literal followed by c we use the regexp pattern aN c Another example of a metasequence is t which is a readable way to represent the tab character We will call the string representation of a regexp the U regezp where U can be taken to mean Uniz style or universal because this notation for regexps is universally familiar Our implementation uses an intermediate tree like representation called the S regexp where can stand for Scheme symbolic or s expression S regexps are more verbose and less readable than U regexps but they are mu
438. xtracted from the lt typed ident gt the lt typed ident gt denotes the type of the function arguments and lt string gt is the C name of the function Bigloo does not produce C extern prototype for macro functions those introduced by macro clauses If the typed identifier of the function does not contain any type information Bigloo will emit a warning message when compiling and it will use a default C type e g the int C type as the return type of the function module example extern macro prn int string long printf let n read prn fib 4d Z d n n fib n 26 1 4 Including an extern file C files can be included in the C code produced by using lt include clause gt lt include clause gt include lt string gt Chapter 26 The C interface 235 26 1 5 Exporting a Scheme variable A Scheme variable or function can be exported to the foreign world if and only if it is also exported using an export clause Type information is given in the Scheme exportation thus the only requirement for a variable to be extern exported is to be given a foreign name The foreign lt export clause gt does this lt export clause gt gt export ident lt string gt Here is an example of exportation module example export fib long long extern export fib scheme_fib define fib x if x 2 1 26 1 6 Defining an extern type New Bigloo types can be defined using exter
439. y z let vect make doublex 3 double set vect O x double set vect 1 y double set vect 2 z vect define vect norm vect double sqrt expt double ref vect 0 2 expt double ref vect 1 2 expt double ref vect 2 2 print vect norm make vect 1 2 4 5 4 5 26 1 6 4 C null pointers It may be convenient to build C null pointers Several means can be used In particular foreign structures and pointers are provided with Null creators For other foreign types the easiest one is likely to be a pragma form For instance in order to create a null pointer to a double type one may use string ptr null string bigloo procedure void null void bigloo procedure make string ptr null bigloo procedure make void null bigloo procedure pragma double double OL These two predicates checks if there argument is the C NULL value These two constructors creates null foreign values Chapter 26 The C interface 239 26 1 6 5 C arrays C arrays are defined by the lt array type gt lt array type gt array lt ident gt lt ident gt is the name of a previously defined type Array types are similar to pointer types except that they include their size in their type definition string Let us suppose the array type declaration type array array ident If ident is the name of a structure type Bigloo automatically creates structures accessors see Section 26 1 6 2 C struc
440. yer process mpg123 musicproc Bigloo Multimedia class class mpg123 musicproc path bstring read only default mpgi23 args pair nil read only default remote A player based on the external software mpg123 mpc music Bigloo Multimedia class class mpc music hello read only default f host read only default localhost port read only default 6600 timeout read only default 10008993 prefix default f A MPC client e hello an optional string written when the connection is establish with the MPD server e prefix an optional path prefix to be removed from music playlist This is needed because MPD can only play music files registered in is private database The file names used by MPD are relative a root directory used to fill the database The prefix field allows programmer to write portable code that manages play list file names independently of the player selected musicstatus Bigloo Multimedia class class musicstatus state symbol default stop volume obj default 1 repeat bool default f random bool default f playlistid int default 1 playlistlength int default 0 xfade int default 0 song int default 0 songid int default 0 songpos default 0 songlength int default 0 bitrate int default 0 khz int default 0 err obj default f The instances of the class musicstatus denote that state of a player 20
441. ypt mmap bstring cipher plaintext mmap Bigloo Cryptography procedure password string gt key mode cfb IV 4 pad none nonce init nonce update encrypt port bstring cipher Bigloo Cryptography procedure plaintext input port password string gt key mode cfb IV f pad none nonce init nonce update 154 Bigloo 4 2b encrypt file bstring cipher filename bstring Bigloo Cryptography procedure password string key mode cfb IV 4 pad none nonce init nonce update encrypt sendchars cipher in input port Bigloo Cryptography procedure out output port password string key mode cfb IV 44f pad none nonce init nonce updatel The procedure encrypt encrypts its input using the chosen cipher The result is returned as string encrypt dispatches depending on the type of plain Strings are processed by encrypt string and not encrypt file The function encrypt sendchars reads from an input port in and encrypts its output directly into an output port out The symbol cipher can be one of e des Data Encryption Standard DES DES works on blocks of 64 bits DES requires keys of length 64 bits but only 56 of these bits are actually used Bigloo s implementation therefore accepts both DES is considered to be insecure and its usage is discouraged e des3 Triple DES Triple Data Encryption Algorithm DES3 TDEA DES3 works on blocks of 64 bits DES3 requires keys

Bigloo - Sophia Antipolis

Contents

Download Pdf Manuals

Related Search

Related Contents