main.cpp File Reference

#include <iostream>
#include <algorithm>
#include <vector>
#include <fstream>
#include <commandline.h>
#include <keyboard.h>
#include <pathstuff.h>
#include <rpn.h>
#include <rpnfunc.h>
#include <rawinterpreter.h>
#include <scopedependentfunctions.h>
#include <singleton.h>

Include dependency graph for main.cpp:

Go to the source code of this file.

Functions

void print (deque< rpnbase * > &ds)

void test01 ()

void test02 ()

void test03 ()

void test04 (int argc, char **argv)

void test05 ()

int main (int argc, char **argv)

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 324 of file main.cpp.

References test04().

00325 {
00326   test04(argc,argv); 
00327 
00328   /* test05(); */
00329 
00330 
00331 }

void print ( deque< rpnbase * > & ds )

Definition at line 17 of file main.cpp.

00018 {
00019   cout << "size=" << ds.size();
00020   cout << "   depth=" << rpnprogramstackstate().ps->size() << endl;
00021 
00022   if (ds.empty())
00023     return;
00024 
00025   unsigned int const imax = 10;
00026   for (unsigned int i=min(ds.size(),imax); i>0; )
00027   {
00028     --i;
00029     cout << i << ": " << ds[i] << endl;
00030   }
00031 
00032 }

void test01 ( )

Definition at line 35 of file main.cpp.

References rpnbase::eval(), and print().

00036 {
00037   deque<rpnbase*> ds;
00038 
00039   rpnbase* x;
00040 
00041   x = new rpnreal(2.5);
00042   x->eval(ds);
00043 
00044   new rpnreal(ds,2.7);
00045   new rpndup(ds);
00046   new rpnstring(ds,"hat");
00047   new rpndup(ds);
00048 
00049   // Add dup without evaluating
00050 
00051   new rpndup(ds,false);
00052 
00053   //x = new rpnprogram();
00054   //ds.push_front(x);
00055 
00056   new rpnprogram(ds);
00057 
00058   deque<rpnbase*> ds2;
00059   new rpnreal(ds2,1.0);
00060   new rpnreal(ds2,2);
00061   new rpndup(ds2,false);
00062   new rpnprogram(ds,ds2,false);
00063   new rpndup(ds);
00064   new rpninteger(ds,5);
00065   new rpnstring(ds,"hat");
00066 
00067   rpnprogramstackstate().init();
00068   new var(ds);
00069   new rpnstring(ds,"mat");
00070   new rpndup(ds);
00071   new var(ds);
00072 
00073   new rpninteger(ds,1);
00074   new rpninteger(ds,27);
00075   new rpnstring(ds,"fat");
00076   new ifthenelse(ds);
00077  
00078   new rpnreal(ds,0);
00079   new rpnnot(ds,false);
00080 
00081   new rpnreal(ds,15.1);
00082   new rpninteger(ds,15);
00083 
00084   new rpnequal(ds,true);
00085   new rpninteger(ds,5);
00086   new prognew(ds,true);
00087   //new rpninteger(ds,3);
00088   //new rpndupn(ds);
00089 
00090   //new rpnneg(ds);
00091 
00092 
00093   new rpninteger(ds,0);
00094   new rpninteger(ds,5);
00095   new rpndup(ds,false);
00096   new rpninteger(ds,1);
00097   new prognew(ds);
00098 
00099   new rpndup(ds,false);
00100   new rot(ds,false);
00101   new rpnadd(ds,false);
00102   new rpnswap(ds,false);
00103   new rpninteger(ds,1);
00104   new rpnsubtract(ds,false);
00105   new rpninteger(ds,6);
00106   new prognew(ds);
00107 
00108   new rpnfor(ds,false);
00109 
00110   new rpninteger(ds,3);
00111   new rpndup(ds,false);
00112   new rpneval(ds,false);
00113   new rpneval(ds);
00114 
00115   /*
00116   new rpninteger(ds,8);
00117   new rpninteger(ds,7);
00118   new rpninteger(ds,6);
00119   new rpninteger(ds,5);
00120   new rpninteger(ds,4);
00121   new rpninteger(ds,3);
00122   new rpninteger(ds,2);
00123   new rpninteger(ds,1);
00124   new rpninteger(ds,8);
00125   new rpninteger(ds,-3);
00126   new rotn(ds);
00127   */
00128 
00129   new rpndup(ds,false);
00130   new rpnstring(ds,"cat");
00131   new var(ds);
00132 
00133   new rpninteger(ds,17);
00134   new rpnstring(ds,"cat");
00135   new varrecall(ds,false);
00136 
00137 /*
00138   cout<< endl << endl;
00139   bool res;
00140   rpnprogramstackstate().exists(res,"hat");
00141   cout << "res=" << res << endl;
00142   rpnprogramstackstate().evaluate(ds,"mat");
00143   rpnprogramstackstate().evaluate(ds,"cat");
00144 
00145   rpnstring(ds,"hat");
00146  //new vardel(ds);
00147 
00148 
00149   //rpnprogramstackstate().replace(new rpnreal(2.3),"fred");
00150   //rpnprogramstackstate().erase("hat");
00151 */
00152 
00153 
00154 /*
00155 
00156   new rot(ds,true);
00157 
00158   new rpnswap(ds,false);
00159   new drop(ds,false);
00160 
00161   new rpnreal(ds,0);
00162   new rpnstring(ds,"cat");
00163   new ifthen(ds);
00164   
00165   new rpninteger(ds,-3);
00166 */
00167 
00168 
00169  
00170   cout << endl << endl;
00171   cout << rpnprogramstackstate();
00172 //  rpnprogramstackstate().print(cout);
00173   cout << endl;
00174 
00175   print(ds);
00176 }

