mex.c

比较新的功能强大的rsa算法源代码,方便使用.

/* mex.c
 *
 * Updated to allow emission of scheduled code. 
 *
 * Macro EXpansion program.
 * Expands Macros from a .mcs file into a .tpl file to create a .c file
 *
 *  Copyright (c) 2002 Shamus Software Ltd.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef int BOOL;
#define FALSE 0
#define TRUE 1

/* Define Algorithms */

#define MULTIPLY 0
#define MULTUP 1
#define SQUARE 2
#define REDC 3
#define ADDITION 4
#define INCREMENT 5
#define SUBTRACTION 6
#define DECREMENT 7
#define SUMMATION 8
#define INCREMENTATION 9
#define DECREMENTATION 10
#define MULTIPLY2 11
#define ADDITION2 12
#define SUBTRACTION2 13
#define PMULT 14
#define DOUBLEIT 15


/* Define Macros */

#define MUL_START       0
#define STEP            1
#define STEP1M          2
#define STEP1A          3
#define STEP2M          4
#define STEP2A          5
#define MFIN            6
#define MUL_END         7
#define LAST            8
#define SQR_START       9
#define DSTEP           10
#define DSTEP1M         11
#define DSTEP1A         12
#define DSTEP2M         13
#define DSTEP2A         14
#define SELF            15
#define SFIN            16
#define SQR_END         17
#define REDC_START      18
#define RFINU           19
#define RFIND           20
#define REDC_END        21
#define ADD_START       22
#define ADD             23
#define ADD_END         24
#define SUB_START       25
#define SUB             26
#define SUB_END         27
#define INC_START       28
#define INC             29
#define INC_END         30
#define DEC_START       31
#define DEC             32
#define DEC_END         33
#define KADD_START      34
#define KASL            35
#define KADD_END        36
#define KINC_START      37
#define KIDL            38
#define KINC_END        39
#define KDEC_START      40
#define KDEC_END        41
#define STEPB           42
#define STEPB1M         43
#define STEPB1A         44
#define STEPB2M         45
#define STEPB2A         46
#define H2_MUL_START    47
#define H2_STEP         48
#define H2_MFIN         49
#define H2_MUL_END      50
#define H2_SQR_START    51
#define H2_DSTEP        52
#define H2_SELF         53
#define H2_SFIN         54
#define H2_SQR_END      55
#define H4_MUL_START    56
#define H4_STEP         57
#define H4_MFIN         58
#define H4_MUL_END      59
#define H4_SQR_START    60
#define H4_DSTEP        61
#define H4_SELF         62
#define H4_SFIN         63
#define H4_SQR_END      64
#define H2_LAST         65
#define H4_LAST         66 
#define PMUL_START      67
#define PMUL            68
#define PMUL_END        69
#define MULB_START      70
#define MULB_END        71
#define MBFIN           72
#define H2_MULB_START   73
#define H2_MULB_END     74
#define H2_MBFIN        75
#define H2_STEPB        76
#define H4_MULB_START   77
#define H4_MULB_END     78
#define H4_MBFIN        79
#define H4_STEPB        80
#define H2_REDC_START   81
#define H2_RFINU        82
#define H2_RFIND        83
#define H2_REDC_END     84
#define H4_REDC_START   85
#define H4_RFINU        86
#define H4_RFIND        87
#define H4_REDC_END     88
#define DOUBLE_START    89
#define DOUBLE          90
#define DOUBLE_END      91
#define LAST_ONE        92

BOOL scheduled;
int hybrid,hybrid_b,pmp,hybrid_r;

int PARAM;
char *macro[LAST_ONE]; /* macro text */ 

char *functions[]={"MULTIPLY","MULTUP","SQUARE","REDC","ADDITION","INCREMENT",
                 "SUBTRACTION","DECREMENT","SUMMATION","INCREMENTATION",
                 "DECREMENTATION","MULTIPLY2","ADDITION2","SUBTRACTION2","PMULT","DOUBLEIT",NULL};

