From 82e62209d696dcb082bd67e227dd5fe30256c776 Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Mon, 1 May 2017 19:50:01 +0300
Subject: [PATCH 01/13] Document pragma trampoline

---
 doc/cc65.sgml | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/doc/cc65.sgml b/doc/cc65.sgml
index 24b37133e..99ddfc82d 100644
--- a/doc/cc65.sgml
+++ b/doc/cc65.sgml
@@ -1209,6 +1209,31 @@ parameter with the <tt/#pragma/.
   The <tt/#pragma/ understands the push and pop parameters as explained above.
 
 
+<sect1><tt>#pragma trampoline (&lt;push&rt;, &lt;name&gt;, &lt;value&gt;)</tt><label id="pragma-trampoline"><p>
+
+  This pragma sets a trampoline for functions. The name is either
+  a function returning void and taking no parameters, or the address
+  of an array in memory (for a RAM trampoline). The value is an
+  8-bit number that's set to tmp4.
+
+  The address of the function is passed in ptr4.
+
+  This is useful for example with banked memory, to automatically
+  switch banks to where this function resides, and then restore
+  the bank when it returns.
+
+  The <tt/#pragma/ requires the push and pop parameters as explained above.
+
+  Example:
+  <tscreen><verb>
+	void mytrampoline(void);
+
+        #pragma trampoline (push, mytrampoline, 0)
+        void somefunc(void);
+        #pragma trampoline (pop)
+  </verb></tscreen>
+
+
 <sect1><tt>#pragma warn (name, [push,] on|off)</tt><label id="pragma-warn"><p>
 
   Switch compiler warnings on or off. "name" is the name of a warning (see the

From a84463a3dfb74b200fc208ab30f89de54631a846 Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Mon, 1 May 2017 20:12:18 +0300
Subject: [PATCH 02/13] callptr4

---
 libsrc/runtime/callptr4.s | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 libsrc/runtime/callptr4.s

diff --git a/libsrc/runtime/callptr4.s b/libsrc/runtime/callptr4.s
new file mode 100644
index 000000000..9a15609aa
--- /dev/null
+++ b/libsrc/runtime/callptr4.s
@@ -0,0 +1,10 @@
+;
+; CC65 runtime: call function via pointer in ptr4
+;
+
+        .export         callptr4
+        .importzp       ptr4
+
+callptr4:
+        jmp     (ptr4)          ; jump there
+

From 679bfb0ae9353646e78a981941d525ea86b44e88 Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Mon, 1 May 2017 20:46:06 +0300
Subject: [PATCH 03/13] Add IntPtrStack

---
 src/common/intptrstack.c |  90 +++++++++++++++++++++++++++++
 src/common/intptrstack.h | 121 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 211 insertions(+)
 create mode 100644 src/common/intptrstack.c
 create mode 100644 src/common/intptrstack.h

diff --git a/src/common/intptrstack.c b/src/common/intptrstack.c
new file mode 100644
index 000000000..de02c09e7
--- /dev/null
+++ b/src/common/intptrstack.c
@@ -0,0 +1,90 @@
+/*****************************************************************************/
+/*                                                                           */
+/*                                intptrstack.c                              */
+/*                                                                           */
+/*                  Integer+ptr stack used for program settings              */
+/*                                                                           */
+/*                                                                           */
+/*                                                                           */
+/* (C) 2017, Mega Cat Studios                                                */
+/*                                                                           */
+/*                                                                           */
+/* This software is provided 'as-is', without any expressed or implied       */
+/* warranty.  In no event will the authors be held liable for any damages    */
+/* arising from the use of this software.                                    */
+/*                                                                           */
+/* Permission is granted to anyone to use this software for any purpose,     */
+/* including commercial applications, and to alter it and redistribute it    */
+/* freely, subject to the following restrictions:                            */
+/*                                                                           */
+/* 1. The origin of this software must not be misrepresented; you must not   */
+/*    claim that you wrote the original software. If you use this software   */
+/*    in a product, an acknowledgment in the product documentation would be  */
+/*    appreciated but is not required.                                       */
+/* 2. Altered source versions must be plainly marked as such, and must not   */
+/*    be misrepresented as being the original software.                      */
+/* 3. This notice may not be removed or altered from any source              */
+/*    distribution.                                                          */
+/*                                                                           */
+/*****************************************************************************/
+
+
+
+/* common */
+#include "check.h"
+#include "intptrstack.h"
+
+
+
+/*****************************************************************************/
+/*                                   Code                                    */
+/*****************************************************************************/
+
+
+
+void IPS_Get (const IntPtrStack* S, long *Val, void **Ptr)
+/* Get the value on top of an int stack */
+{
+    PRECONDITION (S->Count > 0);
+    if (Val) *Val = S->Stack[S->Count-1].val;
+    if (Ptr) *Ptr = S->Stack[S->Count-1].ptr;
+}
+
+
+
+void IPS_Set (IntPtrStack* S, long Val, void *Ptr)
+/* Set the value on top of an int stack */
+{
+    PRECONDITION (S->Count > 0);
+    S->Stack[S->Count-1].val = Val;
+    S->Stack[S->Count-1].ptr = Ptr;
+}
+
+
+
+void IPS_Drop (IntPtrStack* S)
+/* Drop a value from an int stack */
+{
+    PRECONDITION (S->Count > 0);
+    --S->Count;
+}
+
+
+
+void IPS_Push (IntPtrStack* S, long Val, void *Ptr)
+/* Push a value onto an int stack */
+{
+    PRECONDITION (S->Count < sizeof (S->Stack) / sizeof (S->Stack[0]));
+    S->Stack[S->Count].val = Val;
+    S->Stack[S->Count++].ptr = Ptr;
+}
+
+
+
+void IPS_Pop (IntPtrStack* S, long *Val, void **Ptr)
+/* Pop a value from an int stack */
+{
+    PRECONDITION (S->Count > 0);
+    if (Val) *Val = S->Stack[--S->Count].val;
+    if (Ptr) *Ptr = S->Stack[S->Count].ptr;
+}
diff --git a/src/common/intptrstack.h b/src/common/intptrstack.h
new file mode 100644
index 000000000..a7b1c6683
--- /dev/null
+++ b/src/common/intptrstack.h
@@ -0,0 +1,121 @@
+/*****************************************************************************/
+/*                                                                           */
+/*                                intptrstack.h                              */
+/*                                                                           */
+/*                  Integer+ptr stack used for program settings              */
+/*                                                                           */
+/*                                                                           */
+/*                                                                           */
+/* (C) 2017, Mega Cat Studios                                                */
+/*                                                                           */
+/*                                                                           */
+/* This software is provided 'as-is', without any expressed or implied       */
+/* warranty.  In no event will the authors be held liable for any damages    */
+/* arising from the use of this software.                                    */
+/*                                                                           */
+/* Permission is granted to anyone to use this software for any purpose,     */
+/* including commercial applications, and to alter it and redistribute it    */
+/* freely, subject to the following restrictions:                            */
+/*                                                                           */
+/* 1. The origin of this software must not be misrepresented; you must not   */
+/*    claim that you wrote the original software. If you use this software   */
+/*    in a product, an acknowledgment in the product documentation would be  */
+/*    appreciated but is not required.                                       */
+/* 2. Altered source versions must be plainly marked as such, and must not   */
+/*    be misrepresented as being the original software.                      */
+/* 3. This notice may not be removed or altered from any source              */
+/*    distribution.                                                          */
+/*                                                                           */
+/*****************************************************************************/
+
+
+
+#ifndef INTPTRSTACK_H
+#define INTPTRSTACK_H
+
+
+
+#include "inline.h"
+
+
+
+/*****************************************************************************/
+/*                                   Data                                    */
+/*****************************************************************************/
+
+
+
+typedef struct IntPtrStack IntPtrStack;
+struct IntPtrInner {
+	long val;
+	void *ptr;
+};
+struct IntPtrStack {
+    unsigned    Count;
+    struct IntPtrInner Stack[8];
+};
+
+/* An initializer for an empty int stack */
+#define STATIC_INTPTRSTACK_INITIALIZER     { 0, { 0, 0 }, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0} } }
+
+/* Declare an int stack with the given value as first element */
+#define INTPTRSTACK(Val, Ptr)   { 1, { {Val, Ptr}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0} } }
+
+
+
+/*****************************************************************************/
+/*                                   Code                                    */
+/*****************************************************************************/
+
+
+
+#if defined(HAVE_INLINE)
+INLINE int IPS_IsFull (const IntPtrStack* S)
+/* Return true if there is no space left on the given int stack */
+{
+    return (S->Count >= sizeof (S->Stack) / sizeof (S->Stack[0]));
+}
+#else
+#  define IPS_IsFull(S)  ((S)->Count >= sizeof ((S)->Stack) / sizeof ((S)->Stack[0]))
+#endif
+
+#if defined(HAVE_INLINE)
+INLINE int IPS_IsEmpty (const IntPtrStack* S)
+/* Return true if there are no values on the given int stack */
+{
+    return (S->Count == 0);
+}
+#else
+#  define IPS_IsEmpty(S)  ((S)->Count == 0)
+#endif
+
+#if defined(HAVE_INLINE)
+INLINE unsigned IPS_GetCount (const IntPtrStack* S)
+/* Return the number of elements on the given int stack */
+{
+    return S->Count;
+}
+#else
+#  define IPS_GetCount(S)        (S)->Count
+#endif
+
+void IPS_Get (const IntPtrStack* S, long *Val, void **Ptr);
+/* Get the value on top of an int stack */
+
+void IPS_Set (IntPtrStack* S, long Val, void *Ptr);
+/* Set the value on top of an int stack */
+
+void IPS_Drop (IntPtrStack* S);
+/* Drop a value from an int stack */
+
+void IPS_Push (IntPtrStack* S, long Val, void *Ptr);
+/* Push a value onto an int stack */
+
+void IPS_Pop (IntPtrStack* S, long *Val, void **Ptr);
+/* Pop a value from an int stack */
+
+
+
+/* End of IntPtrStack.h */
+
+#endif

From d091a57e918244f0d6a7b651b908f7f08a2cee95 Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Mon, 1 May 2017 21:00:28 +0300
Subject: [PATCH 04/13] Trampoline stack

---
 src/cc65/trampoline.c | 102 ++++++++++++++++++++++++++++++++++++++++++
 src/cc65/trampoline.h |  65 +++++++++++++++++++++++++++
 2 files changed, 167 insertions(+)
 create mode 100644 src/cc65/trampoline.c
 create mode 100644 src/cc65/trampoline.h

diff --git a/src/cc65/trampoline.c b/src/cc65/trampoline.c
new file mode 100644
index 000000000..1f35a0f3c
--- /dev/null
+++ b/src/cc65/trampoline.c
@@ -0,0 +1,102 @@
+/*****************************************************************************/
+/*                                                                           */
+/*                                trampoline.c                               */
+/*                                                                           */
+/*                          Trampoline management                            */
+/*                                                                           */
+/*                                                                           */
+/*                                                                           */
+/* (C) 2017, Mega Cat Studios                                                */
+/*                                                                           */
+/*                                                                           */
+/* This software is provided 'as-is', without any expressed or implied       */
+/* warranty.  In no event will the authors be held liable for any damages    */
+/* arising from the use of this software.                                    */
+/*                                                                           */
+/* Permission is granted to anyone to use this software for any purpose,     */
+/* including commercial applications, and to alter it and redistribute it    */
+/* freely, subject to the following restrictions:                            */
+/*                                                                           */
+/* 1. The origin of this software must not be misrepresented; you must not   */
+/*    claim that you wrote the original software. If you use this software   */
+/*    in a product, an acknowledgment in the product documentation would be  */
+/*    appreciated but is not required.                                       */
+/* 2. Altered source versions must be plainly marked as such, and must not   */
+/*    be misrepresented as being the original software.                      */
+/* 3. This notice may not be removed or altered from any source              */
+/*    distribution.                                                          */
+/*                                                                           */
+/*****************************************************************************/
+
+
+
+#include <stdarg.h>
+#include <string.h>
+
+/* common */
+#include "chartype.h"
+#include "check.h"
+#include "coll.h"
+#include "scanner.h"
+#include "intptrstack.h"
+#include "xmalloc.h"
+
+/* cc65 */
+#include "codeent.h"
+#include "error.h"
+#include "trampoline.h"
+
+
+
+/*****************************************************************************/
+/*                                   Data                                    */
+/*****************************************************************************/
+
+
+/* Trampolines */
+static IntPtrStack Trampolines;
+
+
+
+/*****************************************************************************/
+/*                                   Code                                    */
+/*****************************************************************************/
+
+
+
+void PushTrampoline (void *Ptr, unsigned char Val)
+/* Push the current trampoline */
+{
+    if (IPS_IsFull (&Trampolines)) {
+        Error ("Trampoline stack overflow");
+    } else {
+        IPS_Push (&Trampolines, Val, Ptr);
+    }
+}
+
+
+
+void PopTrampoline (void)
+/* Remove the current trampoline */
+{
+    if (IPS_GetCount (&Trampolines) < 1) {
+        Error ("Trampoline stack is empty");
+    } else {
+        IPS_Drop (&Trampolines);
+    }
+}
+
+
+
+void GetTrampoline (void **Ptr, unsigned char *Val)
+/* Get the current trampoline */
+{
+    if (IPS_GetCount (&Trampolines) < 1) {
+        *Ptr = NULL;
+        *Val = 0;
+    } else {
+        long Temp;
+        IPS_Get (&Trampolines, &Temp, Ptr);
+        *Val = Temp;
+    }
+}
diff --git a/src/cc65/trampoline.h b/src/cc65/trampoline.h
new file mode 100644
index 000000000..f110bd42e
--- /dev/null
+++ b/src/cc65/trampoline.h
@@ -0,0 +1,65 @@
+/*****************************************************************************/
+/*                                                                           */
+/*                                trampoline.h                               */
+/*                                                                           */
+/*                            Trampoline management                          */
+/*                                                                           */
+/*                                                                           */
+/*                                                                           */
+/* (C) 2017, Mega Cat Studios                                                */
+/*                                                                           */
+/*                                                                           */
+/* This software is provided 'as-is', without any expressed or implied       */
+/* warranty.  In no event will the authors be held liable for any damages    */
+/* arising from the use of this software.                                    */
+/*                                                                           */
+/* Permission is granted to anyone to use this software for any purpose,     */
+/* including commercial applications, and to alter it and redistribute it    */
+/* freely, subject to the following restrictions:                            */
+/*                                                                           */
+/* 1. The origin of this software must not be misrepresented; you must not   */
+/*    claim that you wrote the original software. If you use this software   */
+/*    in a product, an acknowledgment in the product documentation would be  */
+/*    appreciated but is not required.                                       */
+/* 2. Altered source versions must be plainly marked as such, and must not   */
+/*    be misrepresented as being the original software.                      */
+/* 3. This notice may not be removed or altered from any source              */
+/*    distribution.                                                          */
+/*                                                                           */
+/*****************************************************************************/
+
+
+
+#ifndef TRAMPOLINE_H
+#define TRAMPOLINE_H
+
+
+
+#include <stdio.h>
+
+/* common */
+#include "attrib.h"
+
+/* cc65 */
+#include "opcodes.h"
+
+
+/*****************************************************************************/
+/*                                   Code                                    */
+/*****************************************************************************/
+
+
+
+void PushTrampoline (void *Ptr, unsigned char Val);
+/* Push the current trampoline */
+
+void PopTrampoline (void);
+/* Pop the current trampoline */
+
+void GetTrampoline (void **Ptr, unsigned char *Val);
+/* Get the current trampoline, if any */
+
+
+/* End of trampoline.h */
+
+#endif

From 9c86c03a96e9885ac7aedd62b099ba43526aef4f Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Tue, 2 May 2017 18:48:31 +0300
Subject: [PATCH 05/13] Add test case

---
 test/val/trampoline.c | 53 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 test/val/trampoline.c

diff --git a/test/val/trampoline.c b/test/val/trampoline.c
new file mode 100644
index 000000000..b5df1a22b
--- /dev/null
+++ b/test/val/trampoline.c
@@ -0,0 +1,53 @@
+/*
+  !!DESCRIPTION!! trampoline pragma
+  !!ORIGIN!!      cc65 regression tests
+  !!LICENCE!!     Public Domain
+  !!AUTHOR!!      Lauri Kasanen
+*/
+
+static unsigned char flag;
+
+static void trampoline_set() {
+	asm("ldy tmp4");
+	asm("sty %v", flag);
+	asm("jsr callptr4");
+}
+
+void trampoline_inc() {
+	asm("inc %v", flag);
+	asm("jsr callptr4");
+}
+
+void func3() {
+
+}
+
+unsigned char array[30];
+#pragma trampoline(push, array, 0)
+#pragma trampoline(pop)
+
+#pragma trampoline(push, trampoline_inc, 0)
+
+void func2() {
+	func3();
+}
+
+#pragma trampoline(push, trampoline_set, 4)
+
+void func1(void);
+
+#pragma trampoline(pop)
+#pragma trampoline(pop)
+
+void func1() {
+	func2();
+}
+
+int main(void)
+{
+	flag = 0;
+
+	func1();
+
+	return flag == 5 ? 0 : 1;
+}

From 2890b3a810219ad512f9fdd2432811f94c0b121e Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Tue, 2 May 2017 19:06:19 +0300
Subject: [PATCH 06/13] Pragma trampoline

---
 src/cc65/declare.c  | 21 +++++++++++
 src/cc65/expr.c     | 46 +++++++++++++++++++++++-
 src/cc65/funcdesc.c |  2 ++
 src/cc65/funcdesc.h |  2 ++
 src/cc65/pragma.c   | 85 +++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 155 insertions(+), 1 deletion(-)

diff --git a/src/cc65/declare.c b/src/cc65/declare.c
index 7b543aa55..2ebc09b14 100644
--- a/src/cc65/declare.c
+++ b/src/cc65/declare.c
@@ -58,6 +58,7 @@
 #include "scanner.h"
 #include "standard.h"
 #include "symtab.h"
+#include "trampoline.h"
 #include "typeconv.h"
 
 
@@ -1315,6 +1316,8 @@ static FuncDesc* ParseFuncDecl (void)
 {
     unsigned Offs;
     SymEntry* Sym;
+    SymEntry* Trampoline;
+    unsigned char TrampolineData;
 
     /* Create a new function descriptor */
     FuncDesc* F = NewFuncDesc ();
@@ -1380,6 +1383,13 @@ static FuncDesc* ParseFuncDecl (void)
     /* Leave the lexical level remembering the symbol tables */
     RememberFunctionLevel (F);
 
+    /* Did we have a trampoline for this function? */
+    GetTrampoline((void **) &Trampoline, &TrampolineData);
+    if (Trampoline) {
+        F->Trampoline = Trampoline;
+        F->TrampolineData = TrampolineData;
+    }
+
     /* Return the function descriptor */
     return F;
 }
@@ -1447,6 +1457,7 @@ static void Declarator (const DeclSpec* Spec, Declaration* D, declmode_t Mode)
 
             /* Function declaration */
             FuncDesc* F;
+            SymEntry* PrevEntry;
 
             /* Skip the opening paren */
             NextToken ();
@@ -1460,6 +1471,16 @@ static void Declarator (const DeclSpec* Spec, Declaration* D, declmode_t Mode)
                 Qualifiers &= ~T_QUAL_FASTCALL;
             }
 
