Pull together everyone's contributions

.gitignore

@@ -0,0 +1,2 @@
+*.o
+picoc

.travis.yml

@@ -0,0 +1,11 @@
+language: c
+compiler: 
+    - gcc
+    - clang
+env:
+    - CFLAGS="-Wall -pedantic -g -DUNIX_HOST"
+    - CFLAGS="-m32 -Wall -pedantic -g -DUNIX_HOST"
+install: 
+    - sudo apt-get update -qq
+    - sudo apt-get install -qq gcc-multilib lib32readline6-dev
+script: make && make test

Makefile

@@ -1,5 +1,7 @@
+CC?=gcc
+VERSION+=$(shell git log --oneline -n 1 | sed 's/\ .*//')$(shell git status --porcelain | grep -q '^\ M' && echo -n M)
 CC=gcc
-CFLAGS=-Wall -pedantic -g -DUNIX_HOST -DVER=\"`svnversion -n`\"
+CFLAGS=-Wall -pedantic -g -DUNIX_HOST -DVER=\"${VERSION}\"
 LIBS=-lm -lreadline
 
 TARGET	= picoc

README → README.md

@@ -25,6 +25,8 @@ picoc can be compiled for a UNIX/Linux/POSIX host by typing "make".
 
 The test suite can be run by typing "make test".
 
+The `readline` library is necessary in order to compile picoc.
+
 
 Porting picoc
 -------------

clibrary.c

@@ -37,15 +37,16 @@ void LibraryAdd(Picoc *pc, struct Table *GlobalTable, const char *LibraryName, s
     struct Value *NewValue;
     void *Tokens;
     char *IntrinsicName = TableStrRegister(pc, "c library");
+	UNUSED(GlobalTable); UNUSED(LibraryName);
 
     /* read all the library definitions */
     for (Count = 0; FuncList[Count].Prototype != NULL; Count++)
     {
-        Tokens = LexAnalyse(pc, IntrinsicName, FuncList[Count].Prototype, strlen((char *)FuncList[Count].Prototype), NULL);
+        Tokens = LexAnalyse(pc, IntrinsicName, FuncList[Count].Prototype, (int) strlen((char *)FuncList[Count].Prototype), NULL);
         LexInitParser(&Parser, pc, FuncList[Count].Prototype, Tokens, IntrinsicName, TRUE, FALSE);
         TypeParse(&Parser, &ReturnType, &Identifier, NULL);
         NewValue = ParseFunctionDefinition(&Parser, ReturnType, Identifier);
-        NewValue->Val->FuncDef.Intrinsic = FuncList[Count].Func;
+        NewValue->Val->FuncDef.Intrinsic = (void (*)()) FuncList[Count].Func;
         HeapFreeMem(pc, Tokens);
     }
 }
@@ -304,11 +305,11 @@ void GenericPrintf(struct ParseState *Parser, struct Value *ReturnValue, struct
                                     PrintStr(Str, Stream); 
                                 break;
                             }
-                            case 'd': PrintInt(ExpressionCoerceInteger(NextArg), FieldWidth, ZeroPad, LeftJustify, Stream); break;
-                            case 'u': PrintUnsigned(ExpressionCoerceUnsignedInteger(NextArg), 10, FieldWidth, ZeroPad, LeftJustify, Stream); break;
-                            case 'x': PrintUnsigned(ExpressionCoerceUnsignedInteger(NextArg), 16, FieldWidth, ZeroPad, LeftJustify, Stream); break;
-                            case 'b': PrintUnsigned(ExpressionCoerceUnsignedInteger(NextArg), 2, FieldWidth, ZeroPad, LeftJustify, Stream); break;
-                            case 'c': PrintCh(ExpressionCoerceUnsignedInteger(NextArg), Stream); break;
+                            case 'd': PrintInt(ExpressionCoerceLong(NextArg), FieldWidth, ZeroPad, LeftJustify, Stream); break;
+                            case 'u': PrintUnsigned(ExpressionCoerceUnsignedLong(NextArg), 10, FieldWidth, ZeroPad, LeftJustify, Stream); break;
+                            case 'x': PrintUnsigned(ExpressionCoerceUnsignedLong(NextArg), 16, FieldWidth, ZeroPad, LeftJustify, Stream); break;
+                            case 'b': PrintUnsigned(ExpressionCoerceUnsignedLong(NextArg), 2, FieldWidth, ZeroPad, LeftJustify, Stream); break;
+                            case 'c': PrintCh(ExpressionCoerceUnsignedLong(NextArg), Stream); break;
 #ifndef NO_FP
                             case 'f': PrintFP(ExpressionCoerceFP(NextArg), Stream); break;
 #endif
@@ -664,7 +665,9 @@ struct LibraryFunction CLibrary[] =
     { LibStrncmp,       "int strncmp(char *,char *,int);" },
     { LibStrcat,        "void strcat(char *,char *);" },
     { LibIndex,         "char *index(char *,int);" },