char *names[]={"MUL_START","STEP","STEP1M","STEP1A","STEP2M",
               "STEP2A","MFIN","MUL_END","LAST","SQR_START","DSTEP",
               "DSTEP1M","DSTEP1A","DSTEP2M","DSTEP2A","SELF",
               "SFIN","SQR_END","REDC_START","RFINU","RFIND",
               "REDC_END","ADD_START","ADD","ADD_END","SUB_START","SUB",
               "SUB_END","INC_START","INC","INC_END","DEC_START","DEC",
               "DEC_END","KADD_START","KASL","KADD_END","KINC_START","KIDL",
               "KINC_END","KDEC_START","KDEC_END","STEPB","STEPB1M","STEPB1A","STEPB2M","STEPB2A",
               "H2_MUL_START","H2_STEP","H2_MFIN","H2_MUL_END",
               "H2_SQR_START","H2_DSTEP","H2_SELF","H2_SFIN","H2_SQR_END",
               "H4_MUL_START","H4_STEP","H4_MFIN","H4_MUL_END",
               "H4_SQR_START","H4_DSTEP","H4_SELF","H4_SFIN","H4_SQR_END","H2_LAST","H4_LAST",
                "PMUL_START","PMUL","PMUL_END","MULB_START","MULB_END","MBFIN",
                "H2_MULB_START","H2_MULB_END","H2_MBFIN","H2_STEPB",
                "H4_MULB_START","H4_MULB_END","H4_MBFIN","H4_STEPB",
                "H2_REDC_START","H2_RFINU","H2_RFIND","H2_REDC_END",
                "H4_REDC_START","H4_RFINU","H4_RFIND","H4_REDC_END",
                "DOUBLE_START","DOUBLE","DOUBLE_END",NULL};

BOOL white(char c)
{
    if (c==' ' || c=='\n' || c=='\r' || c=='\t') return TRUE;
    else return FALSE;
}

int skip(char *c,int i)
{
    while (white(c[i])) i++;
    return i;
}

int which(char *name,char *names[])
{
    int ipt=0;  
    while (names[ipt]!=NULL)
    {
        if (strcmp(name,names[ipt])==0) return ipt;
        ipt++;
    }
    return -1;
}

void m_prologue(FILE *dotc,int k,int m)
{
    fprintf(dotc,macro[STEP1M],k,m); 
}

void m_epilogue(FILE *dotc,int x)
{
    if (x==1) fprintf(dotc,macro[STEP1A]);
    else      fprintf(dotc,macro[STEP2A]);
}

void m_schedule(FILE *dotc,int x,int k,int m)
{
    if (x==1)
    {
        fprintf(dotc,macro[STEP2M],k,m);
        fprintf(dotc,macro[STEP1A]);
    }
    else
    {
        fprintf(dotc,macro[STEP1M],k,m);
        fprintf(dotc,macro[STEP2A]);
    }
}

void m_prologue2(FILE *dotc,int k,int m)
{
    fprintf(dotc,macro[STEPB1M],k,m); 
}

void m_epilogue2(FILE *dotc,int x)
{
    if (x==1) fprintf(dotc,macro[STEPB1A]);
    else      fprintf(dotc,macro[STEPB2A]);
}

void m_schedule2(FILE *dotc,int x,int k,int m)
{
    if (x==1)
    {
        fprintf(dotc,macro[STEPB2M],k,m);
        fprintf(dotc,macro[STEPB1A]);
    }
    else
    {
        fprintf(dotc,macro[STEPB1M],k,m);
        fprintf(dotc,macro[STEPB2A]);
    }
}

void s_prologue(FILE *dotc,int k,int m)
{
    fprintf(dotc,macro[DSTEP1M],k,m);
}

void s_epilogue(FILE *dotc,int x)
{
    if (x==1) fprintf(dotc,macro[DSTEP1A]);
    else      fprintf(dotc,macro[DSTEP2A]);
}

void s_schedule(FILE *dotc,int x,int k,int m)
{
    if (x==1)
    {
        fprintf(dotc,macro[DSTEP2M],k,m);
        fprintf(dotc,macro[DSTEP1A]);
    }
    else
    {
        fprintf(dotc,macro[DSTEP1M],k,m);
        fprintf(dotc,macro[DSTEP2A]);
    }
}

/* Insert functions into template file */

