An Improved C Calling Interface for Unicon Language

/ 29 []
Download Presentation
(3913) |   (1) |   (0)
Views: 9427 | Added:
Rate Presentation: 1 0
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
An Improved C Calling Interface for Unicon Language

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

Download Policy: Content on the Website is provided to you AS IS for your information and personal use only and may not be sold or licensed nor shared on other sites. SlideServe reserves the right to change this policy at anytime. 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 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Udaykumar batchu advisor dr clinton jefferySlide 1

Udaykumar Batchu

Advisor: Dr. Clinton Jeffery

An Improved C Calling Interface for Unicon Language

A brief introduction to the unicon languageSlide 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

Basic data types of uniconSlide 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

Unicon structuresSlide 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++

String scanning in uniconSlide 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


    str ? {

    while tab(upto(&letters))do



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

Procedures in uniconSlide 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


Introduction to the problemSlide 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


  • Automate the whole process mentioned above

  • Make it easier to call external C functions inside Unicon programs

  • Earlier mechanismSlide 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

    Earlier mechanism contdSlide 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

    Earlier mechanism steps followedSlide 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

    Project presentation slides in pptSlide 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;


    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 contdSlide 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)


    • 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 uniconSlide 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) )


    • “” is the shared library file, where we can find the C function ‘fibonacci’ to be loaded dynamically at runtime using loadfunc

    Improved mechanism overviewSlide 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

    Improved mechanism contdSlide 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

    Implementation changes to the unicon languageSlide 16

    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 exampleSlide 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)



    { 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 detailSlide 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))




    { 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 generationSlide 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 );


    Icon unicon stubsSlide 20

    Icon/Unicon Stubs


    procedure myaverage(a[]) #calculates myaverage


    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

    Parameter declaration for arraysSlide 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.

    Example involving arraysSlide 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)



    { 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 1Slide 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;


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


    Macros used for wrapper code generationSlide 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

    LimitationsSlide 26


    • 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 workSlide 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

    ConclusionSlide 28


    • 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

    Thank youSlide 29

    Thank You

    Copyright © 2015 SlideServe. All rights reserved | Powered By DigitalOfficePro