///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Recorre una funcion.
// Parametros:
// - pFunc. Funcion a imprimir.
// Devuelve:
// Notas:
///////////////////////////////////////////////////////////////////////////////
void
ReleaseFunc(sFunc* pFunc)
{
// ¿Hay funcion?
if (pFunc) {
switch (pFunc->eFuncType) {
case FUNC_SEQ: {
ReleaseFunc(pFunc->FuncSeq.pFirst);
ReleaseFunc(pFunc->FuncSeq.pSecond);
} break;
case FUNC_DECL: {
ReleaseType(pFunc->FuncDecl.pType);
ReleaseArgument(pFunc->FuncDecl.pArguments);
ReleaseConst(pFunc->FuncDecl.pConst);
ReleaseVar(pFunc->FuncDecl.pVar);
ReleaseStm(pFunc->FuncDecl.pStm);
Mem_Free(pFunc->FuncDecl.szIdentifier);
Mem_Free(pFunc->FuncDecl.szSignature);
SymTableRelease(pFunc->FuncDecl.pSymTable);
ReleaseLabelList(pFunc->FuncDecl.pLabelList,
pFunc->FuncDecl.unNumLabels);
ReleaseOpcodeList(pFunc->FuncDecl.pOpcodeList);
} break;
}; // ~ switch
// Borra el nodo
Mem_Free(pFunc);
}
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Recorre delcaracion de variables.
// - En caso de que las vbles no tengan inicializacion por defecto, se les
// asociara segun sea su tipo.
// Parametros:
// - pVar. Declaracion de variables
// Devuelve:
// Notas:
///////////////////////////////////////////////////////////////////////////////
void
ReleaseVar(sVar* pVar)
{
// ¿Hay variables?
if (pVar) {
switch(pVar->VarType) {
case VAR_TYPEDECL_SEQ: {
ReleaseVar(pVar->VarTypeDeclSeq.pFirst);
ReleaseVar(pVar->VarTypeDeclSeq.pSecond);
} break;
case VAR_TYPEDECL: {
ReleaseType(pVar->VarTypeDecl.pType);
ReleaseVar(pVar->VarTypeDecl.pVarIdentSeq);
} break;
case VAR_IDENTIFIERDECL_SEQ: {
ReleaseExp(pVar->VarIdentDeclSeq.pValue);
ReleaseVar(pVar->VarIdentDeclSeq.pSigIdent);
Mem_Free(pVar->VarIdentDeclSeq.szIdentifier);
} break;
}; // ~ switch
// Borra nodo
Mem_Free(pVar);
}
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Recorre argumentos
// Parametros:
// - pArgument. Argumentos a imprimir
// Devuelve:
// Notas:
///////////////////////////////////////////////////////////////////////////////
void
ReleaseArgument(sArgument* pArgument)
{
// ¿Hay argumentos para imprimir?
if (pArgument) {
ReleaseArgument(pArgument->pSigArgument);
ReleaseType(pArgument->pType);
Mem_Free(pArgument->szIdentifier);
Mem_Free(pArgument);
}
}
bool
typeIsEnumType(Oid typeoid)
{
Type tup = typeidType(typeoid);
Form_pg_type typeform;
bool res = false;
typeform = (Form_pg_type) GETSTRUCT(tup);
if (typeform->typtype == 'e' && typeform->typinput == F_ENUM_IN)
res = true;
ReleaseType(tup);
return res;
}
bool
typeIsArrayType(Oid typeoid)
{
Type tup = typeidType(typeoid);
Form_pg_type typeform;
bool res = false;
typeform = (Form_pg_type)GETSTRUCT(tup);
if (typeform->typelem != InvalidOid &&
typeform->typtype != 'd' &&
NameStr(typeform->typname)[0] == '_' &&
typeform->typinput == F_ARRAY_IN)
res = true;
ReleaseType(tup);
return res;
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Recorre declaraciones const
// Parametros:
// - pConst. Declaraciones const
// Devuelve:
// Notas:
///////////////////////////////////////////////////////////////////////////////
void
ReleaseConst(sConst* pConst)
{
// ¿Hay declaraciones?
if (pConst) {
switch(pConst->ConstType) {
case CONST_DECLSEQ: {
ReleaseConst(pConst->ConstSeq.pFirst);
ReleaseConst(pConst->ConstSeq.pSecond);
} break;
case CONST_DECL: {
ReleaseType(pConst->ConstDecl.pType);
ReleaseExp(pConst->ConstDecl.pExp);
Mem_Free(pConst->ConstDecl.szIdentifier);
} break;
}; // ~ switch
// Borra nodo
Mem_Free(pConst);
}
}
