Sophie: pnet-devel-0.5.0-1mdk ppc

pnet-devel-0.5.0-1mdk.ppc.rpm

This is pnettools.info, produced by makeinfo version 4.3 from
pnettools.texi.

The Portable.NET development tools assist with building and
manipulating images in the portable executable format. development.

File: pnettools.info, Node: Field Attributes, Next: Field Initialization, Prev: Field Declarations, Up: Field Declarations

Field Attributes
----------------

*public*
Specify that the field is accessible from any other class. This
corresponds to the C# `public' access level.

*private*
Specify that the field is only accessible to the class in which it
is declared. This corresponds to the C# `private' access level.

*family*
Specify that the field is accessible to the class in which it is
declared, and any subclass of the field's class. This corresponds
to the C# `protected' access level.

*assembly*
Specify that the field is only accessible to classes in the same
assembly as the field. This corresponds to the C# `internal'
access level.

*famandassem*
Specify that the field is only accessible to classes in the same
assembly as the field, and which inherit from the field's class.
There is no C# equivalent of this access level.

*famorassem*
Specify that the field is only accessible to classes in the same
assembly as the field or to classes which inherit from the field's
class. This corresponds to the C# `protected internal' access
level.

*compilercontrolled*
Specify that the field is accessible in a manner controlled by the
compiler. The runtime engine treats this the same as *assembly*.
There is no C# equivalent of this access level.

*static*
Specify that the field is staticly declared within its class. If
this attribute is not present, the field will be part of the
instances of its class.

*literal*
Specify that the field is associated with a literal constant value.
Such a field will not occupy space at runtime, and compilers will
expand the literal value into the code stream at compile time.
This corresponds to the C# `const' keyword.

*initonly*
Specify that the field can only be written during the
initialization process for the field's class. Afterwards, it is
read-only. This corresponds to the C# `readonly' keyword.

*notserialized*
Specify that the field will not be output during serialization if
its class has the *serialized* attribute.

*specialname*
Specify that the field has special significance to tools other than
the runtime engine. This should be used on fields that correspond
to enumerated value storage (normally *value__*).

*rtspecialname*
Specify that the field has special significance to the runtime
engine. This should be used on fields that correspond to
enumerated value storage (normally *value__*).

*marshal*
Specify that the field's type should be replaced with an underlying
native type by the runtime.

File: pnettools.info, Node: Field Initialization, Next: Field Layout, Prev: Field Attributes, Up: Field Declarations

Field Initialization
--------------------

File: pnettools.info, Node: Field Layout, Next: Field References, Prev: Field Initialization, Up: Field Declarations

Field Layout
------------

If the field is a member of an *explicit* class declaration, then a
specific offset value may be specified just after the *.field* keyword.
Use of this feature is discouraged in portable programs.

If the field is static, it can be placed at an explicit runtime
address using the *at* clause. Use of this feature is discouraged in
portable programs.

File: pnettools.info, Node: Field References, Next: Method Declarations, Prev: Field Layout, Up: Field Declarations

Field References
----------------

At various points within an assembly stream, it is necessary to refer
to fields defined in the same stream, or imported from other streams.
The following syntax is used for referring to fields:

FieldReference => Type [ TypeSpecification *::* ] Identifier

File: pnettools.info, Node: Method Declarations, Next: Method Attributes, Prev: Field References, Up: Assembler

Method Declarations
===================

Methods may be defined at the global level of the assembly stream, or
within the body of a class. If the method is global, it must appear
before all class declarations in the assembly stream.

MethodDeclaration => *.method* { MethodAttribute }
CallingConventions
{ ParameterAttribute }
MarshalledType MethodName
'(' [ SignatureArguments ] ')'
{ ImplementationAttribute }
'{' { MethodMember } '}
'MethodName => *.ctor*
| *.cctor*
| QualifiedName

The method name *.ctor* indicates an instance constructor, and the
method name *.cctor* indicates a static constructor.

If the method has custom attributes, they should appear in the body
of the method, or just after the method declaration.

* Menu:

* Method Attributes:: Attributes that may be used on methods.
* Calling Conventions:: Specifying a method's calling conventsions.
* Implementation Attributes:: Specifying a method's implementation style.
* Method Signatures:: Method argument signatures.
* PInvoke Methods:: Invoking foreign library methods.
* Method References:: Referring to local and imported methods.
* Method Members:: Members of a method declaration (IL).
* Java Method Members:: Members of a method declaration (Java).

File: pnettools.info, Node: Method Attributes, Next: Calling Conventions, Prev: Method Declarations, Up: Method Declarations

