Lua Language - Revision history

Archiver.of.triviality: Undo revision 7602 by Archiver.of.triviality (talk)

2025-05-11T14:56:41Z

Undo revision 7602 by Archiver.of.triviality (talk)

Archiver.of.triviality: /* Syntax */

2025-05-11T14:55:42Z

‎Syntax

Paper: /* Tables */ typo

2024-06-01T17:30:08Z

‎Tables: typo

Paper: /* Functions */ typo

2024-06-01T17:05:15Z

‎Functions: typo

Paper: /* Functions */ Bug - incorrect output

2024-06-01T17:03:08Z

‎Functions: Bug - incorrect output

Chris314 at 11:41, 27 April 2022

2022-04-27T11:41:37Z

Chris314 at 07:56, 27 April 2022

2022-04-27T07:56:14Z

Chris314 at 07:25, 27 April 2022

2022-04-27T07:25:52Z

Chris314 at 06:23, 27 April 2022

2022-04-27T06:23:43Z

Chris314 at 15:23, 26 April 2022

2022-04-26T15:23:43Z

@@ Line 12: / Line 12: @@
 CE Lua interpreter respects traditional LUA syntax and provides some extra features.
-The Lua Script Editor provide a real-time colored syntax and a Syntax Check feature ('''Ctrl+Alt+L''').
+The Lua Script Editor provide a real-time colored syntax and a Syntax Check feature ('''Ctrl+Alt+C''').
 ==Comments==

@@ Line 12: / Line 12: @@
 CE Lua interpreter respects traditional LUA syntax and provides some extra features.
-The Lua Script Editor provide a real-time colored syntax and a Syntax Check feature ('''Ctrl+Alt+C''').
+The Lua Script Editor provide a real-time colored syntax and a Syntax Check feature ('''Ctrl+Alt+L''').
 ==Comments==

@@ Line 277: / Line 277: @@
 Tab0 = {}
--- Creates an homogenous table of 3 pairs (number key/index, number value): (1,5), (2,10), and (3,20)
+-- Creates a homogenous table of 3 pairs (number key/index, number value): (1,5), (2,10), and (3,20)
 Tab1 = {5, 10, 20}
--- Creates an heterogeneous table of 3 pairs: (number 1,number 0), (number 2,string "second"), (number 3,function print)
+-- Creates a heterogeneous table of 3 pairs: (number 1,number 0), (number 2,string "second"), (number 3,function print)
 Tab2 = {0, "hours", print}
--- creates an heterogeneous table Tab3 of 3 pairs: (string 'no_space',number 8), (string 'string with spaces',boolean true), (number 12,table Tab2)
+-- creates a heterogeneous table Tab3 of 3 pairs: (string 'no_space',number 8), (string 'string with spaces',boolean true), (number 12,table Tab2)
--- Warning: the value of the 3th element is not a new copy of Tab2 but really Tab2 (Lua uses copy by reference for tables!)
+-- Warning: the value of the 3rd element is not a new copy of Tab2 but really Tab2 (Lua uses copy by reference for tables!)
 Tab3 = {no_space = 8, ['string with spaces'] = true, [12] = Tab2}

@@ Line 250: / Line 250: @@
 local MyIdx = 2
 Show(MyTab1)                         -- prints '10 20 30'
-Func1(MyTab1,MyIdx)                  -- change value of 2nd element of MyTab1 but no the value of MyIdx
+Func1(MyTab1,MyIdx)                  -- change value of 2nd element of MyTab1 but not the value of MyIdx
 Show(MyTab1)                         -- prints '20 -100 30'
-Func1(MyTab1)                        -- change value of 1st element of MyTab1 but no the value of MyIdx
+Func1(MyTab1)                        -- change value of 1st element of MyTab1 but not the value of MyIdx
 Show(MyTab1)                         -- prints '-100 -100 30'
 Show2(MyTab1)                        -- prints on 3 lines '-100' '-100' '30'

