- Offizieller Beitrag
Hi,
ich hatte peethebee gebeten, ein Unterforum für Lua einzurichten. Als wichtiger Bestandteil von SciTE und sehr mächtige Skriptsprache ist Lua es wert, sich näher damit zu beschäftigen.
Im Moment bin ich noch recht frisch auf diesem Gebiet. Meine Idee ist, dass ich alles, was ich mir zu Lua aneigne, parallel hier gut kommentiert poste. So können davon auch andere Interessierte profitieren.
Natürlich ist jeder, der Kenntnisse auf dem Gebiet hat oder mit erwirbt herzlich eingeladen sich hier einzubringen.
Edit 23.10.2013:
Nun ist doch "etwas" Zeit ins Land gegangen und ich bin wesentlich weiter als hier sichtbar.
Also werde ich nun endlich beginnen das hier zu vervollständigen.
1. Wie kann ich Lua in SciTE ausführen?Standardmäßig ging es bei mir nicht. Ich bin, wie folgt vorgegangen:
- Download Lua 5.1
- Installation
- lua.properties ==> Pfad anpassen (am Ende der Datei):
für "C:\Program Files\Lua\5.1\luac.exe" und "C:\Program Files\Lua\5.1\lua.exe" euren Installationspfad verwenden
SciTEUser.properties
# compatible with LuaBinaries for Lua 5.1; will work on both platforms.
#command.compile.*.lua=luac5.1 -o "$(FileName).luc" "$(FileNameExt)"
command.compile.*.lua="C:\Program Files\Lua\5.1\luac.exe" -o "$(FileName).luc" "$(FileNameExt)"
# Lua 5.1
#command.go.*.lua=lua5.1 "$(FileNameExt)"
command.go.*.lua="C:\Program Files\Lua\5.1\lua.exe" "$(FileNameExt)"
# Lua 4.0
#command.go.*.lua=Lua-4.0.exe -c -f "$(FileNameExt)"
Das war viel zu kompliziert. Die einfachere Methode ist der Zugriff auf das in SciTE eingebundene Lua.
So gehts:
In der SciTEUser.properties folgende Einträge vornehmen.
So wird mit "F5" die aktuell in SciTE geöffnete Lua-Datei ausgeführt.
2. Wo kann ich etwas zu Lua lesen?
Hilfe im Internet:
Lua für Anfänger
Lua 5.1 Reference Manual
Programming in Lua (first edition)
Einen zu AutoIt vergleichbaren Syntaxcheck kann ich mit Lua nicht durchführen, da sofort nach Fund des ersten Fehlers die Interpretation abgebrochen wird.
Ich habe ein kleines Skript geschrieben, das die aktuelle Datei in einem geschützten Prozeß lädt (nicht ausführt) und dabei auftretende Fehler (bzw. den ersten) meldet. Das gebe ich dann in die Konsole aus, wie von AutoIt bekannt:
+ [15:32:56] Syntax-Check <C:\Code_AutoIt\LUA\test.lua>
> [15:32:56] ------> OK
oder z.B.
+ [15:35:18] Syntax-Check <C:\Code_AutoIt\LUA\test.lua>
! [15:35:18] Line: 701, ERROR: unfinished string near '''
Ich habe ein Lua-Skript mit einigen SciTE-Tools erstellt, welches beim SciTE-Start geladen wird und aus dem dann u.a. der Syntax-Check aufgerufen wird.
Man sollte sinnvollerweise für die Lua-Skripte einen eigenen Ordner anlegen ausserhalb der SciTE-Installation. Der SciTE-Lua-Pfad wird bei Updates überschrieben, ist daher wenig geeignet für eigene Skripte.
Damit dieser Pfad auch überall angesprochen werden kann, empfiehlt sich in der SciTEUser.properties einen Eintrag dafür anzulegen, sieht bei mir so aus:
#~ Speicherort der Skriptdatei !! ohne abschließendem Backslash !!
Lua.User.Scripts.Path=C:\Code_AutoIt\LUA
Beim Starten von SciTE werden alle Properties in ein Array geladen. Darauf kann man in den Lua-Skripten zugreifen mit: Wert = props['Property'], für den Skriptpfad wäre das also: sPath = props["Lua.User.Scripts.Path"]
Wichtig ist: Alle gespeicherten Werte sind Strings, wenn also Zahlenwerte in Properties gespeichert sind müssen diese beim Einlesen umgewandelt werden (numValue = tonumber(props['Property']))
Um den Syntax-Check, wie gewohnt mit "Ctrl+F5" aufzurufen sind zwei Dinge erforderlich:
- Laden der Tools-Datei (Eintrag am Ende der "SciTEStartup.lua": LoadLuaFile("MySciTETools.lua", props["Lua.User.Scripts.Path"] .. "\\") )
- Eintrag in der "SciTEUser.properties":
# 36 Syntax Check Lua, if error --> selects error line and makes it visible
command.name.36.$(file.patterns.lua)=SyntaxCheck Lua
command.36.$(file.patterns.lua)=dostring MySciTETools:LuaCheck()
command.mode.36.$(file.patterns.lua)=subsystem:lua,savebefore:yes
command.shortcut.36.$(file.patterns.lua)=Ctrl+F5
MySciTETools v0.1
-- TIME_STAMP 2013-10-23 17:49:40 v 0.1
MySciTETools = {}
----------------------------------------------------------------------------------------------------
EvtUserlistTip = EventClass:new(Common)
-- Event Select Userlist (Search Variable by Tip)
function EvtUserlistTip:OnUserListSelection(_id, _str)
if _id ~= 99 then return false end
local iFirst = _str:find('[\.\.\.]') +3
local iLast = _str:find('[\.\.\.]', iFirst +1) -1
local var = _str:sub(iFirst,iLast)
editor:ReplaceSel(var)
return false
end
----------------------------------------------------------------------------------------------------
do
local LuaCheck = function()
local time = function() local tD = os.date("*t", os.time()) return string.format('%02d:%02d:%02d',tD.hour,tD.min,tD.sec) end
print("+ ["..time().."] Syntax-Check <"..props['FilePath']..">") io.flush()
local status, err = pcall(function() assert(loadfile(props['FilePath'])) end)
if status then
print("> ["..time().."] ------> OK") io.flush()
else
local filename = (props['FileNameExt']):gsub('([%(%)%.%%%+%-%*%?%[%^%$])', '%%%1') -- escape magic characters
local line, errout = err:match(filename..":(%d+):%s+(.+)")
editor:GotoLine(line -1) editor:LineEndExtend() -- go to error line, make it visible, select line
print("! ["..time().."] Line: "..line..", ERROR: "..errout) io.flush()
end
end --> LuaCheck
----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
-- Zwei verschiedene Funktionen:
--
-- VarGetTip
-- Für Variablen werden in einer separaten Region des Skripts Tipps hinterlegt:
-- #region - Variablen-Tipp
-- ; $Variable1 Das ist der Tipp für $Variable1
-- ; $Variable2 Das ist der Tipp für $Variable2
-- ; $Variable3 Das ist der Tipp für $Variable3
-- #endregion
-- oder sie werden in einer Kommentarzeile mit Tag irgendwo im Skript erstellt:
-- ;@ $Variable1 Das ist der Tipp für diese Variable
-- oder DIREKT nach Erstellung einer Variablen kann in der Folgezeile mit '-1' auf diese verwiesen werden:
-- $GuiMain = GuiCreate(...)
-- ;-1 Das ist der Kommentar zur Variable in der Zeile zuvor
--
-- oder Tipp für Funktionen:
-- In der Folgezeile nach Funktionskopzeile den Tipp hinterlegen mit
-- Func _IrgendeineFunc()
-- ;-f Tipp zu dieser Funktion\nZweite Zeile zu diesem Tipp
-- Ausgabe:
-- Funktionsname( )
-- Tipp zu dieser Funktion
-- Zweite Zeile zu diesem Tipp
--
-- Es können auch Variablen gleichen Namens mehrfach verwendet werden (in unterschiedlichen Funktionen).
-- Die Erstellung der Tipps muß dann innerhalb desselben Gültigkeitsbereiches (also in derselben Funktion oder Global) erfolgen.
-- Das Skript sucht nach Tipps für die aktuelle Variable im aktuellen Gültigkeitsbereich. Zuerst innerhalb der Funktion,
-- falls gerade der Cursor auf einer Variablen in einer Funktion steht, da bei gleichnamigen existierenden lokalen und globalen Variablen,
-- die lokale Variable eine höhere Priorität hat.
-- Es wird immer der Variablenname und der Gültigkeitsbereich ausgegeben
-- $VarBefore [ Global ]
-- Das ist ein Kommentar zu $VarBefore
-- oder
-- $iSelf [ Local: Func _TimeOver() ]
-- Das ist ein Kommentar zu $iSelf
--
-- Mehrzeilige Tipps lassen sich erstellen mit "\n" als Zeilenumbruchzeichen im Text
-- z.B.
-- ;@ $VariableXY comment1\ncomment2\ncomment3
-- Ausgabe:
-- $VariableXY
-- comment1
-- comment2
-- comment3
--
-- Datei speichern als "..\SciTE\LUA\VarGetTipp.lua"
-- oder besser in eigenem Skripte-Ordner "..\VarGetTipp.lua
--
-- In der "SciTEUser.properties" wird ein Hotkey zum Aufruf der Funktion hinterlegt
-- # 49 Variablen Tipp by BugFix
-- command.name.49.*.au3=Variablen Tipp
-- command.49.*.au3=dostring MySciTETools:VarGetTip()
-- command.mode.49.*.au3=subsystem:lua,savebefore:no
-- command.shortcut.49.*.au3=Ctrl+Alt+V
--
-- !!! Zusätzlich folgende properties-Werte erstellen !!!
-- #~ Variablentipp / Suche Variable mit Tipp
-- #~ Tipp als CallTip (1) oder Konsolenausgabe (0)
-- Variable.Tipp.CallTip.*.au3=1
-- #~ Speicherort der Lua-Skriptdateien !! Ohne abschließenden Backslash !!
-- Lua.User.Scripts.Path=C:\Code_AutoIt\LUA
-- #~ Ergebnis Variablensuche per Tipp in Userliste (1) oder Konsole (0)
-- Userlist.VarGetTip=1
--
-- - Cursor auf die Variable setzen
-- - Hotkey aufrufen
-- - Ist ein Tipp hinterlegt, wird dieser als CallTipp angezeigt oder in die Konsole ausgegeben
----------------------------------------------------------------------------------------------------
-- VarByTip ( command.48.*.au3=dostring MySciTETools:VarByTip() )
-- Sucht anhand des Begriffs in der aktuellen Editorzeile innerhalb der vorhandenen Variablentipps nach
-- Übereinstimmungen. Treffer werden in einer Userlist zur Auswahl angezeigt.
-- Die Variable des ausgewählten Treffers wird an der Position des Suchbegriffs im Editor eingefügt.
-- Alternativ können alle Variablen, in deren Beschreibung das Suchwort enthalten ist, in die Konsole ausgegeben werden.
----------------------------------------------------------------------------------------------------
local VariableGetTip = function(_param)
if props['FileExt']:upper() ~= 'AU3' then return end
local GetVarFromCursor = function()
local caret = editor.CurrentPos
if editor.StyleAt[caret] ~= 9 then if editor.StyleAt[caret-1] ~= 9 then return caret, '' end end
local iStart, iEnd, iPos, iEnd2, fBrace, sDebugAU3 = caret, caret, nil, nil, false, ''
local iLine = editor:LineFromPosition(iStart)
local iZero = editor:PositionFromLine(iLine)
local iCol = iStart - iZero
local sLine = editor:GetLine(iLine)
local sRight = Trim(sLine, iCol)
iStart = iCol
while sLine:sub(iStart,iStart):find('[$a-zA-Z0-9_]') do iStart = iStart -1 end
iEnd = iStart +1
iStart = iStart +1
while sLine:sub(iEnd,iEnd):find('[$a-zA-Z0-9_]') do sDebugAU3 = sDebugAU3..sLine:sub(iEnd,iEnd) iEnd = iEnd +1 end
return sDebugAU3, caret
end -- GetVarFromCursor()
local GetFuncFromCursor = function()
local iCaret = editor.CurrentPos
local sSel = string.char(editor.CharAt[iCaret])
if (string.byte(sSel) == 13) or (sSel == ' ') or (sSel == ',') then return nil end
local sLine = editor:GetLine(editor:LineFromPosition(iCaret))
if string.char(editor.CharAt[iCaret -1]) ~= ' ' then editor:WordLeft() end
editor:WordRightExtend()
local sCurrWord = editor:GetSelText()
editor:SetSel(iCaret, iCaret)
if sCurrWord:find('[^%w_)]') then return '' end
if sLine:find(sCurrWord..'%s*%b()') then
return sCurrWord, iCaret
else
return ''
end
end -- GetFuncFromCursor()
local Output = function(sText1, sText2)
if tonumber(props['Variable.Tipp.CallTip.*.au3']) == 1 then
if sText2 ~= nil then sText1 = sText1..'\n'..sText2:gsub('\\n', '\n') end
editor:CallTipShow(editor.CurrentPos, sText1)
else
print('!> '..sText1)
if sText2 ~= nil then print('>> '..sText2:gsub('\\n', '\n>> ')) end
end
end -- Output
local GetAllTip = function()
local tTip = {}
local s = editor:GetText()
-- in vorhergehender Zeile deklariert
for p, tip in s:gmatch('()\n[\t%s]*;%-1%s*([^\r\n]+)') do
local _, _, var = editor:GetLine(editor:LineFromPosition(p) -1):find('(%$[%w_]+)')
table.insert(tTip, {var,tip,p,'global'})
end
-- mit "at"-Tag gesetzter Tipp
for p, var, tip in s:gmatch('()\n[\t%s]*;@%s-(%$[%w_]+)%s([^\r\n]+)') do
table.insert(tTip, {var,tip,p,'global'})
end
-- in Region gesetzte Tipps
local tReg = {}
for p in s:gmatch("()#[Rr]egion %- [Vv]ariablen%-[Tt]ipp") do
table.insert(tReg, p)
end
if table.getn(tReg) > 0 then
for i=1,table.getn(tReg) do
local line = editor:LineFromPosition(tReg[i])
while not editor:GetLine(line):find('#[Ee]nd[Rr]egion') do
line = line +1
local _, _, var, tip = editor:GetLine(line):find(';%s-(%$[%w_]+)%s([^\r\n]+)')
if var then table.insert(tTip, {var,tip,tReg[i],'global'}) end
end
end
end
if sParam == 'v' then
-- Funktionstipps, nur bei Aufruf mit Parameter 'v'
for p, tip in s:gmatch('()\n[\t%s]*;%-f%s*([^\r\n]+)') do
local _, _, sFunc = editor:GetLine(editor:LineFromPosition(p) -1):find('([%w_]+)%s*%b()')
table.insert(tTip, {sFunc,tip,p,sFunc}) -- Alles OK !
end
end
return tTip
end -- GetAllTip
local GetFuncs = function() -- Ermitteln aller Funktionsdeklarationen (Startpos, Endpos, Funktionsname)
local tFuncs = {}
for iStart, sFunc in editor:GetText():gmatch('()[Ff][Uu][Nn][Cc]%s+([%w_]+)%s*%b()') do
local iLine, iEnd = editor:LineFromPosition(iStart)
while true do
iLine = iLine +1
iEnd = editor:GetLine(iLine):find('[Ee][Nn][Dd][Ff][Uu][Nn][Cc]')
if iEnd ~= nil then break end
end
table.insert(tFuncs, {iStart, editor:PositionFromLine(iLine), sFunc})
end
return tFuncs
end -- GetFuncs
if _param == 'v' then
local varCurr, varPos = GetVarFromCursor()
local fIsFuncTip = false
if varCurr == '' then
varCurr, varPos = GetFuncFromCursor()
if varCurr ~= '' then fIsFuncTip = true end
end
local tFuncs, tTip, fMatch, fMatchFunc, fInFunc, sFunc, sTip = GetFuncs(), GetAllTip(), false, false, false
local GetTip = function(_var, _scope)
_scope = _scope or 'global'
for i=1,table.getn(tTip) do
if tTip[i][1]:lower() == _var:lower() and tTip[i][4] == _scope then return tTip[i][2] end
end
return nil
end -- GetTip
if table.getn(tTip) > 0 and table.getn(tFuncs) > 0 then -- den Tipps die Funktionen zuordnen
for i=1,table.getn(tTip) do
for j=1,table.getn(tFuncs) do
if tTip[i][3] >= tFuncs[j][1] and tTip[i][3] <= tFuncs[j][2] then
tTip[i][4] = tFuncs[j][3]
break
end
end
end
end
local IsVarInFunc = function(_var, _pos)
if table.getn(tFuncs) == 0 then return false, nil end
for i=1,table.getn(tFuncs) do
if _pos >= tFuncs[i][1] and _pos <= tFuncs[i][2] then
return true, tFuncs[i][3] -- Rückgabe: True/False, Funktionsname
end
end
return false, nil
end -- IsVarInFunc
if table.getn(tTip) == 0 then
Output('Keine Tipps hinterlegt!')
else
if varCurr == '' then
Output('Cursor steht nicht auf einer Variablen\noder einem Funktionsaufruf!')
else
if not fIsFuncTip then fInFunc, sFunc = IsVarInFunc(varCurr, varPos) end
if fInFunc then
sTip = GetTip(varCurr, sFunc)
if sTip ~= nil then
Output(varCurr..' [ Local: Func '..sFunc..'() ]', sTip)
else
sTip = GetTip(varCurr, 'global')
if sTip ~= nil then
Output(varCurr..' [ Global ]', sTip)
else
Output(varCurr, 'Es ist kein Tipp hinterlegt!')
end
end
elseif fIsFuncTip then
sTip = GetTip(varCurr, varCurr)
if sTip ~= nil then
Output(varCurr..'( )', sTip)
else
Output(varCurr..'( )', 'Es ist kein Tipp hinterlegt!')
end
else
sTip = GetTip(varCurr, 'global')
if sTip ~= nil then
Output(varCurr..' [ Global ]', sTip)
else
Output(varCurr, 'Es ist kein Tipp hinterlegt!')
end
end
end
end
elseif _param == 's' then
local tTip = GetAllTip() -- {variable, tipp, position, scope}
local sWord = AutoItTools:GetWord()
local tFound, sFound, sep, iS, sTipN = {}, '', ';'
if sWord:gsub('[%s]+', '') == '' or table.getn(tTip) == 0 then return end
local fList = false
if props['Userlist.VarGetTip'] == '1' then fList = true end
local OutputGrouped = function(_fList)
local iMax, sOut, sLineEnd = 0, '', '\n'
if _fList then sLineEnd = sep end
for i=1,table.getn(tFound) do if tFound[i][2]:len() > iMax then iMax = tFound[i][2]:len() end end
for i=1,table.getn(tFound) do sOut = sOut..tFound[i][1]..'...'..tFound[i][2]..('.'):rep(iMax-tFound[i][2]:len()+3)..tFound[i][3]..sLineEnd end
return sOut
end
local SelectCurrentWord = function()
local iCaret = editor.CurrentPos
local iLine = editor:LineFromPosition(iCaret)
local iLine1stPos = editor:PositionFromLine(iLine)
local iDiffPos = iCaret - iLine1stPos +1
local sLine = editor:GetLine(iLine)
local sWord = props["CurrentWord"]
if sWord == '' then return end
local s, p = sLine:find(sWord)
local tMatch = {}
while s ~= nil do
table.insert(tMatch, {s,p})
s, p = sLine:find(sWord, s+1)
end
if table.getn(tMatch) > 0 then
for i=1, table.getn(tMatch) do
if iDiffPos >= tMatch[i][1] and iDiffPos <= tMatch[i][2] then
editor:SetSel(iLine1stPos-1 +tMatch[i][1], iLine1stPos +tMatch[i][2])
break
end
end
end
end
for i=1,table.getn(tTip) do
iS = tTip[i][2]:lower():find(sWord:lower())
if iS then
sTipN = tTip[i][2]:gsub('\\n', ' \[LINEBREAK\] ')
table.insert(tFound, {tTip[i][4], tTip[i][1], sTipN})
end
end
if table.getn(tFound) > 0 then sFound = OutputGrouped(fList) else sFound = 'Kein Tipp mit diesem Begriff vorhanden.' end
SelectCurrentWord()
if not fList then print(sFound) editor:ReplaceSel('') return end
editor.AutoCSeparator = string.byte(sep)
editor:UserListShow(99, sFound)
editor.AutoCSeparator = string.byte(' ')
end
end --> VariableGetTip
local VarGetTip = function() VariableGetTip('v') end
local VarByTip = function() VariableGetTip('s') end
----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
-- Time
-- _part - nil (default) returns "hh:mm:ss"
-- - h / m / s returns "hh" / "mm" / "ss"
-- _number - returns h / m / s as number
----------------------------------------------------------------------------------------------------
local Time = function(_part, _number)
local datetable, retValue = os.date("*t", os.time())
if _part == nil then
return string.format('%02d:%02d:%02d', datetable.hour, datetable.min, datetable.sec)
else
if _part:lower() == 'h' then retValue = string.format('%02d', datetable.hour)
elseif _part:lower() == 'm' then retValue = string.format('%02d', datetable.min)
elseif _part:lower() == 's' then retValue = string.format('%02d', datetable.sec) end
if _number ~= nil then retValue = tonumber(retValue) end
return retValue
end
end --> Time
----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
-- Detects if char at given editor position has comment style
----------------------------------------------------------------------------------------------------
local IsComment = function(_pos)
local tComment = {1,2} if tComment[editor.StyleAt[_pos]] == nil then return false else return true end
end
----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
-- Detects if char at given editor position has white space style
----------------------------------------------------------------------------------------------------
local IsWhiteSpace = function(pos)
if editor.StyleAt[pos] == 0 then return true else return false end
end
----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
-- Creates an insensitive string (combination of upper and lower chars: "[aA][bB]")
----------------------------------------------------------------------------------------------------
local InSensitive = function(_s)
_s = _s:gsub("%a", function(_c) return string.format("[%s%s]", _c:upper(),_c:lower()) end) return _s
end
----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
-- Trim _i chars from string _s
-- Positive integer trim from left, negative from right side
-- _s String to trim
-- _i Number of chars to trim
-- _fspace "true" deletes after trimming existing space chars on trimming side
----------------------------------------------------------------------------------------------------
local Trim = function(_s, _i, _fspace)
local iLen, tPatt, iPatt = _s:len(), {'^%s*', '%s*$'}, 1 -- {leftPatt,rightPatt}
local sTrim
if _i == nil then _i = 1 end
if _i >= iLen then return '' end
if _i == 0 then return _s
elseif _i < 0 then sTrim = _s:sub(1, iLen + _i) iPatt = 2 -- trim from right
else sTrim = _s:sub(_i + 1, -1) end -- trim from left
if _fspace then sTrim = sTrim:gsub(tPatt[iPatt], '') end
return sTrim
end --> Trim
----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
--[[ Splits up a string into substrings depending on the given delimiters.
_delimiter: nil= each character will be returned as an element
........... If no delimiters were found, the full string is returned
_flag.....: nil= each character in the delimiter string will mark where to split the string
........... 1= entire delimiter string is needed to mark the split
........... 2= empty substrings are ignored (can be combined with other values)
Note......: Use only raw strings for delimiters, no pattern! To split on tab, newline, or carriage return, use
..........: their wildcards: \t = tab; \r = carriage return; \n = line feed; \r\n = carriage return/line feed
Return....: table with splitted string, count of elements (= 1 if no delimiter was found)
--]]
----------------------------------------------------------------------------------------------------
local StringSplit = function(_string, _delimiter, _flag)
local EscapeMagic = function(_delim)
if _delim:find('[%(%)%.%%%+%-%*%?%[%^%$]') then
return _delim:gsub('([%(%)%.%%%+%-%*%?%[%^%$])', '%%%1')
else return _delim end
end
local tString, tSplit, n = {}, {}, 1
_string = tostring(_string)
if _delimiter ~= nil then
_delimiter = tostring(_delimiter)
else
for k in _string:gmatch('(.)') do table.insert(tString, k) end
return tString, #tString
end
_delimiter = EscapeMagic(_delimiter)
local tPos, patt = {}, '()([' .. _delimiter .. '])'
if (_flag == 1 or _flag == 3) then
patt = '()(' .. _delimiter .. ')'
n = _delimiter:len()
end
local pLast, sLen, sub = 1, _string:len(), ''
local insEmpty = not((_flag == 2 or _flag == 3) or false)
for p in _string:gmatch(patt) do
if p > (pLast -n) then sub = _string:sub(pLast, p-1) pLast = p +n end
if (sub == '' and insEmpty) or sub ~= '' then table.insert(tSplit, sub) end
sub = ''
end
if (sLen-n) >= pLast then sub = _string:sub(pLast, sLen) end
if (sub == '' and insEmpty) or sub ~= '' then table.insert(tSplit, sub) end
return tSplit, #tSplit
end
----------------------------------------------------------------------------------------------------
-- SYNTAX
MySciTETools.LuaCheck = LuaCheck -- Modul.LuaCheck() or Modul:LuaCheck()
MySciTETools.VarGetTip = VarGetTip -- Modul.VarGetTip() or Modul:VarGetTip()
MySciTETools.VarByTip = VarByTip -- Modul.VarByTip() or Modul:VarByTip()
MySciTETools.Time = Time -- Modul.Time(parameter)
MySciTETools.IsComment = IsComment -- Modul.IsComment(pos)
MySciTETools.IsWhiteSpace = IsWhiteSpace -- Modul.IsWhiteSpace(pos)
MySciTETools.InSensitive = InSensitive -- Modul.InSensitive(string)
MySciTETools.Trim = Trim -- Modul.Trim(parameters)
MySciTETools.Split = StringSplit -- Modul.Split(parameters)
end
Alles anzeigen
Nutzung von Bibliotheken
Lua stellt zum Einbinden von Bibliotheken den Befehl "require" zur Verfügung. Einbinden lassen sich *.dll- und *.lua-Bibliotheken. Damit die Bibliotheken gefunden werden müssen sie im Startup-Skript angemeldet werden, bei mir sieht das so aus:
local sUserLua = props["Lua.User.Scripts.Path"]
LUA_USER_PATH = sUserLua .. "\\?.dll;" .. sUserLua .. "\\?\\?.dll;"
package.cpath = LUA_USER_PATH .. package.cpath
LUA_USER_LUA = sUserLua .. "\\?.lua;" .. sUserLua .. "\\?\\?.lua;"
package.path = LUA_USER_LUA .. package.path
Damit dieser Post nicht unendlich lang wird, erstelle ich weitere Themen als eigene Threads und verlinke hier.
• Bibliotheken in Lua
• Alien und VCLua für SciTE (progandy)
• Objekte in Lua