mirror of
https://git.huckle.dev/Huckles-Minecraft-Archive/jpexs-decompiler.git
synced 2026-06-12 06:34:55 +00:00
Updated Dutch translation by Jaap Kramer
This commit is contained in:
Jindra Petřík
@@ -18,7 +18,7 @@ decompilationError.timeout = Timeout ({0}) werd bereikt
|
||||
decompilationError.timeout.description = Niet gedecompileerd vanwege timeout
|
||||
decompilationError.obfuscated = Code kan worden geobfusceerd
|
||||
decompilationError.errorType = Fout type
|
||||
decompilationError.error.description = Niet gedecompileerd gevolg van een fout
|
||||
decompilationError.error.description = Niet gedecompileerd vanwege een fout
|
||||
decompilationError.actionCount = Aantal acties:
|
||||
decompilationError.instructionCount = Aantal instructies:
|
||||
|
||||
|
||||
@@ -0,0 +1,630 @@
|
||||
#String for whole list generation
|
||||
ui.list.heading = Actie lijst
|
||||
ui.list.pageTitle = Actie lijst
|
||||
ui.list.documentTitle = Actie lijst
|
||||
ui.list.pageDescription = Lijst met alle bekende acties met hun operands en stapelwaarden
|
||||
#various strings in UI:
|
||||
ui.unknown = ???
|
||||
ui.stack = Stack:
|
||||
ui.stack.before = ...,
|
||||
ui.stack.before.empty = ...
|
||||
ui.stack.to = \ \u279e
|
||||
ui.flags = Vlaggen:
|
||||
ui.description = Beschrijving:
|
||||
ui.filter.hide = Verbergen:
|
||||
ui.filter.byname = Zoek op naam:
|
||||
ui.filter.order = Sorteren op:
|
||||
ui.filter.order.code = code
|
||||
ui.filter.order.name = naam
|
||||
ui.swfVersion = Sinds SWF-versie:
|
||||
#----------------------- Actions
|
||||
action.gotoframe.name = Ga naar frame
|
||||
action.gotoframe.code = 0x81
|
||||
action.gotoframe.swfVersion = 3
|
||||
action.gotoframe.shortDescription = Ga naar frame
|
||||
action.gotoframe.operands = frame:UI16
|
||||
action.geturl.name = GetURL
|
||||
action.geturl.code = 0x83
|
||||
action.geturl.swfVersion = 3
|
||||
action.geturl.shortDescription = Haal URL op
|
||||
action.geturl.stackBefore =
|
||||
action.geturl.operands = urlString:STRING, doelString:STRING
|
||||
action.nextframe.name = VolgendeFrame
|
||||
action.nextframe.code = 0x04
|
||||
action.nextframe.swfVersion = 3
|
||||
action.nextframe.shortDescription = Ga naar volgende frame
|
||||
action.nextframe.description =
|
||||
action.prevframe.name = VorigeFrame
|
||||
action.prevframe.code = 0x05
|
||||
action.prevframe.swfVersion = 3
|
||||
action.prevframe.shortDescription = Ga naar vorige frame
|
||||
action.prevframe.description =
|
||||
action.play.name = Afspelen
|
||||
action.play.code = 0x06
|
||||
action.play.swfVersion = 3
|
||||
action.play.shortDescription = Afspelen
|
||||
action.play.description = Begin met spelen op het huidige frame
|
||||
action.stop.name = Stop
|
||||
action.stop.code = 0x07
|
||||
action.stop.swfVersion = 3
|
||||
action.stop.shortDescription = Stop
|
||||
action.stop.description = Stop met spelen bij het huidige frame
|
||||
action.togglequality.name = SchakelKwaliteit
|
||||
action.togglequality.code = 0x08
|
||||
action.togglequality.swfVersion = 3
|
||||
action.togglequality.shortDescription = Schakelkwaliteit
|
||||
action.togglequality.description = Schakelt de weergavekwaliteit tussen hoog en laag
|
||||
action.stopsounds.name = StopGeluiden
|
||||
action.stopsounds.code = 0x09
|
||||
action.stopsounds.swfVersion = 3
|
||||
action.stopsounds.shortDescription = Stop geluiden
|
||||
action.stopsounds.description = Stop met het afspelen van alle geluiden
|
||||
action.waitforframe.name = WachtOpFrame
|
||||
action.waitforframe.code = 0x8A
|
||||
action.waitforframe.swfVersion = 3
|
||||
action.waitforframe.shortDescription = Wacht op frame
|
||||
action.waitforframe.description =
|
||||
action.waitforframe.operands = frame:UI16, overslaanAantal:UI8
|
||||
action.settarget.name = BepaalDoel
|
||||
action.settarget.code = 0x8B
|
||||
action.settarget.swfVersion = 3
|
||||
action.settarget.shortDescription = Bepaal doel
|
||||
action.settarget.description = Verandert de context van daaropvolgende acties
|
||||
action.settarget.operands = doelNaam:STRING
|
||||
action.gotolabel.name = GaNaarLabel
|
||||
action.gotolabel.code = 0x8C
|
||||
action.gotolabel.swfVersion = 3
|
||||
action.gotolabel.shortDescription = Ga naar label
|
||||
action.gotolabel.description = Ga naar het frame dat aan het opgegeven label is gekoppeld
|
||||
action.gotolabel.stackAfter =
|
||||
action.gotolabel.operands = label:STRING
|
||||
action.push.name = Push
|
||||
action.push.code = 0x96
|
||||
action.push.swfVersion = 4
|
||||
action.push.shortDescription = Push-waarde(n)
|
||||
action.push.description = Pushed een of meer waarden naar de stapel
|
||||
action.push.stackAfter = waarde1, waarde2, ...
|
||||
action.push.operands = waarde1:*, [waarde2:*, ...]
|
||||
action.pop.name = Pop
|
||||
action.pop.code = 0x17
|
||||
action.pop.swfVersion = 4
|
||||
action.pop.shortDescription = Pop-waarde
|
||||
action.pop.description = Haalt waarde uit de stapel en gooit deze weg
|
||||
action.pop.stackBefore = waarde
|
||||
action.add.name = Toevoegen
|
||||
action.add.code = 0x0A
|
||||
action.add.swfVersion = 4
|
||||
action.add.shortDescription = Voeg twee waarden toe
|
||||
action.add.description = Voegt twee getallen toe en schuift het resultaat terug naar de stapel
|
||||
action.add.stackBefore = waarde1, waarde2
|
||||
action.add.stackAfter = resultaat
|
||||
action.add.operands =
|
||||
action.subtract.name = Aftrekken
|
||||
action.subtract.code = 0x0B
|
||||
action.subtract.swfVersion = 4
|
||||
action.subtract.shortDescription = Trek twee waarden af
|
||||
action.subtract.description = Trekt twee getallen af \u200b\u200ben schuift het resultaat terug naar de stapel
|
||||
action.subtract.stackBefore = waarde1, waarde2
|
||||
action.subtract.stackAfter = resultaat
|
||||
action.multiply.name = Vermenigvuldigen
|
||||
action.multiply.code = 0x0C
|
||||
action.multiply.swfVersion = 4
|
||||
action.multiply.shortDescription = Vermenigvuldig twee waarden
|
||||
action.multiply.description = Vermenigvuldigt twee getallen en schuift het resultaat terug naar de stapel
|
||||
action.multiply.stackBefore = waarde1, waarde2
|
||||
action.multiply.stackAfter = resultaat
|
||||
action.divide.name = Delen
|
||||
action.divide.code = 0x0D
|
||||
action.divide.swfVersion = 4
|
||||
action.divide.shortDescription = Deel twee waarden
|
||||
action.divide.description = Deelt twee getallen en schuift het resultaat terug naar de stapel
|
||||
action.divide.stackBefore = waarde1, waarde2
|
||||
action.divide.stackAfter = resultaat
|
||||
action.equals.name = Gelijk aan
|
||||
action.equals.code = 0x0E
|
||||
action.equals.swfVersion = 4
|
||||
action.equals.shortDescription = Controleer of twee waarden gelijk zijn
|
||||
action.equals.stackBefore = waarde1, waarde2
|
||||
action.equals.stackAfter = booleaansResultaat
|
||||
action.less.name = Minder
|
||||
action.less.code = 0x0F
|
||||
action.less.swfVersion = 4
|
||||
action.less.shortDescription = Controleer of de waarde kleiner is dan de andere waarde
|
||||
action.less.stackBefore = waarde1, waarde2
|
||||
action.less.stackAfter = booleaansResultaat
|
||||
action.and.name = En
|
||||
action.and.code = 0x10
|
||||
action.and.swfVersion = 4
|
||||
action.and.shortDescription = Logisch EN
|
||||
action.and.description = Voert een logische EN van twee getallen uit
|
||||
action.and.stackBefore = waarde1, waarde2
|
||||
action.and.stackAfter = booleaansResultaat
|
||||
action.or.name = Of
|
||||
action.or.code = 0x11
|
||||
action.or.swfVersion = 4
|
||||
action.or.shortDescription = Logische OF
|
||||
action.or.description = Voert een logische OF van twee getallen uit
|
||||
action.or.stackBefore = waarde1, waarde2
|
||||
action.or.stackAfter = booleaansResultaat
|
||||
action.not.name = Niet
|
||||
action.not.code = 0x12
|
||||
action.not.swfVersion = 4
|
||||
action.not.shortDescription = Logische NIET
|
||||
action.not.description = Voert een logische NIET van een getal uit
|
||||
action.not.stackBefore = waarde
|
||||
action.not.stackAfter = booleaansResultaat
|
||||
action.stringequals.name = StringGelijkAan
|
||||
action.stringequals.code = 0x13
|
||||
action.stringequals.swfVersion = 4
|
||||
action.stringequals.shortDescription = Controleer of twee strings gelijk zijn
|
||||
action.stringequals.stackBefore = waarde1, waarde2
|
||||
action.stringequals.stackAfter = booleaansResultaat
|
||||
action.stringlength.name = StringLengte
|
||||
action.stringlength.code = 0x14
|
||||
action.stringlength.swfVersion = 4
|
||||
action.stringlength.shortDescription = Lengte van de string
|
||||
action.stringlength.description = Berekent de lengte van een string
|
||||
action.stringlength.stackBefore = waarde
|
||||
action.stringlength.stackAfter = resultaat
|
||||
action.stringadd.name = StringToevoegen
|
||||
action.stringadd.code = 0x21
|
||||
action.stringadd.swfVersion = 4
|
||||
action.stringadd.shortDescription = Voeg twee strings samen
|
||||
action.stringadd.stackBefore = waarde1, waarde2
|
||||
action.stringadd.stackAfter = resultaat
|
||||
action.stringextract.name = StringExtractie
|
||||
action.stringextract.code = 0x15
|
||||
action.stringextract.swfVersion = 4
|
||||
action.stringextract.shortDescription = Extraheer een subtekenreeks uit een tekenreeks
|
||||
action.stringextract.stackBefore = aantal, index, string
|
||||
action.stringextract.stackAfter = resultaat
|
||||
action.stringless.name = StringKleinerDan
|
||||
action.stringless.code = 0x29
|
||||
action.stringless.swfVersion = 4
|
||||
action.stringless.shortDescription = Controleer of de string kleiner is dan de andere string
|
||||
action.stringless.stackBefore = waarde1, waarde2
|
||||
action.stringless.stackAfter = booleaansResultaat
|
||||
action.mbstringlength.name = MBStringLengte
|
||||
action.mbstringlength.code = 0x31
|
||||
action.mbstringlength.swfVersion = 4
|
||||
action.mbstringlength.shortDescription = Lengte van de string multi-byte bewust
|
||||
action.mbstringlength.description = Berekent de lengte van een tekenreeks die multi-byte bewust is
|
||||
action.mbstringlength.stackBefore = waarde
|
||||
action.mbstringlength.stackAfter = resultaat
|
||||
action.mbstringextract.name = MBStringExtraheren
|
||||
action.mbstringextract.code = 0x35
|
||||
action.mbstringextract.swfVersion = 4
|
||||
action.mbstringextract.shortDescription = Extraheer een subtekenreeks uit een tekenreeks die multi-byte bewust is
|
||||
action.mbstringextract.description =
|
||||
action.mbstringextract.stackBefore = aantal, index, string
|
||||
action.mbstringextract.stackAfter = resultaat
|
||||
action.tointeger.name = NaarInteger
|
||||
action.tointeger.code = 0x18
|
||||
action.tointeger.swfVersion = 4
|
||||
action.tointeger.shortDescription = Converteer een waarde naar integer
|
||||
action.tointeger.stackBefore = waarde
|
||||
action.tointeger.stackAfter = resultaat
|
||||
action.chartoascii.name = TekenNaarAscii
|
||||
action.chartoascii.code = 0x32
|
||||
action.chartoascii.swfVersion = 4
|
||||
action.chartoascii.shortDescription = Converteer een tekencode naar Ascii
|
||||
action.chartoascii.description =
|
||||
action.chartoascii.stackBefore = waarde
|
||||
action.chartoascii.stackAfter = resultaat
|
||||
action.asciitochar.name = AsciiNaarTeken
|
||||
action.asciitochar.code = 0x33
|
||||
action.asciitochar.swfVersion = 4
|
||||
action.asciitochar.shortDescription = Converteert een waarde naar een ASCII-tekencode
|
||||
action.asciitochar.stackBefore = waarde
|
||||
action.asciitochar.stackAfter = resultaat
|
||||
action.mbchartoascii.name = MBTekenNaar Ascii
|
||||
action.mbchartoascii.code = 0x36
|
||||
action.mbchartoascii.swfVersion = 4
|
||||
action.mbchartoascii.shortDescription = Converteer een tekencode naar ASCII multi-byte bewust
|
||||
action.mbchartoascii.stackBefore = waarde
|
||||
action.mbchartoascii.stackAfter = resultaat
|
||||
action.mbasciitochar.name = MBAsciiNaarTeken
|
||||
action.mbasciitochar.code = 0x37
|
||||
action.mbasciitochar.swfVersion = 4
|
||||
action.mbasciitochar.shortDescription = Converteert een waarde naar een ASCII-tekencode die multi-byte bewust is
|
||||
action.mbasciitochar.description =
|
||||
action.mbasciitochar.stackBefore = waarde
|
||||
action.mbasciitochar.stackAfter = resultaat
|
||||
action.jump.name = Spring
|
||||
action.jump.code = 0x99
|
||||
action.jump.swfVersion = 4
|
||||
action.jump.shortDescription = Spring naar locatie
|
||||
action.jump.operands = lokatie:identifier
|
||||
action.if.name = Als
|
||||
action.if.code = 0x9D
|
||||
action.if.swfVersion = 4
|
||||
action.if.shortDescription = Vertakking
|
||||
action.if.description = Cre\u00ebert een voorwaardelijke test en vertakking
|
||||
action.if.stackBefore = conditie
|
||||
action.if.operands = vertakkingsDoel:identifier
|
||||
action.call.name = Aanroep
|
||||
action.call.code = 0x9E
|
||||
action.call.swfVersion = 4
|
||||
action.call.shortDescription = Roep een subroutine op
|
||||
action.call.stackBefore = waarde
|
||||
action.call.stackAfter =
|
||||
action.getvariable.name = HaalVariabeleOp
|
||||
action.getvariable.code = 0x1C
|
||||
action.getvariable.swfVersion = 4
|
||||
action.getvariable.shortDescription = Haal variabele waarde op
|
||||
action.getvariable.stackBefore = naam
|
||||
action.getvariable.stackAfter = waarde
|
||||
action.setvariable.name = SetVariable
|
||||
action.setvariable.code = 0x1D
|
||||
action.setvariable.swfVersion = 4
|
||||
action.setvariable.shortDescription = Stel variabele waarde in
|
||||
action.setvariable.stackBefore = waarde, naam
|
||||
action.geturl2.name = GetURL2
|
||||
action.geturl2.code = 0x9A
|
||||
action.geturl2.swfVersion = 4
|
||||
action.geturl2.shortDescription = Krijg een URL (stackgebaseerd)
|
||||
action.geturl2.stackBefore = doel, url
|
||||
# Note: official documentation has the order of fields wrong
|
||||
action.geturl2.operands = oadVariablesFlag:boolean, loadTargetFlag:boolean, sendVarsMethod:integer
|
||||
action.gotoframe2.name = GotoFrame2
|
||||
action.gotoframe2.code = 0x9F
|
||||
action.gotoframe2.swfVersion = 4
|
||||
action.gotoframe2.shortDescription = Ga naar frame (gebaseerd op stapel)
|
||||
action.gotoframe2.stackBefore = frame
|
||||
action.gotoframe2.operands = sceneBiasFlag:boolean, playFlag:boolean, [sceneBias:UI16]
|
||||
action.settarget2.name = SetTarget2
|
||||
action.settarget2.code = 0x20
|
||||
action.settarget2.swfVersion = 4
|
||||
action.settarget2.shortDescription = Stel de huidige context in (stack-gebaseerd)
|
||||
action.settarget2.stackBefore = doel
|
||||
action.getproperty.name = GetProperty
|
||||
action.getproperty.code = 0x22
|
||||
action.getproperty.swfVersion = 4
|
||||
action.getproperty.shortDescription = Krijg de waarde van waarde
|
||||
action.getproperty.stackBefore = index, doel
|
||||
action.getproperty.stackAfter = waarde
|
||||
action.setproperty.name = SetProperty
|
||||
action.setproperty.code = 0x23
|
||||
action.setproperty.swfVersion = 4
|
||||
action.setproperty.shortDescription = Stel de waarde van de eigenschap in
|
||||
action.setproperty.stackBefore = waarde, index, doel
|
||||
action.clonesprite.name = CloneSprite
|
||||
action.clonesprite.code = 0x24
|
||||
action.clonesprite.swfVersion = 4
|
||||
action.clonesprite.shortDescription = Kloon een sprite
|
||||
action.clonesprite.stackBefore = diepte, doel, bron
|
||||
action.removesprite.name = RemoveSprite
|
||||
action.removesprite.code = 0x25
|
||||
action.removesprite.swfVersion = 4
|
||||
action.removesprite.shortDescription = Verwijder sprite
|
||||
action.removesprite.stackBefore = doel
|
||||
action.startdrag.name = StartDrag
|
||||
action.startdrag.code = 0x27
|
||||
action.startdrag.swfVersion = 4
|
||||
action.startdrag.shortDescription = Begin met het slepen van een filmclip
|
||||
action.startdrag.stackBefore = doel, lockcenter, beperking, [y2, x2, y1, x1]
|
||||
action.enddrag.name = EndDrag
|
||||
action.enddrag.code = 0x28
|
||||
action.enddrag.swfVersion = 4
|
||||
action.enddrag.shortDescription = Be\u00ebindig de sleepoperatie
|
||||
action.waitforframe2.name = WaitForFrame2
|
||||
action.waitforframe2.code = 0x8D
|
||||
action.waitforframe2.swfVersion = 4
|
||||
action.waitforframe2.shortDescription = Wacht op een frame (stackgebaseerd)
|
||||
action.waitforframe2.stackBefore = frame
|
||||
action.waitforframe2.operands = skipCount:UI8
|
||||
action.trace.name = Spoor
|
||||
action.trace.code = 0x26
|
||||
action.trace.swfVersion = 4
|
||||
action.trace.shortDescription = Verzend foutopsporings uitvoerstring
|
||||
action.trace.stackBefore = waarde
|
||||
action.gettime.name = GetTime
|
||||
action.gettime.code = 0x34
|
||||
action.gettime.swfVersion = 4
|
||||
action.gettime.shortDescription = Krijg milliseconden sinds FP-start
|
||||
action.gettime.stackAfter = waarde
|
||||
action.randomnumber.name = RandomNumber
|
||||
action.randomnumber.code = 0x30
|
||||
action.randomnumber.swfVersion = 4
|
||||
action.randomnumber.shortDescription = Bereken willekeurig getal
|
||||
action.randomnumber.stackBefore = maximum
|
||||
action.randomnumber.stackAfter = resultaat
|
||||
action.callfunction.name = CallFunction
|
||||
action.callfunction.code = 0x3D
|
||||
action.callfunction.swfVersion = 5
|
||||
action.callfunction.shortDescription = Voer een functie uit
|
||||
action.callfunction.stackBefore = functionName, numArgs, [argument1, argument2, ...]
|
||||
action.callfunction.stackAfter = resultaat
|
||||
action.callmethod.name = CallMethod
|
||||
action.callmethod.code = 0x52
|
||||
action.callmethod.swfVersion = 5
|
||||
action.callmethod.shortDescription = Voer een methode uit op een object
|
||||
action.callmethod.stackBefore = methodName, object, numArgs, [argument1, argument2, ...]
|
||||
action.callmethod.stackAfter = resultaat
|
||||
action.constantpool.name = ConstantPool
|
||||
action.constantpool.code = 0x88
|
||||
action.constantpool.swfVersion = 5
|
||||
action.constantpool.shortDescription = Maak een nieuwe constante pool
|
||||
action.constantpool.operands = constant1:STRING, constant2:STRING, ...
|
||||
action.definefunction.name = DefineFunction
|
||||
action.definefunction.code = 0x9B
|
||||
action.definefunction.swfVersion = 5
|
||||
action.definefunction.shortDescription = Definieer een functie
|
||||
action.definefunction.stackAfter = resultaat
|
||||
action.definefunction.operands = functionName:STRING, numParams:UI16, [paramName1, paramName2, ...]
|
||||
action.definelocal.name = DefineLocal
|
||||
action.definelocal.code = 0x3C
|
||||
action.definelocal.swfVersion = 5
|
||||
action.definelocal.shortDescription = Definieer de lokale variabele en stel de waarde ervan in
|
||||
action.definelocal.stackBefore = waarde, naam
|
||||
action.definelocal2.name = DefineLocal2
|
||||
action.definelocal2.code = 0x41
|
||||
action.definelocal2.swfVersion = 5
|
||||
action.definelocal2.shortDescription = Definieer de lokale variabele zonder de waarde ervan in te stellen
|
||||
action.definelocal2.description =
|
||||
action.definelocal2.stackBefore = naam
|
||||
action.definelocal2.stackAfter =
|
||||
action.delete.name = Verwijderen
|
||||
action.delete.code = 0x3A
|
||||
action.delete.swfVersion = 5
|
||||
action.delete.shortDescription = Verwijder de benoemde eigenschap uit een scriptObject
|
||||
action.delete.stackBefore = naam, object
|
||||
action.delete2.name = Delete2
|
||||
action.delete2.code = 0x3B
|
||||
action.delete2.swfVersion = 5
|
||||
action.delete2.shortDescription = Verwijder de benoemde egenschap
|
||||
action.delete2.description =
|
||||
action.delete2.stackBefore = naam
|
||||
action.enumerate.name = Enumerate
|
||||
action.enumerate.code = 0x46
|
||||
action.enumerate.swfVersion = 5
|
||||
action.enumerate.shortDescription = Haal de namen van alle slots uit een object
|
||||
action.enumerate.stackBefore = objectName
|
||||
action.enumerate.stackAfter = null, [slotName1, slotName2, ...]
|
||||
action.equals2.name = Equals2
|
||||
action.equals2.code = 0x49
|
||||
action.equals2.swfVersion = 5
|
||||
action.equals2.shortDescription = Controleer of twee waarden gelijk zijn, op basis van typen
|
||||
action.equals2.stackBefore = value1, value2
|
||||
action.equals2.stackAfter = resultaat
|
||||
action.getmember.name = GetMember
|
||||
action.getmember.code = 0x4E
|
||||
action.getmember.swfVersion = 5
|
||||
action.getmember.shortDescription = Haal een benoemde eigenschap op van een object
|
||||
action.getmember.stackBefore = propertyName, object
|
||||
action.getmember.stackAfter = resultaat
|
||||
action.initarray.name = InitArray
|
||||
action.initarray.code = 0x42
|
||||
action.initarray.swfVersion = 5
|
||||
action.initarray.shortDescription = Initialiseer array
|
||||
action.initarray.stackBefore = numArgs, [argument1, argument2, ...]
|
||||
action.initarray.stackAfter = resultaat
|
||||
action.initobject.name = InitObject
|
||||
action.initobject.code = 0x43
|
||||
action.initobject.swfVersion = 5
|
||||
action.initobject.shortDescription = Initialiseer object
|
||||
action.initobject.stackBefore = numProps, [value1, name1, value2, name2, ...]
|
||||
action.initobject.stackAfter = resultaat
|
||||
action.newmethod.name = NewMethod
|
||||
action.newmethod.code = 0x53
|
||||
action.newmethod.swfVersion = 5
|
||||
action.newmethod.shortDescription = Roep de constructormethode aan en maak een nieuw object
|
||||
action.newmethod.stackBefore = methodName, object, numArgs, [argument1, argument2, ...]
|
||||
action.newmethod.stackAfter = resultaat
|
||||
action.newobject.name = NewObject
|
||||
action.newobject.code = 0x40
|
||||
action.newobject.swfVersion = 5
|
||||
action.newobject.shortDescription = Roep de constructorfunctie aan en maak een nieuw object
|
||||
action.newobject.stackBefore = objectName, numArgs, [argument1, argument2, ...]
|
||||
action.newobject.stackAfter = resultaat
|
||||
action.setmember.name = SetMember
|
||||
action.setmember.code = 0x4F
|
||||
action.setmember.swfVersion = 5
|
||||
action.setmember.shortDescription = Stel de benoemde eigenschap van een object in
|
||||
action.setmember.stackBefore = value, propertyName, object
|
||||
action.targetpath.name = TargetPath
|
||||
action.targetpath.code = 0x45
|
||||
action.targetpath.swfVersion = 5
|
||||
action.targetpath.shortDescription = Haal object-doelpad op
|
||||
action.targetpath.stackBefore = object
|
||||
action.targetpath.stackAfter = resultaat
|
||||
action.with.name = With
|
||||
action.with.code = 0x94
|
||||
action.with.swfVersion = 5
|
||||
action.with.shortDescription = Definieer met blok
|
||||
action.with.stackBefore = object
|
||||
action.tonumber.name = ToNumber
|
||||
action.tonumber.code = 0x4A
|
||||
action.tonumber.swfVersion = 5
|
||||
action.tonumber.shortDescription = Converteer waarde naar een getal
|
||||
action.tonumber.stackBefore = waarde
|
||||
action.tonumber.stackAfter = resultaat
|
||||
action.tostring.name = ToString
|
||||
action.tostring.code = 0x4B
|
||||
action.tostring.swfVersion = 5
|
||||
action.tostring.shortDescription = Converteer waarde naar een string
|
||||
action.tostring.stackBefore = waarde
|
||||
action.tostring.stackAfter = resultaat
|
||||
action.typeof.name = TypeOf
|
||||
action.typeof.code = 0x44
|
||||
action.typeof.swfVersion = 5
|
||||
action.typeof.shortDescription = Haalobjecttype op
|
||||
action.typeof.stackBefore = waarde
|
||||
action.typeof.stackAfter = resultaat
|
||||
action.add2.name = Add2
|
||||
action.add2.code = 0x47
|
||||
action.add2.swfVersion = 5
|
||||
action.add2.shortDescription = Voeg twee waarden toe, gebaseerd op typen
|
||||
action.add2.stackBefore = value1, value2
|
||||
action.add2.stackAfter = resultaat
|
||||
action.less2.name = Less2
|
||||
action.less2.code = 0x48
|
||||
action.less2.swfVersion = 5
|
||||
action.less2.shortDescription = Controleer of de waarde kleiner is dan de andere waarde, op basis van typen
|
||||
action.less2.stackBefore = value1, value2
|
||||
action.less2.stackAfter = booleanResult
|
||||
action.less2.operands =
|
||||
action.modulo.name = Modulo
|
||||
action.modulo.code = 0x3F
|
||||
action.modulo.swfVersion = 5
|
||||
action.modulo.shortDescription = Bereken de modulo van twee getallen
|
||||
action.modulo.description = Berekent de modulo van twee getallen en schuift het resultaat terug naar de stapel
|
||||
action.modulo.stackBefore = value1, value2
|
||||
action.modulo.stackAfter = resultaat
|
||||
action.modulo.operands =
|
||||
action.bitand.name = BitAnd
|
||||
action.bitand.code = 0x60
|
||||
action.bitand.swfVersion = 5
|
||||
action.bitand.shortDescription = Bitsgewijs EN
|
||||
action.bitand.description = Voert een bitsgewijze EN van twee getallen uit
|
||||
action.bitand.stackBefore = value1, value2
|
||||
action.bitand.stackAfter = resultaat
|
||||
action.bitlshift.name = BitLShift
|
||||
action.bitlshift.code = 0x63
|
||||
action.bitlshift.swfVersion = 5
|
||||
action.bitlshift.shortDescription = Linker bitverschuiving
|
||||
action.bitlshift.stackBefore = shiftCount, value
|
||||
action.bitlshift.stackAfter = resultaat
|
||||
action.bitor.name = BitOr
|
||||
action.bitor.code = 0x61
|
||||
action.bitor.swfVersion = 5
|
||||
action.bitor.shortDescription = Bitsgewijze OF
|
||||
action.bitor.description = Voert een bitsgewijze OR van twee getallen uit
|
||||
action.bitor.stackBefore = value1, value2
|
||||
action.bitor.stackAfter = resultaat
|
||||
action.bitrshift.name = BitRShift
|
||||
action.bitrshift.code = 0x64
|
||||
action.bitrshift.swfVersion = 5
|
||||
action.bitrshift.shortDescription = Rechter bitverschuiving
|
||||
action.bitrshift.stackBefore = shiftCount, value
|
||||
action.bitrshift.stackAfter = resultaat
|
||||
action.biturshift.name = BitURShift
|
||||
action.biturshift.code = 0x65
|
||||
action.biturshift.swfVersion = 5
|
||||
action.biturshift.shortDescription = Niet-ondertekende juiste bitverschuiving
|
||||
action.biturshift.stackBefore = shiftCount, value
|
||||
action.biturshift.stackAfter = resultaat
|
||||
action.bitxor.name = BitXor
|
||||
action.bitxor.code = 0x62
|
||||
action.bitxor.swfVersion = 5
|
||||
action.bitxor.shortDescription = Bitsgewijze XOR
|
||||
action.bitxor.description = Voert een bitsgewijze XOR van twee getallen uit
|
||||
action.bitxor.stackBefore = value1, value2
|
||||
action.bitxor.stackAfter = resultaart
|
||||
action.decrement.name = Verlagen
|
||||
action.decrement.code = 0x51
|
||||
action.decrement.swfVersion = 5
|
||||
action.decrement.shortDescription = Waarde verlagen
|
||||
action.decrement.stackBefore = waarde
|
||||
action.decrement.stackAfter = resultaat
|
||||
action.decrement.operands =
|
||||
action.increment.name = Verhogen
|
||||
action.increment.code = 0x50
|
||||
action.increment.swfVersion = 5
|
||||
action.increment.shortDescription = Waarde verhogen
|
||||
action.increment.stackBefore = waarde
|
||||
action.increment.stackAfter = resultaat
|
||||
action.pushduplicate.name = PushDuplicate
|
||||
action.pushduplicate.code = 0x4C
|
||||
action.pushduplicate.swfVersion = 5
|
||||
action.pushduplicate.shortDescription = Dupliceer de bovenkant van de stapel
|
||||
action.pushduplicate.stackBefore = waarde
|
||||
action.pushduplicate.stackAfter = waarde, waarde
|
||||
action.pushduplicate.operands =
|
||||
action.return.name = Retourneren
|
||||
action.return.code = 0x3E
|
||||
action.return.swfVersion = 5
|
||||
action.return.shortDescription = Waarde retourneren
|
||||
action.return.description =
|
||||
action.return.stackBefore = waarde
|
||||
action.stackswap.name = StackSwap
|
||||
action.stackswap.code = 0x4D
|
||||
action.stackswap.swfVersion = 5
|
||||
action.stackswap.shortDescription = Wissel de bovenste twee waarden op de stapel om
|
||||
action.stackswap.stackBefore = waarde1, waarde2
|
||||
action.stackswap.stackAfter = waarde1, waarde2
|
||||
action.storeregister.name = StoreRegister
|
||||
action.storeregister.code = 0x87
|
||||
action.storeregister.swfVersion = 5
|
||||
action.storeregister.shortDescription = Sla waarde op in een register
|
||||
action.storeregister.stackBefore = waarde
|
||||
action.storeregister.stackAfter = waarde
|
||||
action.storeregister.operands = registerNumber:UI8
|
||||
action.instanceof.name = InstanceOf
|
||||
action.instanceof.code = 0x54
|
||||
action.instanceof.swfVersion = 6
|
||||
action.instanceof.shortDescription = Object is een instantie van een klasse
|
||||
action.instanceof.stackBefore = constructor, object
|
||||
action.instanceof.stackAfter = booleanResult
|
||||
action.enumerate2.name = Enumerate2
|
||||
action.enumerate2.code = 0x55
|
||||
action.enumerate2.swfVersion = 6
|
||||
action.enumerate2.shortDescription = Haal de namen van alle slots uit een object (stapelargument is objecttype)
|
||||
action.enumerate2.stackBefore = object
|
||||
action.enumerate2.stackAfter = null, [slotName1, slotName2, ...]
|
||||
action.strictequals.name = StrictEquals
|
||||
action.strictequals.code = 0x66
|
||||
action.strictequals.swfVersion = 6
|
||||
action.strictequals.shortDescription = Controleer of twee waarden gelijk zijn en hetzelfde type hebben
|
||||
action.strictequals.stackBefore = waarde1, waarde2
|
||||
action.strictequals.stackAfter = booleanResult
|
||||
action.greater.name = Greater
|
||||
action.greater.code = 0x67
|
||||
action.greater.swfVersion = 6
|
||||
action.greater.shortDescription = Controleer of de waarde groter is dan de andere waarde
|
||||
action.greater.stackBefore = waarde1, waarde2
|
||||
action.greater.stackAfter = booleanResult
|
||||
action.stringgreater.name = StringGreater
|
||||
action.stringgreater.code = 0x68
|
||||
action.stringgreater.swfVersion = 6
|
||||
action.stringgreater.shortDescription = Controleer of de string groter is dan de andere waarde
|
||||
action.stringgreater.stackBefore = waarde1, waarde2
|
||||
action.stringgreater.stackAfter = booleanResult
|
||||
action.stringgreater.operands =
|
||||
action.definefunction2.name = DefineFunction2
|
||||
action.definefunction2.code = 0x8E
|
||||
action.definefunction2.swfVersion = 7
|
||||
action.definefunction2.shortDescription = Definieer een functie (extra functies)
|
||||
action.definefunction2.stackBefore =
|
||||
action.definefunction2.stackAfter = resultaat
|
||||
action.definefunction2.operands = functionName:STRING, numParams:UI16, \
|
||||
registerCount:UI8, \
|
||||
preloadParentFlag:boolean, \
|
||||
preloadRootFlag:boolean, \
|
||||
suppressSuperFlag:boolean, \
|
||||
preloadSuperFlag:boolean, \
|
||||
suppressArgumentsFlag:boolean, \
|
||||
preloadArgumentsFlag:boolean, \
|
||||
suppressThisFlag:boolean, \
|
||||
preloadThisFlag:boolean, \
|
||||
preloadGlobalFlag:boolean, \
|
||||
[register1:UI8, paramName1:STRING, register2:UI8, paramName2:STRING, ...]
|
||||
action.extends.name = Verlengen
|
||||
action.extends.code = 0x69
|
||||
action.extends.swfVersion = 7
|
||||
action.extends.shortDescription = Creeer een overervingsrelatie
|
||||
action.extends.stackBefore = superClassConstructor, subClassConstructor
|
||||
action.extends.operands =
|
||||
action.castop.name = CastOp
|
||||
action.castop.code = 0x2B
|
||||
action.castop.swfVersion = 7
|
||||
action.castop.shortDescription = Cast-gegevenstype
|
||||
action.castop.stackBefore = object, constructor
|
||||
action.castop.stackAfter = resultaat
|
||||
action.implementsop.name = ImplementsOp
|
||||
action.implementsop.code = 0x2C
|
||||
action.implementsop.swfVersion = 7
|
||||
action.implementsop.shortDescription = Specificeer interfaces die een klasse implementeert
|
||||
action.implementsop.stackBefore = classConstructor, numInterfaces, [interfaceConstructor1, interfaceConstructor2, ...]
|
||||
action.try.name = Try
|
||||
action.try.code = 0x8F
|
||||
action.try.swfVersion = 7
|
||||
action.try.shortDescription = Definieer handler voor uitzonderlijke omstandigheden
|
||||
action.try.stackBefore =
|
||||
action.try.operands = catchTarget:register|STRING
|
||||
action.throw.name = Throw
|
||||
action.throw.code = 0x2A
|
||||
action.throw.swfVersion = 7
|
||||
action.throw.shortDescription = Genereer een uitzonderingsconditie
|
||||
action.throw.stackBefore = waarde
|
||||
action.throw.stackAfter =
|
||||
@@ -0,0 +1,799 @@
|
||||
ui.list.pageTitle = AVM2-instructielijst
|
||||
ui.list.documentTitle = AVM2-instructielijst
|
||||
ui.list.pageDescription = Lijst met alle bekende ActionScript 3 - AVM2-instructies met hun operanden en stapelwaarden
|
||||
#various strings in UI:
|
||||
ui.unknown = ???
|
||||
ui.stack = Stack:
|
||||
ui.stack.before = ...,
|
||||
ui.stack.before.empty = ...
|
||||
ui.stack.to = \ \u279e
|
||||
ui.flags = Vlaggen:
|
||||
ui.description = Beschrijving:
|
||||
ui.filter.hide = Verbergen:
|
||||
ui.filter.byname = Zoek op naam:
|
||||
ui.filter.order = Rangschikken op:
|
||||
ui.filter.order.code = code
|
||||
ui.filter.order.name = naam
|
||||
#----------------------- Flags of the instructions
|
||||
instructionFlag.undocumented = Ongedocumenteerd
|
||||
instructionFlag.unknownStack = Onbekende stapel
|
||||
instructionFlag.es4NumericsMinor = ES4 numeriek (ABC minor 17)
|
||||
instructionFlag.floatMajor = Float waarden (ABC major 47)
|
||||
instructionFlag.unknownOperands = Onbekende operanden
|
||||
instructionFlag.noFlashPlayer = Niet in standaard Flash Player
|
||||
instructionFlag.deprecated = Verouderd
|
||||
instructionFlag.domainMemory = Domein geheugenbewerking
|
||||
#----------------------- Operand types
|
||||
operandType.multinameIndex = Index met meerdere namen
|
||||
operandType.multinameIndex.description = Index in constante pool met meerdere namen
|
||||
operandType.multinameIndex.name = multinameIndex
|
||||
operandType.multinameIndex.uiName = multiname
|
||||
operandType.argCount = Aantal argumenten
|
||||
operandType.argCount.description = Aantal volgende argumenten
|
||||
operandType.argCount.name = argCount
|
||||
operandType.argCount.uiName = uint
|
||||
operandType.methodIndex = Methode index
|
||||
operandType.methodIndex.description = Index van de methode in het ABC
|
||||
operandType.methodIndex.name = methodIndex
|
||||
operandType.methodIndex.uiName = methodIndex
|
||||
operandType.stringIndex = Stringindex
|
||||
operandType.stringIndex.description = Index in constante pool van stringwaarden
|
||||
operandType.stringIndex.name = stringIndex
|
||||
operandType.stringIndex.uiName = string
|
||||
operandType.debugType = Foutopsporingstype
|
||||
operandType.debugType.description = Type foutopsporingsinformatie. Momenteel wordt alleen de waarde 1 gebruikt.
|
||||
operandType.debugType.name = debugType
|
||||
operandType.debugType.uiName = debugType
|
||||
operandType.registerIndex = Registerindex
|
||||
operandType.registerIndex.description = Index van een lokaal register (0-255)
|
||||
operandType.registerIndex.name = registerIndex
|
||||
operandType.registerIndex.uiName = uint
|
||||
operandType.linenum = Regelnummer
|
||||
operandType.linenum.description = Regelnummer van bestand
|
||||
operandType.linenum.name = linenum
|
||||
operandType.linenum.uiName = linenum
|
||||
#similar as registerIndex, but U30 instead of U8
|
||||
operandType.localRegIndex = Registerindex
|
||||
operandType.localRegIndex.description = Index van een lokaal register
|
||||
operandType.localRegIndex.name = localRegIndex
|
||||
operandType.localRegIndex.uiName = uint
|
||||
operandType.slotIndex = Slotindex
|
||||
operandType.slotIndex.description = Index van het slot op een object
|
||||
operandType.slotIndex.name = slotIndex
|
||||
operandType.slotIndex.uiName = slotIndex
|
||||
operandType.scopeIndex = Scope-stackindex
|
||||
operandType.scopeIndex.description = Index in de scopestack
|
||||
operandType.scopeIndex.name = scopeIndex
|
||||
operandType.scopeIndex.uiName = scopeIndex
|
||||
operandType.offset = Offset
|
||||
operandType.offset.description = Offset naar andere locatie
|
||||
operandType.offset.name = offset
|
||||
operandType.offset.uiName = labelName
|
||||
operandType.exceptionIndex = Uitzonderings index
|
||||
operandType.exceptionIndex.description = Index van uitzonderingen in informatie over de huidige methode
|
||||
operandType.exceptionIndex.name = exceptionIndex
|
||||
operandType.exceptionIndex.uiName = exceptionIndex
|
||||
operandType.classIndex = Klasse-index
|
||||
operandType.classIndex.description = Index van klasse in ABC
|
||||
operandType.classIndex.name = classIndex
|
||||
operandType.classIndex.uiName = classIndex
|
||||
operandType.intIndex = Int-index
|
||||
operandType.intIndex.description = Index in constante pool van gehele getallen
|
||||
operandType.intIndex.name = intIndex
|
||||
operandType.intIndex.uiName = int
|
||||
operandType.uintIndex = UInt-index
|
||||
operandType.uintIndex.description = Indexeer in de constante pool van integerwaarden zonder teken
|
||||
operandType.uintIndex.name = uintIndex
|
||||
operandType.uintIndex.uiName = uint
|
||||
operandType.doubleIndex = Dubbele index
|
||||
operandType.doubleIndex.description = Index in constante pool met drijvende-kommawaarden met dubbele precisie
|
||||
operandType.doubleIndex.name = doubleIndex
|
||||
operandType.doubleIndex.uiName = dubbele
|
||||
operandType.decimalIndex = Decimale index
|
||||
operandType.decimalIndex.description = Index in decimale waarden (128 bit drijvende komma) constante pool
|
||||
operandType.decimalIndex.name = decimalIndex
|
||||
operandType.decimalIndex.uiName = decimaal
|
||||
operandType.caseBaseoffset = Basis-offset
|
||||
operandType.caseBaseoffset.description = Basisoffset van opzoek-schakelaar geactiveerd wanneer geen waarde overeenkomt
|
||||
operandType.caseBaseoffset.name = offset
|
||||
operandType.caseBaseoffset.uiName = labelName
|
||||
operandType.numberContext = Nummercontext (ES4)
|
||||
operandType.numberContext.description = Context van berekeningen bij gebruik van EcmaScript 4 numerieke waarden (ABC minorVersion 17).\nBits 0-2 type,3-5 afrondingstype, 6-12 precisie.\nType: 0=getal,1=decimaal,2=dubbel,3=int ,4=uint\nAfronding: 0=plafond,1=omhoog,2=half_omhoog,3=half_even,4=half_omlaag,5=omlaag,6=vloer\nPrecisie:0-34
|
||||
operandType.numberContext.name = numberContext
|
||||
operandType.numberContext.uiName = uint
|
||||
operandType.dispatchId = Verzendings-id
|
||||
operandType.dispatchId.description = Id van de methode dispatch
|
||||
operandType.dispatchId.name = dispatchId
|
||||
operandType.dispatchId.uiName = uint
|
||||
operandType.floatIndex = Float index
|
||||
operandType.floatIndex.description = Index in float-waarden constante pool
|
||||
operandType.floatIndex.name = floatIndex
|
||||
operandType.floatIndex.uiName = float
|
||||
operandType.float4Index = Float4 index
|
||||
operandType.float4Index.description = Index in float-waarden constante pool
|
||||
operandType.float4Index.name = float4Index
|
||||
operandType.float4Index.uiName = float4
|
||||
operandType.namespaceIndex = Indexeer in de constante pool van de naamruimte
|
||||
operandType.namespaceIndex.name = namespaceIndex
|
||||
operandType.namespaceIndex.uiName = naamruimte
|
||||
operandType.number = Nummer
|
||||
operandType.number.name = nummer
|
||||
operandType.number.uiName = uint
|
||||
operandType.U30 = U30
|
||||
operandType.U30.name = U30
|
||||
operandType.U30.uiName = uint
|
||||
#----------------------- Instructions
|
||||
instruction.bkpt.shortDescription = Breekpunt
|
||||
instruction.bkpt.description = Breekpunt bij het debuggen
|
||||
instruction.nop.shortDescription = Geen bewerking
|
||||
instruction.nop.description = Doet niets
|
||||
instruction.throw.shortDescription = Gooi uitzondering
|
||||
instruction.throw.description = Haalt waarde van de stack en gooit deze
|
||||
instruction.throw.stackBefore = waarde
|
||||
instruction.getsuper.shortDescription = Eigenschap van bovenliggende klasse ophalen
|
||||
instruction.getsuper.stackBefore = obj, [ns], [name]
|
||||
instruction.getsuper.stackAfter = waarde
|
||||
instruction.getsuper.operands = parentClassMultiname
|
||||
instruction.setsuper.shortDescription = Stel de eigenschap van de bovenliggende klasse in
|
||||
instruction.setsuper.stackBefore = obj, [ns], [name], value
|
||||
instruction.setsuper.operands = parentClassMultiname
|
||||
instruction.dxns.shortDescription = Stel de standaard XML-naamruimte in
|
||||
instruction.dxns.operands = uriString
|
||||
instruction.dxnslate.shortDescription = Stel de standaard XML-naamruimte in tijdens runtime
|
||||
instruction.dxnslate.stackBefore = uriValue
|
||||
instruction.dxnslate.operands =
|
||||
instruction.kill.shortDescription = Leeg (kill) het lokale register
|
||||
instruction.kill.stackBefore =
|
||||
instruction.kill.operands = killedRegister
|
||||
instruction.label.shortDescription = Doel van een vertakking
|
||||
instruction.label.description = Gewoon een teken dat dit het doelwit is van de volgende vertakking
|
||||
instruction.lf32x4.shortDescription = Load 32bit float4
|
||||
instruction.lf32x4.stackBefore = addres
|
||||
instruction.lf32x4.stackAfter = float4Value
|
||||
instruction.sf32x4.shortDescription = Store 32bit float4
|
||||
instruction.sf32x4.description =
|
||||
instruction.sf32x4.stackBefore = float4Value, address
|
||||
instruction.sf32x4.stackAfter =
|
||||
instruction.ifnlt.shortDescription = Vertakking indien niet lager dan
|
||||
instruction.ifnlt.stackBefore = value1, value2
|
||||
instruction.ifnlt.operands = branchTarget
|
||||
instruction.ifnle.shortDescription = Vertakking indien niet lager of gelijk
|
||||
instruction.ifnle.stackBefore = value1, value2
|
||||
instruction.ifnle.operands = branchTarget
|
||||
instruction.ifngt.shortDescription = Vertakking indien niet groter dan
|
||||
instruction.ifngt.stackBefore = value1, value2
|
||||
instruction.ifngt.operands = branchTarget
|
||||
instruction.ifnge.shortDescription = Vertakking indien niet groter dan of gelijk aan
|
||||
instruction.ifnge.stackBefore = value1, value2
|
||||
instruction.ifnge.operands = value1, value2
|
||||
instruction.jump.shortDescription = Spring naar lokatie
|
||||
instruction.jump.operands = lokatie
|
||||
instruction.iftrue.shortDescription = Vertakking indien waar
|
||||
instruction.iftrue.stackBefore = waarde
|
||||
instruction.iftrue.operands = branchTarget
|
||||
instruction.iffalse.shortDescription = Vertakking indien onwaar
|
||||
instruction.iffalse.stackBefore = waarde
|
||||
instruction.iffalse.operands = branchTarget
|
||||
instruction.ifeq.shortDescription = Vertakking indien gelijk aan
|
||||
instruction.ifeq.stackBefore = value1, value2
|
||||
instruction.ifeq.operands = branchTarget
|
||||
instruction.ifne.shortDescription = Vertakking indien niet gelijk aan
|
||||
instruction.ifne.stackBefore = value1, value2
|
||||
instruction.ifne.operands = branchTarget
|
||||
instruction.iflt.shortDescription = Vertakking indien lager dan
|
||||
instruction.iflt.stackBefore = value1, value2
|
||||
instruction.iflt.operands = branchTarget
|
||||
instruction.ifle.shortDescription = Vertakking indien lager dan of gelijk aan
|
||||
instruction.ifle.stackBefore = value1, value2
|
||||
instruction.ifle.operands = branchTarget
|
||||
instruction.ifgt.shortDescription = Vertakking indien groter dan
|
||||
instruction.ifgt.stackBefore = value1, value2
|
||||
instruction.ifgt.operands = branchTarget
|
||||
instruction.ifge.shortDescription = Vertakking indien groter dan of gelijk aan
|
||||
instruction.ifge.stackBefore = value1, value2
|
||||
instruction.ifge.operands = branchTarget
|
||||
instruction.ifstricteq.shortDescription = Vertakking indien strikt gelijk
|
||||
instruction.ifstricteq.stackBefore = value1, value2
|
||||
instruction.ifstricteq.operands = branchTarget
|
||||
instruction.ifstrictne.shortDescription = Vertakking indien niet strikt gelijk
|
||||
instruction.ifstrictne.stackBefore = value1, value2
|
||||
instruction.ifstrictne.operands = branchTarget
|
||||
instruction.lookupswitch.shortDescription = Vertakking op basis van index
|
||||
instruction.lookupswitch.stackBefore = index
|
||||
instruction.lookupswitch.operands = defaultTarget, caseCount, case0Target, case1Target, ...
|
||||
# special case for UI
|
||||
instruction.lookupswitch.operands.ui = defaultTarget:labelName, [case0Target:labelName, case1Target:labelName, ...]
|
||||
instruction.pushwith.shortDescription = Push met op de scopestack
|
||||
instruction.pushwith.stackBefore = withScope
|
||||
instruction.popscope.shortDescription = Pop uit de scopestack en gooi de waarde weg
|
||||
instruction.nextname.shortDescription = Vraag de naam op van de volgende eigenschap
|
||||
instruction.nextname.stackBefore = obj, index
|
||||
instruction.nextname.stackAfter = naam
|
||||
instruction.hasnext.shortDescription = Controleer of het object meer eigenschappen heeft
|
||||
instruction.hasnext.stackBefore = obj, currentIndex
|
||||
instruction.hasnext.stackAfter = nextIndex
|
||||
instruction.pushnull.shortDescription = Duw een nulwaarde opde stapel
|
||||
instruction.pushnull.stackAfter = null
|
||||
instruction.pushundefined.shortDescription = Duw een ongedefinieerde waarde op de stack
|
||||
instruction.pushundefined.stackAfter = ongedefinieert
|
||||
instruction.pushfloat.shortDescription = Push de floatwaarde op de stack
|
||||
instruction.pushfloat.stackAfter = floatValue
|
||||
instruction.pushfloat.operands = float
|
||||
instruction.nextvalue.shortDescription = Ontvang de waarde van het volgende eigenschap
|
||||
instruction.nextvalue.stackBefore = obj, index
|
||||
instruction.nextvalue.stackAfter = waarde
|
||||
instruction.pushbyte.shortDescription = Push een bytewaarde op de stack
|
||||
instruction.pushbyte.stackBefore =
|
||||
instruction.pushbyte.stackAfter = byteValue
|
||||
instruction.pushbyte.operands = waarde
|
||||
instruction.pushshort.shortDescription = Push een korte waarde op de stackl
|
||||
instruction.pushshort.stackAfter = shortValue
|
||||
instruction.pushshort.operands = waarde
|
||||
instruction.pushtrue.shortDescription = Push waar (true) op de stackl
|
||||
instruction.pushtrue.stackAfter = waar
|
||||
instruction.pushfalse.shortDescription = Push onwaar (false) op de stapel
|
||||
instruction.pushfalse.stackAfter = onwaar (false)
|
||||
instruction.pushnan.shortDescription = Push NaN waarde op de stackl
|
||||
instruction.pushnan.description =
|
||||
instruction.pushnan.stackAfter = NaN
|
||||
instruction.pop.shortDescription = Haal (pop) de bovenste waarde uit de stack
|
||||
instruction.pop.stackBefore = waarde
|
||||
instruction.dup.shortDescription = Dubbele waarde op de stack
|
||||
instruction.dup.stackBefore = waarde
|
||||
instruction.dup.stackAfter = waarde, waarde
|
||||
instruction.swap.shortDescription = Verwissel twee waarden bovenop de stack
|
||||
instruction.swap.stackBefore = waarde1, waarde2
|
||||
instruction.swap.stackAfter = waarde1, waarde2
|
||||
instruction.pushstring.shortDescription = Duw de stringwaarde op de stapel
|
||||
instruction.pushstring.stackAfter = stringValue
|
||||
instruction.pushstring.operands = waarde
|
||||
instruction.pushint.shortDescription = Duw een geheel getal op de stapel
|
||||
instruction.pushint.stackAfter = intValue
|
||||
instruction.pushint.operands = value
|
||||
instruction.pushuint.shortDescription = Push een niet-ondertekende integerwaarde op de stack
|
||||
instruction.pushuint.stackAfter = uintValue
|
||||
instruction.pushuint.operands = waarde
|
||||
instruction.pushdouble.shortDescription = Push dubbele precisiewaarde op de stack
|
||||
instruction.pushdouble.stackAfter = doubleValue
|
||||
instruction.pushdouble.operands = waarde
|
||||
instruction.pushscope.shortDescription = Push een object op de scope stack
|
||||
instruction.pushscope.stackBefore = obj
|
||||
instruction.pushnamespace.shortDescription = Push naamruimte op de stapel
|
||||
instruction.pushnamespace.stackAfter = naamruimte
|
||||
instruction.pushnamespace.operands = waarde
|
||||
instruction.hasnext2.shortDescription = Controleer of het object meer eigenschappen heeft (registergebaseerd)
|
||||
instruction.hasnext2.stackAfter = boolValue
|
||||
instruction.hasnext2.operands = objectReg, indexReg
|
||||
instruction.pushdecimal.shortDescription = Duw decimale waarde op de stapel
|
||||
instruction.pushdecimal.stackAfter = decimalValue
|
||||
instruction.pushdecimal.operands = waarde
|
||||
instruction.pushdnan.shortDescription = Push decimale NaN waarde op de stack
|
||||
instruction.pushdnan.stackAfter = decimalNaN
|
||||
instruction.li8.shortDescription = Laad een 8-bits gehele waarde
|
||||
instruction.li8.stackBefore = adres
|
||||
instruction.li8.stackAfter = int8Value
|
||||
instruction.li16.shortDescription = Laad een 16-bits integer waarde
|
||||
instruction.li16.stackBefore = adres
|
||||
instruction.li16.stackAfter = int16Value
|
||||
instruction.li32.shortDescription = Laad een 32-bits integer waarde
|
||||
instruction.li32.stackBefore = adres
|
||||
instruction.li32.stackAfter = int32Value
|
||||
instruction.lf32.shortDescription = Laad een 32-bits float-waarde
|
||||
instruction.lf32.stackBefore = adres
|
||||
instruction.lf32.stackAfter = float32Value
|
||||
instruction.lf64.shortDescription = Laad een 64-bits float-waarde
|
||||
instruction.lf64.stackBefore = adres
|
||||
instruction.lf64.stackAfter = float64Value
|
||||
instruction.si8.shortDescription = Bewaar een 8-bits geheel getalwaarde
|
||||
instruction.si8.stackBefore = waarde, adres
|
||||
instruction.si16.shortDescription = Bewaar een 16-bits integer waarde
|
||||
instruction.si16.stackBefore = waarde, adres
|
||||
instruction.si32.shortDescription = Bewaar een 32-bits integer waarde
|
||||
instruction.si32.stackBefore = waarde, adres
|
||||
instruction.sf32.shortDescription = Bewaar 32-bits float-waarde
|
||||
instruction.sf32.stackBefore = waarde, adres
|
||||
instruction.sf64.shortDescription = Bewaar een 64-bits float-waarde
|
||||
instruction.sf64.stackBefore = waarde, adres
|
||||
instruction.newfunction.shortDescription = Maak een nieuw Functie-object
|
||||
instruction.newfunction.stackAfter = functie
|
||||
instruction.newfunction.operands = methode
|
||||
instruction.call.shortDescription = Call-functie op de stack
|
||||
instruction.call.description =
|
||||
instruction.call.stackBefore = functie, dit, arg1, ..., argN
|
||||
instruction.call.stackAfter = waarde
|
||||
instruction.call.operands = argCount
|
||||
instruction.construct.shortDescription = Roep de constructorfunctie aan op de stack
|
||||
instruction.construct.stackBefore = functie, arg1, ..., argN
|
||||
instruction.construct.stackAfter = waarde
|
||||
instruction.construct.operands = argCount
|
||||
instruction.callmethod.shortDescription = Roep de methode van het object aan op dispatch-id
|
||||
instruction.callmethod.description =
|
||||
instruction.callmethod.stackBefore = dit, arg1, ..., argN
|
||||
instruction.callmethod.stackAfter = waarde
|
||||
instruction.callmethod.operands = methode, argCount
|
||||
instruction.callstatic.shortDescription = Roep de methode aan op methode in het ABC-bestand
|
||||
instruction.callstatic.description =
|
||||
instruction.callstatic.stackBefore = dit, arg1, ..., argN
|
||||
instruction.callstatic.stackAfter = waarde
|
||||
instruction.callstatic.operands = methode, argCount
|
||||
instruction.callsuper.shortDescription = Roep de methode aan op de bovenliggende klasse
|
||||
instruction.callsuper.stackBefore = obj, [ns], [name], arg1, ..., argN
|
||||
instruction.callsuper.stackAfter = waarde
|
||||
instruction.callsuper.operands = methodName, argCount
|
||||
instruction.callproperty.shortDescription = Roep eigenschap aan
|
||||
instruction.callproperty.stackBefore = obj, [ns], [name], arg1, ..., argN
|
||||
instruction.callproperty.stackAfter = waarde
|
||||
instruction.callproperty.operands = eigenschap, argCount
|
||||
instruction.returnvoid.shortDescription = Terugkeer van een methode
|
||||
instruction.returnvalue.shortDescription = Terugkeer van een methode
|
||||
instruction.returnvalue.stackBefore = waarde
|
||||
instruction.constructsuper.shortDescription = Roep de bovenliggende constructor van een object op
|
||||
instruction.constructsuper.stackBefore = obj, arg1, ..., argN
|
||||
instruction.constructsuper.operands = argCount
|
||||
instruction.constructprop.shortDescription = Construeer een eigenschap van een object
|
||||
instruction.constructprop.stackBefore = obj, [ns], [name], arg1, ..., argN
|
||||
instruction.constructprop.stackAfter = waarde
|
||||
instruction.constructprop.operands = eigenschap, argCount
|
||||
#Undocumented:
|
||||
instruction.callsuperid.shortDescription = Roep super-id op
|
||||
#instruction.callsuperid.stackBefore =
|
||||
#instruction.callsuperid.stackAfter =
|
||||
#instruction.callsuperid.operands =
|
||||
instruction.callproplex.shortDescription = Roep eigenschap met null als volgt op
|
||||
instruction.callproplex.stackBefore = obj, [ns], [name], arg1, ..., argN
|
||||
instruction.callproplex.stackAfter = waarde
|
||||
instruction.callproplex.operands = eigenschap, argCount
|
||||
#Undocumented:
|
||||
instruction.callinterface.shortDescription = Roep interface op
|
||||
#instruction.callinterface.stackBefore =
|
||||
#instruction.callinterface.stackAfter =
|
||||
instruction.callinterface.operands = interface, argCount
|
||||
instruction.callsupervoid.shortDescription = Roep de methode aan op de bovenliggende klasse en negeer de retourwaarde
|
||||
instruction.callsupervoid.stackBefore = obj, [ns], [name], arg1, ..., argN
|
||||
instruction.callsupervoid.operands = methodName, argCount
|
||||
instruction.callpropvoid.shortDescription = Roep eigenschap op, negeer de geretourneerde waarde
|
||||
instruction.callpropvoid.stackBefore = obj, [ns], [name], arg1, ..., argN
|
||||
instruction.callpropvoid.operands = property, argCount
|
||||
instruction.sxi1.shortDescription = Teken breidt de waarde van 1 bit uit naar 32 bits
|
||||
instruction.sxi1.stackBefore = waarde
|
||||
instruction.sxi1.stackAfter = valueExtended
|
||||
instruction.sxi8.shortDescription = Teken breidt de 8-bits waarde uit naar 32 bits
|
||||
instruction.sxi8.stackBefore = waarde
|
||||
instruction.sxi8.stackAfter = valueExtended
|
||||
instruction.sxi16.shortDescription = Teken breidt de 16-bits waarde uit naar 32 bits
|
||||
instruction.sxi16.stackBefore = waarde
|
||||
instruction.sxi16.stackAfter = valueExtended
|
||||
instruction.applytype.shortDescription = Pas typeparameters toe
|
||||
instruction.applytype.description = Pas parametertypen toe op het basistype. Bijvoorbeeld wanneer Vector<String> tijdens runtime wordt opgelost. String is parameter, Vector is basisklasse.
|
||||
instruction.applytype.stackBefore = baseType, typeParam1, ..., typeParamN
|
||||
instruction.applytype.stackAfter = baseType<typeParam1, ..., typeParamN>
|
||||
instruction.applytype.operands = typeParamCount
|
||||
instruction.pushfloat4.shortDescription = Push de float4-waarde op de stapel
|
||||
instruction.pushfloat4.stackAfter = float4Value
|
||||
instruction.pushfloat4.operands = float4
|
||||
instruction.newobject.shortDescription = Cre\u00ebert een nieuw object
|
||||
instruction.newobject.stackBefore = name1, value1, name2, value2, ..., nameN, valueN
|
||||
instruction.newobject.stackAfter = newObject
|
||||
instruction.newobject.operands = propertyCount
|
||||
instruction.newarray.shortDescription = Cre\u00ebert een nieuw array
|
||||
instruction.newarray.stackBefore = value1, value2, ..., valueN
|
||||
instruction.newarray.stackAfter = newArray
|
||||
instruction.newarray.operands = valueCount
|
||||
instruction.newactivation.shortDescription = Cre\u00ebert een nieuw activatie object
|
||||
instruction.newactivation.stackAfter = new Activation
|
||||
instruction.newclass.shortDescription = Cre\u00ebert een nieuwe klasse
|
||||
instruction.newclass.stackBefore = baseType
|
||||
instruction.newclass.stackAfter = newClass
|
||||
instruction.newclass.operands = klasse
|
||||
instruction.getdescendants.shortDescription = Get descendants
|
||||
instruction.getdescendants.stackBefore = obj, [ns], [name]
|
||||
instruction.getdescendants.stackAfter = waarde
|
||||
instruction.getdescendants.operands = operand1
|
||||
instruction.newcatch.shortDescription = Cre\u00ebert een nieuwe catch scope
|
||||
instruction.newcatch.stackAfter = catchScope
|
||||
instruction.newcatch.operands = uitzondering
|
||||
#Undocumented:
|
||||
instruction.deldescendants.shortDescription = Verwijder nakomelingen
|
||||
#instruction.deldescendants.stackBefore =
|
||||
#instruction.deldescendants.stackAfter =
|
||||
instruction.deldescendants.operands = multinameIndex
|
||||
#Undocumented:
|
||||
instruction.findpropglobal.shortDescription = Zoek eigenschap in globale scope
|
||||
instruction.findpropglobal.stackBefore = [ns], [name]
|
||||
instruction.findpropglobal.stackAfter = obj
|
||||
instruction.findpropglobal.operands = eigenschap
|
||||
instruction.findpropstrict.shortDescription = Zoek eigenschap in scopestack, fout wanneer niet gevonden
|
||||
instruction.findpropstrict.stackBefore = [ns], [name]
|
||||
instruction.findpropstrict.stackAfter = obj
|
||||
instruction.findpropstrict.operands = eigenschap
|
||||
instruction.findproperty.shortDescription = Zoek eigenschap in scope-stack, bovenste object wanneer niet gevonden
|
||||
instruction.findproperty.stackBefore = [ns], [name]
|
||||
instruction.findproperty.stackAfter = obj
|
||||
instruction.findproperty.operands = eigenschap
|
||||
#Undocumented:
|
||||
instruction.finddef.shortDescription = Definitie van zoekscriptniveau
|
||||
instruction.finddef.stackBefore = [ns], [name]
|
||||
instruction.finddef.stackAfter = obj
|
||||
instruction.finddef.operands = eigenschap
|
||||
instruction.getlex.shortDescription = Vind en haal eigenschap op
|
||||
instruction.getlex.stackAfter = obj
|
||||
instruction.getlex.operands = eigenschap
|
||||
instruction.setproperty.shortDescription = Stel de eigenschap in
|
||||
instruction.setproperty.description =
|
||||
instruction.setproperty.stackBefore = obj, [ns], [name], value
|
||||
instruction.setproperty.operands = eigenschap
|
||||
instruction.getlocal.shortDescription = Haal lokale registerwaarde op
|
||||
instruction.getlocal.stackAfter = waarde
|
||||
instruction.getlocal.operands = localRegIndex
|
||||
instruction.setlocal.shortDescription = Stel lokale registerwaarde in
|
||||
instruction.setlocal.stackBefore = waarde
|
||||
instruction.setlocal.operands = localRegIndex
|
||||
instruction.getglobalscope.shortDescription = Krijg lokale scope
|
||||
instruction.getglobalscope.stackAfter = obj
|
||||
instruction.getscopeobject.shortDescription = Haal het scope-object op van de lokale scope-stack
|
||||
instruction.getscopeobject.stackAfter = obj
|
||||
instruction.getscopeobject.operands = scopeIndex
|
||||
instruction.getproperty.shortDescription = Haal eigenschap op
|
||||
instruction.getproperty.stackBefore = obj, [ns], [name]
|
||||
instruction.getproperty.stackAfter = waarde
|
||||
instruction.getproperty.operands = eigenschap
|
||||
instruction.getouterscope.shortDescription = Haal het scope-object op van de buitenste scope-stack
|
||||
instruction.getouterscope.stackAfter = obj
|
||||
instruction.getouterscope.operands = scopeIndex
|
||||
instruction.initproperty.shortDescription = Initialiseer eigenschap
|
||||
instruction.initproperty.stackBefore = obj, [ns], [name], value
|
||||
instruction.initproperty.operands = eigenschap
|
||||
#Undocumented:
|
||||
instruction.setpropertylate.shortDescription = Stel eigenschap (op basis van stack) in
|
||||
#instruction.setpropertylate.stackBefore =
|
||||
#instruction.setpropertylate.stackAfter =
|
||||
#instruction.setpropertylate.operands =
|
||||
instruction.deleteproperty.shortDescription = Eigenschap verwijderen
|
||||
instruction.deleteproperty.stackBefore = obj, [ns], [name]
|
||||
instruction.deleteproperty.stackAfter = boolResult
|
||||
instruction.deleteproperty.operands = eigenschap
|
||||
#Undocumented:
|
||||
instruction.deletepropertylate.shortDescription = Eigenschap verwijderen (op bais van stack)
|
||||
instruction.getslot.shortDescription = Haal de waarde op van een slot
|
||||
instruction.getslot.stackBefore = obj
|
||||
instruction.getslot.stackAfter = waarde
|
||||
instruction.getslot.operands = slotIndex
|
||||
instruction.setslot.shortDescription = Stel de waarde van en slot in
|
||||
instruction.setslot.stackBefore = obj, value
|
||||
instruction.setslot.operands = slotIndex
|
||||
instruction.getglobalslot.shortDescription = Haal de waarde op van een slot uit de 'global scope'
|
||||
instruction.getglobalslot.description =
|
||||
instruction.getglobalslot.stackAfter = waarde
|
||||
instruction.getglobalslot.operands = slotIndex
|
||||
instruction.setglobalslot.shortDescription = Haal de waarde op van een slot uit de 'global scope'
|
||||
instruction.setglobalslot.stackBefore = waarde
|
||||
instruction.setglobalslot.operands = slotIndex
|
||||
instruction.convert_s.shortDescription = Converteer waarde naar string
|
||||
instruction.convert_s.description =
|
||||
instruction.convert_s.stackBefore = waarde
|
||||
instruction.convert_s.stackAfter = stringValue
|
||||
instruction.esc_xelem.shortDescription = Escape XML-element
|
||||
instruction.esc_xelem.stackBefore = waarde
|
||||
instruction.esc_xelem.stackAfter = stringValue
|
||||
instruction.esc_xattr.shortDescription = Escape XML-attribuut
|
||||
instruction.esc_xattr.stackBefore = waarde
|
||||
instruction.esc_xattr.stackAfter = stringValue
|
||||
instruction.esc_xattr.operands =
|
||||
instruction.convert_i.shortDescription = Converteer waarde naar integer
|
||||
instruction.convert_i.stackBefore = waarde
|
||||
instruction.convert_i.stackAfter = intValue
|
||||
instruction.convert_u.shortDescription = Converteer waarde naar een ongetekende integer
|
||||
instruction.convert_u.stackBefore = waarde
|
||||
instruction.convert_u.stackAfter = uintValue
|
||||
instruction.convert_d.shortDescription = Converteer waarde naar 'double'
|
||||
instruction.convert_d.stackBefore = waarde
|
||||
instruction.convert_d.stackAfter = doubleValue
|
||||
instruction.convert_b.shortDescription = Converteer waarde naar booleaan
|
||||
instruction.convert_b.stackBefore = waarde
|
||||
instruction.convert_b.stackAfter = booleanValue
|
||||
instruction.convert_o.shortDescription = Converteer waarde naar object
|
||||
instruction.convert_o.stackBefore = waarde
|
||||
instruction.convert_o.stackAfter = waarde
|
||||
instruction.checkfilter.shortDescription = Controleer of op het object een filterbewerking kan worden toegepast
|
||||
instruction.checkfilter.stackBefore = waarde
|
||||
instruction.checkfilter.stackAfter = waarde
|
||||
instruction.convert_m.shortDescription = Converteer waarde naar decimaal
|
||||
instruction.convert_m.stackBefore = waarde
|
||||
instruction.convert_m.stackAfter = decimalValue
|
||||
instruction.convert_m_p.shortDescription = Converteer waarde naar decimaal met getalcontext
|
||||
instruction.convert_m_p.description =
|
||||
instruction.convert_m_p.stackBefore = waarde
|
||||
instruction.convert_m_p.stackAfter = decimalValue
|
||||
instruction.convert_m_p.operands = numberContext
|
||||
instruction.convert_f.shortDescription = Converteer waarde naar 'float'
|
||||
instruction.convert_f.stackBefore = value
|
||||
instruction.convert_f.stackAfter = floatValue
|
||||
instruction.convert_f4.shortDescription = Converteer waarde naar float4
|
||||
instruction.convert_f4.stackBefore = waarde
|
||||
instruction.convert_f4.stackAfter = float4Value
|
||||
instruction.coerce.shortDescription = Dwing waarde naar gespecificeerd type
|
||||
instruction.coerce.stackBefore = waarde
|
||||
instruction.coerce.stackAfter = coercedValue
|
||||
instruction.coerce.operands = type
|
||||
instruction.coerce_b.shortDescription = Dwing waarde af naar booleaan
|
||||
instruction.coerce_b.stackBefore = waarde
|
||||
instruction.coerce_b.stackAfter = booleanValue
|
||||
instruction.coerce_b.deprecated = Gebruik in plaats daarvan convert_b
|
||||
instruction.coerce_a.shortDescription = Dwing waarde af voor elk type
|
||||
instruction.coerce_a.stackBefore = waarde
|
||||
instruction.coerce_a.stackAfter = waarde
|
||||
instruction.coerce_i.shortDescription = Dwing waarde af naar integer
|
||||
instruction.coerce_i.stackBefore = waarde
|
||||
instruction.coerce_i.stackAfter = intValue
|
||||
instruction.coerce_i.deprecated = Use convert_i instead
|
||||
instruction.coerce_d.shortDescription = Dwing waarde af naar 'double'
|
||||
instruction.coerce_d.stackBefore = waarde
|
||||
instruction.coerce_d.stackAfter = doubleValue
|
||||
instruction.coerce_d.deprecated = Gebruik in plaats daarvan convert_d
|
||||
instruction.coerce_s.shortDescription = Dwing waarde af naar string
|
||||
instruction.coerce_s.stackBefore = waarde
|
||||
instruction.coerce_s.stackAfter = stringVAlue
|
||||
instruction.astype.shortDescription = Retourneert dezelfde waarde of null als er geen type is opgegeven
|
||||
instruction.astype.stackBefore = waarde
|
||||
instruction.astype.stackAfter = waarde
|
||||
instruction.astype.operands = type
|
||||
instruction.astypelate.shortDescription = Retourneert dezelfde waarde of null als het type niet is opgegeven (op stack gebaseerd)
|
||||
instruction.astypelate.description =
|
||||
instruction.astypelate.stackBefore = waarde, type
|
||||
instruction.astypelate.stackAfter = waarde
|
||||
instruction.coerce_u.shortDescription = Dwing waarde af naar ongetekende integer
|
||||
instruction.coerce_u.stackBefore = waarde
|
||||
instruction.coerce_u.stackAfter = uintValue
|
||||
instruction.coerce_o.shortDescription = Dwing waarde af naar object
|
||||
instruction.coerce_o.stackBefore = waarde
|
||||
instruction.coerce_o.stackAfter = waarde
|
||||
instruction.negate_p.shortDescription = Negeer waarde met behulp van getalcontext
|
||||
instruction.negate_p.stackBefore = waarde
|
||||
instruction.negate_p.stackAfter = -waarde
|
||||
instruction.negate_p.operands = numberContext
|
||||
instruction.negate.shortDescription = Negeer waarde
|
||||
instruction.negate.stackBefore = waarde
|
||||
instruction.negate.stackAfter = -waarde
|
||||
instruction.increment.shortDescription = Verhoog waarde
|
||||
instruction.increment.stackBefore = waarde
|
||||
instruction.increment.stackAfter = incrementedValue
|
||||
instruction.inclocal.shortDescription = Verhoog lokale register
|
||||
instruction.inclocal.operands = localRegister
|
||||
instruction.decrement.shortDescription = Verlaag waarde
|
||||
instruction.decrement.stackBefore = waarde
|
||||
instruction.decrement.stackAfter = decrementedValue
|
||||
instruction.declocal.shortDescription = Verlaag lokaal register
|
||||
instruction.declocal.operands = localRegister
|
||||
instruction.typeof.shortDescription = Haal naam van waardetype op
|
||||
instruction.typeof.stackBefore = waarde
|
||||
instruction.typeof.stackAfter = typeName
|
||||
instruction.not.shortDescription = Negeer Boolean
|
||||
instruction.not.stackBefore = waarde
|
||||
instruction.not.stackAfter = !waarde
|
||||
instruction.bitnot.shortDescription = Bitsgewijs negeren
|
||||
instruction.bitnot.stackBefore = waarde
|
||||
instruction.bitnot.stackAfter = ~waarde
|
||||
#Undocumented:
|
||||
instruction.concat.shortDescription = Concat
|
||||
#instruction.concat.stackBefore =
|
||||
#instruction.concat.stackAfter =
|
||||
#instruction.concat.operands =
|
||||
#Undocumented:
|
||||
instruction.add_d.shortDescription = Add_d
|
||||
#instruction.add_d.stackBefore =
|
||||
#instruction.add_d.stackAfter =
|
||||
#instruction.add_d.operands =
|
||||
instruction.increment_p.shortDescription = Verhoog de waarde met behulp van getalcontext
|
||||
instruction.increment_p.stackBefore = waarde
|
||||
instruction.increment_p.stackAfter = incrementedValue
|
||||
instruction.increment_p.operands = numberContext
|
||||
instruction.inclocal_p.shortDescription = Verhoog het lokale register met behulp van nummercontext
|
||||
instruction.inclocal_p.operands = numberContext, localRegister
|
||||
instruction.decrement_p.shortDescription = Verlaag de waarde met behulp van getalcontext
|
||||
instruction.decrement_p.stackBefore = waarde
|
||||
instruction.decrement_p.stackAfter = decrementedValue
|
||||
instruction.decrement_p.operands = numberContext
|
||||
instruction.declocal_p.shortDescription = Verlaag het lokale register met behulp van nummercontext
|
||||
instruction.declocal_p.operands = numberContext, localRegister
|
||||
instruction.add.shortDescription = Voeg twee waarden toe
|
||||
instruction.add.stackBefore = waarde1, waarde2
|
||||
instruction.add.stackAfter = waarde3
|
||||
instruction.subtract.shortDescription = Trek twee waarden van elkaar af
|
||||
instruction.subtract.stackBefore = waarde1, waarde2
|
||||
instruction.subtract.stackAfter = waarde3
|
||||
instruction.multiply.shortDescription = Vermenigvuldig twee waarden
|
||||
instruction.multiply.stackBefore = waarde1, waarde2
|
||||
instruction.multiply.stackAfter = waarde3
|
||||
instruction.divide.shortDescription = Deel twee waarden
|
||||
instruction.divide.stackBefore = waarde1, waarde2
|
||||
instruction.divide.stackAfter = waarde3
|
||||
instruction.modulo.shortDescription = Module van twee te delen waarden
|
||||
instruction.modulo.stackBefore = waarde1, waarde2
|
||||
instruction.modulo.stackAfter = waarde3
|
||||
instruction.lshift.shortDescription = Bitgewijs links schuiven
|
||||
instruction.lshift.stackBefore = waarde1, waarde2
|
||||
instruction.lshift.stackAfter = waarde3
|
||||
instruction.rshift.shortDescription = Bitgewijs rechts schuiven
|
||||
instruction.rshift.stackBefore = waarde1, waarde2
|
||||
instruction.rshift.stackAfter = waarde3
|
||||
instruction.urshift.shortDescription = Niet-ondertekende bitsgewijze verschuiving naar rechts
|
||||
instruction.urshift.stackBefore = waarde1, waarde2
|
||||
instruction.urshift.stackAfter = waarde3
|
||||
instruction.bitand.shortDescription = Bitgewijs en (and)
|
||||
instruction.bitand.stackBefore = waarde1, waarde2
|
||||
instruction.bitand.stackAfter = waarde3
|
||||
instruction.bitor.shortDescription = Bitgewijs of (or)
|
||||
instruction.bitor.stackBefore = waarde1, waarde2
|
||||
instruction.bitor.stackAfter = waarde3
|
||||
instruction.bitxor.shortDescription = Bitgewijs exclusief of (xor)
|
||||
instruction.bitxor.stackBefore = waarde1, waarde2
|
||||
instruction.bitxor.stackAfter = waarde3
|
||||
instruction.equals.shortDescription = Vergelijk twee waarden
|
||||
instruction.equals.stackBefore = waarde1, waarde2
|
||||
instruction.equals.stackAfter = booleanResult
|
||||
instruction.equals.operands =
|
||||
instruction.strictequals.shortDescription = Vergelijk twee waarden strikt
|
||||
instruction.strictequals.stackBefore = waarde1, waarde2
|
||||
instruction.strictequals.stackAfter = booleanResult
|
||||
instruction.lessthan.shortDescription = Controleer of de waarde kleiner is dan de andere waarde
|
||||
instruction.lessthan.stackBefore = waarde1, waarde2
|
||||
instruction.lessthan.stackAfter = booleanResult
|
||||
instruction.lessequals.shortDescription = Controleer of de waarde kleiner of gelijk is aan de andere waarde
|
||||
instruction.lessequals.stackBefore = waarde1, waarde2
|
||||
instruction.lessequals.stackAfter = booleanResult
|
||||
instruction.lessequals.operands = booleanResult
|
||||
instruction.greaterthan.shortDescription = Controleer of de waarde groter is dan de andere waarde
|
||||
instruction.greaterthan.stackBefore = waarde1, waarde2
|
||||
instruction.greaterthan.stackAfter = booleanResult
|
||||
instruction.greaterequals.shortDescription = Controleer of de waarde groter of gelijk is dan de andere waarde
|
||||
instruction.greaterequals.stackBefore = waarde1, waarde2
|
||||
instruction.greaterequals.stackAfter = booleanResult
|
||||
instruction.instanceof.shortDescription = Controleer of het type bestaat in de object-prototype-keten
|
||||
instruction.instanceof.stackBefore = waarde, type
|
||||
instruction.instanceof.stackAfter = booleanResult
|
||||
instruction.istype.shortDescription = Controleer of het object van het opgegeven type is
|
||||
instruction.istype.stackBefore = waarde
|
||||
instruction.istype.stackAfter = booleanResult
|
||||
instruction.istype.operands = type
|
||||
instruction.istypelate.shortDescription = Controleer of het object van het opgegeven type is (stack gebaseerd)
|
||||
instruction.istypelate.stackBefore = waarde, type
|
||||
instruction.istypelate.stackAfter = booleanResult
|
||||
instruction.in.shortDescription = Controleer of het object een benoemde naam heeft
|
||||
instruction.in.stackBefore = naam, obj
|
||||
instruction.in.stackAfter = booleanResult
|
||||
instruction.add_p.shortDescription = Voeg twee waarden toe met behulp van de getalcontext
|
||||
instruction.add_p.stackBefore = waarde1, waarde2
|
||||
instruction.subtract_p.shortDescription = Trek twee waarden af \u200b\u200bmet behulp van de getalcontext
|
||||
instruction.subtract_p.stackBefore = waarde1, waarde2
|
||||
instruction.subtract_p.stackAfter = waarde3
|
||||
instruction.multiply_p.shortDescription = Vermenigvuldig twee waarden met behulp van de getalcontext
|
||||
instruction.multiply_p.stackBefore = waarde1, waarde2
|
||||
instruction.multiply_p.stackAfter = waarde3
|
||||
instruction.multiply_p.operands = numberContext
|
||||
instruction.divide_p.shortDescription = Deel twee waarden op elkaar met behulp van de getalcontext
|
||||
instruction.divide_p.stackBefore = waarde1, waarde2
|
||||
instruction.divide_p.stackAfter = waarde3
|
||||
instruction.modulo_p.shortDescription = Modulo deel twee waarden op elkaar met behulp van getalcontext
|
||||
instruction.modulo_p.stackBefore = waarde1, waarde2
|
||||
instruction.modulo_p.stackAfter = waarde3
|
||||
instruction.modulo_p.operands = numberContext
|
||||
instruction.increment_i.shortDescription = Verhoog integer waarde
|
||||
instruction.increment_i.stackBefore = waarde
|
||||
instruction.increment_i.stackAfter = incrementedValue
|
||||
instruction.decrement_i.shortDescription = Verlaag integer waarde
|
||||
instruction.decrement_i.stackBefore = waarde
|
||||
instruction.decrement_i.stackAfter = decrementedValue
|
||||
instruction.inclocal_i.shortDescription = Verhoog de integer waarde van het lokale register
|
||||
instruction.inclocal_i.operands = localRegister
|
||||
instruction.declocal_i.shortDescription = Verlaag de integer waarde van het lokale register
|
||||
instruction.declocal_i.operands = localRegister
|
||||
instruction.negate_i.shortDescription = Negeer integer waarde
|
||||
instruction.negate_i.stackBefore = waarde
|
||||
instruction.negate_i.stackAfter = -waarde
|
||||
instruction.add_i.shortDescription = Voeg twee integer waarde toe
|
||||
instruction.add_i.stackBefore = waarde1, waarde2
|
||||
instruction.add_i.stackAfter = waarde3
|
||||
instruction.subtract_i.shortDescription = Trek twee integer waarden van elkaar af
|
||||
instruction.subtract_i.stackBefore = waard1, waarde2
|
||||
instruction.subtract_i.stackAfter = waarde3
|
||||
instruction.multiply_i.shortDescription = Vermenigvuldig twee integer waarden met elkaar
|
||||
instruction.multiply_i.stackBefore = waarde1, waarde2
|
||||
instruction.multiply_i.stackAfter = waarde3
|
||||
instruction.getlocal0.shortDescription = Haal lokaal register 0 op
|
||||
instruction.getlocal0.stackAfter = waarde
|
||||
instruction.getlocal1.shortDescription = Haal lokaal register 1 op
|
||||
instruction.getlocal1.stackAfter = waarde
|
||||
instruction.getlocal2.shortDescription = Haal lokaal register 2 op
|
||||
instruction.getlocal2.stackAfter = waarde
|
||||
instruction.getlocal3.shortDescription = Haal lokaal register 3 op
|
||||
instruction.getlocal3.stackAfter = waarde
|
||||
instruction.setlocal0.shortDescription = Stel lokaal register 0 in
|
||||
instruction.setlocal0.stackBefore = waarde
|
||||
instruction.setlocal1.shortDescription = Stel lokaal register 1 in
|
||||
instruction.setlocal1.stackBefore = waarde
|
||||
instruction.setlocal2.shortDescription = Stel lokaal register 2 in
|
||||
instruction.setlocal2.stackBefore = waarde
|
||||
instruction.setlocal3.shortDescription = Stel lokaal register 3 in
|
||||
instruction.setlocal3.stackBefore = waarde
|
||||
#Undocumented:
|
||||
instruction.invalid.shortDescription = Ongeldig
|
||||
#instruction.invalid.stackBefore =
|
||||
#instruction.invalid.stackAfter =
|
||||
#instruction.invalid.operands =
|
||||
#Undocumented:
|
||||
instruction.abs_jump.shortDescription = Absolute sprong
|
||||
#instruction.abs_jump.stackBefore =
|
||||
#instruction.abs_jump.stackAfter =
|
||||
#instruction.abs_jump.operands =
|
||||
instruction.debug.shortDescription = Foutopsporingsinformatie
|
||||
instruction.debug.operands = debugType, regName, localRegister, extra
|
||||
instruction.debugline.shortDescription = Foutopsporing in regelnummerinformatie
|
||||
instruction.debugline.operands = lineNumber
|
||||
instruction.debugfile.shortDescription = Foutopsporing in bestandsinformatie
|
||||
instruction.debugfile.operands = fileName
|
||||
instruction.bkptline.shortDescription = Breekpunt op regel
|
||||
#Undocumented:
|
||||
instruction.timestamp.shortDescription = Tijdstempel
|
||||
instruction.timestamp.operands =
|
||||
#Undocumented:
|
||||
instruction.verifypass.shortDescription = Verifieer wachtw.
|
||||
#instruction.verifypass.stackBefore =
|
||||
#instruction.verifypass.stackAfter =
|
||||
#instruction.verifypass.operands =
|
||||
#Undocumented:
|
||||
instruction.alloc.shortDescription = Alloceer
|
||||
#instruction.alloc.stackBefore =
|
||||
#instruction.alloc.stackAfter =
|
||||
#instruction.alloc.operands =
|
||||
#Undocumented:
|
||||
instruction.mark.shortDescription = Markeer
|
||||
#instruction.mark.stackBefore =
|
||||
#instruction.mark.stackAfter =
|
||||
#instruction.mark.operands =
|
||||
#Undocumented:
|
||||
instruction.wb.shortDescription = Wb
|
||||
#instruction.wb.stackBefore =
|
||||
#instruction.wb.stackAfter =
|
||||
#instruction.wb.operands =
|
||||
#Undocumented:
|
||||
instruction.prologue.shortDescription = Proloog
|
||||
#instruction.prologue.stackBefore =
|
||||
#instruction.prologue.stackAfter =
|
||||
#instruction.prologue.operands =
|
||||
#Undocumented:
|
||||
instruction.sendenter.shortDescription = Stuur 'enter'
|
||||
#instruction.sendenter.stackBefore =
|
||||
#instruction.sendenter.stackAfter =
|
||||
#instruction.sendenter.operands =
|
||||
#Undocumented:
|
||||
instruction.doubletoatom.shortDescription = Verdubbel tot atoom
|
||||
#instruction.doubletoatom.stackBefore =
|
||||
#instruction.doubletoatom.stackAfter =
|
||||
#instruction.doubletoatom.operands =
|
||||
#Undocumented:
|
||||
instruction.sweep.shortDescription = Vegen
|
||||
#instruction.sweep.stackBefore =
|
||||
#instruction.sweep.stackAfter =
|
||||
#instruction.sweep.operands =
|
||||
#Undocumented:
|
||||
instruction.codegenop.shortDescription = CodeGenOp
|
||||
#instruction.codegenop.stackBefore =
|
||||
#instruction.codegenop.stackAfter =
|
||||
#instruction.codegenop.operands =
|
||||
#Undocumented:
|
||||
instruction.verifyop.shortDescription = VerifyOp
|
||||
#instruction.verifyop.stackBefore =
|
||||
#instruction.verifyop.stackAfter =
|
||||
#instruction.verifyop.operands =
|
||||
#Undocumented:
|
||||
instruction.decode.shortDescription = Decoderen
|
||||
#instruction.decode.stackBefore =
|
||||
#instruction.decode.stackAfter =
|
||||
#instruction.decode.operands =
|
||||
instruction.unplus.shortDescription = Unair plus - dwang tot numeriek
|
||||
instruction.unplus.stackBefore = waarde
|
||||
instruction.unplus.stackAfter = waarde
|
||||
instruction.pushconstant.shortDescription = Push constant value on stack
|
||||
#instruction.pushconstant.stackBefore =
|
||||
#instruction.pushconstant.stackAfter =
|
||||
instruction.pushconstant.operands = waarde
|
||||
Reference in New Issue
Block a user