gered/picoc
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Removed unnecessary ResultOnHeap parameters - they just added code for no reason.

Browse source 
Arguments are now stored fully on the stack to fix a bug with nested function calls.

git-svn-id: http://picoc.googlecode.com/svn/trunk@91 21eae674-98b7-11dd-bd71-f92a316d2d60
This commit is contained in:
zik.saleeba 2009-02-19 23:29:35 +00:00
parent b428c0f544
commit ebc32dc1f0
4 changed files with 71 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
intrinsic.c
View file

@ -4,7 +4,7 @@
void IntrinsicPrintInt(void) void IntrinsicPrintInt(void)
{ {
printf("%d\n", Parameter[0]->Val->Integer); printf("%d\n", TopStackFrame->Parameter[0]->Val->Integer);
} }
void IntrinsicPrintf(void) void IntrinsicPrintf(void)

105
parse.c
View file

@ -2,11 +2,6 @@
#include "picoc.h" #include "picoc.h"
/* parameter passing area */
struct Value *Parameter[PARAMETER_MAX];
int ParameterUsed = 0;
struct Value *ReturnValue;
/* local prototypes */ /* local prototypes */
int ParseArguments(struct ParseState *Parser, int RunIt); int ParseArguments(struct ParseState *Parser, int RunIt);
int ParseStatementMaybeRun(struct ParseState *Parser, int Condition); int ParseStatementMaybeRun(struct ParseState *Parser, int Condition);
@ -21,9 +16,11 @@ void ParseInit()
} }
/* do a function call */ /* do a function call */
void ParseFunctionCall(struct ParseState *Parser, struct Value **Result, int ResultOnHeap, const char *FuncName) void ParseFunctionCall(struct ParseState *Parser, struct Value **Result, const char *FuncName)
{ {
struct Value *FuncValue; struct Value *FuncValue;
struct Value *Param;
int ArgCount;
enum LexToken Token = LexGetToken(Parser, NULL, TRUE); /* open bracket */ enum LexToken Token = LexGetToken(Parser, NULL, TRUE); /* open bracket */
if (Parser->Mode == RunModeRun) if (Parser->Mode == RunModeRun)
@ -32,25 +29,31 @@ void ParseFunctionCall(struct ParseState *Parser, struct Value **Result, int Res
if (FuncValue->Typ->Base != TypeFunction) if (FuncValue->Typ->Base != TypeFunction)
ProgramFail(Parser, "not a function - can't call"); ProgramFail(Parser, "not a function - can't call");
*Result = VariableAllocValueFromType(Parser, FuncValue->Val->FuncDef.ReturnType, FALSE, ResultOnHeap); *Result = VariableAllocValueFromType(Parser, FuncValue->Val->FuncDef.ReturnType, FALSE);
if (FuncValue->Val->FuncDef.Intrinsic == NULL) VariableStackFrameAdd(Parser, FuncValue->Val->FuncDef.Intrinsic ? FuncValue->Val->FuncDef.NumParams : 0);
VariableStackFrameAdd(Parser); TopStackFrame->ReturnValue = *Result;
else
HeapPushStackFrame();
} }
/* parse arguments */ /* parse arguments */
ParameterUsed = 0; ArgCount = 0;
do { do {
if (ParseExpression(Parser, &Parameter[ParameterUsed], FALSE)) if (ParseExpression(Parser, &Param))
{ {
if (Parser->Mode == RunModeRun && ParameterUsed >= FuncValue->Val->FuncDef.NumParams) if (Parser->Mode == RunModeRun)
ProgramFail(Parser, "too many arguments"); {
if (ArgCount >= FuncValue->Val->FuncDef.NumParams)
ProgramFail(Parser, "too many arguments to %s()", FuncName);
if (Parser->Mode == RunModeRun && FuncValue->Val->FuncDef.ParamType[ParameterUsed] != Parameter[ParameterUsed]->Typ) if (FuncValue->Val->FuncDef.ParamType[ArgCount] != Param->Typ)
ProgramFail(Parser, "parameter %d to %s is the wrong type", ParameterUsed, FuncName); ProgramFail(Parser, "parameter %d to %s() is the wrong type", ArgCount, FuncName);
ParameterUsed++; if (FuncValue->Val->FuncDef.Intrinsic)
TopStackFrame->Parameter[ArgCount] = Param;
else
VariableDefine(Parser, FuncValue->Val->FuncDef.ParamName[ArgCount], Param);
}
ArgCount++;
Token = LexGetToken(Parser, NULL, TRUE); Token = LexGetToken(Parser, NULL, TRUE);
if (Token != TokenComma && Token != TokenCloseBracket) if (Token != TokenComma && Token != TokenCloseBracket)
ProgramFail(Parser, "comma expected"); ProgramFail(Parser, "comma expected");
@ -65,33 +68,29 @@ void ParseFunctionCall(struct ParseState *Parser, struct Value **Result, int Res
if (Parser->Mode == RunModeRun) if (Parser->Mode == RunModeRun)
{ /* run the function */ { /* run the function */
int Count; if (ArgCount < FuncValue->Val->FuncDef.NumParams)
ProgramFail(Parser, "not enough arguments to '%s'", FuncName);
TopStackFrame->NumParams = ArgCount;
if (FuncValue->Val->FuncDef.Intrinsic == NULL) if (FuncValue->Val->FuncDef.Intrinsic == NULL)
{ /* run a user-defined function */ { /* run a user-defined function */
struct ParseState FuncParser = FuncValue->Val->FuncDef.Body; struct ParseState FuncParser = FuncValue->Val->FuncDef.Body;
for (Count = 0; Count < ParameterUsed; Count++)
VariableDefine(Parser, FuncValue->Val->FuncDef.ParamName[Count], Parameter[Count]);
if (!ParseStatement(&FuncParser)) if (!ParseStatement(&FuncParser))
ProgramFail(&FuncParser, "function body expected"); ProgramFail(&FuncParser, "function body expected");
if (FuncValue->Val->FuncDef.ReturnType != (*Result)->Typ) if (FuncValue->Val->FuncDef.ReturnType != (*Result)->Typ)
ProgramFail(&FuncParser, "bad type of return value"); ProgramFail(&FuncParser, "bad type of return value");
VariableStackFramePop(Parser);
} }
else else
{
FuncValue->Val->FuncDef.Intrinsic(); FuncValue->Val->FuncDef.Intrinsic();
HeapPopStackFrame();
} VariableStackFramePop(Parser);
} }
} }
/* parse a single value */ /* parse a single value */
int ParseValue(struct ParseState *Parser, struct Value **Result, int ResultOnHeap) int ParseValue(struct ParseState *Parser, struct Value **Result)
{ {
struct ParseState PreState = *Parser; struct ParseState PreState = *Parser;
struct Value *LexValue; struct Value *LexValue;
@ -104,14 +103,14 @@ int ParseValue(struct ParseState *Parser, struct Value **Result, int ResultOnHea
switch (Token) switch (Token)
{ {
case TokenIntegerConstant: case TokenCharacterConstant: case TokenFPConstant: case TokenStringConstant: case TokenIntegerConstant: case TokenCharacterConstant: case TokenFPConstant: case TokenStringConstant:
*Result = VariableAllocValueAndCopy(Parser, LexValue, ResultOnHeap); *Result = VariableAllocValueAndCopy(Parser, LexValue, FALSE);
break; break;
case TokenMinus: case TokenUnaryExor: case TokenUnaryNot: case TokenMinus: case TokenUnaryExor: case TokenUnaryNot:
IntValue = ParseIntExpression(Parser); IntValue = ParseIntExpression(Parser);
if (Parser->Mode == RunModeRun) if (Parser->Mode == RunModeRun)
{ {
*Result = VariableAllocValueFromType(Parser, &IntType, FALSE, ResultOnHeap); *Result = VariableAllocValueFromType(Parser, &IntType, FALSE);
switch(Token) switch(Token)
{ {
case TokenMinus: (*Result)->Val->Integer = -IntValue; break; case TokenMinus: (*Result)->Val->Integer = -IntValue; break;
@ -123,7 +122,7 @@ int ParseValue(struct ParseState *Parser, struct Value **Result, int ResultOnHea
break; break;
case TokenOpenBracket: case TokenOpenBracket:
if (!ParseExpression(Parser, Result, ResultOnHeap)) if (!ParseExpression(Parser, Result))
ProgramFail(Parser, "invalid expression"); ProgramFail(Parser, "invalid expression");
if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket) if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket)
@ -131,7 +130,7 @@ int ParseValue(struct ParseState *Parser, struct Value **Result, int ResultOnHea
break; break;
case TokenAsterisk: case TokenAsterisk:
if (!ParseExpression(Parser, Result, ResultOnHeap)) if (!ParseExpression(Parser, Result))
ProgramFail(Parser, "invalid expression"); ProgramFail(Parser, "invalid expression");
if ((*Result)->Typ->Base != TypePointer) if ((*Result)->Typ->Base != TypePointer)
@ -139,23 +138,23 @@ int ParseValue(struct ParseState *Parser, struct Value **Result, int ResultOnHea
LocalLValue = (*Result)->Val->Pointer.Segment; LocalLValue = (*Result)->Val->Pointer.Segment;
VariableStackPop(Parser, *Result); VariableStackPop(Parser, *Result);
*Result = VariableAllocValueShared(Parser, LocalLValue, ResultOnHeap); *Result = VariableAllocValueShared(Parser, LocalLValue);
break; break;
case TokenAmpersand: case TokenAmpersand:
if (!ParseValue(Parser, Result, ResultOnHeap) || !(*Result)->IsLValue) if (!ParseValue(Parser, Result) || !(*Result)->IsLValue)
ProgramFail(Parser, "can't get the address of this"); ProgramFail(Parser, "can't get the address of this");
VType = (*Result)->Typ; VType = (*Result)->Typ;
VariableStackPop(Parser, *Result); VariableStackPop(Parser, *Result);
*Result = VariableAllocValueFromType(Parser, TypeGetMatching(Parser, VType, TypePointer, 0, StrEmpty), FALSE, ResultOnHeap); *Result = VariableAllocValueFromType(Parser, TypeGetMatching(Parser, VType, TypePointer, 0, StrEmpty), FALSE);
(*Result)->Val->Pointer.Segment = LocalLValue; (*Result)->Val->Pointer.Segment = LocalLValue;
(*Result)->Val->Pointer.Data.Offset = 0; (*Result)->Val->Pointer.Data.Offset = 0;
break; break;
case TokenIdentifier: case TokenIdentifier:
if (LexGetToken(Parser, NULL, FALSE) == TokenOpenBracket) if (LexGetToken(Parser, NULL, FALSE) == TokenOpenBracket)
ParseFunctionCall(Parser, Result, ResultOnHeap, LexValue->Val->String); ParseFunctionCall(Parser, Result, LexValue->Val->String);
else else
{ {
if (Parser->Mode == RunModeRun) if (Parser->Mode == RunModeRun)
@ -165,14 +164,14 @@ int ParseValue(struct ParseState *Parser, struct Value **Result, int ResultOnHea
{ {
struct ParseState MacroLexer = LocalLValue->Val->Parser; struct ParseState MacroLexer = LocalLValue->Val->Parser;
if (!ParseExpression(&MacroLexer, Result, ResultOnHeap)) if (!ParseExpression(&MacroLexer, Result))
ProgramFail(&MacroLexer, "expression expected"); ProgramFail(&MacroLexer, "expression expected");
} }
else if (LocalLValue->Typ == TypeVoid) else if (LocalLValue->Typ == TypeVoid)
ProgramFail(Parser, "a void value isn't much use here"); ProgramFail(Parser, "a void value isn't much use here");
else else
{ /* it's a value variable */ { /* it's a value variable */
*Result = VariableAllocValueShared(Parser, LocalLValue, ResultOnHeap); *Result = VariableAllocValueShared(Parser, LocalLValue);
} }
} }
@ -208,7 +207,7 @@ int ParseValue(struct ParseState *Parser, struct Value **Result, int ResultOnHea
ProgramFail(Parser, "illegal array index"); ProgramFail(Parser, "illegal array index");
VariableStackPop(Parser, *Result); VariableStackPop(Parser, *Result);
*Result = VariableAllocValueFromExistingData(Parser, (*Result)->Typ->FromType, (union AnyValue *)((void *)(*Result)->Val + (*Result)->Typ->FromType->Sizeof * IntValue), TRUE, ResultOnHeap); *Result = VariableAllocValueFromExistingData(Parser, (*Result)->Typ->FromType, (union AnyValue *)((void *)(*Result)->Val + (*Result)->Typ->FromType->Sizeof * IntValue), TRUE);
} }
} }
} }
@ -223,27 +222,27 @@ int ParseValue(struct ParseState *Parser, struct Value **Result, int ResultOnHea
return Success; return Success;
} }
struct Value *ParsePushFP(struct ParseState *Parser, int ResultOnHeap, double NewFP) struct Value *ParsePushFP(struct ParseState *Parser, double NewFP)
{ {
struct Value *Val = VariableAllocValueFromType(Parser, &FPType, FALSE, ResultOnHeap); struct Value *Val = VariableAllocValueFromType(Parser, &FPType, FALSE);
Val->Val->FP = NewFP; Val->Val->FP = NewFP;
return Val; return Val;
} }
struct Value *ParsePushInt(struct ParseState *Parser, int ResultOnHeap, int NewInt) struct Value *ParsePushInt(struct ParseState *Parser, int NewInt)
{ {
struct Value *Val = VariableAllocValueFromType(Parser, &IntType, FALSE, ResultOnHeap); struct Value *Val = VariableAllocValueFromType(Parser, &IntType, FALSE);
Val->Val->Integer = NewInt; Val->Val->Integer = NewInt;
return Val; return Val;
} }
/* parse an expression. operator precedence is not supported */ /* parse an expression. operator precedence is not supported */
int ParseExpression(struct ParseState *Parser, struct Value **Result, int ResultOnHeap) int ParseExpression(struct ParseState *Parser, struct Value **Result)
{ {
struct Value *CurrentValue; struct Value *CurrentValue;
struct Value *TotalValue; struct Value *TotalValue;
if (!ParseValue(Parser, &TotalValue, ResultOnHeap)) if (!ParseValue(Parser, &TotalValue))
return FALSE; return FALSE;
while (TRUE) while (TRUE)
@ -278,13 +277,13 @@ int ParseExpression(struct ParseState *Parser, struct Value **Result, int Result
ProgramFail(Parser, "structure doesn't have a member called '%s'", Ident->Val->String); ProgramFail(Parser, "structure doesn't have a member called '%s'", Ident->Val->String);
VariableStackPop(Parser, TotalValue); VariableStackPop(Parser, TotalValue);
TotalValue = VariableAllocValueFromExistingData(Parser, CurrentValue->Typ, TotalValueData + CurrentValue->Val->Integer, TRUE, ResultOnHeap); TotalValue = VariableAllocValueFromExistingData(Parser, CurrentValue->Typ, TotalValueData + CurrentValue->Val->Integer, TRUE);
} }
continue; continue;
} }
case TokenAssign: case TokenAddAssign: case TokenSubtractAssign: case TokenAssign: case TokenAddAssign: case TokenSubtractAssign:
LexGetToken(Parser, NULL, TRUE); LexGetToken(Parser, NULL, TRUE);
if (!ParseExpression(Parser, &CurrentValue, ResultOnHeap)) if (!ParseExpression(Parser, &CurrentValue))
ProgramFail(Parser, "expression expected"); ProgramFail(Parser, "expression expected");
if (Parser->Mode == RunModeRun) if (Parser->Mode == RunModeRun)
@ -308,7 +307,7 @@ int ParseExpression(struct ParseState *Parser, struct Value **Result, int Result
return TRUE; return TRUE;
} }
if (!ParseValue(Parser, &CurrentValue, ResultOnHeap)) if (!ParseValue(Parser, &CurrentValue))
return FALSE; return FALSE;
if (Parser->Mode == RunModeRun) if (Parser->Mode == RunModeRun)
@ -351,7 +350,7 @@ int ParseExpression(struct ParseState *Parser, struct Value **Result, int Result
case TokenLogicalAnd: case TokenLogicalOr: case TokenAmpersand: case TokenArithmeticOr: case TokenArithmeticExor: ProgramFail(Parser, "bad type for operator"); break; case TokenLogicalAnd: case TokenLogicalOr: case TokenAmpersand: case TokenArithmeticOr: case TokenArithmeticExor: ProgramFail(Parser, "bad type for operator"); break;
default: break; default: break;
} }
TotalValue = ParsePushFP(Parser, ResultOnHeap, FPResult); TotalValue = ParsePushFP(Parser, FPResult);
} }
else else
{ /* integer expression */ { /* integer expression */
@ -384,7 +383,7 @@ int ParseExpression(struct ParseState *Parser, struct Value **Result, int Result
case TokenArithmeticExor: IntResult = IntX ^ IntY; break; case TokenArithmeticExor: IntResult = IntX ^ IntY; break;
default: break; default: break;
} }
TotalValue = ParsePushInt(Parser, ResultOnHeap, IntResult); TotalValue = ParsePushInt(Parser, IntResult);
} }
*Result = TotalValue; *Result = TotalValue;
@ -400,7 +399,7 @@ int ParseIntExpression(struct ParseState *Parser)
struct Value *Val; struct Value *Val;
int Result = 0; int Result = 0;
if (!ParseExpression(Parser, &Val, FALSE)) if (!ParseExpression(Parser, &Val))
ProgramFail(Parser, "expression expected"); ProgramFail(Parser, "expression expected");
if (Parser->Mode == RunModeRun) if (Parser->Mode == RunModeRun)
@ -618,7 +617,7 @@ int ParseStatement(struct ParseState *Parser)
case TokenIdentifier: case TokenIdentifier:
*Parser = PreState; *Parser = PreState;
ParseExpression(Parser, &CValue, FALSE); ParseExpression(Parser, &CValue);
if (Parser->Mode == RunModeRun) if (Parser->Mode == RunModeRun)
VariableStackPop(Parser, CValue); VariableStackPop(Parser, CValue);
break; break;
@ -716,7 +715,7 @@ int ParseStatement(struct ParseState *Parser)
if (LexGetToken(Parser, NULL, FALSE) == TokenOpenBracket) if (LexGetToken(Parser, NULL, FALSE) == TokenOpenBracket)
ParseFunctionDefinition(Parser, Typ, Identifier, FALSE); ParseFunctionDefinition(Parser, Typ, Identifier, FALSE);
else else
VariableDefine(Parser, Identifier, VariableAllocValueFromType(Parser, Typ, TRUE, FALSE)); VariableDefine(Parser, Identifier, VariableAllocValueFromType(Parser, Typ, TRUE));
} }
break; break;

16
picoc.h
View file

@ -197,6 +197,9 @@ struct Table
struct StackFrame struct StackFrame
{ {
struct ParseState ReturnParser; /* how we got here */ struct ParseState ReturnParser; /* how we got here */
struct Value *ReturnValue; /* copy the return value here */
struct Value **Parameter; /* array of parameter values */
int NumParams; /* the number of parameters */
struct Table LocalTable; /* the local variables and parameters */ struct Table LocalTable; /* the local variables and parameters */
struct TableEntry *LocalHashTable[LOCAL_TABLE_SIZE]; struct TableEntry *LocalHashTable[LOCAL_TABLE_SIZE];
struct StackFrame *PreviousStackFrame; /* the next lower stack frame */ struct StackFrame *PreviousStackFrame; /* the next lower stack frame */
@ -204,10 +207,7 @@ struct StackFrame
/* globals */ /* globals */
extern struct Table GlobalTable; extern struct Table GlobalTable;
extern struct Value *Parameter[PARAMETER_MAX];
extern int ParameterUsed;
extern struct StackFrame *TopStackFrame; extern struct StackFrame *TopStackFrame;
extern struct Value *ReturnValue;
extern struct ValueType IntType; extern struct ValueType IntType;
extern struct ValueType CharType; extern struct ValueType CharType;
extern struct ValueType StringType; extern struct ValueType StringType;
@ -235,7 +235,7 @@ enum LexToken LexGetToken(struct ParseState *Parser, struct Value **Value, int I
/* parse.c */ /* parse.c */
void ParseInit(void); void ParseInit(void);
int ParseExpression(struct ParseState *Parser, struct Value **Result, int ResultOnHeap); int ParseExpression(struct ParseState *Parser, struct Value **Result);
int ParseIntExpression(struct ParseState *Parser); int ParseIntExpression(struct ParseState *Parser);
int ParseStatement(struct ParseState *Parser); int ParseStatement(struct ParseState *Parser);
struct Value *ParseFunctionDefinition(struct ParseState *Parser, struct ValueType *ReturnType, const char *Identifier, int IsProtoType); struct Value *ParseFunctionDefinition(struct ParseState *Parser, struct ValueType *ReturnType, const char *Identifier, int IsProtoType);
@ -266,13 +266,13 @@ void *VariableAlloc(struct ParseState *Parser, int Size, int OnHeap);
void VariableStackPop(struct ParseState *Parser, struct Value *Var); void VariableStackPop(struct ParseState *Parser, struct Value *Var);
struct Value *VariableAllocValueAndData(struct ParseState *Parser, int DataSize, int IsLValue, int OnHeap); struct Value *VariableAllocValueAndData(struct ParseState *Parser, int DataSize, int IsLValue, int OnHeap);
struct Value *VariableAllocValueAndCopy(struct ParseState *Parser, struct Value *FromValue, int OnHeap); struct Value *VariableAllocValueAndCopy(struct ParseState *Parser, struct Value *FromValue, int OnHeap);
struct Value *VariableAllocValueFromType(struct ParseState *Parser, struct ValueType *Typ, int IsLValue, int OnHeap); struct Value *VariableAllocValueFromType(struct ParseState *Parser, struct ValueType *Typ, int IsLValue);
struct Value *VariableAllocValueFromExistingData(struct ParseState *Parser, struct ValueType *Typ, union AnyValue *FromValue, int IsLValue, int OnHeap); struct Value *VariableAllocValueFromExistingData(struct ParseState *Parser, struct ValueType *Typ, union AnyValue *FromValue, int IsLValue);
struct Value *VariableAllocValueShared(struct ParseState *Parser, struct Value *FromValue, int OnHeap); struct Value *VariableAllocValueShared(struct ParseState *Parser, struct Value *FromValue);
void VariableDefine(struct ParseState *Parser, const char *Ident, struct Value *InitValue); void VariableDefine(struct ParseState *Parser, const char *Ident, struct Value *InitValue);
int VariableDefined(const char *Ident); int VariableDefined(const char *Ident);
void VariableGet(struct ParseState *Parser, const char *Ident, struct Value **LVal); void VariableGet(struct ParseState *Parser, const char *Ident, struct Value **LVal);
void VariableStackFrameAdd(struct ParseState *Parser); void VariableStackFrameAdd(struct ParseState *Parser, int NumParams);
void VariableStackFramePop(struct ParseState *Parser); void VariableStackFramePop(struct ParseState *Parser);
/* str.c */ /* str.c */

17
variable.c
View file

@ -54,9 +54,9 @@ struct Value *VariableAllocValueAndData(struct ParseState *Parser, int DataSize,
} }
/* allocate a value given its type */ /* allocate a value given its type */
struct Value *VariableAllocValueFromType(struct ParseState *Parser, struct ValueType *Typ, int IsLValue, int OnHeap) struct Value *VariableAllocValueFromType(struct ParseState *Parser, struct ValueType *Typ, int IsLValue)
{ {
struct Value *NewValue = VariableAllocValueAndData(Parser, Typ->Sizeof, IsLValue, OnHeap); struct Value *NewValue = VariableAllocValueAndData(Parser, Typ->Sizeof, IsLValue, FALSE);
NewValue->Typ = Typ; NewValue->Typ = Typ;
return NewValue; return NewValue;
} }
@ -71,9 +71,9 @@ struct Value *VariableAllocValueAndCopy(struct ParseState *Parser, struct Value
} }
/* allocate a value either on the heap or the stack from an existing AnyValue and type */ /* allocate a value either on the heap or the stack from an existing AnyValue and type */
struct Value *VariableAllocValueFromExistingData(struct ParseState *Parser, struct ValueType *Typ, union AnyValue *FromValue, int IsLValue, int OnHeap) struct Value *VariableAllocValueFromExistingData(struct ParseState *Parser, struct ValueType *Typ, union AnyValue *FromValue, int IsLValue)
{ {
struct Value *NewValue = VariableAlloc(Parser, sizeof(struct Value), OnHeap); struct Value *NewValue = VariableAlloc(Parser, sizeof(struct Value), FALSE);
NewValue->Typ = Typ; NewValue->Typ = Typ;
NewValue->Val = FromValue; NewValue->Val = FromValue;
NewValue->ValOnHeap = FALSE; NewValue->ValOnHeap = FALSE;
@ -84,9 +84,9 @@ struct Value *VariableAllocValueFromExistingData(struct ParseState *Parser, stru
} }
/* allocate a value either on the heap or the stack from an existing Value, sharing the value */ /* allocate a value either on the heap or the stack from an existing Value, sharing the value */
struct Value *VariableAllocValueShared(struct ParseState *Parser, struct Value *FromValue, int OnHeap) struct Value *VariableAllocValueShared(struct ParseState *Parser, struct Value *FromValue)
{ {
return VariableAllocValueFromExistingData(Parser, FromValue->Typ, FromValue->Val, FromValue->IsLValue, OnHeap); return VariableAllocValueFromExistingData(Parser, FromValue->Typ, FromValue->Val, FromValue->IsLValue);
} }
/* define a variable */ /* define a variable */
@ -145,13 +145,14 @@ void VariableStackPop(struct ParseState *Parser, struct Value *Var)
} }
/* add a stack frame when doing a function call */ /* add a stack frame when doing a function call */
void VariableStackFrameAdd(struct ParseState *Parser) void VariableStackFrameAdd(struct ParseState *Parser, int NumParams)
{ {
struct StackFrame *NewFrame; struct StackFrame *NewFrame;
HeapPushStackFrame(); HeapPushStackFrame();
NewFrame = HeapAllocStack(sizeof(struct StackFrame)); NewFrame = HeapAllocStack(sizeof(struct StackFrame) + sizeof(struct Value *) * NumParams);
NewFrame->ReturnParser = *Parser; NewFrame->ReturnParser = *Parser;
NewFrame->Parameter = (NumParams > 0) ? ((void *)NewFrame + sizeof(struct StackFrame)) : NULL;
TableInit(&NewFrame->LocalTable, &NewFrame->LocalHashTable[0], LOCAL_TABLE_SIZE, FALSE); TableInit(&NewFrame->LocalTable, &NewFrame->LocalHashTable[0], LOCAL_TABLE_SIZE, FALSE);
NewFrame->PreviousStackFrame = TopStackFrame; NewFrame->PreviousStackFrame = TopStackFrame;
TopStackFrame = NewFrame; TopStackFrame = NewFrame;