import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
private LessSource source(final String filename) throws StringSourceException {
  String[] files = {path + filename, filename };
  for (String file : files) {
    InputStream stream = getClass().getResourceAsStream(file);
    if (stream != null) {
      try {
        return new LessStrSource(
            new String(ByteStreams.toByteArray(stream), StandardCharsets.UTF_8), file);
      } catch (IOException ex) {
        log.debug("Can't read file: " + path, ex);
        throw new StringSourceException();
      } finally {
        Closeables.closeQuietly(stream);
      }
    }
  }
  throw new StringSourceException();
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
public static com.github.sommeri.less4j.core.ast.StyleSheet getLessStyleSheet(LessSource source) throws ParseException {
	
	ANTLRParser parser = new ANTLRParser();
	
	ANTLRParser.ParseResult result;
	ProblemsHandler problemsHandler = new ProblemsHandler();
	com.github.sommeri.less4j.core.ast.StyleSheet lessStyleSheet;
	ASTBuilder astBuilder = new ASTBuilder(problemsHandler);
	try {
		
		result = parser.parseStyleSheet(source.getContent(), source);

		lessStyleSheet = astBuilder.parseStyleSheet(result.getTree());			

	} catch (FileNotFound | CannotReadFile | BugHappened ex) {
		throw new ParseException(ex);
	}
	return lessStyleSheet;
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
@Override
public LessResource relativeSource(final String filename) throws LessSource.FileNotFound,
                                                                 LessSource.CannotReadFile,
                                                                 LessSource.StringSourceException {
    final Path relativePath = path.getParent().resolve(filename);
    return new LessResource(relativePath);
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
@Override
protected void sendResource(URL resourceUrl, RouteContext routeContext) throws IOException {
    try {
        // compile less to css
        log.trace("Send css for '{}'", resourceUrl);
        LessSource.URLSource source = new LessSource.URLSource(resourceUrl);
        String content = source.getContent();
        String result = sourceMap.get(content);
        if (result == null) {
            ThreadUnsafeLessCompiler compiler = new ThreadUnsafeLessCompiler();
            LessCompiler.Configuration configuration = new LessCompiler.Configuration();
            configuration.setCompressing(minify);
            LessCompiler.CompilationResult compilationResult = compiler.compile(resourceUrl, configuration);
            for (LessCompiler.Problem warning : compilationResult.getWarnings()) {
                log.warn("Line: {}, Character: {}, Message: {} ", warning.getLine(), warning.getCharacter(), warning.getMessage());
            }
            result = compilationResult.getCss();

            if (routeContext.getApplication().getPippoSettings().isProd()) {
                sourceMap.put(content, result);
            }
        }

        // send css
        routeContext.getResponse().contentType("text/css");
        routeContext.getResponse().ok().send(result);
    } catch (Exception e) {
        throw new PippoRuntimeException(e);
    }
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
@Override
public String process(final String filename, final String source, final Config conf)
    throws Exception {
  String path = filename;
  try {
    LessCompiler compiler = new ThreadUnsafeLessCompiler();
    LessSource src = new LessStrSource(source, path);

    CompilationResult result = compiler.compile(src, lessConf(conf));

    result.getWarnings().forEach(warn -> {
      log.warn("{}:{}:{}:{}: {}", path, warn.getType(), warn.getLine(),
          warn.getCharacter(), warn.getMessage());
    });

    if (path.endsWith(".map")) {
      return result.getSourceMap();
    } else {
      return result.getCss();
    }
  } catch (Less4jException ex) {
    List<AssetProblem> problems = ex.getErrors().stream()
        .map(it -> new AssetProblem(path, it.getLine(), it.getCharacter(), it.getMessage(), null))
        .collect(Collectors.toList());
    throw new AssetException(name(), problems);
  }
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
@Override
public StyleSheet parseCSSString(String css) throws ParseException {
	
	com.github.sommeri.less4j.core.ast.StyleSheet lessStyleSheet = getLessStyleSheet(new LessSource.StringSource(css));
	
	try {
		
		LessStyleSheetAdapter adapter = new LessStyleSheetAdapter(lessStyleSheet);
		return adapter.getAdaptedStyleSheet();
		
	} catch (RuntimeException ex) {
		throw new ParseException(ex);
	}	
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
public static com.github.sommeri.less4j.core.ast.StyleSheet getLessParserFromStyleSheet(StyleSheet styleSheet) throws ParseException {

		if (styleSheet.getFilePath() == null) {
			return getLessStyleSheet(new LessSource.StringSource(styleSheet.toString()));
		} else {
			return getLessStyleSheet(new ModifiedLessFileSource(new File(styleSheet.getFilePath())));
		}
		
	}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
public StyleSheet getAdaptedStyleSheet() {
	StyleSheet ourStyleSheet = new StyleSheet();
	LessSource source = lessStyleSheet.getSource();
	if ((source instanceof FileSource || source instanceof URLSource) && source.getURI() != null) {
		ourStyleSheet.setPath(source.getURI().toString());
	} else if (source instanceof ModifiedLessFileSource) {
		ourStyleSheet.setPath(((ModifiedLessFileSource) source).getInputFile().getAbsolutePath());
	}
	adapt(ourStyleSheet);
	return ourStyleSheet;
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
public static StyleSheet compileStyleSheetUsingLess4J(String filePath) throws ParseException {
	/*
	 * This is weird, however, it seems that when we make changes to
	 * the AST of the Less style sheet, it cannot compile because, for instance,
	 * it cannot find Mixin declarations. 
	 * For the moment, the naive approach is to parse it again.
	 */
	Configuration options = new Configuration();
	LessSource source = new FileSource(new File(filePath));
	
	/*
	 * Got from Less4j code
	 */
	ANTLRParser.ParseResult result = null;
	try {
		result = new ANTLRParser().parseStyleSheet(source.getContent(), source);
	} catch (FileNotFound | CannotReadFile ex) {
		throw new ParseException(ex);
	}

	if (result.hasErrors()) {
		CompilationResult compilationResult = new CompilationResult("Errors during parsing phase, partial result is not available.");
		throw new ParseException(new Less4jException(result.getErrors(), compilationResult));
	}

	ProblemsHandler problemsHandler = new ProblemsHandler();
	ASTBuilder astBuilder = new ASTBuilder(problemsHandler);
	LessToCssCompiler compiler = new LessToCssCompiler(problemsHandler, options);
	com.github.sommeri.less4j.core.ast.StyleSheet lessStyleSheet = astBuilder.parseStyleSheet(result.getTree());
	ASTCssNode cssStyleSheet = compiler.compileToCss(lessStyleSheet, source, options);
	
	// Adapt to our style sheet
	LessStyleSheetAdapter adapter = new LessStyleSheetAdapter(cssStyleSheet);
	StyleSheet resultingStyleSheet = adapter.getAdaptedStyleSheet();
	return resultingStyleSheet;
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
public List<Selector> getCallingSelectors() {

		if (callingSelectors == null) {

			List<Selector> selectorsToReturn = new ArrayList<>();

			List<LessMixinCall> mixinCallInfo = queryHandler.getMixinCallInfo();
			List<List<ASTCssNode>> parentsList = getParentRuleSets(mixinCallInfo, new HashSet<>());

			if (parentsList.size() == 0)
				return selectorsToReturn;

			for (List<ASTCssNode> parents : parentsList) {
				LessPrinter printer = new LessPrinter();
				ASTCssNode rootNode = parents.get(parents.size() - 1);

				try {
					String stringOfRootNode = printer.getStringForNode(rootNode);		
					StyleSheet lessStyleSheet = LessCSSParser.getLessStyleSheet(new LessSource.StringSource(stringOfRootNode));
					ca.concordia.cssanalyser.cssmodel.StyleSheet compileLESSStyleSheet = LessHelper.compileLESSStyleSheet(lessStyleSheet);
					if (compileLESSStyleSheet.getAllSelectors().iterator().hasNext()) {
						Selector callingSelector = compileLESSStyleSheet.getAllSelectors().iterator().next();
						callingSelector.removeDeclaration(callingSelector.getDeclarations().iterator().next());
						selectorsToReturn.add(callingSelector);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			callingSelectors = selectorsToReturn;
			
		}

		return callingSelectors;
	}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
@Override
public String getContent() throws LessSource.FileNotFound, LessSource.CannotReadFile {
    return getAndCacheContent();
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
@Override
public byte[] getBytes() throws LessSource.FileNotFound, LessSource.CannotReadFile {
    return getAndCacheContent().getBytes();
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
@Override
public LessSource relativeSource(final String filename) throws StringSourceException {
  return source(spath(filename));
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
/**
 * Compiles a given less style sheet to a {@link StyleSheet} object
 * @param lessStyleSheetToCompile
 * @param forceReadingFromAST Force the method to read from the AST.
 * otherwise, the method will first try to read from the source
 * (using {@link com.github.sommeri.less4j.core.ast.StyleSheet#getSource()}
 * of the style sheet being compiled.
 * @return Pure CSS represented in our model
 * @throws Less4jException
 */
public static StyleSheet compileLESSStyleSheet(com.github.sommeri.less4j.core.ast.StyleSheet lessStyleSheetToCompile, boolean forceReadingFromAST) throws Exception {
	try {

		String filePath = "";
		
		if (!forceReadingFromAST) {
			LessSource source = lessStyleSheetToCompile.getSource();
			if (source instanceof FileSource) {
				FileSource fileSource = (FileSource) source;
				if (fileSource.getURI() != null) {
					filePath = fileSource.getURI().toString();
				} else {
					if (source instanceof ModifiedLessFileSource) {
						ModifiedLessFileSource modifiedLessFileSource = (ModifiedLessFileSource) source;
						filePath = modifiedLessFileSource.getInputFile().getAbsolutePath();
					}
				}
			} else if (source instanceof URLSource) {
				URLSource urlSource = (URLSource) source;
				filePath = urlSource.getURI().toString();
			}
		}
		
		if ("".equals(filePath) || forceReadingFromAST) {
			File tempFile = File.createTempFile("lessToCompile", "less");
			LessPrinter lessPrinter = new LessPrinter();	
			String lessCSSFileAsString = lessPrinter.getString(lessStyleSheetToCompile);
			IOHelper.writeStringToFile(lessCSSFileAsString, tempFile.getAbsolutePath());
			filePath = tempFile.getAbsolutePath();
		}

		StyleSheet resultingStyleSheet = //compileStyleSheetUsingLess4J(filePath);
				compileStyleSheetOnWindowsUsingLessJS(filePath);

		resultingStyleSheet.setPath(filePath + ".css");

		return resultingStyleSheet;
		
	} catch (Exception e) {
		System.err.println(e);
	}

	return null;
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
public static ASTCssNode getLessNodeFromLessString(String nodeString) throws ParseException {
	String fakeSelectorString = ".fake { " + nodeString + "}" ;
	com.github.sommeri.less4j.core.ast.StyleSheet root = LessCSSParser.getLessStyleSheet(new LessSource.StringSource(fakeSelectorString));
	ASTCssNode resultingNode = root.getChilds().get(0).getChilds().get(1).getChilds().get(1); // :)
	return resultingNode;
}
 

import com.github.sommeri.less4j.LessSource; //导入依赖的package包/类
static String replaceImports(File lessFile, boolean onlyImportLessFiles) throws IOException {
	try {
		StyleSheet lessStyleSheet = LessCSSParser.getLessStyleSheet(new ModifiedLessFileSource(lessFile));
		List<Import> allImports = getAllImports(lessStyleSheet);
		String toReturn = IOHelper.readFileToString(lessFile.getAbsolutePath());
		for(Import importNode : allImports) {
			try {

				String url = getURLFromImportStatement(importNode);	

				if (!"".equals(url)) {
					if (!onlyImportLessFiles && url.endsWith(".css"))
						continue;
					if (url.contains("@{")) {
						LOGGER.warn("In {} (line {}) URL expression has to be evaluated because it needs string interpolation",
										lessFile.getAbsolutePath(),
										importNode.getSourceLine());
					} else {
						// Inline!
						File importedFile = new File(url);
						if (!importedFile.isAbsolute()) {
							importedFile = new File(url);
							url = lessFile.getParentFile().getAbsolutePath() + File.separator + url;
						}
						
						if (!importedFile.exists()) {
							if (url.toLowerCase().lastIndexOf(".less") != url.length() - 5) {
								importedFile = new File(url + ".less");
							}
							if (!onlyImportLessFiles && !importedFile.exists()) {
								if (url.toLowerCase().lastIndexOf(".css") != url.length() - 4) {
									importedFile = new File(url + ".css");
								}
							}
						}

						if (importedFile.exists()) {
							String importedFileText = replaceImports(importedFile, onlyImportLessFiles);
							try {
								StyleSheet replacedImportsImportedStyleSheet = LessCSSParser.getLessStyleSheet(new LessSource.StringSource(importedFileText));
								lessStyleSheet.addMemberAfter(replacedImportsImportedStyleSheet, importNode);
							} catch (RuntimeException rte) {
								LOGGER.warn(lessFile.getAbsolutePath());
								rte.printStackTrace();
							}
							lessStyleSheet.removeMember(importNode);
							toReturn = (new LessPrinter()).getString(lessStyleSheet);
						} else {
							LOGGER.warn("In {} (line {}), imported file {} does not exist",
											lessFile.getAbsolutePath(),
											importNode.getSourceLine(),
											url);
						}
					}
				}

			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
		return toReturn;
	} catch (Exception e) {
		e.printStackTrace();
	}
	return "";
}