bool File::ReadAllText(WString& text)const
{
FileStream fileStream(filePath.GetFullPath(), FileStream::ReadOnly);
if (!fileStream.IsAvailable()) return false;
BomDecoder decoder;
DecoderStream decoderStream(fileStream, decoder);
StreamReader reader(decoderStream);
text = reader.ReadToEnd();
return true;
}
bool File::ReadAllLines(collections::List<WString>& lines)const
{
FileStream fileStream(filePath.GetFullPath(), FileStream::ReadOnly);
if (!fileStream.IsAvailable()) return false;
BomDecoder decoder;
DecoderStream decoderStream(fileStream, decoder);
StreamReader reader(decoderStream);
while (!reader.IsEnd())
{
lines.Add(reader.ReadLine());
}
return true;
}
Ptr<DocumentModel> DocumentModel_Constructor(const WString& path)
{
FileStream fileStream(path, FileStream::ReadOnly);
if(!fileStream.IsAvailable()) return 0;
BomDecoder decoder;
DecoderStream decoderStream(fileStream, decoder);
StreamReader reader(decoderStream);
WString xmlText=reader.ReadToEnd();
Ptr<ParsingTable> table=XmlLoadTable();
Ptr<XmlDocument> xml=XmlParseDocument(xmlText, table);
if(!xml) return 0;
List<WString> errors;
return DocumentModel::LoadFromXml(xml, GetFolderPath(path), errors);
}
Ptr<text::DocumentModel> BuildDocumentModel(const WString& fileName, List<Ptr<GifRun>>& animations)
{
HDC dc=CreateCompatibleDC(NULL);
int dpi=GetDeviceCaps(dc, LOGPIXELSY);
DeleteDC(dc);
Ptr<text::DocumentModel> document=new text::DocumentModel;
WString rawDocument;
{
FileStream fileStream(fileName, FileStream::ReadOnly);
BomDecoder decoder;
DecoderStream decoderStream(fileStream, decoder);
StreamReader reader(decoderStream);
rawDocument=reader.ReadToEnd();
}
WString regexTag_s=L"<(<tag>s)>(<font>[^:]+):(<bold>[^:]+):(<color>[^:]+):(<size>[^:]+):(<text>/.*?)<//s>";
WString regexTag_i=L"<(<tag>i)>(<cx>[^:]+),(<cy>[^:]+):(<b>[^:]+):(<file>/.*?)<//i>";
WString regexTag_p=L"<(<tag>p)//>";
Regex regexTag(regexTag_s+L"|"+regexTag_i+L"|"+regexTag_p);
Regex regexLine(L"\r\n");
RegexMatch::List matches;
regexTag.Search(rawDocument, matches);
Ptr<text::DocumentParagraph> paragraph=0;
Ptr<text::DocumentLine> line=0;
for(int i=0;i<matches.Count();i++)
{
Ptr<RegexMatch> match=matches[i];
if(match->Groups()[L"tag"].Get(0).Value()==L"p")
{
paragraph=0;
line=0;
}
else if(match->Groups()[L"tag"].Get(0).Value()==L"i")
{
int cx=wtoi(match->Groups()[L"cx"].Get(0).Value());
int cy=wtoi(match->Groups()[L"cy"].Get(0).Value());
int b=wtoi(match->Groups()[L"b"].Get(0).Value());
WString file=match->Groups()[L"file"].Get(0).Value();
if(!paragraph)
{
paragraph=new text::DocumentParagraph;
document->paragraphs.Add(paragraph);
line=0;
}
if(!line)
{
line=new text::DocumentLine;
paragraph->lines.Add(line);
}
Ptr<text::DocumentImageRun> run=new text::DocumentImageRun;
run->size=Size(cx, cy);
run->baseline=b;
run->image=GetCurrentController()->ImageService()->CreateImageFromFile(L"..\\Resources\\"+file);
run->frameIndex=0;
line->runs.Add(run);
if(run->image->GetFrameCount()>1)
{
Ptr<GifRun> gifRun=new GifRun;
gifRun->imageRun=run;
gifRun->paragraphIndex=document->paragraphs.Count()-1;
animations.Add(gifRun);
}
}
else if(match->Groups()[L"tag"].Get(0).Value()==L"s")
{
FontProperties fontStyle;
Color fontColor;
RegexMatch::List lines;
{
WString font=match->Groups()[L"font"].Get(0).Value();
WString bold=match->Groups()[L"bold"].Get(0).Value();
WString color=match->Groups()[L"color"].Get(0).Value();
WString size=match->Groups()[L"size"].Get(0).Value();
WString text=match->Groups()[L"text"].Get(0).Value();
fontStyle.fontFamily=font;
fontStyle.bold=bold==L"true";
fontStyle.size=(int)(wtof(size)*dpi/72);
fontColor=ConvertColor(color);
regexLine.Split(text, true, lines);
}
for(int j=0;j<lines.Count();j++)
{
WString lineText=lines[j]->Result().Value();
if(!paragraph)
{
paragraph=new text::DocumentParagraph;
document->paragraphs.Add(paragraph);
line=0;
}
if(!line || j>0)
{
line=new text::DocumentLine;
paragraph->lines.Add(line);
}
Ptr<text::DocumentTextRun> run=new text::DocumentTextRun;
run->style=fontStyle;
run->color=fontColor;
run->text=lineText;
line->runs.Add(run);
}
}
}
return document;
}
int main(int argc, char* argv[])
#endif
{
WString baseDirectory;
{
#if defined VCZH_MSVC
wchar_t currentDirectory[MAX_PATH]={0};
GetCurrentDirectory(MAX_PATH, currentDirectory);
baseDirectory=currentDirectory;
#elif defined VCZHGCC
char currentDirectory[1024]={0};
getcwd(currentDirectory, 1024);
baseDirectory=atow(currentDirectory);
#endif
if(baseDirectory[baseDirectory.Length()-1]!=PATH_DELIMITER)
{
baseDirectory+=PATH_DELIMITER;
}
}
Regex regexPathSplitter(L"[///\\]");
Ptr<ParsingGeneralParser> parser=CreateBootstrapStrictParser();
Console::SetTitle(L"Vczh Parser Generator for C++");
Console::SetColor(false, true, false, true);
Console::WriteLine(L"parsing>Files : "+itow(argc-1));
for(int i=1;i<argc;i++)
{
Console::WriteLine(L"------------------------------------------------------------");
#if defined VCZH_MSVC
WString inputPath=argv[i];
#elif defined VCZH_GCC
WString inputPath=atow(argv[i]);
#endif
if(inputPath.Length()<2 || inputPath[1]!=L':')
{
inputPath=baseDirectory+inputPath;
}
Console::WriteLine(L"parsing>Making : "+inputPath);
if(inputPath.Length()<11 || inputPath.Right(11)!=L".parser.txt")
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> The extenion name of the input file path must be \".parser.txt\".");
Console::SetColor(false, true, false, true);
}
else
{
WString name;
{
List<Ptr<RegexMatch>> matches;
regexPathSplitter.Split(inputPath, true, matches);
name=matches[matches.Count()-1]->Result().Value();
name=name.Left(name.Length()-11);
}
WString outputMetaPath=inputPath.Left(inputPath.Length()-11);
WString outputHeaderPath=outputMetaPath+L".h";
WString outputCppPath=outputMetaPath+L".cpp";
WString logPath=outputMetaPath+L".log";
Console::WriteLine(L"parsing>Output header path : "+outputHeaderPath);
Console::WriteLine(L"parsing>Output cpp path : "+outputCppPath);
Console::WriteLine(L"parsing>Log path : "+logPath);
CodegenConfig config;
WString codeGrammar;
{
FileStream fileStream(inputPath, FileStream::ReadOnly);
if(!fileStream.IsAvailable())
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Cannot open \""+inputPath+L" for read.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
BomDecoder decoder;
DecoderStream decoderStream(fileStream, decoder);
StreamReader reader(decoderStream);
if(!config.ReadConfig(reader))
{
goto STOP_PARSING;
}
codeGrammar=reader.ReadToEnd();
}
Ptr<ParsingDefinition> definition;
Ptr<ParsingTable> table;
{
FileStream fileStream(logPath, FileStream::WriteOnly);
if(!fileStream.IsAvailable())
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Cannot open \""+logPath+L" for write.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
BomEncoder encoder(BomEncoder::Utf16);
EncoderStream encoderStream(fileStream, encoder);
StreamWriter writer(encoderStream);
if(codeGrammar==L"<bootstrap-grammar>")
{
definition=CreateParserDefinition();
MemoryStream bootstrapStream;
{
StreamWriter bootstrapWriter(bootstrapStream);
Log(definition, bootstrapWriter);
}
bootstrapStream.SeekFromBegin(0);
StreamReader bootstrapReader(bootstrapStream);
codeGrammar=bootstrapReader.ReadToEnd();
}
else
{
definition=CreateDefinition(parser, codeGrammar, writer);
}
if(!definition)
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Error happened. Open \""+logPath+L" for details.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
table=CreateTable(definition, writer, config.ambiguity);
if(!table)
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Error happened. Open \""+logPath+L" for details.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
}
{
FileStream fileStream(outputHeaderPath, FileStream::WriteOnly);
if(!fileStream.IsAvailable())
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Cannot open \""+outputHeaderPath+L" for write.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
BomEncoder encoder(BomEncoder::Mbcs);
EncoderStream encoderStream(fileStream, encoder);
StreamWriter writer(encoderStream);
WriteHeaderFile(name, definition, table, config, writer);
}
{
FileStream fileStream(outputCppPath, FileStream::WriteOnly);
if(!fileStream.IsAvailable())
{
Console::SetColor(true, false, false, true);
Console::WriteLine(L"error> Cannot open \""+outputCppPath+L" for write.");
Console::SetColor(false, true, false, true);
goto STOP_PARSING;
}
BomEncoder encoder(BomEncoder::Mbcs);
EncoderStream encoderStream(fileStream, encoder);
StreamWriter writer(encoderStream);
config.includes.Clear();
config.includes.Add(L"\""+name+L".h\"");
WriteCppFile(name, codeGrammar, definition, table, config, writer);
}
}
STOP_PARSING:;
}
Console::WriteLine(L"Finished!");
return 0;
}
