d04337125e
Effectively just ignores any declarations as global scope is shared across files in PicoC anyway, so the ultimate definition should be enough.
742 lines
28 KiB
C
742 lines
28 KiB
C
/* picoc main header file - this has all the main data structures and
|
|
* function prototypes. If you're just calling picoc you should look at the
|
|
* external interface instead, in picoc.h */
|
|
#ifndef INTERPRETER_H
|
|
#define INTERPRETER_H
|
|
|
|
#include "platform.h"
|
|
|
|
#ifndef NULL
|
|
#define NULL 0
|
|
#endif
|
|
|
|
/*
|
|
#ifndef min
|
|
#define min(x,y) (((x)<(y))?(x):(y))
|
|
#endif
|
|
#ifndef min
|
|
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
|
#endif
|
|
*/
|
|
/* Get the name of a type */
|
|
// #define typename(x) _Generic((x), \
|
|
// _Bool: "_Bool", \
|
|
// unsigned char: "unsigned char", \
|
|
// char: "char", \
|
|
// signed char: "signed char", \
|
|
// short int: "short int", \
|
|
// unsigned short int: "unsigned short int", \
|
|
// int: "int", \
|
|
// unsigned int: "unsigned int", \
|
|
// long int: "long int", \
|
|
// unsigned long int: "unsigned long int", \
|
|
// long long int: "long long int", \
|
|
// unsigned long long int: "unsigned long long int", \
|
|
// float: "float", \
|
|
// double: "double", \
|
|
// long double: "long double", \
|
|
// char *: "pointer to char", \
|
|
// void *: "pointer to void", \
|
|
// int *: "pointer to int", \
|
|
// default: "other") (x)
|
|
|
|
|
|
#define MEM_ALIGN(x) (((x) + sizeof(ALIGN_TYPE)-1) & ~(sizeof(ALIGN_TYPE)-1))
|
|
|
|
/* for debugging */
|
|
#define PRINT_SOURCE_POS() { \
|
|
PrintSourceTextErrorLine(Parser->pc->CStdOut, \
|
|
Parser->FileName, \
|
|
Parser->SourceText, \
|
|
Parser->Line, \
|
|
Parser->CharacterPos); \
|
|
PlatformPrintf(Parser->pc->CStdOut, "\n"); \
|
|
}
|
|
|
|
#define PRINT_TYPE(typ) PlatformPrintf(Parser->pc->CStdOut, "%t\n", typ);
|
|
|
|
typedef FILE IOFILE;
|
|
|
|
/* coercion of numeric types to other numeric types */
|
|
#define IS_FP(v) ((v)->Typ->Base == TypeFP)
|
|
#define FP_VAL(v) ((v)->Val->FP)
|
|
|
|
/* ap -> AllowPointerCoercion = true | false */
|
|
#define IS_POINTER_COERCIBLE(v, ap) ((ap) ? ((v)->Typ->Base == TypePointer) : 0)
|
|
#define POINTER_COERCE(v) ((int)(v)->Val->Pointer)
|
|
|
|
#define IS_INTEGER_NUMERIC_TYPE(t) ((t)->Base >= TypeInt && (t)->Base <= TypeUnsignedLong)
|
|
#define IS_INTEGER_NUMERIC(v) IS_INTEGER_NUMERIC_TYPE((v)->Typ)
|
|
#define IS_NUMERIC_COERCIBLE(v) (IS_INTEGER_NUMERIC(v) || IS_FP(v))
|
|
#define IS_NUMERIC_COERCIBLE_PLUS_POINTERS(v,ap) (IS_NUMERIC_COERCIBLE(v) || IS_POINTER_COERCIBLE(v,ap))
|
|
|
|
|
|
struct Table;
|
|
struct Picoc_Struct;
|
|
|
|
typedef struct Picoc_Struct Picoc;
|
|
|
|
/* lexical tokens */
|
|
enum LexToken {
|
|
/* 0x00 */ TokenNone,
|
|
/* 0x01 */ TokenComma,
|
|
/* 0x02 */ TokenAssign,
|
|
TokenAddAssign,
|
|
TokenSubtractAssign,
|
|
TokenMultiplyAssign,
|
|
TokenDivideAssign,
|
|
TokenModulusAssign,
|
|
/* 0x08 */ TokenShiftLeftAssign,
|
|
TokenShiftRightAssign,
|
|
TokenArithmeticAndAssign,
|
|
TokenArithmeticOrAssign,
|
|
TokenArithmeticExorAssign,
|
|
/* 0x0d */ TokenQuestionMark,
|
|
TokenColon,
|
|
/* 0x0f */ TokenLogicalOr,
|
|
/* 0x10 */ TokenLogicalAnd,
|
|
/* 0x11 */ TokenArithmeticOr,
|
|
/* 0x12 */ TokenArithmeticExor,
|
|
/* 0x13 */ TokenAmpersand,
|
|
/* 0x14 */ TokenEqual,
|
|
TokenNotEqual,
|
|
/* 0x16 */ TokenLessThan,
|
|
TokenGreaterThan,
|
|
TokenLessEqual,
|
|
TokenGreaterEqual,
|
|
/* 0x1a */ TokenShiftLeft,
|
|
TokenShiftRight,
|
|
/* 0x1c */ TokenPlus,
|
|
TokenMinus,
|
|
/* 0x1e */ TokenAsterisk,
|
|
TokenSlash,
|
|
TokenModulus,
|
|
/* 0x21 */ TokenIncrement,
|
|
TokenDecrement,
|
|
TokenUnaryNot,
|
|
TokenUnaryExor,
|
|
TokenSizeof,
|
|
TokenCast,
|
|
/* 0x27 */ TokenLeftSquareBracket,
|
|
TokenRightSquareBracket,
|
|
TokenDot,
|
|
TokenArrow,
|
|
/* 0x2b */ TokenOpenBracket,
|
|
TokenCloseBracket,
|
|
/* 0x2d */ TokenIdentifier,
|
|
TokenIntegerConstant,
|
|
TokenFPConstant,
|
|
TokenStringConstant,
|
|
TokenCharacterConstant,
|
|
/* 0x32 */ TokenSemicolon,
|
|
TokenEllipsis,
|
|
/* 0x34 */ TokenLeftBrace,
|
|
TokenRightBrace,
|
|
/* 0x36 */ TokenIntType,
|
|
TokenCharType,
|
|
TokenFloatType,
|
|
TokenDoubleType,
|
|
TokenVoidType,
|
|
TokenEnumType,
|
|
/* 0x3c */ TokenLongType,
|
|
TokenSignedType,
|
|
TokenShortType,
|
|
TokenStaticType,
|
|
TokenAutoType,
|
|
TokenRegisterType,
|
|
TokenExternType,
|
|
TokenStructType,
|
|
TokenUnionType,
|
|
TokenUnsignedType,
|
|
TokenTypedef,
|
|
/* 0x46 */ TokenContinue,
|
|
TokenDo,
|
|
TokenElse,
|
|
TokenFor,
|
|
TokenGoto,
|
|
TokenIf,
|
|
TokenWhile,
|
|
TokenBreak,
|
|
TokenSwitch,
|
|
TokenCase,
|
|
TokenDefault,
|
|
TokenReturn,
|
|
/* 0x52 */ TokenHashDefine,
|
|
TokenHashInclude,
|
|
TokenHashIf,
|
|
TokenHashIfdef,
|
|
TokenHashIfndef,
|
|
TokenHashElse,
|
|
TokenHashEndif,
|
|
/* 0x59 */ TokenNew,
|
|
TokenDelete,
|
|
/* 0x5b */ TokenOpenMacroBracket,
|
|
/* 0x5c */ TokenEOF,
|
|
TokenEndOfLine,
|
|
TokenEndOfFunction,
|
|
TokenBackSlash,
|
|
TokenVolatileType,
|
|
TokenHashPragma,
|
|
TokenUnderscorePragma,
|
|
TokenConstType
|
|
};
|
|
|
|
/* used in dynamic memory allocation */
|
|
struct AllocNode {
|
|
unsigned int Size;
|
|
struct AllocNode *NextFree;
|
|
};
|
|
|
|
/* whether we're running or skipping code */
|
|
enum RunMode {
|
|
RunModeRun, /* we're running code as we parse it */
|
|
RunModeSkip, /* skipping code, not running */
|
|
RunModeReturn, /* returning from a function */
|
|
RunModeCaseSearch, /* searching for a case label */
|
|
RunModeBreak, /* breaking out of a switch/while/do */
|
|
RunModeContinue, /* as above but repeat the loop */
|
|
RunModeGoto /* searching for a goto label */
|
|
};
|
|
|
|
/* parser state - has all this detail so we can parse nested files */
|
|
struct ParseState {
|
|
Picoc *pc; /* the picoc instance this parser is a part of */
|
|
const unsigned char *Pos; /* the character position in the source text */
|
|
char *FileName; /* what file we're executing (registered string) */
|
|
short int Line; /* line number we're executing */
|
|
short int CharacterPos; /* character/column in the line we're executing */
|
|
enum RunMode Mode; /* whether to skip or run code */
|
|
int SearchLabel; /* what case label we're searching for */
|
|
const char *SearchGotoLabel;/* what goto label we're searching for */
|
|
const char *SourceText; /* the entire source text */
|
|
short int HashIfLevel; /* how many "if"s we're nested down */
|
|
short int HashIfEvaluateToLevel; /* if we're not evaluating an if branch,
|
|
what the last evaluated level was */
|
|
char DebugMode; /* debugging mode */
|
|
int ScopeID; /* for keeping track of local variables (free them after t
|
|
hey go out of scope) */
|
|
};
|
|
|
|
/* values */
|
|
enum BaseType {
|
|
TypeVoid, /* no type */
|
|
TypeInt, /* integer */
|
|
TypeShort, /* short integer */
|
|
TypeChar, /* a single character (signed) */
|
|
TypeLong, /* long integer */
|
|
TypeUnsignedInt, /* unsigned integer */
|
|
TypeUnsignedShort, /* unsigned short integer */
|
|
TypeUnsignedChar, /* unsigned 8-bit number */ /* must be before unsigned long */
|
|
TypeUnsignedLong, /* unsigned long integer */
|
|
TypeFP, /* floating point */
|
|
TypeFunction, /* a function */
|
|
TypeMacro, /* a macro */
|
|
TypePointer, /* a pointer */
|
|
TypeArray, /* an array of a sub-type */
|
|
TypeStruct, /* aggregate type */
|
|
TypeUnion, /* merged type */
|
|
TypeEnum, /* enumerated integer type */
|
|
TypeGotoLabel, /* a label we can "goto" */
|
|
Type_Type /* a type for storing types */
|
|
};
|
|
|
|
/* data type */
|
|
struct ValueType {
|
|
enum BaseType Base; /* what kind of type this is */
|
|
int ArraySize; /* the size of an array type */
|
|
int Sizeof; /* the storage required */
|
|
int AlignBytes; /* the alignment boundary of this type */
|
|
const char *Identifier; /* the name of a struct or union */
|
|
struct ValueType *FromType; /* the type we're derived from (or NULL) */
|
|
struct ValueType *DerivedTypeList; /* first in a list of types derived from this one */
|
|
struct ValueType *Next; /* next item in the derived type list */
|
|
struct Table *Members; /* members of a struct or union */
|
|
int OnHeap; /* true if allocated on the heap */
|
|
int StaticQualifier; /* true if it's a static */
|
|
};
|
|
|
|
/* function definition */
|
|
struct FuncDef {
|
|
struct ValueType *ReturnType; /* the return value type */
|
|
int NumParams; /* the number of parameters */
|
|
int VarArgs; /* has a variable number of arguments after
|
|
the explicitly specified ones */
|
|
struct ValueType **ParamType; /* array of parameter types */
|
|
char **ParamName; /* array of parameter names */
|
|
void (*Intrinsic)(); /* intrinsic call address or NULL */
|
|
struct ParseState Body; /* lexical tokens of the function body if
|
|
not intrinsic */
|
|
};
|
|
|
|
/* macro definition */
|
|
struct MacroDef {
|
|
int NumParams; /* the number of parameters */
|
|
char **ParamName; /* array of parameter names */
|
|
struct ParseState Body; /* lexical tokens of the function body
|
|
if not intrinsic */
|
|
};
|
|
|
|
/* values */
|
|
union AnyValue {
|
|
char Character;
|
|
short ShortInteger;
|
|
int Integer;
|
|
long LongInteger;
|
|
unsigned short UnsignedShortInteger;
|
|
unsigned int UnsignedInteger;
|
|
unsigned long UnsignedLongInteger;
|
|
unsigned char UnsignedCharacter;
|
|
char *Identifier;
|
|
char ArrayMem[2]; /* placeholder for where the data starts,
|
|
doesn't point to it */
|
|
struct ValueType *Typ;
|
|
struct FuncDef FuncDef;
|
|
struct MacroDef MacroDef;
|
|
double FP;
|
|
void *Pointer; /* unsafe native pointers */
|
|
};
|
|
|
|
struct Value {
|
|
struct ValueType *Typ; /* the type of this value */
|
|
union AnyValue *Val; /* pointer to the AnyValue which holds the actual content */
|
|
struct Value *LValueFrom; /* if an LValue, this is a Value our LValue is contained within (or NULL) */
|
|
char ValOnHeap; /* this Value is on the heap */
|
|
char ValOnStack; /* the AnyValue is on the stack along with this Value */
|
|
char AnyValOnHeap; /* the AnyValue is separately allocated from the Value on the heap */
|
|
char IsLValue; /* is modifiable and is allocated somewhere we can usefully modify it */
|
|
int ScopeID; /* to know when it goes out of scope */
|
|
char OutOfScope;
|
|
};
|
|
|
|
/* hash table data structure */
|
|
struct TableEntry {
|
|
struct TableEntry *Next; /* next item in this hash chain */
|
|
const char *DeclFileName; /* where the variable was declared */
|
|
unsigned short DeclLine;
|
|
unsigned short DeclColumn;
|
|
|
|
union TableEntryPayload {
|
|
struct ValueEntry {
|
|
char *Key; /* points to the shared string table */
|
|
struct Value *Val; /* the value we're storing */
|
|
} v; /* used for tables of values */
|
|
|
|
char Key[1]; /* dummy size - used for the shared string table */
|
|
|
|
/* defines a breakpoint */
|
|
struct BreakpointEntry {
|
|
const char *FileName;
|
|
short int Line;
|
|
short int CharacterPos;
|
|
} b;
|
|
|
|
} p;
|
|
};
|
|
|
|
struct Table {
|
|
short Size;
|
|
short OnHeap;
|
|
struct TableEntry **HashTable;
|
|
};
|
|
|
|
/* stack frame for function calls */
|
|
struct StackFrame {
|
|
struct ParseState ReturnParser; /* how we got here */
|
|
const char *FuncName; /* the name of the function we're in */
|
|
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 TableEntry *LocalHashTable[LOCAL_TABLE_SIZE];
|
|
struct StackFrame *PreviousStackFrame; /* the next lower stack frame */
|
|
};
|
|
|
|
/* lexer state */
|
|
enum LexMode {
|
|
LexModeNormal,
|
|
LexModeHashInclude,
|
|
LexModeHashDefine,
|
|
LexModeHashDefineSpace,
|
|
LexModeHashDefineSpaceIdent
|
|
};
|
|
|
|
struct LexState {
|
|
const char *Pos;
|
|
const char *End;
|
|
const char *FileName;
|
|
int Line;
|
|
int CharacterPos;
|
|
const char *SourceText;
|
|
enum LexMode Mode;
|
|
int EmitExtraNewlines;
|
|
};
|
|
|
|
/* library function definition */
|
|
struct LibraryFunction {
|
|
void (*Func)(struct ParseState *Parser, struct Value *, struct Value **, int);
|
|
const char *Prototype;
|
|
};
|
|
|
|
/* output stream-type specific state information */
|
|
union OutputStreamInfo {
|
|
struct StringOutputStream {
|
|
struct ParseState *Parser;
|
|
char *WritePos;
|
|
} Str;
|
|
};
|
|
|
|
/* stream-specific method for writing characters to the console */
|
|
typedef void CharWriter(unsigned char, union OutputStreamInfo *);
|
|
|
|
/* used when writing output to a string - eg. sprintf() */
|
|
struct OutputStream {
|
|
CharWriter *Putch;
|
|
union OutputStreamInfo i;
|
|
};
|
|
|
|
/* possible results of parsing a statement */
|
|
enum ParseResult { ParseResultEOF, ParseResultError, ParseResultOk };
|
|
|
|
/* a chunk of heap-allocated tokens we'll cleanup when we're done */
|
|
struct CleanupTokenNode {
|
|
void *Tokens;
|
|
const char *SourceText;
|
|
struct CleanupTokenNode *Next;
|
|
};
|
|
|
|
/* linked list of lexical tokens used in interactive mode */
|
|
struct TokenLine {
|
|
struct TokenLine *Next;
|
|
unsigned char *Tokens;
|
|
int NumBytes;
|
|
};
|
|
|
|
|
|
/* a list of libraries we can include */
|
|
struct IncludeLibrary {
|
|
char *IncludeName;
|
|
void (*SetupFunction)(Picoc *pc);
|
|
struct LibraryFunction *FuncList;
|
|
const char *SetupCSource;
|
|
struct IncludeLibrary *NextLib;
|
|
};
|
|
|
|
#define FREELIST_BUCKETS (8) /* freelists for 4, 8, 12 ... 32 byte allocs */
|
|
#define SPLIT_MEM_THRESHOLD (16) /* don't split memory which is close in size */
|
|
#define BREAKPOINT_TABLE_SIZE (21)
|
|
|
|
|
|
/* the entire state of the picoc system */
|
|
struct Picoc_Struct {
|
|
/* parser global data */
|
|
struct Table GlobalTable;
|
|
struct CleanupTokenNode *CleanupTokenList;
|
|
struct TableEntry *GlobalHashTable[GLOBAL_TABLE_SIZE];
|
|
|
|
/* lexer global data */
|
|
struct TokenLine *InteractiveHead;
|
|
struct TokenLine *InteractiveTail;
|
|
struct TokenLine *InteractiveCurrentLine;
|
|
int LexUseStatementPrompt;
|
|
union AnyValue LexAnyValue;
|
|
struct Value LexValue;
|
|
struct Table ReservedWordTable;
|
|
struct TableEntry *ReservedWordHashTable[RESERVED_WORD_TABLE_SIZE];
|
|
|
|
/* the table of string literal values */
|
|
struct Table StringLiteralTable;
|
|
struct TableEntry *StringLiteralHashTable[STRING_LITERAL_TABLE_SIZE];
|
|
|
|
/* the stack */
|
|
struct StackFrame *TopStackFrame;
|
|
|
|
/* the value passed to exit() */
|
|
int PicocExitValue;
|
|
|
|
/* a list of libraries we can include */
|
|
struct IncludeLibrary *IncludeLibList;
|
|
|
|
/* heap memory */
|
|
unsigned char *HeapMemory; /* stack memory since our heap is malloc()ed */
|
|
void *HeapBottom; /* the bottom of the (downward-growing) heap */
|
|
void *StackFrame; /* the current stack frame */
|
|
void *HeapStackTop; /* the top of the stack */
|
|
|
|
struct AllocNode *FreeListBucket[FREELIST_BUCKETS]; /* we keep a pool of freelist buckets to reduce fragmentation */
|
|
struct AllocNode *FreeListBig; /* free memory which doesn't fit in a bucket */
|
|
|
|
/* types */
|
|
struct ValueType UberType;
|
|
struct ValueType IntType;
|
|
struct ValueType ShortType;
|
|
struct ValueType CharType;
|
|
struct ValueType LongType;
|
|
struct ValueType UnsignedIntType;
|
|
struct ValueType UnsignedShortType;
|
|
struct ValueType UnsignedLongType;
|
|
struct ValueType UnsignedCharType;
|
|
struct ValueType FPType;
|
|
struct ValueType VoidType;
|
|
struct ValueType TypeType;
|
|
struct ValueType FunctionType;
|
|
struct ValueType MacroType;
|
|
struct ValueType EnumType;
|
|
struct ValueType GotoLabelType;
|
|
struct ValueType *CharPtrType;
|
|
struct ValueType *CharPtrPtrType;
|
|
struct ValueType *CharArrayType;
|
|
struct ValueType *VoidPtrType;
|
|
|
|
/* debugger */
|
|
struct Table BreakpointTable;
|
|
struct TableEntry *BreakpointHashTable[BREAKPOINT_TABLE_SIZE];
|
|
int BreakpointCount;
|
|
int DebugManualBreak;
|
|
|
|
/* C library */
|
|
int BigEndian;
|
|
int LittleEndian;
|
|
|
|
IOFILE *CStdOut;
|
|
IOFILE CStdOutBase;
|
|
|
|
/* the picoc version string */
|
|
const char *VersionString;
|
|
|
|
/* exit longjump buffer */
|
|
#if defined(UNIX_HOST) || defined(WIN32)
|
|
jmp_buf PicocExitBuf;
|
|
#endif
|
|
|
|
/* string table */
|
|
struct Table StringTable;
|
|
struct TableEntry *StringHashTable[STRING_TABLE_SIZE];
|
|
char *StrEmpty;
|
|
};
|
|
|
|
/* table.c */
|
|
extern void TableInit(Picoc *pc);
|
|
extern char *TableStrRegister(Picoc *pc, const char *Str);
|
|
extern char *TableStrRegister2(Picoc *pc, const char *Str, int Len);
|
|
extern void TableInitTable(struct Table *Tbl, struct TableEntry **HashTable,
|
|
int Size, int OnHeap);
|
|
extern int TableSet(Picoc *pc, struct Table *Tbl, char *Key, struct Value *Val,
|
|
const char *DeclFileName, int DeclLine, int DeclColumn);
|
|
extern int TableGet(struct Table *Tbl, const char *Key, struct Value **Val,
|
|
const char **DeclFileName, int *DeclLine, int *DeclColumn);
|
|
extern struct Value *TableDelete(Picoc *pc, struct Table *Tbl, const char *Key);
|
|
extern char *TableSetIdentifier(Picoc *pc, struct Table *Tbl, const char *Ident,
|
|
int IdentLen);
|
|
extern void TableStrFree(Picoc *pc);
|
|
|
|
/* lex.c */
|
|
extern void LexInit(Picoc *pc);
|
|
extern void LexCleanup(Picoc *pc);
|
|
extern void *LexAnalyse(Picoc *pc, const char *FileName, const char *Source,
|
|
int SourceLen, int *TokenLen);
|
|
extern void LexInitParser(struct ParseState *Parser, Picoc *pc,
|
|
const char *SourceText, void *TokenSource, char *FileName, int RunIt, int SetDebugMode);
|
|
extern enum LexToken LexGetToken(struct ParseState *Parser, struct Value **Value,
|
|
int IncPos);
|
|
extern enum LexToken LexRawPeekToken(struct ParseState *Parser);
|
|
extern void LexToEndOfMacro(struct ParseState *Parser);
|
|
extern void *LexCopyTokens(struct ParseState *StartParser, struct ParseState *EndParser);
|
|
extern void LexInteractiveClear(Picoc *pc, struct ParseState *Parser);
|
|
extern void LexInteractiveCompleted(Picoc *pc, struct ParseState *Parser);
|
|
extern void LexInteractiveStatementPrompt(Picoc *pc);
|
|
|
|
/* parse.c */
|
|
/* the following are defined in picoc.h:
|
|
* void PicocParse(const char *FileName, const char *Source, int SourceLen, int RunIt, int CleanupNow, int CleanupSource);
|
|
* void PicocParseInteractive(); */
|
|
extern void PicocParseInteractiveNoStartPrompt(Picoc *pc, int EnableDebugger);
|
|
extern enum ParseResult ParseStatement(struct ParseState *Parser,
|
|
int CheckTrailingSemicolon);
|
|
extern struct Value *ParseFunctionDefinition(struct ParseState *Parser,
|
|
struct ValueType *ReturnType, char *Identifier);
|
|
extern void ParseCleanup(Picoc *pc);
|
|
extern void ParserCopyPos(struct ParseState *To, struct ParseState *From);
|
|
extern void ParserCopy(struct ParseState *To, struct ParseState *From);
|
|
|
|
/* expression.c */
|
|
extern int ExpressionParse(struct ParseState *Parser, struct Value **Result);
|
|
extern long ExpressionParseInt(struct ParseState *Parser);
|
|
extern void ExpressionAssign(struct ParseState *Parser, struct Value *DestValue,
|
|
struct Value *SourceValue, int Force, const char *FuncName, int ParamNo, int AllowPointerCoercion);
|
|
extern long ExpressionCoerceInteger(struct Value *Val);
|
|
extern unsigned long ExpressionCoerceUnsignedInteger(struct Value *Val);
|
|
extern double ExpressionCoerceFP(struct Value *Val);
|
|
|
|
/* type.c */
|
|
extern void TypeInit(Picoc *pc);
|
|
extern void TypeCleanup(Picoc *pc);
|
|
extern int TypeSize(struct ValueType *Typ, int ArraySize, int Compact);
|
|
extern int TypeSizeValue(struct Value *Val, int Compact);
|
|
extern int TypeStackSizeValue(struct Value *Val);
|
|
extern int TypeLastAccessibleOffset(Picoc *pc, struct Value *Val);
|
|
extern int TypeParseFront(struct ParseState *Parser, struct ValueType **Typ,
|
|
int *IsStatic, int *IsExtern, int *IsVolatile);
|
|
extern void TypeParseIdentPart(struct ParseState *Parser,
|
|
struct ValueType *BasicTyp, struct ValueType **Typ, char **Identifier);
|
|
extern void TypeParse(struct ParseState *Parser, struct ValueType **Typ,
|
|
char **Identifier, int *IsStatic, int *IsExtern, int *IsVolatile);
|
|
extern struct ValueType *TypeGetMatching(Picoc *pc, struct ParseState *Parser,
|
|
struct ValueType *ParentType, enum BaseType Base, int ArraySize, const char *Identifier, int AllowDuplicates);
|
|
extern struct ValueType *TypeCreateOpaqueStruct(Picoc *pc, struct ParseState *Parser,
|
|
const char *StructName, int Size);
|
|
extern int TypeIsForwardDeclared(struct ParseState *Parser, struct ValueType *Typ);
|
|
|
|
/* heap.c */
|
|
#ifdef DEBUG_HEAP
|
|
extern void ShowBigList(Picoc *pc);
|
|
#endif
|
|
extern void HeapInit(Picoc *pc, int StackSize);
|
|
extern void HeapCleanup(Picoc *pc);
|
|
extern void *HeapAllocStack(Picoc *pc, int Size);
|
|
extern int HeapPopStack(Picoc *pc, void *Addr, int Size);
|
|
extern void HeapUnpopStack(Picoc *pc, int Size);
|
|
extern void HeapPushStackFrame(Picoc *pc);
|
|
extern int HeapPopStackFrame(Picoc *pc);
|
|
extern void *HeapAllocMem(Picoc *pc, int Size);
|
|
extern void HeapFreeMem(Picoc *pc, void *Mem);
|
|
|
|
/* variable.c */
|
|
extern void VariableInit(Picoc *pc);
|
|
extern void VariableCleanup(Picoc *pc);
|
|
extern void VariableFree(Picoc *pc, struct Value *Val);
|
|
extern void VariableTableCleanup(Picoc *pc, struct Table *HashTable);
|
|
extern void *VariableAlloc(Picoc *pc, struct ParseState *Parser, int Size, int OnHeap);
|
|
extern void VariableStackPop(struct ParseState *Parser, struct Value *Var);
|
|
extern struct Value *VariableAllocValueAndData(Picoc *pc, struct ParseState *Parser,
|
|
int DataSize, int IsLValue, struct Value *LValueFrom, int OnHeap);
|
|
extern struct Value *VariableAllocValueAndCopy(Picoc *pc, struct ParseState *Parser,
|
|
struct Value *FromValue, int OnHeap);
|
|
extern struct Value *VariableAllocValueFromType(Picoc *pc, struct ParseState *Parser,
|
|
struct ValueType *Typ, int IsLValue, struct Value *LValueFrom, int OnHeap);
|
|
extern struct Value *VariableAllocValueFromExistingData(struct ParseState *Parser,
|
|
struct ValueType *Typ, union AnyValue *FromValue, int IsLValue,
|
|
struct Value *LValueFrom);
|
|
extern struct Value *VariableAllocValueShared(struct ParseState *Parser,
|
|
struct Value *FromValue);
|
|
extern struct Value *VariableDefine(Picoc *pc, struct ParseState *Parser,
|
|
char *Ident, struct Value *InitValue, struct ValueType *Typ, int MakeWritable);
|
|
extern struct Value *VariableDefineButIgnoreIdentical(struct ParseState *Parser,
|
|
char *Ident, struct ValueType *Typ, int IsStatic, int *FirstVisit);
|
|
extern int VariableDefined(Picoc *pc, const char *Ident);
|
|
extern int VariableDefinedAndOutOfScope(Picoc *pc, const char *Ident);
|
|
extern void VariableRealloc(struct ParseState *Parser, struct Value *FromValue,
|
|
int NewSize);
|
|
extern void VariableGet(Picoc *pc, struct ParseState *Parser, const char *Ident,
|
|
struct Value **LVal);
|
|
extern void VariableDefinePlatformVar(Picoc *pc, struct ParseState *Parser,
|
|
char *Ident, struct ValueType *Typ, union AnyValue *FromValue, int IsWritable);
|
|
extern void VariableStackFrameAdd(struct ParseState *Parser, const char *FuncName,
|
|
int NumParams);
|
|
extern void VariableStackFramePop(struct ParseState *Parser);
|
|
extern struct Value *VariableStringLiteralGet(Picoc *pc, char *Ident);
|
|
extern void VariableStringLiteralDefine(Picoc *pc, char *Ident, struct Value *Val);
|
|
extern void *VariableDereferencePointer(struct Value *PointerValue,
|
|
struct Value **DerefVal, int *DerefOffset, struct ValueType **DerefType,
|
|
int *DerefIsLValue);
|
|
extern int VariableScopeBegin(struct ParseState *Parser, int *PrevScopeID);
|
|
extern void VariableScopeEnd(struct ParseState *Parser, int ScopeID, int PrevScopeID);
|
|
|
|
/* clibrary.c */
|
|
extern void BasicIOInit(Picoc *pc);
|
|
extern void LibraryInit(Picoc *pc);
|
|
extern void LibraryAdd(Picoc *pc, struct LibraryFunction *FuncList);
|
|
extern void CLibraryInit(Picoc *pc);
|
|
extern void PrintCh(char OutCh, IOFILE *Stream);
|
|
extern void PrintSimpleInt(long Num, IOFILE *Stream);
|
|
extern void PrintInt(long Num, int FieldWidth, int ZeroPad, int LeftJustify,
|
|
IOFILE *Stream);
|
|
extern void PrintStr(const char *Str, IOFILE *Stream);
|
|
extern void PrintFP(double Num, IOFILE *Stream);
|
|
extern void PrintType(struct ValueType *Typ, IOFILE *Stream);
|
|
extern void LibPrintf(struct ParseState *Parser, struct Value *ReturnValue,
|
|
struct Value **Param, int NumArgs);
|
|
|
|
/* platform.c */
|
|
/* the following are defined in picoc.h:
|
|
* void PicocCallMain(int argc, char **argv);
|
|
* int PicocPlatformSetExitPoint();
|
|
* void PicocInitialize(int StackSize);
|
|
* void PicocCleanup();
|
|
* void PicocPlatformScanFile(const char *FileName);
|
|
* extern int PicocExitValue; */
|
|
extern void ProgramFail(struct ParseState *Parser, const char *Message, ...);
|
|
extern void ProgramFailNoParser(Picoc *pc, const char *Message, ...);
|
|
extern void AssignFail(struct ParseState *Parser, const char *Format,
|
|
struct ValueType *Type1, struct ValueType *Type2, int Num1, int Num2,
|
|
const char *FuncName, int ParamNo);
|
|
extern void LexFail(Picoc *pc, struct LexState *Lexer, const char *Message, ...);
|
|
extern void PlatformInit(Picoc *pc);
|
|
extern void PlatformCleanup(Picoc *pc);
|
|
extern char *PlatformGetLine(char *Buf, int MaxLen, const char *Prompt);
|
|
extern int PlatformGetCharacter();
|
|
extern void PlatformPutc(unsigned char OutCh, union OutputStreamInfo *);
|
|
extern void PlatformPrintf(IOFILE *Stream, const char *Format, ...);
|
|
extern void PlatformVPrintf(IOFILE *Stream, const char *Format, va_list Args);
|
|
extern void PlatformExit(Picoc *pc, int ExitVal);
|
|
extern char *PlatformMakeTempName(Picoc *pc, char *TempNameBuffer);
|
|
extern void PlatformLibraryInit(Picoc *pc);
|
|
|
|
/* include.c */
|
|
extern void IncludeInit(Picoc *pc);
|
|
extern void IncludeCleanup(Picoc *pc);
|
|
extern void IncludeRegister(Picoc *pc, const char *IncludeName,
|
|
void (*SetupFunction)(Picoc *pc), struct LibraryFunction *FuncList,
|
|
const char *SetupCSource);
|
|
extern void IncludeFile(Picoc *pc, char *Filename);
|
|
/* the following is defined in picoc.h:
|
|
* void PicocIncludeAllSystemHeaders(); */
|
|
|
|
#ifdef DEBUGGER
|
|
/* debug.c */
|
|
extern void DebugInit(Picoc *pc);
|
|
extern void DebugCleanup(Picoc *pc);
|
|
extern void DebugCheckStatement(struct ParseState *Parser);
|
|
extern void DebugSetBreakpoint(struct ParseState *Parser);
|
|
extern int DebugClearBreakpoint(struct ParseState *Parser);
|
|
extern void DebugStep(void)
|
|
#endif
|
|
|
|
/* stdio.c */
|
|
extern const char StdioDefs[];
|
|
extern struct LibraryFunction StdioFunctions[];
|
|
extern void StdioSetupFunc(Picoc *pc);
|
|
|
|
/* math.c */
|
|
extern struct LibraryFunction MathFunctions[];
|
|
extern void MathSetupFunc(Picoc *pc);
|
|
|
|
/* string.c */
|
|
extern struct LibraryFunction StringFunctions[];
|
|
extern void StringSetupFunc(Picoc *pc);
|
|
|
|
/* stdlib.c */
|
|
extern struct LibraryFunction StdlibFunctions[];
|
|
extern void StdlibSetupFunc(Picoc *pc);
|
|
|
|
/* time.c */
|
|
extern const char StdTimeDefs[];
|
|
extern struct LibraryFunction StdTimeFunctions[];
|
|
extern void StdTimeSetupFunc(Picoc *pc);
|
|
|
|
/* errno.c */
|
|
extern void StdErrnoSetupFunc(Picoc *pc);
|
|
|
|
/* ctype.c */
|
|
extern struct LibraryFunction StdCtypeFunctions[];
|
|
|
|
/* stdbool.c */
|
|
extern const char StdboolDefs[];
|
|
extern void StdboolSetupFunc(Picoc *pc);
|
|
|
|
/* unistd.c */
|
|
extern const char UnistdDefs[];
|
|
extern struct LibraryFunction UnistdFunctions[];
|
|
extern void UnistdSetupFunc(Picoc *pc);
|
|
|
|
#endif /* INTERPRETER_H */
|