@@ Line 252: / Line 252: @@
 Func1(MyTab1,MyIdx)                  -- change value of 2nd element of MyTab1 but no the value of MyIdx
 Show(MyTab1)                         -- prints '20 -100 30'
-Func1(MyTab1,MyIdx)                  -- change value of 1st element of MyTab1 but no the value of MyIdx
+Func1(MyTab1)                        -- change value of 1st element of MyTab1 but no the value of MyIdx
 Show(MyTab1)                         -- prints '-100 -100 30'
 Show2(MyTab1)                        -- prints on 3 lines '-100' '-100' '30'

@@ Line 29: / Line 29: @@
 ==Variables, types and operators==
-In Lua variables are polymorphic (can change the type during theirs lifes). By default a variable is global at Lua Engine level unless the declaration begins with <code>local</code> modifier.
+In Lua variables are polymorphic (can change the type during theirs lifes). By default a variable is '''global''' at Lua Engine level unless the declaration begins with <code>local</code> modifier.
 Any variable can host different data types and use specific operators:
@@ Line 52: / Line 51: @@
 ** Length operator: <code>#</code> returns the integer index of the first element not equal to <code>nil</code>
 * a '''function'''
 '''Tips:'''
@@ Line 57: / Line 58: @@
 * Always use parethesis for complex expressions (the expression <code>not var1==nil or var1~=3</code> is not equal to <code>not (var1==nil or var1~=3)</code> ).
 * Use the function <code>type</code> to get a '''string''' containing the real type of a variable.
 '''Examples:'''
@@ Line 70: / Line 72: @@
 MyVar2 = (1e3 > 7.55)  -- now MyVar2 becomes a boolean equal to true
 MyVar7 = print         -- global function variable MyVar7 which can be used as an alias of print function
 </pre>

@@ Line 50: / Line 50: @@
 ** Indexing operator: <code>[ ]</code> returns the associated value of an index/key in a table
 ** Indexing operator: <code>.</code> returns the associated value of a string key in a table
-** Length operator: <code>#</code> returns the integer index of the first element not equal to nil
+** Length operator: <code>#</code> returns the integer index of the first element not equal to <code>nil</code>
 * a '''function'''
@@ Line 56: / Line 56: @@
 * Always use the right operators for the right types.
 * Always use parethesis for complex expressions (the expression <code>not var1==nil or var1~=3</code> is not equal to <code>not (var1==nil or var1~=3)</code> ).
-* Use the function <code>type</code> to get a string containing the real type of a variable.
+* Use the function <code>type</code> to get a '''string''' containing the real type of a variable.
 '''Examples:'''
@@ Line 83: / Line 83: @@
 '''Copy operations:'''
-For any copy operation like assignment, function calling arguments and function returns, Lua performs a '''''copy by value''''' (real copy) for '''nil''', '''numbers''', '''strings''', '''booleans''' types and performs a '''''copy be reference''''' (not a new copy, just pointing to the original) for '''tables''' and '''functions'''.
+For any copy operation like assignment, function calling arguments and function returns, Lua performs a '''''copy by value''''' (real copy) for '''nil''', '''numbers''', '''strings''', '''booleans''' types and performs a '''''copy by reference''''' (not a new copy, just pointing to the original) for '''tables''' and '''functions'''.
 ==Console output==
 Lua uses the <code>print</code> function to output numericals and strings to the console (use the menu to open the Lua Engine console).
-The <code>print</code> function has a variable number of arguments. Each argument (string or numerical) will be printed to the console and a new line will be added at the end. Spaces around number arguments will be smartly added. The default format for numericals is the decimal base with automatic use of decimal point if necessary.
+The <code>print</code> function has a variable number of arguments. Each argument ('''string''' or '''number''') will be printed to the console with spaces between arguments and a new line will be added at the end. The default format for '''numbers''' is the decimal base with automatic use of decimal point and/or decimal power if necessary.
 '''Examples:'''
@@ Line 174: / Line 174: @@
 end
