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

Loading in 2 Seconds...

play fullscreen
1 / 29

An Improved C Calling Interface for Unicon Language - PowerPoint PPT Presentation

  • Uploaded on

Udaykumar Batchu Advisor: Dr. Clinton Jeffery. An Improved C Calling Interface for Unicon Language. A Brief Introduction to the Unicon Language. Is a high level programming language Derives Its name from Icon, originated from University of Arizona

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'An Improved C Calling Interface for Unicon Language' - libitha

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
a brief introduction to the unicon language
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
basic data types of unicon
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
unicon structures
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++
string scanning in unicon
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


str ? {

while tab(upto(&letters))do



writes out all the set of words found in the string str

procedures in unicon
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


introduction to the problem
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


  • Automate the whole process mentioned above
  • Make it easier to call external C functions inside Unicon programs
earlier mechanism
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
earlier mechanism contd
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
earlier mechanism steps followed
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

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;


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 */


steps to be followed contd
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 “libcfunc.so”

Step 4) Creation of Icon/Unicon Stub:

procedure fibonacci(a[]) #:Fibonacci

if fibonacci := pathload("libcfunc.so", "fibonacciwrap") then

return fibonacci(n)


  • 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
calling c function from unicon
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) )


  • “libcfunc.so” is the shared library file, where we can find the C function ‘fibonacci’ to be loaded dynamically at runtime using loadfunc
improved mechanism overview
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
improved mechanism contd
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
implementation changes to the unicon language
Implementation: Changes to the Unicon Language

Unicon Source Program

Unicon Preprocessor




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
improved mechanism example
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)



{ fibonacci.o {int fib(int)} }


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

improved mechanism in detail
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))




{ fact.o { int factorialfunc (int ) },

classavg.o { double myaverage(double, double)},

checkpalin.o { int palindrome( char) } }


Start of the external C function declarations

C function signatures

End of the external C function declarations

wrapper code generation
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 );


icon unicon stubs
Icon/Unicon Stubs


procedure myaverage(a[]) #calculates myaverage


About the Shared Library -ctest1.so

  • 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
parameter declaration for arrays
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.
example involving arrays
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)



{ bubblesort.o { void bubbleSort(int[], int[], int) },

arrayavg.o { double Caverage(double[], int) } }


Calling external C functions inside Unicon

Start of the external C function declaration

End of the external C function declarations

wrapper code for arrays 1
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;


wrapper code for arrays 2
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 );


macros used for wrapper code generation
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
  • 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
future work
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
  • 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