+            /* Was there a previous entry? If so, copy trampoline info from it */
+            PrevEntry = FindGlobalSym (D->Ident);
+            if (PrevEntry && PrevEntry->Flags & SC_FUNC) {
+                FuncDesc* D = PrevEntry->V.F.Func;
+                if (D->Trampoline && !F->Trampoline) {
+                    F->Trampoline = D->Trampoline;
+                    F->TrampolineData = D->TrampolineData;
+                }
+            }
+
             /* Add the function type. Be sure to bounds check the type buffer */
             NeedTypeSpace (D, 1);
             D->Type[D->Index].C = T_FUNC | Qualifiers;
diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index 34cf550a2..fb1232fc1 100644
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -536,6 +536,10 @@ static void FunctionCall (ExprDesc* Expr)
     /* Special handling for function pointers */
     if (IsFuncPtr) {
 
+        if (Func->Trampoline) {
+            Warning("Calling a trampolined function via a pointer, trampoline will not be used");
+        }
+
         /* If the function is not a fastcall function, load the pointer to
         ** the function into the primary.
         */
@@ -584,7 +588,47 @@ static void FunctionCall (ExprDesc* Expr)
     } else {
 
         /* Normal function */
-        g_call (TypeOf (Expr->Type), (const char*) Expr->Name, ParamSize);
+        if (Func->Trampoline) {
+            char tmp[64];
+            StrBuf S = AUTO_STRBUF_INITIALIZER;
+
+            /* Store the trampoline data in tmp4 */
+            sprintf(tmp, "ldy #%u", Func->TrampolineData);
+            SB_AppendStr (&S, tmp);
+            g_asmcode (&S);
+            SB_Clear(&S);
+
+            SB_AppendStr (&S, "sty tmp4");
+            g_asmcode (&S);
+            SB_Clear(&S);
+
+            /* Store the original function address in ptr4 */
+            SB_AppendStr (&S, "ldy #<(_");
+            SB_AppendStr (&S, (const char*) Expr->Name);
+            SB_AppendChar (&S, ')');
+            g_asmcode (&S);
+            SB_Clear(&S);
+
+            SB_AppendStr (&S, "sty ptr4");
+            g_asmcode (&S);
+            SB_Clear(&S);
+
+            SB_AppendStr (&S, "ldy #>(_");
+            SB_AppendStr (&S, (const char*) Expr->Name);
+            SB_AppendChar (&S, ')');
+            g_asmcode (&S);
+            SB_Clear(&S);
+
+            SB_AppendStr (&S, "sty ptr4+1");
+            g_asmcode (&S);
+            SB_Clear(&S);
+
+            SB_Done (&S);
+
+            g_call (TypeOf (Expr->Type), Func->Trampoline->Name, ParamSize);
+        } else {
+            g_call (TypeOf (Expr->Type), (const char*) Expr->Name, ParamSize);
+        }
 
     }
 