-for i = 14, 10, -2.1 do       -- it loops for i equal to 14 and 11.8
+for i = 14, 10, -2.1 do       -- it loops for i equal to 14 and 11.9
 end
@@ Line 260: / Line 260: @@
 Tables are a very special build-in data type providing the only way to create user-defined data structures. Tables are heterogeneous associative arrays where each element is a pair of a '''key/index''' and a '''data/value'''. Data and key types can be different between elements. Lua provides automatic numeric key creation and build-in functions for access, iteration, adding etc.
-A table declaration uses <code>{ }</code> and inside elements are separated by <code>,</code> . Implicit keys/indexes are automatically generated and start with 1. Explicit keys/indexes declaration use a special syntax for each element:<code>[key]=value</code> . A key can't be <code>nil</code> nor a <code>NaN</code> number.
+A table declaration uses <code>{ }</code> and inside elements are separated by <code>,</code> . Implicit keys/indexes are automatically generated and start with 1. Explicit keys/indexes declaration uses a special syntax for each element:<code>[key]=value</code> . A key can't be <code>nil</code> nor a <code>NaN</code> number.
 '''Tables syntactic sugar:'''

@@ Line 16: / Line 16: @@
 ==Comments==
-In Lua simple comments begin with <code><nowiki>--</nowiki></code> and end at the end of line.
+In Lua simple comments begin with <code><nowiki>--</nowiki></code> and end at the end of the line.
 Multi-line comments begin with <code><nowiki>--[[</nowiki></code> and end with <code><nowiki>]]</nowiki></code> .
@@ Line 36: / Line 36: @@
 ** Comparing operators: comparing any variable to '''<code>nil</code>''' ( <code>var == nil</code> or <code>var ~= nil</code> )
 * a '''number''' value (no difference between integer or float values, nor between different precisions)
-** Binary arithmetic operators between two numbers: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>%</code> (modulo), <code>^</code> (power).
+** Binary arithmetic operators between two numbers: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>//</code> (floor division), <code>%</code> (modulo), <code>^</code> (power).
 ** Unary arithmetic operator:  <code>-</code> (example: <code>var1 = -var2</code>)
 ** Comparing operators between two numbers giving a boolean: <code>></code>, <code>>=</code>, <code><</code>, <code><=</code>, <code>==</code>, <code>~=</code>.
 * a '''boolean''' value (equal to <code>true</code> or <code>false</code>)
 ** Binary boolean operators: <code>and</code>, <code>or</code>.
@@ Line 62: / Line 63: @@
 MyVar1 = nil           -- global variable MyVar1 having nothing inside (no type neither)
 MyVar2 = UnknownVar    -- another global variable equal to nil (because UnknowVar is not yet defined)
-local MyVar3 = 2       -- local numerical variable MyVar3 equal to 2
+local MyVar3 = 2+0x10  -- local number variable MyVar3 equal to 18 (2+16)
 MyVar4 = 'Hello'       -- global string variable MyVar4
 local MyVar5 = "Hello" -- local string variable MyVar5 having the same string as MyVar3
 MyVar6 = [[First Line
 Second Line.]]         -- global multi-line string variable MyVar6 beginning with 'First' and ending with 'Line.'
-MyVar2 = (10 > 7.55)   -- now MyVar2 becomes a boolean equal to true
+MyVar2 = (1e3 > 7.55)  -- now MyVar2 becomes a boolean equal to true
 MyVar7 = print         -- global function variable MyVar7 which can be used as an alias of print function
 </pre>
 '''Automatic typecast (coercion):'''
@@ Line 81: / Line 78: @@
 * But the expression <code>'one'+9</code> is a not valid because the string <code>'one'</code> can't be automatically converted to a number.
 * The expression <code>'Waiting '..10</code> is valid and is a string because the number <code>10</code> will be automatically converted to the string <code>'10'</code> by the presence of <code>..</code> operator.
