Download

An Improved C Calling Interface for Unicon Language






Advertisement
/ 29 []
Download Presentation
Comments
libitha
From:
|  
(3913) |   (1) |   (0)
Views: 9402 | Added:
Rate Presentation: 1 0
Description:
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 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -




Slide 1

Udaykumar Batchu

Advisor: Dr. Clinton Jeffery

An Improved C Calling Interface for Unicon Language

Slide 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

Slide 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

Slide 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++

Slide 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

Slide 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

Slide 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

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

    Slide 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

    Slide 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

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

    }

    Slide 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 “libcfunc.so”

      Step 4) Creation of Icon/Unicon Stub:

      procedure fibonacci(a[]) #:Fibonacci

      if fibonacci := pathload("libcfunc.so", "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

    Slide 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

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

    Slide 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

    Slide 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

    Slide 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 2.6.11.4) environment and is easily portable to other platforms

    • Existing Macros for handling Integers, Reals and Strings are used

    Slide 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

    Slide 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

    Slide 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 );

    }

    Slide 20

    Icon/Unicon Stubs

    #myaverage.c

    procedure myaverage(a[]) #calculates myaverage

    return(myaverage:=pathload("ctest1.so","myaveragewrap"))!a;end

    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

    Slide 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.

    Slide 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

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

    }

    Slide 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 );

    }

    Slide 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

    Slide 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

    Slide 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

    Slide 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

    Slide 29

    Thank You


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