[PDF] Programming in Lua, Fourth Edition PDF Programming_in_Lua%2C_4th_ed._%282017%29

presents a short but complete program in Lua, which gives a more holistic view of the language Other Resources The reference manual is a must for anyone

[PDF] Programming in Lua (first edition) - Free

To keep with the tradition, our first program in Lua just prints "Hello World": print(" Hello World") If you are using the stand-alone Lua interpreter, all you have to

[PDF] Programming in Lua - X-Files

13 jan 2010 · Programming in Lua Second Edition Roberto Ierusalimschy PUC-Rio, Brazil Lua Rio de Janeiro Property of Ian Bloss

[PDF] Programming with Multiple Paradigms in Lua - CORE

Lua is an embedded language, designed to be used inside other applications Therefore, it keeps all its state in dynamically-allocated structures, so that it does not interfere with other data from the application If a program creates multiple Lua states, each one will be completely independent of the others

[PDF] Lua Programming Gems - Luaorg

Lua Programming Gems edited by Luiz Henrique de Figueiredo Waldemar Celes Roberto Ierusalimschy Lua Rio de Janeiro 2008

[PDF] Learn Lua in X minutes

Uses of Lua • Embedded systems • internet switches, robots, keyboards ( Logitech G15), LCDs • Scripting • Metaplace, nmap, Wireshark, Snort • Programming

[PDF] Preview LUA Tutorial (PDF Version) - Tutorialspoint

Lua is an open source language built on top of C programming language Lua has its value across multiple platforms ranging from large server systems to small

[PDF] Lua Tutorialpdf

Let us now see the basic structure of Lua program, so that it will be easy for you to understand the basic building blocks of the Lua programming language Tokens

Appendix A: A Brief Summary of the Lua Programming Language

All global variables in a Lua program live as fields in Lua tables called environment tables A table field may reference another table and tables may be embedded

Programming in Lua, Fourth Edition

Roberto Ierusalimschy

Copyright © 2016, 2003 Roberto Ierusalimschy

Feisty Duck Digital

Book Distribution

