lib/printer.dart - source_maps - Git at Google

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 /// Contains a code printer that generates code by recording the source maps.
 library source_maps.printer;

 import 'builder.dart';
 import 'span.dart';

 const int _LF = 10;
 const int _CR = 13;

 /// A simple printer that keeps track of offset locations and records source
 /// maps locations.
 class Printer {
   final String filename;
   final StringBuffer _buff = new StringBuffer();
   final SourceMapBuilder _maps = new SourceMapBuilder();
   String get text => _buff.toString();
   String get map => _maps.toJson(filename);

   /// Current source location mapping.
   Location _loc;

   /// Current line in the buffer;
   int _line = 0;

   /// Current column in the buffer.
   int _column = 0;

   Printer(this.filename);

   /// Add [str] contents to the output, tracking new lines to track correct
   /// positions for span locations. When [projectMarks] is true, this method
   /// adds a source map location on each new line, projecting that every new
   /// line in the target file (printed here) corresponds to a new line in the
   /// source file.
   void add(String str, {projectMarks: false}) {
     var chars = str.runes.toList();
     var length = chars.length;
     for (int i = 0; i < length; i++) {
       var c = chars[i];
       if (c == _LF || (c == _CR && (i + 1 == length || chars[i + 1] != _LF))) {
         // Return not followed by line-feed is treated as a new line.
         _line++;
         _column = 0;
         if (projectMarks && _loc != null) {
           if (_loc is FixedLocation) {
             mark(new FixedLocation(0, _loc.sourceUrl, _loc.line + 1, 0));
           } else if (_loc is FileLocation) {
             var file = (_loc as FileLocation).file;
             mark(new FileLocation(file, file.getOffset(_loc.line + 1, 0)));
           }
         }
       } else {
         _column++;
       }
     }
     _buff.write(str);
   }


   /// Append a [total] number of spaces in the target file. Typically used for
   /// formatting indentation.
   void addSpaces(int total) {
     for (int i = 0; i < total; i++) _buff.write(' ');
     _column += total;
   }

   /// Marks that the current point in the target file corresponds to the [mark]
   /// in the source file, which can be either a [Location] or a [Span]. When the
   /// mark is an identifier's Span, this also records the name of the identifier
   /// in the source map information.
   void mark(mark) {
     var loc;
     var identifier = null;
     if (mark is Location) {
       loc = mark;
     } else if (mark is Span) {
       loc = mark.start;
       if (mark.isIdentifier) identifier = mark.text;
     }
     _maps.addLocation(loc,
         new FixedLocation(_buff.length, null, _line, _column), identifier);
     _loc = loc;
   }
 }

 /// A more advanced printer that keeps track of offset locations to record
 /// source maps, but additionally allows nesting of different kind of items,
 /// including [NestedPrinter]s, and it let's you automatically indent text.
 ///
 /// This class is especially useful when doing code generation, where different
 /// peices of the code are generated independently on separate printers, and are
 /// finally put together in the end.
 class NestedPrinter implements NestedItem {

   /// Items recoded by this printer, which can be [String] literals,
   /// [NestedItem]s, and source map information like [Location] and [Span].
   List _items = [];

   /// Internal buffer to merge consecutive strings added to this printer.
   StringBuffer _buff;

   /// Current indentation, which can be updated from outside this class.
   int indent;

   /// Item used to indicate that the following item is copied from the original
   /// source code, and hence we should preserve source-maps on every new line.
   static final _ORIGINAL = new Object();

   NestedPrinter([this.indent = 0]);

   /// Adds [object] to this printer. [object] can be a [String],
   /// [NestedPrinter], or anything implementing [NestedItem]. If [object] is a
   /// [String], the value is appended directly, without doing any formatting
   /// changes. If you wish to add a line of code with automatic indentation, use
   /// [addLine] instead.  [NestedPrinter]s and [NestedItem]s are not processed
   /// until [build] gets called later on. We ensure that [build] emits every
   /// object in the order that they were added to this printer.
   ///
   /// The [location] and [span] parameters indicate the corresponding source map
   /// location of [object] in the original input. Only one, [location] or
   /// [span], should be provided at a time.
   ///
   /// Indicate [isOriginal] when [object] is copied directly from the user code.
   /// Setting [isOriginal] will make this printer propagate source map locations
   /// on every line-break.
   void add(object, {Location location, Span span, bool isOriginal: false}) {
     if (object is! String || location != null || span != null || isOriginal) {
       _flush();
       assert(location == null || span == null);
       if (location != null) _items.add(location);
       if (span != null) _items.add(span);
       if (isOriginal) _items.add(_ORIGINAL);
     }

     if (object is String) {
       _appendString(object);
     } else {
       _items.add(object);
     }
   }

   /// Append `2 * indent` spaces to this printer.
   void insertIndent() => _indent(indent);

   /// Add a [line], autoindenting to the current value of [indent]. Note,
   /// indentation is not inferred from the contents added to this printer. If a
   /// line starts or ends an indentation block, you need to also update [indent]
   /// accordingly. Also, indentation is not adapted for nested printers. If
   /// you add a [NestedPrinter] to this printer, its indentation is set
   /// separately and will not include any the indentation set here.
   ///
   /// The [location] and [span] parameters indicate the corresponding source map
   /// location of [object] in the original input. Only one, [location] or
   /// [span], should be provided at a time.
   void addLine(String line, {Location location, Span span}) {
     if (location != null || span != null) {
       _flush();
       assert(location == null || span == null);
       if (location != null) _items.add(location);
       if (span != null) _items.add(span);
     }
     if (line == null) return;
     if (line != '') {
       // We don't indent empty lines.
       _indent(indent);
       _appendString(line);
     }
     _appendString('\n');
   }

   /// Appends a string merging it with any previous strings, if possible.
   void _appendString(String s) {
     if (_buff == null) _buff = new StringBuffer();
     _buff.write(s);
   }

   /// Adds all of the current [_buff] contents as a string item.
   void _flush() {
     if (_buff != null) {
       _items.add(_buff.toString());
       _buff = null;
     }
   }

   void _indent(int indent) {
     for (int i = 0; i < indent; i++) _appendString('  ');
   }

   /// Returns a string representation of all the contents appended to this
   /// printer, including source map location tokens.
   String toString() {
     _flush();
     return (new StringBuffer()..writeAll(_items)).toString();
   }

   /// [Printer] used during the last call to [build], if any.
   Printer printer;

   /// Returns the text produced after calling [build].
   String get text => printer.text;

   /// Returns the source-map information produced after calling [build].
   String get map => printer.map;

   /// Builds the output of this printer and source map information. After
   /// calling this function, you can use [text] and [map] to retrieve the
   /// geenrated code and source map information, respectively.
   void build(String filename) {
     writeTo(printer = new Printer(filename));
   }

   /// Implements the [NestedItem] interface.
   void writeTo(Printer printer) {
     _flush();
     bool propagate = false;
     for (var item in _items) {
       if (item is NestedItem) {
         item.writeTo(printer);
       } else if (item is String) {
         printer.add(item, projectMarks: propagate);
         propagate = false;
       } else if (item is Location || item is Span) {
         printer.mark(item);
       } else if (item == _ORIGINAL) {
         // we insert booleans when we are about to quote text that was copied
         // from the original source. In such case, we will propagate marks on
         // every new-line.
         propagate = true;
       } else {
         throw new UnsupportedError('Unknown item type: $item');
       }
     }
   }
 }

 /// An item added to a [NestedPrinter].
 abstract class NestedItem {
   /// Write the contents of this item into [printer].
   void writeTo(Printer printer);
 }
	// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	/// Contains a code printer that generates code by recording the source maps.
	library source_maps.printer;

	import 'builder.dart';
	import 'span.dart';

	const int _LF = 10;
	const int _CR = 13;

	/// A simple printer that keeps track of offset locations and records source
	/// maps locations.
	class Printer {
	final String filename;
	final StringBuffer _buff = new StringBuffer();
	final SourceMapBuilder _maps = new SourceMapBuilder();
	String get text => _buff.toString();
	String get map => _maps.toJson(filename);

	/// Current source location mapping.
	Location _loc;

	/// Current line in the buffer;
	int _line = 0;

	/// Current column in the buffer.
	int _column = 0;

	Printer(this.filename);

	/// Add [str] contents to the output, tracking new lines to track correct
	/// positions for span locations. When [projectMarks] is true, this method
	/// adds a source map location on each new line, projecting that every new
	/// line in the target file (printed here) corresponds to a new line in the
	/// source file.
	void add(String str, {projectMarks: false}) {
	var chars = str.runes.toList();
	var length = chars.length;
	for (int i = 0; i < length; i++) {
	var c = chars[i];
	if (c == _LF \|\| (c == _CR && (i + 1 == length \|\| chars[i + 1] != _LF))) {
	// Return not followed by line-feed is treated as a new line.
	_line++;
	_column = 0;
	if (projectMarks && _loc != null) {
	if (_loc is FixedLocation) {
	mark(new FixedLocation(0, _loc.sourceUrl, _loc.line + 1, 0));
	} else if (_loc is FileLocation) {
	var file = (_loc as FileLocation).file;
	mark(new FileLocation(file, file.getOffset(_loc.line + 1, 0)));
	}
	}
	} else {
	_column++;
	}
	}
	_buff.write(str);
	}


	/// Append a [total] number of spaces in the target file. Typically used for
	/// formatting indentation.
	void addSpaces(int total) {
	for (int i = 0; i < total; i++) _buff.write(' ');
	_column += total;
	}

	/// Marks that the current point in the target file corresponds to the [mark]
	/// in the source file, which can be either a [Location] or a [Span]. When the
	/// mark is an identifier's Span, this also records the name of the identifier
	/// in the source map information.
	void mark(mark) {
	var loc;
	var identifier = null;
	if (mark is Location) {
	loc = mark;
	} else if (mark is Span) {
	loc = mark.start;
	if (mark.isIdentifier) identifier = mark.text;
	}
	_maps.addLocation(loc,
	new FixedLocation(_buff.length, null, _line, _column), identifier);
	_loc = loc;
	}
	}

	/// A more advanced printer that keeps track of offset locations to record
	/// source maps, but additionally allows nesting of different kind of items,
	/// including [NestedPrinter]s, and it let's you automatically indent text.
	///
	/// This class is especially useful when doing code generation, where different
	/// peices of the code are generated independently on separate printers, and are
	/// finally put together in the end.
	class NestedPrinter implements NestedItem {

	/// Items recoded by this printer, which can be [String] literals,
	/// [NestedItem]s, and source map information like [Location] and [Span].
	List _items = [];

	/// Internal buffer to merge consecutive strings added to this printer.
	StringBuffer _buff;

	/// Current indentation, which can be updated from outside this class.
	int indent;

	/// Item used to indicate that the following item is copied from the original
	/// source code, and hence we should preserve source-maps on every new line.
	static final _ORIGINAL = new Object();

	NestedPrinter([this.indent = 0]);

	/// Adds [object] to this printer. [object] can be a [String],
	/// [NestedPrinter], or anything implementing [NestedItem]. If [object] is a
	/// [String], the value is appended directly, without doing any formatting
	/// changes. If you wish to add a line of code with automatic indentation, use
	/// [addLine] instead. [NestedPrinter]s and [NestedItem]s are not processed
	/// until [build] gets called later on. We ensure that [build] emits every
	/// object in the order that they were added to this printer.
	///
	/// The [location] and [span] parameters indicate the corresponding source map
	/// location of [object] in the original input. Only one, [location] or
	/// [span], should be provided at a time.
	///
	/// Indicate [isOriginal] when [object] is copied directly from the user code.
	/// Setting [isOriginal] will make this printer propagate source map locations
	/// on every line-break.
	void add(object, {Location location, Span span, bool isOriginal: false}) {
	if (object is! String \|\| location != null \|\| span != null \|\| isOriginal) {
	_flush();
	assert(location == null \|\| span == null);
	if (location != null) _items.add(location);
	if (span != null) _items.add(span);
	if (isOriginal) _items.add(_ORIGINAL);
	}

	if (object is String) {
	_appendString(object);
	} else {
	_items.add(object);
	}
	}

	/// Append `2 * indent` spaces to this printer.
	void insertIndent() => _indent(indent);

	/// Add a [line], autoindenting to the current value of [indent]. Note,
	/// indentation is not inferred from the contents added to this printer. If a
	/// line starts or ends an indentation block, you need to also update [indent]
	/// accordingly. Also, indentation is not adapted for nested printers. If
	/// you add a [NestedPrinter] to this printer, its indentation is set
	/// separately and will not include any the indentation set here.
	///
	/// The [location] and [span] parameters indicate the corresponding source map
	/// location of [object] in the original input. Only one, [location] or
	/// [span], should be provided at a time.
	void addLine(String line, {Location location, Span span}) {
	if (location != null \|\| span != null) {
	_flush();
	assert(location == null \|\| span == null);
	if (location != null) _items.add(location);
	if (span != null) _items.add(span);
	}
	if (line == null) return;
	if (line != '') {
	// We don't indent empty lines.
	_indent(indent);
	_appendString(line);
	}
	_appendString('\n');
	}

	/// Appends a string merging it with any previous strings, if possible.
	void _appendString(String s) {
	if (_buff == null) _buff = new StringBuffer();
	_buff.write(s);
	}

	/// Adds all of the current [_buff] contents as a string item.
	void _flush() {
	if (_buff != null) {
	_items.add(_buff.toString());
	_buff = null;
	}
	}

	void _indent(int indent) {
	for (int i = 0; i < indent; i++) _appendString(' ');
	}

	/// Returns a string representation of all the contents appended to this
	/// printer, including source map location tokens.
	String toString() {
	_flush();
	return (new StringBuffer()..writeAll(_items)).toString();
	}

	/// [Printer] used during the last call to [build], if any.
	Printer printer;

	/// Returns the text produced after calling [build].
	String get text => printer.text;

	/// Returns the source-map information produced after calling [build].
	String get map => printer.map;

	/// Builds the output of this printer and source map information. After
	/// calling this function, you can use [text] and [map] to retrieve the
	/// geenrated code and source map information, respectively.
	void build(String filename) {
	writeTo(printer = new Printer(filename));
	}

	/// Implements the [NestedItem] interface.
	void writeTo(Printer printer) {
	_flush();
	bool propagate = false;
	for (var item in _items) {
	if (item is NestedItem) {
	item.writeTo(printer);
	} else if (item is String) {
	printer.add(item, projectMarks: propagate);
	propagate = false;
	} else if (item is Location \|\| item is Span) {
	printer.mark(item);
	} else if (item == _ORIGINAL) {
	// we insert booleans when we are about to quote text that was copied
	// from the original source. In such case, we will propagate marks on
	// every new-line.
	propagate = true;
	} else {
	throw new UnsupportedError('Unknown item type: $item');
	}
	}
	}
	}

	/// An item added to a [NestedPrinter].
	abstract class NestedItem {
	/// Write the contents of this item into [printer].
	void writeTo(Printer printer);
	}