smparcom.c

基于单片机的 snmp协议解析的一些原代码 给有用的 同行

/*
 * Copyright 1992 SynOptics Communications, Inc.  All Rights Reserved.
 * SynOptics grants a non-exclusive license to use, copy, modify, and
 * distribute this software for any purpose and without fee, provided
 * that this copyright notice and license appear on all copies and
 * supporting documentation.
 * SynOptics makes no representations about the suitability of this
 * software for any particular purpose.  The software is supplied
 * "AS IS", and SynOptics makes no warranty, either express or implied,
 * as to the use, operation, condition, or performance of the software.
 * SynOptics retains all title and ownership in the software.
 *
 * file: SMPARCOM.C - parsing support routines common to the compiler
 *                    and all backends.
 *
 * $Revision:   1.3  $ $Date:   08 Jul 1992 17:34:34  $
 * $Log:   R:/MIBTOOLS/V1.0/SMIC/SRC/SMPARCOM.C_V  $
 * 
 *    Rev 1.3   08 Jul 1992 17:34:34   gfoster
 * Removed unnecessary revision comment lines added by
 * PVCS to make revision history easier to read.
 * 
 *    Rev 1.2   29 Jun 1992 19:57:00   gfoster
 * Casted the value "-1L" to "(ULONG)-1L" to prevent
 * signed/unsigned mismatch when assigning "-1" to
 * the ulVal member of the MIBOID data structure.
 * 
 * Changed the incorrect escape sequences in the fprintf
 * statements from "\%s\ ..." to "\"%s\" ...".
 * 
 *    Rev 1.1   19 Jun 1992 16:17:32   gfoster
 * Copyright text was reformated.
 * 
 *    Rev 1.0   27 May 1992 16:12:24   gfoster
 * Initial revision.
 *
*/

#include <stdio.h>

#ifdef MS_DOS
#include <stdlib.h>
#endif /* MS_DOS */

#include <string.h>
#include <ctype.h>

#include "tds.h"
#include "smscdefs.h"
#include "smstdefs.h"
#include "smsydefs.h"
#include "smic.h"


/** initOIDroot - initialize the Root for the OID tree
*
*/
    VOID
#ifdef __STDC__
initOIDroot(VOID)
#else
initOIDroot()
#endif /* __STDC__ */
{
    OidRoot.usType = MIBSYMoid;
    OidRoot.pSym = NULL;
    OidRoot.pMod = NULL;
    OidRoot.pAlist = NULL;
    OidRoot.pszName = "OID_tree_Root";
    OidRoot.usNeed = MIBIEex;
    OidRoot.pBKEdata = NULL;
    OidRoot.usStatus = MIBSTAnu;
    OidRoot.pszDesc = NULL;
    OidRoot.pszRefer = NULL;
    OidRoot.pNext = NULL;

    OidRoot.ut.oid.fDup = FALSE;
    OidRoot.ut.oid.ulVal = 0L;
    OidRoot.ut.oid.pPar = NULL;
    OidRoot.ut.oid.pChild = NULL;
    OidRoot.ut.oid.pSib = NULL;
    OidRoot.ut.oid.usOType = MIBOToid;
    OidRoot.ut.oid.syn.usSyntax = MIBSYNnu;
    OidRoot.ut.oid.syn.usi.pSI = NULL;
    OidRoot.ut.oid.syn.usSizeRange = MIBSRno;
    OidRoot.ut.oid.usAccess = MIBACCnu;
    OidRoot.ut.oid.pIndxL = NULL;
    OidRoot.ut.oid.cIndx = 0;
    OidRoot.ut.oid.pDefSeq = NULL;
    OidRoot.ut.oid.rsyn.usSyntax = MIBSYNnu;
    OidRoot.ut.oid.rsyn.usi.pSI = NULL;
    OidRoot.ut.oid.rsyn.usSizeRange = MIBSRno;
    OidRoot.ut.oid.usDefVal = MIBDFVno;

} /* initOIDroot */


