/** read all source files to their compilation units. Return true if no error. */
public boolean readSourceFiles() {
for (CompilationUnit compilationUnit : program.getCompilationUnitList()) {
try {
compilationUnit.readSourceFile();
} catch (Exception e) {
return false;
}
}
return true;
}
private static void apply_ati_ActionsToGenericPrototype(Env env, CompilationUnit compUnit) {
ICompiler_ati compiler_ati = new Compiler_ati(env);
CompilerManager_ati compilerManager = new CompilerManager_ati(env);
compUnit.ati_actions(compiler_ati, compilerManager);
/*
* all changes demanded by metaobject calls collected above are made in the call
* to CompilerManager_ati#changeCheckProgram.
*/
compilerManager.changeCheckProgram();
}
/**
* compile the project passed as parameter to the constructor. The basic packages of Cyan, stored
* in project <code>cyanLangPackageProject</code>, are added to the project. Currently there is
* only one basic package of the language: "cyan.lang". This should be included in every
* compilation.
*
* @return <code>false</code> in error
*/
public boolean compile(HashSet<saci.CompilationInstruction> compInstSet) {
Compiler compiler;
try {
// list of non-generic prototypes of the programc
nonGenericCompilationUnitList = new ArrayList<CompilationUnit>();
// list of generic prototypes of the program
ArrayList<CompilationUnit> genericCompilationUnitList = new ArrayList<CompilationUnit>();
/* separates the compilation units (source files) that have generic prototypes from
those that don´t.
A prototype whose file has a digit after '(' is a generic prototype. For example,
Proto(1)(1).cyan has a generic prototype Proto<T><R>. And file
MyData<main.Person><Int> is put in file MyData(main.Person)(Int).cyan.
*/
for (CompilationUnit compilationUnit : program.getCompilationUnitList()) {
/*
// if the file name has a '(' character followed by a digit, then it is a
// generic prototype. Note that "Stack(Int).cyan" contains prototype "Stack<Int>"
// which is not considered generic
*
*/
String filename = compilationUnit.getFilename();
boolean foundDigit = false;
int ifn = 0;
int sizeFilename = filename.length();
while (ifn < sizeFilename) {
if (filename.charAt(ifn) == '(' && Character.isDigit(filename.charAt(ifn + 1))) {
foundDigit = true;
break;
}
++ifn;
}
if (foundDigit) {
compilationUnit.setHasGenericPrototype(true);
genericCompilationUnitList.add(compilationUnit);
} else nonGenericCompilationUnitList.add(compilationUnit);
/*
if ( indexOfLeftPar > 0 && Character.isDigit(compilationUnit.getFilename().charAt(indexOfLeftPar + 1)) )
genericCompilationUnitList.add(compilationUnit);
else
nonGenericCompilationUnitList.add(compilationUnit);
*/
}
/**
* delete all files from "tmp" directories. If a generic prototype is in a directory "D", the
* Compiler creates the generic instantiations in "D\tmp". For example, if "Stack<T>" is in
* directory "util", the Compiler creates prototypes "Stack<Int>" and "Stack<Person>"
* (assuming the program uses "Stack<Int>" and "Stack<Person>") in directory "util\tmp".
*/
Set<String> pathCompilationUnitTable = new HashSet<String>();
for (CompilationUnit c : genericCompilationUnitList) {
pathCompilationUnitTable.add(c.getPackageCanonicalPath());
c.getCyanPackage().setHasGenericPrototype(true);
}
for (String path : pathCompilationUnitTable) {
File dir = new File(path + NameServer.temporaryDirName);
if (dir.exists()) for (File file : dir.listFiles()) file.delete();
}
String dotExtension = "." + NameServer.cyanSourceFileExtension;
boolean hasCompilationError = false;
/**
* first of all, parse all generic prototypes. This is not allowed in step 7 of the
* compilation because all generic prototype instantiation should have been created before
* that.
*/
if (this.compilationStep.compareTo(CompilationStep.step_7) < 0) {
for (CompilationUnit compilationUnit : genericCompilationUnitList) {
compiler = new Compiler(compilationUnit, compInstSet, compilationStep, project, null);
compiler.parse();
/**
* print the errors found in the generic prototypes and apply all actions to them. An
* action is a small refactoring like insert a ";"
*/
if (compilationUnit.hasCompilationError()) {
// compilationUnit.printErrorList(printWriter);
hasCompilationError = true;
}
if (compilationUnit.getActionList().size() > 0) compilationUnit.doActionList(printWriter);
}
}
/* if ( hasCompilationError )
return false;
*/
/*
* in the first step of this while statement, all non-generic prototypes are compiled.
*
* In the second step of the while statement, the real prototypes created in the previous step
* are compiled. They may instantiate new generic prototypes. For example, Stack<Int> may
* declare a variable of type "Array<Int>". This new Cyan prototype should be created and
* compiled. The process continues till no new prototypes should be created.
*/
CompilationUnit compilationUnit;
int numCompilationUnitsAlreadyCompiled = 0;
int sizeNonGenericCompilationUnitList;
while (numCompilationUnitsAlreadyCompiled < nonGenericCompilationUnitList.size()) {
sizeNonGenericCompilationUnitList = nonGenericCompilationUnitList.size();
boolean thereWasErrors = false;
// parse of all source files that were not yet parsed. That may include some
// generic prototypes that were instantiated in the previous round of the above
// while statement.
for (int i = numCompilationUnitsAlreadyCompiled;
i < sizeNonGenericCompilationUnitList;
i++) {
compilationUnit = nonGenericCompilationUnitList.get(i);
// System.out.println("cc: " + compilationUnit.getFilename());
compiler = new Compiler(compilationUnit, compInstSet, compilationStep, project, null);
compiler.parse();
// if ( ! compilationUnit.hasCompilationError() ) {
// }
if (compilationUnit.hasCompilationError()) {
thereWasErrors = true;
// compilationUnit.printErrorList(printWriter);
} else if (compInstSet.contains(CompilationInstruction.createPrototypesForInterfaces)
&& compilationUnit.getPrototypeIsNotGeneric()
&& compilationUnit.getPublicPrototype() instanceof InterfaceDec) {
// if public program unit is an interface, create ProtoInterface
CompilationUnit newCompilationUnit = compilationUnit.createProtoInterface();
if (newCompilationUnit == null) {
if (compilationUnit.hasCompilationError()) {
thereWasErrors = true;
compilationUnit.printErrorList(printWriter);
}
} else {
CyanPackage thisCyanPackage = compilationUnit.getCyanPackage();
thisCyanPackage.addCompilationUnit(newCompilationUnit);
newCompilationUnit.setCyanPackage(thisCyanPackage);
nonGenericCompilationUnitList.add(newCompilationUnit);
String name = newCompilationUnit.getFilename();
int indexDotCyan = name.indexOf(dotExtension);
if (indexDotCyan > 0) name = name.substring(0, indexDotCyan);
program.addCompilationUnit(newCompilationUnit);
if (nameSet.contains(newCompilationUnit.getFilename()))
System.out.println("error: " + newCompilationUnit.getFilename());
else nameSet.add(newCompilationUnit.getFilename());
}
}
// if there was not any errors and there is a list of actions ...
/*if ( compilationUnit.getActionList().size() > 0 )
compilationUnit.doActionList(printWriter);
compilationUnit.clearErrorsActions(); */
}
if (thereWasErrors) {
return false;
}
numCompilationUnitsAlreadyCompiled = sizeNonGenericCompilationUnitList;
}
} catch (Exception e) {
System.out.println(
"Internal error at CompilerManager::compile(). e = " + e.getClass().getName());
e.printStackTrace();
return false;
}
project.printErrorList(printWriter);
return true;
}
/**
* Create an instantiation of a generic prototype given by parameter gt
*
* @param gt
* @param env
* @return
*/
private CompilationUnit createGenericPrototypeInstantiation(
ExprGenericPrototypeInstantiation gt, Env env) {
CompilationUnit genericProto = null;
/* if ( gt.getName().equals("generic02.gb.G1<X>") ) {
System.out.println("generic02.gb.G1<X>");
gt.ifPrototypeReturnsNameWithPackageAndType(env);
} */
String genSourceFileName = gt.getGenericSourceFileName();
String genSourceFileNameVaryingNumberOfParameters =
gt.getGenericSourceFileNameWithVaryingNumberOfParameters();
// if ( gt.getRealTypeListList().size() > 1 )
// System.out.println("3");
boolean isInterface = false;
if (NameServer.isPrototypeFromInterface(genSourceFileName)) {
// int sizePrefix = NameServer.prefixProtoInterface.length();
isInterface = true;
/*
genSourceFileName = genSourceFileName.substring(sizePrefix);
genSourceFileNameVaryingNumberOfParameters = genSourceFileNameVaryingNumberOfParameters.substring(sizePrefix);
*/
genSourceFileName = NameServer.prototypeFileNameFromInterfaceFileName(genSourceFileName);
genSourceFileNameVaryingNumberOfParameters =
NameServer.prototypeFileNameFromInterfaceFileName(
genSourceFileNameVaryingNumberOfParameters);
}
// something like util.Stack if gt is "util.Stack<Int>" or
// Stack if gt is Stack<Int>
ExprIdentStar typeIdent = gt.getTypeIdent();
if (typeIdent.getIdentSymbolArray().size() == 1) {
// no package preceding the generic prototype name as in "Stack<Int>"
ProgramUnit pu =
env.searchProgramUnitBySourceFileName(genSourceFileName, gt.getFirstSymbol(), false);
if (pu != null) {
genericProto = pu.getCompilationUnit();
ProgramUnit pu2 =
env.searchProgramUnitBySourceFileName(
genSourceFileNameVaryingNumberOfParameters, gt.getFirstSymbol(), false);
if (pu2 != null)
/* found both generic prototype and generic prototype with varying number of parameters
* Example: found both Tuple<T> and Tuple<T+>
*/
env.error(
gt.getFirstSymbol(),
"Ambiguity in creating a real prototype from a generic prototype. There is both "
+ pu.getCompilationUnit().getPackageName()
+ "."
+ genSourceFileName
+ " and "
+ pu2.getCompilationUnit().getPackageName()
+ "."
+ genSourceFileNameVaryingNumberOfParameters,
true);
}
if (genericProto == null) {
pu =
env.searchProgramUnitBySourceFileName(
genSourceFileNameVaryingNumberOfParameters, gt.getFirstSymbol(), false);
if (pu != null) genericProto = pu.getCompilationUnit();
}
} else {
// package preceding the generic prototype name as in "util.Stack<Int>"
int i = 0;
ArrayList<Symbol> symbolList = typeIdent.getIdentSymbolArray();
int sizeLessOne = symbolList.size() - 1;
String packageName = "";
while (i < sizeLessOne) {
packageName = packageName + symbolList.get(i).getSymbolString();
++i;
if (i < sizeLessOne) packageName += ".";
}
CyanPackage cyanPackage = env.getProject().searchPackage(packageName);
if (cyanPackage == null) {
env.error(typeIdent.getFirstSymbol(), "Package '" + packageName + "' was not found", true);
return null;
}
// first searches for something like "Stack(1)" in package 'util'
for (CompilationUnit cunit : cyanPackage.getCompilationUnitList()) {
if (genSourceFileName.equals(cunit.getFileNameWithoutExtension())) {
genericProto = cunit;
break;
}
}
CompilationUnit genericProto2 = null;
// searches for a generic prototype with varying number of parameters
// something like "Stack(1+)"
for (CompilationUnit cunit : cyanPackage.getCompilationUnitList()) {
if (genSourceFileNameVaryingNumberOfParameters.equals(
cunit.getFileNameWithoutExtension())) {
genericProto2 = cunit;
break;
}
}
if (genericProto != null && genericProto2 != null) {
env.error(
gt.getFirstSymbol(),
"Ambiguity in creating a real prototype from a generic prototype. There is both "
+ genericProto.getPackageName()
+ "."
+ genSourceFileName
+ " and "
+ genericProto2.getPackageName()
+ "."
+ genSourceFileNameVaryingNumberOfParameters,
true);
}
if (genericProto == null) genericProto = genericProto2;
}
// genericProto = nameGenProtoUnitTable.get(genSourceFileName);
if (genericProto == null) {
env.error(
true,
gt.getFirstSymbol(),
"Prototype '" + gt.getName() + "' was not found",
gt.getName(),
ErrorKind.prototype_was_not_found_inside_method);
/*gt.getProgramUnit().getCompilationUnit().error(null,
"Internal error at CompilerManager::createInterfaceObjectFunctionAndArray: cannot create " + gt.getName()); */
return null;
} else {
/**
* if there was no compilation error in "Stack(1).cyan", then create an instance of the
* generic prototype
*/
if (isInterface) {
gt.removeProtoPrefix();
}
CompilationUnit newCompilationUnit = genericProto.createInstanceGenericPrototype(gt, env);
CompilationUnit interCompilationUnit = null;
/**
* if the package for this generic prototype instantiation was not created before, create it
* now.
*/
CyanPackage cyanPackage = genericProto.getCyanPackage();
cyanPackage.addCompilationUnit(newCompilationUnit);
newCompilationUnit.setCyanPackage(cyanPackage);
nonGenericCompilationUnitList.add(newCompilationUnit);
if (nameSet.contains(newCompilationUnit.getFullFileNamePath())) {
env.error(gt.getFirstSymbol(), "Internal error in CompilerManager");
gt.ifPrototypeReturnsNameWithPackageAndType(env);
} else nameSet.add(newCompilationUnit.getFullFileNamePath());
program.addCompilationUnit(newCompilationUnit);
newCompilationUnit.readSourceFile();
HashSet<saci.CompilationInstruction> compInstSet = new HashSet<>();
compInstSet.add(CompilationInstruction.dpa_actions);
compInstSet.add(CompilationInstruction.pp_addCode);
if (compilationStep.compareTo(CompilationStep.step_5) >= 0)
compInstSet.add(CompilationInstruction.new_addCode);
Compiler compiler =
new Compiler(newCompilationUnit, compInstSet, compilationStep, project, null);
compiler.parse();
if (newCompilationUnit.hasCompilationError()) {
// newCompilationUnit.printErrorList(printWriter);
env.setThereWasError(true);
throw new CompileErrorException();
} else if (compInstSet.contains(CompilationInstruction.createPrototypesForInterfaces)
&& newCompilationUnit.getPrototypeIsNotGeneric()
&& newCompilationUnit.getPublicPrototype() instanceof InterfaceDec) {
// if public program unit is an interface, create ProtoInterface
interCompilationUnit = newCompilationUnit.createProtoInterface();
if (interCompilationUnit != null) {
interCompilationUnit.setCyanPackage(cyanPackage);
cyanPackage.addCompilationUnit(interCompilationUnit);
newCompilationUnit.setCyanPackage(cyanPackage);
nonGenericCompilationUnitList.add(interCompilationUnit);
String nameInter = interCompilationUnit.getFilename();
if (nameInter.endsWith(NameServer.dotCyanSourceFileExtension))
nameInter =
nameInter.substring(
0, nameInter.length() - NameServer.sizeCyanSourceFileExtensionPlusOne);
// nameRealGenProtoUnitTable.put(nameInter, interCompilationUnit);
program.addCompilationUnit(interCompilationUnit);
interCompilationUnit.readSourceFile();
compiler =
new Compiler(interCompilationUnit, compInstSet, compilationStep, project, null);
compiler.parse();
if (interCompilationUnit.getActionList().size() > 0)
interCompilationUnit.doActionList(printWriter);
interCompilationUnit.clearErrorsActions();
}
}
// newCompilationUnit.clearErrorsActions();
if (isInterface) return interCompilationUnit;
else return newCompilationUnit;
}
}
/**
* Create a generic prototype from parameter gpi. The new prototype is compiled. If it is an
* interface, the prototype Proto_IntefaceName is created too. Methods calcInterfaceTypes and
* calcInternalTypes are called for both the prototype and its Proto_InterfaceName, if any.
*
* @param gpi
* @param env
* @return
*/
public static ProgramUnit createGenericPrototype(ExprGenericPrototypeInstantiation gpi, Env env) {
saci.Tuple<String, Type> t = gpi.ifPrototypeReturnsNameWithPackageAndType(env);
// t.f1 is the name of the prototype
if (t != null && t.f2 != null) {
/*
* prototype has already been created before
*/
if (t.f2 instanceof ProgramUnit) {
return (ProgramUnit) t.f2;
} else {
env.error(
gpi.getFirstSymbol(),
"Internal error: a type that is not a program unit is used to instantiate a generic prototype");
return null;
}
} else {
/*
* prototype has not been created. Create it.
*/
// if ( env.getCurrentMethod() != null && env.getCurrentMethod().getName().contains("run2") )
// gpi.ifPrototypeReturnsItsNameWithPackage(env);
/*
* first, create all prototypes that are real parameters to this generic prototype instantiation
*/
for (ArrayList<Expr> realTypeList : gpi.getRealTypeListList()) {
for (Expr realType : realTypeList) {
if (realType instanceof ExprGenericPrototypeInstantiation) {
ExprGenericPrototypeInstantiation genRealType =
(ExprGenericPrototypeInstantiation) realType;
genRealType.setType(createGenericPrototype(genRealType, env));
// javaName = type.getJavaName();
genRealType.setJavaName(genRealType.getType().getJavaName());
}
}
}
CompilationUnit compUnit =
env.getProject().getCompilerManager().createGenericPrototypeInstantiation(gpi, env);
Env newEnv = new Env(env.getProject());
/*
* If a generic prototype is created when method calcInterfaceTypes of Program is being executed
* (env.getProject().getProgram().getInCalcInterfaceTypes() returns true), it is not necessary
* to call its method calcInterfaceTypes. It will be called in the loop of
* method Program::calcInterfaceTypes.
* If a generic prototype is created when method calcInternalTypes of Program is being executed,
* method calcInterfaceTypes of this generic prototype should be called because the interface
* of this prototype is necessary in methods calcInternalTypes. Method calcInternalTypes
* of this newly created generic prototype will be called in the loop of
* method Program::calcInternalTypes.
*
* calcInternalTypes cannot be called when a generic prototype is created when
* the compiler is calling calcInterfaceTypes. If this is allowed, some calcInternalType
* method could try to use the interface of some prototype P whose method calcInterfaceTypes
* have not been called.
*/
if (!env.getProject().getProgram().getInCalcInterfaceTypes()) {
compUnit.calcInterfaceTypes(newEnv);
// compUnit.calcInternalTypes(newEnv);
}
CompilationUnit interfaceCompilationUnit = compUnit.getInterfaceCompilationUnit();
if (interfaceCompilationUnit != null) {
newEnv = new Env(env.getProject());
if (!env.getProject().getProgram().getInCalcInterfaceTypes()) {
interfaceCompilationUnit.calcInterfaceTypes(newEnv);
}
}
/*
* if the generic prototype was created from phase (4), included, onwards, then execute
* the ati actions. A generic prototype instantiation can only change itself and
* no other prototype can change it.
*/
if (env.getProject().getCompilerManager().getCompilationStep().ordinal()
> CompilationStep.step_3.ordinal()) {
apply_ati_ActionsToGenericPrototype(newEnv, compUnit);
if (interfaceCompilationUnit != null) {
apply_ati_ActionsToGenericPrototype(env, interfaceCompilationUnit);
}
}
return compUnit.getPublicPrototype();
}
}