void test02 ( )

Definition at line 178 of file main.cpp.

References print().

00179 {
00180   deque<rpnbase*> ds;
00181   rpnprogramstackstate().init();
00182 
00183 /*
00184   new rpninteger(ds,2);
00185   new rpninteger(ds,3);
00186   new rpninteger(ds,1);
00187   new prognew(ds);
00188   new rpninteger(ds,2);
00189   new prognew(ds);
00190   new rpneval(ds);
00191 */
00192 
00193   new rpninteger(ds,0);
00194   new rpnstring(ds,"s");
00195   new var(ds,false);
00196   new rpninteger(ds,1);
00197   new rpnstring(ds,"i");
00198   new var(ds,false);
00199 
00200   new rpnstring(ds,"i");
00201   new vareval(ds,false);
00202   new rpninteger(ds,5);
00203   new rpnlessthanequal(ds,false);
00204   new rpninteger(ds,4);
00205   new prognew(ds);
00206 
00207   new rpnstring(ds,"i");
00208   new vareval(ds,false);
00209   new rpnstring(ds,"s");
00210   new vareval(ds,false);
00211   new rpnadd(ds,false);
00212   new rpnstring(ds,"s");
00213   new varreplace(ds,false);
00214   new rpnstring(ds,"i");
00215   new vareval(ds,false);
00216   new rpninteger(ds,1);
00217   new rpnadd(ds,false);
00218   new rpnstring(ds,"i");
00219   new varreplace(ds,false);
00220   new rpninteger(ds,13);
00221   new prognew(ds);
00222   new rpnfor(ds,false);
00223   new rpnstring(ds,"s");
00224   new vareval(ds,false);
00225 
00226   new rpninteger(ds,11);
00227   new prognew(ds);
00228 
00229 
00230   new rpndup(ds);
00231   new rpneval(ds);
00232 
00233 
00234   cout << endl << endl;
00235   cout << rpnprogramstackstate();
00236   cout << endl;
00237 
00238   print(ds);
00239 }

void test03 ( )

Definition at line 242 of file main.cpp.

References fdatainterp::eval(), init(), and print().

00243 {
00244   deque<string> s;
00245   rpnprogramstackstate().init();
00246 
00247   s.push_back("2.5");
00248   s.push_back("dup");
00249   s.push_back("ahat");
00250   s.push_back("3");
00251   s.push_back("5.3");
00252   s.push_back("/");
00253 
00254   fdatainterp fd;
00255 
00256   inputstatescope inscp;
00257   SingletonPtr<inputstatescope> init(&inscp);
00258 
00259 
00260   for (unsigned int i=0, imax=s.size(); i<imax; ++i )
00261   {
00262     fd.eval(s.front());
00263     s.pop_front();
00264   }
00265 
00266   print( rpnprogramstackstate().ds() );
00267 }

void test04	(	int	argc,
		char **	argv
	)

Definition at line 269 of file main.cpp.

References commandline::mapvar().

00270 {
00271   commandline c(argc,argv);
00272 
00273   /* Read in an initialization file, if non specified
00274    * then read in the default rpnhome.txt file if it exists.
00275    * eg ./main load="mycalcstate.txt" */
00276 
00277   string load;
00278   c.mapvar(load,"load");
00279  
00280   if (load.empty())
00281     load = "rpnhome.txt";
00282 
00283   bool open = false;
00284   {
00285     ifstream file(load.c_str());
00286     if (!(!file))
00287       open = true;
00288   }
00289 
00290 
00291   cout << "<rpn compiler>" << endl;
00292   cout << "Enter quit to terminate." << endl << endl;
00293   cout << "0: " << endl;
00294 
00295   string strinit;
00296   if (open)
00297     strinit = load + " load ";
00298 
00299   keyboardinterface* kbd = new keyboardinterface(strinit);
00300   delete kbd;
00301 
00302 }

void test05 ( )

Definition at line 304 of file main.cpp.

00305 {
00306   cout << "test05" << endl;
00307 
00308   vector<string> v0, v1;
00309   string s,t;
00310   bool res;
00311 
00312   for ( ;s!="quit"; )
00313   {
00314     cin >> s;
00315     pathstuff().convert(v0,s);
00316     pathstuff().resolveparent(res,v1,v0);
00317     cout << "res=" << res;
00318     pathstuff().convert(t,v1);
00319     cout << " t=" << t << endl;
00320   }
00321 
00322 }


Functions
void	print (deque< rpnbase * > &ds)
void	test01 ()
void	test02 ()
void	test03 ()
void	test04 (int argc, char **argv)
void	test05 ()
int	main (int argc, char **argv)