/** newOID - allocate a new oid object
*
* ??NOTE: change to allocate only space needed
*
* call with:
*   pNa - name of oid object
*   pMod - module containing object
*
* returns:
*   ptr to oid object or NULL if error
*/
MIBSYM *newOID(STRTAB *pNa, MIBSYM *pMod)
	{
   MIBSYM *pOid;
   MIBSYM *pS;
   int err;

   pOid = (MIBSYM *)malloc(sizeof(MIBSYM));
   if (pOid != NULL)
   	{
      err = AllocMemAdd(pOid);
      if (err)
      	{
         free(pOid);
         pOid = NULL;
         }
      else
      	{
         cOidUsed++;

         /* init fields */
         pOid->usType = MIBSYMoid | MIBSYMFR; /* make forward reference */
         pOid->pSym = pNa->pSym;
         pNa->pSym = pOid;
         pOid->pMod = pMod;
         pOid->pAlist = NULL;
         pOid->pszName = pNa->pszVal;
         pOid->usStatus = MIBSTAnu;
         pOid->usNeed = MIBIEns;
         pOid->pBKEdata = NULL;
         pOid->pszDesc = NULL;
         pOid->pszRefer = NULL;
         pOid->pNext = NULL;

         pOid->ut.oid.fDup = FALSE;
         for (pS = pOid->pSym; pS != NULL; pS = pS->pSym)
         	{
         	if ((pS->usType & MIBSYMmask) == MIBSYMoid)
            	{
               pOid->ut.oid.fDup = TRUE;
               pS->ut.oid.fDup = TRUE;
               break;
           		}
         	}
         pOid->ut.oid.ulVal = (ULONG)-1L;
         pOid->ut.oid.pPar = NULL;
         pOid->ut.oid.pChild = NULL;
         pOid->ut.oid.pSib = NULL;
         pOid->ut.oid.usOType = MIBOToid;
         pOid->ut.oid.syn.usSyntax = MIBSYNnu;
         pOid->ut.oid.syn.usi.pSI = NULL;
         pOid->ut.oid.syn.usSizeRange = MIBSRno;
         pOid->ut.oid.syn.usr.ulRange[0] = 0L;
         pOid->ut.oid.syn.usr.ulRange[1] = 0L;
         pOid->ut.oid.usAccess = MIBACCnu;
         pOid->ut.oid.pIndxL = NULL;
         pOid->ut.oid.cIndx = 0;
         pOid->ut.oid.pDefSeq = NULL;
         pOid->ut.oid.rsyn.usSyntax = MIBSYNnu;
         pOid->ut.oid.rsyn.usi.pSI = NULL;
         pOid->ut.oid.rsyn.usSizeRange = MIBSRno;
         pOid->ut.oid.rsyn.usr.ulRange[0] = 0L;
         pOid->ut.oid.rsyn.usr.ulRange[1] = 0L;
         pOid->ut.oid.usDefVal = MIBDFVno;
         pOid->ut.oid.udv.ulDefVal = 0L;

         /* link to end of global list of oid objects */
         if (pOidGHL == NULL)
         	{
           	/* list empty */
           	pOidGHL = pOid;
         	}
         else
         	{
         	/* add to end */
           	pOidGTL->pNext = pOid;
         	}
         pOidGTL = pOid;
         }
      }
   return(pOid);
	} /* newOID */
#if 0
    MIBSYM *
#ifdef __STDC__
newOID(STRTAB *pNa, MIBSYM *pMod)
#else
newOID(pNa, pMod)
    STRTAB *pNa;
    MIBSYM *pMod;
