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