Method Attributes
-----------------

*public*
Specify that the method is accessible from any other class. This
corresponds to the C# `public' access level.

*private*
Specify that the method is only accessible to the class in which
it is declared. This corresponds to the C# `private' access level.

*family*
Specify that the method is accessible to the class in which it is
declared, and any subclass of the method's class. This corresponds
to the C# `protected' access level.

*assembly*
Specify that the method is only accessible to classes in the same
assembly as the method. This corresponds to the C# `internal'
access level.

*famandassem*
Specify that the method is only accessible to classes in the same
assembly as the method, and which inherit from the method's class.
There is no C# equivalent of this access level.

*famorassem*
Specify that the method is only accessible to classes in the same
assembly as the method or to classes which inherit from the
method's class. This corresponds to the C# `protected internal'
access level.

*compilercontrolled*
Specify that the method is accessible in a manner controlled by
the compiler. The runtime engine treats this the same as
*assembly*. There is no C# equivalent of this access level.

*static*
Specify that the method is staticly declared within its class.
The method will not have a `this' parameter.

*virtual*
Specify that the method is virtual.

*final*
Specify that the virtual method is the last definition of the
method, and that it cannot be overridden in subclasses.

*abstract*
Specify that the virtual method is abstract. The class that
contains the method must also have the *abstract* attribute.

*hidebysig*
Specify that the method hides any other definition in a parent
class only if the method name and signature are identical. If
this attribute is not present, then the method hides any
definition in a parent class if the method name is identical.

*newslot*
Specify that the virtual method occupies a different vtable slot
from the same method in parent classes.

*specialname*
Specify that the method has special significance to tools other
than the runtime engine. This should be used on methods that
correspond to constructors, operators, property accessors, and
event accessors.

*rtspecialname*
Specify that the method has special significance to the runtime
engine. This should be used on methods that correspond to
constructors.

*pinvokeimpl*
Specify that the method is imported from a foreign library. The
parameters to this attribute specify how to perform the import.
*Note PInvoke Methods::, for more information.

File: pnettools.info, Node: Calling Conventions, Next: Implementation Attributes, Prev: Method Attributes, Up: Method Declarations

Calling Conventions
-------------------

CallingConventions => /* empty */
| *instance* CallingConventions
| *explicit* CallingConventions
| *default*
| *vararg*
| *unmanaged cdecl*
| *unmanaged stdcall*
| *unmanaged thiscall*
| *unmanaged fastcall*

*instance*
Specify that the method takes an additional argument that
corresponds to the `this' instance.

*explicit*
Specify that the `this' instance is explicitly provided in the
method signature.

*default*
Specify that the default calling conventions should be used. This
convention is implied if no calling convention is supplied for the
method.

*vararg*
Specify that the method is capable of supporting a variable number
of arguments.

*unmanaged cdecl*
Specify that the method is in a foreign library and that it uses
the standard C calling conventions for the underlying operating
system.

*unmanaged stdcall*
Specify that the method is in a foreign library and that it uses
the "standard call" calling convention. This is Windows-specific.

*unmanaged thiscall*
Specify that the method is in a foreign library and that it uses
the "this call" calling convention. This is Windows-specific.

*unmanaged fastcall*
Specify that the method is in a foreign library and that it uses
the "fast call" calling convention. This is Windows-specific.

File: pnettools.info, Node: Implementation Attributes, Next: Method Signatures, Prev: Calling Conventions, Up: Method Declarations

Implementation Attributes
-------------------------

*cil*
Specify that the method is implemented in IL bytecode. This is
also used on *internalcall* methods, even though they are typically
implemented with native code.

*optil*
Specify that the method is implemented in OptIL bytecode, which is
a variant of IL that provides extra information for JIT optimizers.
There will normally be no reason to use this attribute. The
runtime engine treats OptIL identically to IL.

*native*
Specify that the method is implemented using native machine code.
This will rarely be required in binaries that are intended to be
portable.

*runtime*
Specify that the method has special meaning to the runtime engine.
This is used when implementing delegates.

*managed*
Specify that the method uses managed objects. This is the default.

*unmanaged*
Specify that the method uses unmanaged objects.

*forwardref*
Specify that the method is not defined here. This is provided for
linker support only. The runtime engine will reject methods that
have this attribute.

*internalcall*
Specify that the method is implemented internally within the
runtime engine.

*synchronized*
Specifies that the runtime engine should acquire a lock on the
object prior to calling the method, and should release the lock
after returning from the method. If the method is static, then a
lock on the method's type will be obtained.

*noinlining*
Specifies that the JIT should not inline this method.

*java*
Specifies that the method is implemented using Java bytecode
instead of IL bytecode. This must be last attribute in the list.
i.e. `java managed' is incorrect; it must be specifies as
`managed java'. This ordering allows `ilasm' to properly switch
parsing modes to recognise the Java instruction set rather than
the IL instruction set.