#endif /* __STDC__ */
{
    MIBSYM *pT;
    MIBSYM *pOid;
    MIBSYM *pS;
    USHORT i;


    /* check if any available */
    if (pOidAvail == NULL) {
        /* none avail - so allocate some */
        pOidAvail = (MIBSYM *)malloc(sizeof(MIBSYM)*MIBOIDACT);
        if (pOidAvail == NULL) {
            yyerror("newOID: out of heap memory");
            yystats();
            yyterm();
            return(NULL);
        }
        cOidAlloc += MIBOIDACT;
        /* put oid objects in list */
        for (pT = pOidAvail, i = 1; i < MIBOIDACT; i++, pT++) {
            pT->pNext = pT+1;
        }
        pT->pNext = NULL;
    }

    /* get oid object from list */
    pOid = pOidAvail;
    pOidAvail = pOidAvail->pNext;
    cOidUsed++;

    /* init fields */
    pOid->usType = MIBSYMoid | MIBSYMFR; /* make forward reference */
    pOid->pSym = pNa->pSym;
    pNa->pSym = pOid;
    pOid->pMod = pMod;
    pOid->pAlist = NULL;
    pOid->pszName = pNa->pszVal;
    pOid->usStatus = MIBSTAnu;
    pOid->usNeed = MIBIEns;
    pOid->pBKEdata = NULL;
    pOid->pszDesc = NULL;
    pOid->pszRefer = NULL;
    pOid->pNext = NULL;

    pOid->ut.oid.fDup = FALSE;
    for (pS = pOid->pSym; pS != NULL; pS = pS->pSym) {
        if ((pS->usType & MIBSYMmask) == MIBSYMoid) {
            pOid->ut.oid.fDup = TRUE;
            pS->ut.oid.fDup = TRUE;
            break;
        }
    }
    pOid->ut.oid.ulVal = (ULONG)-1L;
    pOid->ut.oid.pPar = NULL;
    pOid->ut.oid.pChild = NULL;
    pOid->ut.oid.pSib = NULL;
    pOid->ut.oid.usOType = MIBOToid;
    pOid->ut.oid.syn.usSyntax = MIBSYNnu;
    pOid->ut.oid.syn.usi.pSI = NULL;
    pOid->ut.oid.syn.usSizeRange = MIBSRno;
    pOid->ut.oid.syn.usr.ulRange[0] = 0L;
    pOid->ut.oid.syn.usr.ulRange[1] = 0L;
    pOid->ut.oid.usAccess = MIBACCnu;
    pOid->ut.oid.pIndxL = NULL;
    pOid->ut.oid.cIndx = 0;
    pOid->ut.oid.pDefSeq = NULL;
    pOid->ut.oid.rsyn.usSyntax = MIBSYNnu;
    pOid->ut.oid.rsyn.usi.pSI = NULL;
    pOid->ut.oid.rsyn.usSizeRange = MIBSRno;
    pOid->ut.oid.rsyn.usr.ulRange[0] = 0L;
    pOid->ut.oid.rsyn.usr.ulRange[1] = 0L;
    pOid->ut.oid.usDefVal = MIBDFVno;
    pOid->ut.oid.udv.ulDefVal = 0L;

    /* link to end of global list of oid objects */
    if (pOidGHL == NULL) {
        /* list empty */
        pOidGHL = pOid;
    } else {
        /* add to end */
        pOidGTL->pNext = pOid;
    }
    pOidGTL = pOid;

    return(pOid);

} /* newOID */
#endif

/** newMOD - allocate a module
*
* ??NOTE: change to allocate only space needed
*
* call with:
*   pNa - name of module
*
* returns:
*   ptr to module name or NULL if error
*/
MIBSYM *newMOD(STRTAB *pNa)
	{
   MIBSYM *pMod;
   int err;

   pMod = (MIBSYM *)malloc(sizeof(MIBSYM));
   if (pMod != NULL)
   	{
      err = AllocMemAdd(pMod);
      if (err)
      	{
         free(pMod);
         }
      else
      	{
         cModUsed++;

         /* init fields */
         pMod->usType = MIBSYMmod;
         pMod->pSym = pNa->pSym;
         pNa->pSym = pMod;
         pMod->pMod = NULL;
         pMod->pAlist = NULL;
         pMod->pszName = pNa->pszVal;
         pMod->usStatus = MIBSTAnu;
         pMod->usNeed = MIBIEns;
         pMod->pBKEdata = NULL;
         pMod->pszDesc = NULL;
         pMod->pszRefer = NULL;
         pMod->pNext = NULL;

         pMod->ut.mod.pImodHL = NULL;
         pMod->ut.mod.pImodTL = NULL;

         /* link to end of global list of modules */
         if (pModGHL == NULL) {
           /* list empty */
           pModGHL = pMod;
         } else {
           /* add to end */
           pModGTL->pNext = pMod;
         }
         pModGTL = pMod;
#if 0
         /* init fields */
         pMod->usType = MIBSYMmod;
         pMod->pSym = pNa->pSym;
         pNa->pSym = pMod;
         pMod->pMod = NULL;
         pMod->pAlist = NULL;
         pMod->pszName = pNa->pszVal;
         pMod->usStatus = MIBSTAnu;
         pMod->usNeed = MIBIEns;
         pMod->pBKEdata = NULL;
         pMod->pszDesc = NULL;
         pMod->pszRefer = NULL;
         pMod->pNext = NULL;

         pMod->ut.mod.pImodHL = NULL;
         pMod->ut.mod.pImodTL = NULL;

         /* link to end of global list of modules */
         if (pModGHL == NULL)
         	{
         	/* list empty */
         	pModGHL = pMod;
         	}
         else
         	{
           	/* add to end */
         	pModGTL->pNext = pMod;
         	}
         pModGTL = pMod;
#endif
         }
      }
   return (pMod);
   }
