开始写代码,STEP_1

#include "Vector.h"

void Vector_Initialize(Vector* this)
...{
    this->count = 0;
}

void add(Vector* this, void* obj)
...{
    this->obj[this->count] = obj;
    this->count++;
}

int size(Vector* this)
...{
    return this->count;
}

void* elementAt(Vector* this, int pos)
...{
    return this->obj[pos];
}

void addVector(Vector* this, void* data)
...{
    int i;
    
    for(i = 0;i<size(data);i++)...{
        add(this,elementAt(data,i));
    }
}

 

 

#ifndef VECTOR_H__
#define VECTOR_H__

#define VECTOR_MAX  256

typedef struct...{
    void* obj[VECTOR_MAX];
    int   count;
}Vector;

void Vector_Initialize(Vector* this);

void add(Vector* this, void* obj);

int size(Vector* this);

void* elementAt(Vector* this, int pos);

void addVector(Vector* this, void* data);
#endif

 

 

#include "Numeric.h"

static const CNumeric_VMT vmt = ...{CNumeric_Generate};

void CNumeric_Initialize(CNumeric* this, int val)
...{
    ((CExpression*)this)->vmt = (const CExpression_VMT*)&vmt;
    this->value = val;
}

void CNumeric_Generate(CNumeric* this, FILE* output)
...{
    fprintf(output, "%d", this->value);
}

 

 

#ifndef NUMERIC__H_
#define NUMERIC__H_
#include "Expression.h"
#include <stdio.h>

typedef struct Numeric_t CNumeric;

typedef struct...{
    void (*generate)(CNumeric*, FILE*);
}CNumeric_VMT;

struct Numeric_t...{
     CExpression super;
     int value;
};

extern void CNumeric_Initialize(CNumeric*, int);
extern void CNumeric_Generate(CNumeric*, FILE*);

#endif

 

#include "PrimaryExpression.h"

static const CPrimaryExpression_VMT vmt = ...{ CPrimaryExpression_Generate };

void CPrimaryExpression_Initialize(CPrimaryExpression* this)
...{
    CExpression_Initialize((CExpression*)this);
    ((CExpression*)this)->vmt = (const CExpression_VMT*)&vmt;
}
void CPrimaryExpression_Generate(CPrimaryExpression* this, FILE* output)
...{
    
}

 

 

#ifndef _PRIMARY_EXPRESSION_H
#define _PRIMARY_EXPRESSION_H

#include "Expression.h"
#include <stdio.h>

typedef struct PrimaryExpression_t CPrimaryExpression;

typedef struct...{
  void (*generate)(CPrimaryExpression*, FILE*);
}CPrimaryExpression_VMT;

struct PrimaryExpression_t...{
  CExpression super;
};

extern void CPrimaryExpression_Initialize(CPrimaryExpression*);
extern void CPrimaryExpression_Generate(CPrimaryExpression*, FILE*);
#endif

 

 

#include "Expression.h"

static const CExpression_VMT vmt = ...{CExpression_Generate};

void CExpression_Initialize(CExpression* this)
...{
    ((CExpression*)this)->vmt = (const CExpression_VMT*)&vmt;
}

void CExpression_Generate(CExpression *this, FILE *output)
...{

}

 

 

#ifndef EXPRESSION__H_
#define EXPRESSION__H_
#include <stdio.h>

typedef struct Expression_t CExpression;

typedef struct...{
    void (*generate)(CExpression*, FILE*);    
}CExpression_VMT;

struct Expression_t...{
    const CExpression_VMT *vmt;
};

extern void CExpression_Initialize(CExpression*);

extern void CExpression_Generate(CExpression*, FILE*);

#define Expression_Generate(this, output)
            (((CExpression*)(this))->vmt->generate((CExpression*)(this),output))
#endif

 

 

#include "FunctionCall.h"

static const CFunctionCall_VMT vmt = ...{ CFunctionCall_Generate };

void CFunctionCall_Initialize(CFunctionCall* this, char* name, Vector* parm)
...{
    CPrimaryExpression_Initialize((CPrimaryExpression*)this);
    ((CExpression*)this)->vmt = (const CExpression_VMT*)&vmt;
    this->name = name;
    this->parm = parm;
}

void CFunctionCall_Generate(CFunctionCall* this, FILE* output)
...{
    int i;
    fprintf(output, "%s(", this->name);
    for(i = 0; i< size(this->parm); i++)...{
        Expression_Generate(elementAt(this->parm, i), output);
        if(i < size(this->parm) - 1)...{
            fprintf(output, ",");
        }
    }
    fprintf(output, ")");
}

 

#ifndef FUNCTIONCALL__H_
#define FUNCTIONCALL__H_

#include "PrimaryExpression.h"
#include "Vector.h"
#include <stdio.h>

typedef struct FunctionCall_t CFunctionCall;

typedef struct...{
    void (*generate)(CFunctionCall*,FILE*);
}CFunctionCall_VMT;

struct FunctionCall_t...{
    CPrimaryExpression super;
    char* name;
    Vector *parm;
};

extern void CFunctionCall_Initialize(CFunctionCall*, char*, Vector*);

extern void CFunctionCall_Generate(CFunctionCall*, FILE*);
#endif