void insert(int index,FILE *dotc)
{
    int i,j,k,m,n,x,inc;
    switch (index)
    {
    case PMULT:
        if (!pmp) break;
        fprintf(dotc,macro[PMUL_START]);
        for (i=0;i<PARAM;i++)
        {
            fprintf(dotc,macro[PMUL],i,i,i);
        }
        fprintf(dotc,macro[PMUL_END]);
        break;
    case MULTIPLY2:
        inc=1;
        if (hybrid_b)
        {
            inc=hybrid_b;
            if (hybrid_b==2)  fprintf(dotc,macro[H2_MULB_START]);
            if (hybrid_b==4)  fprintf(dotc,macro[H4_MULB_START]);
        }
        else fprintf(dotc,macro[MULB_START]);
        for (i=n=0;i<PARAM;i+=inc,n+=inc)
        {    
            k=0; m=i;
            if (scheduled)
            {
                x=1;
                m_prologue2(dotc,k,m);
                k++; m--;

                while (k<=i)
                {
                    m_schedule2(dotc,x,k,m);
                    k++; m--;
                    x=3-x;
                }

                m_epilogue2(dotc,x);

            }
            else
            {
                while (k<=i)
                {
                    if (hybrid_b)
                    {
                        if (hybrid_b==2) fprintf(dotc,macro[H2_STEPB],k,k,m,m);
                        if (hybrid_b==4) fprintf(dotc,macro[H4_STEPB],k,k,k,k,m,m,m,m);
                    }
                    else fprintf(dotc,macro[STEPB],k,m);
                    k+=inc; m-=inc;
                }

            }
            if (hybrid_b) 
            {
                if (hybrid_b==2) fprintf(dotc,macro[H2_MBFIN],n,n+1);
                if (hybrid_b==4) fprintf(dotc,macro[H4_MBFIN],n,n+1,n+2,n+3);
            }
            else fprintf(dotc,macro[MBFIN],n);

        }
        for (i=0;i<PARAM-inc;i+=inc,n+=inc)
        {
            k=i+inc; m=PARAM-inc;
            if (scheduled)
            {
                x=1;
                m_prologue2(dotc,k,m);
                k++; m--;

                while (k<=PARAM-1)
                {
                    m_schedule2(dotc,x,k,m);
                    k++; m--;
                    x=3-x;
                }
                m_epilogue2(dotc,x);
            }
            else
            {
                while (k<=PARAM-inc)
                {
                    if (hybrid_b)
                    {
                        if (hybrid_b==2) fprintf(dotc,macro[H2_STEPB],k,k,m,m);
                        if (hybrid_b==4) fprintf(dotc,macro[H4_STEPB],k,k,k,k,m,m,m,m);
                    }
                    else fprintf(dotc,macro[STEPB],k,m);
                    k+=inc; m-=inc;
                }
            }
            if (hybrid_b) 
            {
                if (hybrid_b==2) fprintf(dotc,macro[H2_MBFIN],n,n+1);
                if (hybrid_b==4) fprintf(dotc,macro[H4_MBFIN],n,n+1,n+2,n+3);
            }
            else fprintf(dotc,macro[MBFIN],n);
    
        }

        if (hybrid_b) 
        {
            if (hybrid_b==2) fprintf(dotc,macro[H2_MULB_END],2*PARAM-2);
            if (hybrid_b==4) fprintf(dotc,macro[H4_MULB_END],2*PARAM-4,2*PARAM-3,2*PARAM-2);
        }
        else fprintf(dotc,macro[MULB_END]);
    break;
    case MULTIPLY: 
        inc=1;
        if (hybrid)
        {
            inc=hybrid;
            if (hybrid==2)  fprintf(dotc,macro[H2_MUL_START]);
            if (hybrid==4)  fprintf(dotc,macro[H4_MUL_START]);
        }
        else fprintf(dotc,macro[MUL_START]);
        for (i=n=0;i<PARAM;i+=inc,n+=inc)
        {    
            k=0; m=i;

            if (scheduled)
            {
                x=1;
                m_prologue(dotc,k,m);
                k++; m--;

                while (k<=i)
                {
                    m_schedule(dotc,x,k,m);
                    k++; m--;
                    x=3-x;
                }

                m_epilogue(dotc,x);

            }
            else
            {
                while (k<=i)
                {
                    if (hybrid)
                    {
                        if (hybrid==2) fprintf(dotc,macro[H2_STEP],k,k,m,m);
                        if (hybrid==4) fprintf(dotc,macro[H4_STEP],k,k,k,k,m,m,m,m);
                    }
                    else fprintf(dotc,macro[STEP],k,m);
                    k+=inc; m-=inc;
                }
            }
            if (hybrid) 
            {
                if (hybrid==2) fprintf(dotc,macro[H2_MFIN],n,n+1);
                if (hybrid==4) fprintf(dotc,macro[H4_MFIN],n,n+1,n+2,n+3);
            }
            else fprintf(dotc,macro[MFIN],n);
        }
        for (i=0;i<PARAM-inc;i+=inc,n+=inc)
        {
            k=i+inc; m=PARAM-inc;

            if (scheduled)
            {
                x=1;
                m_prologue(dotc,k,m);
                k++; m--;

                while (k<=PARAM-1)
                {
                    m_schedule(dotc,x,k,m);
                    k++; m--;
                    x=3-x;
                }
                m_epilogue(dotc,x);
            }
            else
            {
                while (k<=PARAM-inc)
                {
                    if (hybrid)
                    {
                        if (hybrid==2) fprintf(dotc,macro[H2_STEP],k,k,m,m);
                        if (hybrid==4) fprintf(dotc,macro[H4_STEP],k,k,k,k,m,m,m,m);
                    }
                    else fprintf(dotc,macro[STEP],k,m);
                    k+=inc; m-=inc;
                }
            }
            if (hybrid) 
            {
                if (hybrid==2) fprintf(dotc,macro[H2_MFIN],n,n+1);
                if (hybrid==4) fprintf(dotc,macro[H4_MFIN],n,n+1,n+2,n+3);
            }
            else fprintf(dotc,macro[MFIN],n);
        }
        if (hybrid) 
        {
            if (hybrid==2) fprintf(dotc,macro[H2_MUL_END],2*PARAM-2,2*PARAM-1);
            if (hybrid==4) fprintf(dotc,macro[H4_MUL_END],2*PARAM-4,2*PARAM-3,2*PARAM-2,2*PARAM-1);
        }
        else fprintf(dotc,macro[MUL_END],2*PARAM-1);
        break;
    case MULTUP:
        inc=1;
        if (hybrid)
        {
            inc=hybrid;
            if (hybrid==2)  fprintf(dotc,macro[H2_MUL_START]);
            if (hybrid==4)  fprintf(dotc,macro[H4_MUL_START]);
        }
        else fprintf(dotc,macro[MUL_START]);

        for (i=n=0;i<PARAM-inc;i+=inc,n+=inc)
        {    
            k=0; m=i;

            if (scheduled)
            {   
                x=1;
                m_prologue(dotc,k,m);
                k++; m--;

                while (k<=i)
                {
                    m_schedule(dotc,x,k,m);
                    k++; m--;
                    x=3-x;
                }
                m_epilogue(dotc,x);
            }
            else
            {
                while (k<=i)
                {
                    if (hybrid)
                    {
                        if (hybrid==2) fprintf(dotc,macro[H2_STEP],k,k,m,m);
                        if (hybrid==4) fprintf(dotc,macro[H4_STEP],k,k,k,k,m,m,m,m);
                    }
                    else fprintf(dotc,macro[STEP],k,m);
                    k+=inc; m-=inc;
                }
            }
            if (hybrid) 
            {
                if (hybrid==2) fprintf(dotc,macro[H2_MFIN],n,n+1);
                if (hybrid==4) fprintf(dotc,macro[H4_MFIN],n,n+1,n+2,n+3);
            }
            else fprintf(dotc,macro[MFIN],n);
        }
        k=0; m=PARAM-inc;
        while (k<=i)
        {
            if (hybrid)
            {
                if (hybrid==2) fprintf(dotc,macro[H2_LAST],k,k,m,m);
                if (hybrid==4) fprintf(dotc,macro[H4_LAST],k,k,k,k,m,m,m,m);