A Template Class In C

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct templateStructure
{
        signed int mcsi_row;
        signed int mcsi_col;
        signed int mcsi_type;
        char *mcpc_ptr;
        //void (*init)(templateStructure *,const char*,const int,const int);
        void (*mcfn_get)(struct templateStructure *,const int ,const int,void *);
        void (*mcfn_set)(struct templateStructure *,const int,const int,const void *);
};
typedef struct templateStructure template_t;
typedef template_t* template_p;

void fnG_set(template_p StL_obj,const int iL_row,const int iL_col,const void *val)
{
        char *pvL_tmpPtr;
        pvL_tmpPtr =StL_obj->mcpc_ptr + (((StL_obj->mcsi_col*StL_obj->mcsi_type)*iL_row)+(iL_col*StL_obj->mcsi_type));
        memcpy(pvL_tmpPtr,val,StL_obj->mcsi_type);
}

void fnG_get(template_p StL_obj,const int iL_row,const int iL_col,void *val)
{
        char *pvL_tmpPtr;
        pvL_tmpPtr =StL_obj->mcpc_ptr + ((((StL_obj->mcsi_col)*(StL_obj->mcsi_type))*(iL_row))+((iL_col)*(StL_obj->mcsi_type)));
        memcpy(val,pvL_tmpPtr,StL_obj->mcsi_type);
}

int fnG_initTemplate(template_p StL_obj,const char *pcL_type,const int iL_row,const int iL_col)
{
        StL_obj->mcsi_row=iL_row;
        StL_obj->mcsi_col=iL_col;
        if(strcmp(pcL_type,"int")==0)
        {
                StL_obj->mcsi_type=sizeof(int);
                StL_obj->mcpc_ptr=(char *)malloc((sizeof(int)*iL_row)*iL_col);
        }
        else if(strcmp(pcL_type,"char")==0)
        {
                StL_obj->mcsi_type=sizeof(char);
                StL_obj->mcpc_ptr=(char *)malloc((sizeof(char)*iL_row)*iL_col);
        }
        else if(strcmp(pcL_type,"float")==0)
        {
                StL_obj->mcsi_type=sizeof(float);
                StL_obj->mcpc_ptr=(char *)malloc((sizeof(float)*iL_row)*iL_col);
        }
        StL_obj->mcfn_get=fnG_get;
        StL_obj->mcfn_set=fnG_set;
}

int main(int argc,char* argv[],char* envp[])
{
        char val='a';
        char val1='z';
//      int val=1000;
//      int val1=999;
        template_t myObj;
        printf("val=%c and val1=%c\n",val,val1);
        //printf("val=%d and val1=%d\n",val,val1);
        fnG_initTemplate(&myObj,"char",4,3);//use to define different type at run time 
        //fnG_initTemplate(&myObj,"int",4,3);//use to define different type at run time 
        myObj.mcfn_set(&myObj,0,3,&val1);
        printf("val=%c and val1=%c \n",val,val1);
        myObj.mcfn_get(&myObj,0,3,&val);
        printf("val=%c and val1=%c \n",val,val1);
        //printf("val=%d and val1=%d\n",val,val1);
        return 0;
}

CALLING ASSEMBLY DELAY ROUTINE FROM C SOURCE CODE

THIS POST IS ALL ABOUT HOW TO CALL AN ASSEMBLY ROUTINE FROM C SOURCE CODE

I PRESENT A EXAMPLE BELOW

THERE IS THREE FILES
1) DELAYS.ASM
2)DELAY_MAIN.C
3)DELAY_HEADER.H

DELAYS.ASM
------------------------------------------------------------------------------------------------------------

;;

;THIS IS A ASSEMBLY LANGUAGE ROUTINES WHICH GENERATING

; 1MILI SEC,500MILI SEC

;AND 1SEC ROUTINES.

;THIS ROUTINES CAN BE CALLED FROM C LANGUAGE USING BELOW FORMATS

;FOR 1 MILI SEC:: void delay_1_ms(void);

;FOR 500 MILI SEC:: void delay_500_ms(void);

;FOR 1 SEC:: void delay_1_sec(void);

;FILE NAME:DELAYS.ASM