File: pnettools.info, Node: Method Signatures, Next: PInvoke Methods, Prev: Implementation Attributes, Up: Method Declarations

Method Signatures
-----------------

SignatureArguments => SignatureArgument
{ ',' SignatureArgument }
SignatureArgument => *...*
| { ParameterAttribute }
MarshalledType [ Identifier ]

ParameterAttribute => '[' *in* ']'
| '[' *out* ']'
| '[' *opt* ']'

*in*
Specify that the parameter is an input to the method. The type
must be a managed or unmanaged pointer type.

*out*
Specify that the parameter is an output from the method. The type
must be a managed or unmanaged pointer type.

*opt*
Specify that the parameter is optional. The method will normally
contain a *.param* declaration that specifies the default value
for the parameter.

Parameter attributes are ignored by the runtime engine. They provide
information for compilers and other tools.

File: pnettools.info, Node: PInvoke Methods, Next: Method References, Prev: Method Signatures, Up: Method Declarations

PInvoke Methods
---------------

Methods in foreign libraries are referenced using the PInvoke
mechanism.

PInvokeParameters => '(' [ ComposedString
[ *as* ComposedString ] ]
{ PInvokeAttribute } ')'

The first string indicates the name of the library from which the
foreign method is being imported. The second string indicates the name
of the method in the foreign library. If the second string is not
present, then the name of the method declaration will be used.

The `ilasm' syntax allows the library name to be omitted, for
compatibility with older assemblers. In practice, a PInvoke declaration
that does not have a library name cannot be resolved at runtime.

*nomangle*
Specify that the foreign method name is exact. Windows systems
will search for 'A' and 'W' variants of the method name if this
attribute is not specified.

*ansi*
Specify that any strings that are passed to, or return from, the
foreign method will be in the operating system's prevailing
character set.

*unicode*
Specify that any strings that are passed to, or return from, the
foreign method will be in the Unicode character set.

*autochar*
Specify that the runtime engine should determine the character set
automatically.

*ole*
Specify that the method signature has been managled to return a
`HRESULT' value. This is Windows-specific.

*lasterr*
Specify that the method returns additional error information in a
separate variable. On Windows systems, this variable can be
queried using `GetLastError'. On other systems, the variable is
usually called `errno'.

*winapi*
Specify that the foreign method uses the "winapi" calling
conventions. This is Windows-specific.

*cdecl*
Specify that the foreign method uses the standard C calling
conventions.

*stdcall*
Specify that the foreign method uses the "standard call" calling
conventions. This is Windows-specific.

*thiscall*
Specify that the foreign method uses the "this call" calling
conventions. This is Windows-specific.

*fastcall*
Specify that the foreign method uses the "fast call" calling
conventions. This is Windows-specific.

If none of the above calling convention attributes are supplied,
then the default is chosen by the runtime engine.

File: pnettools.info, Node: Method References, Next: Method Members, Prev: PInvoke Methods, Up: Method Declarations

Method References
-----------------

At various points within an assembly stream, it is necessary to refer
to methods defined in the same stream, or imported from other streams.
The following syntax is used for referring to methods:

MethodReference => CallingConventions Type
[ TypeSpecification *::* ] MethodName
'(' [ SignatureArguments ] ')'

File: pnettools.info, Node: Method Members, Next: Java Method Members, Prev: Method References, Up: Method Declarations

Method Members
--------------

MethodMember => *.emitbyte* Integer32
| ExceptionBlock
| *.maxstack* Integer32
| *.locals* '(' [ SignatureArguments ] ')'
| *.locals init*
'(' [ SignatureArguments ] ')'
| *.entrypoint*
| *.zeroinit*
| DataDeclaration
| Instruction
| Identifier ':'
| SecurityDeclaration
| DebugInformation
| CustomAttributeSpecification
| *.vtentry* Integer32 ':' Integer32
| *.override* TypeSpecification
*::* MethodName
| '{' { MethodMember } '}'
| *.param* '[' Integer32 ']'
[ '=' FieldInitialization ]

File: pnettools.info, Node: Java Method Members, Next: Property Declarations, Prev: Method Members, Up: Method Declarations

