6502/cc65
1
0
Fork 0
mirror of https://github.com/cc65/cc65.git synced 2024-06-17 00:29:31 +00:00
Code Issues Projects Releases Wiki Activity

Rename pragma trampoline to wrapped-call, value to identifier

Browse Source
This commit is contained in:
Lauri Kasanen 2017-05-16 20:10:24 +03:00
parent 2890b3a810
commit ca41af41c2
3 changed files with 41 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
doc/cc65.sgml
View File

@ -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,

20
src/cc65/pragma.c
View File

@ -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:

12
test/val/trampoline.c
View File

@ -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();