;AUTHOR::RAJESH KUMAR SAHOO

;SKYPE ID:rajesh6115

;face book:www.facebook.com/rajesh6115

;                                  ;                                  ;





?PR?del_seg SEGMENT CODE

    PUBLIC delay_1_ms

    PUBLIC delay_500_ms

    PUBLIC delay_1_sec

    RSEG ?PR?del_seg

delay_1_ms:

    MOV R7,#250

    DJNZ R7,$

    MOV R7,#247

    DJNZ R7,$

    RET

delay_500_ms:

    MOV R6,#250

L1_500:

    ACALL delay_1_ms

    DJNZ R6,L1_500

    

    MOV R6,#248

L2_500:

    ACALL delay_1_ms

    DJNZ R6,L2_500

    MOV R6,#250

    DJNZ R6,$

    MOV R6,#247

    DJNZ R6,$

    NOP

    NOP

    RET

delay_1_sec:

    MOV R5,#8

LO_SEC:

    MOV R6,#124

LI_SEC:

    ACALL delay_1_ms

    DJNZ R6,LI_SEC

    DJNZ R5,LO_SEC

    MOV R5,#5

L_SEC:    

    ACALL delay_1_ms

    DJNZ R5,L_SEC

    MOV R5,#250

    DJNZ R5,$

    MOV R5,#237

    DJNZ R5,$

    RET

    END

  

---------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------
DELAY_MAIN.C
---------------------------------------------------------------------------------------------------------------
/**
*THIS IS A C SOURCE CODE FROM WHERE ASSEMBLY ROUTINES ARE CALLED
*FILE NAME: DELAY_MAIN.C
*
*/

#include <reg51.h>
#include "delays_header.h"
void main()
{
    delay_1_sec();
    delay_500_ms();
    delay_1_ms();

    delay_1_sec();
}

---------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------
DELAY_HEADER.H
---------------------------------------------------------------------------------------------------------------

#ifndef _delay_h_
#define _delay_h_

void delay_1_ms(void);
void delay_500_ms(void);
void delay_1_sec(void);

#endif

---------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------
THE HOLE EXAMPLE PROJECT YOU CAN DOWNLOAD FROM HERE
DOWNLOAD HERE

USING OF DELAY IN A ASSEMBLY PROGRAM

;;
;THIS PROGRAM CALL DELAY ROUTINES AVAILABLE IN
; DELAY.ASM FILE(SEE PREVIOUS POST)
;
;FILE NAME: DELAY_DEMO.ASM
;DELAY.ASM FILE MUST PRESENT IN THE PROJECT FOLDER
;                      ;                            ;


$INCLUDE(delay1ms.asm)
CSEG AT 0H
MAIN:
ACALL DELAY1MS
SJMP $
END

DELAY GENERATION USING ASSEMBLY INSTRUCTIONS

;THIS IS AN ASSEMBLY LANGUAGE PROGRAM FOR GENERATION OF DELAY
;FILE NAME : DELAY.ASM
;COMPILED WITH KEIL IDE
;CRYSTAL:12MHZ USED
;THIS FILE USED WHEN EVER DELAY REQUIRED
;JUST YOU HAVE TO INCLUDE THIS FILE TO YOUR SOURCE PROGRAM
;                    ;                    ;
;ALL DELAYS ROUTINES HERE
DELAY_SEG SEGMENT CODE
RSEG DELAY_SEG
;DELAY OF 1MS SUBROUTINE
DELAY1MS:
MOV R7,#250
DJNZ R7,$
MOV R7,#247
DJNZ R7,$
RET
;DELAY OF 100MS SUBROUTINE
DELAY100MS:
MOV R6,#99;1MUS
L1:
ACALL DELAY1MS ;99MS
DJNZ R6,L1;198MUS
MOV R6,#250;1MUS
DJNZ R6,$;500US
MOV R6,#147;1US
DJNZ R6,$;294US
NOP
RET;1US
;DELAY 0F 1SEC SUB ROUTINE
DELAY1S:
MOV R5,#9
L2:
ACALL DELAY100MS
DJNZ R5,L2
MOV R5,#99
L3:
ACALL DELAY1MS
DJNZ R5,L3
MOV R5,#250
DJNZ R5,$
MOV R5,#138
DJNZ R5,$
RET

