udaykumar batchu advisor dr clinton jeffery n.
Skip this Video
Loading SlideShow in 5 Seconds..
An Improved C Calling Interface for Unicon Language PowerPoint Presentation
Download Presentation
An Improved C Calling Interface for Unicon Language

An Improved C Calling Interface for Unicon Language

9736 Vues Download Presentation
Télécharger la présentation

An Improved C Calling Interface for Unicon Language

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Udaykumar Batchu Advisor: Dr. Clinton Jeffery An Improved C Calling Interface for Unicon Language

  2. A Brief Introduction to the Unicon Language • Is a high level programming language • Derives Its name from Icon, originated from University of Arizona • Offers support for various data types, structures, procedures, high-level graphics functions and object oriented facilities • Easy for application development involving objects, networks and databases and simpler syntax than C and many other high level languages • Is highly portable

  3. Basic Data Types of Unicon All the basic data types are Immutable • Integers: size of long int; are of arbitrary precision • Real: double-precision floating point values • String: similar to C; includes escape sequences and special characters • Cset: character sets represented within single quotes

  4. Unicon Structures Unicon provides four different types of structures. All can hold heterogeneous values • Lists: useful for representing arrays, queues, linked lists and stacks; declared with list() function • Tables: similar to associative arrays; declared with table() function • Records: similar C structures; declared with record() function • Sets: used for holding unordered collection of values; declared with set() function • Classes: similar to classes found in C++

  5. String Scanning in Unicon str ? expression • str is the subject string used for string scanning operations • expression is/are the set of operations to be performed on str • nested string scanning expressions are possible • can design flexible and readable string scanning expressions • easier regular expressions and pattern matching actions • Unicon provides a variety functions for use with string scanning e.g. str ? { while tab(upto(&letters))do write(tab(many(&letters))) } writes out all the set of words found in the string str

  6. Procedures in Unicon • Procedures in Unicon are declared with the keyword procedure • procedure main()is the start of any Unicon program • All parameters are passed by value except for structures • parameter types are not declared; they are intuitive e.g. sample Unicon procedure procedure array(i, j, x) local L L := list(i) every !L := list(j, x) return L end

  7. Introduction to the Problem Goal: Using the existing code written in C language, inside Unicon Programs Earlier Mechanism: • Support was available only for few data types • Manual Updating of Makefile and shared library • Wrapper code need to be hand written • Building and linking the shared library for calling C functions Mission: • Automate the whole process mentioned above • Make it easier to call external C functions inside Unicon programs

  8. Earlier Mechanism • C functions were called with • pathload (filename, funcname) filename – shared library name containing the C function funcname – name of the C function • pathload uses loadfunc which in turn uses dynamic loading and loads the external C function dynamically at runtime • Making entries into the Makefile; building it for Shared library creation or updating the existing one

  9. Earlier Mechanism contd… Supplying files to Makefile: FUNCS = bitcount.o files.o fpoll.o internal.o lgconv.o osf.o \ pack.o ppm.o process.o tconnect.o fibonacci.o CSRC = bitcount.c files.c fpoll.c internal.c lgconv.c osf.c \ pack.c ppm.c process.c tconnect.c fibonacci.c FUNCS: Object files CSRC: C language Source files • UNIX Shell scripts were used for building the shared library and Icon/Unicon stubs

  10. Earlier Mechanism - Steps followed • Write or locate the C code to be called • For the C function(s) to be called, the programmer needs to write wrapper code using macros present in “icall.h” header file • Build (Update) the shared library with an entry for the new C function • Write a Unicon/Icon stub procedure to call the wrapper function: which is used for data type conversions • Link the external C function inside the Unicon program

  11. Steps to be Followed Step 1)Example: C code for Fibonacci Series using recursion: fibonacci.c int fibonacci(int n) { if(n<2)return 1; else return (fibonacci(n-1) + fibonacci(n-2)); } Step 2) Wrapper Code for Fibonacci: fibonacciwrap.c int fibonacciwrap(int argc, descriptor *argv) { unsigned long v; int n; ArgInteger(1); /* validate type */ v = IntegerVal(argv[1]); /* convert to C type */ n = fibonacci(v); RetInteger(n); /* return the value to Unicon */ }

  12. Steps to be Followed - contd… Step 3) Building the Shared Library • Compile the above two files and update the makefile to create a shared called “” Step 4) Creation of Icon/Unicon Stub: procedure fibonacci(a[]) #:Fibonacci if fibonacci := pathload("", "fibonacciwrap") then return fibonacci(n) end • The above entry is created in “cfunc.icn” under /unicon/ipl/cfuncs/ during the updation of shared library Step 5) Linking the external C Program • Adding the statement ‘link cfunc’ inside the Unicon program for calling the external C function

  13. Calling C function from Unicon Example Unicon Program: “foo.icn” using “fibonacci” from C function link cfunc procedure main() local i write("Enter value for fibonacci") i := read() write("Value of Fibonacci is:", fibonacci(i) ) end • “” is the shared library file, where we can find the C function ‘fibonacci’ to be loaded dynamically at runtime using loadfunc

  14. Improved Mechanism - Overview New Preprocessor Directives and more • “$libc” and “$libcend” preprocessor directives within which external C functions can be declared • Providing room for function signatures for the external C functions being used in Unicon with these new preprocessor directives • External C function signatures are grabbed as a string and processed within the preprocessor

  15. Improved Mechanism contd… • Automatic wrapper code generation along with Icon/Unicon stubs takes place during preprocessing stage of compilation • Unicon translator also builds the Shared library for loading the external C functions used inside the Unicon program • Each Unicon (*.icn) program has its own shared library built when C functions are used in it. • Support is provided for basic data types such as: Integers, Real’s and Characters along with Integer and Real Arrays

  16. Implementation: Changes to the Unicon Language Unicon Source Program Unicon Preprocessor cincludesparser make_library icon_stub Automatic Wrapper Code generation Building the shared library Generation of Icon/Unicon stubs • Preprocessor code is modified at /unicon/uni/preproce.icn • Macros used for handling arrays are tweaked at /unicon/src/runtime/rstruct.r • All the work is developed under 32-bit Linux (Kernel Version environment and is easily portable to other platforms • Existing Macros for handling Integers, Reals and Strings are used

  17. Improved Mechanism – example Beginning place for external C code procedure main() local a, b a :=4 b := fib(a) write(“the fibonacci value for”, a, “ is:”, b) end $libc { fibonacci.o {int fib(int)} } $libcend Name of the object file to look for the external C function Signature of the C function with return types and function parameter types End of external C code

  18. Improved Mechanism in Detail Calling the external C functions inside Unicon e.g. test1.icn – Unicon program calling C functions procedure main() local i, j, str write("enter two variables i and j :") i := read() j := read() write("enter the string for palindrome check: ") str := read() write("the avg of i and j is***********: ", myaverage(i, j)) write("the factorial of number i is****: ", factorialfunc(i)) palindrome(str) end $libc { fact.o { int factorialfunc (int ) }, classavg.o { double myaverage(double, double)}, checkpalin.o { int palindrome( char) } } $libcend Start of the external C function declarations C function signatures End of the external C function declarations

  19. Wrapper code generation Wrapper Code for the functions present classavg.o library #include <stdio.h> #include "MyIcall.h" double myaverage(double, double); int myaveragewrap(int argc, descriptor *argv) { double returnValue; double arg1; double arg2; ArgReal( 1 ); arg1 = RealVal( argv[ 1 ] ); ArgReal( 2 ); arg2 = RealVal( argv[ 2 ] ); returnValue = myaverage( arg1, arg2 ); RetReal( returnValue ); }

  20. Icon/Unicon Stubs #myaverage.c procedure myaverage(a[]) #calculates myaverage return(myaverage:=pathload("","myaveragewrap"))!a;end About the Shared Library • Library contains the entries for all external C functions used inside a particular Unicon program, here it is test1.icn • pathload () in turn calls loadfunc() to load the external C funtion dynamically at run time • The stubs become written procedures of a Unicon program written for the compiler • Programmers’ burden is heavily reduced

  21. Parameter Declaration for Arrays • format for declaring a function parameter to be a single dimensional array is • data type followed by array indices ‘[]’ • look like: int[] or double[] • When array indices are found for a function parameter type • wrapper code for handling arrays is generated by the Unicon translator • support is provided for both integer and real arrays.

  22. Example involving Arrays # test2.icn – Program using C functions having single dimensional arrays as parameters procedure main() local elements, sorted, size, loop, avg write("enter the size of the array: ") size := integer(read()) elements := list(size, 0) dblelements := list(size, 0) - - bubbleSort(elements, sorted, size) avg := Caverage(dblelements, size) write("the list after getting sorted is:") every write(!elements) write("the average of the list of doubles is--> ", avg) End $libc { bubblesort.o { void bubbleSort(int[], int[], int) }, arrayavg.o { double Caverage(double[], int) } } $libcend Calling external C functions inside Unicon Start of the external C function declaration End of the external C function declarations

  23. Wrapper code for Arrays - 1 #bubbleSortwrap.c – Wrapper code generated for the C function bubbleSort #include <stdio.h> #include "MyIcall.h" int bubbleSort(int[], int); int bubbleSortwrap(int argc, descriptor *argv) { int *arg1; int arg2; ArgList( 1 ); arg1 = (int *) malloc((int) ListLen( argv[ 1 ] )* sizeof(int)); IListVal( argv[ 1 ],arg1 ); ArgInteger( 2 ); arg2 = IntegerVal( argv[ 2 ] ); bubbleSort( arg1, arg2 ); IValList( arg1, argv[ 1 ] ); return 0; }

  24. Wrapper code for Arrays - 2 #arrayavgwrap.c – Wrapper code for the C function Caverage #include <stdio.h> #include "MyIcall.h" double Caverage(double[], int); int Caveragewrap(int argc, descriptor *argv) { double returnValue; double *arg1; int arg2; ArgList( 1 ); arg1 = (double *) malloc((int) ListLen( argv[ 1 ] )* sizeof(double)); RListVal( argv[ 1 ],arg1 ); ArgInteger( 2 ); arg2 = IntegerVal( argv[ 2 ] ); returnValue = Caverage( arg1, arg2 ); RetReal( returnValue ); }

  25. Macros Used for Wrapper Code Generation • Macros help in converting Unicon descriptors to equivalent C data types and vice versa • Basic descriptor looks as: • typedef long word; • typedef struct { word dword, vword; } descriptor; • dword has the information about its type • vword stores the actual value • Macros are provided are for handling Various Unicon data types: Integer, Real, Character and Arrays • ArgList for validating List data type • IListVal and RListVal: takes a Unicon list descriptor and convert them to an array of integers or reals • IValList and RValList: copy back the contents of C array of integers or reals into Unicon list structure

  26. Limitations • Unicon strings are Immutable: modifying values of the string variables when passed to C functions is not possible • Programmer should take care of wrapper code when using string manipulation functions inside Unicon • Support is provided only for Integer and Real arrays

  27. Future Work • Making the C function calling inside Unicon into a Inline capability • Extending the support for C structures (struct *) and Union data types inside Unicon

  28. Conclusion • New preprocessor directives make it easier for calling external C functions inside Unicon • Different data types such as Integer, Real, Character and single dimensional Array types for Integers and Reals are supported • New interface eliminates writing the wrapper code • Shared library is automatically built by the Preprocessor • Icon/Unicon stubs generated automatically are passed to the Unicon program

  29. Thank You