Java Method Members
-------------------

TODO

File: pnettools.info, Node: Property Declarations, Next: Property Attributes, Prev: Java Method Members, Up: Assembler

Property Declarations
=====================

PropertyDeclaration => *.property* { PropertyAttribute }
CallingConventions Type Identifier
'(' [ SignatureArguments ] ')'
'{' { PropertyMember } '}'

If the property has custom attributes, they should appear in the
body of the property, or just after the property declaration.

* Menu:

* Property Attributes:: Attributes that may be used on properties.
* Property Members:: Specifying the members of a property.

File: pnettools.info, Node: Property Attributes, Next: Property Members, Prev: Property Declarations, Up: Property Declarations

Property Attributes
-------------------

PropertyAttribute => *specialname*
| *rtspecialname*

*specialname*
Specify that the property has special significance to tools other
than the runtime engine.

*rtspecialname*
Specify that the property has special significance to the runtime
engine.

File: pnettools.info, Node: Property Members, Next: Event Declarations, Prev: Property Attributes, Up: Property Declarations

Property Members
----------------

PropertyMember => *.get* MethodReference
| *.set* MethodReference
| *.other* MethodReference
| CustomAttributeDeclaration
| DebugInformation

*.get*
Specify the method to be used to implement the property's "get"
accessor.

*.set*
Specify the method to be used to implement the property's "set"
accessor.

*.other*
Specify the method to be used to implement the property's "other"
accessor. This is not currently used by C#.

File: pnettools.info, Node: Event Declarations, Next: Event Attributes, Prev: Property Members, Up: Assembler

Event Declarations
==================

EventDeclaration => *.event* { EventAttribute }
[ TypeSpecification ] Identifier
'{' { EventMember } '}'

If the event has custom attributes, they should appear in the body of
the event, or just after the event declaration.

* Menu:

* Event Attributes:: Attributes that may be used on events.
* Event Members:: Specifying the members of an event.

File: pnettools.info, Node: Event Attributes, Next: Event Members, Prev: Event Declarations, Up: Event Declarations

Event Attributes
----------------

EventAttribute => *specialname*
| *rtspecialname*

*specialname*
Specify that the event has special significance to tools other than
the runtime engine.

*rtspecialname*
Specify that the event has special significance to the runtime
engine.

File: pnettools.info, Node: Event Members, Next: Debug Information, Prev: Event Attributes, Up: Event Declarations

Event Members
-------------

*.addon*
Specify the method to be used to implement the event's "add"
accessor.

*.removeon*
Specify the method to be used to implement the event's "remove"
accessor.

*.fire*
Specify the method to be used to implement the event's "fire"
accessor.

*.other*
Specify the method to be used to implement the event's "other"
accessor. This is not currently used by C#.

File: pnettools.info, Node: Debug Information, Next: Custom Attributes, Prev: Event Members, Up: Assembler

Debug Information
=================

When a program is compiled in debug mode, extra information is
inserted into the assembly stream to assist debuggers.

Debug information in the assembly stream is only processed if the
`-g' option is supplied to `ilasm'.

DebugInformation => *.line* INT SQSTRING
| *.line* INT DQSTRING
| *.line*

The first two forms above specify a line number and a filename. The
third form specifies a line number within the same file as the previous
*.line* directive.

The keyword *#line* can be used instead of *.line*, but this usage
is deprecated.

Debug information lines are treated differently in method bodies
versus elsewhere. Inside a method body, debug information should
appear at the code position where the corresponding source line begins.

Outside a method body, debug information indicates the point in the
source where the corresponding declaration was encountered. For
example:

.class C
{
.line 28 "testing.cs"

.field int32 f
.line 31
}

This indicates that the class `C' was declared on line 28 of the
source file `testing.cs', and that the field `f' was declared on line
31 of the same file. Debug information for classes must precede any of
the class members.

*Note Debug Symbols::, for more information on how debug information
is stored in IL binaries.

File: pnettools.info, Node: Custom Attributes, Next: Assembly Declarations, Prev: Debug Information, Up: Assembler

Custom Attributes
=================

CustomAttributeDeclaration => *.custom* MethodReference '=' Bytes

The method reference indicates the constructor to use to build the
attribute at runtime. The hexadecimal bytes provide a serialized form
of the constructor arguments.

File: pnettools.info, Node: Assembly Declarations, Next: Assembly Attributes, Prev: Custom Attributes, Up: Assembler

Assembly Declarations
=====================

