dupzap.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 620 行 · 第 1/2 页

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/



#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include "wic.h"


/*============== Duplicate functions ========================*/

static pTokPos _dupPos;

static pCTree _dupCTree(pCTree elem);
static pLabel _dupLabel(pLabel elem);
static pDeclInfo _dupDeclInfo(void *elem);
static pDclr _dupDclr(pDclr elem);
static pDeclStructInfo _dupDeclStructInfo(pDeclStructInfo elem);
static pDeclStructBody _dupDeclStructBody(pDeclStructBody elem);
static pArrElem _dupArrElem(pArrElem elem);
static pDclrPtr _dupDclrPtr(pDclrPtr elem);
static pDeclEnum _dupDeclEnum(pDeclEnum elem);
static pEnumElem _dupEnumElem(void *elem);
static pToken _dupToken(pToken elem);
static pTokPos _dupTokPos(pTokPos elem);
static pTokData _dupTokData(pTokData elem);
static void _zapTokData(pTokData elem);
#define _dupSLList dupSLList

static pCTree _dupCTree(pCTree elem) {
    pCTree newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    newElem->label = _dupLabel(elem->label);
    newElem->child1 = _dupCTree(elem->child1);
    newElem->child2 = _dupCTree(elem->child2);

    return newElem;
}

static pLabel _dupLabel(pLabel elem) {
    pLabel newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    newElem->type = elem->type;
    switch (elem->type) {
    case LABT_LIST:
        newElem->repr.list = _dupSLList(elem->repr.list, (void *(*)(void *))_dupToken);
        break;
    case LABT_TOKEN:
        newElem->repr.token = _dupToken(elem->repr.token);
        break;
    case LABT_CONSTRUCT_ROOT:
        {
            int size = elem->repr.constr.numTokens;
            int i;
            memcpy(&(newElem->repr.constr), &(elem->repr.constr),
                    sizeof elem->repr.constr);
            if (size > 0) {
                newElem->repr.constr.tokens = wicMalloc(size *
                                      sizeof newElem->repr.constr.tokens[0]);
            }
            for (i = 0; i < size; i++) {
                newElem->repr.constr.tokens[i] =
                    _dupToken(elem->repr.constr.tokens[i]);
            }
        }
        break;
    case LABT_DECL_INFO:
        newElem->repr.dinfo = _dupDeclInfo(elem->repr.dinfo);
        break;
    case LABT_DECL_LIST:
        newElem->repr.declList =
                _dupSLList(elem->repr.declList, (void *(*)(void *))_dupDeclInfo);
        break;
    default:
        assert(0);
    }
    return newElem;
}

static pDeclInfo _dupDeclInfo(void *_elem) {
    pDeclInfo elem = _elem;
    pDeclInfo newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    memcpy(newElem, elem, sizeof *newElem);

    newElem->begPunct = _dupToken(elem->begPunct);
    newElem->prefixPos = _dupTokPos(elem->prefixPos);

    switch(elem->type) {
        case DIT_SCALAR:
            newElem->repr.scalar.scalarPos =
                    _dupTokPos(elem->repr.scalar.scalarPos);
            break;

        case DIT_STRUCT_OR_UNION:
            newElem->repr.s = _dupDeclStructInfo(elem->repr.s);
            break;

        case DIT_ENUM:
            newElem->repr.e = _dupDeclEnum(elem->repr.e);
            break;

        case DIT_NULL:
            break;

        default:
            break;
    }
    newElem->dclrList = _dupSLList(elem->dclrList, (void *(*)(void *))_dupDclr);
    newElem->dclr = _dupDclr(elem->dclr);

    return newElem;
}

