testsuite/systemtap.base/inlinedvars.c


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

static inline int
m(char *name, int i, long j)
{
  // Random syntactical block to be inlined.
  // Mimics what STAP_PROBE macro does a bit.
  do {
    // Dummy (volatile) counter to trick gcc into thinking we are actually
    // using the label. If not it will partially optimize the label away,
    // but still emits a somewhat bogus DW_AT_low_pc for it...
    volatile int c = 0;
    volatile __typeof__(name) p_name = name;
    volatile __typeof__(i) p_i = i;
    volatile __typeof__(j) p_j = j;
    // empty asm to force locals into regs.
    inlined_label: asm volatile ("" : "=g"(c) : "g"(p_name), "g"(p_i), "g"(p_j));
    if (c != 0) goto inlined_label;
  } while (0);
  return i + 32;
}

static inline int
call(int pi, long pj)
{
  volatile ic = pi - 42;
  volatile jc = pj + 42;
  return m("call", ic, jc);
}

static inline int
call2(int pi2, long pj2)
{
  volatile ic2 = pi2 + 64;
  volatile jc2 = pj2 - 64;
  return m("call2", ic2, jc2);
}

int
main (int argc, char **argv)
{
  volatile int i = 64;
  volatile long j = 42;
  call(i, j);
  call2(i, j);
  m("main", i, j);
  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.swt.dnd;

import org.eclipse.swt.internal.wpf.OS;

/**
 * The class <code>URLTransfer</code> provides a platform specific mechanism 
 * for converting text in URL format represented as a java <code>String</code> 
 * to a platform specific representation of the data and vice versa.  See 
 * <code>Transfer</code> for additional information. The string  
 * must contain the fully specified url.
 * 
 * <p>An example of a java <code>String</code> containing a URL is shown 
 * below:</p>
 * 
 * <code><pre>
 *     String url = "http://www.eclipse.org";
 * </code></pre>
 */
public class URLTransfer extends ByteArrayTransfer {

	static URLTransfer _instance = new URLTransfer();
	static final String URL = "UniformResourceLocator"; //$NON-NLS-1$
	static final int URL_ID = registerType(URL);

private URLTransfer() {}

/**
 * Returns the singleton instance of the URLTransfer class.
 *
 * @return the singleton instance of the URLTransfer class
 */
public static URLTransfer getInstance () {
	return _instance;
}

/**
 * This implementation of <code>javaToNative</code> converts a URL 
 * represented by a java <code>String</code> to a platform specific representation.
 * For additional information see <code>Transfer#javaToNative</code>.
 * 
 * @param object a java <code>String</code> containing a URL
 * @param transferData an empty <code>TransferData</code> object; this
 *  object will be filled in on return with the platform specific format of the data
 */
public void javaToNative (Object object, TransferData transferData){
	if (!checkURL(object) || !isSupportedType(transferData)) {
		DND.error(DND.ERROR_INVALID_DATA);
	}
	String string = (String)object + '\0';
	byte[] buffer = string.getBytes();
	if (buffer.length == 0) return;
	int typeid = OS.Byte_typeid();
	int pBytes = OS.Array_CreateInstance(typeid, buffer.length);
	OS.GCHandle_Free(typeid);
	if (pBytes == 0) return;
	OS.memcpy(pBytes, buffer, buffer.length);
	int pStream = OS.gcnew_MemoryStream();
	OS.MemoryStream_Write(pStream, pBytes, 0, buffer.length);
	OS.GCHandle_Free(pBytes);
	transferData.pValue = pStream;
}

/**
 * This implementation of <code>nativeToJava</code> converts a platform specific 
 * representation of a URL to a java <code>String</code>.
 * For additional information see <code>Transfer#nativeToJava</code>.
 * 
 * @param transferData the platform specific representation of the data to be 
 * converted
 * @return a java <code>String</code> containing a URL if the 
 * conversion was successful; otherwise null
 */
public Object nativeToJava(TransferData transferData){
	if (!isSupportedType(transferData) || transferData.pValue == 0) return null;

	int byteArray = 	OS.MemoryStream_ToArray(transferData.pValue);
	int bLength = OS.Array_GetLength(byteArray, 0);
	byte[] buffer = new byte[bLength];
	if (bLength == 0) return "";
	OS.memcpy(buffer, byteArray, bLength);
	OS.GCHandle_Free(byteArray);

	String string = new String(buffer);
	int end = string.indexOf('\0');
	return (end == -1) ? string : string.substring(0, end);
}

protected int[] getTypeIds(){
	return new int[] {URL_ID};
}

protected String[] getTypeNames(){
	return new String[] {URL}; 
}

boolean checkURL(Object object) {
	return object != null && (object instanceof String) && ((String)object).length() > 0;
}

protected boolean validate(Object object) {
	return checkURL(object);
}
}