AssemblyDeclaration => *.assembly* { AssemblyAttribute }
AssemblyName '{' { AssemblyMember } '}'
AssemblyName => QualifiedName | *.library*

If the assembly declaration has custom attributes, they should
appear in the body of the declaration, or just after the declaration.

* Menu:

* Assembly Attributes:: Attributes that may be used on assemblies.
* Assembly Members:: Specifying the members of an assembly.
* Assembly References:: Referring to imported assemblies.
* Assembly Reference Members:: Specifying the members of an assembly reference.

File: pnettools.info, Node: Assembly Attributes, Next: Assembly Members, Prev: Assembly Declarations, Up: Assembly Declarations

Assembly Attributes
-------------------

AssemblyAttribute => *noappdomain*
| *nomachine*
| *noprocess*

*noappdomain*
Specifies that the assembly cannot be loaded more than once in the
same application domain.

*nomachine*
Specifies that the assembly cannot be loaded more than once on the
same physical machine.

*noprocess*
Specifies that the assembly cannot be loaded more than once in the
same process.

File: pnettools.info, Node: Assembly Members, Next: Assembly References, Prev: Assembly Attributes, Up: Assembly Declarations

Assembly Members
----------------

*.hash*
Specify the hash algorithm to use for hashing other files that make
up the same assembly manifest. These files are typically referred
to using *.file* declarations. The value 0x8004 is recommended,
and refers to the SHA1 hash algorithm.

*.publickey*
Specify the bytes of the public key that was used to sign this
assembly. Compilers that write assembly streams normally won't
need to use this directive because separate tools are used to sign
assemblies.

*.ver*
Specify the version number of this assembly. e.g. `1:0:2411:0'.

*.locale*
Specify the culture string for this assembly. This is called
*.locale* instead of *.culture* for historical reasons. An
example of a valid culture value is `en-AU' which indicates
"English, Australia".

*.processor*
*.os*
Specify operating systems and processors for which this assembly
has been built and tested. Use of these directives is discouraged
in portable programs.

File: pnettools.info, Node: Assembly References, Next: Assembly Reference Members, Prev: Assembly Members, Up: Assembly Declarations

Assembly References
-------------------

AssemblyRefDeclaration => *.assembly* *extern* QualifiedName
'{' { AssemblyRefMember } '}'

File: pnettools.info, Node: Assembly Reference Members, Next: Module Declarations, Prev: Assembly References, Up: Assembly Declarations

Assembly Reference Members
--------------------------

*.hash*
Specify the hash value for the referenced assembly.

*.publickey*
Specify the bytes of the public key that was used to sign the
referenced assembly.

*.publickeytoken*
Specify the low 8 bytes of the SHA1 hash of the public key that was
used to sign the referenced assembly.

Only one of *.publickey* or *.publickeytoken* can be specified.
Tokens are much shorter than full public keys and the full key can
be obtained from the referenced assembly when it is loaded.