#if 0
    MIBSYM *
#ifdef __STDC__
newMOD(STRTAB *pNa)
#else
newMOD(pNa)
    STRTAB *pNa;
#endif /* __STDC__ */
{
    MIBSYM *pT;
    MIBSYM *pMod;
    USHORT i;

    /* check if any available */
    if (pModAvail == NULL) {
        /* none avail - so allocate some */
        pModAvail = (MIBSYM *)malloc(sizeof(MIBSYM)*MIBMODACT);
        if (pModAvail == NULL) {
            yyerror("newMOD: out of heap memory");
            yystats();
            yyterm();
            return(NULL);
        }
        cModAlloc += MIBMODACT;
        /* put modules in list */
        for (pT = pModAvail, i = 1; i < MIBMODACT; i++, pT++) {
            pT->pNext = pT+1;
        }
        pT->pNext = NULL;
    }

    /* get module from list */
    pMod = pModAvail;
    pModAvail = pModAvail->pNext;
    cModUsed++;

    /* init fields */
    pMod->usType = MIBSYMmod;
    pMod->pSym = pNa->pSym;
    pNa->pSym = pMod;
    pMod->pMod = NULL;
    pMod->pAlist = NULL;
    pMod->pszName = pNa->pszVal;
    pMod->usStatus = MIBSTAnu;
    pMod->usNeed = MIBIEns;
    pMod->pBKEdata = NULL;
    pMod->pszDesc = NULL;
    pMod->pszRefer = NULL;
    pMod->pNext = NULL;

    pMod->ut.mod.pImodHL = NULL;
    pMod->ut.mod.pImodTL = NULL;

    /* link to end of global list of modules */
    if (pModGHL == NULL) {
        /* list empty */
        pModGHL = pMod;
    } else {
        /* add to end */
        pModGTL->pNext = pMod;
    }
    pModGTL = pMod;

    return(pMod);
} /* newMOD */
#endif

/** newMODREF - allocate a new module reference for an import
*
* call with:
*   pMod - module containing the import
*
* returns:
*   ptr to new module reference or NULL if an error
*/
MIBMODREF *newMODREF(MIBSYM *pMod)
	{
   MIBMODREF *pModRef;
   int err;

   pModRef = (MIBMODREF *)malloc(sizeof(MIBMODREF));
   if (pModRef != NULL)
		{
      err = AllocMemAdd(pModRef);
      if (err)
      	{
         free(pModRef);
         pModRef = NULL;
         }
      else
      	{
         cModRefUsed++;

         /* init fields */
         pModRef->pMod = NULL;
         pModRef->pImpIL = NULL;
         pModRef->cImpi = 0;
         pModRef->pNext = NULL;

         /* add to tail of list for module */
         if (pMod->ut.mod.pImodHL == NULL)
         	{
           	/* list empty */
           	pMod->ut.mod.pImodHL = pModRef;
         	}
         else
         	{
           	/* add to end */
           	(pMod->ut.mod.pImodTL)->pNext = pModRef;
         	}
         pMod->ut.mod.pImodTL = pModRef;
         }
      }
	return(pModRef);
	}
#if 0
    MIBMODREF *
#ifdef __STDC__
newMODREF(MIBSYM *pMod)
#else
newMODREF(pMod)
    MIBSYM *pMod;
#endif /* __STDC__ */
{
    MIBMODREF *pT;
    MIBMODREF *pModRef;
    USHORT i;

    /* check if any available */
    if (pModRefAvail == NULL) {
        /* none avail - so allocate some */
        pModRefAvail = (MIBMODREF *)malloc(sizeof(MIBMODREF)*MIBMODREFACT);
        if (pModRefAvail == NULL) {
            yyerror("newMODREF: out of heap memory");
            yystats();
            yyterm();
            return(NULL);
        }
        cModRefAlloc += MIBMODREFACT;
        /* put modules in list */
        for (pT = pModRefAvail, i = 1; i < MIBMODREFACT; i++, pT++) {
            pT->pNext = pT+1;