ParsedInclude parseInclude (String const& line, String const& trimmed)
{
ParsedInclude parsed;
if (trimmed.startsWithChar ('#'))
{
const String removed = trimmed.removeCharacters (" \t");
if (removed.startsWithIgnoreCase ("#include\""))
{
parsed.endOfInclude = line.indexOfChar (line.indexOfChar ('\"') + 1, '\"') + 1;
parsed.filename = line.fromFirstOccurrenceOf ("\"", false, false)
.upToLastOccurrenceOf ("\"", false, false);
parsed.isIncludeLine = true;
parsed.preventReinclude = m_preventReincludes.contains (parsed.filename);
parsed.forceReinclude = m_forceReincludes.contains (parsed.filename);
}
else if (removed.startsWithIgnoreCase ("#include<"))
{
if (m_checkSystemIncludes) {
parsed.endOfInclude = line.indexOfChar (line.indexOfChar ('<') + 1, '>') + 1;
parsed.filename = line.fromFirstOccurrenceOf ("<", false, false)
.upToLastOccurrenceOf (">", false, false);
parsed.isIncludeLine = true;
parsed.preventReinclude = m_preventReincludes.contains (parsed.filename);
parsed.forceReinclude = m_forceReincludes.contains (parsed.filename);
}
}
else if (removed.startsWithIgnoreCase ("#include"))
{
String name;
#if 1
if (line.contains ("/*"))
name = line.fromFirstOccurrenceOf ("#include", false, false)
.upToFirstOccurrenceOf ("/*", false, false).trim ();
else
name = line.fromFirstOccurrenceOf ("#include", false, false).trim ();
parsed.endOfInclude = line.upToFirstOccurrenceOf (name, true, false).length ();
#else
name = line.fromFirstOccurrenceOf ("#include", false, false).trim ();
#endif
String value = m_macrosDefined [name];
if (m_verbose)
std::cout << "name = " << name << "\n";
if (value.startsWithIgnoreCase ("\""))
{
parsed.endOfInclude = line.trimEnd().length () + 1;
parsed.filename = value.fromFirstOccurrenceOf ("\"", false, false)
.upToLastOccurrenceOf ("\"", false, false);
parsed.isIncludeLine = true;
}
else if (value.startsWithIgnoreCase ("<") && m_checkSystemIncludes)
{
parsed.endOfInclude = line.trimEnd().length () + 1;
parsed.filename = value.fromFirstOccurrenceOf ("<", false, false)
.upToLastOccurrenceOf (">", false, false);
parsed.isIncludeLine = true;
}
parsed.preventReinclude = parsed.isIncludeLine && m_preventReincludes.contains (name);
parsed.forceReinclude = parsed.isIncludeLine && m_forceReincludes.contains (name);
}
}
return parsed;
}
WebInputStream (const String& address_, bool isPost_, const MemoryBlock& postData_,
URL::OpenStreamProgressCallback* progressCallback, void* progressCallbackContext,
const String& headers_, int timeOutMs_, StringPairArray* responseHeaders,
int numRedirectsToFollow, const String& httpRequestCmd_)
: statusCode (0), connection (0), request (0),
address (address_), headers (headers_), postData (postData_), position (0),
finished (false), isPost (isPost_), timeOutMs (timeOutMs_), httpRequestCmd (httpRequestCmd_)
{
while (numRedirectsToFollow-- >= 0)
{
createConnection (progressCallback, progressCallbackContext);
if (! isError())
{
DWORD bufferSizeBytes = 4096;
StringPairArray dataHeaders (false);
for (;;)
{
HeapBlock<char> buffer ((size_t) bufferSizeBytes);
if (HttpQueryInfo (request, HTTP_QUERY_RAW_HEADERS_CRLF, buffer.getData(), &bufferSizeBytes, 0))
{
StringArray headersArray;
headersArray.addLines (String (reinterpret_cast<const WCHAR*> (buffer.getData())));
for (int i = 0; i < headersArray.size(); ++i)
{
const String& header = headersArray[i];
const String key (header.upToFirstOccurrenceOf (": ", false, false));
const String value (header.fromFirstOccurrenceOf (": ", false, false));
const String previousValue (dataHeaders[key]);
dataHeaders.set (key, previousValue.isEmpty() ? value : (previousValue + "," + value));
}
break;
}
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
break;
bufferSizeBytes += 4096;
}
DWORD status = 0;
DWORD statusSize = sizeof (status);
if (HttpQueryInfo (request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &statusSize, 0))
{
statusCode = (int) status;
if (numRedirectsToFollow >= 0
&& (statusCode == 301 || statusCode == 302 || statusCode == 303 || statusCode == 307))
{
String newLocation (dataHeaders["Location"]);
// Check whether location is a relative URI - this is an incomplete test for relative path,
// but we'll use it for now (valid protocols for this implementation are http, https & ftp)
if (! (newLocation.startsWithIgnoreCase ("http://")
|| newLocation.startsWithIgnoreCase ("https://")
|| newLocation.startsWithIgnoreCase ("ftp://")))
{
if (newLocation.startsWithChar ('/'))
newLocation = URL (address).withNewSubPath (newLocation).toString (true);
else
newLocation = address + "/" + newLocation;
}
if (newLocation.isNotEmpty() && newLocation != address)
{
address = newLocation;
continue;
}
}
}
if (responseHeaders != nullptr)
responseHeaders->addArray (dataHeaders);
}
break;
}
}
//==============================================================================
String File::parseAbsolutePath (const String& p)
{
if (p.isEmpty())
return String::empty;
#if JUCE_WINDOWS
// Windows..
String path (p.replaceCharacter ('/', '\\'));
if (path.startsWithChar (separator))
{
if (path[1] != separator)
{
/* When you supply a raw string to the File object constructor, it must be an absolute path.
If you're trying to parse a string that may be either a relative path or an absolute path,
you MUST provide a context against which the partial path can be evaluated - you can do
this by simply using File::getChildFile() instead of the File constructor. E.g. saying
"File::getCurrentWorkingDirectory().getChildFile (myUnknownPath)" would return an absolute
path if that's what was supplied, or would evaluate a partial path relative to the CWD.
*/
jassertfalse;
path = File::getCurrentWorkingDirectory().getFullPathName().substring (0, 2) + path;
}
}
else if (! path.containsChar (':'))
{
/* When you supply a raw string to the File object constructor, it must be an absolute path.
If you're trying to parse a string that may be either a relative path or an absolute path,
you MUST provide a context against which the partial path can be evaluated - you can do
this by simply using File::getChildFile() instead of the File constructor. E.g. saying
"File::getCurrentWorkingDirectory().getChildFile (myUnknownPath)" would return an absolute
path if that's what was supplied, or would evaluate a partial path relative to the CWD.
*/
jassertfalse;
return File::getCurrentWorkingDirectory().getChildFile (path).getFullPathName();
}
#else
// Mac or Linux..
// Yes, I know it's legal for a unix pathname to contain a backslash, but this assertion is here
// to catch anyone who's trying to run code that was written on Windows with hard-coded path names.
// If that's why you've ended up here, use File::getChildFile() to build your paths instead.
jassert ((! p.containsChar ('\\')) || (p.indexOfChar ('/') >= 0 && p.indexOfChar ('/') < p.indexOfChar ('\\')));
String path (p);
if (path.startsWithChar ('~'))
{
if (path[1] == separator || path[1] == 0)
{
// expand a name of the form "~/abc"
path = File::getSpecialLocation (File::userHomeDirectory).getFullPathName()
+ path.substring (1);
}
else
{
// expand a name of type "~dave/abc"
const String userName (path.substring (1).upToFirstOccurrenceOf ("/", false, false));
if (struct passwd* const pw = getpwnam (userName.toUTF8()))
path = addTrailingSeparator (pw->pw_dir) + path.fromFirstOccurrenceOf ("/", false, false);
}
}
else if (! path.startsWithChar (separator))
{
#if JUCE_DEBUG || JUCE_LOG_ASSERTIONS
if (! (path.startsWith ("./") || path.startsWith ("../")))
{
/* When you supply a raw string to the File object constructor, it must be an absolute path.
If you're trying to parse a string that may be either a relative path or an absolute path,
you MUST provide a context against which the partial path can be evaluated - you can do
this by simply using File::getChildFile() instead of the File constructor. E.g. saying
"File::getCurrentWorkingDirectory().getChildFile (myUnknownPath)" would return an absolute
path if that's what was supplied, or would evaluate a partial path relative to the CWD.
*/
jassertfalse;
#if JUCE_LOG_ASSERTIONS
Logger::writeToLog ("Illegal absolute path: " + path);
#endif
}
#endif
return File::getCurrentWorkingDirectory().getChildFile (path).getFullPathName();
}
#endif
while (path.endsWithChar (separator) && path != separatorString) // careful not to turn a single "/" into an empty string.
path = path.dropLastCharacters (1);
return path;
}
//==============================================================================
static bool parseFile (const File& rootFolder,
const File& newTargetFile,
OutputStream& dest,
const File& file,
StringArray& alreadyIncludedFiles,
const StringArray& includesToIgnore,
const StringArray& wildcards,
bool isOuterFile,
bool stripCommentBlocks)
{
if (! file.exists())
{
std::cout << "!! ERROR - file doesn't exist!";
return false;
}
StringArray lines;
lines.addLines (file.loadFileAsString());
if (lines.size() == 0)
{
std::cout << "!! ERROR - input file was empty: " << file.getFullPathName();
return false;
}
bool lastLineWasBlank = true;
for (int i = 0; i < lines.size(); ++i)
{
String line (lines[i]);
String trimmed (line.trimStart());
if ((! isOuterFile) && trimmed.startsWith ("//================================================================"))
line = String::empty;
if (trimmed.startsWithChar ('#')
&& trimmed.removeCharacters (" \t").startsWithIgnoreCase ("#include\""))
{
const int endOfInclude = line.indexOfChar (line.indexOfChar ('\"') + 1, '\"') + 1;
const String lineUpToEndOfInclude (line.substring (0, endOfInclude));
const String lineAfterInclude (line.substring (endOfInclude));
const String filename (line.fromFirstOccurrenceOf ("\"", false, false)
.upToLastOccurrenceOf ("\"", false, false));
const File targetFile (file.getSiblingFile (filename));
if (targetFile.exists() && targetFile.isAChildOf (rootFolder))
{
if (matchesWildcard (filename.replaceCharacter ('\\', '/'), wildcards)
&& ! includesToIgnore.contains (targetFile.getFileName()))
{
if (line.containsIgnoreCase ("FORCE_AMALGAMATOR_INCLUDE")
|| ! alreadyIncludedFiles.contains (targetFile.getFullPathName()))
{
if (! canFileBeReincluded (targetFile))
alreadyIncludedFiles.add (targetFile.getFullPathName());
dest << newLine << "/*** Start of inlined file: " << targetFile.getFileName() << " ***/" << newLine;
if (! parseFile (rootFolder, newTargetFile,
dest, targetFile, alreadyIncludedFiles, includesToIgnore,
wildcards, false, stripCommentBlocks))
{
return false;
}
dest << "/*** End of inlined file: " << targetFile.getFileName() << " ***/" << newLine << newLine;
line = lineAfterInclude;
}
else
{
line = String::empty;
}
}
else
{
line = lineUpToEndOfInclude.upToFirstOccurrenceOf ("\"", true, false)
+ targetFile.getRelativePathFrom (newTargetFile.getParentDirectory())
.replaceCharacter ('\\', '/')
+ "\""
+ lineAfterInclude;
}
}
}
if ((stripCommentBlocks || i == 0) && trimmed.startsWith ("/*") && (i > 10 || ! isOuterFile))
{
int originalI = i;
String originalLine = line;
for (;;)
{
int end = line.indexOf ("*/");
if (end >= 0)
{
line = line.substring (end + 2);
// If our comment appeared just before an assertion, leave it in, as it
// might be useful..
if (lines [i + 1].contains ("assert")
|| lines [i + 2].contains ("assert"))
{
i = originalI;
line = originalLine;
}
break;
}
line = lines [++i];
if (i >= lines.size())
break;
}
line = line.trimEnd();
if (line.isEmpty())
continue;
}
line = line.trimEnd();
{
// Turn initial spaces into tabs..
int numIntialSpaces = 0;
int len = line.length();
while (numIntialSpaces < len && line [numIntialSpaces] == ' ')
++numIntialSpaces;
if (numIntialSpaces > 0)
{
int tabSize = 4;
int numTabs = numIntialSpaces / tabSize;
line = String::repeatedString ("\t", numTabs) + line.substring (numTabs * tabSize);
}
if (! line.containsChar ('"'))
{
// turn large areas of spaces into tabs - this will mess up alignment a bit, but
// it's only the amalgamated file, so doesn't matter...
line = line.replace (" ", "\t", false);
line = line.replace (" ", "\t", false);
}
}
if (line.isNotEmpty() || ! lastLineWasBlank)
dest << line << newLine;
lastLineWasBlank = line.isEmpty();
}
return true;
}
void XmlDocument::readChildElements (XmlElement& parent)
{
LinkedListPointer<XmlElement>::Appender childAppender (parent.firstChildElement);
for (;;)
{
const String::CharPointerType preWhitespaceInput (input);
skipNextWhiteSpace();
if (outOfData)
{
setLastError ("unmatched tags", false);
break;
}
if (*input == '<')
{
const juce_wchar c1 = input[1];
if (c1 == '/')
{
// our close tag..
const int closeTag = input.indexOf ((juce_wchar) '>');
if (closeTag >= 0)
input += closeTag + 1;
break;
}
if (c1 == '!' && CharacterFunctions::compareUpTo (input + 2, CharPointer_ASCII ("[CDATA["), 7) == 0)
{
input += 9;
const String::CharPointerType inputStart (input);
for (;;)
{
const juce_wchar c0 = *input;
if (c0 == 0)
{
setLastError ("unterminated CDATA section", false);
outOfData = true;
break;
}
else if (c0 == ']'
&& input[1] == ']'
&& input[2] == '>')
{
childAppender.append (XmlElement::createTextElement (String (inputStart, input)));
input += 3;
break;
}
++input;
}
}
else
{
// this is some other element, so parse and add it..
if (XmlElement* const n = readNextElement (true))
childAppender.append (n);
else
break;
}
}
else // must be a character block
{
input = preWhitespaceInput; // roll back to include the leading whitespace
MemoryOutputStream textElementContent;
bool contentShouldBeUsed = ! ignoreEmptyTextElements;
for (;;)
{
const juce_wchar c = *input;
if (c == '<')
{
if (input[1] == '!' && input[2] == '-' && input[3] == '-')
{
input += 4;
const int closeComment = input.indexOf (CharPointer_ASCII ("-->"));
if (closeComment < 0)
{
setLastError ("unterminated comment", false);
outOfData = true;
return;
}
input += closeComment + 3;
continue;
}
break;
}
if (c == 0)
{
setLastError ("unmatched tags", false);
outOfData = true;
return;
}
if (c == '&')
{
String entity;
readEntity (entity);
if (entity.startsWithChar ('<') && entity [1] != 0)
{
const String::CharPointerType oldInput (input);
const bool oldOutOfData = outOfData;
input = entity.getCharPointer();
outOfData = false;
while (XmlElement* n = readNextElement (true))
childAppender.append (n);
input = oldInput;
outOfData = oldOutOfData;
}
else
{
textElementContent << entity;
contentShouldBeUsed = contentShouldBeUsed || entity.containsNonWhitespaceChars();
}
}
else
{
for (;;)
{
const juce_wchar nextChar = *input;
if (nextChar == '<' || nextChar == '&')
break;
if (nextChar == 0)
{
setLastError ("unmatched tags", false);
outOfData = true;
return;
}
textElementContent.appendUTF8Char (nextChar);
contentShouldBeUsed = contentShouldBeUsed || ! CharacterFunctions::isWhitespace (nextChar);
++input;
}
}
}
if (contentShouldBeUsed)
childAppender.append (XmlElement::createTextElement (textElementContent.toUTF8()));
}
}
}
void XmlDocument::readChildElements (XmlElement* parent)
{
LinkedListPointer<XmlElement>::Appender childAppender (parent->firstChildElement);
for (;;)
{
const String::CharPointerType preWhitespaceInput (input);
skipNextWhiteSpace();
if (outOfData)
{
setLastError ("unmatched tags", false);
break;
}
if (*input == '<')
{
if (input[1] == '/')
{
// our close tag..
const int closeTag = input.indexOf ((juce_wchar) '>');
if (closeTag >= 0)
input += closeTag + 1;
break;
}
else if (input[1] == '!'
&& input[2] == '['
&& input[3] == 'C'
&& input[4] == 'D'
&& input[5] == 'A'
&& input[6] == 'T'
&& input[7] == 'A'
&& input[8] == '[')
{
input += 9;
const String::CharPointerType inputStart (input);
size_t len = 0;
for (;;)
{
if (*input == 0)
{
setLastError ("unterminated CDATA section", false);
outOfData = true;
break;
}
else if (input[0] == ']'
&& input[1] == ']'
&& input[2] == '>')
{
input += 3;
break;
}
++input;
++len;
}
childAppender.append (XmlElement::createTextElement (String (inputStart, len)));
}
else
{
// this is some other element, so parse and add it..
if (XmlElement* const n = readNextElement (true))
childAppender.append (n);
else
break;
}
}
else // must be a character block
{
input = preWhitespaceInput; // roll back to include the leading whitespace
String textElementContent;
for (;;)
{
const juce_wchar c = *input;
if (c == '<')
break;
if (c == 0)
{
setLastError ("unmatched tags", false);
outOfData = true;
return;
}
if (c == '&')
{
String entity;
readEntity (entity);
if (entity.startsWithChar ('<') && entity [1] != 0)
{
const String::CharPointerType oldInput (input);
const bool oldOutOfData = outOfData;
input = entity.getCharPointer();
outOfData = false;
for (;;)
{
XmlElement* const n = readNextElement (true);
if (n == nullptr)
break;
childAppender.append (n);
}
input = oldInput;
outOfData = oldOutOfData;
}
else
{
textElementContent += entity;
}
}
else
{
const String::CharPointerType start (input);
size_t len = 0;
for (;;)
{
const juce_wchar nextChar = *input;
if (nextChar == '<' || nextChar == '&')
{
break;
}
else if (nextChar == 0)
{
setLastError ("unmatched tags", false);
outOfData = true;
return;
}
++input;
++len;
}
textElementContent.appendCharPointer (start, len);
}
}
if ((! ignoreEmptyTextElements) || textElementContent.containsNonWhitespaceChars())
{
childAppender.append (XmlElement::createTextElement (textElementContent));
}
}
}
}