+    { LibIndex,         "char *strchr(char *,int);" },
     { LibRindex,        "char *rindex(char *,int);" },
+    { LibRindex,        "char *strrchr(char *,int);" },
     { LibStrlen,        "int strlen(char *);" },
     { LibMemset,        "void memset(void *,int,int);" },
     { LibMemcpy,        "void memcpy(void *,void *,int);" },

cstdlib/ctype.c

@@ -6,82 +6,98 @@
 
 void StdIsalnum(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = isalnum(Param[0]->Val->Integer);
 }
 
 void StdIsalpha(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = isalpha(Param[0]->Val->Integer);
 }
 
 void StdIsblank(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
     int ch = Param[0]->Val->Integer;
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = (ch == ' ') | (ch == '\t');
 }
 
 void StdIscntrl(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = iscntrl(Param[0]->Val->Integer);
 }
 
 void StdIsdigit(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = isdigit(Param[0]->Val->Integer);
 }
 
 void StdIsgraph(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = isgraph(Param[0]->Val->Integer);
 }
 
 void StdIslower(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = islower(Param[0]->Val->Integer);
 }
 
 void StdIsprint(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = isprint(Param[0]->Val->Integer);
 }
 
 void StdIspunct(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = ispunct(Param[0]->Val->Integer);
 }
 
 void StdIsspace(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = isspace(Param[0]->Val->Integer);
 }
 
 void StdIsupper(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = isupper(Param[0]->Val->Integer);
 }
 
 void StdIsxdigit(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = isxdigit(Param[0]->Val->Integer);
 }
 
 void StdTolower(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = tolower(Param[0]->Val->Integer);
 }
 
 void StdToupper(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = toupper(Param[0]->Val->Integer);
 }
 
 void StdIsascii(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = isascii(Param[0]->Val->Integer);
 }
 
 void StdToascii(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs); 
     ReturnValue->Val->Integer = toascii(Param[0]->Val->Integer);
 }
 

cstdlib/math.c

@@ -21,118 +21,141 @@ static double M_SQRT1_2Value =  0.70710678118654752440;  /* 1/sqrt(2) */
 
 void MathSin(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = sin(Param[0]->Val->FP);
 }
 
 void MathCos(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = cos(Param[0]->Val->FP);
 }
 
 void MathTan(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = tan(Param[0]->Val->FP);
 }
 
 void MathAsin(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = asin(Param[0]->Val->FP);
 }
 
 void MathAcos(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = acos(Param[0]->Val->FP);
 }
 
 void MathAtan(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = atan(Param[0]->Val->FP);
 }
 
 void MathAtan2(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = atan2(Param[0]->Val->FP, Param[1]->Val->FP);
 }
 
 void MathSinh(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = sinh(Param[0]->Val->FP);
 }
 
 void MathCosh(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = cosh(Param[0]->Val->FP);
 }
 
 void MathTanh(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = tanh(Param[0]->Val->FP);
 }
 
 void MathExp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = exp(Param[0]->Val->FP);
 }
 
 void MathFabs(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = fabs(Param[0]->Val->FP);
 }
 
 void MathFmod(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = fmod(Param[0]->Val->FP, Param[1]->Val->FP);
 }
 
 void MathFrexp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
-    ReturnValue->Val->FP = frexp(Param[0]->Val->FP, Param[1]->Val->Pointer);
+	UNUSED(Parser); UNUSED(NumArgs);
+    ReturnValue->Val->FP = frexp(Param[0]->Val->FP, (int *) Param[1]->Val->Pointer);
 }
 
 void MathLdexp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = ldexp(Param[0]->Val->FP, Param[1]->Val->Integer);
 }
 
 void MathLog(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = log(Param[0]->Val->FP);
 }
 
 void MathLog10(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = log10(Param[0]->Val->FP);
 }
 
 void MathModf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
-    ReturnValue->Val->FP = modf(Param[0]->Val->FP, Param[0]->Val->Pointer);
+	UNUSED(Parser); UNUSED(NumArgs);
+    ReturnValue->Val->FP = modf(Param[0]->Val->FP, (double *) Param[0]->Val->Pointer);
 }
 
 void MathPow(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = pow(Param[0]->Val->FP, Param[1]->Val->FP);
 }
 
 void MathSqrt(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = sqrt(Param[0]->Val->FP);
 }
 
 void MathRound(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     /* this awkward definition of "round()" due to it being inconsistently
      * declared in math.h */
     ReturnValue->Val->FP = ceil(Param[0]->Val->FP - 0.5);
 }
 
 void MathCeil(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = ceil(Param[0]->Val->FP);
 }
 
 void MathFloor(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
 {
+	UNUSED(Parser); UNUSED(NumArgs);
     ReturnValue->Val->FP = floor(Param[0]->Val->FP);
 }