www.feistyduck.com /LFHQVHGIRUWKHH[FOXVLYHXVHRI (ULF7D\ORUMGVONJMILDSJMIONVIJ#\DQGH[FRP!

About the Book ................................................................................................................. ix

I. The Basics ...................................................................................................................... 1

1. Getting Started ........................................................................................................ 4

Chunks .............................................................................................................. 4

Some Lexical Conventions ................................................................................... 6

Global Variables ................................................................................................. 7

Types and Values ................................................................................................ 7

Nil ............................................................................................................ 8

Booleans .................................................................................................... 8

The Stand-Alone Interpreter .................................................................................. 9

2. Interlude: The Eight-Queen Puzzle ............................................................................ 12

3. Numbers ............................................................................................................... 15

Numerals .......................................................................................................... 15

Arithmetic Operators .......................................................................................... 16

Relational Operators .......................................................................................... 17

The Mathematical Library ................................................................................... 18

Random-number generator .......................................................................... 18

Rounding functions .................................................................................... 18

Representation Limits ......................................................................................... 19

Conversions ...................................................................................................... 21

Precedence ....................................................................................................... 22

Lua Before Integers ........................................................................................... 22

4. Strings ................................................................................................................. 24

Literal strings .................................................................................................... 24

Long strings ..................................................................................................... 25

Coercions ......................................................................................................... 26

The String Library ............................................................................................. 27

Unicode ........................................................................................................... 29

5. Tables .................................................................................................................. 33

Table Indices .................................................................................................... 33

Table Constructors ............................................................................................. 35

Arrays, Lists, and Sequences ............................................................................... 36

Table Traversal ................................................................................................. 38

Safe Navigation ................................................................................................. 38

The Table Library ............................................................................................. 39

6. Functions .............................................................................................................. 42

Multiple Results ................................................................................................ 43

Variadic Functions ............................................................................................. 45

The function table.unpack ............................................................................ 47

Proper Tail Calls ............................................................................................... 48

7. The External World ................................................................................................ 50

The Simple I/O Model ....................................................................................... 50

The Complete I/O Model .................................................................................... 53

Other Operations on Files ................................................................................... 54

Other System Calls ............................................................................................ 55

Running system commands ......................................................................... 55

8. Filling some Gaps .................................................................................................. 57

Local Variables and Blocks ................................................................................. 57

Control Structures .............................................................................................. 58

if then else ............................................................................................... 58

while ....................................................................................................... 59

repeat ..................................................................................................... 59

Numerical for ........................................................................................... 60

Generic for .............................................................................................. 60

break, return, and goto ..................................................................................... 61

II. Real Programming ......................................................................................................... 65

9. Closures ............................................................................................................... 68

Functions as First-Class Values ............................................................................ 68

Non-Global Functions ........................................................................................ 69

Lexical Scoping ................................................................................................ 71

A Taste of Functional Programming ..................................................................... 74

10. Pattern Matching .................................................................................................. 77

The Pattern-Matching Functions ........................................................................... 77

The function string.find ...................................................................... 77 The function string.match .................................................................... 77 The function string.gsub ...................................................................... 78 The function string.gmatch .................................................................. 78

Patterns ............................................................................................................ 78

Captures ........................................................................................................... 82

Replacements .................................................................................................... 83

URL encoding .......................................................................................... 84

Tab expansion ........................................................................................... 86

Tricks of the Trade ............................................................................................ 86

11. Interlude: Most Frequent Words ............................................................................. 90

12. Date and Time ..................................................................................................... 92

The Function os.time ..................................................................................... 92

The Function os.date ..................................................................................... 93

Date-Time Manipulation .................................................................................... 95

13. Bits and Bytes ..................................................................................................... 97

Bitwise Operators .............................................................................................. 97

Unsigned Integers .............................................................................................. 97

Packing and Unpacking Binary Data ..................................................................... 99

Binary files ..................................................................................................... 101

14. Data Structures ................................................................................................... 104

Arrays ............................................................................................................ 104

Matrices and Multi-Dimensional Arrays ............................................................... 105

Linked Lists .................................................................................................... 107

Queues and Double-Ended Queues ..................................................................... 107

Reverse Tables ................................................................................................ 108

Sets and Bags ................................................................................................. 109

String Buffers .................................................................................................. 110

Graphs ........................................................................................................... 111

15. Data Files and Serialization .................................................................................. 114

Data Files ....................................................................................................... 114

Serialization .................................................................................................... 116

Saving tables without cycles ...................................................................... 118

Saving tables with cycles .......................................................................... 119

16. Compilation, Execution, and Errors ....................................................................... 122

Compilation .................................................................................................... 122

Precompiled Code ............................................................................................ 125

Errors ............................................................................................................. 126

Error Handling and Exceptions .......................................................................... 127

Error Messages and Tracebacks .......................................................................... 128

17. Modules and Packages ........................................................................................ 131

The Function require .................................................................................... 132

Renaming a module ................................................................................. 133

Path searching ......................................................................................... 133

Searchers ................................................................................................ 135

The Basic Approach for Writing Modules in Lua .................................................. 135

Submodules and Packages ................................................................................. 137

III. Lua-isms ................................................................................................................... 139

18. Iterators and the Generic for ................................................................................ 142

Iterators and Closures ....................................................................................... 142

The Semantics of the Generic for ....................................................................... 143

Stateless Iterators ............................................................................................. 145

Traversing Tables in Order ................................................................................ 146

True Iterators .................................................................................................. 147

19. Interlude: Markov Chain Algorithm ....................................................................... 149

20. Metatables and Metamethods ................................................................................ 152

Arithmetic Metamethods ................................................................................... 152

Relational Metamethods .................................................................................... 155

Library-Defined Metamethods ............................................................................ 155

Table-Access Metamethods ............................................................................... 156

The __index metamethod ....................................................................... 156 The __newindex metamethod ................................................................. 157

Tables with default values ......................................................................... 158

Tracking table accesses ............................................................................. 159

Read-only tables ...................................................................................... 160

21. Object-Oriented Programming .............................................................................. 162

Classes ........................................................................................................... 163

Inheritance ...................................................................................................... 165

Multiple Inheritance ......................................................................................... 166

Privacy ........................................................................................................... 168

The Single-Method Approach ............................................................................ 170

Dual Representation ......................................................................................... 170

22. The Environment ................................................................................................ 173

Global Variables with Dynamic Names ............................................................... 173

Global-Variable Declarations ............................................................................. 174

Non-Global Environments ................................................................................. 176

Using _ENV .................................................................................................... 177

Environments and Modules ............................................................................... 180

_ENV and load .............................................................................................. 181

23. Garbage ............................................................................................................ 183

Weak Tables ................................................................................................... 183

Memorize Functions ......................................................................................... 184

Object Attributes ............................................................................................. 185

Revisiting Tables with Default Values ................................................................. 186

Ephemeron Tables ........................................................................................... 187

Finalizers ........................................................................................................ 188

The Garbage Collector ...................................................................................... 190

Controlling the Pace of Collection ...................................................................... 191

24. Coroutines ......................................................................................................... 194

Coroutine Basics .............................................................................................. 194

Who Is the Boss? ............................................................................................ 196

Coroutines as Iterators ...................................................................................... 198

Event-Driven Programming ............................................................................... 200

25. Reflection .......................................................................................................... 205

Introspective Facilities ...................................................................................... 205

Accessing local variables .......................................................................... 207

Accessing non-local variables .................................................................... 208

Accessing other coroutines ........................................................................ 209

Hooks ............................................................................................................ 210

Profiles .......................................................................................................... 211

Sandboxing ..................................................................................................... 212

26. Interlude: Multithreading with Coroutines ............................................................... 217

IV. The C API ................................................................................................................ 221

27. An Overview of the C API .................................................................................. 223

A First Example .............................................................................................. 223

The Stack ....................................................................................................... 225

Pushing elements ..................................................................................... 226

Querying elements ................................................................................... 227

Other stack operations .............................................................................. 229

Error Handling with the C API .......................................................................... 231

Error handling in application code .............................................................. 232

Error handling in library code .................................................................... 232

Memory Allocation .......................................................................................... 233

28. Extending Your Application ................................................................................. 236

The Basics ...................................................................................................... 236

Table Manipulation .......................................................................................... 237

Some short cuts ....................................................................................... 240

Calling Lua Functions ...................................................................................... 241

A Generic Call Function ................................................................................... 242

29. Calling C from Lua ............................................................................................ 247

C Functions .................................................................................................... 247

Continuations .................................................................................................. 249

C Modules ...................................................................................................... 251

30. Techniques for Writing C Functions ...................................................................... 254

Array Manipulation .......................................................................................... 254

String Manipulation .......................................................................................... 255

Storing State in C Functions .............................................................................. 258

The registry ............................................................................................ 258

Upvalues ................................................................................................ 260

Shared upvalues ....................................................................................... 263

31. User-Defined Types in C ..................................................................................... 265

Userdata ......................................................................................................... 265

Metatables ...................................................................................................... 268

Object-Oriented Access ..................................................................................... 270

Array Access .................................................................................................. 271

Light Userdata ................................................................................................. 272

32. Managing Resources ........................................................................................... 274

A Directory Iterator .......................................................................................... 274

An XML Parser ............................................................................................... 277

33. Threads and States .............................................................................................. 286

Multiple Threads ............................................................................................. 286

Lua States ...................................................................................................... 289

List of Figures

2.1. The eight-queen program .............................................................................................. 13

7.1. A program to sort a file ............................................................................................... 52

8.1. An example of a state machine with goto ........................................................................ 62

8.2. A maze game ............................................................................................................. 63

8.3. A strange (and invalid) use of a goto .............................................................................. 64

9.1. Union, intersection, and difference of regions ................................................................... 75

9.2. Drawing a region in a PBM file ..................................................................................... 75

11.1. Word-frequency program ............................................................................................ 91

12.1. Directives for function os.date ................................................................................. 94

13.1. Unsigned division ...................................................................................................... 98

13.2. Dumping the dump program ...................................................................................... 102

14.1. Multiplication of sparse matrices ................................................................................ 106

14.2. A double-ended queue .............................................................................................. 108

quotesdbs_dbs12.pdfusesText_18

[PDF] [PDF] Programming in Lua, Fourth Edition