static pDclr _dupDclr(pDclr elem) {
    pDclr newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    memcpy(newElem, elem, sizeof *newElem);

    newElem->memType = elem->memType;
    newElem->memPos = _dupTokPos(elem->memPos);

    newElem->pragmaMod = _dupToken(elem->pragmaMod);

    newElem->ptr = _dupDclrPtr(elem->ptr);

    newElem->id = _dupToken(elem->id);

    newElem->arrList = _dupSLList(elem->arrList, (void *(*)(void *))_dupArrElem);
    newElem->argBegin = _dupToken(elem->argBegin);
    newElem->args = _dupSLList(elem->args, (void *(*)(void *))_dupDeclInfo);
    newElem->argEnd = _dupToken(elem->argEnd);

    newElem->equalTok = _dupToken(elem->equalTok);
    newElem->initializer = _dupCTree(elem->initializer);

    return newElem;
}

static pDeclStructInfo _dupDeclStructInfo(pDeclStructInfo elem) {
    pDeclStructInfo newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    memcpy(newElem, elem, sizeof *newElem);

    newElem->type = elem->type;
    newElem->typePos = _dupTokPos(elem->typePos);
    newElem->name = _dupToken(elem->name);
    newElem->body = _dupDeclStructBody(elem->body);

    return newElem;
}

static pDeclStructBody _dupDeclStructBody(pDeclStructBody elem) {
    pDeclStructBody newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    memcpy(newElem, elem, sizeof *newElem);

    newElem->declList = _dupSLList(elem->declList, (void *(*)(void *))_dupDeclInfo);
    newElem->endPos = _dupTokPos(elem->endPos);
    return newElem;
}

static pArrElem _dupArrElem(pArrElem elem) {
    pArrElem newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);

    newElem->lBracket = _dupToken(elem->lBracket);
    newElem->constExpr = _dupCTree(elem->constExpr);
    newElem->rBracket = _dupToken(elem->rBracket);

    return newElem;
}

static pDclrPtr _dupDclrPtr(pDclrPtr elem) {
    pDclrPtr newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    memcpy(newElem, elem, sizeof *newElem);

    newElem->memType = elem->memType;
    newElem->qualifiers = elem->qualifiers;
    newElem->pos = _dupTokPos(elem->pos);

    return newElem;
}

static pDeclEnum _dupDeclEnum(pDeclEnum elem) {
    pDeclEnum newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    memcpy(newElem, elem, sizeof *newElem);

    newElem->enumPos = _dupTokPos(elem->enumPos);
    newElem->list = _dupSLList(elem->list, (void *(*)(void *))_dupEnumElem);

    return newElem;
}

static pEnumElem _dupEnumElem(void *_elem) {
    pEnumElem elem = _elem;
    pEnumElem newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    memcpy(newElem, elem, sizeof *newElem);

    newElem->name = _dupToken(elem->name);
    newElem->equal = _dupToken(elem->equal);
    newElem->expression = _dupCTree(elem->expression);

    return newElem;
}

static pToken _dupToken(pToken elem) {
    pToken newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);
    memcpy(newElem, elem, sizeof *newElem);

    newElem->data = _dupTokData(elem->data);
    newElem->pos = _dupTokPos(elem->pos);
    return newElem;
}

static pTokData _dupTokData(pTokData elem) {
    pTokData newElem;
    if (elem == NULL) {
        return NULL;
    }
    newElem = wicMalloc(sizeof *newElem);

    memcpy(newElem, elem, sizeof *newElem);
    if (elem->code == Y_NUMBER) {
        // Nothing to copy
    } else if (elem->code == Y_STRING) {
        newElem->repr.s.s = wicMalloc(elem->repr.s.strLen);
        memcpy(newElem->repr.s.s, elem->repr.s.s, elem->repr.s.strLen);
    } else {
        registerString(elem->repr.string, !FREE_STRING);
    }
    return newElem;
}

static int _firstPosChange;

static pTokPos _dupTokPos(pTokPos elem) {
    pTokPos newElem;
    pTokPos temp;
    int saveSpacesBefore, saveLinesBefore;
    if (elem == NULL) {
        return NULL;