*.ver*
Specify the version number of the referenced assembly. e.g.
`1:0:2411:0'.

*.locale*
Specify the culture string for the referenced assembly.

*.processor*
*.os*
Specify operating systems and processors for which the referenced
assembly has been built and tested. Use of these directives is
discouraged in portable programs.

File: pnettools.info, Node: Module Declarations, Next: Other Declarations, Prev: Assembly Reference Members, Up: Assembler

Module Declarations
===================

ModuleDeclaration => *.module* QualifiedName
| *.module* *extern* QualifiedName

If the module declaration has custom attributes, they should appear
just after the declaration.

File: pnettools.info, Node: Other Declarations, Next: Disassembler, Prev: Module Declarations, Up: Assembler

Other Declarations
==================

This section defines the syntax for a number of other declaration
kinds that provide miscellaneous information that does not fall into
any of the above categories.

VtableDeclaration => *.vtable* '=' '(' (HEXBYTE)+ ')'
VtfixupDeclaration => *.vtfixup* '[' Integer32 ']'
{ VtfixupAttribute } *at* Identifier
VtfixupAttribute => *int32*
| *int64*
| *fromunmanaged*
| *callmostderived*

File: pnettools.info, Node: Disassembler, Next: ildasm invocation, Prev: Other Declarations, Up: Top

Intermediate language disassembler
**********************************

Ildasm converts IL object files (`.obj'), IL executables (`.exe'),
and IL dynamic link libraries (`.dll') into Intermediate Language (IL)
assembly code. The output is suitable for input to ilasm.

Ildasm is useful for diagnosing problems with compilers and other
development tools. It is rarely useful to regular users or programmers.

* Menu:

* ildasm invocation:: Invoking ildasm

File: pnettools.info, Node: ildasm invocation, Next: Linker, Prev: Disassembler, Up: Disassembler

Invoking ildasm
===============

The general form of the ildasm syntax is as follows:

ildasm [OPTIONS] INPUT ...

`-o FILE'
`--output FILE'
Specify the name of the file to write the assembler output to. The
default is standard output. Specifying `FILE' as `-' also
indicates that the output should be set to standard output.

`-d'
`--dump-sections'
Dump the contents of the IL program sections in hexadecimal instead
of as IL assembly code. This may be useful for diagnosing problems
with badly formatted IL binaries.

`-r'
`--real-offsets'
By default, ildasm prints "relative virtual addresses", or RVA's,
when dumping IL program sections in hexadecimal, and when dumping
the names of labels within methods. The `-r' option informs ildasm
to use real file offsets instead. This may assist in locating
data within the file with separate tools.

`-t'
`--show-tokens'
Show the token codes of program elements within the disassembly
output.

`-q'
`--quote-names'
Quote all identifiers within the disassembly output so that they
are not confused with reserved words. This is necessary if the
output will be fed into ilasm.

`-w'
`--whole-file'
Dump the contents of the whole input file in hexadecimal. If the
file is not otherwise recognized by ildasm as an IL binary, this
may be the only way to inspect the contents to determine what the
problem is.

`-b'
`--dump-bytes'
Dump the IL instructions in hexadecimal.

`-n'
`--no-il'
Do not dump the IL instructions within the methods.

`--help'
Print a usage message for the ildasm program.

`-v'
`--version'
Print the version of the ildasm program.

`--'
Marks the end of the command-line options, and the beginning of
the input filenames. You may need to use this if your filename
begins with `-'. e.g. `ildasm -- -input.obj'. This is not needed
if the input is stdin: `ildasm -' is perfectly valid.

The exit status is 1 if an error occurred while processing the input.
Otherwise the exit status is 0. *Note Load Errors::, for a complete
list of errors that may occur when loading an IL image file.

File: pnettools.info, Node: Linker, Next: ilalink invocation, Prev: ildasm invocation, Up: Top

Intermediate language assembly linker
*************************************

Ilalink links a number of IL object files (`.obj') together,
resolves external references to IL libraries, and creates a final IL
executable (`.exe') or IL dynamic link library (`.dll').

* Menu:

* ilalink invocation:: Invoking ilalink

File: pnettools.info, Node: ilalink invocation, Next: Size, Prev: Linker, Up: Linker

Invoking ilalink
================

The general form of the ilalink syntax is as follows:

ilalink [OPTIONS] INPUT ...

`-o FILE'
`--output FILE'
Specify the name of the file to write the linker output to. The
default is `a.out.exe', `a.out.dll', or `a.out.obj', depending on
the value of the `--format' option.

`-j'
`--format obj'
Write a `.obj' file as output, instead of an executable or dynamic
link library. This is normally not very useful.

`-e'
`--format exe'
Write an executable file as output, instead of a `.obj' file or
dynamic link library. This is the default value.

`-d'
`--format dll'
Write a dynamic link library file as output, instead of a `.obj'
file or executable.

`-l NAME'
`--library NAME'
Link against the library called `NAME'. The linker will search
all of the library directories for a file called `NAME.dll'. If
`--no-stdlib' is not specified, then the standard library
`mscorlib' will be automatically added to the list of libraries.
The name of the standard library can be changed using the
`-fstdlib-name' option.

`-L PATH'
`--library-dir PATH'
Specify a directory to be searched for libraries. The option `-L
.' must be explicitly supplied to search the current directory.
If `--no-stdlib' is not specified, then a standard set of builtin
paths will be added to the end of the list specified by the `-L'
options. The set of builtin paths can be overridden by setting the
`CSCC_LIB_PATH' environment variable to an appropriate value.

`-n'
`--no-stdlib'
Do not include the standard library or any of the builtin library
directories.

`-S NAME'
`-fstdlib-name=NAME'
Set the name of the standard library to `NAME'. The default is
`mscorlib'.

`--shared'
Link the output as a shared image. This is the default.

`--static'
Link the output statically. This option is not yet implemented.
It is provided for compatibility with other tools.

`-a NAME'
`-fassembly-name=NAME'
Set the name of the final assembly to `NAME'. The default is the
name of the output file without its directory path or extension.

`-A NN:NN:NN:NN'
`-fassembly-version NN:NN:NN:NN'
Set the final assembly version to `NN:NN:NN:NN'. The default is
`0:0:0:0', unless a non-zero version is supplied by one of the
input files.

`-M NAME'
`-fmodule-name=NAME'
Set the name of the final module to `NAME'. The default is the
name of the output file without its directory path.

`-E NAME'
`--entry-point NAME'
Specify the name of the program's entry point. This should only
be used if the output is an executable (`.exe'). If this option
is not present, the linker will attempt to deduce which method is
the entry point by inspecting the names and signatures of methods
within the input files. The name is either a class name, or a
class name plus method name. The sequence `::' is used to
separate the class and method names. Examples are `MyClass',
`MyNamespace.MyClass', and `MyNamespace.MyClass::Main'.

`-r FILE'
`-fresources=FILE'
Specify the name of a resource file to be linked with the output
assembly.

`-R'
`--resources-only'
Create an output assembly that only contains resources. This is
useful for building satellite resource assemblies for foreign
languages.

`-p'
`-fprivate-resources'
Mark the resources as private to the output assembly.

`-H ALG'
`-fhash-algorithm=ALG'
Set the assembly hash algorithm to `ALG', which must be either
`SHA1' or `MD5'. The default is `SHA1'.

`-3'
`-m32bit-only'
Mark the final output assembly so that it can only be used on
32-bit systems. Use of this option is severely discouraged.

`-c'
`-mcui-subsystem'
Link the final output assembly for the command-line subsystem on
Windows. This is the default.

Link the final output assembly for the GUI subsystem on Windows.

`--help'
Print a usage message for the ilalink program.

`-v'
`--version'
Print the version of the ilalink program.

`--'
Marks the end of the command-line options, and the beginning of
the input filenames. You may need to use this if your filename
begins with `-'. e.g. `ilalink -- -input.obj'. This is not
needed if the input is stdin: `ilalink -' is perfectly valid.

The `-f' and `-m' options can be specified on the cscc command-line,
and will be passed to the linker automatically by the compiler.

The exit status is 1 if an error occurred while processing the input.
Otherwise the exit status is 0.

File: pnettools.info, Node: Size, Next: ilsize invocation, Prev: ilalink invocation, Up: Top

Intermediate language size utility
**********************************

Ilsize lists size information for each of the sections within an IL
object file (`.obj'), an IL executable (`.exe'), or an IL dynamic link
library (`.dll'). The output is similar to that produced by size(1).

* Menu:

* ilsize invocation:: Invoking ilsize

File: pnettools.info, Node: ilsize invocation, Next: Native, Prev: Size, Up: Size

Invoking ilsize
===============

The general form of the ilsize syntax is as follows:

ilsize [OPTIONS] input ...

`--radix NUM'
Set the radix for displaying size values within the output. The
default value is 10. Legal values are 8, 10, and 16.

`-d'
Set the radix to 10. Same as `--radix 10'.

`-o'
Set the radix to 8. Same as `--radix 8'.

`-x'
Set the radix to 16. Same as `--radix 16'.

`-D'
`--detailed'
Use a more detailed output that also includes the number of
classes, fields, methods, etc.

`--help'
Print a usage message for the ilsize program.

`-v'
`-V'
`--version'
Print the version of the ilsize program.

`--'
Marks the end of the command-line options, and the beginning of
the input filenames. You may need to use this if your filename
begins with `-'. e.g. `ilsize -- -input.obj'. This is not needed
if the input is stdin: `ilsize -' is perfectly valid.

The exit status is 1 if an error occurred while processing the input.
Otherwise the exit status is 0. *Note Load Errors::, for a complete
list of errors that may occur when loading an IL image file.

Ilsize does not currently understand the format of `.a' or `.lib'
archive libraries, so it cannot display information about archive
contents like size(1) can.

File: pnettools.info, Node: Native, Next: ilnative invocation, Prev: ilsize invocation, Up: Top

Intermediate language native utility
************************************

Ilnative lists the native methods that are used within an IL object
file (`.obj'), an IL executable (`.exe'), or an IL dynamic link library
(`.dll'). This can aid developers who are building programs that use
native methods, or developers who are attempting to discover which
native methods a third party program requires.

* Menu:

* ilnative invocation:: Invoking ilnative

File: pnettools.info, Node: ilnative invocation, Next: Find, Prev: Native, Up: Native

Invoking ilnative
=================

The general form of the ilnative syntax is as follows:

ilnative [OPTIONS] INPUT ...

`-n'
`--names-only'
Only print the names of the methods, and not the type information.

`--help'
Print a usage message for the ilnative program.

`-v'
`--version'
Print the version of the ilnative program.

`--'
Marks the end of the command-line options, and the beginning of
the input filenames. You may need to use this if your filename
begins with `-'. e.g. `ilnative -- -input.obj'. This is not
needed if the input is stdin: `ilnative -' is perfectly valid.

The exit status is 1 if an error occurred while processing the input.
Otherwise the exit status is 0. *Note Load Errors::, for a complete
list of errors that may occur when loading an IL image file.

File: pnettools.info, Node: Find, Next: ilfind invocation, Prev: ilnative invocation, Up: Top

Intermediate language name find utility
***************************************

Ilfind searches for a pattern within the supplied input files. Each
input file must be an IL object file (`.obj'), an IL executable
(`.exe'), or an IL dynamic link library (`.dll').

For each assembly, namespace, class, field, method, event, or
property whose name matches the pattern, a line is written to standard
output describing the match.

* Menu:

* ilfind invocation:: Invoking ilfind

File: pnettools.info, Node: ilfind invocation, Next: Dependencies, Prev: Find, Up: Find

Invoking ilfind
===============

The general form of the ilfind syntax is as follows:

ilfind [OPTIONS] PATTERN INPUT ...

`-w'
`--whole-string'
Match the whole pattern string against names in the input files.
This is the default. For example, the pattern `ABC' will match
classes, fields, and methods called `ABC', but will not match
items called `ABCD'.

`-s'
`--sub-string'
Match the pattern against sub-strings of names in the input files.
For example, the pattern `ABC' will match any item that contains
`ABC' within its name.

`-f'
`--file-regex'
Use a file-like regular expression matching scheme. This is the
default. Patterns can use `?' and `*' to match a single character
or multiple characters. Patterns can use the characters `[' and
`]' to group a set of alternative characters. This pattern syntax
is similar to that used to match filenames in shells such as sh(1)
and csh(1).

`-g'

`--grep-regex'
Use a regular expression matching scheme similar to grep(1).
Note: the `^' and `$' characters will be implicitly prepended and
appended to the pattern if whole string matching is enabled (`-w').

`-n'
`--no-regex'
Do not use regular expression matching. This will perform a simple
identity check against names (`-w') or a simple sub-string check
(`-s').

`-i'
`--ignore-case'
Ignore case when matching names against the pattern.

`-p'
`--public-only'
Search only the classes that are publicly accessible.

`--help'
Print a usage message for the ilfind program.

`-v'
`--version'
Print the version of the ilfind program.

`--'
Marks the end of the command-line options. The next argument is
the pattern. You may need to use this if your pattern begins with
`-'. e.g. `ilfind -- -name input.obj'.

The exit status is 1 if an error occurred while processing the input.
Otherwise the exit status is 0. *Note Load Errors::, for a complete
list of errors that may occur when loading an IL image file.

File: pnettools.info, Node: Dependencies, Next: ildd invocation, Prev: ilfind invocation, Up: Top

Intermediate language dependency utility
****************************************

Ildd lists the assemblies and PInvoke modules that are referenced by
an IL object file (`.obj'), an IL executable (`.exe'), or an IL dynamic
link library (`.dll').

* Menu:

* ildd invocation:: Invoking ildd

File: pnettools.info, Node: ildd invocation, Next: Resources, Prev: Dependencies, Up: Dependencies

Invoking ildd
=============

The general form of the ildd syntax is as follows:

ildd [OPTIONS] PATTERN INPUT ...

`--help'
Print a usage message for the ildd program.

`-v'
`--version'
Print the version of the ildd program.

`--'
Marks the end of the command-line options. The next argument is
the pattern. You may need to use this if your filename begins
with `-'. e.g. `ildd -- -input.exe'. This is not needed if the
input is stdin: `ildd -' is perfectly valid.

The exit status is 1 if an error occurred while processing the input.
Otherwise the exit status is 0. *Note Load Errors::, for a complete
list of errors that may occur when loading an IL image file.

File: pnettools.info, Node: Resources, Next: resgen invocation, Prev: ildd invocation, Up: Top

Resource generation and conversion
**********************************

Resgen converts strings between a number of resource formats that
are used within the Portable.NET platform. It is typically used to
convert text resources (`.txt'), XML resources (`.resx'), or GNU gettext
resources (.po) into binary resources (`.resources') that can be
attached to an IL executable or dynamic link library.

* Menu:

* resgen invocation:: Invoking resgen
* Resource Format:: Text resource file format
* Resource Examples:: Resource conversion examples