QUEUE IMPLEMENTED USING ARRAY IN C

/**
 *THIS PROGRAM IS A REPRESENTATION OF QUEUE IMPLEMENTATION.
 *HERE AN ARRAY USED TO RE-PRESENT A QUEUE
 *AND BASIC QUEUE OPERATION ARE DESCRIBED USING SOME BASIC FUNCTION
 *MENU DRIVEN FOR BETTER UNDERSTANDING
 *
 *
 *FILE NAME :queue_using_array.c
 *DATE      :08/09/2012
 *PROGMMER  :RAJESH KUMAR SAHOO.
 *BOLOG     :http://dsforeverystudent.blogspot.in/
 */

/*
   header files for function prototypes of inbuild library functions
 */

/*Program for queue using array*/
/*headers for avoid compile error and warnings*/
#include <stdio.h>
#include <stdlib.h>
/*macros used for easy modification*/
#define QUE_SIZE 10
#define INVALID -1
#define BEG 0
/*function prototypes*/
void init(void);
int menu(void);
void enque(int ele);
int deque(void);
void print(void);

/*global datas*/
int QUEUE[QUE_SIZE];
int end;
/*INITIALIZE THE QUEUE FOR OPERATION(CLEARING THE CONTENTS)*/
void init()
{
        end=INVALID;
        int i;
        for(i=0;i<QUE_SIZE;i++)
                QUEUE[i]=INVALID;
}

/*THIS FUNCTION IS USED FOR ENQUE AN ELEMENT(INSERT TO QUEUE)*/
void enque(int ele)
{
        if(end>=QUE_SIZE-1)
        {
                printf("\nQUEUE IS ALREDY FILLED\n");
                return;
        }
        ++end;
        QUEUE[end]=ele;
        printf("\n%d ENQUE TO THE QUEUE\n",ele);
}

/*THIS FUNCTION USED FOR DE-QUE OPERATION(PROCESS/REMOVE AN ELEMENT FROM QUEUE)*/
int deque(void)
{
        int ele,i;
        ele=INVALID;
        if(end==INVALID)
        {
                printf("\nQUEUE IS EMPTY\n");
                return ele;
        }
        ele=QUEUE[BEG];
        for(i=1;i<=end;i++)
        {
                QUEUE[i-1]=QUEUE[i];
        }
        --end;
        //printf("\n%d IS DEQUQ FROM QUEUE\n",ele);
        return ele;
}

/*THIS FUNCTION USED TO PRINT THE QUEUE ELEMENTS FOR VERIFICATION*/
void print(void)
{
        int i;
        if(end==INVALID)
        {
                printf("\nQUEUE IS EMPTY\n");
                return;
        }
        else
                printf("\n:::::::::::QUEUE:::::::::\n|BEG|");

        for(i=BEG;i<=end;i++)
        {
                if(i==end)
                        printf("%d|END|",QUEUE[i]);
                else
                        printf("%d<-",QUEUE[i]);
        }
}

/*MAIN FUNCTION TO CONTROL THE FLOW OF PROGRAM*/
int main()
{
        int choice,ele;
        init();
        while(1)
        {
                choice=menu();
                switch(choice)
                {
                        case 1:printf("\nEnter a number for enqueue: ");
                               scanf("%d",&ele);enque(ele);break;
                        case 2:ele=deque();
                               if(ele!=INVALID)
                                       printf("\n%d IS DEQUQ FROM QUEUE\n",ele);break;
                        case 3:print();break;
                        case 4:exit(0);break;
                        default:
                               printf("\nINVALID CHOICE\nTRY AGAIN.....\n");break;
                }
        }
}

/*THIS FUNCTION USED TO DISPLAY MENU IN THE OUTPUT DEVICE AND GETTING USER CHOICE*/
int menu()
{
        int choice;
        printf("\n:::::::::::MENU::::::::::::\n");
        printf("\n1.ENQUE\n2.DEQUE\n3.PRINT\n4.EXIT\n");
        printf("\nENTER YOUR CHOICE: ");
        scanf("%d",&choice);
        return choice;
}