-* But the expressions <code>7..'days'</code> or <code>'Waiting '..10..' seconds'</code> are invalid because Lua needs a string as left operand of <code>..</code> operator before trying eventually to automatically convert the rigth operand.
+* But the expressions <code>7..'days'</code> or <code>'Waiting '..10..' seconds'</code> are invalid because Lua interprets the first dot <code>.</code> after <code>7</code> or <code>10</code> as a decimal separator and then it is unable to detect the concatenation operator <code>..</code>.
-* But, but, the expression <code>('Waiting '..10)..' seconds'</code> is valid! Now the sub-expression inside parenthesis is computed before trying to do the second concatenation so all is alright.
+* Solution: use spaces and parenthesis as much as you need. The following expressions are valid: <code>('Waiting '..10)..' seconds'</code> , <code>'Waiting '.. 10 ..' seconds'</code> , and <code>7 ..'days'</code> .
-* Without parenthesis, between operators with the same priority Lua begins evaluating from right to left.
 ==Console output==
@@ Line 181: / Line 181: @@
    print(MyVar)                -- prints '314' and new line
 end
-printf(MyVar)                 -- prints nothing but a new line
+print(MyVar)                  -- prints nothing but a new line
 </pre>
@@ Line 220: / Line 220: @@
 Func1=function(Tab, Idx)
    if(Idx==nil) then Idx=1 end        -- giving a default value 1
-   Tab[Idx]=-100                      -- changing a first element of List and the real calling argument table (reference not copy)
+   Tab[Idx]=-100                      -- changing Idx-th element in the real calling argument table (reference not copy)
-   Idx=33                             -- changing Idx value, no effect to the real argument, this is a copy value
+   Idx=33                             -- changing Idx value, no effect to the real argument, this is a local copy value
 end
 function Show(Tab)                   -- prints the first 3 elements of Tab, on the same line
-   print(Tab[1],Tab[2],Tab[2])
+   print(Tab[1],Tab[2],Tab[3])
 end
@@ Line 234: / Line 234: @@
 function Show3(Tab)                  -- prints all elements of Tab, one by line
    for Idx in ipairs(Tab) do          -- using the build-in iterator ipairs on input table
-     print(Tab[Idx])                  -- print value using the [] operator
+     print(Tab[Idx])                  -- prints value using the [] operator
    end
 end
@@ Line 240: / Line 240: @@
 function Show4(Tab)                  -- prints all elements of Tab, one by line
    for Idx,Val in ipairs(Tab) do      -- using the build-in iterator ipairs on input table
-     print(Val)                       -- print directly the value
+     print(Val)                       -- prints directly the value
    end
 end
@@ Line 294: / Line 294: @@
 function ShowTab(tab)
    for i,val in ipairs(tab)
-     printf('tab[',i,']=',val);
+     print('tab[',i,']=',val);
    end
 end
@@ Line 302: / Line 302: @@
 function ShowTypeTab(tab)
    for key,val in pairs(tab)
-     printf('type(tab[',key,']) =',type(val))
+     print('type(tab[',key,']) =',type(val))
    end
 end

@@ Line 36: / Line 36: @@
 ** Comparing operators: comparing any variable to '''<code>nil</code>''' ( <code>var == nil</code> or <code>var ~= nil</code> )
 * a '''number''' value (no difference between integer or float values, nor between different precisions)
-** Binary arithmetic operators between two numbers: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>.
+** Binary arithmetic operators between two numbers: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>%</code> (modulo), <code>^</code> (power).
-** Unary arithmetic operators:  <code>+</code>, <code>-</code> (example: <code>var1 = -var2</code>)
+** Unary arithmetic operator:  <code>-</code> (example: <code>var1 = -var2</code>)
-** Comparing operators between two numebers giving a boolean: <code>></code>, <code>>=</code>, <code><</code>, <code><=</code>, <code>==</code>, <code>~=</code>.
+** Comparing operators between two numbers giving a boolean: <code>></code>, <code>>=</code>, <code><</code>, <code><=</code>, <code>==</code>, <code>~=</code>.
 * a '''boolean''' value (equal to <code>true</code> or <code>false</code>)
 ** Binary boolean operators: <code>and</code>, <code>or</code>.
