//=========================================================================
scx::ScriptRef* RenderMarkupContext::script_op(const scx::ScriptAuth& auth,
const scx::ScriptRef& ref,
const scx::ScriptOp& op,
const scx::ScriptRef* right)
{
if (op.type() == scx::ScriptOp::Lookup) {
const std::string name = right->object()->get_string();
// Methods
if ("print" == name ||
"print_esc" == name ||
"print_json" == name ||
"escape" == name ||
"urlencode" == name ||
"urldecode" == name ||
"random_string" == name ||
"get_articles" == name ||
"process_article" == name ||
"edit_article" == name ||
"template" == name ||
"get_files" == name ||
"abort" == name) {
return new scx::ScriptMethodRef(ref,name);
}
// Sub-objects
if ("request" == name)
return m_request->ref_copy(ref.reftype());
if ("response" == name)
return m_response->ref_copy(ref.reftype());
if ("session" == name)
return new scx::ScriptRef(m_request->object()->get_session());
if ("local_addr" == name) {
scx::Socket* socket = dynamic_cast<scx::Socket*>(&m_output);
if (!socket) return 0;
return new scx::ScriptRef(socket->get_local_addr()->new_copy());
}
if ("remote_addr" == name) {
//NOTE: At the moment this is only ever likely to be a StreamSocket,
// but this may change in the future, who knows?
scx::StreamSocket* socket = dynamic_cast<scx::StreamSocket*>(&m_output);
if (!socket) return 0;
return new scx::ScriptRef(socket->get_remote_addr()->new_copy());
}
if ("realms" == name) { // for convenience access to http.realms
scx::Module::Ref http = scx::Kernel::get()->get_module("http");
DEBUG_ASSERT(http.valid(),"http module should be loaded");
scx::ScriptList::Ref largs(new scx::ScriptList());
largs.object()->give(scx::ScriptString::new_ref("realms"));
scx::ScriptRef* realms =
http.script_op(auth,scx::ScriptOp::Lookup,&largs);
return realms;
}
if ("article" == name) {
if (!m_article)
return scx::ScriptError::new_ref("No article");
return m_article->ref_copy(ref.reftype());
}
if ("profile" == name)
return new scx::ScriptRef(m_profile);
}
return scx::ScriptObject::script_op(auth,ref,op,right);
}
bool JavaVirtualMachine::StartJVM() {
Platform& platform = Platform::GetInstance();
Package& package = Package::GetInstance();
TString classpath = package.GetClassPath();
JavaOptions options;
options.AppendValue(_T("-Djava.class.path"), classpath);
options.AppendValue(_T("-Djava.library.path"), package.GetPackageAppDirectory() + FilePath::PathSeparator() + package.GetPackageLauncherDirectory());
options.AppendValue(_T("-Djava.launcher.path"), package.GetPackageLauncherDirectory());
options.AppendValue(_T("-Dapp.preferences.id"), package.GetAppID());
options.AppendValues(package.GetJVMArgs());
options.AppendValues(RemoveTrailingEquals(package.GetJVMUserArgs()));
TString maxHeapSizeOption;
TString minHeapSizeOption;
if (package.GetMemoryState() == PackageBootFields::msAuto) {
TPlatformNumber memorySize = package.GetMemorySize();
TString memory = PlatformString((size_t)memorySize).toString() + _T("m");
maxHeapSizeOption = TString(_T("-Xmx")) + memory;
options.AppendValue(maxHeapSizeOption, _T(""));
if (memorySize > 256)
minHeapSizeOption = _T("-Xms256m");
else
minHeapSizeOption = _T("-Xms") + memory;
options.AppendValue(minHeapSizeOption, _T(""));
}
TString mainClassName = package.GetMainClassName();
if (mainClassName.empty() == true) {
Messages& messages = Messages::GetInstance();
platform.ShowError(messages.GetMessage(NO_MAIN_CLASS_SPECIFIED));
return false;
}
JavaLibrary javaLibrary(package.GetJVMLibraryFileName());
#ifndef USE_JLI_LAUNCH
if (package.HasSplashScreen() == true) {
options.AppendValue(TString(_T("-splash:")) + package.GetSplashScreenFileName(), _T(""));
}
// Set up the VM init args
JavaVMInitArgs jvmArgs;
memset(&jvmArgs, 0, sizeof(JavaVMInitArgs));
jvmArgs.version = JNI_VERSION_1_6;
jvmArgs.options = options.ToJavaOptions();
jvmArgs.nOptions = (jint)options.GetCount();
jvmArgs.ignoreUnrecognized = JNI_TRUE;
if (javaLibrary.JavaVMCreate(&FJvm, &FEnv, &jvmArgs) == true) {
try {
JavaClass mainClass(FEnv, Helpers::ConvertIdToJavaPath(mainClassName));
JavaStaticMethod mainMethod = mainClass.GetStaticMethod(_T("main"), _T("([Ljava/lang/String;)V"));
std::list<TString> appargs = package.GetArgs();
JavaStringArray largs(FEnv, appargs);
package.FreeBootFields();
mainMethod.CallVoidMethod(1, largs.GetData());
return true;
}
catch (JavaException& exception) {
platform.ShowError(PlatformString(exception.what()).toString());
return false;
}
}
return false;
}
node *lambda (node *args, node *sexp) {
node *ptr = newnode(LAMBDA);
largs(ptr) = args;
lbody(ptr) = sexp;
return ptr;
}
bool MatchingImplementation::module_matching_with_star_and_valueconstraints(
const ParamModule& module,
const PatternModule& pattern,
ArgList& l)
{
if (pattern.isStar()){
size_t patternsize = pattern.argSize();
if (patternsize == 0) return true;
if (patternsize == 1) {
size_t modulesize = module.argSize();
const LsysVar& v = pattern.getAt(0);
if(v.isArgs()) {
ArgList largs;
if(v.isNamed() || v.hasCondition()){ // if necessary we retrieve the args
ArgsCollector::append_arg(largs,bp::object(module.name()));
ArgsCollector::append_modargs(largs,module.getParameterList());
}
// we check the condition
if(!v.isCompatible(toPyList(largs))) return false;
// we add the params to the result list
if(v.isNamed()) ArgsCollector::append_as_arg(l,largs);
return true;
}
else if(v.isKwds()) {
if( module.getNamedParameterNb() != module.size()) {
return false;
}
boost::python::dict lkwds;
if(v.isNamed() || v.hasCondition()){ // if necessary we retrieve the args
lkwds[boost::python::object("name")] = boost::python::object(module.name());
module.getNamedParameters(lkwds);
}
// we check the condition
if(!v.isCompatible(lkwds))return false;
// we add the params to the result list
if(v.isNamed()) ArgsCollector::append_arg(l,lkwds);
return true;
}
else {
if(modulesize == 0){
// we get the name
boost::python::object largs(module.name());
// we check the condition
if (!v.isCompatible(largs)) return false;
// we add the params to the result list
if (v.isNamed()) ArgsCollector::append_arg(l,largs);
return true;
}
else return false;
}
}
else { // patternsize > 2
size_t modulesize = module.argSize();
if (modulesize + 3 < patternsize) return false; // name,args,kwd can be extra args
const LsysVar& vlast = pattern.getAt(patternsize-1);
const LsysVar& vbeforelast = pattern.getAt(patternsize-2);
bool vlastisArgs = vlast.isArgs();
bool vbeforelastisArgs = vbeforelast.isArgs();
bool vlastisKwds = vlast.isKwds();
if(!vlastisArgs && !vlastisKwds){
if (modulesize != patternsize-1) return false;
}
if (patternsize == 2 && vlastisKwds && vbeforelastisArgs){ // (**kwds,*args)
size_t nbNamedParameter = module.getNamedParameterNb();
if(nbNamedParameter > modulesize) return false;
boost::python::list largs;
if (vbeforelast.isNamed() || vbeforelast.hasCondition()) {
largs = module.getSlice(0,modulesize-nbNamedParameter);
}
if (!vbeforelast.isCompatible(largs))return false;
if (vbeforelast.isNamed()) ArgsCollector::append_arg(l,largs);
boost::python::dict lkwd;
if (vlast.isNamed() || vlast.hasCondition()) {
lkwd[boost::python::object("name")] = boost::python::object(module.name());
module.getNamedParameters(lkwd);
}
if (!vlast.isCompatible(lkwd)) return false;
if (vlast.isNamed()) ArgsCollector::append_arg(l,lkwd);
return true;
}
size_t normalparam = patternsize - 1;
if (vlastisArgs || vlastisKwds) --normalparam;
if (vbeforelastisArgs) --normalparam;
// check if normal number of parameter to retrieve is compatible
if( normalparam > modulesize) return false;
// processing module name
const LsysVar& v1 = pattern.getAt(0);
if (v1.isNamed() || v1.hasCondition()) {
boost::python::object mname(module.name());
if (!v1.isCompatible(mname))return false;
if (v1.isNamed()) ArgsCollector::append_arg(l,mname);
}
// retrieve normal parameters
for(int i = 0; i < normalparam; i++) {
const LsysVar& v = pattern.getAt(i+1);
if(!v.isCompatible(module.getAt(i))) return false;
if(v.isNamed())ArgsCollector::append_arg_ref(l,module.getAt(i));
}
// retrieve *args
if (vbeforelastisArgs || vlastisArgs){
const LsysVar& varg = (vlastisArgs?vlast:vbeforelast);
boost::python::list argvalue;
if (varg.isNamed() || varg.hasCondition()) {
if ( normalparam == 0 && !vlastisKwds) // (name,*args)
argvalue = module.getPyArgs();
else if (normalparam == modulesize) // (name,x,*args) on A(1)
argvalue = boost::python::list();
else {
int lastarrayarg = modulesize;
if (vlastisKwds) {
lastarrayarg = std::max(normalparam, modulesize-module.getNamedParameterNb()) ;
}
if (lastarrayarg <= normalparam)
argvalue = boost::python::list();
else
argvalue = module.getSlice(normalparam,lastarrayarg);
}
}
if(!varg.isCompatible(argvalue)) return false;
if (varg.isNamed())ArgsCollector::append_arg(l,argvalue);
}
// retrieve **kwds
if (vlastisKwds){
if (! vbeforelastisArgs && (module.getNamedParameterNb()+normalparam < modulesize) ) return false;
boost::python::dict kwdvalue;
if (vlast.isNamed() || vlast.hasCondition()) {
int startkwd = std::max<int>(0,normalparam - std::max<int>(0, modulesize-module.getNamedParameterNb()));
module.getNamedParameters(kwdvalue, startkwd);
}
if(!vlast.isCompatible(kwdvalue)) return false;
if (vlast.isNamed())ArgsCollector::append_arg(l,kwdvalue);
}
return true;
/*
bool lastarg = false;
boost::python::object lastargval;
const LsysVar& v = pattern.getAt(patternsize-1);
if(!v.isNamed()){
if (modulesize != (patternsize-1+beg)) return false;
if (!v.isCompatible(module.getAt(patternsize-2+beg)))return false;
}
else {
lastarg = true;
if(beg == 1){
if(!v.isArgs()){
if (modulesize != patternsize) return false;
lastargval = module.getAt(patternsize-1);
}
else {
if (modulesize < patternsize-1) return false;
else if (modulesize == patternsize-1) lastargval = boost::python::list();
lastargval = module.getSlice(patternsize-1,modulesize);
}
}
else {
if(!v.isArgs()){
if (modulesize != patternsize-1) return false;
lastargval = module.getAt(patternsize-2);
}
else {
if (modulesize < patternsize-2) return false;
else {
if(patternsize == 2){
lastargval = module.getPyArgs();
if(!v.isCompatible(lastargval))return false;
ArgsCollector::append_arg(l,lastargval);
return true;
}
else if (modulesize == patternsize-2) lastargval = boost::python::list();
else lastargval = module.getSlice(patternsize-2,modulesize);
}
}
}
if(!v.isCompatible(lastargval))return false;
}
for(size_t i = 1; i < patternsize-1; i++){
const LsysVar& v = pattern.getAt(i);
if(!v.isCompatible(module.getAt(i-1+beg))) return false;
if(v.isNamed())ArgsCollector::append_arg_ref(l,module.getAt(i-1+beg));
}
if(lastarg)ArgsCollector::append_arg(l,lastargval);
return true;
*/}
}
else { // pattern is not star
if (!compatibleName(module,pattern)) return false;
size_t patternsize = pattern.argSize();
size_t modulesize = module.argSize();
if (modulesize + 2 < patternsize) return false;
if( patternsize == 0) return modulesize == 0;
else if(patternsize == 1) {
LsysVar v = pattern.getAt(0);
if(v.isArgs()) {
ArgList largs;
if(v.isNamed() || v.hasCondition()){ // if necessary we retrieve the args
ArgsCollector::append_modargs(largs,module.getParameterList());
}
// we check the condition
if(!v.isCompatible(toPyList(largs))) return false;
// we add the params to the result list
if(v.isNamed()) ArgsCollector::append_as_arg(l,largs);
return true;
}
else if(v.isKwds()) {
if( module.getNamedParameterNb() != module.size()) return false;
boost::python::dict lkwds;
if(v.isNamed() || v.hasCondition()){ // if necessary we retrieve the args
module.getNamedParameters(lkwds);
}
// we check the condition
if(!v.isCompatible(lkwds))return false;
// we add the params to the result list
if(v.isNamed()) ArgsCollector::append_arg(l,lkwds);
return true;
}
else {
if(modulesize != 1) return false;
// we check the condition
if (!v.isCompatible(module.getAt(0))) return false;
// we add the params to the result list
if (v.isNamed()) ArgsCollector::append_arg_ref(l,module.getAt(0));
return true;
}
}
else { // args >= 2
LsysVar vlast = pattern.getAt(patternsize-1);
LsysVar vbeforelast = pattern.getAt(patternsize-2);
bool vlastisArgs = vlast.isArgs();
bool vbeforelastisArgs = vbeforelast.isArgs();
bool vlastisKwds = vlast.isKwds();
if(!vlastisArgs && !vlastisKwds){
if (modulesize != patternsize) return false;
}
if (patternsize == 2 && vbeforelastisArgs && vlastisKwds){ // (*args,**kwds)
size_t nbNamedParameter = module.getNamedParameterNb();
if(nbNamedParameter > modulesize) return false;
boost::python::list largs;
if (vbeforelast.isNamed() || vbeforelast.hasCondition()) {
largs = module.getSlice(0,modulesize-nbNamedParameter);
}
if (!vbeforelast.isCompatible(largs))return false;
if (vbeforelast.isNamed()) ArgsCollector::append_arg(l,largs);
boost::python::dict lkwd;
if (vlast.isNamed() || vlast.hasCondition()) {
module.getNamedParameters(lkwd);
}
if (!vlast.isCompatible(lkwd)) return false;
if (vlast.isNamed()) ArgsCollector::append_arg(l,lkwd);
return true;
}
size_t normalparam = patternsize ;
if (vbeforelastisArgs) --normalparam;
if (vlastisArgs || vlastisKwds) --normalparam;
if( normalparam > modulesize) return false;
// retrieve normal parameters
for(int i = 0; i < normalparam; i++) {
const LsysVar& v = pattern.getAt(i);
if(!v.isCompatible(module.getAt(i))) return false;
if(v.isNamed())ArgsCollector::append_arg_ref(l,module.getAt(i));
}
// retrieve *args
if (vbeforelastisArgs || vlastisArgs){
const LsysVar& varg = (vlastisArgs?vlast:vbeforelast);
boost::python::list argvalue;
if (varg.isNamed() || varg.hasCondition()) {
if ( normalparam == 0 && !vlastisKwds) // (name,*args)
argvalue = module.getPyArgs();
else if (normalparam == modulesize) // (name,x,*args) on A(1)
argvalue = boost::python::list();
else {
int lastarrayarg = modulesize;
if (vlastisKwds) {
lastarrayarg = std::max(normalparam, modulesize-module.getNamedParameterNb()) ;
}
if (lastarrayarg <= normalparam)
argvalue = boost::python::list();
else
argvalue = module.getSlice(normalparam,lastarrayarg);
}
}
if(!varg.isCompatible(argvalue)) return false;
if (varg.isNamed())ArgsCollector::append_arg(l,argvalue);
}
if (vlastisKwds){
if (! vbeforelastisArgs && (module.getNamedParameterNb()+normalparam < modulesize) ) {
return false;
}
boost::python::dict kwdvalue;
if (vlast.isNamed() || vlast.hasCondition()) {
int startkwd = std::max<int>(0,normalparam - std::max<int>(0, modulesize-module.getNamedParameterNb()));
module.getNamedParameters(kwdvalue, startkwd);
}
if(!vlast.isCompatible(kwdvalue)) return false;
if (vlast.isNamed())ArgsCollector::append_arg(l,kwdvalue);
}
return true;
}
/*if (!compatibleName(module,pattern)) return false;
int s = pattern.argSize();
int s2 = module.argSize();
if( s == 0) return s2 == 0;
else {
bool lastarg = false;
boost::python::object lastargval;
const LsysVar& v = pattern.getAt(s-1);
if(!v.isNamed()){
if (s2 != s) return false;
if (!v.isCompatible(module.getAt(s-1)))return false;
}
else {
lastarg = true;
if(!v.isArgs()){
if (s2 != s) return false;
else lastargval = module.getAt(s-1);
}
else {
if (s2 < s - 1) return false;
if(s == 1){
lastargval = module.getPyArgs();
if(!v.isCompatible(lastargval))return false;
ArgsCollector::append_arg(l,lastargval); return true;
}
else if (s2 == s - 1) lastargval = boost::python::list();
else lastargval = module.getSlice(s-1,s2);
}
if(!v.isCompatible(lastargval)) return false;
}
for(size_t i = 0; i < s-1; i++){
const LsysVar& v = pattern.getAt(i);
if(!v.isCompatible(module.getAt(i))) return false;
if(v.isNamed())ArgsCollector::append_arg_ref(l,module.getAt(i));
}
if(lastarg)ArgsCollector::append_arg(l,lastargval);
}
return true;*/
}
}
void VerilogDocGen::writeVerilogDeclarations(MemberDef* mdef,OutputList &ol,
ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,
bool inGroup) {
static bool bComp=false;
//LockingPtr<MemberDef> lock(mdef,mdef);
Definition *d=0;
// ASSERT (cd!=0 || nd!=0 || fd!=0 || gd!=0); // member should belong to something
//static_cast<VPreProcImp*>(m_opaquep);
if (cd) d=cd;
else if (nd) d=(Definition*)nd;
else if (fd) d=fd;
else if (gd) d=(Definition*)gd;
else d=(Definition*)mdef;
//if (cd) d=cd;
// write tag file information of this member
int memType=mdef->getMemberSpecifiers();
if (!Config_getString("GENERATE_TAGFILE").isEmpty())
{
Doxygen::tagFile << " <member kind=\"";
Doxygen::tagFile << VerilogDocGen::convertTypeToString(memType);
Doxygen::tagFile << "\">" << endl;
Doxygen::tagFile << " <type>" << convertToXML(mdef->typeString()) << "</type>" << endl;
Doxygen::tagFile << " <name>" << convertToXML(mdef->name()) << "</name>" << endl;
Doxygen::tagFile << " <anchorfile>" << convertToXML(mdef->getOutputFileBase()+Doxygen::htmlFileExtension) << "</anchorfile>" << endl;
Doxygen::tagFile << " <anchor>" << convertToXML(mdef->anchor()) << "</anchor>" << endl;
if(memType==VerilogDocGen::FUNCTION)
Doxygen::tagFile << " <arglist>" << convertToXML(VhdlDocGen::convertArgumentListToString(mdef->argumentList(),true)) << "</arglist>" << endl;
else if(memType==VerilogDocGen::ALWAYS)
Doxygen::tagFile << " <arglist>" << convertToXML(VhdlDocGen::convertArgumentListToString(mdef->argumentList(),false)) << "</arglist>" << endl;
else{
Doxygen::tagFile << " <arglist>" << convertToXML(mdef->argsString()) << "</arglist>" << endl;
Doxygen::tagFile << " <arglist>" << convertToXML(mdef->typeString()) << "</arglist>" << endl;
}
mdef->writeDocAnchorsToTagFile();
Doxygen::tagFile << " </member>" << endl;
}
// write search index info
if (Doxygen::searchIndex)
{
Doxygen::searchIndex->setCurrentDoc(mdef,mdef->anchor(),FALSE);
Doxygen::searchIndex->addWord(mdef->localName(),TRUE);
Doxygen::searchIndex->addWord(mdef->qualifiedName(),FALSE);
}
QCString cname = d->name();
QCString cfname = mdef->getOutputFileBase();
// HtmlHelp *htmlHelp=0;
// bool hasHtmlHelp = Config_getBool("GENERATE_HTML") && Config_getBool("GENERATE_HTMLHELP");
// if (hasHtmlHelp) htmlHelp = HtmlHelp::getInstance();
// search for the last anonymous scope in the member type
// ClassDef *annoClassDef=mdef->getClassDefOfAnonymousType();
// start a new member declaration
// bool isAnonymous = annoClassDef; // || m_impl->annMemb || m_impl->annEnumType;
///printf("startMemberItem for %s\n",name().data());
// if(mdef->getMemberSpecifiers()==VerilogDocGen::FEATURE)
// ol.startMemberItem(mdef->anchor(),3); //? 1 : m_impl->tArgList ? 3 : 0);
// else
ol.startMemberItem(mdef->anchor(), 0);// ? 1 : m_impl->tArgList ? 3 : 0);
// If there is no detailed description we need to write the anchor here.
bool detailsVisible = mdef->isDetailedSectionLinkable();
if (!detailsVisible) // && !m_impl->annMemb)
{
QCString doxyName=mdef->name().copy();
if (!cname.isEmpty()) doxyName.prepend(cname+"::");
QCString doxyArgs=mdef->argsString();
ol.startDoxyAnchor(cfname,cname,mdef->anchor(),doxyName,doxyArgs);
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
ol.disable(OutputGenerator::Latex);
ol.docify("\n");
ol.popGeneratorState();
}
// *** write type
/*Verilog CHANGE */
VerilogDocGen::adjustMemberName(mdef);
QCString ltype(mdef->typeString());
QCString largs(mdef->argsString());
int mm=mdef->getMemberSpecifiers();
ClassDef *kl=NULL;
FileDef *fdd=NULL;
ArgumentList *alp = mdef->argumentList();
QCString nn;
if(gd)gd=NULL;
switch(mm)
{
case VhdlDocGen::MISCELLANEOUS:
VhdlDocGen::writeSource(mdef,ol,nn);
break;
case VhdlDocGen::UCF_CONST:
mm=mdef->name().findRev('_');
if(mm>0)
mdef->setName(mdef->name().left(mm));
writeUCFLink(mdef,ol);
break;
case VerilogDocGen::INCLUDE:
bool ambig;
largs=mdef->name();
fdd=findFileDef(Doxygen::inputNameDict,largs.data(),ambig);
if(fdd){
QCString fbb=fdd->getFileBase();
fbb=fdd->getReference();
fbb= fdd->getOutputFileBase();
fbb=fdd->getSourceFileBase();
fbb=fdd->convertNameToFile(largs.data(),true);
fbb=fdd->getPath();
fbb+=fdd->getOutputFileBase()+".html";
ol.writeObjectLink(fdd->getReference(),
fdd->getOutputFileBase(),
0,
fdd->name());
}
else
VhdlDocGen::formatString(largs,ol,mdef);
break;
case VerilogDocGen::FEATURE:
parseDefineConstruct(largs,mdef,ol);
break;
case VerilogDocGen::MODULE:
ol.startBold();
VhdlDocGen::formatString(ltype,ol,mdef);
ol.endBold();
ol.insertMemberAlign();
//writeLink(mdef,ol);
case VerilogDocGen::PORT:
writeLink(mdef,ol);
ol.insertMemberAlign();
if(largs.length()>0)
VhdlDocGen::formatString(largs,ol,mdef);
if(ltype.length()>0)
VhdlDocGen::formatString(ltype,ol,mdef);
break;
case VerilogDocGen::ALWAYS:
writeLink(mdef,ol);
ol.insertMemberAlign();
VhdlDocGen::writeProcessProto(ol,alp,mdef);
break;
case VerilogDocGen::FUNCTION:
case VerilogDocGen::TASK:
writeLink(mdef,ol);
ol.docify(" ");// need for pdf has no effect in html
ol.insertMemberAlign();
if(ltype.length()>0)
VhdlDocGen::formatString(ltype,ol,mdef);
writeFunctionProto(ol,alp,mdef);
break;
case VerilogDocGen::SIGNAL:
if(largs.length()>0)
VhdlDocGen::formatString(largs,ol,mdef);
ol.docify(" ");
ol.insertMemberAlign();
writeLink(mdef,ol);
ol.docify(" ");
if(ltype.length())
VhdlDocGen::formatString(ltype,ol,mdef);
break;
case VerilogDocGen::CONFIGURATION:
case VerilogDocGen::LIBRARY:
writeLink(mdef,ol);
break;
case VerilogDocGen::INPUT:
case VerilogDocGen::OUTPUT:
case VerilogDocGen::INOUT:
case VerilogDocGen::PARAMETER:
writeLink(mdef,ol);
ol.docify(" ");
ol.insertMemberAlign();
if(ltype.length()>0){
VhdlDocGen::formatString(ltype,ol,mdef);
ol.writeString(" ");
}
//ol.insertMemberAlign();
if(largs.length()>0)
VhdlDocGen::formatString(largs,ol,mdef);
break;
case VerilogDocGen::COMPONENT:
//VhdlDocGen::writeLink(mdef,ol);
if(true)
{
nn=mdef->name();
kl=VhdlDocGen::getClass(nn);
//if(kl==NULL){
ol.startBold();
QCString inst=mdef->name()+"::"+ltype;
ol.writeObjectLink(mdef->getReference(),
mdef->getOutputFileBase(),
mdef->anchor(),
inst.data());
ol.docify(" ");
ol.endBold();
//}
ol.insertMemberAlign();
if(kl) {
nn=kl->getOutputFileBase();
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
ol.docify(" ");
QCString name=VerilogDocGen::getClassTitle(kl);
name=VhdlDocGen::getIndexWord(name.data(),1);
// ol.insertMemberAlign();
ol.startBold();
ol.docify(name.data());
ol.endBold();
ol.startEmphasis();
ol.docify(" ");
ol.writeObjectLink(kl->getReference(),kl->getOutputFileBase(),0,mdef->name().data());
ol.endEmphasis();
ol.popGeneratorState();
}
if(largs.data())
{
ol.docify(" ");
ol.docify(largs.data());
}
}
break;
default: break;
}
bool htmlOn = ol.isEnabled(OutputGenerator::Html);
if (htmlOn && !ltype.isEmpty())
{
ol.disable(OutputGenerator::Html);
}
if (!ltype.isEmpty()) ol.docify(" ");
if (htmlOn)
{
ol.enable(OutputGenerator::Html);
}
if (!detailsVisible)// && !m_impl->annMemb)
{
ol.endDoxyAnchor(cfname,mdef->anchor());
}
//printf("endMember %s annoClassDef=%p annEnumType=%p\n",
// name().data(),annoClassDef,annEnumType);
ol.endMemberItem();
//fprintf(stderr,"\n%d %s",mdef->docLine,mdef->name().data());
if (!mdef->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC") /* && !annMemb */)
{
ol.startMemberDescription(mdef->anchor());
ol.generateDoc(mdef->briefFile(),mdef->briefLine(),mdef->getOuterScope()?mdef->getOuterScope():d,mdef,mdef->briefDescription(),TRUE,FALSE,0,TRUE,FALSE);
if (detailsVisible)
{
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
//ol.endEmphasis();
ol.docify(" ");
if (mdef->getGroupDef()!=0 && gd==0) // forward link to the group
{
ol.startTextLink(mdef->getOutputFileBase(),mdef->anchor());
}
else // local link
{
ol.startTextLink(0,mdef->anchor());
}
ol.endTextLink();
//ol.startEmphasis();
ol.popGeneratorState();
}
//ol.newParagraph();
ol.endMemberDescription();
// if(VhdlDocGen::isComponent(mdef))
// ol.lineBreak();
}
mdef->warnIfUndocumented();
}// end writeVerilogDeclaration
