book

Beginning Lua Programming

by Kurt Jung, Aaron Brown

February 2007

Beginner

672 pages

15h 34m

English

Wrox

Read now

Unlock full access

0.1. The Facets of Lua0.1.1. Lua Is a Programming Language0.1.2. Lua Is an Implementation0.1.3. Lua Is Fast0.1.4. Lua Is Free and Open0.2. Who This Book Is For0.3. How This Book Is Structured0.4. What You Need to Use This Book0.5. Conventions0.5.1.0.5.1.1. How It Works0.6. Source Code0.7. Errata0.8. p2p.wrox.com
1.1. Choosing How to Install Lua1.1.1. Building Lua Yourself1.1.2. Selecting Prebuilt Lua1.2. Finding Your System's Shell1.2.1. Windows Shells1.2.2. Shells on Unix and Unix-Like systems1.2.3. Shell Features1.2.4. The Environment1.2.4.1. Environment Variables on Unix-Like Systems1.2.4.2. Environment Variables on Windows1.2.4.2.1. The Windows Search Path1.2.4.2.2. Recommended Settings for Windows1.3. Dealing with Tarballs and Zip Files1.4. Compiling Lua1.4.1. The Lua Source Tarball1.4.2. Compiling Lua on Linux and Other Unix-Like Systems1.4.3. Compiling Lua on Windows1.4.3.1. Building Lua with Microsoft Visual C++1.4.3.2. Building Lua with the Tiny C Compiler1.4.3.3. Building Lua with MinGW1.5. Binary Packages1.5.1. Selecting a Prebuilt Binary Package1.5.2. Installing a Prebuilt Binary Package on a Unix-Type System1.5.3. Installing a Prebuilt Binary Package on Windows1.6. Additional Tools1.6.1. Programmer's Editor1.6.2. Revision Control System1.7. Summary
2.1. Numbers and Arithmetic Operations: Basic Interpreter Usage2.1.1. Addition, Subtraction, Multiplication, Division, and Exponentiation2.1.2. Interacting with the Interpreter2.1.3. Other Notations for Numbers2.2. Interpreter Know-How2.2.1. Quitting the Interpreter2.2.2. Interpreter Shortcuts2.3. Numerical Gotchas2.3.1. Division by Zero and Overflow2.3.2. Floating-Point Rounding2.4. Variables and Assignment2.4.1. Assignment Basics2.4.2. Multiple Assignment2.4.3. Variables on the Right Side of Assignments2.5. Strings2.5.1. Quoting Strings2.5.1.1. Quoting Strings with Double Quotes2.5.1.2. Quoting Strings with Single Quotes2.5.1.3. Quoting Strings with Square Brackets2.5.2. Backslash Escaping2.6. Relational Operators and Boolean Values2.6.1. Comparing Numbers2.6.2. Comparing Strings2.7. The nil Value2.8. Boolean Operators2.8.1. The and Operator2.8.2. The or Operator2.8.3. The not Unary Operator2.9. The Concatenation, Length, and Modulo Operators2.9.1. The String Concatenation Operator2.9.2. The Length Operator2.9.3. The Modulo Operator2.9.3.1. Try It Out: Using % to Model a Clock Face2.9.3.2. How It Works2.10. Automatic Conversion of Operands2.11. Precedence and Associativity2.12. Variables and Values2.13. Comments2.14. Expressions and Statements2.15. Compound Statements2.15.1. The if Statement2.15.1.1. Try It Out: Using if to Make a Choice2.15.1.2. How It Works2.15.2. The while Loop2.15.3. The for Loop2.15.4. The repeat Loop2.15.5. The break and do Statements2.16. Summary2.17. Exercises
3.1. Return Values3.1.1. Using a Function that Returns a Value3.1.2. Defining a Function that Returns a Value3.1.3. Using return to Alter Control Flow3.1.4. Returning Nothing3.1.5. Returning Multiple Values3.1.6. Adjusting Value Lists3.1.6.1. Using Multiple-Valued Functions in Value Lists3.1.6.2. Using Valueless Functions in Value Lists3.2. Chunks as Functions3.3. Variable Scope3.3.1. Actual and Formal Arguments3.3.2. Local Variables3.4. Understanding Side Effects3.4.1. Ordering Side Effects3.4.2. Short-Circuit Evaluation3.5. Functions Calling Functions3.5.1. The Call Stack3.5.1.1. Try It Out: Use Creating Nested Function Calls3.5.1.2. How It Works3.5.2. Recursion3.5.3. Stack Overflow3.5.4. Tail Calls3.6. Functions as Values3.6.1. Replacing Built-In Functions3.6.2. Comparing and Printing Functions3.6.3. Function Definitions as Assignments3.6.4. Local Functions3.7. Whitespace, Semicolons, and Function Calls3.8. Upvalues and Closures3.8.1. Defining Functions that Create Functions3.8.2. Defining Functions with Private State3.8.3. Figuring Out Tricky Scope Situations3.9. Summary3.10. Exercises
4.1. Tables Introduced4.2. A Shorter Way to Write Some Keys4.3. Altering a Table's Contents4.4. Tables as Arrays4.5. Array Length4.6. Looping through Tables4.7. Tables of Functions4.7.1. The Table Library4.7.1.1. table.sort4.7.1.2. table.concat4.7.1.3. table.remove4.7.1.4. table.maxn4.7.2. Object-Oriented Programming with Tables4.8. Functions with Variable Numbers of Arguments4.8.1. Defining Vararg Functions4.8.2. Scripts as Vararg Functions4.9. Keyword Arguments4.10. Different but the Same4.10.1. Table Equality4.10.2. Avoiding Bugs by Understanding Mutability4.10.3. Variables and Mutable Values4.10.4. Tables and Functions4.10.5. Copying Tables4.10.5.1. Try It Out: Copying Subtables Correctly4.10.5.2. How It Works4.11. Building Other Data Structures from Tables4.12. Custom-Made Loops4.13. Global Variable Environments4.14. Summary4.15. Exercises
5.1. Basic String Conversion Functions5.2. String Length5.3. Converting Between Characters and Character Codes5.4. Formatting Strings and Numbers with string.format5.5. Input/Output5.5.1. Writing to and Reading from a File5.6. Pattern-Matching5.6.1. Searching for a Specific String5.6.2. Matching Any of Several Characters5.6.3. Matches of Varying Lengths5.6.3.1. How It Works5.6.4. Captures5.6.5. Matching Balanced Delimiters5.6.6. More on string.find, string.match, and string.gsub5.6.7. Iterating Through All Matches5.6.8. Tricks for the Tricky5.6.9. Magic Characters Chart5.7. Summary5.8. Exercises

