bool A_parseScript(IScriptEngine *engine, const char *name)
{
return parseScript(engine, name, IScriptEngine::Normal);
}
static rpmSpec parseSpec(const char *specFile, rpmSpecFlags flags,
const char *buildRoot, int recursing)
{
int parsePart = PART_PREAMBLE;
int initialPackage = 1;
rpmSpec spec;
/* Set up a new Spec structure with no packages. */
spec = newSpec();
spec->specFile = rpmGetPath(specFile, NULL);
pushOFI(spec, spec->specFile);
/* If buildRoot not specified, use default %{buildroot} */
if (buildRoot) {
spec->buildRoot = xstrdup(buildRoot);
} else {
spec->buildRoot = rpmGetPath("%{?buildroot:%{buildroot}}", NULL);
}
addMacro(NULL, "_docdir", NULL, "%{_defaultdocdir}", RMIL_SPEC);
addMacro(NULL, "_licensedir", NULL, "%{_defaultlicensedir}", RMIL_SPEC);
spec->recursing = recursing;
spec->flags = flags;
/* All the parse*() functions expect to have a line pre-read */
/* in the spec's line buffer. Except for parsePreamble(), */
/* which handles the initial entry into a spec file. */
while (parsePart != PART_NONE) {
int goterror = 0;
switch (parsePart) {
case PART_ERROR: /* fallthrough */
default:
goterror = 1;
break;
case PART_PREAMBLE:
parsePart = parsePreamble(spec, initialPackage);
initialPackage = 0;
break;
case PART_PREP:
parsePart = parsePrep(spec);
break;
case PART_BUILD:
case PART_INSTALL:
case PART_CHECK:
case PART_CLEAN:
parsePart = parseBuildInstallClean(spec, parsePart);
break;
case PART_CHANGELOG:
parsePart = parseChangelog(spec);
break;
case PART_DESCRIPTION:
parsePart = parseDescription(spec);
break;
case PART_PRE:
case PART_POST:
case PART_PREUN:
case PART_POSTUN:
case PART_PRETRANS:
case PART_POSTTRANS:
case PART_VERIFYSCRIPT:
case PART_TRIGGERPREIN:
case PART_TRIGGERIN:
case PART_TRIGGERUN:
case PART_TRIGGERPOSTUN:
case PART_FILETRIGGERIN:
case PART_FILETRIGGERUN:
case PART_FILETRIGGERPOSTUN:
case PART_TRANSFILETRIGGERIN:
case PART_TRANSFILETRIGGERUN:
case PART_TRANSFILETRIGGERPOSTUN:
parsePart = parseScript(spec, parsePart);
break;
case PART_FILES:
parsePart = parseFiles(spec);
break;
case PART_POLICIES:
parsePart = parsePolicies(spec);
break;
case PART_NONE: /* XXX avoid gcc whining */
case PART_LAST:
case PART_BUILDARCHITECTURES:
break;
}
if (goterror || parsePart >= PART_LAST) {
goto errxit;
}
if (parsePart == PART_BUILDARCHITECTURES) {
int index;
int x;
closeSpec(spec);
spec->BASpecs = xcalloc(spec->BACount, sizeof(*spec->BASpecs));
index = 0;
if (spec->BANames != NULL)
for (x = 0; x < spec->BACount; x++) {
/* Skip if not arch is not compatible. */
if (!rpmMachineScore(RPM_MACHTABLE_BUILDARCH, spec->BANames[x]))
continue;
addMacro(NULL, "_target_cpu", NULL, spec->BANames[x], RMIL_RPMRC);
spec->BASpecs[index] = parseSpec(specFile, flags, buildRoot, 1);
if (spec->BASpecs[index] == NULL) {
spec->BACount = index;
goto errxit;
}
delMacro(NULL, "_target_cpu");
index++;
}
spec->BACount = index;
if (! index) {
rpmlog(RPMLOG_ERR,
_("No compatible architectures found for build\n"));
goto errxit;
}
/*
* Return the 1st child's fully parsed Spec structure.
* The restart of the parse when encountering BuildArch
* causes problems for "rpm -q --specfile". This is
* still a hack because there may be more than 1 arch
* specified (unlikely but possible.) There's also the
* further problem that the macro context, particularly
* %{_target_cpu}, disagrees with the info in the header.
*/
if (spec->BACount >= 1) {
rpmSpec nspec = spec->BASpecs[0];
spec->BASpecs = _free(spec->BASpecs);
rpmSpecFree(spec);
spec = nspec;
}
goto exit;
}
}
if (spec->clean == NULL) {
char *body = rpmExpand("%{?buildroot: %{__rm} -rf %{buildroot}}", NULL);
spec->clean = newStringBuf();
appendLineStringBuf(spec->clean, body);
free(body);
}
/* Check for description in each package */
for (Package pkg = spec->packages; pkg != NULL; pkg = pkg->next) {
if (!headerIsEntry(pkg->header, RPMTAG_DESCRIPTION)) {
rpmlog(RPMLOG_ERR, _("Package has no %%description: %s\n"),
headerGetString(pkg->header, RPMTAG_NAME));
goto errxit;
}
}
/* Add arch, os and platform, self-provides etc for each package */
addTargets(spec->packages);
/* Check for encoding in each package unless disabled */
if (!(spec->flags & RPMSPEC_NOUTF8)) {
int badenc = 0;
for (Package pkg = spec->packages; pkg != NULL; pkg = pkg->next) {
if (checkForEncoding(pkg->header, 0) != RPMRC_OK) {
badenc = 1;
}
}
if (badenc)
goto errxit;
}
closeSpec(spec);
exit:
/* Assemble source header from parsed components */
initSourceHeader(spec);
return spec;
errxit:
rpmSpecFree(spec);
return NULL;
}
static void RunScript(const char *name)
{
parseScript(tempEngine, name, IScriptEngine::DebugOnError);
}
static void DebugScript(const char *name)
{
parseScript(tempEngine, name, IScriptEngine::Debug);
}
void GameScriptParser::restart() {
callStopFunction();
parseScript(m_sFileName, m_sResourceGroupName);
callStartFunction();
}
//---------------------------------------------------------------------
void OverlayManager::parseScript(DataStreamPtr& stream, const String& groupName)
{
// check if we've seen this script before (can happen if included
// multiple times)
if (!stream->getName().empty() &&
mLoadedScripts.find(stream->getName()) != mLoadedScripts.end())
{
LogManager::getSingleton().logMessage(
"Skipping loading overlay include: '"
+ stream->getName() + " as it is already loaded.");
return;
}
String line;
Overlay* pOverlay = 0;
bool skipLine;
while(!stream->eof())
{
bool isATemplate = false;
skipLine = false;
line = stream->getLine();
// Ignore comments & blanks
if (!(line.length() == 0 || line.substr(0,2) == "//"))
{
if (line.substr(0,8) == "#include")
{
vector<String>::type params = StringUtil::split(line, "\t\n ()<>");
DataStreamPtr includeStream =
ResourceGroupManager::getSingleton().openResource(
params[1], groupName);
parseScript(includeStream, groupName);
continue;
}
if (!pOverlay)
{
// No current overlay
// check to see if there is a template
if (line.substr(0,8) == "template")
{
isATemplate = true;
}
else
{
// So first valid data should be overlay name
if (StringUtil::startsWith(line, "overlay "))
{
// chop off the 'particle_system ' needed by new compilers
line = line.substr(8);
}
pOverlay = create(line);
pOverlay->_notifyOrigin(stream->getName());
// Skip to and over next {
skipToNextOpenBrace(stream);
skipLine = true;
}
}
if ((pOverlay && !skipLine) || isATemplate)
{
// Already in overlay
vector<String>::type params = StringUtil::split(line, "\t\n ()");
if (line == "}")
{
// Finished overlay
pOverlay = 0;
}
else if (parseChildren(stream,line, pOverlay, isATemplate, NULL))
{
}
else
{
// Attribute
if (!isATemplate)
{
parseAttrib(line, pOverlay);
}
}
}
}
}
// record as parsed
mLoadedScripts.insert(stream->getName());
}
//-----------------------------------------------------------------------------
void ScriptLoaderEx::parseScript( DataStreamPtr& _dataStream, const String& _resourceGroup)
{
DataStreamExPtr dataStreamEx = _dataStream;
parseScript( dataStreamEx, _resourceGroup );
}
int parseSpec(rpmts ts, const char *specFile, const char *rootDir,
const char *buildRoot, int recursing, const char *passPhrase,
const char *cookie, int anyarch, int force)
{
rpmParseState parsePart = PART_PREAMBLE;
int initialPackage = 1;
Package pkg;
rpmSpec spec;
/* Set up a new Spec structure with no packages. */
spec = newSpec();
spec->specFile = rpmGetPath(specFile, NULL);
spec->fileStack = newOpenFileInfo();
spec->fileStack->fileName = xstrdup(spec->specFile);
/* If buildRoot not specified, use default %{buildroot} */
if (buildRoot) {
spec->buildRoot = xstrdup(buildRoot);
} else {
spec->buildRoot = rpmGetPath("%{?buildroot:%{buildroot}}", NULL);
}
addMacro(NULL, "_docdir", NULL, "%{_defaultdocdir}", RMIL_SPEC);
spec->recursing = recursing;
spec->anyarch = anyarch;
spec->force = force;
if (rootDir)
spec->rootDir = xstrdup(rootDir);
if (passPhrase)
spec->passPhrase = xstrdup(passPhrase);
if (cookie)
spec->cookie = xstrdup(cookie);
spec->timeCheck = rpmExpandNumeric("%{_timecheck}");
/* All the parse*() functions expect to have a line pre-read */
/* in the spec's line buffer. Except for parsePreamble(), */
/* which handles the initial entry into a spec file. */
while (parsePart != PART_NONE) {
int goterror = 0;
switch (parsePart) {
/* XXX Trap unexpected RPMRC_FAIL returns for now */
case RPMRC_FAIL:
rpmlog(RPMLOG_ERR, "FIXME: got RPMRC_FAIL from spec parse\n");
abort();
case PART_ERROR: /* fallthrough */
default:
goterror = 1;
break;
case PART_PREAMBLE:
parsePart = parsePreamble(spec, initialPackage);
initialPackage = 0;
break;
case PART_PREP:
parsePart = parsePrep(spec);
break;
case PART_BUILD:
case PART_INSTALL:
case PART_CHECK:
case PART_CLEAN:
parsePart = parseBuildInstallClean(spec, parsePart);
break;
case PART_CHANGELOG:
parsePart = parseChangelog(spec);
break;
case PART_DESCRIPTION:
parsePart = parseDescription(spec);
break;
case PART_PRE:
case PART_POST:
case PART_PREUN:
case PART_POSTUN:
case PART_PRETRANS:
case PART_POSTTRANS:
case PART_VERIFYSCRIPT:
case PART_TRIGGERPREIN:
case PART_TRIGGERIN:
case PART_TRIGGERUN:
case PART_TRIGGERPOSTUN:
parsePart = parseScript(spec, parsePart);
break;
case PART_FILES:
parsePart = parseFiles(spec);
break;
case PART_NONE: /* XXX avoid gcc whining */
case PART_LAST:
case PART_BUILDARCHITECTURES:
break;
}
if (goterror || parsePart >= PART_LAST) {
goto errxit;
}
if (parsePart == PART_BUILDARCHITECTURES) {
int index;
int x;
closeSpec(spec);
spec->BASpecs = xcalloc(spec->BACount, sizeof(*spec->BASpecs));
index = 0;
if (spec->BANames != NULL)
for (x = 0; x < spec->BACount; x++) {
/* Skip if not arch is not compatible. */
if (!rpmMachineScore(RPM_MACHTABLE_BUILDARCH, spec->BANames[x]))
continue;
addMacro(NULL, "_target_cpu", NULL, spec->BANames[x], RMIL_RPMRC);
spec->BASpecs[index] = NULL;
if (parseSpec(ts, specFile, spec->rootDir, buildRoot, 1,
passPhrase, cookie, anyarch, force)
|| (spec->BASpecs[index] = rpmtsSetSpec(ts, NULL)) == NULL)
{
spec->BACount = index;
goto errxit;
}
delMacro(NULL, "_target_cpu");
index++;
}
spec->BACount = index;
if (! index) {
rpmlog(RPMLOG_ERR,
_("No compatible architectures found for build\n"));
goto errxit;
}
/*
* Return the 1st child's fully parsed Spec structure.
* The restart of the parse when encountering BuildArch
* causes problems for "rpm -q --specfile". This is
* still a hack because there may be more than 1 arch
* specified (unlikely but possible.) There's also the
* further problem that the macro context, particularly
* %{_target_cpu}, disagrees with the info in the header.
*/
if (spec->BACount >= 1) {
rpmSpec nspec = spec->BASpecs[0];
spec->BASpecs = _free(spec->BASpecs);
spec = freeSpec(spec);
spec = nspec;
}
(void) rpmtsSetSpec(ts, spec);
return 0;
}
}
if (spec->clean == NULL) {
char *body = rpmExpand("%{?buildroot: %{__rm} -rf %{buildroot}}", NULL);
spec->clean = newStringBuf();
appendLineStringBuf(spec->clean, body);
free(body);
}
/* Check for description in each package and add arch and os */
{
char *platform = rpmExpand("%{_target_platform}", NULL);
char *arch = rpmExpand("%{_target_cpu}", NULL);
char *os = rpmExpand("%{_target_os}", NULL);
for (pkg = spec->packages; pkg != NULL; pkg = pkg->next) {
if (!headerIsEntry(pkg->header, RPMTAG_DESCRIPTION)) {
rpmlog(RPMLOG_ERR, _("Package has no %%description: %s\n"),
headerGetString(pkg->header, RPMTAG_NAME));
goto errxit;
}
headerPutString(pkg->header, RPMTAG_OS, os);
/* noarch subpackages already have arch set here, leave it alone */
if (!headerIsEntry(pkg->header, RPMTAG_ARCH)) {
headerPutString(pkg->header, RPMTAG_ARCH, arch);
}
headerPutString(pkg->header, RPMTAG_PLATFORM, platform);
pkg->ds = rpmdsThis(pkg->header, RPMTAG_REQUIRENAME, RPMSENSE_EQUAL);
}
platform = _free(platform);
arch = _free(arch);
os = _free(os);
}
closeSpec(spec);
(void) rpmtsSetSpec(ts, spec);
return 0;
errxit:
spec = freeSpec(spec);
return PART_ERROR;
}
/**
* Parse a block element, identified by the given name.
* @param blockType Identifier of the block.
*/
BlockElement *parseBlockElement(String blockType)
{
DENG2_ASSERT(blockType != "}");
DENG2_ASSERT(blockType != ")");
String blockName;
if(!scriptBlockTypes.contains(blockType)) // script blocks are never named
{
if(peekToken() != "(" && peekToken() != "{")
{
blockName = parseValue();
}
}
if(!implicitBlockType.isEmpty() && blockName.isEmpty() &&
blockType != implicitBlockType &&
!scriptBlockTypes.contains(blockType))
{
blockName = blockType;
blockType = implicitBlockType;
}
QScopedPointer<BlockElement> block(new BlockElement(blockType, blockName, self));
int startLine = currentLine;
String endToken;
try
{
// How about some attributes?
// Syntax: {token value} '('|'{'
while(peekToken() != "(" && peekToken() != "{")
{
String keyName = peekToken();
nextToken();
InfoValue value = parseValue();
// This becomes a key element inside the block but it's
// flagged as Attribute.
block->add(new KeyElement(keyName, value, KeyElement::Attribute));
}
endToken = (peekToken() == "("? ")" : "}");
// Parse the contents of the block.
if(scriptBlockTypes.contains(blockType))
{
// Parse as Doomsday Script.
block->add(new KeyElement(SCRIPT_TOKEN, parseScript()));
}
else
{
// Move past the opening parentheses.
nextToken();
// Parse normally as Info.
while(peekToken() != endToken)
{
Element *element = parseElement();
if(!element)
{
throw SyntaxError("Info::parseBlockElement",
QString("Block element was never closed, end of file encountered before '%1' was found (on line %2).")
.arg(endToken).arg(currentLine));
}
block->add(element);
}
}
}
catch(EndOfFile const &)
{
throw SyntaxError("Info::parseBlockElement",
QString("End of file encountered unexpectedly while parsing a block element (block started on line %1).")
.arg(startLine));
}
DENG2_ASSERT(peekToken() == endToken);
// Move past the closing parentheses.
nextToken();
return block.take();
}
/**
Load or append a file.
The file type is determined automatically and the ad-hoc video decoder is spawned
*/
uint8_t ADM_Composer::addFile (char *name, uint8_t mode)
{
uint8_t ret = 0;
aviInfo info;
WAVHeader * _wavinfo;
// aviHeader * tmp;
fileType type = Unknown_FileType;
UNUSED_ARG(mode);
_haveMarkers=0; // by default no markers are present
ADM_assert (_nb_segment < max_seg);
ADM_assert (_nb_video < MAX_VIDEO);
if (!identify (name, &type))
return 0;
#define OPEN_AS(x,y) case x:\
_videos[_nb_video]._aviheader=new y; \
ret = _videos[_nb_video]._aviheader->open(name); \
break;
switch (type)
{
case VCodec_FileType:
loadVideoCodecConf(name);
return ADM_IGN; // we do it but it wil fail, no problem with that
break;
OPEN_AS (Mp4_FileType, mp4Header);
OPEN_AS (H263_FileType, h263Header);
case ASF_FileType:
_videos[_nb_video]._aviheader=new asfHeader;
ret = _videos[_nb_video]._aviheader->open(name);
if(!ret)
{
delete _videos[_nb_video]._aviheader;;
printf("Trying mpeg\n");
goto thisIsMpeg;
}
break;
OPEN_AS (NewMpeg_FileType,dmxHeader);
// For AVI we first try top open it as openDML
case AVI_FileType:
_videos[_nb_video]._aviheader=new OpenDMLHeader;
ret = _videos[_nb_video]._aviheader->open(name);
break;
case Nuppel_FileType:
{ // look if the idx exists
char *tmpname = (char*)ADM_alloc(strlen(name)+strlen(".idx")+1);
ADM_assert(tmpname);
sprintf(tmpname,"%s.idx",name);
if(addFile(tmpname))
{
return 1; // Memleak ?
}
ADM_dealloc(tmpname);
// open .nuv file
_videos[_nb_video]._aviheader=new nuvHeader;
ret = _videos[_nb_video]._aviheader->open(name);
// we store the native .nuv file in the edl
// the next load of the edl will open .idx instead
break;
}
OPEN_AS (BMP_FileType, picHeader);
OPEN_AS (Matroska_FileType, mkvHeader);
OPEN_AS (AvsProxy_FileType, avsHeader);
OPEN_AS (_3GPP_FileType, _3GPHeader);
OPEN_AS (Ogg_FileType, oggHeader);
case Mpeg_FileType:
thisIsMpeg:
// look if the idx exists
char tmpname[256];
ADM_assert(strlen(name)+5<256);;
strcpy(tmpname,name);
strcat(tmpname,".idx");
if(ADM_fileExist(tmpname))
{
return addFile(tmpname);
}
/* check for "Read-only file system" */
{
int fd = open(tmpname,O_CREAT|O_EXCL|O_WRONLY,S_IRUSR|S_IWUSR);
if( fd >= 0 )
{
close(fd);
unlink(tmpname);
printf("Filesystem is writable\n");
}else if( errno == EROFS ){
char *tmpdir = getenv("TMPDIR");
#ifdef CYG_MANGLING
printf("Filesystem is not writable, looking for somewhere else\n");
if( !tmpdir )
tmpdir = "c:";
snprintf(tmpname,256,"%s%s.idx",tmpdir,strrchr(name,'\\'));
#else
if( !tmpdir )
tmpdir = "/tmp";
snprintf(tmpname,256,"%s%s.idx",tmpdir,strrchr(name,'/'));
#endif
tmpname[255] = 0;
printf("Storing index in %s\n",tmpname);
if(ADM_fileExist(tmpname))
{
printf("Index present, loading it\n");
return addFile(tmpname);
}
}
}
if(tryIndexing(name,tmpname))
{
return addFile (tmpname);
}
return 0;
break;
case WorkBench_FileType:
return loadWorbench(name);
#if 0
case Script_FileType:
return parseScript(name);
#endif
case ECMAScript_FileType:
printf("****** This is an ecmascript, run it with avidemux2 --run yourscript *******\n");
printf("****** This is an ecmascript, run it with avidemux2 --run yourscript *******\n");
printf("****** This is an ecmascript, run it with avidemux2 --run yourscript *******\n");
return 0;
default:
if (type == Unknown_FileType)
{
printf ("\n not identified ...\n");
}
else
GUI_Error_HIG(_("File type identified but no loader support detected..."),
_("May be related to an old index file."));
return 0;
}
// check opening was successful
if (ret == 0) {
char str[512+1];
snprintf(str,512,_("Attempt to open %s failed!"), name);
str[512] = '\0';
GUI_Error_HIG(str,NULL);
delete _videos[_nb_video]._aviheader;;
return 0;
}
/* check for resolution */
if( _nb_video ){
/* append operation */
aviInfo info0, infox;
_videos[ 0 ]._aviheader->getVideoInfo (&info0);
_videos[_nb_video]._aviheader->getVideoInfo (&infox);
if( info0.width != infox.width || info0.height != infox.height ){
char str[512+1];
str[0] = '\0';
if( info0.width != infox.width )
strcpy(str,"width");
if( info0.height != infox.height )
snprintf(str+strlen(str),512-strlen(str),
"%sheight%sdifferent between first and this video stream",
(strlen(str)?" and ":""),
(strlen(str)?" are ":" is ") );
str[512] = '\0';
GUI_Error_HIG(str,_("You cannot mix different video dimensions yet. Using the partial video filter later, will not work around this problem. The workaround is:\n1.) \"resize\" / \"add border\" / \"crop\" each stream to the same resolution\n2.) concatinate them together"));
delete _videos[_nb_video]._aviheader;;
return 0;
}
}
// else update info
_videos[_nb_video]._aviheader->getVideoInfo (&info);
_videos[_nb_video]._aviheader->setMyName (name);
// 1st if it is our first video we update postproc
if(!_nb_video)
{
uint32_t type,value;
if(!prefs->get(DEFAULT_POSTPROC_TYPE,&type)) type=3;
if(!prefs->get(DEFAULT_POSTPROC_VALUE,&value)) value=3;
deletePostProc(&_pp );
initPostProc(&_pp,info.width,info.height);
_pp.postProcType=type;
_pp.postProcStrength=value;
_pp.forcedQuant=0;
updatePostProc(&_pp);
if(_imageBuffer) delete _imageBuffer;
_imageBuffer=new ADMImage(info.width,info.height);
_imageBuffer->_qSize= ((info.width+15)>>4)*((info.height+15)>>4);
_imageBuffer->quant=new uint8_t[_imageBuffer->_qSize];
_imageBuffer->_qStride=(info.width+15)>>4;
}
/***************************************************************
* Function: CodeParser::parseScript()
* Purpose : Parse the XML root element
* Initial : Maxime Chevalier-Boisvert on November 18, 2008
****************************************************************
Revisions and bug fixes:
*/
CompUnits CodeParser::parseXMLRoot(const XML::Element* pTreeRoot)
{
// Create a list to store parsed functions
CompUnits functionList;
// If the root tag is not the compilation units, throw an exception
if (pTreeRoot->getName() != "CompilationUnits")
{
// TODO: implement error list parsing
std::cout << "XML tree: " << pTreeRoot->toString(true, 0) << std::endl;
throw XML::ParseError("Expected compilation units: \"" + pTreeRoot->getName() + "\"", pTreeRoot->getTextPos());
}
// If the verbose output flag is set
if (ConfigManager::s_verboseVar.getBoolValue() == true)
{
// Log the number of compilation units
std::cout << "Number of compilation units: " << pTreeRoot->getNumChildren() << std::endl;
}
// For each compilation unit
for (size_t i = 0; i < pTreeRoot->getNumChildren(); ++i)
{
// Get a pointer to this element
XML::Element* pUnitElement = pTreeRoot->getChildElement(i);
// If this is a function list
if (pUnitElement->getName() == "FunctionList")
{
// Get the list of functions
const std::vector<XML::Node*>& functions = pUnitElement->getChildren();
// For each function
for (std::vector<XML::Node*>::const_iterator itr = functions.begin(); itr != functions.end(); ++itr)
{
// If this is not an XML element, throw an exception
if ((*itr)->getType() != XML::Node::ELEMENT)
throw XML::ParseError("Unexpected XML node type in function list");
// Get a pointer to this element
XML::Element* pFuncElement = (XML::Element*)*itr;
// If this ia a function declaration
if (pFuncElement->getName() == "Function")
{
// Parse the function
IIRNode* pNewNode = parseFunction(pFuncElement);
// Add the function to the list
functionList.push_back(pNewNode);
}
// If this is a symbol table
else if (pFuncElement->getName() == "Symboltable")
{
// Ignore for now
}
// Otherwise
else
{
// This is an invalid element, throw an exception
throw XML::ParseError("Invalid element in function list: \"" + pFuncElement->getName() + "\"", pFuncElement->getTextPos());
}
}
}
// If this is a script
else if (pUnitElement->getName() == "Script")
{
// Parse the script
IIRNode* pNewNode = parseScript(pUnitElement);
// Add the function to the list
functionList.push_back(pNewNode);
}
// Otherwise
else
{
// This is an invalid element, throw an exception
throw XML::ParseError("Invalid element in compilation unit list: \"" + pUnitElement->getName() + "\"", pUnitElement->getTextPos());
}
}
// If the verbose output flag is set
if (ConfigManager::s_verboseVar.getBoolValue() == true)
{
// Output parsed IIR
std::cout << std::endl;
std::cout << "Constructed IIR:" << std::endl;
for (CompUnits::iterator itr = functionList.begin(); itr != functionList.end(); ++itr)
std::cout << ((*itr) == NULL? "NULL":(*itr)->toString()) << std::endl << std::endl;
std::cout << std::endl;
// Log that the parsing was successful
std::cout << "Parsing successful" << std::endl;
}
// Return the parsed function list
return functionList;
}