@@ Line 74: / Line 74: @@
 For any copy operation like assignment, function calling arguments and function returns, Lua performs a '''''copy by value''''' (real copy) for '''nil''', '''numbers''', '''strings''', '''booleans''' types and performs a '''''copy be reference''''' (not a new copy, just pointing to the original) for '''tables''' and '''functions'''.
 ==Console output==
@@ Line 322: / Line 332: @@
 <pre>
 numbs = {'One','Two','Three','Four'}
-print(table.concat(numb,' ')) -- 'One Two Three Four'
+print(table.concat(numbs,' ')) -- 'One Two Three Four'
-table.insert(nums,'Five')
+table.insert(numbs,'Five')
-print(table.concat(numb,' ')) -- 'One Two Three Four Five'
+print(table.concat(numbs,' ')) -- 'One Two Three Four Five'
-table.sort(nums)
+table.sort(numbs)
-print(table.concat(numb,' ')) -- 'Five Four One Three Two'
+print(table.concat(numbs,' ')) -- 'Five Four One Three Two'
-table.remove(nums,3)
+table.remove(numbs,3)
-print(table.concat(numb,' ')) -- 'Five Four Three Two'
+print(table.concat(numbs,' ')) -- 'Five Four Three Two'
 </pre>
@@ Line 334: / Line 344: @@
 * [https://wikipedia.org/wiki/Wikipedia:Lua wikipedia.org/wiki/Wikipedia:Lua]
 * [https://www.lua.org/ www.lua.org]
-* [http://lua-users.org/wiki/ Lua Wiki]
+* [http://lua-users.org/wiki/ Lua Users Wiki]

@@ Line 78: / Line 78: @@
 Lua uses the <code>print</code> function to output numericals and strings to the console (use the menu to open the Lua Engine console).
-The <code>print</code> function has a variable number of arguments. Each argument (string or numerical) will be printed to the console and a new line will be added at the end. Automatically a space will be added between consecutive number arguments. The default format for numericals is the decimal base with automatic use of decimal point if necessary.
+The <code>print</code> function has a variable number of arguments. Each argument (string or numerical) will be printed to the console and a new line will be added at the end. Spaces around number arguments will be smartly added. The default format for numericals is the decimal base with automatic use of decimal point if necessary.
 '''Examples:'''
@@ Line 132: / Line 132: @@
 </pre>
 Any flow control instruction can be embedded in any other flow control instruction.
@@ Line 256: / Line 257: @@
 ** Can use the point operator <code>.</code> instead of squared brackets operator <code>[ ]</code>. These make tables usage similar to structures/records/classes/namespaces in C/C++/Pascal.
 * Automatic insertion:
-** Assigning an unknown (but valid) key in a existing table will automatically create this element
+** Assigning an unknown (but valid) key in a existing table will automatically create/add this element.
 '''Examples''':
@@ Line 273: / Line 274: @@
 Tab3 = {no_space = 8, ['string with spaces'] = true, [12] = Tab2}
--- The next quasi-unreadable instruction will print '8hours'
+-- The next quasi-unreadable instruction will print '8 hours'
 Tab2[3](Tab3["no_space"],Tab3[12][2])
 -- Explanation: Tab2[3] value is print, Tab3["no_space"] is 8, Tab3[12] is Tab2 and Tab2[2] is "hours"
@@ Line 279: / Line 280: @@
 Tab3[12][1]=Tab1[2]    -- write 10 (value of 2nd element of Tab1) in the value of Tab2[1] (first element of Tab2)
 Tab3.no_space = -8     -- write -8 in the value of the first element of Tab3
-Tab3.FourthElement=3.7 -- create a 4th (new) element in Tab3 with key 'FourthElement' and value 3.7
+Tab3.FourthElement=3.7 -- create a new element in Tab3 with key 'FourthElement' and value 3.7
 </pre>
 == External links ==