mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-05 16:46:26 +00:00
120 lines
4.3 KiB
C++
120 lines
4.3 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*/
|
|
#ifndef _NAME_MANGLER_H_
|
|
#define _NAME_MANGLER_H_
|
|
|
|
#include "Fundamentals.h"
|
|
#include "FieldOrMethod.h"
|
|
|
|
/* Some platforms (ok, windows) have more than one native calling
|
|
* convention. This enumerates the different available types.
|
|
*/
|
|
enum NativeCallingConvention {
|
|
nativeCallingConventionInvalid = 0,
|
|
nativeCallingConventionStdCallMSVC, /* Windows MS VC only: stdcall */
|
|
nativeCallingConventionCCallMSVC, /* Windows only: C call */
|
|
nativeCallingConventionFastCallMSVC, /* Windows only: fast call */
|
|
nativeCallingConventionDefault /* Default C calling convention on
|
|
* platforms other than windows.
|
|
*/
|
|
};
|
|
|
|
/* A NameMangler class handles name-mangling for a particular type
|
|
* of native-method dispatch. It does not do the platform-specific
|
|
* name-mangling although it provides information about which calling
|
|
* conventions are supported (if the native platform supports more than
|
|
* one).
|
|
*/
|
|
class NS_EXTERN NameMangler {
|
|
public:
|
|
NameMangler(Int32 numCallingConventions,
|
|
NativeCallingConvention *conventions) :
|
|
numCallingConventions(numCallingConventions),
|
|
conventions(conventions) { }
|
|
|
|
/* Given a classname, method name and signature string of the method,
|
|
* produce a mangled name that can be looked for in a shared lib/symbol
|
|
* table. buffer must be preallocated by the caller and must be of length
|
|
* len. If there is not enough space for the mangled name, this routine
|
|
* returns 0.
|
|
*/
|
|
virtual char *mangle(const char *className,
|
|
const char *methodName,
|
|
const char *signature,
|
|
char *buffer,
|
|
Int32 len) = 0;
|
|
|
|
/* Return extra size in bytes of any extra arguments that are to
|
|
* be passed to the native method. Note that the VM has already taken into
|
|
* account the "this" pointer to an object, which is passed as the
|
|
* first argument to the method. if staticMethod is true, then the
|
|
* method in question is a static method. Otherwise, it's an instance
|
|
* method.
|
|
*/
|
|
virtual Int32 getExtraArgsSize(bool staticMethod) = 0;
|
|
|
|
/* Return a pointer to the first instruction of the "processed"
|
|
* native method. "method" is the method in question, and actualCode
|
|
* is a pointer to the native code as found in a shared library.
|
|
* This method could potentially insert stubs and/or modify
|
|
* the code appropriately so that the VM can call this
|
|
* method.
|
|
*/
|
|
virtual void *getCode(const Method &method, void *actualCode) = 0;
|
|
|
|
/* return the number of native method conventions on the given
|
|
* platform allowed for this mangling scheme.
|
|
*/
|
|
Int32 numNativeConventions() { return numCallingConventions; }
|
|
|
|
/* Get the native calling conventions supported by this mangling
|
|
* scheme.
|
|
*/
|
|
const NativeCallingConvention *getNativeConventions()
|
|
{ return conventions; }
|
|
|
|
/* A MangleUtfType indicates type of transformation to apply to some UTF
|
|
* characters encountered in the string to be mangled.
|
|
*/
|
|
enum MangleUTFType {
|
|
mangleUTFInvalid=0,
|
|
mangleUTFClass, /* Mangle only the forward slashes in class names */
|
|
mangleUTFFieldStub,
|
|
mangleUTFSignature,
|
|
mangleUTFJNI /* Perform JNI-style mangling; underscore -> _1,
|
|
* semicolon -> _2, etc
|
|
*/
|
|
};
|
|
|
|
protected:
|
|
static Int32 mangleUTFString(const char *name, char *buffer,
|
|
int buflen, MangleUTFType type);
|
|
|
|
static Int32 mangleUnicodeChar(Int32 ch, char *bufptr, char *bufend);
|
|
|
|
Int32 numCallingConventions;
|
|
NativeCallingConvention *conventions;
|
|
};
|
|
|
|
|
|
#endif /* _NAME_MANGLER_H_ */
|