Recovered from cvs revision 2007-05-06 16:04:00

ase/test/awk/Awk.cpp

@@ -1,34 +1,202 @@
 /*
- * $Id: Awk.cpp,v 1.1 2007/05/02 15:07:33 bacon Exp $
+ * $Id: Awk.cpp,v 1.2 2007/05/06 06:55:05 bacon Exp $
  */
 
-#include <ase/awk/Awk.h>
+#include <ase/awk/StdAwk.hpp>
+#include <ase/cmn/str.h>
 
-class TestAwk: public ASE::Awk
+#include <ase/utl/ctype.h>
+#include <ase/utl/stdio.h>
+#include <ase/utl/main.h>
+
+#include <stdlib.h>
+#include <math.h>
+#include <windows.h>
+
+class TestAwk: public ASE::StdAwk
 {
-	int openSource (SourceMode mode)
+public:
+	int parse (const char_t* name)
 	{
-		return 1;
+		ase_strxcpy (sourceInName, ASE_COUNTOF(sourceInName), name);
+		return StdAwk::parse ();
 	}
 
-	int closeSource (SourceMode mode)
+protected:
+	int openSource (Source& io)
+	{
+		Source::Mode mode = io.getMode();
+
+		if (mode == Source::READ)
+		{
+			FILE* fp = ase_fopen (sourceInName, ASE_T("r"));
+			if (fp == ASE_NULL) return -1;
+			io.setHandle (fp);
+		}
+		else if (mode == Source::WRITE)
+		{
+			return 0;
+		}
+
+		return -1;
+	}
+
+	int closeSource (Source& io)
+	{
+		Source::Mode mode = io.getMode();
+
+		if (mode == Source::READ)
+		{
+			fclose ((FILE*)io.getHandle());
+			io.setHandle (ASE_NULL);
+			return 0;
+		}
+		else if (mode == Source::WRITE)
+		{
+			return 0;
+		}
+
+		return -1;
+	}
+
+	ssize_t readSource (Source& io, char_t* buf, size_t count)
 	{
 		return 0;
 	}
 
-	ase_ssize_t readSource (ase_char_t* buf, ase_size_t count)
+	ssize_t writeSource (Source& io, char_t* buf, size_t count)
 	{
 		return 0;
 	}
 
-	ase_ssize_t writeSource (ase_char_t* buf, ase_size_t count);
+
+	// pipe io handlers 
+	int     openPipe  (Pipe& io) { return -1; }
+	int     closePipe (Pipe& io) { return 0; }
+	ssize_t readPipe  (Pipe& io, char_t* buf, size_t len) { return 0; }
+	ssize_t writePipe (Pipe& io, char_t* buf, size_t len) { return 0; }
+	int     flushPipe (Pipe& io) { return 0; }
+	int     nextPipe  (Pipe& io) { return 0; }
+
+	// file io handlers 
+	int     openFile  (File& io) { return -1; }
+	int     closeFile (File& io) { return 0; }
+	ssize_t readFile  (File& io, char_t* buf, size_t len) { return 0; }
+	ssize_t writeFile (File& io, char_t* buf, size_t len) { return 0; }
+	int     flushFile (File& io) { return 0; }
+	int     nextFile  (File& io) { return 0; }
+
+	// console io handlers 
+	int openConsole  (Console& io) { return 1; }
+	int closeConsole (Console& io) { return 0; }
+	ssize_t readConsole  (Console& io, char_t* buf, size_t len) 
 	{
 		return 0;
 	}
+	ssize_t writeConsole (Console& io, char_t* buf, size_t len) 
+	{
+		return ase_printf (ASE_T(".%s"), len, buf);
+	}
+	int flushConsole (Console& io) { return 0; }
+	int nextConsole  (Console& io) { return 0; }
+
+	// primitive operations 
+	void* malloc  (size_t n) { return ::malloc (n); }
+	void* realloc (void* ptr, size_t n) { return ::realloc (ptr, n); }
+	void  free    (void* ptr) { ::free (ptr); }
+
+	bool_t isUpper  (cint_t c) { return ase_isupper (c); }
+	bool_t isLower  (cint_t c) { return ase_islower (c); }
+	bool_t isAlpha  (cint_t c) { return ase_isalpha (c); }
+	bool_t isDigit  (cint_t c) { return ase_isdigit (c); }
+	bool_t isXdigit (cint_t c) { return ase_isxdigit (c); }
+	bool_t isAlnum  (cint_t c) { return ase_isalnum (c); }
+	bool_t isSpace  (cint_t c) { return ase_isspace (c); }
+	bool_t isPrint  (cint_t c) { return ase_isprint (c); }
+	bool_t isGraph  (cint_t c) { return ase_isgraph (c); }
+	bool_t isCntrl  (cint_t c) { return ase_iscntrl (c); }
+	bool_t isPunct  (cint_t c) { return ase_ispunct (c); }
+	cint_t toUpper  (cint_t c) { return ase_toupper (c); }
+	cint_t toLower  (cint_t c) { return ase_tolower (c); }
+
+	real_t pow (real_t x, real_t y) 
+	{ 
+		return ::pow (x, y); 
+	}
+
+	int vsprintf (char_t* buf, size_t size, const char_t* fmt, va_list arg) 
+	{
+		return ase_vsprintf (buf, size, fmt, arg);
+	}
+
+	void vdprintf (const char_t* fmt, va_list arg) 
+	{
+		ase_vfprintf (stderr, fmt, arg);
+	}
+
+private:
+	char_t sourceInName[1024+1];
 };
 
-int main ()
+#ifndef NDEBUG
+void ase_assert_abort (void)
 {
-
-	
+	abort ();
+}
+
+void ase_assert_printf (const ase_char_t* fmt, ...)
+{
+	va_list ap;
+#ifdef _WIN32
+	int n;
+	ase_char_t buf[1024];
+#endif
+
+	va_start (ap, fmt);
+#if defined(_WIN32)
+	n = _vsntprintf (buf, ASE_COUNTOF(buf), fmt, ap);
+	if (n < 0) buf[ASE_COUNTOF(buf)-1] = ASE_T('\0');
+
+	#if defined(_MSC_VER) && (_MSC_VER<1400)
+	MessageBox (NULL, buf, 
+		ASE_T("Assertion Failure"), MB_OK|MB_ICONERROR);
+	#else
+	MessageBox (NULL, buf, 
+		ASE_T("\uB2DD\uAE30\uB9AC \uC870\uB610"), MB_OK|MB_ICONERROR);
+	#endif
+#else
+	ase_vprintf (fmt, ap);
+#endif
+	va_end (ap);
+}
+#endif
+
+int ase_main (int argc, ase_char_t* argv[])
+{
+	TestAwk awk;
+
+	if (awk.open() == -1)
+	{
+		ase_fprintf (stderr, ASE_T("cannot open awk\n"));
+		//awk.close ();
+		return -1;
+	}
+
+return -1;
+	if (awk.parse(ASE_T("t.awk")) == -1)
+	{
+		ase_fprintf (stderr, ASE_T("cannot parse\n"));
+		//awk.close ();
+		return -1;
+	}
+
+	if (awk.run () == -1)
+	{
+		ase_fprintf (stderr, ASE_T("cannot run\n"));
+		//awk.close ();
+		return -1;
+	}
+
+	awk.close ();
+	return 0;
 }