diff --git a/src/cc65/funcdesc.c b/src/cc65/funcdesc.c
index b9561a97c..607094acd 100644
--- a/src/cc65/funcdesc.c
+++ b/src/cc65/funcdesc.c
@@ -60,6 +60,8 @@ FuncDesc* NewFuncDesc (void)
     F->ParamCount = 0;
     F->ParamSize  = 0;
     F->LastParam  = 0;
+    F->Trampoline = 0;
+    F->TrampolineData = 0;
 
     /* Return the new struct */
     return F;
diff --git a/src/cc65/funcdesc.h b/src/cc65/funcdesc.h
index b79c6a055..b83cfa362 100644
--- a/src/cc65/funcdesc.h
+++ b/src/cc65/funcdesc.h
@@ -67,6 +67,8 @@ struct FuncDesc {
     unsigned            ParamCount;     /* Number of parameters              */
     unsigned            ParamSize;      /* Size of the parameters            */
     struct SymEntry*    LastParam;      /* Pointer to last parameter         */
+    struct SymEntry*    Trampoline;     /* Pointer to the trampoline         */
+    unsigned char       TrampolineData; /* The trampoline's user data        */
 };
 
 
diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index 707546e1d..c36811f35 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -51,6 +51,7 @@
 #include "scanstrbuf.h"
 #include "symtab.h"
 #include "pragma.h"
