mirror of
https://gitflic.ru/project/openide/openide.git
synced 2025-12-13 06:59:44 +07:00
551 lines
36 KiB
INI
551 lines
36 KiB
INI
evaluation.error.empty.code.fragment=Code fragment expected
|
|
evaluation.error.cannot.evaluate.tostring=Cannot evaluate {0}.toString()
|
|
evaluation.error.unsupported.expression.type=Unsupported expression type
|
|
evaluation.error.object.is.being.initialized=Object is being initialized
|
|
internal.error.locations.of.line=Internal error loading debug information from ''{0}''. Breakpoints will be unavailable in this class.
|
|
evaluation.error.inconsistent.debug.info=Debug information is inconsistent
|
|
evaluation.error.boolean.value.expected.in.condition='boolean' value expected in condition
|
|
evaluation.error.boolean.condition.expected='boolean' value expected in condition
|
|
evaluation.error.process.exited=Cannot evaluate: process exited
|
|
evaluation.error.stack.frame.unavailable=Stack frame unavailable
|
|
evaluation.error.nested.evaluation=Evaluation is not supported during another method's evaluation
|
|
evaluation.error.sources.out.of.sync=Sources do not correspond to code being executed
|
|
evaluation.error.cannot.find.stackframe.source=Cannot find source class for current stack frame
|
|
evaluation.error.cannot.find.source=Cannot find source class for {0}
|
|
evaluation.error.object.collected=Object has been collected
|
|
evaluation.error.thread.collected=Thread has been collected
|
|
evaluation.error.array.collected=Array has been collected
|
|
evaluation.error.thread.resumed=Thread has been resumed
|
|
evaluation.error.debug.info.unavailable=Debug info unavailable
|
|
evaluation.error.invalid.expression=Invalid expression : {0}
|
|
evaluation.error.unknown.expression.type=Expression type unknown: {0}
|
|
evaluation.error.unknown.expression.operand=Expression operand unknown: {0}
|
|
evaluation.error.type.mismatch=Type mismatch
|
|
evaluation.error.class.not.loaded=Class ''{0}'' is not loaded
|
|
evaluation.error.thread.not.at.breakpoint=Cannot evaluate methods after Pause action
|
|
evaluation.error.method.exception=Method threw ''{0}'' exception.
|
|
evaluation.error.surrounded.expression.null=Surrounded expression is null
|
|
title.customize.data.views=Customize Data Views
|
|
title.evaluating=Evaluating\u2026
|
|
error.native.method.exception=None of the frames through and including frame may be native
|
|
error.executing.finally=Error while executing finally blocks: {0}
|
|
error.early.return=Error while doing early return: {0}
|
|
error.throw.exception=Error while throwing exception: {0}
|
|
warning.finally.block.detected=Non-empty finally blocks detected:
|
|
button.drop.anyway=Do Not Execute
|
|
button.execute.finally=Execute Finally Blocks
|
|
drop.frame.error.no.information=Information about the frame is not available
|
|
progress.evaluating=Evaluating {0}
|
|
action.resume.thread.text.resume=Resume
|
|
action.interrupt.thread.text=Interrupt
|
|
title.set.value=Set Value
|
|
warning.recalculate=The value will be recalculated
|
|
warning.source.code.not.match=Source code does not match the bytecode
|
|
action.add.field.watchpoint.text=Add Field Watchpoint
|
|
status.process.started=Process started
|
|
status.process.terminated=Process terminated
|
|
status.disconnected=Disconnected from the target VM, address: {0}
|
|
status.stopped.at.cursor=Stopped at cursor
|
|
status.line.breakpoint.reached=Breakpoint reached at {0}({1}:{2,number,#})
|
|
status.line.breakpoint.reached.full.trace=Breakpoint reached
|
|
status.generic.breakpoint.reached=Breakpoint reached
|
|
status.thread.blocked.by=Stepping in thread {0} is blocked by thread {1}
|
|
status.thread.blocked.by.resume=<a href="#">Resume {0}</a>
|
|
status.breakpoint.reached.in.thread=Breakpoint reached in thread {0}
|
|
status.breakpoint.reached.in.thread.switch=<a href="#">Switch thread</a>
|
|
status.method.entry.breakpoint.reached=Method ''{0}'' entered at {1}({2}:{3,number,#})
|
|
status.method.exit.breakpoint.reached=Method breakpoint reached. Method ''{0}'' is about to exit at {1}({2}:{3,number,#})
|
|
status.field.watchpoint.reached.access='{'{0}@{5}'}'.{1} will be accessed at {2}({3}:{4,number,#})
|
|
status.static.field.watchpoint.reached.access={0}.{1} will be accessed at {2}({3}:{4,number,#})
|
|
status.field.watchpoint.reached.modification='{'{0}@{7}'}'.{1} will be modified at {4}({5}:{6,number,#}). Current value = ''{2}''. New value = ''{3}''
|
|
status.static.field.watchpoint.reached.modification={0}.{1} will be modified at {4}({5}:{6,number,#}). Current value = ''{2}''. New value = ''{3}''
|
|
status.connected=Connected to the target VM, address: {0}
|
|
status.connect.failed=Failed to establish connection to the target VM, address: {0}
|
|
error.debugger.already.listening=Debugger is already listening
|
|
transport.name.shared.memory=shared memory
|
|
transport.name.socket=socket
|
|
error.debug.connector.not.found=Required connector ''{0}'' not found. Check your JDK installation.
|
|
error.no.debug.listen.port=The port to listen at unspecified
|
|
error.no.debug.attach.port=The port to attach to unspecified
|
|
error.no.shmem.address=Shared memory address unspecified
|
|
error.no.pid=Pid is not specified
|
|
debugger.jdi.bootstrap.error={0}. Check your JDK installation.
|
|
warning.jdk140.unstable=The debuggee VM version is "1.4.0".\nJ2SDK 1.4.0 documented bugs may cause unstable debugger behavior.\nWe recommend using J2SDK 1.4.0_01 or higher.
|
|
title.jdk140.unstable=VM Version Warning
|
|
message.remote.jre.version.mismatch=Target JRE version ({0})\ndoes not match project JDK version ({1}), \nwill use sources from JDK: {2}
|
|
message.breakpoint.skipped.during.evaluation=Skipped breakpoint at {0} because it happened inside debugger evaluation
|
|
message.breakpoint.skipped.other.vm=Skipped breakpoint at {0} because it happened outside current JVM
|
|
message.breakpoint.skipped.during.stepping.in.another.thread=Skipped breakpoint at {0} because of stepping in another thread
|
|
message.breakpoint.skipped.learn.more=Troubleshooting guide
|
|
message.other.threads.reached.breakpoints={0,choice,1#Another thread also reached a breakpoint|2#{0} other threads also reached breakpoints}
|
|
error.invalid.argument={0,choice, 1#Invalid argument|2#Invalid arguments}
|
|
error.vm.disconnected=VM disconnected. Target virtual machine closed connection
|
|
error.unknown.host=Cannot connect to remote process. Host is unknown
|
|
error.unknown.host.with.address=Cannot connect to remote process. Host is unknown ({0})
|
|
error.cannot.open.debugger.port=Unable to open debugger port
|
|
error.exception.while.connecting=Error connecting to remote process.\nException occurred: {0}\nException message: {1}
|
|
status.waiting.attach=Debugger is waiting for application to start
|
|
status.waiting.attach.address=debug address: {0}
|
|
status.listening=Listening to the connection, address: {0}
|
|
status.connecting=Connecting to the target VM, address: {0}
|
|
status.app.running=The application is running
|
|
status.debug.stopped=Debug stopped
|
|
status.waiting.evaluation.result=Waiting until last debugger command completes
|
|
status.step.out=Stepping out
|
|
status.step.into=Stepping into
|
|
status.step.over=Stepping over
|
|
status.run.to.cursor=Run to cursor
|
|
status.process.resumed=Process resumed
|
|
status.paused.in.another.thread=Paused in another thread
|
|
string.connection=''{0}'', transport: ''{1}''
|
|
error.pop.bottom.stackframe=Cannot pop bottom frame
|
|
error.pop.stackframe=An error occurred while popping stack frame: {0}
|
|
error.class.not.loaded=Class not loaded : {0}
|
|
string.file.line.position=Class at {0}:{1}
|
|
string.null.context=null context
|
|
evaluation.error.array.reference.expected=Array reference expected
|
|
evaluation.error.invalid.index.expression=Invalid index expression
|
|
evaluation.error.not.rvalue=Right part of the assignment is not a value
|
|
evaluation.error.not.lvalue=Left part of the assignment is not lvalue
|
|
evaluation.error.incompatible.types=Incompatible types for ''{0}'' operation
|
|
evaluation.error.lebeled.loops.not.found=No loop statements labeled with label ''{0}''
|
|
evaluation.error.variable.not.declared=Variable ''{0}'' is not declared
|
|
evaluation.error.variable.already.declared=Variable ''{0}'' is already declared
|
|
evaluation.error.operation.not.supported=Operation ''{0}'' is not supported
|
|
evaluation.error.statement.not.supported=Statement ''{0}'' is not supported
|
|
evaluation.error.incompatible.variable.initializer.type=Initializer for ''{0}'' has incompatible type
|
|
evaluation.error.local.variable.missing.from.class.closure=Local variable ''{0}'' not found in class closure
|
|
evaluation.error.local.variable.missing=Cannot find local variable ''{0}''
|
|
evaluation.error.cannot.resolve.field.class=Cannot resolve class containing field ''{0}''
|
|
evaluation.error.cannot.sources.for.field.class=Cannot find sources for class containing field ''{0}''
|
|
evaluation.error.identifier.expected=Identifier expected instead of ''{0}''
|
|
evaluation.error.cannot.evaluate.qualifier=Cannot evaluate qualifier ''{0}''
|
|
evaluation.error.invalid.array.dimension.expression=Invalid expression for array dimension: {0}
|
|
evaluation.error.multi.dimensional.arrays.creation.not.supported=Creation of multi-dimensional arrays not supported
|
|
evaluation.error.anonymous.class.evaluation.not.supported=Anonymous class evaluation is not supported
|
|
evaluation.error.lambda.evaluation.not.supported=Lambdas evaluation is not supported
|
|
evaluation.error.method.reference.evaluation.not.supported=Method reference evaluation is not supported
|
|
evaluation.error.signature.polymorphic.call.evaluation.not.supported=Signature polymorphic call evaluation is not supported
|
|
evaluation.error.no.static.field=No such static field: ''{0}''
|
|
evaluation.error.no.instance.field=No such instance field: ''{0}''
|
|
evaluation.error.class.or.array.expected=Class or array type expected while evaluating field ''{0}''
|
|
evaluation.error.evaluating.field=Error evaluating field : ''{0}''
|
|
evaluation.error.evaluating.method=Error evaluating method : ''{0}''
|
|
evaluation.error.object.reference.expected=Object reference expected
|
|
evaluation.error.no.stackframe=Cannot evaluate: stack frame unavailable
|
|
evaluation.error.no.static.method=No such static method: ''{0}''
|
|
evaluation.error.no.instance.method=No such instance method: ''{0}''
|
|
evaluation.error.array.type.expected=Array type expected
|
|
evaluation.error.array.dimention.numeric.value.expected=Numeric value expected as array dimension
|
|
evaluation.error.cannot.evaluate.array.initializer=Cannot evaluate array initializer
|
|
evaluation.error.incompatible.array.initializer.type=Initializer type is not assignment-compatible with array's component type
|
|
evaluation.error.invalid.array.size=Invalid array size
|
|
evaluation.error.cannot.initialize.array=Cannot initialize array
|
|
evaluation.error.cannot.evaluate.class.type=Cannot evaluate class type
|
|
evaluation.error.cannot.resolve.constructor=Cannot resolve constructor ''{0}''
|
|
evaluation.error.this.not.avalilable='this' is not available
|
|
evaluation.error.cannot.cast.null=Cannot cast null to ''{0}''
|
|
evaluation.error.cannot.cast.numeric=Cannot cast numeric value to ''{0}''
|
|
evaluation.error.cannot.cast.boolean=Cannot cast boolean value to ''{0}''
|
|
evaluation.error.cannot.cast.char=Cannot cast char value to ''{0}''
|
|
evaluation.error.cannot.cast.object=Cannot cast ''{0}'' to ''{1}''
|
|
evaluation.error.numeric.expected=Numeric value expected
|
|
evaluation.error.integer.expected=Integer value expected
|
|
evaluation.error.boolean.expected=Boolean value expected
|
|
evaluation.error.during.indexing=Evaluation is not possible during indexing
|
|
status.invalid.breakpoint.out.of.class=Breakpoint does not belong to any class
|
|
error.invalid.breakpoint.source.changed=Source file changed or found source file does not correspond to the breakpoint's file
|
|
error.invalid.breakpoint.source.not.found=The class {0}, found in the project classpath, has no associated source files
|
|
status.paused=Paused
|
|
status.thread.monitor=MONITOR
|
|
status.thread.not.started=NOT_STARTED
|
|
status.thread.running=RUNNING
|
|
status.thread.sleeping=SLEEPING
|
|
status.thread.unknown=UNKNOWN
|
|
status.thread.wait=WAIT
|
|
status.thread.zombie=ZOMBIE
|
|
status.thread.undefined=UNDEFINED
|
|
progress.hotswap.scanning.path=Scanning: {0}
|
|
progress.hotswap.scanning.classes=Scanning for classes to reload\u2026
|
|
progress.hotswap.reloading=Reloading classes\u2026
|
|
error.operation.canceled=Operation canceled
|
|
error.operation.not.supported.by.vm=Operation not supported by VM : {0}
|
|
error.class.def.not.found=Class definition not found : {0}
|
|
error.verification.error=Verification error : {0}
|
|
error.unsupported.class.version=Unsupported class version : {0}
|
|
error.class.format.error=Class format error : {0}
|
|
error.class.circularity.error=Class circularity error : {0}
|
|
error.exception.while.reloading=Exception while reloading classes : {0} : {1}
|
|
status.hotswap.loaded.classes.up.to.date=Loaded classes are up to date. Nothing to reload
|
|
error.io.error=I/O error
|
|
status.classes.reloaded={0,number} {0,choice, 0#classes|1#class|2#classes} reloaded
|
|
status.classes.not.all.versions.reloaded=For {0} of {1} {1,choice, 1#class|2#classes} not all versions were reloaded
|
|
warning.range.too.big=Range specified is too big. {0} needs too much resources to perform requested operation. Are you sure you want to continue?
|
|
title.range.too.big=Range Is Too Big
|
|
error.array.renderer.configurable.start.index.less.than.zero=Start index is less than 0
|
|
error.array.renderer.configurable.end.index.less.than.start=End index is less than start index
|
|
label.array.renderer.configurable.start.index=Array sta&rt index:
|
|
label.array.renderer.configurable.end.index=en&d index:
|
|
label.array.renderer.configurable.max.count1=Show &maximum
|
|
label.array.renderer.configurable.max.count2=array elements
|
|
label.base.renderer.configurable.autoscroll=Autoscroll to new &local variables
|
|
label.base.renderer.configurable.dfa.assist=Predict condition values and exceptions based on data flow analysis
|
|
label.base.renderer.configurable.dfa.assist.gray.out=Gray out blocks of code that are predicted to be unreachable
|
|
label.base.renderer.configurable.show.synthetic.fields=S&ynthetic fields
|
|
label.base.renderer.configurable.show.val.fields.as.locals=$val fields as local &variables
|
|
label.base.renderer.configurable.hide.null.array.elements=Hide &null elements in arrays and collections
|
|
label.base.renderer.configurable.show.static.fields=&Static fields
|
|
label.base.renderer.configurable.show.static.final.fields=Static &final fields
|
|
label.base.renderer.configurable.show.declared.type=Declared &type
|
|
label.base.renderer.configurable.show.fq.names=Fully &qualified names
|
|
label.base.renderer.configurable.show.object.id=Object &id
|
|
label.base.renderer.configurable.show.hex.value=Show hex value for primitives
|
|
label.base.renderer.configurable.show.strings.type=Show type for strings
|
|
label.base.renderer.configurable.populate.throwable.stack=Auto populate Throwable object's stack trace
|
|
label.base.renderer.configurable.alternate.view=Enable alternative view for Coll&ections classes
|
|
label.base.renderer.configurable.enable.toString=Enable 't&oString()' object view:
|
|
label.base.renderer.configurable.all.overriding=For all classes that override 'toString()' method
|
|
label.base.renderer.configurable.classes.from.list=For classes from the list:
|
|
label.compound.renderer.configurable.show.type=Show type and object id
|
|
label.compound.renderer.configurable.ondemand=On-demand
|
|
label.compound.renderer.configurable.use.default.renderer=Use default renderer
|
|
label.compound.renderer.configurable.use.expression=Use following expression:
|
|
label.compound.renderer.configurable.use.expression.list=Use list of expressions:
|
|
label.compound.renderer.configurable.apply.to=Apply renderer to objects of type (fully qualified name):
|
|
error.compound.renderer.configurable.fqn.generic=Generic type is not allowed
|
|
label.compound.renderer.configurable.when.rendering=When rendering a node
|
|
label.compound.renderer.configurable.when.expanding=When expanding a node
|
|
label.compound.renderer.configurable.test.can.expand=Test if a node can be expanded (optional):
|
|
title.compound.renderer.configurable.choose.renderer.reference.type=Renderer Reference Type
|
|
label.compound.renderer.configurable.append.default.children=Append default children
|
|
button.add=Add
|
|
label.compound.renderer.configurable.table.header.name=Name
|
|
label.compound.renderer.configurable.table.header.expression=Expression
|
|
label.compound.renderer.configurable.table.header.ondemand=On-demand
|
|
label.debugger.hotswap.configurable.compile.before.hotswap=Build project before reloading classes
|
|
label.debugger.hotswap.configurable.enable.vm.hang.warning=Enable 'JVM will hang' warning
|
|
label.debugger.hotswap.configurable.suggest.in.editor=Suggest hotswap in the editor when code is modified
|
|
label.debugger.hotswap.option.suggest.in.editor=Suggest Hotswap in the Editor
|
|
label.debugger.hotswap.configurable.reload.classes=Reload classes after compilation:
|
|
label.debugger.hotswap.configurable.always=&Always
|
|
label.debugger.hotswap.configurable.never=&Never
|
|
label.debugger.hotswap.configurable.ask=As&k
|
|
label.debugger.launching.configurable.debugger.transport=Transport:
|
|
label.debugger.launching.configurable.socket=&Socket
|
|
label.debugger.launching.configurable.shmem=Shared &memory
|
|
label.debugger.general.configurable.show.alternative.source=Show alternative source switcher
|
|
label.debugger.general.configurable.kill.immediately=Kill the debug process immediately
|
|
label.debugger.general.configurable.always.debug=Start run configurations with the debug agent
|
|
label.debugger.general.configurable.enable.memory.agent=Attach memory agent
|
|
label.debugger.general.configurable.enable.memory.agent.tooltip.text=Java debugger will provide additional information about objects in the heap
|
|
label.debugger.general.configurable.always.smart.step.into=A&lways do smart step into
|
|
label.debugger.general.configurable.skip.synthetic.methods=Ski&p synthetic methods
|
|
label.debugger.general.configurable.skip.constructors=Skip &constructors
|
|
label.debugger.general.configurable.skip.classLoaders=Skip class l&oaders
|
|
label.debugger.general.configurable.skip.simple.getters=Skip simple &getters
|
|
label.debugger.general.configurable.step.filters.list.header=Do not step &into the classes
|
|
label.debugger.general.configurable.hide.stack.frames.using.step.filter=Hide stack &frames using stepping filters
|
|
label.debugger.general.configurable.evaluate.finally.on.pop=Evaluate finally blocks on pop frame and early return:
|
|
label.debugger.general.configurable.evaluate.finally.always=&Always
|
|
label.debugger.general.configurable.evaluate.finally.never=N&ever
|
|
label.debugger.general.configurable.evaluate.finally.ask=As&k
|
|
label.debugger.general.configurable.resume.only.current.thread=Resume only the current thread
|
|
label.threads.view.configurable.show.source.file.name=Show source file name
|
|
label.threads.view.configurable.show.class.name=Show class name
|
|
label.threads.view.configurable.show.package=Show package name
|
|
label.threads.view.configurable.show.line.number=Show &line number
|
|
label.threads.view.configurable.current.thread.on.top=Move current thread to the top
|
|
label.threads.view.configurable.show.stack.frames.for.synthetic.methods=Show stack &frames for synthetic methods
|
|
label.threads.view.configurable.show.thread.groups=Show thread &groups
|
|
label.capture.configurable.capture.variables=Capture local variables (may greatly slow down the execution)
|
|
label.capture.configurable.debugger.agent=Instrumenting agent (requires debugger restart)
|
|
label.capture.configurable.annotations.configure=Configure Annotations\u2026
|
|
threads.view.configurable.display.name=Customize Threads View
|
|
user.renderers.configurable.display.name=Java Type Renderers
|
|
async.stacktraces.configurable.display.name=Async Stack Traces
|
|
label.user.renderers.configurable.renderer.name=Renderer name:
|
|
text.user.renderers.configurable.no.renderers=No renderers
|
|
button.copy=Copy
|
|
user.renderers.configurable.button.description.copy=Copy selected renderer
|
|
threads.export.attribute.label.daemon=daemon
|
|
threads.export.attribute.label.priority=prio={0}
|
|
threads.export.attribute.label.tid=tid=0x{0}
|
|
threads.export.attribute.label.blocks.thread=blocks {0}
|
|
threads.export.attribute.label.waiting.for.thread=waiting for {0} to release lock on {1}
|
|
threads.export.attribute.label.locked=locked {0}
|
|
threads.export.attribute.label.object-id=<0x{0}> (a {1})
|
|
threads.export.attribute.error.incompatible.state=Incompatible thread state: thread not suspended
|
|
label.generic.debugger.parameters.patcher.configurable.shmem=Shared &memory
|
|
label.generic.debugger.parameters.patcher.configurable.socket=&Socket
|
|
button.debugger.settings=Debugger Settings\u2026
|
|
label.generic.debugger.parameters.patcher.configurable.transport=Transport:
|
|
label.generic.debugger.parameters.patcher.configurable.shmem.address=Shared memory address:
|
|
progress.hot.swap.title=Hot Swap
|
|
status.hot.swap.completed.with.errors=Hot Swap failed
|
|
status.hot.swap.completed.restart=Restart
|
|
status.hot.swap.completed.stop=Stop debug session
|
|
status.hot.swap.completed.continue=Continue with previous code
|
|
status.hot.swap.completed.with.warnings=Hot Swap completed with warnings
|
|
label.generic.debugger.parameters.patcher.configurable.port=Port:
|
|
status.hotswap.uptodate=Loaded classes are up to date. Nothing to reload.
|
|
add.instance.filter.dialog.title=Add Instance Filter
|
|
add.instance.filter.dialog.prompt=Enter instance ID:
|
|
add.instance.filter.dialog.error.numeric.value.expected=Instance ID should be a numeric value of type 'long'
|
|
filters.not.configured=No filters configured
|
|
hotswap.dialog.title.with.session=Reload Changed Classes for {0}
|
|
hotswap.dialog.title=Reload Changed Classes
|
|
hotswap.dialog.reload.action.text=Reload
|
|
hotswap.dialog.run.prompt=Some classes have been changed. Reload changed classes now?
|
|
hotswap.dialog.hang.warning=JVM is currently suspended.\nReloading classes with active third-party JVM agents may cause the JVM to hang.
|
|
label.add.field.breakpoint.dialog.fq.name=Fully qualified name of a class:
|
|
label.add.field.breakpoint.dialog.field.name=Field name:
|
|
add.field.breakpoint.dialog.title=Add Field Watchpoint
|
|
add.field.breakpoint.dialog.classchooser.title=Choose Field's Class
|
|
add.field.breakpoint.dialog.field.chooser.title={0,choice, 0#Class Has No Fields|1#Select Field}
|
|
label.add.wildcard.breakpoint.dialog.method.name=&Method name:
|
|
label.add.wildcard.breakpoint.dialog.class.pattern=&Class pattern:
|
|
breakpoint.any.exception.display.name=Any exception
|
|
action.hide.text=Hide
|
|
default.package.name=<Default>
|
|
class.filters.dialog.title=Class Filters
|
|
class.filters.dialog.inclusion.filters.group=Include
|
|
class.filters.dialog.exclusion.filters.group=Exclude
|
|
instance.filters.dialog.title=Instance Filters
|
|
exception.breakpoints.tab.title=Java Exception Breakpoints
|
|
exception.breakpoint.description=Exception breakpoint
|
|
field.watchpoints.tab.title=Java Field Watchpoints
|
|
field.watchpoint.description=Field watchpoint
|
|
field.watchpoint.property.name.access=Watch access:
|
|
field.watchpoint.property.name.modification=Watch modification:
|
|
collection.watchpoints.tab.title=Java Collection Watchpoints
|
|
collection.watchpoint.description=Collection watchpoint
|
|
line.breakpoints.tab.title=Java Line Breakpoints
|
|
line.breakpoint.description.basic.line=Line breakpoint
|
|
line.breakpoint.description.lambda=Lambda breakpoint
|
|
line.breakpoint.description.conditional.return=Return breakpoint
|
|
method.breakpoints.tab.title=Java Method Breakpoints
|
|
method.breakpoint.description=Method breakpoint
|
|
method.breakpoints.slowness.warning=Method breakpoints may dramatically slow down debugging
|
|
method.breakpoint.property.name.emulated=Emulated:
|
|
method.breakpoint.property.name.watch.entry=Watch entry:
|
|
method.breakpoint.property.name.watch.exit=Watch exit:
|
|
title.error.evaluating.breakpoint.condition=Breakpoint Condition Error
|
|
title.error.evaluating.breakpoint.action=Breakpoint Action Error
|
|
error.evaluating.breakpoint.condition.or.action=Problem processing VM event:\nBreakpoint: ''{0}''\nError: {1}\nWould you like to stop at the breakpoint?
|
|
error.unable.to.evaluate.expression=Unable to evaluate the expression
|
|
error.unable.to.evaluate.children.expression=Unable to evaluate the children renderer expression
|
|
error.unable.to.evaluate.capture.expression=Unable to evaluate capture key expression: {0}
|
|
error.unable.to.evaluate.insert.expression=Unable to evaluate insert key expression: {0}
|
|
breakpoint.properties.panel.option.pass.count=&Pass count:
|
|
breakpoint.properties.panel.option.class.filters=C&lass filters:
|
|
breakpoint.properties.panel.option.instance.filters=&Instance filters:
|
|
breakpoint.property.name.pass.count=Pass count:
|
|
breakpoint.property.name.class.filters=Class filters:
|
|
breakpoint.property.name.instance.filters=Instance filters:
|
|
error.absent.exception.breakpoint.class.name=No class name for exception breakpoint
|
|
exception.breakpoint.console.message.location.info={0}:{1,number,#}
|
|
exception.breakpoint.console.message.location.info.absent=No Debug Info
|
|
exception.breakpoint.console.message.with.thread.info=Exception ''{0}'' occurred in thread ''{1}'' at {2}({3})
|
|
exception.breakpoint.console.message=Exception ''{0}'' occurred at {1}({2})
|
|
add.exception.breakpoint.classchooser.title=Enter Exception Class
|
|
label.exception.breakpoint.properties.panel.caught.exception=Caught exceptio&n
|
|
label.exception.breakpoint.properties.panel.uncaught.exception=Uncaught excepti&on
|
|
label.exception.breakpoint.properties.panel.group.notifications=Notifications
|
|
error.invalid.breakpoint.missing.field.in.class=Cannot find field ''{0}'' in class ''{1}''
|
|
status.breakpoint.invalid=INVALID
|
|
error.field.breakpoint.class.name.not.specified=Cannot add watchpoint: a class name is not specified
|
|
error.field.breakpoint.field.name.not.specified=Cannot add watchpoint: a field name is not specified
|
|
error.field.breakpoint.field.not.found=Cannot create a field watchpoint for ''{0}.{1}''.\nField ''{2}'' not found
|
|
error.field.breakpoint.class.sources.not.found=Cannot create a field watchpoint for ''{0}.{1}''.\nNo sources for class ''{2}''
|
|
label.field.breakpoint.properties.panel.field.access=Field acce&ss
|
|
label.field.breakpoint.properties.panel.field.modification=Field &modification
|
|
label.group.watch.events=Watch
|
|
label.collection.breakpoint.properties.save.history=Save collection history
|
|
error.failed.evaluating.breakpoint.condition=Failed to evaluate breakpoint condition\n''{0}''\nReason: {1}
|
|
error.invalid.breakpoint.no.executable.code=No executable code found at line {0} in class {1}
|
|
error.invalid.breakpoint.no.line.info=Line numbers info is not available in class {0}
|
|
line.breakpoint.display.name=Line {0,number,#}
|
|
line.breakpoint.display.name.with.class.or.method=Line {0,number,#} in {1}
|
|
line.breakpoint.display.name.with.column=Line {0,number,#} column {1,number,#}
|
|
line.breakpoint.display.name.with.column.and.class.or.method=Line {0,number,#} column {1,number,#} in {2}
|
|
error.invalid.breakpoint.method.not.found=Method not found in class {0}
|
|
label.method.breakpoints.processing.classes=Processing classes for emulated method breakpoints
|
|
label.method.breakpoints.setting.breakpoints=Setting emulated method breakpoints
|
|
label.method.breakpoint.properties.panel.method.entry=Method entr&y
|
|
label.method.breakpoint.properties.panel.method.exit=Method e&xit
|
|
label.method.breakpoint.properties.panel.emulated=Em&ulated
|
|
error.invalid.field.name=Invalid field name ''{0}''
|
|
label.unknown.value=<unknown>
|
|
message.node.debug.info.not.available=Debug info not available
|
|
message.node.local.variables.debug.info.not.available=Variables debug info not available
|
|
message.node.local.variables.not.captured=Local variables are not captured for synthetic, bridge etc. methods
|
|
message.node.local.variables.capture.disabled=Local variables were not captured, you can change it in
|
|
message.node.array.elements.more=+{0} more
|
|
message.node.elements.null.hidden=Not showing null elements
|
|
message.node.all.array.elements.null=All elements in range ({0}, {1}) are null
|
|
message.node.all.elements.null=All elements are null
|
|
message.node.filtered=Filtered by:
|
|
message.node.empty.array=Empty
|
|
message.node.class.has.no.fields=Class has no fields
|
|
message.node.class.no.fields.to.display=No fields to display
|
|
message.node.object.collected=Object has been garbage collected during method invocation
|
|
message.node.thread.running=Thread is running
|
|
message.node.thread.has.no.frames=Thread has no frames
|
|
message.node.evaluation.not.possible=Target VM is not paused by breakpoint request. Evaluation of methods is not possible in this mode
|
|
message.node.show.image=\u2026 Show image
|
|
message.node.show.icon=\u2026 Show icon
|
|
message.node.navigate=\u2026 Navigate
|
|
message.node.open=\u2026 Open
|
|
message.node.toString=\u2026 toString()
|
|
message.node.evaluate=\u2026 Evaluate
|
|
label.thread.node.thread.collected=Thread ''{0}'' has been garbage-collected
|
|
label.thread.node=\"{0}\"@{1}: {2}
|
|
label.thread.node.in.group=\"{0}\"@{1} in group \"{3}\": {2}
|
|
label.thread.group.node.group.collected=Thread Group \"{0}\" has been garbage-collected
|
|
label.thread.group.node=Thread Group \"{0}\"@{1}
|
|
evaluation.error.invalid.type.name=Invalid type name: ''{0}''
|
|
label.undefined=undefined
|
|
error.running.to.cursor.no.executable.code=There is no executable code at {0}:{1}
|
|
evaluation.error.local.variable.declarations.not.supported=Local variable declarations are not supported here.
|
|
evaluation.error.unsupported.declaration=Invalid declaration : {0} Only local variable declarations are supported.
|
|
error.jdk.not.specified=JDK is not specified
|
|
error.field.not.found.in.class=No such field {0} in {1}
|
|
error.breakpoint.file.not.found=File ''{0}'' not found; breakpoints for this file will be ignored
|
|
error.cannot.load.breakpoint.file=Cannot load file ''{0}''; breakpoints for this file will be ignored
|
|
evaluation.error.invalid.this.expression=Cannot substitute ''{0}'' into ''{1}'' as ''this''
|
|
error.invalid.type.name=Invalid type name ''{0}''
|
|
error.cannot.create.expression.from.code.fragment=Cannot create expression from code fragment.
|
|
error.invalid.local.variable.name=Invalid local variable name ''{0}''
|
|
error.inconsistent.debug.info=Inconsistent debug information
|
|
error.invalid.stackframe=Internal exception - invalid stackframe
|
|
internal.debugger.error=Internal error. See logs for more details
|
|
error.text.invalid.port=Port is not specified
|
|
title.smart.step.popup=Method to Step Into
|
|
action.watch.method.return.value.description=Enables watching last executed method return value
|
|
action.watches.method.return.value.enable=Show Method Return Values
|
|
action.calculate.retained.size.info=Retained objects of ''{0}'' are highlighted
|
|
action.calculate.retained.size.title=Retained Size of ''{0}''
|
|
action.calculate.retained.size.text=Retained size of ''{0}'' is {1}, shallow size is {2}
|
|
action.calculate.retained.size.waiting.message=Calculating retained size\u2026
|
|
action.watches.method.return.value.unavailable.reason=Feature is not supported by the target VM
|
|
action.auto.variables.mode=Show Variables Near Execution Point Only
|
|
action.auto.variables.mode.description=Show only variables used near the execution point
|
|
frame.panel.frames.not.available=Frames not available for unsuspended thread
|
|
frame.panel.thread.finished=Thread has finished execution
|
|
frame.panel.async.stacktrace=Async stack trace
|
|
error.corrupt.debug.info=Debug info might be corrupt: {0}
|
|
evaluation.error.unknown.method.return.type=Cannot resolve method return type: {0}
|
|
evaluation.error.unknown.type=Cannot resolve type: {0}
|
|
rule.name.group.by.class=Group by class
|
|
rule.name.group.by.package=Group by package
|
|
error.context.has.changed=Context has changed, operation is not possible
|
|
editor.notification.alternative.source=Alternative source available for the class {0}
|
|
label.threads.view.configurable.show.prams.types=Show method arguments types
|
|
breakpoint.properties.panel.option.catch.class.filters=Catc&h class filters:
|
|
breakpoint.properties.panel.option.caller.filter=Calle&r filters:
|
|
caller.filters.dialog.title=Caller Filters
|
|
settings.breakpoints.based=Breakpoints based:
|
|
settings.capture.column.capture.class.name=Capture class name
|
|
settings.capture.column.capture.method.name=Capture method name
|
|
settings.capture.column.capture.key.expression=Capture key expression
|
|
settings.capture.column.insert.class.name=Insert class name
|
|
settings.capture.column.insert.method.name=Insert method name
|
|
settings.capture.column.insert.key.expression=Insert key expression
|
|
settings.async.schedule=Async Schedule
|
|
settings.async.execute=Async Execute
|
|
settings.async.annotations.configuration=Async Annotations Configuration
|
|
action.AnActionButton.text.duplicate=Duplicate
|
|
action.AnActionButton.description.duplicate=Duplicate
|
|
action.AnActionButton.text.enable.selected=Enable Selected
|
|
action.AnActionButton.description.enable.selected=Enable Selected
|
|
action.AnActionButton.text.disable.selected=Disable Selected
|
|
action.AnActionButton.description.disable.selected=Disable Selected
|
|
action.AnActionButton.text.import=Import
|
|
action.AnActionButton.description.import=Import
|
|
action.AnActionButton.text.export=Export
|
|
action.AnActionButton.description.export=Export
|
|
warning.0=WARNING! {0}
|
|
instances.window.show.history=InstancesWindow.ShowHistory
|
|
select.stack.frame=Select stack frame
|
|
tracing.class.filters=Tracing Class Filters
|
|
filters=Filters\u2026
|
|
export.failed=Export Failed
|
|
export.selected.capture.points.to.file=Export Selected Capture Points to File\u2026
|
|
import.capture.points=Import Capture Points
|
|
please.select.a.file.to.import=Please select a file to import.
|
|
waiting.for.debugger.response=Waiting for the process to finish gracefully
|
|
thread.dump=Thread Dump
|
|
collection.history=Collection history
|
|
cancel.emulation=Cancel emulation
|
|
thread.operation.interrupt.is.not.supported.by.vm=Thread operation 'interrupt' is not supported by VM
|
|
add.stepping.filter=Add Stepping Filter
|
|
method.name.not.specified=Method name not specified
|
|
class.pattern.not.specified=Class pattern not specified
|
|
add.method.breakpoint=Add Method Breakpoint
|
|
if.the.value.is.referenced.by.a.constant.field=If the value is referenced by a constant field of an abstract class,\nIDEA could additionally mark all values referenced from this class with the names of referencing fields.
|
|
action.failed=Action failed
|
|
label.object.markup.dialog.mark.referenced=&Mark values referenced from constant fields
|
|
debugger.data.views.configurable.show.title=Show
|
|
overhead.toolwindow.title=Overhead
|
|
memory.toolwindow.title=Memory
|
|
checkbox.tracing=Tracing
|
|
enable.tracking.for.new.instances=Enable tracking for new instances
|
|
condition=Condition:
|
|
warning.filtering.may.have.side.effects=Warning: filtering may have side effects
|
|
invoke.completion.once.more=Invoke completion once more to see runtime type variants
|
|
debugger.actions.group.title=Debugger Actions
|
|
surround.with.runtime.type.template=((RuntimeType)expr)
|
|
command.name.surround.with.runtime.cast=Surround With Runtime Cast
|
|
checkbox.start.tracing=start
|
|
checkbox.stop.tracing=stop
|
|
checkbox.tracking.filters=filters
|
|
status.text.select.instance.to.see.stack.frame=Select instance to see stack frame
|
|
label.arrays.could.not.be.tracked=Arrays cannot be tracked
|
|
status.text.no.stack.frame.for.this.instance=No stack frame for this instance
|
|
label.capture.point.at=Capture point at {0}.{1}
|
|
dialog.title.exception.to.throw=Exception To Throw
|
|
notification.method.has.not.been.called=Method <b>{0}()</b> has not been called
|
|
error.no.debug.process=No debug process
|
|
error.context.not.available=Context is not available
|
|
error.internal=Internal error
|
|
label.too.many.frames.rest.truncated=Too many frames, the rest is truncated\u2026
|
|
thread.dump.name=Dump {0}
|
|
collection.history.tab.title=History of {0}
|
|
error.unable.to.create.sapidattachingconnector=Unable to create SAPIDAttachingConnector
|
|
action.show.objects.text=Show {0} Objects\u2026
|
|
progress.text.shown.x.of.y=Shown: {0} / {1}
|
|
progress.text.errors.count=Errors: {0}
|
|
progress.suffix.filtering.has.been.interrupted=(Filtering has been interrupted)
|
|
progress.suffix.limit.has.been.reached=(Limit has been reached)
|
|
button.perform.reload.classes=Perform &Reload Classes
|
|
button.skip.reload.classes=&Skip Reload Classes
|
|
call.tracer=Call Tracer
|
|
label.instrumentation.tracker=Instrumentation tracker: {0}
|
|
column.name.hits=Hits
|
|
column.name.time.ms=Time (ms)
|
|
renderer.name={0} renderer
|
|
action.do.not.stop.if.called.from.text=Do not stop if called from: {0}
|
|
action.stop.only.if.called.from.text=Stop only if called from: {0}
|
|
action.stop.only.in.current.object.text=Stop only in the current object
|
|
action.stop.only.in.class.text=Stop only in the class: {0}
|
|
action.do.not.stop.in.class.text=Do not stop in the class: {0}
|
|
dialog.title.return.value=Return Value
|
|
process.attach.run.configuration.type.name=Attach to process
|
|
memory.view.constructor.tracker.name=MemoryViewConstructorTracker: {0}
|
|
capture.node.settings.link=\ settings
|
|
array.filter.node.clear.link=\ clear
|
|
breakpoint.variant.text.line=Line
|
|
breakpoint.variant.text.line.and.lambda=Line and {0,choice,1#Lambda|2#Lambdas}
|
|
breakpoint.variant.text.line.and.lambda.uknown.count=Line and Lambda(s)
|
|
debugger.attach.group.name.java=Java
|
|
debugger.attach.group.name.java.read.only=Java Read Only
|
|
debugger.memory.agent.timeout.error=Calculation timeout (heap is too large and memory agent can't execute this operation in reasonable time, it's preferable to capture the heap dump)
|
|
debugger.memory.agent.loading.error=Memory agent couldn't be loaded to the VM
|
|
debugger.attach.password.for.sudo=Enter your password to attach with su privileges:
|
|
notification.group.hotswap=Hot Swap performed
|
|
message.conditional.return.breakpoint.on.android=Breakpoint on conditional return is not yet supported on Android, regular line breakpoint is set.
|
|
paths.to.closest.gc.roots.for=Paths to the Closest GC Roots for {0}
|
|
column.name.instances=Instances
|
|
column.name.shallow.size=Shallow Size
|
|
column.name.retained.size=Retained Size
|