#include "litpool.h"
#include "locals.h"
#include "scanner.h"
+#include "segments.h"
#include "stmt.h"
#include "symtab.h"
#include "function.h"
-const char* GetFuncName (const Function* F)
+const char* F_GetFuncName (const Function* F)
/* Return the name of the current function */
{
return F->FuncEntry->Name;
-unsigned GetParamCount (const Function* F)
+unsigned F_GetParamCount (const Function* F)
/* Return the parameter count for the current function */
{
return F->Desc->ParamCount;
-unsigned GetParamSize (const Function* F)
+unsigned F_GetParamSize (const Function* F)
/* Return the parameter size for the current function */
{
return F->Desc->ParamSize;
-type* GetReturnType (Function* F)
+type* F_GetReturnType (Function* F)
/* Get the return type for the function */
{
return F->ReturnType;
-int HasVoidReturn (const Function* F)
+int F_HasVoidReturn (const Function* F)
/* Return true if the function does not have a return value */
{
return IsTypeVoid (F->ReturnType);
-int IsVariadic (const Function* F)
+int F_IsVariadic (const Function* F)
/* Return true if this is a variadic function */
{
return (F->Desc->Flags & FD_VARIADIC) != 0;
-unsigned GetRetLab (const Function* F)
+int F_IsOldStyle (const Function* F)
+/* Return true if this is an old style (K&R) function */
+{
+ return (F->Desc->Flags & FD_OLDSTYLE) != 0;
+}
+
+
+
+int F_HasOldStyleIntRet (const Function* F)
+/* Return true if this is an old style (K&R) function with an implicit int return */
+{
+ return (F->Desc->Flags & FD_OLDSTYLE_INTRET) != 0;
+}
+
+
+
+unsigned F_GetRetLab (const Function* F)
/* Return the return jump label */
{
return F->RetLab;
-int GetTopLevelSP (const Function* F)
+int F_GetTopLevelSP (const Function* F)
/* Get the value of the stack pointer on function top level */
{
return F->TopLevelSP;
-int ReserveLocalSpace (Function* F, unsigned Size)
+int F_ReserveLocalSpace (Function* F, unsigned Size)
/* Reserve (but don't allocate) the given local space and return the stack
* offset.
*/
-void AllocLocalSpace (Function* F)
+void F_AllocLocalSpace (Function* F)
/* Allocate any local space previously reserved. The function will do
* nothing if there is no reserved local space.
*/
{
if (F->Reserved > 0) {
- /* Create space on the stack */
- g_space (F->Reserved);
+ /* Create space on the stack */
+ g_space (F->Reserved);
- /* Correct the stack pointer */
- oursp -= F->Reserved;
+ /* Correct the stack pointer */
+ oursp -= F->Reserved;
- /* Nothing more reserved */
- F->Reserved = 0;
+ /* Nothing more reserved */
+ F->Reserved = 0;
}
}
{
int HadReturn;
int IsVoidFunc;
- unsigned Flags;
+ SymEntry* LastParam;
/* Get the function descriptor from the function entry */
FuncDesc* D = Func->V.F.Func;
/* Reenter the lexical level */
ReenterFunctionLevel (D);
+ /* Before adding more symbols, remember the last parameter for later */
+ LastParam = D->SymTab->SymTail;
+
/* Declare two special functions symbols: __fixargs__ and __argsize__.
* The latter is different depending on the type of the function (variadic
* or not).
*/
AddConstSym ("__fixargs__", type_uint, SC_DEF | SC_CONST, D->ParamSize);
if (D->Flags & FD_VARIADIC) {
- /* Variadic function. The variable must be const. */
- static const type T [] = { T_UCHAR | T_QUAL_CONST, T_END };
- AddLocalSym ("__argsize__", T, SC_DEF | SC_REF | SC_AUTO, 0);
+ /* Variadic function. The variable must be const. */
+ static const type T [] = { T_UCHAR | T_QUAL_CONST, T_END };
+ AddLocalSym ("__argsize__", T, SC_DEF | SC_REF | SC_AUTO, 0);
} else {
- /* Non variadic */
+ /* Non variadic */
AddConstSym ("__argsize__", type_uchar, SC_DEF | SC_CONST, D->ParamSize);
}
InitRegVars ();
/* Allocate code and data segments for this function */
- g_pushseg (&Func->V.F.CS, &Func->V.F.DS, Func->Name);
+ Func->V.F.Seg = PushSegments (Func);
/* If this is a fastcall function, push the last parameter onto the stack */
if (IsFastCallFunc (Func->Type) && D->ParamCount > 0) {
- SymEntry* LastParam;
- unsigned Flags;
-
- /* Fastcall functions may never have an ellipsis or the compiler is buggy */
- CHECK ((D->Flags & FD_VARIADIC) == 0);
+ unsigned Flags;
- /* Get a pointer to the last parameter entry */
- LastParam = D->SymTab->SymTail;
+ /* Fastcall functions may never have an ellipsis or the compiler is buggy */
+ CHECK ((D->Flags & FD_VARIADIC) == 0);
- /* Generate the push */
- if (IsTypeFunc (LastParam->Type)) {
+ /* Generate the push */
+ if (IsTypeFunc (LastParam->Type)) {
/* Pointer to function */
Flags = CF_PTR;
} else {
}
/* Generate function entry code if needed */
- g_enter (TypeOf (Func->Type), GetParamSize (CurrentFunc));
+ g_enter (TypeOf (Func->Type), F_GetParamSize (CurrentFunc));
/* Setup the stack */
oursp = 0;
/* Now process statements in this block */
HadReturn = 0;
- while (curtok != TOK_RCURLY) {
- if (curtok != TOK_CEOF) {
- HadReturn = Statement ();
+ while (CurTok.Tok != TOK_RCURLY) {
+ if (CurTok.Tok != TOK_CEOF) {
+ HadReturn = Statement (0);
} else {
break;
}
/* If the function has a return type but no return statement, flag
* a warning
*/
- IsVoidFunc = HasVoidReturn (CurrentFunc);
+ IsVoidFunc = F_HasVoidReturn (CurrentFunc);
#if 0
/* Does not work reliably */
- if (!IsVoidFunc && !HadReturn) {
+ if (!F_IsVoidFunc && !HadReturn) {
Warning ("Function `%s' should return a value", Func->Name);
}
#endif
/* Output the function exit code label */
- g_defcodelabel (GetRetLab (CurrentFunc));
+ g_defcodelabel (F_GetRetLab (CurrentFunc));
/* Restore the register variables */
RestoreRegVars (!IsVoidFunc);
/* Generate the exit code */
- Flags = IsVoidFunc? CF_NONE : CF_REG;
- g_leave (Flags, 0);
+ g_leave ();
/* Eat the closing brace */
ConsumeRCurly ();
LeaveFunctionLevel ();
/* Switch back to the old segments */
- g_popseg ();
+ PopSegments ();
/* Reset the current function pointer */
FreeFunction (CurrentFunc);
projects / cc65 / blobdiff