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

Created a stream output system.

Browse source 
Implemented sprintf().

git-svn-id: http://picoc.googlecode.com/svn/trunk@271 21eae674-98b7-11dd-bd71-f92a316d2d60
This commit is contained in:
zik.saleeba 2009-04-27 04:56:58 +00:00
parent 647cc90999
commit b6e61dd8ab
6 changed files with 122 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
TODO
View file

@ -27,6 +27,7 @@ Improvements:
* expression and auto-cast support for all types
* periodic heap cleanup
* octal/hex character constants
* comma expressions
* see if we can use ParserCopyPos() in other places rather than copying everything
* check for no value returned in functions with a return value
* native pointer access?

120
clibrary.c
View file

@ -1,5 +1,7 @@
#include "picoc.h"
struct OutputStream CStdOut;
static int TRUEValue = 1;
static int ZeroValue = 0;
@ -14,6 +16,8 @@ void LibraryInit(struct Table *GlobalTable, const char *LibraryName, struct Libr
void *Tokens;
const char *IntrinsicName = TableStrRegister("c library");
CStdOut.Putch = &PlatformPutc;
for (Count = 0; (*FuncList)[Count].Prototype != NULL; Count++)
{
Tokens = LexAnalyse(IntrinsicName, (*FuncList)[Count].Prototype, strlen((char *)(*FuncList)[Count].Prototype), NULL);
@ -34,15 +38,30 @@ void CLibraryInit()
VariableDefinePlatformVar(NULL, "FALSE", &IntType, (union AnyValue *)&ZeroValue, FALSE);
}
/* stream for writing into strings */
void SPutc(unsigned char Ch, union OutputStreamInfo *Stream)
{
struct StringOutputStream *Out = &Stream->Str;
*Out->WritePos++ = Ch;
if (Out->WritePos == Out->MaxPos)
Out->WritePos--;
}
/* print a character to a stream without using printf/sprintf */
void PrintCh(char OutCh, struct OutputStream *Stream)
{
(*Stream->Putch)(OutCh, &Stream->i);
}
/* print a string to a stream without using printf/sprintf */
void PrintStr(const char *Str, CharWriter *PutCh)
void PrintStr(const char *Str, struct OutputStream *Stream)
{
while (*Str != 0)
PutCh(*Str++);
PrintCh(*Str++, Stream);
}
/* print an integer to a stream without using printf/sprintf */
void PrintInt(int Num, CharWriter *PutCh)
void PrintInt(int Num, struct OutputStream *Stream)
{
int Div;
int Remainder = 0;
@ -50,12 +69,12 @@ void PrintInt(int Num, CharWriter *PutCh)
if (Num < 0)
{
PutCh('-');
PrintCh('-', Stream);
Num = -Num;
}
if (Num == 0)
PutCh('0');
PrintCh('0', Stream);
else
{
Div = LARGE_INT_POWER_OF_TEN;
@ -64,7 +83,7 @@ void PrintInt(int Num, CharWriter *PutCh)
Remainder = Num / Div;
if (Printing || Remainder > 0)
{
PutCh('0' + Remainder);
PrintCh('0' + Remainder, Stream);
Printing = TRUE;
}
Num -= Remainder * Div;
@ -75,7 +94,7 @@ void PrintInt(int Num, CharWriter *PutCh)
#ifndef NO_FP
/* print a double to a stream without using printf/sprintf */
void PrintFP(double Num, CharWriter *PutCh)
void PrintFP(double Num, struct OutputStream *Stream)
{
int Exponent = 0;
@ -85,42 +104,42 @@ void PrintFP(double Num, CharWriter *PutCh)
Exponent = log(Num) / LOG10E - 0.999999999;
Num /= pow(10.0, Exponent);
PrintInt((int)Num, PutCh);
PutCh('.');
PrintInt((int)Num, Stream);
PrintCh('.', Stream);
for (Num -= (int)Num; Num != 0.0; Num *= 10.0)
PutCh('0' + (int)Num);
PrintCh('0' + (int)Num, Stream);
if (Exponent)
{
PutCh('e');
PrintInt(Exponent, PutCh);
PrintCh('e', Stream);
PrintInt(Exponent, Stream);
}
}
#endif
/* print a type to a stream without using printf/sprintf */
void PrintType(struct ValueType *Typ, CharWriter *PutCh)
void PrintType(struct ValueType *Typ, struct OutputStream *Stream)
{
switch (Typ->Base)
{
case TypeVoid: PrintStr("void", PutCh); break;
case TypeInt: PrintStr("int", PutCh); break;
case TypeVoid: PrintStr("void", Stream); break;
case TypeInt: PrintStr("int", Stream); break;
#ifndef NO_FP
case TypeFP: PrintStr("double", PutCh); break;
case TypeFP: PrintStr("double", Stream); break;
#endif
case TypeChar: PrintStr("char", PutCh); break;
case TypeFunction: PrintStr("function", PutCh); break;
case TypeMacro: PrintStr("macro", PutCh); break;
case TypePointer: if (Typ->FromType) PrintType(Typ->FromType, PutCh); PutCh('*'); break;
case TypeArray: PrintType(Typ->FromType, PutCh); PutCh('['); if (Typ->ArraySize != 0) PrintInt(Typ->ArraySize, PutCh); PutCh(']'); break;
case TypeStruct: PrintStr("struct ", PutCh); PrintStr(Typ->Identifier, PutCh); break;
case TypeUnion: PrintStr("union ", PutCh); PrintStr(Typ->Identifier, PutCh); break;
case TypeEnum: PrintStr("enum ", PutCh); PrintStr(Typ->Identifier, PutCh); break;
case TypeChar: PrintStr("char", Stream); break;
case TypeFunction: PrintStr("function", Stream); break;
case TypeMacro: PrintStr("macro", Stream); break;
case TypePointer: if (Typ->FromType) PrintType(Typ->FromType, Stream); PrintCh('*', Stream); break;
case TypeArray: PrintType(Typ->FromType, Stream); PrintCh('[', Stream); if (Typ->ArraySize != 0) PrintInt(Typ->ArraySize, Stream); PrintCh(']', Stream); break;
case TypeStruct: PrintStr("struct ", Stream); PrintStr(Typ->Identifier, Stream); break;
case TypeUnion: PrintStr("union ", Stream); PrintStr(Typ->Identifier, Stream); break;
case TypeEnum: PrintStr("enum ", Stream); PrintStr(Typ->Identifier, Stream); break;
}
}
/* intrinsic functions made available to the language */
void LibPrintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
void GenericPrintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs, struct OutputStream *Stream)
{
struct Value *CharArray = Param[0]->Val->Pointer.Segment;
char *Format;
@ -146,20 +165,20 @@ void LibPrintf(struct ParseState *Parser, struct Value *ReturnValue, struct Valu
#ifndef NO_FP
case 'f': FormatType = &FPType; break;
#endif
case '%': PlatformPutc('%'); FormatType = NULL; break;
case '%': PrintCh('%', Stream); FormatType = NULL; break;
case '\0': FPos--; FormatType = NULL; break;
default: PlatformPutc(*FPos); FormatType = NULL; break;
default: PrintCh(*FPos, Stream); FormatType = NULL; break;
}
if (FormatType != NULL)
{ /* we have to format something */
if (ArgCount >= NumArgs)
PrintStr("XXX", PlatformPutc); /* not enough parameters for format */
PrintStr("XXX", Stream); /* not enough parameters for format */
else
{
NextArg = (struct Value *)((void *)NextArg + sizeof(struct Value) + TypeStackSizeValue(NextArg));
if (NextArg->Typ != FormatType && !(FormatType == &IntType && IS_INTEGER_COERCIBLE(NextArg)))
PrintStr("XXX", PlatformPutc); /* bad type for format */
PrintStr("XXX", Stream); /* bad type for format */
else
{
switch (*FPos)
@ -174,13 +193,13 @@ void LibPrintf(struct ParseState *Parser, struct Value *ReturnValue, struct Valu
else
Str = CharArray->Val->Array.Data + NextArg->Val->Pointer.Offset;
PrintStr(Str, PlatformPutc);
PrintStr(Str, Stream);
break;
}
case 'd': PrintInt(COERCE_INTEGER(NextArg), PlatformPutc); break;
case 'c': PlatformPutc(COERCE_INTEGER(NextArg)); break;
case 'd': PrintInt(COERCE_INTEGER(NextArg), Stream); break;
case 'c': PrintCh(COERCE_INTEGER(NextArg), Stream); break;
#ifndef NO_FP
case 'f': PrintFP(NextArg->Val->FP, PlatformPutc); break;
case 'f': PrintFP(NextArg->Val->FP, Stream); break;
#endif
}
}
@ -190,10 +209,40 @@ void LibPrintf(struct ParseState *Parser, struct Value *ReturnValue, struct Valu
}
}
else
PlatformPutc(*FPos);
PrintCh(*FPos, Stream);
}
}
/* printf(): print to console output */
void LibPrintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
{
struct OutputStream ConsoleStream;
ConsoleStream.Putch = &PlatformPutc;
GenericPrintf(Parser, ReturnValue, Param, NumArgs, &ConsoleStream);
}
/* sprintf(): print to a string */
void LibSPrintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
{
struct OutputStream StrStream;
struct Value *DerefVal;
int DerefOffset;
struct ValueType *DerefType;
StrStream.i.Str.WritePos = VariableDereferencePointer(StrStream.i.Str.Parser, Param[0], &DerefVal, &DerefOffset, &DerefType);
if (DerefVal->Typ->Base != TypeArray)
ProgramFail(Parser, "can only print to arrays of char");
StrStream.Putch = &SPutc;
StrStream.i.Str.Parser = Parser;
StrStream.i.Str.MaxPos = StrStream.i.Str.WritePos- DerefOffset + DerefVal->Val->Array.Size;
GenericPrintf(Parser, ReturnValue, Param+1, NumArgs-1, &StrStream);
PrintCh(0, &StrStream);
ReturnValue->Val->Pointer.Segment = *Param;
ReturnValue->Val->Pointer.Offset = 0;
}
/* get a line of input. protected from buffer overrun */
void LibGets(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
{
@ -202,7 +251,7 @@ void LibGets(struct ParseState *Parser, struct Value *ReturnValue, struct Value
int MaxLength = CharArray->Val->Array.Size - Param[0]->Val->Pointer.Offset;
char *Result;
ReturnValue->Val->Pointer.Segment = 0;
ReturnValue->Val->Pointer.Segment = NULL;
ReturnValue->Val->Pointer.Offset = 0;
if (Param[0]->Val->Pointer.Offset < 0 || MaxLength < 0)
@ -224,6 +273,7 @@ void LibGetc(struct ParseState *Parser, struct Value *ReturnValue, struct Value
struct LibraryFunction CLibrary[] =
{
{ LibPrintf, "void printf(char *, ...)" },
{ LibSPrintf, "char *sprintf(char *, char *, ...)" },
{ LibGets, "void gets(char *, int)" },
{ LibGetc, "int getchar()" },
{ NULL, NULL }

34
picoc.h
View file

@ -231,8 +231,26 @@ struct LibraryFunction
const char *Prototype;
};
/* platform-specific method for writing characters to the console */
typedef void CharWriter(unsigned char);
/* output stream-type specific state information */
union OutputStreamInfo
{
struct StringOutputStream
{
struct ParseState *Parser;
char *WritePos;
char *MaxPos;
} 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;
};
/* globals */
extern void *HeapStackTop;
@ -253,6 +271,7 @@ extern char *StrEmpty;
extern struct PointerValue NULLPointer;
extern struct LibraryFunction CLibrary[];
extern struct LibraryFunction PlatformLibrary[];
extern struct OutputStream CStdOut;
/* table.c */
void TableInit();
@ -335,10 +354,11 @@ void *VariableDereferencePointer(struct ParseState *Parser, struct Value *Pointe
/* clibrary.c */
void LibraryInit(struct Table *GlobalTable, const char *LibraryName, struct LibraryFunction (*FuncList)[]);
void CLibraryInit();
void PrintInt(int Num, CharWriter *PutCh);
void PrintStr(const char *Str, CharWriter *PutCh);
void PrintFP(double Num, CharWriter *PutCh);
void PrintType(struct ValueType *Typ, CharWriter *PutCh);
void PrintCh(char OutCh, struct OutputStream *Stream);
void PrintInt(int Num, struct OutputStream *Stream);
void PrintStr(const char *Str, struct OutputStream *Stream);
void PrintFP(double Num, struct OutputStream *Stream);
void PrintType(struct ValueType *Typ, struct OutputStream *Stream);
/* platform.c */
void ProgramFail(struct ParseState *Parser, const char *Message, ...);
@ -347,7 +367,7 @@ void PlatformCleanup();
void PlatformScanFile(const char *FileName);
char *PlatformGetLine(char *Buf, int MaxLen);
int PlatformGetCharacter();
void PlatformPutc(unsigned char OutCh);
void PlatformPutc(unsigned char OutCh, union OutputStreamInfo *);
void PlatformPrintf(const char *Format, ...);
void PlatformVPrintf(const char *Format, va_list Args);
void PlatformExit();

15
platform.c
View file

@ -1,6 +1,5 @@
#include "picoc.h"
/* exit with a message */
void ProgramFail(struct ParseState *Parser, const char *Message, ...)
{
@ -50,18 +49,18 @@ void PlatformVPrintf(const char *Format, va_list Args)
FPos++;
switch (*FPos)
{
case 's': PrintStr(va_arg(Args, char *), PlatformPutc); break;
case 'd': PrintInt(va_arg(Args, int), PlatformPutc); break;
case 'c': PlatformPutc(va_arg(Args, int)); break;
case 't': PrintType(va_arg(Args, struct ValueType *), PlatformPutc); break;
case 's': PrintStr(va_arg(Args, char *), &CStdOut); break;
case 'd': PrintInt(va_arg(Args, int), &CStdOut); break;
case 'c': PrintCh(va_arg(Args, int), &CStdOut); break;
case 't': PrintType(va_arg(Args, struct ValueType *), &CStdOut); break;
#ifndef NO_FP
case 'f': PrintFP(va_arg(Args, double), PlatformPutc); break;
case 'f': PrintFP(va_arg(Args, double), &CStdOut); break;
#endif
case '%': PlatformPutc('%'); break;
case '%': PrintCh('%', &CStdOut); break;
case '\0': FPos--; break;
}
}
else
PlatformPutc(*FPos);
PrintCh(*FPos, &CStdOut);
}
}

2
platform_surveyor.c
View file

@ -32,7 +32,7 @@ char *PlatformGetLine(char *Buf, int MaxLen)
}
/* write a character to the console */
void PlatformPutc(unsigned char OutCh)
void PlatformPutc(unsigned char OutCh, union OutputStreamInfo *Stream)
{
putchar(OutCh);
}

2
platform_unix.c
View file

@ -25,7 +25,7 @@ int PlatformGetCharacter()
}
/* write a character to the console */
void PlatformPutc(unsigned char OutCh)
void PlatformPutc(unsigned char OutCh, union OutputStreamInfo *Stream)
{
putchar(OutCh);
}