6.1. Kinds of Errors6.1.1. Syntax Errors6.1.2. Runtime Errors6.2. Handling Errors6.2.1. Default Error Behavior6.2.2. Checking Assumptions6.2.2.1. Code Errors6.2.2.2. Data Errors6.2.2.3. The assert and error Functions6.2.2.4. Defining Your Own Error Condition6.2.3. Anticipating Error Conditions6.2.4. Working with Return Values6.2.5. Structuring Code6.2.6. Error-Containment Functions6.2.6.1. The pcall Function6.2.6.2. The xpcall Function6.2.6.3. User-Written Scripts6.3. Locating Errors6.4. Summary6.5. Exercises
7.1. Interfaces and Implementations7.2. The require Function7.3. Where to Put Modules7.3.1. Creating a Module Directory7.3.2. Setting Lua's Environment Variable7.4. Preserving a Module's Interface7.4.1.7.4.1.1. Try It Out: Extending the show Module7.4.1.2. How It Works7.5. Module Bookkeeping7.6. Bytecode7.7. Namespaces7.7.1. Creating and Reusing Namespaces7.7.2. Avoiding Global Variables7.7.2.1. Using the strict Module7.7.2.2. Reporting All Global Assignments7.8. The module Function7.9. C Modules7.10. Summary7.11. Exercises
8.1. Using Concatenation and Arithmetical Operators on Tables8.2. Relational Metamethods8.3. Indexing and Call Metamethods8.4. Non-Tables with Metamethods8.5. Non-Syntactical Metamethods8.6. Metamethod Applicability8.7. Summary8.8. Exercises
9.1. Coroutines and Program Control9.1.1. Coroutines Are Not Functions9.1.2. How Coroutines Are Like Programs9.1.2.1. Coroutines Transfer Control9.1.2.2. Wrapping a Coroutine9.1.3. Coroutines Are Cooperative9.1.3.1. Outside Looking In9.1.3.2. How It Works9.1.4. Coroutines Have Status9.1.4.1. Try It Out: Examining the Status of Coroutines9.1.4.2. How It Works9.1.5. Rules of Conduct9.1.5.1. Work Shoulder-to-Shoulder9.1.5.2. Trust the Dispatcher9.1.5.3. Expect the Best, Prepare for the Worst9.1.5.4. Play on Your Side of the Fence9.1.5.5. Avoid the Deep End9.2. Managing Concurrent Tasks9.2.1.9.2.1.1. Try It Out: Partitioning Longs Jobs with Coroutines9.2.1.2. How It Works9.3. Retaining State9.3.1. Exercising a Coroutine's Memory9.3.1.1. Try It Out: Creating a Tokenizing Coroutine9.3.1.2. How It Works9.3.2. Iterating with Coroutines9.3.2.1. Try It Out: Looping Backwards with a Coroutine Iterator9.3.2.2. How It Works9.4. Handling Events Simply9.4.1. The Event Loop9.4.1.1. Try It Out: Handling Events with Coroutines9.4.1.2. How It Works9.4.2. Yielding to Another Coroutine9.5. Summary9.6. Exercises
10.1. Bytecode and luac10.2. Garbage Collection10.3. The Implementation of Tables and Strings10.4. The Debug Library10.4.1. Inspecting and Manipulating Running Code10.4.2. Hooks10.4.3. Other Functions in the Debug Library10.5. Summary10.6. Exercises
11.1. Core Library11.1.1. Environment Functions11.1.2. Metatable Functions11.1.3. Chunk-Loading Functions11.1.4. Error-Containment Functions11.1.5. Module Functions11.1.6. The Garbage-Collection Function11.1.7. Type and Conversion Functions11.1.8. Basic Output11.1.9. Error-Condition Functions11.1.10. Table Traversal Functions11.1.11. Vararg-Related Functions11.2. Coroutine Library11.3. Package Library11.4. String Library11.4.1. Pattern-Based String Functions11.4.2. String-Conversion Functions11.5. Table Library11.6. Math Library11.6.1. Trigonometric Functions11.6.2. Inverse Trigonometric Functions11.6.3. Hyperbolic Functions11.6.4. Exponent Functions11.6.5. Logarithm Functions11.6.6. Adjustment Functions11.6.7. Floating Point Representation11.6.8. Angle Conversion Functions11.6.9. Pseudo-Random Number Functions11.6.10. Modulus Functions11.6.11. Minimum and Maximum Functions11.6.12. Constants11.7. Input/Output Library11.8. Operating System Library11.8.1. CPU Timing11.8.2. Time and Date Functions11.8.3. Filesystem Functions11.8.4. Other Operating System Functions11.9. Debugging Library11.10. Summary
12.1. Library Overview12.1.1. Dynamically Linked Libraries12.1.1.1. Resolving External References12.1.1.2. Configuration Options12.1.2. Libraries Built from Source Code12.1.2.1. Building Libraries on Unix-Like Systems12.1.2.2. Building Libraries on Windows12.1.3. Limits to Portability12.2. How Lua Interacts with Libraries12.2.1. The Variable Registration Process12.2.2. Calling a C Function from Lua12.3. The pack Binary Structuring Library12.3.1. Building the pack Library on Unix-type Systems12.3.2. Building and Installing the pack Library on Windows12.3.3. Testing the pack Library12.3.4. Installing the pack Library12.3.5. Using the pack Library12.4. The cURL File Transfer Library12.4.1. Building libcurl12.4.1.1. Building libcurl on Unix-Like Systems12.4.1.2. Building libcurl on Windows12.4.2. Building luacurl12.4.2.1. Building luacurl on Unix-Like Systems12.4.2.2. Building luacurl on Windows12.4.3. Using luacurl12.5. The gd Graphics Library12.5.1. Building gd12.5.1.1. Building gd on Unix-Like Systems12.5.1.2. Installing gd on Windows12.5.2. Building lua-gd12.5.2.1. Building lua-gd on Unix-Like Systems12.5.2.2. Building lua-gd on Windows12.5.3. Using lua-gd12.6. The SQLite Database Library12.6.1. Building SQLite312.6.1.1. Building SQLite3 on Unix-Like Systems12.6.1.2. Building SQLite3 on Windows12.6.2. Building lua-sqlite312.6.2.1. Building lua-sqlite3 on Unix-Like Systems12.6.2.2. Building lua-sqlite3 on Windows12.6.3. Using lua-sqlite312.7. Summary12.8. Exercises
13.1. How C Programs Use Lua13.1.1. Embedding Lua13.1.2. Extending Lua13.1.3. Embedding or Extending: Which Is Best?13.2. Communicating Between Lua and C13.2.1.13.2.1.1. Try It Out: Stacking Gymnastics13.2.1.2. How It Works13.3. Calling Lua from C13.3.1. Obtaining a Lua Function13.3.2. Calling a Lua Function13.3.3. Protected Calls13.4. Working with Userdata13.4.1.13.4.1.1. Try It Out: Setting the Mode of Files13.4.1.2. How It Works13.5. Indexing Values in C13.5.1. Retrieving Indexed Values13.5.2. Setting Indexed Values13.6. Retaining Values in C13.6.1. The Registry13.6.2. C Function Environments13.6.3. Upvalues in C13.6.4. Referencing Values13.6.5. The Thread Environment13.7. Layering Your Extension Library13.7.1.13.7.1.1. Try It Out: Creating a Layered-Extension Library for CSV Records13.7.1.2. How It Works13.8. Summary13.9. Exercises
14.1. Some Basic Relational Database Concepts14.2. SQL, LuaSQL, and MySQL14.2.1.14.2.1.1. Try It Out: Creating a Customers, Products, and Orders Table in MySQL14.2.1.2. How It Works14.3. Summary14.4. Exercises
15.1. A Web Server Primer15.2. Dynamic Web Content15.2.1. Embedded Web Server15.2.2. Extended Web Server15.2.3. Creating Content at Run Time with Lua15.3. Executing CGI Scripts15.3.1. CGI Scripts on Unix-Type Systems15.3.2. CGI Scripts on Windows15.4. Installing a Web Server15.4.1. Apache15.4.2. TinyWeb15.5. Testing Your Web Server with Static Content15.6. Serving Dynamic Web Content15.6.1.15.6.1.1. Try It Out: Creating a Simple Time Server15.6.1.2. How It Works15.6.2. Problems with CGI Scripts15.6.3. Asynchronous Calls to the Server15.6.4. Producing a Calendar Dynamically15.6.4.1. Try It Out: Displaying a Calendar of the Current Month15.6.4.2. How It Works15.6.5. Producing Charts Dynamically15.6.5.1. Try It Out: Creating a Simulated Report with Bar Chart15.6.5.2. How It Works15.7. Interactive CGI Applications15.7.1. CGI Helper Routines15.7.2. Developing CGI Scripts15.7.3. Security Issues15.8. The Kepler Project15.8.1. CGI the Kepler Way15.8.1.1. Try It Out: Creating a Time Server with Kepler15.8.1.2. How It Works15.8.2. Lua Pages15.8.2.1. Try It Out: Displaying the Server Time Using a Lua Page15.8.2.2. How It Works15.9. Summary15.10. Exercises
16.1. Installing LuaSocket16.1.1. Compiling LuaSocket16.1.1.1. Compiling on Linux and Other Unix-Like Systems16.1.1.2. Compiling on Windows16.1.2. Installing Windows Binaries16.2. Network Overview16.2.1. Routed Packets16.2.2. Addresses16.2.3. Domain Names16.2.3.1. Try It Out: Name and Number, Please16.2.3.2. How It Works16.2.4. Identifying Internet Resources16.2.4.1. Try It Out: Unfurling a URL16.2.4.2. How It Works16.2.5. Transport Protocols16.2.6. Sockets: Streams and Datagrams16.2.7. TCP Socket Sociology16.3. Using LuaSocket for Network Communication16.3.1.16.3.1.1. Try It Out: Creating a Simple Web Server16.3.1.2. How It Works16.4. Handling Multiple Persistent Connections16.4.1. Using Lua Coroutines with the select Function16.4.2. Multiple Connections on the Server Side16.4.3. Setting Timeout Values for the Server Socket16.5. The Application Protocols16.5.1. Filtering the Flow of Data16.5.1.1. Try It Out: Text Hydraulics16.5.1.2. How It Works16.5.2. Accessing Web Pages16.5.2.1. Try It Out: Grabbing a File16.5.2.2. How It Works16.5.3. Sending and Receiving E-mail Messages16.5.3.1. Try It Out: Getting E-mail16.5.3.2. How It Works16.6. Networking with Lua and Streams16.6.1. On the Server Side: inetd and Friends16.6.1.1. Try It Out: Creating a Stream-Based Server16.6.1.2. How It Works16.6.2. On the Client Side: ssh and Friends16.6.2.1. Try It Out: Using a Stream-Based Client16.6.2.2. How It Works16.7. Summary16.8. Exercises
17.1. Understanding Why and When to Use Lua17.2. Simple 2-D Action Game Using SDL17.2.1. Installing SDL and LuaCheia17.2.2. Using SDL17.3. Summary17.4. Exercise
18.1. Getting Started with Plua18.1.1. Obtaining Plua18.1.2. Examining the Distribution Contents18.2. Exploring Plua's Features18.2.1. Running the Plua Application18.2.2. Saving Plua Programs18.2.3. Reading the Online Documentation18.2.4. Using Palm OS Streams18.2.5. Compiling Applications18.2.6. Compiling Libraries18.3. Plua on the Mothership18.3.1. The Command-Line Compiler18.3.2. The Palm OS Emulator18.3.2.1. Obtaining the Emulator18.3.2.2. Installing on Windows18.3.2.3. Configuring POSE18.3.2.4. Running Plua in the Emulator18.3.2.5. Compiling a Program in the Emulator18.3.2.6. Exiting the Emulator18.3.3. The Palm OS Simulator18.3.3.1. Obtaining the Simulator18.3.3.2. Using the Simulator18.4. Programming with Plua18.4.1. Generating Graphics18.4.2. Programming the User Interface18.4.3. Accessing Databases18.5. Summary18.6. Exercises
19.1. The Lua Web Site19.2. The Lua Reference Manual19.3. Framing Questions19.4. The Lua Mailing List19.4.1. Viewing and Searching the Archives19.4.2. Downloading the Archives19.4.3. Using a Web Browser to Access the List19.4.4. Using a Newsreader to Access the List19.4.5. Subscribing to the List Server19.4.6. Posting Messages19.5. The Lua Chat Room19.6. Forums19.7. The Lua Wiki19.8. LuaForge19.9. Annual Workshops19.10. Summary
A.1. Chapter 2A.1.1. Exercise 1 SolutionA.1.2. Exercise 2 SolutionA.1.3. Exercise 3 SolutionA.1.4. Exercise 4 SolutionA.1.5. Exercise 5 SolutionA.2. Chapter 3A.2.1. Exercise 1 SolutionA.2.2. Exercise 2 SolutionA.2.3. Exercise 3 SolutionA.2.4. Exercise 4 SolutionA.2.5. Exercise 5 SolutionA.3. Chapter 4A.3.1. Exercise 1 SolutionA.3.2. Exercise 2 SolutionA.3.3. Exercise 3 SolutionA.3.4. Exercise 4 SolutionA.3.5. Exercise 5 SolutionA.4. Chapter 5A.4.1. Exercise 1 SolutionA.4.2. Exercise 2 SolutionA.4.3. Exercise 3 SolutionA.4.4. Exercise 4 SolutionA.4.5. Exercise 5 SolutionA.4.6. Exercise 6 SolutionA.4.7. Exercise 7 SolutionA.5. Chapter 6A.5.1. Exercise 1 SolutionA.5.2. Exercise 2 SolutionA.5.3. Exercise 3 SolutionA.6. Chapter 7A.6.1. Exercise 1 SolutionA.6.2. Exercise 2 SolutionA.7. Chapter 8A.7.1. Exercise 1 SolutionA.7.2. Exercise 2 SolutionA.8. Chapter 9A.8.1. Exercise 1 SolutionA.8.2. Exercise 2 SolutionA.8.3. Exercise 3 SolutionA.9. Chapter 10A.9.1. Exercise 1 SolutionA.9.2. Exercise 2 SolutionA.10. Chapter 12A.10.1. Exercise 1 SolutionA.10.2. Exercise 2 SolutionA.11. Chapter 13A.11.1. Exercise 1 SolutionA.11.2. Exercise 2 SolutionA.11.3. Exercise 3 SolutionA.12. Chapter 14A.12.1. Exercise 1 SolutionA.12.2. Exercise 2 SolutionA.13. Chapter 15A.13.1. Exercise 1 SolutionA.13.2. Exercise 2 SolutionA.13.3. Exercise 3 SolutionA.14. Chapter 16A.14.1. Exercise 1 SolutionA.14.2. Exercise 2 SolutionA.14.3. Exercise 3 SolutionA.15. Chapter 17A.15.1. Exercise SolutionA.16. Chapter 18A.16.1. Exercise 1 SolutionA.16.2. Exercise 2 SolutionA.16.3. Exercise 3 Solution

Content preview from Beginning Lua Programming

Chapter 6. Handling and Avoiding Errors

Program correctness matters on every count, from user acceptance and trust to the downstream consequences of program output. In this chapter, you learn about the following:

The kinds of errors that can occur in your programs
Lua's mechanisms for handling errors
Techniques to avoid program errors
Techniques to locate program errors

Along the way, you'll become familiar with Lua's I/O library, which is included in some of the examples.

Kinds of Errors

Some flaws can turn up before a program is executed. These are compile-time errors, which Lua can find as it converts your source code into executable bytecode. Often these result from simple misspellings or typing slips as you edit your source code. Other flaws are more insidious—Lua recognizes them as syntactically correct so they make their way into the executable bytecode. These errors await discovery at run time, preferably by you during testing rather than by someone who's actually using a product after it's been released with the erroneous code.

Syntax Errors

Syntax refers to the way various language elements are allowed to fit together, completely independent from the meaning of those elements. A programming language like Lua is necessarily fussy about syntax, because source code expressed in it needs to translate unambiguously to bytecode, the instructions that Lua's virtual machine can deal with. During the 1960s (the renaissance era of modern programming languages) computer science practitioners ...