From e714c776ac9f5637d1dc4f9eb23c242f83a4e2f9 Mon Sep 17 00:00:00 2001
From: rupak
Date: Wed, 13 Nov 2019 15:00:02 +0530
Subject: added src folder for cpp source

---
 jar/scilab_en_US_help.jar           | Bin 16530 -> 16530 bytes
 macros/octave_fun.bin               | Bin 4411 -> 4411 bytes
 sci_gateway/cpp/libscilab_octave.so | Bin 17160 -> 17160 bytes
 src/Makefile                        |  20 ++++
 src/fun.cpp                         | 180 ++++++++++++++++++++++++++++++++++++
 src/fun.h                           |  38 ++++++++
 src/fun.o                           | Bin 0 -> 4617248 bytes
 src/libfun.so                       | Bin 0 -> 2887768 bytes
 src/main.cpp                        | 112 ++++++++++++++++++++++
 src/testfun                         | Bin 0 -> 41008 bytes
 thirdparty/linux/lib/x64/libfun.so  | Bin 2856176 -> 2887768 bytes
 11 files changed, 350 insertions(+)
 create mode 100755 src/Makefile
 create mode 100644 src/fun.cpp
 create mode 100644 src/fun.h
 create mode 100644 src/fun.o
 create mode 100755 src/libfun.so
 create mode 100644 src/main.cpp
 create mode 100755 src/testfun