+#include "trampoline.h"
 
 
 
@@ -87,6 +88,7 @@ typedef enum {
     PRAGMA_SIGNEDCHARS,                                 /* obsolete */
     PRAGMA_STATIC_LOCALS,
     PRAGMA_STATICLOCALS,                                /* obsolete */
+    PRAGMA_TRAMPOLINE,
     PRAGMA_WARN,
     PRAGMA_WRITABLE_STRINGS,
     PRAGMA_ZPSYM,
@@ -122,6 +124,7 @@ static const struct Pragma {
     { "signedchars",            PRAGMA_SIGNEDCHARS        },      /* obsolete */
     { "static-locals",          PRAGMA_STATIC_LOCALS      },
     { "staticlocals",           PRAGMA_STATICLOCALS       },      /* obsolete */
+    { "trampoline",		PRAGMA_TRAMPOLINE	  },
     { "warn",                   PRAGMA_WARN               },
     { "writable-strings",       PRAGMA_WRITABLE_STRINGS   },
     { "zpsym",                  PRAGMA_ZPSYM              },
@@ -446,6 +449,84 @@ ExitPoint:
 }
 
 
+static void TrampolinePragma (StrBuf* B)
+/* Handle the trampoline pragma */
+{
+    StrBuf      S = AUTO_STRBUF_INITIALIZER;
+    const char *Name;
+    long Val;
+    SymEntry *Entry;
+
+    /* Check for the "push" or "pop" keywords */
+    switch (ParsePushPop (B)) {
+
+        case PP_NONE:
+            Error ("Push or pop required");
+            break;
+
+        case PP_PUSH:
+            break;
+
+        case PP_POP:
+            PopTrampoline();
+
+            /* Done */
+            goto ExitPoint;
+
+        case PP_ERROR:
+            /* Bail out */
+            goto ExitPoint;
+
+        default:
+            Internal ("Invalid result from ParsePushPop");
+
+    }
+
+    /* A symbol argument must follow */
+    if (!SB_GetSym (B, &S, NULL)) {
+        goto ExitPoint;
+    }
+
+    /* Skip the following comma */
+    if (!GetComma (B)) {
+        /* Error already flagged by GetComma */
+        Error ("Value required for trampoline data");
+        goto ExitPoint;
+    }
+
+    if (!GetNumber (B, &Val)) {
+        Error ("Value required for trampoline data");
+        goto ExitPoint;
+    }
+
+    if (Val < 0 || Val > 255) {
+        Error ("Value must be between 0-255");
+        goto ExitPoint;
+    }
+
+    /* Get the string */
+    Name = SB_GetConstBuf (&S);
+    Entry = FindSym(Name);
+
+    /* Check if the name is valid */
+    if (Entry && Entry->Flags & (SC_FUNC | SC_STORAGE)) {
+
+        PushTrampoline(Entry, Val);
+        Entry->Flags |= SC_REF;
+
+    } else {
+
+        /* Segment name is invalid */
+        Error ("Trampoline does not exist or is not a function or array");
+
+    }
+
+ExitPoint:
+    /* Call the string buf destructor */
+    SB_Done (&S);
+}
+
+
 
 static void CharMapPragma (StrBuf* B)
 /* Change the character map */
@@ -791,6 +872,10 @@ static void ParsePragma (void)
             FlagPragma (&B, &StaticLocals);
             break;
 
+	case PRAGMA_TRAMPOLINE:
+	    TrampolinePragma(&B);
+	    break;
+
         case PRAGMA_WARN:
             WarnPragma (&B);
             break;

From ca41af41c2d555355ea45dd0c83a5fa3508ddd1a Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Tue, 16 May 2017 20:10:24 +0300
Subject: [PATCH 07/13] Rename pragma trampoline to wrapped-call, value to
 identifier

---
 doc/cc65.sgml         | 50 +++++++++++++++++++++----------------------
 src/cc65/pragma.c     | 20 ++++++++---------
 test/val/trampoline.c | 12 +++++------
 3 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/doc/cc65.sgml b/doc/cc65.sgml
index 99ddfc82d..a9b88c2b4 100644
--- a/doc/cc65.sgml
+++ b/doc/cc65.sgml
@@ -1209,31 +1209,6 @@ parameter with the <tt/#pragma/.
   The <tt/#pragma/ understands the push and pop parameters as explained above.
 
 
-<sect1><tt>#pragma trampoline (&lt;push&rt;, &lt;name&gt;, &lt;value&gt;)</tt><label id="pragma-trampoline"><p>
-
-  This pragma sets a trampoline for functions. The name is either
-  a function returning void and taking no parameters, or the address
-  of an array in memory (for a RAM trampoline). The value is an
-  8-bit number that's set to tmp4.
-
-  The address of the function is passed in ptr4.
-
-  This is useful for example with banked memory, to automatically
-  switch banks to where this function resides, and then restore
-  the bank when it returns.
-
-  The <tt/#pragma/ requires the push and pop parameters as explained above.
-
-  Example:
-  <tscreen><verb>
-	void mytrampoline(void);
-
-        #pragma trampoline (push, mytrampoline, 0)
-        void somefunc(void);
-        #pragma trampoline (pop)
-  </verb></tscreen>
-
-
 <sect1><tt>#pragma warn (name, [push,] on|off)</tt><label id="pragma-warn"><p>
 
   Switch compiler warnings on or off. "name" is the name of a warning (see the
@@ -1254,6 +1229,31 @@ parameter with the <tt/#pragma/.
   </verb></tscreen>
 
 
+<sect1><tt>#pragma wrapped-call (&lt;push&rt;, &lt;name&gt;, &lt;identifier&gt;)</tt><label id="pragma-trampoline"><p>
+
+  This pragma sets a wrapper for functions, often used for trampolines.
+  The name is either a function returning void and taking no parameters,
+  or the address of an array in memory (for a RAM trampoline). The identifier
+  is an 8-bit number that's set to tmp4.
+
+  The address of the function is passed in ptr4.
+
+  This is useful for example with banked memory, to automatically
+  switch banks to where this function resides, and then restore
+  the bank when it returns.
+
+  The <tt/#pragma/ requires the push and pop parameters as explained above.
+
+  Example:
+  <tscreen><verb>
+	void mytrampoline(void);
+
+        #pragma wrapped-call (push, mytrampoline, 0)
+        void somefunc(void);
+        #pragma wrapped-call (pop)
+  </verb></tscreen>
+
+
 <sect1><tt>#pragma writable-strings ([push,] on|off)</tt><label id="pragma-writable-strings"><p>
 
   Changes the storage location of string literals. For historical reasons,
diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index c36811f35..6ec2df3a3 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -88,8 +88,8 @@ typedef enum {
     PRAGMA_SIGNEDCHARS,                                 /* obsolete */
     PRAGMA_STATIC_LOCALS,
     PRAGMA_STATICLOCALS,                                /* obsolete */
-    PRAGMA_TRAMPOLINE,
     PRAGMA_WARN,
+    PRAGMA_WRAPPED_CALL,
     PRAGMA_WRITABLE_STRINGS,
     PRAGMA_ZPSYM,
     PRAGMA_COUNT
@@ -124,8 +124,8 @@ static const struct Pragma {
     { "signedchars",            PRAGMA_SIGNEDCHARS        },      /* obsolete */
     { "static-locals",          PRAGMA_STATIC_LOCALS      },
     { "staticlocals",           PRAGMA_STATICLOCALS       },      /* obsolete */
-    { "trampoline",		PRAGMA_TRAMPOLINE	  },
     { "warn",                   PRAGMA_WARN               },
+    { "wrapped-call",		PRAGMA_WRAPPED_CALL	  },
     { "writable-strings",       PRAGMA_WRITABLE_STRINGS   },
     { "zpsym",                  PRAGMA_ZPSYM              },
 };
@@ -449,8 +449,8 @@ ExitPoint:
 }
 
 
-static void TrampolinePragma (StrBuf* B)
-/* Handle the trampoline pragma */
+static void WrappedCallPragma (StrBuf* B)
+/* Handle the wrapped-call pragma */
 {
     StrBuf      S = AUTO_STRBUF_INITIALIZER;
     const char *Name;
@@ -490,17 +490,17 @@ static void TrampolinePragma (StrBuf* B)
     /* Skip the following comma */
     if (!GetComma (B)) {
         /* Error already flagged by GetComma */
-        Error ("Value required for trampoline data");
+        Error ("Value required for wrapped-call identifier");
         goto ExitPoint;
     }
 
     if (!GetNumber (B, &Val)) {
-        Error ("Value required for trampoline data");
+        Error ("Value required for wrapped-call identifier");
         goto ExitPoint;
     }
 
     if (Val < 0 || Val > 255) {
-        Error ("Value must be between 0-255");
+        Error ("Identifier must be between 0-255");
         goto ExitPoint;
     }
 
@@ -517,7 +517,7 @@ static void TrampolinePragma (StrBuf* B)
     } else {
 
         /* Segment name is invalid */
-        Error ("Trampoline does not exist or is not a function or array");
+        Error ("Wrapped-call target does not exist or is not a function or array");
 
     }
 
@@ -872,8 +872,8 @@ static void ParsePragma (void)
             FlagPragma (&B, &StaticLocals);
             break;
 
-	case PRAGMA_TRAMPOLINE:
-	    TrampolinePragma(&B);
+	case PRAGMA_WRAPPED_CALL:
+	    WrappedCallPragma(&B);
 	    break;
 
         case PRAGMA_WARN:
diff --git a/test/val/trampoline.c b/test/val/trampoline.c
index b5df1a22b..aad4c96ea 100644
--- a/test/val/trampoline.c
+++ b/test/val/trampoline.c
@@ -23,21 +23,21 @@ void func3() {
 }
 
 unsigned char array[30];
-#pragma trampoline(push, array, 0)
-#pragma trampoline(pop)
+#pragma wrapped-call(push, array, 0)
+#pragma wrapped-call(pop)
 
-#pragma trampoline(push, trampoline_inc, 0)
+#pragma wrapped-call(push, trampoline_inc, 0)
 
 void func2() {
 	func3();
 }
 
-#pragma trampoline(push, trampoline_set, 4)
+#pragma wrapped-call(push, trampoline_set, 4)
 
 void func1(void);
 
-#pragma trampoline(pop)
-#pragma trampoline(pop)
+#pragma wrapped-call(pop)
+#pragma wrapped-call(pop)
 
 void func1() {
 	func2();

From ac7a0e21ac0211df2594dff303da973e88a4faee Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Tue, 16 May 2017 20:14:19 +0300
Subject: [PATCH 08/13] Correct missed doc label

---
 doc/cc65.sgml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/cc65.sgml b/doc/cc65.sgml
index a9b88c2b4..d87fa47a7 100644
--- a/doc/cc65.sgml
+++ b/doc/cc65.sgml
@@ -1229,7 +1229,7 @@ parameter with the <tt/#pragma/.
   </verb></tscreen>
 
 
-<sect1><tt>#pragma wrapped-call (&lt;push&rt;, &lt;name&gt;, &lt;identifier&gt;)</tt><label id="pragma-trampoline"><p>
+<sect1><tt>#pragma wrapped-call (&lt;push&rt;, &lt;name&gt;, &lt;identifier&gt;)</tt><label id="pragma-wrapped-call"><p>
 
   This pragma sets a wrapper for functions, often used for trampolines.
   The name is either a function returning void and taking no parameters,

From a590b99f5be4af391811d0e79520ea07852b763f Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Thu, 18 May 2017 14:21:43 +0300
Subject: [PATCH 09/13] Align with spaces instead of tabs here

---
 src/cc65/pragma.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index 6ec2df3a3..27015285e 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -125,7 +125,7 @@ static const struct Pragma {
     { "static-locals",          PRAGMA_STATIC_LOCALS      },
     { "staticlocals",           PRAGMA_STATICLOCALS       },      /* obsolete */
     { "warn",                   PRAGMA_WARN               },
-    { "wrapped-call",		PRAGMA_WRAPPED_CALL	  },
+    { "wrapped-call",           PRAGMA_WRAPPED_CALL	  },
     { "writable-strings",       PRAGMA_WRITABLE_STRINGS   },
     { "zpsym",                  PRAGMA_ZPSYM              },
 };

From 7feced88627dc3f07fe1580e80670c234bd0a984 Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Thu, 18 May 2017 15:54:47 +0300
Subject: [PATCH 10/13] More tabs to spaces

---
 src/cc65/pragma.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index 27015285e..fe7101d97 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -125,7 +125,7 @@ static const struct Pragma {
     { "static-locals",          PRAGMA_STATIC_LOCALS      },
     { "staticlocals",           PRAGMA_STATICLOCALS       },      /* obsolete */
     { "warn",                   PRAGMA_WARN               },
-    { "wrapped-call",           PRAGMA_WRAPPED_CALL	  },
+    { "wrapped-call",           PRAGMA_WRAPPED_CALL       },
     { "writable-strings",       PRAGMA_WRITABLE_STRINGS   },
     { "zpsym",                  PRAGMA_ZPSYM              },
 };

From f6fa74a6367f6aa8f803c867c61be9f6071bb614 Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Thu, 18 May 2017 16:00:04 +0300
Subject: [PATCH 11/13] Rename trampoline to wrappedcall everywhere

---
 src/cc65/declare.c                       | 24 +++++++--------
 src/cc65/expr.c                          | 12 ++++----
 src/cc65/funcdesc.c                      |  4 +--
 src/cc65/funcdesc.h                      |  4 +--
 src/cc65/pragma.c                        |  6 ++--
 src/cc65/{trampoline.c => wrappedcall.c} | 38 ++++++++++++------------
 src/cc65/{trampoline.h => wrappedcall.h} | 22 +++++++-------
 7 files changed, 55 insertions(+), 55 deletions(-)
 rename src/cc65/{trampoline.c => wrappedcall.c} (79%)
 rename src/cc65/{trampoline.h => wrappedcall.h} (85%)

diff --git a/src/cc65/declare.c b/src/cc65/declare.c
index 2ebc09b14..a6b232905 100644
--- a/src/cc65/declare.c
+++ b/src/cc65/declare.c
@@ -58,7 +58,7 @@
 #include "scanner.h"
 #include "standard.h"
 #include "symtab.h"
-#include "trampoline.h"
+#include "wrappedcall.h"
 #include "typeconv.h"
 
 
@@ -1316,8 +1316,8 @@ static FuncDesc* ParseFuncDecl (void)
 {
     unsigned Offs;
     SymEntry* Sym;
-    SymEntry* Trampoline;
-    unsigned char TrampolineData;
+    SymEntry* WrappedCall;
+    unsigned char WrappedCallData;
 
     /* Create a new function descriptor */
     FuncDesc* F = NewFuncDesc ();
@@ -1383,11 +1383,11 @@ static FuncDesc* ParseFuncDecl (void)
     /* Leave the lexical level remembering the symbol tables */
     RememberFunctionLevel (F);
 
-    /* Did we have a trampoline for this function? */
-    GetTrampoline((void **) &Trampoline, &TrampolineData);
-    if (Trampoline) {
-        F->Trampoline = Trampoline;
-        F->TrampolineData = TrampolineData;
+    /* Did we have a WrappedCall for this function? */
+    GetWrappedCall((void **) &WrappedCall, &WrappedCallData);
+    if (WrappedCall) {
+        F->WrappedCall = WrappedCall;
+        F->WrappedCallData = WrappedCallData;
     }
 
     /* Return the function descriptor */
@@ -1471,13 +1471,13 @@ static void Declarator (const DeclSpec* Spec, Declaration* D, declmode_t Mode)
                 Qualifiers &= ~T_QUAL_FASTCALL;
             }
 
-            /* Was there a previous entry? If so, copy trampoline info from it */
+            /* Was there a previous entry? If so, copy WrappedCall info from it */
             PrevEntry = FindGlobalSym (D->Ident);
             if (PrevEntry && PrevEntry->Flags & SC_FUNC) {
                 FuncDesc* D = PrevEntry->V.F.Func;
-                if (D->Trampoline && !F->Trampoline) {
-                    F->Trampoline = D->Trampoline;
-                    F->TrampolineData = D->TrampolineData;
+                if (D->WrappedCall && !F->WrappedCall) {
+                    F->WrappedCall = D->WrappedCall;
+                    F->WrappedCallData = D->WrappedCallData;
                 }
             }
 
diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index fb1232fc1..467c30da2 100644
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -536,8 +536,8 @@ static void FunctionCall (ExprDesc* Expr)
     /* Special handling for function pointers */
     if (IsFuncPtr) {
 
-        if (Func->Trampoline) {
-            Warning("Calling a trampolined function via a pointer, trampoline will not be used");
+        if (Func->WrappedCall) {
+            Warning("Calling a wrapped function via a pointer, wrapped-call will not be used");
         }
 
         /* If the function is not a fastcall function, load the pointer to
@@ -588,12 +588,12 @@ static void FunctionCall (ExprDesc* Expr)
     } else {
 
         /* Normal function */
-        if (Func->Trampoline) {
+        if (Func->WrappedCall) {
             char tmp[64];
             StrBuf S = AUTO_STRBUF_INITIALIZER;
 
-            /* Store the trampoline data in tmp4 */
-            sprintf(tmp, "ldy #%u", Func->TrampolineData);
+            /* Store the WrappedCall data in tmp4 */
+            sprintf(tmp, "ldy #%u", Func->WrappedCallData);
             SB_AppendStr (&S, tmp);
             g_asmcode (&S);
             SB_Clear(&S);
@@ -625,7 +625,7 @@ static void FunctionCall (ExprDesc* Expr)
 
             SB_Done (&S);
 
-            g_call (TypeOf (Expr->Type), Func->Trampoline->Name, ParamSize);
+            g_call (TypeOf (Expr->Type), Func->WrappedCall->Name, ParamSize);
         } else {
             g_call (TypeOf (Expr->Type), (const char*) Expr->Name, ParamSize);
         }
diff --git a/src/cc65/funcdesc.c b/src/cc65/funcdesc.c
index 607094acd..273263dec 100644
--- a/src/cc65/funcdesc.c
+++ b/src/cc65/funcdesc.c
@@ -60,8 +60,8 @@ FuncDesc* NewFuncDesc (void)
     F->ParamCount = 0;
     F->ParamSize  = 0;
     F->LastParam  = 0;
-    F->Trampoline = 0;
-    F->TrampolineData = 0;
+    F->WrappedCall = 0;
+    F->WrappedCallData = 0;
 
     /* Return the new struct */
     return F;
diff --git a/src/cc65/funcdesc.h b/src/cc65/funcdesc.h
index b83cfa362..966aff573 100644
--- a/src/cc65/funcdesc.h
+++ b/src/cc65/funcdesc.h
@@ -67,8 +67,8 @@ struct FuncDesc {
     unsigned            ParamCount;     /* Number of parameters              */
     unsigned            ParamSize;      /* Size of the parameters            */
     struct SymEntry*    LastParam;      /* Pointer to last parameter         */
-    struct SymEntry*    Trampoline;     /* Pointer to the trampoline         */
-    unsigned char       TrampolineData; /* The trampoline's user data        */
+    struct SymEntry*    WrappedCall;     /* Pointer to the WrappedCall         */
+    unsigned char       WrappedCallData; /* The WrappedCall's user data        */
 };
 
 
diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index fe7101d97..98f1a20d0 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -51,7 +51,7 @@
 #include "scanstrbuf.h"
 #include "symtab.h"
 #include "pragma.h"
-#include "trampoline.h"
+#include "wrappedcall.h"
 
 
 
@@ -468,7 +468,7 @@ static void WrappedCallPragma (StrBuf* B)
             break;
 
         case PP_POP:
-            PopTrampoline();
+            PopWrappedCall();
 
             /* Done */
             goto ExitPoint;
@@ -511,7 +511,7 @@ static void WrappedCallPragma (StrBuf* B)
     /* Check if the name is valid */
     if (Entry && Entry->Flags & (SC_FUNC | SC_STORAGE)) {
 
-        PushTrampoline(Entry, Val);
+        PushWrappedCall(Entry, Val);
         Entry->Flags |= SC_REF;
 
     } else {
diff --git a/src/cc65/trampoline.c b/src/cc65/wrappedcall.c
similarity index 79%
rename from src/cc65/trampoline.c
rename to src/cc65/wrappedcall.c
index 1f35a0f3c..2d11245fd 100644
--- a/src/cc65/trampoline.c
+++ b/src/cc65/wrappedcall.c
@@ -1,8 +1,8 @@
 /*****************************************************************************/
 /*                                                                           */
-/*                                trampoline.c                               */
+/*                                wrappedcall.c                              */
 /*                                                                           */
-/*                          Trampoline management                            */
+/*                          WrappedCall management                           */
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
@@ -44,7 +44,7 @@
 /* cc65 */
 #include "codeent.h"
 #include "error.h"
-#include "trampoline.h"
+#include "wrappedcall.h"
 
 
 
@@ -53,8 +53,8 @@
 /*****************************************************************************/
 
 
-/* Trampolines */
-static IntPtrStack Trampolines;
+/* WrappedCalls */
+static IntPtrStack WrappedCalls;
 
 
 
@@ -64,39 +64,39 @@ static IntPtrStack Trampolines;
 
 
 
-void PushTrampoline (void *Ptr, unsigned char Val)
-/* Push the current trampoline */
+void PushWrappedCall (void *Ptr, unsigned char Val)
+/* Push the current WrappedCall */
 {
-    if (IPS_IsFull (&Trampolines)) {
-        Error ("Trampoline stack overflow");
+    if (IPS_IsFull (&WrappedCalls)) {
+        Error ("WrappedCall stack overflow");
     } else {
-        IPS_Push (&Trampolines, Val, Ptr);
+        IPS_Push (&WrappedCalls, Val, Ptr);
     }
 }
 
 
 
-void PopTrampoline (void)
-/* Remove the current trampoline */
+void PopWrappedCall (void)
+/* Remove the current WrappedCall */
 {
-    if (IPS_GetCount (&Trampolines) < 1) {
-        Error ("Trampoline stack is empty");
+    if (IPS_GetCount (&WrappedCalls) < 1) {
+        Error ("WrappedCall stack is empty");
     } else {
-        IPS_Drop (&Trampolines);
+        IPS_Drop (&WrappedCalls);
     }
 }
 
 
 
-void GetTrampoline (void **Ptr, unsigned char *Val)
-/* Get the current trampoline */
+void GetWrappedCall (void **Ptr, unsigned char *Val)
+/* Get the current WrappedCall */
 {
-    if (IPS_GetCount (&Trampolines) < 1) {
+    if (IPS_GetCount (&WrappedCalls) < 1) {
         *Ptr = NULL;
         *Val = 0;
     } else {
         long Temp;
-        IPS_Get (&Trampolines, &Temp, Ptr);
+        IPS_Get (&WrappedCalls, &Temp, Ptr);
         *Val = Temp;
     }
 }
diff --git a/src/cc65/trampoline.h b/src/cc65/wrappedcall.h
similarity index 85%
rename from src/cc65/trampoline.h
rename to src/cc65/wrappedcall.h
index f110bd42e..3517c2465 100644
--- a/src/cc65/trampoline.h
+++ b/src/cc65/wrappedcall.h
@@ -1,8 +1,8 @@
 /*****************************************************************************/
 /*                                                                           */
-/*                                trampoline.h                               */
+/*                                wrappedcall.h                              */
 /*                                                                           */
-/*                            Trampoline management                          */
+/*                            Wrapped-call management                        */
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
@@ -30,8 +30,8 @@
 
 
 
-#ifndef TRAMPOLINE_H
-#define TRAMPOLINE_H
+#ifndef WRAPPEDCALL_H
+#define WRAPPEDCALL_H
 
 
 
@@ -50,16 +50,16 @@
 
 
 
-void PushTrampoline (void *Ptr, unsigned char Val);
-/* Push the current trampoline */
+void PushWrappedCall (void *Ptr, unsigned char Val);
+/* Push the current WrappedCall */
 
-void PopTrampoline (void);
-/* Pop the current trampoline */
+void PopWrappedCall (void);
+/* Pop the current WrappedCall */
 
-void GetTrampoline (void **Ptr, unsigned char *Val);
-/* Get the current trampoline, if any */
+void GetWrappedCall (void **Ptr, unsigned char *Val);
+/* Get the current WrappedCall, if any */
 
 
-/* End of trampoline.h */
+/* End of wrappedcall.h */
 
 #endif

From 4c05c46cd15ade6c282bb4bf51686a07bf0b4ca3 Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Thu, 18 May 2017 16:11:39 +0300
Subject: [PATCH 12/13] Remove RAM-trampoline array support

---
 doc/cc65.sgml         | 5 ++---
 src/cc65/pragma.c     | 2 +-
 test/val/trampoline.c | 4 ----
 3 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/doc/cc65.sgml b/doc/cc65.sgml
index d87fa47a7..2e480e4c3 100644
--- a/doc/cc65.sgml
+++ b/doc/cc65.sgml
@@ -1232,9 +1232,8 @@ parameter with the <tt/#pragma/.
 <sect1><tt>#pragma wrapped-call (&lt;push&rt;, &lt;name&gt;, &lt;identifier&gt;)</tt><label id="pragma-wrapped-call"><p>
 
   This pragma sets a wrapper for functions, often used for trampolines.
-  The name is either a function returning void and taking no parameters,
-  or the address of an array in memory (for a RAM trampoline). The identifier
-  is an 8-bit number that's set to tmp4.
+  The name is a function returning void and taking no parameters.
+  The identifier is an 8-bit number that's set to tmp4.
 
   The address of the function is passed in ptr4.
 
diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index 98f1a20d0..2cd510ff8 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -509,7 +509,7 @@ static void WrappedCallPragma (StrBuf* B)
     Entry = FindSym(Name);
 
     /* Check if the name is valid */
-    if (Entry && Entry->Flags & (SC_FUNC | SC_STORAGE)) {
+    if (Entry && Entry->Flags & SC_FUNC) {
 
         PushWrappedCall(Entry, Val);
         Entry->Flags |= SC_REF;
diff --git a/test/val/trampoline.c b/test/val/trampoline.c
index aad4c96ea..6723df9b3 100644
--- a/test/val/trampoline.c
+++ b/test/val/trampoline.c
@@ -22,10 +22,6 @@ void func3() {
 
 }
 
-unsigned char array[30];
-#pragma wrapped-call(push, array, 0)
-#pragma wrapped-call(pop)
-
 #pragma wrapped-call(push, trampoline_inc, 0)
 
 void func2() {

From 219b239a347fd07742e09628599f5d7e4f987253 Mon Sep 17 00:00:00 2001
From: Lauri Kasanen <cand@gmx.com>
Date: Thu, 18 May 2017 17:14:26 +0300
Subject: [PATCH 13/13] Adjustments in response to latest comments

---
 src/cc65/funcdesc.h   | 4 ++--
 src/cc65/pragma.c     | 2 +-
 test/val/trampoline.c | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/cc65/funcdesc.h b/src/cc65/funcdesc.h
index 966aff573..040f6e97c 100644
--- a/src/cc65/funcdesc.h
+++ b/src/cc65/funcdesc.h
@@ -67,8 +67,8 @@ struct FuncDesc {
     unsigned            ParamCount;     /* Number of parameters              */
     unsigned            ParamSize;      /* Size of the parameters            */
     struct SymEntry*    LastParam;      /* Pointer to last parameter         */
-    struct SymEntry*    WrappedCall;     /* Pointer to the WrappedCall         */
-    unsigned char       WrappedCallData; /* The WrappedCall's user data        */
+    struct SymEntry*    WrappedCall;    /* Pointer to the WrappedCall        */
+    unsigned char       WrappedCallData;/* The WrappedCall's user data       */
 };
 
 
diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index 2cd510ff8..8d5dfd8b1 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -517,7 +517,7 @@ static void WrappedCallPragma (StrBuf* B)
     } else {
 
         /* Segment name is invalid */
-        Error ("Wrapped-call target does not exist or is not a function or array");
+        Error ("Wrapped-call target does not exist or is not a function");
 
     }
 
diff --git a/test/val/trampoline.c b/test/val/trampoline.c
index 6723df9b3..63741b590 100644
--- a/test/val/trampoline.c
+++ b/test/val/trampoline.c
@@ -1,5 +1,5 @@
 /*
-  !!DESCRIPTION!! trampoline pragma
+  !!DESCRIPTION!! wrapped-call pragma used for trampolines
   !!ORIGIN!!      cc65 regression tests
   !!LICENCE!!     Public Domain
   !!AUTHOR!!      Lauri Kasanen