diff --git a/jar/scilab_en_US_help.jar b/jar/scilab_en_US_help.jar
index d876a5c..c7db7b5 100644
Binary files a/jar/scilab_en_US_help.jar and b/jar/scilab_en_US_help.jar differ
diff --git a/macros/octave_fun.bin b/macros/octave_fun.bin
index 2e1076e..f063b32 100644
Binary files a/macros/octave_fun.bin and b/macros/octave_fun.bin differ
diff --git a/sci_gateway/cpp/libscilab_octave.so b/sci_gateway/cpp/libscilab_octave.so
index 3a2f181..e8bea75 100755
Binary files a/sci_gateway/cpp/libscilab_octave.so and b/sci_gateway/cpp/libscilab_octave.so differ
diff --git a/src/Makefile b/src/Makefile
new file mode 100755
index 0000000..ad535f0
--- /dev/null
+++ b/src/Makefile
@@ -0,0 +1,20 @@
+LIBNAME = fun
+
+all: lib$(LIBNAME).so test$(LIBNAME)
+
+$(LIBNAME).o: $(LIBNAME).h $(LIBNAME).cpp
+	mkoctfile -c -fPIC $(LIBNAME).cpp
+
+lib$(LIBNAME).so: $(LIBNAME).o
+	g++ -loctave -loctinterp -shared -o lib$(LIBNAME).so $(LIBNAME).o
+
+test$(LIBNAME): lib$(LIBNAME).so main.cpp fun.h
+	g++ -Wall -L$(PWD) -Wl,-rpath=$(PWD) -o $@ main.cpp -l$(LIBNAME) -g -loctave -loctinterp
+
+install:
+	cp fun.h ../thirdparty/linux/include/
+	cp libfun.so ../thirdparty/linux/lib/x64/
+
+.PHONY: clean
+clean:
+	$(RM) -f *.out *.so *.o *.oct
diff --git a/src/fun.cpp b/src/fun.cpp
new file mode 100644
index 0000000..31d5dc1
--- /dev/null
+++ b/src/fun.cpp
@@ -0,0 +1,180 @@
+#include <iostream>
+#include <stdlib.h>
+#include <octave/oct.h>
+#include <octave/octave.h>
+#include <octave/parse.h>
+#include <octave/interpreter.h>
+#include <math.h>
+#include <string>
+#include "fun.h"
+
+extern "C"
+{
+	int fun(FUNCARGS *inp, FUNCCALL *funcall)
+	{
+
+		static octave::interpreter interpreter;
+		bool status = interpreter.initialized();
+		
+		if(status==false)
+		{
+		interpreter.initialize ();
+		int status_exec = interpreter.execute ();
+
+			if (status_exec != 0)
+			{
+				std::cerr << "creating embedded Octave interpreter failed!"
+						<< std::endl;
+			}
+		}
+		
+		try
+		{	
+			octave_value_list in;
+			unsigned int k;
+			int l;
+			int str_count = 0;
+			char str_fun[20];
+			char str_pkg[20];
+			int pkg=0;
+			int nouts;
+			for(l=0;l<funcall->n_in_arguments;l++)
+			{
+				if(inp[l].type==TYPE_DOUBLE)
+				{
+					if(inp[l].is_in_cmplx==1)
+					{
+						ComplexMatrix matr = ComplexMatrix (inp[l].n_in_rows,inp[l].n_in_cols); 
+						double* id_real = (double *)inp[l].in_data_real;
+						double* id_img = (double *)inp[l].in_data_img;
+						k=0;
+						for (int r=0;r<inp[l].n_in_rows;r++) 
+							{ 
+							for(int c=0;c<inp[l].n_in_cols;c++) 
+								{ 
+								Complex cc(id_real[k],id_img[k]); 
+								matr(r,c) = cc;
+								k++;
+								} 
+							} 
+						in(l-str_count) = octave_value(matr);
+					}
+					else
+					{
+						Matrix inMatrix_x(inp[l].n_in_rows,inp[l].n_in_cols);
+						double* id = (double *)inp[l].in_data_real;
+						k=0;
+						for( unsigned int i = 0; i < inp[l].n_in_rows; i++ )
+						{
+							for( unsigned int j = 0; j < inp[l].n_in_cols; j++ )
+							{
+									inMatrix_x(i, j) = id[k];
+									k++;
+							}
+						}
+						in(l-str_count) = inMatrix_x;
+					}
+				}
+				else if(inp[l].type==TYPE_STRING)
+				{
+					//std::cout << "In fun string. l is : " << l << '\n';
+					
+					char* c = (char *)inp[l].in_data_real;
+					//std::cout << "String is: " << c << '\n';
+					if(l==0)
+						strcpy(str_fun,c);
+					else if(l==1)
+					{
+						strcpy(str_pkg,c);
+						pkg=1;
+					}					
+					else
+						in(l-str_count) = c;
+
+					str_count++;
+					//std::cout << "String is: " << c << '\n';
+				}
+			}
+
+			if(pkg==1)
+			{
+				//std::cout << "loading package " << str_pkg << '\n';
+				octave::feval ("pkg", ovl ("load", str_pkg), 0);
+			}
+
+			octave_value_list out = octave::feval (str_fun, in, funcall->n_out_user);
+
+
+			int row;
+			int col;
+			nouts = out.length();
+			funcall->n_out_arguments = nouts;
+//std::cout << "funcall->n_out_arguments is: " << funcall->n_out_arguments << '\n';
+
+			for( unsigned int ii = 0; ii < nouts; ii++ )
+			{
+				if(out(ii).iscomplex()==1)
+				{
+					inp[ii].is_out_cmplx=1;
+					//std::cout << "out "<< ii<< " is complex" << '\n';
+					ComplexMatrix cmOut(out(ii).complex_matrix_value());
+					//std::cout << "cmOut "<< cmOut << '\n';
+					//std::cout << "Out(ii) "<< out(ii).complex_matrix_value() << '\n';
+					//std::cout << "out(ii) "<< out(ii) << '\n';
+					row = cmOut.rows();
+					col = cmOut.columns();
+					inp[ii].n_out_rows = row;
+					inp[ii].n_out_cols = col;
+					k=0;
+					inp[ii].out_data_real = malloc(sizeof(double)*(row*col));
+					inp[ii].out_data_img = malloc(sizeof(double)*(row*col));
+					double* rd = (double *)inp[ii].out_data_real;
+					double* cd = (double *)inp[ii].out_data_img;
+					for(unsigned int i=0;i<row;i++)
+					{
+						for(unsigned int j=0;j<col;j++)
+						{
+							rd[k]=real(cmOut(k));
+							cd[k]=imag(cmOut(k));
+							//std::cout << "out img "<< k << " is :" << (double)imag(cmOut(k)) << '\n';
+							k++;
+						}
+					}
+				}
+				else
+				{
+					//std::cout << "out "<< ii<< " is NOT complex" << '\n';
+					inp[ii].is_out_cmplx=0;
+					Matrix mOut(out(ii).matrix_value());
+					row = mOut.rows();
+					col = mOut.columns();
+					inp[ii].n_out_rows = row;
+					inp[ii].n_out_cols = col;
+					k=0;
+					inp[ii].out_data_real = malloc(sizeof(double)*(row*col));
+					double* dd = (double *)inp[ii].out_data_real;
+					for(unsigned int i=0;i<row;i++)
+					{
+						for(unsigned int j=0;j<col;j++)
+						{
+							dd[k]=mOut(k);
+							k++;
+						}
+					}
+				}
+			}
+		}
+		catch (const octave::exit_exception& ex)
+		{
+			std::cerr << "Octave interpreter exited with status = "
+					<< ex.exit_status () << std::endl;
+			return 1;
+		}
+		catch (const octave::execution_exception&)
+		{
+			std::cerr << "error encountered in Octave evaluator!" << std::endl;
+			return 1;
+		}
+		return 0;
+	}
+}
diff --git a/src/fun.h b/src/fun.h
new file mode 100644
index 0000000..ac0c166
--- /dev/null
+++ b/src/fun.h
@@ -0,0 +1,38 @@
+#define fun_h__
+//extern "C" int fun (double* answ, double* in1, int in1_row, std::string name, std::string opt);
+
+extern "C"
+{
+
+	typedef enum
+	{
+		TYPE_DOUBLE,
+		TYPE_STRING,
+	}FUNCTYPE;
+
+	typedef struct
+	{
+		FUNCTYPE type;
+		int n_in_rows;
+		int n_in_cols;
+		int n_out_rows;
+		int n_out_cols;
+		int is_in_cmplx;
+		int is_out_cmplx;
+		void* in_data_real;
+		void* in_data_img;
+		void* out_data_real;
+		void* out_data_img;
+	}FUNCARGS;
+	
+	typedef struct {
+	int n_in_arguments; // number of input arguments
+	int n_out_arguments; // number of output arguments
+	int n_out_user; // number of output arguments
+	char *err; // Name
+	//char *package; //Name of octave package to be loaded
+	FUNCARGS *argument;
+} FUNCCALL;
+
+	int fun(FUNCARGS *arr, FUNCCALL *call);
+}
diff --git a/src/fun.o b/src/fun.o
new file mode 100644
index 0000000..b939504
Binary files /dev/null and b/src/fun.o differ
diff --git a/src/libfun.so b/src/libfun.so
new file mode 100755
index 0000000..81fa71f
Binary files /dev/null and b/src/libfun.so differ
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..36be819
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,112 @@
+#include<iostream>
+#include <stdlib.h>
+#include <string.h>
+#include"fun.h"
+//octave_fun("arburg","signal", [1,2,3,4,5],2)
+int main(void)
+{
+	FUNCCALL funcall;
+	FUNCCALL *funptr = &funcall;
+	funcall.n_in_arguments = 2;
+	funcall.n_out_user = 1;
+
+	FUNCARGS ins[funcall.n_in_arguments*funcall.n_out_user];
+	FUNCARGS *argptr = ins;
+	
+	int a;
+	int in_type[4] = {10,1};
+	char str[3][20] = {"hamming","signal"};
+	int si;
+	double* d;
+	int size_double;
+	for(a = 0; a<funcall.n_in_arguments;a++)
+	{
+		if(in_type[a]==1)
+		{
+			ins[a].is_in_cmplx = 0;
+			ins[a].n_in_rows = 1;
+			ins[a].n_in_cols = 1;
+			//if(a>2)
+				//ins[a].n_in_cols = 1;
+			
+			size_double = ins[a].n_in_rows*ins[a].n_in_cols;
+			ins[a].type = TYPE_DOUBLE;
+			ins[a].in_data_real = malloc(sizeof(double)*size_double);
+			d = (double *)ins[a].in_data_real;
+			for(int i=0;i<size_double;i++)
+				d[i] = (i+4);
+		}
+		else if(in_type[a]==10)
+		{
+			if(a==0)
+				si=0;// "hamming";
+			else if(a==1)
+				si=1;// "pkg";
+			else
+				si=2;// "symmetric";
+
+			ins[a].type = TYPE_STRING;
+			int len = strlen(str[si]);
+			ins[a].n_in_rows = 1;
+			ins[a].n_in_cols = len;
+			ins[a].in_data_real = malloc(sizeof(char)*len+1);
+			char* c = (char *)ins[a].in_data_real;
+			strcpy(c,str[si]);
+
+			std::cout << "func string in main is: " << c << '\n';
+		}
+
+	}
+
+	for(int j=0;j<funcall.n_in_arguments;j++)
+	{
+	if(in_type[j]==1)
+		{
+			d = (double *)ins[j].in_data_real;
+			size_double = ins[j].n_in_rows*ins[j].n_in_cols;
+			for(int i=0;i<size_double;i++)
+				std::cout << "input data" << j<< " is: " << d[i] << '\n';
+		}
+	}
+
+	fun(argptr, funptr);
+
+
+
+	for(int j=0;j<funcall.n_out_user;j++)
+	{
+		double* rd = (double *)ins[j].out_data_real;
+		for(int i=0;i<(ins[j].n_out_rows*ins[j].n_out_cols);i++)
+			std::cout << "output data real: " << j<< " is: " << rd[i] << '\n';
+
+		if(ins[j].is_out_cmplx==1)
+		{
+			double* cd = (double *)ins[j].out_data_img;
+			for(int i=0;i<(ins[j].n_out_rows*ins[j].n_out_cols);i++)
+				std::cout << "output data img: " << j<< " is: " << cd[i] << '\n';
+		}
+	}
+
+	std::cout << "ins[0].n_in_rows is: " << ins[0].n_in_rows << '\n';
+	std::cout << "ins[0].n_in_cols is: " << ins[0].n_in_cols << '\n';
+
+	for(int i=0;i<funcall.n_in_arguments;i++)	
+	{
+		free(ins[i].in_data_real);
+
+		if(ins[i].is_in_cmplx==1)
+			free(ins[i].in_data_img);
+	}
+
+	for(int i=0;i<funcall.n_out_user;i++)	
+	{
+		free(ins[i].out_data_real);
+
+		if(ins[i].is_out_cmplx==1)
+			free(ins[i].out_data_img);
+	}
+	//free(ins[1].in_data);
+	//free(ins[2].in_data);
+	//free(ins[0].out_data);
+return 0;
+}
diff --git a/src/testfun b/src/testfun
new file mode 100755
index 0000000..631bb20
Binary files /dev/null and b/src/testfun differ
diff --git a/thirdparty/linux/lib/x64/libfun.so b/thirdparty/linux/lib/x64/libfun.so
index ce9cbce..81fa71f 100755
Binary files a/thirdparty/linux/lib/x64/libfun.so and b/thirdparty/linux/lib/x64/libfun.so differ
-- 
cgit